@atomoz/workflows-nodes 0.1.20 → 0.1.21

package/dist/index.js

@@ -917,13 +917,54 @@ var IaAgentNode = {
         name: "response",
         fieldType: "string"
       }
+    },
+    {
+      id: "beforeGuardrails",
+      label: "Before Guardrails",
+      type: "guardrail",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Before Guardrails",
+        name: "beforeGuardrails",
+        fieldType: "guardrail",
+        acceptTypes: ["guardrail"],
+        maxConnections: 10
+      }
+    },
+    {
+      id: "afterGuardrails",
+      label: "After Guardrails",
+      type: "guardrail",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "After Guardrails",
+        name: "afterGuardrails",
+        fieldType: "guardrail",
+        acceptTypes: ["guardrail"],
+        maxConnections: 10
+      }
+    },
+    {
+      id: "guardrailMode",
+      label: "Guardrail Mode",
+      type: "select",
+      required: true,
+      defaultValue: "fail-first",
+      options: [
+        { label: "Fail on First Violation", value: "fail-first" },
+        { label: "Run All and Combine", value: "run-all" }
+      ]
     }
   ]
 };
 
 // src/nodes/ia/agent/function.ts
 import { createReactAgent } from "@langchain/langgraph/prebuilt";
-import { SystemMessage } from "@langchain/core/messages";
+import { SystemMessage, HumanMessage } from "@langchain/core/messages";
 
 // src/utils/llm-factory.ts
 import { gql } from "graphql-request";
@@ -956,7 +997,7 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
     case "gemini":
       return new ChatGoogle({
         model: "gemini-flash-latest",
-        apiKey: "AIzaSyAWS9GhesWxG4uTdJRQbBziMB1diXtXtlI",
+        apiKey: "AIzaSyD9WiFuXp2fhVAokIMPp9YPKMlh7_Bvddc",
         streaming
       });
     case "openai":
@@ -981,22 +1022,165 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
   }
 }
 
+// src/utils/guardrail-executor.ts
+async function executeGuardrails(guardrails, content, mode = "fail-first") {
+  const list = Array.isArray(guardrails) ? guardrails : [guardrails];
+  const result = {
+    passed: true,
+    blocked: false,
+    modifiedContent: content,
+    violations: []
+  };
+  for (const guard of list) {
+    if (!guard) continue;
+    let guardPassed = true;
+    let violationMessage = "";
+    if (guard.type === "rule") {
+      const { ruleType, config, action } = guard;
+      if (ruleType === "keywords" && config) {
+        const keywords = config.split(",").map((k) => k.trim().toLowerCase());
+        const lowerContent = content.toLowerCase();
+        const found = keywords.filter((k) => lowerContent.includes(k));
+        if (found.length > 0) {
+          guardPassed = false;
+          violationMessage = `Conte\xFAdo cont\xE9m palavras proibidas: ${found.join(", ")}`;
+        }
+      } else if (ruleType === "regex" && config) {
+        try {
+          const regex = new RegExp(config, "i");
+          if (regex.test(content)) {
+            guardPassed = false;
+            violationMessage = `Conte\xFAdo viola regra de padr\xE3o (regex): ${config}`;
+          }
+        } catch (e) {
+          console.error("Invalid regex in guardrail:", config);
+        }
+      } else if (ruleType === "maxValue" && config) {
+        const val = parseFloat(content.replace(/[^\d.-]/g, ""));
+        const max = parseFloat(config);
+        if (!isNaN(val) && val > max) {
+          guardPassed = false;
+          violationMessage = `Valor ${val} excede o m\xE1ximo permitido de ${max}.`;
+        }
+      } else if (ruleType === "minValue" && config) {
+        const val = parseFloat(content.replace(/[^\d.-]/g, ""));
+        const min = parseFloat(config);
+        if (!isNaN(val) && val < min) {
+          guardPassed = false;
+          violationMessage = `Valor ${val} \xE9 menor que o m\xEDnimo permitido de ${min}.`;
+        }
+      }
+    } else if (guard.type === "function") {
+      const { nodeFunction, name } = guard;
+      if (typeof nodeFunction === "function") {
+        try {
+          const result2 = await nodeFunction({
+            input: content,
+            fieldValues: { input: content },
+            originalNodeData: guard.originalNodeData
+          });
+          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.`;
+          } else if (typeof result2 === "object" && result2?.modifiedContent) {
+            result2.modifiedContent = result2.modifiedContent;
+          }
+        } catch (error) {
+          console.error(`Error executing function guardrail "${name}":`, error);
+          guardPassed = false;
+          violationMessage = `Erro na fun\xE7\xE3o guardrail: ${error instanceof Error ? error.message : String(error)}`;
+        }
+      }
+    } else if (guard.type === "model") {
+      const { model, evaluationPrompt, name } = guard;
+      if (model && typeof model.invoke === "function") {
+        try {
+          const prompt = evaluationPrompt.replace("{{content}}", 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.`;
+          }
+        } catch (error) {
+          console.error(`Error executing model guardrail "${name}":`, error);
+        }
+      }
+    }
+    if (!guardPassed) {
+      result.passed = false;
+      result.violations.push({
+        name: guard.name,
+        message: violationMessage,
+        action: guard.action || "block"
+      });
+      if (guard.action === "block") {
+        result.blocked = true;
+        result.message = violationMessage;
+        if (mode === "fail-first") break;
+      }
+    }
+  }
+  return result;
+}
+function applyPromptGuardrails(systemMessage, guardrails) {
+  const list = Array.isArray(guardrails) ? guardrails : [guardrails];
+  let finalSystemMessage = systemMessage;
+  for (const guard of list) {
+    if (guard?.type === "prompt" && guard.prompt) {
+      finalSystemMessage += `
+
+GUARDRAIL [${guard.name}]: ${guard.prompt}`;
+    }
+  }
+  return finalSystemMessage;
+}
+
 // src/nodes/ia/agent/function.ts
 var IaAgentNodeFunction = async (inputs) => {
   const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = inputs;
   const fieldValues = inputs.fieldValues || {};
-  const { model, tools, systemMessage, name, message } = fieldValues;
+  const { model, tools, systemMessage, name, message, beforeGuardrails, afterGuardrails, guardrailMode } = fieldValues;
   const authToken = inputs.authToken;
   const stream = Boolean(inputs?.stream);
   const emitter = inputs?.emitter;
   const sessionMemory = fieldValues.sessionMemory || inputs.sessionMemory;
-  const checkpointer = sessionMemory?.checkpointer;
+  const checkpointer = sessionMemory && typeof sessionMemory.put === "function" ? sessionMemory : sessionMemory?.checkpointer;
   const sessionId = inputs.sessionId || inputs.$req?.sessionId || `session-${Date.now()}`;
   if (!name) {
     throw new Error("Agent 'name' is required. Please provide a unique name for the agent in the node properties.");
   }
-  if (!model) {
-    throw new Error("Model is required for IaAgentNode");
+  const prepareGuardrails = async (list) => {
+    const guardrailsList = Array.isArray(list) ? list : [list];
+    return await Promise.all(guardrailsList.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);
+        return { ...g, model: modelInstance };
+      }
+      return g;
+    }));
+  };
+  if (message && beforeGuardrails) {
+    const preparedBefore = await prepareGuardrails(beforeGuardrails);
+    const beforeResults = await executeGuardrails(preparedBefore, message, guardrailMode);
+    if (beforeResults.blocked) {
+      console.log(`\u{1F6E1}\uFE0F IaAgentNode "${name}": Blocked by before-agent guardrail:`, beforeResults.message);
+      if (stream && emitter?.emitDelta) {
+        emitter.emitDelta({
+          content: beforeResults.message || "Requisi\xE7\xE3o bloqueada por pol\xEDtica de seguran\xE7a.",
+          actor: name,
+          isAgent: true,
+          isError: true
+        });
+      }
+      return {
+        agent: null,
+        output: beforeResults.message || "Requisi\xE7\xE3o bloqueada por pol\xEDtica de seguran\xE7a.",
+        blocked: true,
+        violations: beforeResults.violations
+      };
+    }
   }
   let toolsArray = [];
   if (Array.isArray(tools)) {
@@ -1004,9 +1188,15 @@ var IaAgentNodeFunction = async (inputs) => {
   } else if (tools) {
     toolsArray = [tools];
   }
-  const finalSystemMessageContent = `${systemMessage || ""}
+  let finalSystemMessageContent = `${systemMessage || ""}
 
 IMPORTANT: You must base your response on the last message in the conversation history.`;
+  if (beforeGuardrails) {
+    finalSystemMessageContent = applyPromptGuardrails(finalSystemMessageContent, beforeGuardrails);
+  }
+  if (afterGuardrails) {
+    finalSystemMessageContent = applyPromptGuardrails(finalSystemMessageContent, afterGuardrails);
+  }
   const finalSystemMessage = new SystemMessage(finalSystemMessageContent);
   let llmInstance;
   if (model?.integrationId) {
@@ -1035,11 +1225,10 @@ IMPORTANT: You must base your response on the last message in the conversation h
   let output = "";
   if (message) {
     try {
-      const { HumanMessage: HumanMessage2 } = await import("@langchain/core/messages");
       const invokeConfig = checkpointer ? { configurable: { thread_id: sessionId } } : {};
       if (stream && emitter) {
         const streamIterator = await agent.stream(
-          { messages: [new HumanMessage2(message)] },
+          { messages: [new HumanMessage(message)] },
           invokeConfig
         );
         let lastMessages = [];
@@ -1086,7 +1275,7 @@ IMPORTANT: You must base your response on the last message in the conversation h
         }
       } else {
         const result = await agent.invoke(
-          { messages: [new HumanMessage2(message)] },
+          { messages: [new HumanMessage(message)] },
           invokeConfig
         );
         if (result?.messages && result.messages.length > 0) {
@@ -1105,6 +1294,26 @@ 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);
+        if (afterResults.blocked) {
+          console.log(`\u{1F6E1}\uFE0F IaAgentNode "${name}": Response blocked by after-agent guardrail:`, afterResults.message);
+          if (stream && emitter?.emitDelta) {
+            emitter.emitDelta({
+              content: `
+
+\u26A0\uFE0F RESPOSTA BLOQUEADA: ${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;
+        }
+      }
     } catch (error) {
       console.error("Error processing message in agent:", error);
       output = `Error: ${error instanceof Error ? error.message : "Unknown error"}`;
@@ -1219,7 +1428,7 @@ var AiSupervisorNode = {
 
 // src/nodes/ia/supervisor/function.ts
 import { createSupervisor } from "@langchain/langgraph-supervisor";
-import { HumanMessage } from "@langchain/core/messages";
+import { HumanMessage as HumanMessage2 } from "@langchain/core/messages";
 import { InMemoryStore } from "@langchain/langgraph";
 var store = new InMemoryStore();
 var extractSupervisorAgents = (agents) => {
@@ -1312,7 +1521,7 @@ var AiSupervisorNodeFunction = async (params) => {
     if (stream && emitter) {
       try {
         const streamIterator = await app.stream(
-          { messages: [new HumanMessage({ content: message })] },
+          { messages: [new HumanMessage2({ content: message })] },
           { recursionLimit: 150, configurable: { thread_id: sessionId } }
         );
         let finalMessages = [];
@@ -1391,7 +1600,7 @@ var AiSupervisorNodeFunction = async (params) => {
       }
     } else {
       const result = await app.invoke(
-        { messages: [new HumanMessage({ content: message })] },
+        { messages: [new HumanMessage2({ content: message })] },
         { recursionLimit: 150, configurable: { thread_id: sessionId } }
       );
       const finalResponse = extractFinalResponse(result?.messages);
@@ -1508,7 +1717,7 @@ var PostgresMemoryNode = {
       label: "Connection String",
       type: "string",
       required: true,
-      defaultValue: "postgresql://postgres:postgres@localhost:5432/workflows",
+      defaultValue: "postgresql://yugabyte:yugabyte@localhost:5433/workflows",
       placeholder: "postgresql://user:pass@host:5432/database"
     },
     {
@@ -2060,6 +2269,375 @@ var CustomCodeNode = {
   ]
 };
 
+// src/nodes/guardrails/prompt/data.ts
+import { z as z13 } from "zod";
+var PromptGuardrailNodeSchema = z13.object({
+  name: z13.string().describe("Nome do guardrail"),
+  prompt: z13.string().describe("Instru\xE7\xE3o do guardrail")
+});
+var PromptGuardrailNode = {
+  label: "Prompt Guardrail",
+  type: "PromptGuardrailNode",
+  category: "step",
+  description: "Injeta instru\xE7\xF5es de seguran\xE7a ou comportamento no sistema do agente",
+  icon: "\u{1F6E1}\uFE0F",
+  group: "Guardrails",
+  tags: {
+    execution: "sync",
+    group: "Guardrails"
+  },
+  fields: [
+    {
+      id: "name",
+      label: "Nome",
+      type: "string",
+      required: true,
+      placeholder: "Ex: Enforce Portuguese"
+    },
+    {
+      id: "prompt",
+      label: "Instru\xE7\xE3o",
+      type: "textarea",
+      required: true,
+      placeholder: "Ex: Sempre responda em portugu\xEAs brasileiro"
+    },
+    {
+      id: "guardrail",
+      label: "Guardrail",
+      type: "guardrail",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Guardrail",
+        name: "guardrail",
+        fieldType: "guardrail"
+      }
+    }
+  ]
+};
+
+// src/nodes/guardrails/prompt/function.ts
+var PromptGuardrailNodeFunction = async (inputs) => {
+  const { fieldValues = {} } = inputs;
+  const { name, prompt } = fieldValues;
+  return {
+    type: "prompt",
+    name: name || "Prompt Guardrail",
+    prompt: prompt || ""
+  };
+};
+
+// src/nodes/guardrails/rule/data.ts
+import { z as z14 } from "zod";
+var RuleGuardrailNodeSchema = z14.object({
+  name: z14.string().describe("Nome do guardrail"),
+  phase: z14.enum(["before", "after"]).describe("Fase de execu\xE7\xE3o"),
+  ruleType: z14.enum(["maxValue", "minValue", "regex", "keywords", "pii"]).describe("Tipo de regra"),
+  config: z14.any().describe("Configura\xE7\xE3o da regra"),
+  action: z14.enum(["block", "warn", "modify"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o")
+});
+var RuleGuardrailNode = {
+  label: "Rule Guardrail",
+  type: "RuleGuardrailNode",
+  category: "step",
+  description: "Valida\xE7\xF5es determin\xEDsticas baseadas em regras (limites, palavras-chave, regex)",
+  icon: "\u2696\uFE0F",
+  group: "Guardrails",
+  tags: {
+    execution: "sync",
+    group: "Guardrails"
+  },
+  fields: [
+    {
+      id: "name",
+      label: "Nome",
+      type: "string",
+      required: true,
+      placeholder: "Ex: Limit Discount"
+    },
+    {
+      id: "phase",
+      label: "Fase",
+      type: "select",
+      required: true,
+      defaultValue: "after",
+      options: [
+        { label: "Antes do Agente (Input)", value: "before" },
+        { label: "Depois do Agente (Output)", value: "after" }
+      ]
+    },
+    {
+      id: "ruleType",
+      label: "Tipo de Regra",
+      type: "select",
+      required: true,
+      options: [
+        { label: "Valor M\xE1ximo", value: "maxValue" },
+        { label: "Valor M\xEDnimo", value: "minValue" },
+        { label: "Express\xE3o Regular (Regex)", value: "regex" },
+        { label: "Palavras-chave (Keywords)", value: "keywords" },
+        { label: "Dados Sens\xEDveis (PII)", value: "pii" }
+      ]
+    },
+    {
+      id: "config",
+      label: "Configura\xE7\xE3o",
+      type: "string",
+      required: true,
+      placeholder: "Ex: 15 (para valor) ou ofensivo,hack (para keywords)"
+    },
+    {
+      id: "action",
+      label: "A\xE7\xE3o em Viola\xE7\xE3o",
+      type: "select",
+      required: true,
+      defaultValue: "block",
+      options: [
+        { label: "Bloquear Resposta", value: "block" },
+        { label: "Avisar (Warning)", value: "warn" },
+        { label: "Modificar/Ocultar", value: "modify" }
+      ]
+    },
+    {
+      id: "guardrail",
+      label: "Guardrail",
+      type: "guardrail",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Guardrail",
+        name: "guardrail",
+        fieldType: "guardrail"
+      }
+    }
+  ]
+};
+
+// src/nodes/guardrails/rule/function.ts
+var RuleGuardrailNodeFunction = async (inputs) => {
+  const { fieldValues = {} } = inputs;
+  const { name, phase, ruleType, config, action } = fieldValues;
+  return {
+    type: "rule",
+    name: name || "Rule Guardrail",
+    phase: phase || "after",
+    ruleType: ruleType || "keywords",
+    config: config || "",
+    action: action || "block"
+  };
+};
+
+// src/nodes/guardrails/function/data.ts
+import { z as z15 } from "zod";
+var FunctionGuardrailNodeSchema = z15.object({
+  name: z15.string().describe("Nome do guardrail"),
+  phase: z15.enum(["before", "after"]).describe("Fase de execu\xE7\xE3o"),
+  description: z15.string().optional().describe("Descri\xE7\xE3o do que a fun\xE7\xE3o valida"),
+  action: z15.enum(["block", "warn", "modify", "escalate"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o")
+});
+var FunctionGuardrailNode = {
+  label: "Function Guardrail",
+  type: "FunctionGuardrailNode",
+  category: "step",
+  description: "Executa uma fun\xE7\xE3o customizada (Custom Code ou HTTP) para validar entrada/sa\xEDda",
+  icon: "\u{1F9E9}",
+  group: "Guardrails",
+  tags: {
+    execution: "async",
+    group: "Guardrails"
+  },
+  fields: [
+    {
+      id: "name",
+      label: "Nome",
+      type: "string",
+      required: true,
+      placeholder: "Ex: Validar Desconto API"
+    },
+    {
+      id: "phase",
+      label: "Fase",
+      type: "select",
+      required: true,
+      defaultValue: "after",
+      options: [
+        { label: "Antes do Agente (Input)", value: "before" },
+        { label: "Depois do Agente (Output)", value: "after" }
+      ]
+    },
+    {
+      id: "description",
+      label: "Descri\xE7\xE3o",
+      type: "textarea",
+      required: false,
+      placeholder: "Descreva o que este guardrail valida..."
+    },
+    {
+      id: "function",
+      label: "Fun\xE7\xE3o",
+      type: "function",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Fun\xE7\xE3o",
+        name: "function",
+        fieldType: "function",
+        acceptTypes: ["code", "http", "any"],
+        maxConnections: 1
+      }
+    },
+    {
+      id: "action",
+      label: "A\xE7\xE3o em Viola\xE7\xE3o",
+      type: "select",
+      required: true,
+      defaultValue: "block",
+      options: [
+        { label: "Bloquear", value: "block" },
+        { label: "Avisar (Warning)", value: "warn" },
+        { label: "Modificar", value: "modify" },
+        { label: "Escalar (Human-in-the-loop)", value: "escalate" }
+      ]
+    },
+    {
+      id: "guardrail",
+      label: "Guardrail",
+      type: "guardrail",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Guardrail",
+        name: "guardrail",
+        fieldType: "guardrail"
+      }
+    }
+  ]
+};
+
+// src/nodes/guardrails/function/function.ts
+var FunctionGuardrailNodeFunction = async (inputs) => {
+  const { fieldValues = {} } = inputs;
+  const {
+    name,
+    phase,
+    description,
+    action,
+    nodeFunction,
+    nodeType,
+    originalNodeData
+  } = fieldValues;
+  return {
+    type: "function",
+    name: name || "Function Guardrail",
+    phase: phase || "after",
+    description: description || "",
+    action: action || "block",
+    // Injected by executeWorkflow.ts
+    nodeFunction,
+    nodeType,
+    originalNodeData
+  };
+};
+
+// src/nodes/guardrails/model/data.ts
+import { z as z16 } from "zod";
+var ModelGuardrailNodeSchema = z16.object({
+  name: z16.string().describe("Nome do guardrail"),
+  evaluationPrompt: z16.string().describe("Prompt de avalia\xE7\xE3o"),
+  model: z16.any().describe("Modelo LLM para avalia\xE7\xE3o"),
+  action: z16.enum(["block", "warn", "escalate"]).describe("A\xE7\xE3o em caso de viola\xE7\xE3o")
+});
+var ModelGuardrailNode = {
+  label: "Model Guardrail",
+  type: "ModelGuardrailNode",
+  category: "step",
+  description: "Usa um modelo de IA secund\xE1rio para avaliar a seguran\xE7a ou qualidade do conte\xFAdo",
+  icon: "\u{1F9E0}\u{1F6E1}\uFE0F",
+  group: "Guardrails",
+  tags: {
+    execution: "async",
+    group: "Guardrails"
+  },
+  fields: [
+    {
+      id: "name",
+      label: "Nome",
+      type: "string",
+      required: true,
+      placeholder: "Ex: Safety Check"
+    },
+    {
+      id: "evaluationPrompt",
+      label: "Prompt de Avalia\xE7\xE3o",
+      type: "textarea",
+      required: true,
+      placeholder: "Ex: Avalie se a resposta abaixo cont\xE9m discurso de \xF3dio ou ofensas. Responda apenas SAFE ou UNSAFE.",
+      defaultValue: "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}}"
+    },
+    {
+      id: "model",
+      label: "Modelo de Avalia\xE7\xE3o",
+      type: "model",
+      required: true,
+      handle: {
+        type: "input",
+        label: "Modelo",
+        name: "model",
+        fieldType: "model",
+        acceptTypes: ["model"],
+        maxConnections: 1
+      }
+    },
+    {
+      id: "action",
+      label: "A\xE7\xE3o em Viola\xE7\xE3o (UNSAFE)",
+      type: "select",
+      required: true,
+      defaultValue: "block",
+      options: [
+        { label: "Bloquear Resposta", value: "block" },
+        { label: "Avisar (Warning)", value: "warn" },
+        { label: "Escalar (Human-in-the-loop)", value: "escalate" }
+      ]
+    },
+    {
+      id: "guardrail",
+      label: "Guardrail",
+      type: "guardrail",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Guardrail",
+        name: "guardrail",
+        fieldType: "guardrail"
+      }
+    }
+  ]
+};
+
+// src/nodes/guardrails/model/function.ts
+var ModelGuardrailNodeFunction = async (inputs) => {
+  const { fieldValues = {} } = inputs;
+  const {
+    name,
+    evaluationPrompt,
+    model,
+    action
+  } = fieldValues;
+  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"
+  };
+};
+
 // src/nodes/consts/nodes.ts
 var nodes = [
   ChatInputNode,
@@ -2082,7 +2660,11 @@ var nodes = [
   WhatsappSendTemplateNode,
   WhatsappSendMessageNode,
   WhatsappMessageTriggerNode,
-  CustomCodeNode
+  CustomCodeNode,
+  PromptGuardrailNode,
+  RuleGuardrailNode,
+  FunctionGuardrailNode,
+  ModelGuardrailNode
 ];
 var nodes_default = nodes;
 
@@ -2200,7 +2782,11 @@ var nodeFunctions = {
   CustomCodeNode: NodeFunction,
   CustomNode: CustomNodeFunction,
   PostgresMemoryNode: PostgresMemoryNodeFunction,
-  RedisMemoryNode: RedisMemoryNodeFunction
+  RedisMemoryNode: RedisMemoryNodeFunction,
+  PromptGuardrailNode: PromptGuardrailNodeFunction,
+  RuleGuardrailNode: RuleGuardrailNodeFunction,
+  FunctionGuardrailNode: FunctionGuardrailNodeFunction,
+  ModelGuardrailNode: ModelGuardrailNodeFunction
 };
 var node_functions_default = nodeFunctions;
 
@@ -2314,12 +2900,12 @@ var HttpPutInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/put/schema.ts
-import { z as z13 } from "zod";
-var HttpPutInputNodeSchema = z13.object({
+import { z as z17 } from "zod";
+var HttpPutInputNodeSchema = z17.object({
   route: RouteSchema,
-  queryParams: z13.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z13.array(HeaderSchema).optional().describe("Headers configuration"),
-  body: z13.array(BodyFieldSchema).optional().describe("Body fields configuration")
+  queryParams: z17.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: z17.array(HeaderSchema).optional().describe("Headers configuration"),
+  body: z17.array(BodyFieldSchema).optional().describe("Body fields configuration")
 });
 
 // src/nodes/inputs/http/delete/data.ts
@@ -2411,11 +2997,11 @@ var HttpDeleteInputNodeFunction = async (params) => {
 };
 
 // src/nodes/inputs/http/delete/schema.ts
-import { z as z14 } from "zod";
-var HttpDeleteInputNodeSchema = z14.object({
+import { z as z18 } from "zod";
+var HttpDeleteInputNodeSchema = z18.object({
   route: RouteSchema,
-  queryParams: z14.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z14.array(HeaderSchema).optional().describe("Headers configuration")
+  queryParams: z18.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: z18.array(HeaderSchema).optional().describe("Headers configuration")
 });
 
 // src/nodes/inputs/http/patch/data.ts
@@ -2528,12 +3114,12 @@ var HttpPatchInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/patch/schema.ts
-import { z as z15 } from "zod";
-var HttpPatchInputNodeSchema = z15.object({
+import { z as z19 } from "zod";
+var HttpPatchInputNodeSchema = z19.object({
   route: RouteSchema,
-  queryParams: z15.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z15.array(HeaderSchema).optional().describe("Headers configuration"),
-  body: z15.array(BodyFieldSchema).optional().describe("Body fields configuration")
+  queryParams: z19.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: z19.array(HeaderSchema).optional().describe("Headers configuration"),
+  body: z19.array(BodyFieldSchema).optional().describe("Body fields configuration")
 });
 
 // src/nodes/inputs/http/utils.ts