Simplify guardrail implementation and improve error handling in runner

Author: ciro-maciel

examples/guardrail.js

@@ -15,13 +15,7 @@ const inappropriateContentGuardrail = new Guardrail.Input({
             message.toLowerCase().includes(word)
         );
 
-        return {
-            output_info: {
-                checked_for: "inappropriate content",
-                found: containsInappropriate ? "yes" : "no"
-            },
-            tripwire_triggered: containsInappropriate
-        };
+        return containsInappropriate;
     }
 });
 
@@ -49,15 +43,7 @@ const minimumLengthGuardrail = new Guardrail.Output({
         const outputStr = String(output);
         const isTooShort = outputStr.length < minimumLength;
 
-        return {
-            output_info: {
-                checked_for: "minimum length",
-                required_length: minimumLength,
-                actual_length: outputStr.length,
-                is_too_short: isTooShort
-            },
-            tripwire_triggered: isTooShort
-        };
+        return isTooShort;
     }
 });
 

src/agent.js

@@ -107,7 +107,7 @@ class Agent {
      * @returns {LLMProvider} - Initialized provider instance
      */
     initializeProvider(provider, config) {
-        console.log('Initializing provider:', provider, config);
+        // console.log('Initializing provider:', provider, config);
         switch (provider.toLowerCase()) {
             case 'openai':
                 return new OpenAIProvider(config);

src/guardrail.js

@@ -11,16 +11,8 @@ class Input {
         this.check = check;
     }
 
-    async validate(agent, input, context) {
-        const result = await this.check(context, agent, input);
-        return {
-            guardrail: { name: this.name },
-            output: result
-        };
-    }
-
     async run(agent, input, context) {
-        return this.validate(agent, input, context);
+        return await this.check(context, agent, input);
     }
 }
 
@@ -37,16 +29,8 @@ class Output {
         this.check = check;
     }
 
-    async validate(agent, output, context) {
-        const result = await this.check(context, agent, output);
-        return {
-            guardrail: { name: this.name },
-            output: result
-        };
-    }
-
     async run(agent, output, context) {
-        return this.validate(agent, output, context);
+        return await this.check(context, agent, output);
     }
 }
 

src/runner.js

@@ -37,6 +37,8 @@ class Runner {
         let currentAgent = startingAgent;
         let messages = [];
         let finalOutput = null;
+        const inputGuardrailResults = [];
+        const outputGuardrailResults = [];
 
         // Validate provider configuration
         currentAgent.llmProvider.validateConfig();
@@ -48,19 +50,11 @@ class Runner {
             messages = [...input];
         }
 
-        // Run input guardrails inline
-        const inputGuardrailResults = [];
+        // Run input guardrails
         for (const guardrail of currentAgent?.guardrails?.input || []) {
-            console.log(`Running input guardrail: ${guardrail.name}`);
-            try {
-                const result = await guardrail.validate(currentAgent, messages, context);
-                inputGuardrailResults.push(result);
-                if (result.output && result.output.tripwireTriggered) {
-                    throw new Error(`Input guardrail ${guardrail.name} triggered: ${JSON.stringify(result.output)}`);
-                }
-            } catch (error) {
-                console.error(`Error running input guardrail: ${error.message}`);
-                throw error;
+            const result = await guardrail.run(currentAgent, messages, context);
+            if (result) {
+                inputGuardrailResults.push(guardrail.name);
             }
         }
 
@@ -112,6 +106,9 @@ class Runner {
 
             // Check for tool calls
             if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
+
+                // console.log("Tool calls detected:", assistantMessage.tool_calls);
+
                 for (const toolCall of assistantMessage.tool_calls) {
                     const { name, arguments: args } = toolCall.function;
 
@@ -178,22 +175,6 @@ class Runner {
                 // No tool calls, this is a final output
                 finalOutput = assistantMessage.content;
 
-                // Run output guardrails inline
-                const outputGuardrailResults = [];
-                for (const guardrail of currentAgent?.guardrails?.output || []) {
-                    console.log(`Running output guardrail: ${guardrail.name}`);
-                    try {
-                        const result = await guardrail.validate(currentAgent, finalOutput, context);
-                        outputGuardrailResults.push(result);
-                        if (result.output && result.output.tripwireTriggered) {
-                            throw new Error(`Output guardrail ${guardrail.name} triggered: ${JSON.stringify(result.output)}`);
-                        }
-                    } catch (error) {
-                        console.error(`Error running output guardrail: ${error.message}`);
-                        throw error;
-                    }
-                }
-
                 // If we have a final output, we're done
                 break;
             }
@@ -204,23 +185,14 @@ class Runner {
             throw new Error(`Max turns (${maxTurns}) exceeded`);
         }
 
-        // Run output guardrails inline (final)
-        const outputGuardrailResults = [];
+        // Run output guardrails
         for (const guardrail of currentAgent?.guardrails?.output || []) {
-            console.log(`Running output guardrail: ${guardrail.name}`);
-            try {
-                const result = await guardrail.validate(currentAgent, finalOutput, context);
-                outputGuardrailResults.push(result);
-                if (result.output && result.output.tripwireTriggered) {
-                    throw new Error(`Output guardrail ${guardrail.name} triggered: ${JSON.stringify(result.output)}`);
-                }
-            } catch (error) {
-                console.error(`Error running output guardrail: ${error.message}`);
-                throw error;
+            const result = await guardrail.run(currentAgent, finalOutput, context);
+            if (result) {
+                outputGuardrailResults.push(guardrail.name);
             }
         }
 
-
         const result = new RunResult({
             input,
             messages,