@atomoz/workflows-nodes 0.1.22 → 0.1.24

package/dist/index.cjs

@@ -993,39 +993,50 @@ var IaAgentNode = {
       typeable: false,
       handle: {
         type: "output",
-        label: "response",
+        label: "Response",
         name: "response",
         fieldType: "string"
       }
     },
     {
-      id: "beforeGuardrails",
-      label: "Before Guardrails",
-      type: "guardrail",
+      id: "blocked",
+      label: "Is Blocked",
+      type: "boolean",
       required: false,
       typeable: false,
       handle: {
-        type: "input",
-        label: "Before Guardrails",
-        name: "beforeGuardrails",
-        fieldType: "guardrail",
-        acceptTypes: ["guardrail"],
-        maxConnections: 10
+        type: "output",
+        label: "Blocked",
+        name: "blocked",
+        fieldType: "boolean"
+      }
+    },
+    {
+      id: "violations",
+      label: "Violations",
+      type: "json",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Violations",
+        name: "violations",
+        fieldType: "json"
       }
     },
     {
-      id: "afterGuardrails",
-      label: "After Guardrails",
+      id: "guardrails",
+      label: "Guardrails (Todas as Fases)",
       type: "guardrail",
       required: false,
       typeable: false,
       handle: {
         type: "input",
-        label: "After Guardrails",
-        name: "afterGuardrails",
+        label: "Guardrails",
+        name: "guardrails",
         fieldType: "guardrail",
         acceptTypes: ["guardrail"],
-        maxConnections: 10
+        maxConnections: 20
       }
     },
     {
@@ -1077,7 +1088,7 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
     case "gemini":
       return new import_google_gauth.ChatGoogle({
         model: "gemini-flash-latest",
-        apiKey: "AIzaSyD9WiFuXp2fhVAokIMPp9YPKMlh7_Bvddc",
+        apiKey: "AIzaSyBzrL8Hx6dHhXgwc2HfLlQsf5Y-9pdtc9M",
         streaming
       });
     case "openai":
@@ -1103,7 +1114,7 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
 }
 
 // src/utils/guardrail-executor.ts
-async function executeGuardrails(guardrails, content, mode = "fail-first") {
+async function executeGuardrails(guardrails, content, mode = "fail-first", context = {}) {
   const list = Array.isArray(guardrails) ? guardrails : [guardrails];
   const result = {
     passed: true,
@@ -1116,7 +1127,7 @@ async function executeGuardrails(guardrails, content, mode = "fail-first") {
     let guardPassed = true;
     let violationMessage = "";
     if (guard.type === "rule") {
-      const { ruleType, config, action } = guard;
+      const { ruleType, config, action, actionInstruction } = guard;
       if (ruleType === "keywords" && config) {
         const keywords = config.split(",").map((k) => k.trim().toLowerCase());
         const lowerContent = content.toLowerCase();
@@ -1150,18 +1161,33 @@ async function executeGuardrails(guardrails, content, mode = "fail-first") {
           violationMessage = `Valor ${val} \xE9 menor que o m\xEDnimo permitido de ${min}.`;
         }
       }
+      if (!guardPassed && actionInstruction) {
+        violationMessage = actionInstruction;
+      }
     } else if (guard.type === "function") {
-      const { nodeFunction, name } = guard;
+      const { nodeFunction, name, actionInstruction } = guard;
       if (typeof nodeFunction === "function") {
         try {
+          const executionContext = {
+            input: content,
+            ...context
+          };
           const result2 = await nodeFunction({
             input: content,
-            fieldValues: { input: content },
-            originalNodeData: guard.originalNodeData
+            fieldValues: { input: content, ...executionContext },
+            // Envia contexto como fieldValues
+            originalNodeData: guard.originalNodeData,
+            $req: context?.$req,
+            // Pass request context explicitly
+            $vars: context?.$vars
+            // Pass variables explicitly
           });
           if (result2 === false || typeof result2 === "object" && result2?.passed === false) {
             guardPassed = false;
             violationMessage = typeof result2?.message === "string" ? result2.message : `Fun\xE7\xE3o guardrail "${name}" reprovou o conte\xFAdo.`;
+            if (actionInstruction) {
+              violationMessage = actionInstruction;
+            }
           } else if (typeof result2 === "object" && result2?.modifiedContent) {
             result2.modifiedContent = result2.modifiedContent;
           }
@@ -1172,15 +1198,41 @@ async function executeGuardrails(guardrails, content, mode = "fail-first") {
         }
       }
     } else if (guard.type === "model") {
-      const { model, evaluationPrompt, name } = guard;
+      const { model, evaluationPrompt, name, actionInstruction } = guard;
       if (model && typeof model.invoke === "function") {
         try {
-          const prompt = evaluationPrompt.replace("{{content}}", content);
+          let prompt = evaluationPrompt;
+          if (actionInstruction) {
+            prompt += `
+
+INSTRU\xC7\xC3O ADICIONAL DE A\xC7\xC3O:
+${actionInstruction}`;
+          }
+          if (prompt.includes("{{content}}")) {
+            prompt = prompt.replace("{{content}}", content);
+          } else {
+            prompt = `${prompt}
+
+CONTE\xDADO PARA AVALIAR:
+${content}`;
+          }
           const response = await model.invoke(prompt);
           const resultText = typeof response.content === "string" ? response.content : String(response.content);
-          if (resultText.toUpperCase().includes("UNSAFE")) {
-            guardPassed = false;
-            violationMessage = `Modelo de avalia\xE7\xE3o "${name}" detectou viola\xE7\xE3o de seguran\xE7a/pol\xEDtica.`;
+          if (guard.action === "fix") {
+            if (resultText && resultText.trim() !== content.trim() && !resultText.includes("SAFE")) {
+              result.modifiedContent = resultText;
+              violationMessage = `Conte\xFAdo reescrito pelo guardrail "${name}".`;
+              result.violations.push({
+                name: guard.name,
+                message: violationMessage,
+                action: "fix"
+              });
+            }
+          } else {
+            if (resultText.toUpperCase().includes("UNSAFE")) {
+              guardPassed = false;
+              violationMessage = actionInstruction || `Modelo de avalia\xE7\xE3o "${name}" detectou viola\xE7\xE3o de seguran\xE7a/pol\xEDtica.`;
+            }
           }
         } catch (error) {
           console.error(`Error executing model guardrail "${name}":`, error);
@@ -1196,7 +1248,7 @@ async function executeGuardrails(guardrails, content, mode = "fail-first") {
       });
       if (guard.action === "block") {
         result.blocked = true;
-        result.message = violationMessage;
+        result.message = `GUARDRAILS ATIVADO: ${violationMessage}`;
         if (mode === "fail-first") break;
       }
     }
@@ -1220,7 +1272,10 @@ GUARDRAIL [${guard.name}]: ${guard.prompt}`;
 var IaAgentNodeFunction = async (inputs) => {
   const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = inputs;
   const fieldValues = inputs.fieldValues || {};
-  const { model, tools, systemMessage, name, message, beforeGuardrails, afterGuardrails, guardrailMode } = fieldValues;
+  const { model, tools, systemMessage, name, message, guardrails, guardrailMode } = fieldValues;
+  const guardrailsList = Array.isArray(guardrails) ? guardrails : guardrails ? [guardrails] : [];
+  const beforeGuardrails = guardrailsList.filter((g) => g?.phase === "before");
+  const afterGuardrails = guardrailsList.filter((g) => !g?.phase || g?.phase === "after");
   const authToken = inputs.authToken;
   const stream = Boolean(inputs?.stream);
   const emitter = inputs?.emitter;
@@ -1231,8 +1286,8 @@ var IaAgentNodeFunction = async (inputs) => {
     throw new Error("Agent 'name' is required. Please provide a unique name for the agent in the node properties.");
   }
   const prepareGuardrails = async (list) => {
-    const guardrailsList = Array.isArray(list) ? list : [list];
-    return await Promise.all(guardrailsList.map(async (g) => {
+    const guardrailsList2 = Array.isArray(list) ? list : [list];
+    return await Promise.all(guardrailsList2.map(async (g) => {
       if (g?.type === "model" && g.model && !g.model.invoke) {
         if (!authToken) throw new Error("Auth token required for model guardrail");
         const modelInstance = await createLLMFromModel(g.model, authToken, false);
@@ -1241,9 +1296,12 @@ var IaAgentNodeFunction = async (inputs) => {
       return g;
     }));
   };
+  let isBlocked = false;
+  let guardrailViolations = [];
   if (message && beforeGuardrails) {
     const preparedBefore = await prepareGuardrails(beforeGuardrails);
-    const beforeResults = await executeGuardrails(preparedBefore, message, guardrailMode);
+    const context = { ...inputs, input: message };
+    const beforeResults = await executeGuardrails(preparedBefore, message, guardrailMode, context);
     if (beforeResults.blocked) {
       console.log(`\u{1F6E1}\uFE0F IaAgentNode "${name}": Blocked by before-agent guardrail:`, beforeResults.message);
       if (stream && emitter?.emitDelta) {
@@ -1256,9 +1314,9 @@ var IaAgentNodeFunction = async (inputs) => {
       }
       return {
         agent: null,
-        output: beforeResults.message || "Requisi\xE7\xE3o bloqueada por pol\xEDtica de seguran\xE7a.",
+        output: beforeResults.message || "GUARDRAILS ATIVADO: Requisi\xE7\xE3o bloqueada por pol\xEDtica de seguran\xE7a.",
         blocked: true,
-        violations: beforeResults.violations
+        violations: beforeResults.violations || []
       };
     }
   }
@@ -1278,17 +1336,65 @@ IMPORTANT: You must base your response on the last message in the conversation h
     finalSystemMessageContent = applyPromptGuardrails(finalSystemMessageContent, afterGuardrails);
   }
   const finalSystemMessage = new import_messages.SystemMessage(finalSystemMessageContent);
+  const defaultModel = {
+    model: "gemini-flash-latest",
+    integrationId: "default-gemini"
+  };
+  const finalModel = model?.integrationId || typeof model?.bindTools === "function" ? model : defaultModel;
+  console.log(`\u{1F916} IaAgentNode "${name}": Using model:`, finalModel === defaultModel ? "DEFAULT (Gemini)" : finalModel?.model || "instance");
+  const tokenUsage = { input: 0, output: 0, total: 0 };
+  const callbacks = [
+    {
+      handleLLMEnd: (output2) => {
+        let usage = output2.llmOutput?.tokenUsage || output2.llmOutput?.estimatedTokenUsage;
+        if (!usage && output2.generations && Array.isArray(output2.generations) && output2.generations.length > 0) {
+          const firstGen = output2.generations[0][0];
+          if (firstGen?.generationInfo?.tokenUsage) {
+            usage = firstGen.generationInfo.tokenUsage;
+          }
+        }
+        if (usage) {
+          tokenUsage.input += usage.promptTokens || usage.input_tokens || 0;
+          tokenUsage.output += usage.completionTokens || usage.output_tokens || 0;
+          tokenUsage.total += usage.totalTokens || usage.total_tokens || 0;
+        }
+      }
+    }
+  ];
+  if (stream && emitter) {
+    callbacks.push({
+      handleLLMNewToken: (token) => {
+        if (emitter?.emitDelta) {
+          emitter.emitDelta({
+            content: token,
+            actor: name,
+            isAgent: true,
+            isTool: false
+          });
+        }
+      }
+    });
+  }
   let llmInstance;
-  if (model?.integrationId) {
+  if (finalModel?.integrationId) {
     if (!authToken) {
       throw new Error("Auth token is required to instantiate LLM from integration");
     }
-    llmInstance = await createLLMFromModel(model, authToken, stream);
-  } else if (typeof model?.bindTools === "function") {
-    llmInstance = model;
+    llmInstance = await createLLMFromModel(finalModel, authToken, stream);
+  } else if (typeof finalModel?.bindTools === "function") {
+    llmInstance = finalModel;
   } else {
     throw new Error("Invalid model: must have integrationId or be a valid LLM instance with bindTools method");
   }
+  if (callbacks.length > 0) {
+    if (llmInstance.callbacks) {
+      if (Array.isArray(llmInstance.callbacks)) {
+        llmInstance.callbacks.push(...callbacks);
+      }
+    } else {
+      llmInstance.callbacks = callbacks;
+    }
+  }
   const agent = (0, import_prebuilt.createReactAgent)({
     llm: llmInstance,
     tools: toolsArray,
@@ -1305,14 +1411,17 @@ IMPORTANT: You must base your response on the last message in the conversation h
   let output = "";
   if (message) {
     try {
-      const invokeConfig = checkpointer ? { configurable: { thread_id: sessionId } } : {};
+      const invokeConfig = {
+        ...checkpointer ? { configurable: { thread_id: sessionId } } : {},
+        callbacks
+        // Also pass here as backup
+      };
       if (stream && emitter) {
         const streamIterator = await agent.stream(
           { messages: [new import_messages.HumanMessage(message)] },
           invokeConfig
         );
         let lastMessages = [];
-        const sentContents = /* @__PURE__ */ new Set();
         for await (const step of streamIterator) {
           if (step && typeof step === "object") {
             for (const [key, value] of Object.entries(step)) {
@@ -1320,21 +1429,6 @@ IMPORTANT: You must base your response on the last message in the conversation h
                 const messages = value.messages;
                 if (Array.isArray(messages)) {
                   lastMessages = messages;
-                  for (const msg of messages) {
-                    const content = msg?.content;
-                    const contentStr = typeof content === "string" ? content : Array.isArray(content) ? content.map((p) => p.type === "text" ? p.text : "").filter(Boolean).join("") : "";
-                    if (contentStr && !sentContents.has(contentStr)) {
-                      sentContents.add(contentStr);
-                      if (emitter?.emitDelta) {
-                        emitter.emitDelta({
-                          content: contentStr,
-                          actor: name,
-                          isAgent: true,
-                          isTool: false
-                        });
-                      }
-                    }
-                  }
                 }
               }
             }
@@ -1343,6 +1437,22 @@ IMPORTANT: You must base your response on the last message in the conversation h
         if (lastMessages.length > 0) {
           const lastMessage = lastMessages[lastMessages.length - 1];
           const content = lastMessage?.content;
+          const msg = lastMessage;
+          const usageMetadata = msg?.response_metadata?.tokenUsage || msg?.response_metadata?.usage || msg?.usage_metadata;
+          if (usageMetadata) {
+            const input = usageMetadata.promptTokens || usageMetadata.input_tokens || 0;
+            const output2 = usageMetadata.completionTokens || usageMetadata.output_tokens || 0;
+            const total = usageMetadata.totalTokens || usageMetadata.total_tokens || 0;
+            if (tokenUsage.total === 0) {
+              if (input + output2 > 0) {
+                tokenUsage.input = input;
+                tokenUsage.output = output2;
+                tokenUsage.total = input + output2;
+              } else if (total > 0) {
+                tokenUsage.total = total;
+              }
+            }
+          }
           if (typeof content === "string") {
             output = content;
           } else if (Array.isArray(content)) {
@@ -1361,6 +1471,22 @@ IMPORTANT: You must base your response on the last message in the conversation h
         if (result?.messages && result.messages.length > 0) {
           const lastMessage = result.messages[result.messages.length - 1];
           const content = lastMessage?.content;
+          const msg = lastMessage;
+          const usageMetadata = msg?.response_metadata?.tokenUsage || msg?.response_metadata?.usage || msg?.usage_metadata;
+          if (usageMetadata) {
+            const input = usageMetadata.promptTokens || usageMetadata.input_tokens || 0;
+            const output2 = usageMetadata.completionTokens || usageMetadata.output_tokens || 0;
+            const total = usageMetadata.totalTokens || usageMetadata.total_tokens || 0;
+            if (tokenUsage.total === 0) {
+              if (input + output2 > 0) {
+                tokenUsage.input = input;
+                tokenUsage.output = output2;
+                tokenUsage.total = input + output2;
+              } else if (total > 0) {
+                tokenUsage.total = total;
+              }
+            }
+          }
           if (typeof content === "string") {
             output = content;
           } else if (Array.isArray(content)) {
@@ -1376,22 +1502,42 @@ IMPORTANT: You must base your response on the last message in the conversation h
       }
       if (output && afterGuardrails) {
         const preparedAfter = await prepareGuardrails(afterGuardrails);
-        const afterResults = await executeGuardrails(preparedAfter, output, guardrailMode);
+        const context = { ...inputs, input: output };
+        const afterResults = await executeGuardrails(preparedAfter, output, guardrailMode, context);
         if (afterResults.blocked) {
           console.log(`\u{1F6E1}\uFE0F IaAgentNode "${name}": Response blocked by after-agent guardrail:`, afterResults.message);
+          isBlocked = true;
+          guardrailViolations = afterResults.violations || [];
           if (stream && emitter?.emitDelta) {
             emitter.emitDelta({
               content: `
 
-\u26A0\uFE0F RESPOSTA BLOQUEADA: ${afterResults.message}`,
+${afterResults.message}`,
               actor: name,
               isAgent: true,
               isError: true
             });
           }
-          output = afterResults.message || "Resposta bloqueada por pol\xEDtica de seguran\xE7a.";
-        } else if (afterResults.modifiedContent) {
-          output = afterResults.modifiedContent;
+          output = afterResults.message || "GUARDRAILS ATIVADO: Resposta bloqueada por pol\xEDtica de seguran\xE7a.";
+        } else {
+          if (afterResults.modifiedContent) {
+            output = afterResults.modifiedContent;
+          }
+          const warnings = afterResults.violations.filter((v) => v.action === "warn");
+          if (warnings.length > 0) {
+            const warningText = warnings.map((w) => `
+
+\u26A0\uFE0F GUARDRAILS ATIVADO: ${w.message}`).join("");
+            output += warningText;
+            if (stream && emitter?.emitDelta) {
+              emitter.emitDelta({
+                content: warningText,
+                actor: name,
+                isAgent: true,
+                isError: false
+              });
+            }
+          }
         }
       }
     } catch (error) {
@@ -1399,9 +1545,19 @@ IMPORTANT: You must base your response on the last message in the conversation h
       output = `Error: ${error instanceof Error ? error.message : "Unknown error"}`;
     }
   }
+  if (tokenUsage.total === 0 && (tokenUsage.input > 0 || tokenUsage.output > 0)) {
+    tokenUsage.total = tokenUsage.input + tokenUsage.output;
+  } else if (tokenUsage.total !== tokenUsage.input + tokenUsage.output) {
+    tokenUsage.total = tokenUsage.input + tokenUsage.output;
+  }
+  console.log(`[TOKEN COUNT] Input: ${tokenUsage.input}, Output: ${tokenUsage.output}, Total: ${tokenUsage.total}`);
   return {
     agent,
-    output: output || ""
+    response: output || "",
+    output: output || "",
+    // Keep both for safety
+    blocked: isBlocked,
+    violations: guardrailViolations
   };
 };
 
@@ -1821,7 +1977,7 @@ var import_langgraph_checkpoint_postgres = require("@langchain/langgraph-checkpo
 var PostgresMemoryNodeFunction = async (inputs) => {
   const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = inputs;
   const fieldValues = inputs.fieldValues || {};
-  const connectionString = fieldValues.connectionString || inputs.connectionString || "postgresql://postgres:postgres@localhost:5432/workflows";
+  const connectionString = fieldValues.connectionString || inputs.connectionString || "postgresql://yugabyte:yugabyte@localhost:5433/workflows";
   try {
     const checkpointer = import_langgraph_checkpoint_postgres.PostgresSaver.fromConnString(connectionString);
     await checkpointer.setup();
@@ -2399,12 +2555,14 @@ var PromptGuardrailNode = {
 
 // src/nodes/guardrails/prompt/function.ts
 var PromptGuardrailNodeFunction = async (inputs) => {
-  const { fieldValues = {} } = inputs;
-  const { name, prompt } = fieldValues;
+  const values = inputs.fieldValues || inputs;
+  const { name, prompt } = values;
   return {
-    type: "prompt",
-    name: name || "Prompt Guardrail",
-    prompt: prompt || ""
+    guardrail: {
+      type: "prompt",
+      name: name || "Prompt Guardrail",
+      prompt: prompt || ""
+    }
   };
 };
 
@@ -2415,7 +2573,8 @@ var RuleGuardrailNodeSchema = import_zod14.z.object({
   phase: import_zod14.z.enum(["before", "after"]).describe("Fase de execu\xE7\xE3o"),
   ruleType: import_zod14.z.enum(["maxValue", "minValue", "regex", "keywords", "pii"]).describe("Tipo de regra"),
   config: import_zod14.z.any().describe("Configura\xE7\xE3o da regra"),
-  action: import_zod14.z.enum(["block", "warn", "modify"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o")
+  action: import_zod14.z.enum(["block", "warn", "modify"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o"),
+  actionInstruction: import_zod14.z.string().optional().describe("Instru\xE7\xE3o adicional para a a\xE7\xE3o")
 });
 var RuleGuardrailNode = {
   label: "Rule Guardrail",
@@ -2479,6 +2638,13 @@ var RuleGuardrailNode = {
         { label: "Modificar/Ocultar", value: "modify" }
       ]
     },
+    {
+      id: "actionInstruction",
+      label: "Instru\xE7\xE3o da A\xE7\xE3o",
+      type: "textarea",
+      required: false,
+      placeholder: "Ex: Bloquear: 'N\xE3o posso falar sobre isso'. Warn: 'Aten\xE7\xE3o...'"
+    },
     {
       id: "guardrail",
       label: "Guardrail",
@@ -2497,15 +2663,21 @@ var RuleGuardrailNode = {
 
 // src/nodes/guardrails/rule/function.ts
 var RuleGuardrailNodeFunction = async (inputs) => {
-  const { fieldValues = {} } = inputs;
-  const { name, phase, ruleType, config, action } = fieldValues;
+  const values = inputs.fieldValues || inputs;
+  const {
+    name,
+    ruleType,
+    config,
+    action
+  } = values;
   return {
-    type: "rule",
-    name: name || "Rule Guardrail",
-    phase: phase || "after",
-    ruleType: ruleType || "keywords",
-    config: config || "",
-    action: action || "block"
+    guardrail: {
+      type: "rule",
+      name: name || "Rule Guardrail",
+      ruleType: ruleType || "keywords",
+      config: config || "",
+      action: action || "block"
+    }
   };
 };
 
@@ -2515,7 +2687,8 @@ var FunctionGuardrailNodeSchema = import_zod15.z.object({
   name: import_zod15.z.string().describe("Nome do guardrail"),
   phase: import_zod15.z.enum(["before", "after"]).describe("Fase de execu\xE7\xE3o"),
   description: import_zod15.z.string().optional().describe("Descri\xE7\xE3o do que a fun\xE7\xE3o valida"),
-  action: import_zod15.z.enum(["block", "warn", "modify", "escalate"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o")
+  action: import_zod15.z.enum(["block", "warn", "modify", "escalate"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o"),
+  actionInstruction: import_zod15.z.string().optional().describe("Instru\xE7\xE3o adicional para a a\xE7\xE3o")
 });
 var FunctionGuardrailNode = {
   label: "Function Guardrail",
@@ -2582,6 +2755,13 @@ var FunctionGuardrailNode = {
         { label: "Escalar (Human-in-the-loop)", value: "escalate" }
       ]
     },
+    {
+      id: "actionInstruction",
+      label: "Instru\xE7\xE3o da A\xE7\xE3o",
+      type: "textarea",
+      required: false,
+      placeholder: "Ex: Instru\xE7\xE3o para a modifica\xE7\xE3o ou mensagem de bloqueio"
+    },
     {
       id: "guardrail",
       label: "Guardrail",
@@ -2600,26 +2780,24 @@ var FunctionGuardrailNode = {
 
 // src/nodes/guardrails/function/function.ts
 var FunctionGuardrailNodeFunction = async (inputs) => {
-  const { fieldValues = {} } = inputs;
+  const values = inputs.fieldValues || inputs;
   const {
     name,
-    phase,
     description,
     action,
     nodeFunction,
-    nodeType,
     originalNodeData
-  } = fieldValues;
+  } = values;
   return {
-    type: "function",
-    name: name || "Function Guardrail",
-    phase: phase || "after",
-    description: description || "",
-    action: action || "block",
-    // Injected by executeWorkflow.ts
-    nodeFunction,
-    nodeType,
-    originalNodeData
+    guardrail: {
+      type: "function",
+      name: name || "Function Guardrail",
+      description,
+      action: action || "block",
+      // Injected by executeWorkflow.ts
+      nodeFunction,
+      originalNodeData
+    }
   };
 };
 
@@ -2629,7 +2807,9 @@ var ModelGuardrailNodeSchema = import_zod16.z.object({
   name: import_zod16.z.string().describe("Nome do guardrail"),
   evaluationPrompt: import_zod16.z.string().describe("Prompt de avalia\xE7\xE3o"),
   model: import_zod16.z.any().describe("Modelo LLM para avalia\xE7\xE3o"),
-  action: import_zod16.z.enum(["block", "warn", "escalate"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o")
+  action: import_zod16.z.enum(["block", "warn", "fix", "escalate"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o"),
+  phase: import_zod16.z.enum(["before", "after"]).describe("Fase de execu\xE7\xE3o"),
+  actionInstruction: import_zod16.z.string().optional().describe("Instru\xE7\xE3o adicional para a a\xE7\xE3o")
 });
 var ModelGuardrailNode = {
   label: "Model Guardrail",
@@ -2680,10 +2860,29 @@ var ModelGuardrailNode = {
       defaultValue: "block",
       options: [
         { label: "Bloquear Resposta", value: "block" },
+        { label: "Corrigir/Reescrever (Fix)", value: "fix" },
         { label: "Avisar (Warning)", value: "warn" },
         { label: "Escalar (Human-in-the-loop)", value: "escalate" }
       ]
     },
+    {
+      id: "actionInstruction",
+      label: "Instru\xE7\xE3o da A\xE7\xE3o",
+      type: "textarea",
+      required: false,
+      placeholder: "Ex: Se bloquear, diga 'Pol\xEDtica violada'. Se corrigir, 'Reescreva com...'"
+    },
+    {
+      id: "phase",
+      label: "Fase de Execu\xE7\xE3o",
+      type: "select",
+      required: true,
+      defaultValue: "after",
+      options: [
+        { label: "Antes do Agente (Input)", value: "before" },
+        { label: "Depois do Agente (Output)", value: "after" }
+      ]
+    },
     {
       id: "guardrail",
       label: "Guardrail",
@@ -2702,19 +2901,25 @@ var ModelGuardrailNode = {
 
 // src/nodes/guardrails/model/function.ts
 var ModelGuardrailNodeFunction = async (inputs) => {
-  const { fieldValues = {} } = inputs;
+  const values = inputs.fieldValues || inputs;
   const {
     name,
     evaluationPrompt,
     model,
     action
-  } = fieldValues;
+  } = values;
+  const defaultModel = {
+    model: "gemini-flash-latest",
+    integrationId: "default-gemini"
+  };
   return {
-    type: "model",
-    name: name || "Model Guardrail",
-    evaluationPrompt: evaluationPrompt || "Avalie se este conte\xFAdo \xE9 seguro. Responda apenas SAFE ou UNSAFE.",
-    model,
-    action: action || "block"
+    guardrail: {
+      type: "model",
+      name: name || "Model Guardrail",
+      evaluationPrompt: evaluationPrompt || "Analise se o conte\xFAdo a seguir \xE9 apropriado, seguro e segue as pol\xEDticas de \xE9tica. Responda 'SAFE' se estiver tudo bem ou 'UNSAFE' caso contr\xE1rio.\n\nCONTE\xDADO:\n{{content}}",
+      model: model || defaultModel,
+      action: action || "block"
+    }
   };
 };