Merge pull request #2 from riligar/2025-04-20_guardrails

fix: Guardrails

Author: ciro-maciel

examples/guardrail.js

@@ -2,62 +2,33 @@
 const { Agent, Runner, Tool, Guardrail } = require('../src/index');
 
 // Create an input guardrail that checks if the input contains inappropriate content
-const inappropriateContentGuardrail = new Guardrail.InputGuardrail({
+const inappropriateContentGuardrail = new Guardrail.Input({
     name: "inappropriate_content_filter",
     check: async (context, agent, input) => {
+
         // In a real implementation, you might use a content moderation API
         // Here we're just doing a simple check for demonstration
-        const message = typeof input === 'string' ? input :
-            (input[0]?.content || '');
+        const message = typeof input === 'string' ? input : (input[0]?.content || '');
 
         const inappropriateWords = ['hate', 'violence', 'explicit'];
         const containsInappropriate = inappropriateWords.some(word =>
             message.toLowerCase().includes(word)
         );
 
-        return {
-            output_info: {
-                checked_for: "inappropriate content",
-                found: containsInappropriate ? "yes" : "no"
-            },
-            tripwire_triggered: containsInappropriate
-        };
+        return containsInappropriate;
     }
 });
 
 // Create an output guardrail that ensures the response isn't too short
-const minimumLengthGuardrail = new Guardrail.OutputGuardrail({
+const minimumLengthGuardrail = new Guardrail.Output({
     name: "minimum_length_check",
     check: async (context, agent, output) => {
         const minimumLength = 20; // characters
 
-        // Safely handle null/undefined output
-        if (!output) {
-            return {
-                output_info: {
-                    checked_for: "minimum length",
-                    required_length: minimumLength,
-                    actual_length: 0,
-                    is_too_short: true,
-                    error: "Output is null or undefined"
-                },
-                tripwire_triggered: true
-            };
-        }
-
-        // Convert output to string if it isn't already
         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;
     }
 });
 
@@ -86,45 +57,32 @@ async function main() {
         name: "Guarded Assistant",
         instructions: "You are a helpful assistant that provides detailed and thoughtful responses.",
         tools: [getWeather],
-        inputGuardrails: [inappropriateContentGuardrail],
-        outputGuardrails: [minimumLengthGuardrail]
+        guardrails: { input: [inappropriateContentGuardrail], output: [minimumLengthGuardrail] }
     });
 
-    try {
-        // Example 1: Normal input (should work fine)
-        console.log("Example 1: Normal input");
-        const result1 = await Runner.run(agent, "Tell me about the weather in Paris");
-        console.log("Final output:", result1.finalOutput);
-        console.log("Input guardrail results:", JSON.stringify(result1.inputGuardrailResults, null, 2));
-        console.log("Output guardrail results:", JSON.stringify(result1.outputGuardrailResults, null, 2));
+    const tooShortAgent = new Agent({
+        name: "Brief Assistant",
+        instructions: "You are an assistant that gives very brief, one-word answers whenever possible.",
+        guardrails: { output: [minimumLengthGuardrail] }
+    });
 
-        // Example 2: Input that should trigger the input guardrail
-        console.log("\nExample 2: Inappropriate input");
-        try {
-            const result2 = await Runner.run(agent, "I hate the weather in London");
-            console.log("Final output:", result2.finalOutput);
-        } catch (error) {
-            console.log("Error (expected):", error.message);
-        }
 
-        // Example 3: Create an agent that might generate short outputs
-        const tooShortAgent = new Agent({
-            name: "Brief Assistant",
-            instructions: "You are an assistant that gives very brief, one-word answers whenever possible.",
-            outputGuardrails: [minimumLengthGuardrail]
-        });
+    // Example 1: Normal input (should work fine)
+    console.log("Example 1: Normal input");
+    const result1 = await Runner.run(agent, "Tell me about the weather in Paris");
+    console.log("Final output:", result1.finalOutput);
+    console.log("Guardrails results:", JSON.stringify(result1.guardrails, null, 2));
 
-        console.log("\nExample 3: Testing output guardrail");
-        try {
-            const result3 = await Runner.run(tooShortAgent, "What color is the sky?");
-            console.log("Final output:", result3.finalOutput);
-        } catch (error) {
-            console.log("Error (expected):", error.message);
-        }
+    // Example 2: Input that should trigger the input guardrail
+    console.log("\nExample 2: Inappropriate input");
+    const result2 = await Runner.run(agent, "I hate the weather in London");
+    console.log("Final output:", result2.finalOutput);
+    console.log("Guardrails results:", JSON.stringify(result2.guardrails, null, 2));
 
-    } catch (error) {
-        console.error("Unexpected error:", error);
-    }
+    // Example 3: Create an agent that might generate short outputs
+    const result3 = await Runner.run(tooShortAgent, "What color is the sky?");
+    console.log("Final output:", result3.finalOutput);
+    console.log("Guardrails results:", JSON.stringify(result3.guardrails, null, 2));
 }
 
 main().catch(console.error);

src/agent.js

@@ -16,8 +16,7 @@ class Agent {
      * @param {Object} [config.providerConfig={}] - Provider-specific configuration
      * @param {string} [config.model='gpt-4'] - The model to use
      * @param {Object} [config.modelSettings={}] - Settings for the model (temperature, etc.)
-     * @param {Array} [config.inputGuardrails=[]] - Guardrails for input validation
-     * @param {Array} [config.outputGuardrails=[]] - Guardrails for output validation
+     * @param {Array} [config.guardrails=[]] - Guardrails para validação de input e output
      * @param {Object} [config.outputType=null] - Type definition for structured output
      * @param {Array} [config.mcpServers=[]] - URLs dos servidores MCP
      */
@@ -30,8 +29,7 @@ class Agent {
         providerConfig = {},
         model = 'gpt-4.1-nano',
         modelSettings = {},
-        inputGuardrails = [],
-        outputGuardrails = [],
+        guardrails = { input: [], output: [] },
         outputType = null,
         handoffDescription = null
     }) {
@@ -46,15 +44,15 @@ class Agent {
             top_p: 1,
             ...modelSettings
         };
-        this.inputGuardrails = inputGuardrails;
-        this.outputGuardrails = outputGuardrails;
+        this.guardrails = guardrails;
         this.outputType = outputType;
         this.handoffDescription = handoffDescription;
 
         // Inicializa MCPManager se houver MCPs
         this.mcpServers = Array.isArray(arguments[0]?.mcpServers) ? arguments[0].mcpServers : [];
         this.mcpManager = this.mcpServers.length > 0 ? new MCPManager(this.mcpServers) : null;
 
+
         // Initialize the provider
         this.llmProvider = this.initializeProvider(provider, {
             ...providerConfig,
@@ -109,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);
@@ -131,8 +129,7 @@ class Agent {
             handoffs: this.handoffs,
             model: this.model,
             modelSettings: this.modelSettings,
-            inputGuardrails: this.inputGuardrails,
-            outputGuardrails: this.outputGuardrails,
+            guardrails: this.guardrails,
             outputType: this.outputType,
             handoffDescription: this.handoffDescription,
             ...newProps

src/guardrail.js

@@ -5,18 +5,14 @@
  * @param {Function} options.check - Function that checks the input
  * @returns {Object} - An input guardrail object
  */
-class InputGuardrail {
+class Input {
     constructor({ name, check }) {
         this.name = name;
         this.check = check;
     }
 
     async run(agent, input, context) {
-        const output = await this.check(context, agent, input);
-        return {
-            guardrail: { name: this.name },
-            output
-        };
+        return await this.check(context, agent, input);
     }
 }
 
@@ -27,21 +23,15 @@ class InputGuardrail {
  * @param {Function} options.check - Function that checks the output
  * @returns {Object} - An output guardrail object
  */
-class OutputGuardrail {
+class Output {
     constructor({ name, check }) {
         this.name = name;
         this.check = check;
     }
 
     async run(agent, output, context) {
-        const result = await this.check(context, agent, output);
-        return {
-            guardrail: { name: this.name },
-            agentOutput: output,
-            agent,
-            output: result
-        };
+        return await this.check(context, agent, output);
     }
 }
 
-module.exports = { InputGuardrail, OutputGuardrail };
+module.exports = { Input, Output };

src/result.js

@@ -17,17 +17,16 @@ class RunResult {
         messages,
         finalOutput,
         lastAgent,
-        inputGuardrailResults = [],
-        outputGuardrailResults = []
+        guardrails = {
+            input: [],
+            output: []
+        }
     }) {
         this.input = input;
         this.messages = messages;
         this.finalOutput = finalOutput;
         this.lastAgent = lastAgent;
-        this.guardrails = {
-            input: inputGuardrailResults,
-            output: outputGuardrailResults
-        };
+        this.guardrails = guardrails;
     }
 }