@atomoz/workflows-nodes 0.1.19 → 0.1.21

package/dist/index.cjs

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,14 +14,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // index.ts
@@ -980,6 +970,21 @@ var IaAgentNode = {
         fieldType: "agent"
       }
     },
+    {
+      id: "sessionMemory",
+      label: "Session Memory",
+      type: "memory",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Session Memory",
+        name: "sessionMemory",
+        fieldType: "memory",
+        acceptTypes: ["memory"],
+        maxConnections: 1
+      }
+    },
     {
       id: "response",
       label: "Response",
@@ -992,6 +997,47 @@ 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" }
+      ]
     }
   ]
 };
@@ -1031,7 +1077,7 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
     case "gemini":
       return new import_google_gauth.ChatGoogle({
         model: "gemini-flash-latest",
-        apiKey: "AIzaSyAWS9GhesWxG4uTdJRQbBziMB1diXtXtlI",
+        apiKey: "AIzaSyD9WiFuXp2fhVAokIMPp9YPKMlh7_Bvddc",
         streaming
       });
     case "openai":
@@ -1056,18 +1102,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 { model, tools, systemMessage, name, message } = inputs.fieldValues || {};
+  const fieldValues = inputs.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 && 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)) {
@@ -1075,9 +1268,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 import_messages.SystemMessage(finalSystemMessageContent);
   let llmInstance;
   if (model?.integrationId) {
@@ -1093,17 +1292,25 @@ IMPORTANT: You must base your response on the last message in the conversation h
   const agent = (0, import_prebuilt.createReactAgent)({
     llm: llmInstance,
     tools: toolsArray,
-    messageModifier: finalSystemMessage
+    messageModifier: finalSystemMessage,
+    // Pass checkpointer directly for distributed memory
+    ...checkpointer ? { checkpointer } : {}
   });
   agent.name = name;
+  if (checkpointer) {
+    console.log(`\u{1F9E0} IaAgentNode "${name}": Using distributed memory (sessionId: ${sessionId})`);
+  } else {
+    console.log(`\u26A0\uFE0F IaAgentNode "${name}": No sessionMemory connected - stateless mode`);
+  }
   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)]
-        });
+        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) {
@@ -1147,9 +1354,10 @@ IMPORTANT: You must base your response on the last message in the conversation h
           }
         }
       } else {
-        const result = await agent.invoke({
-          messages: [new HumanMessage2(message)]
-        });
+        const result = await agent.invoke(
+          { messages: [new import_messages.HumanMessage(message)] },
+          invokeConfig
+        );
         if (result?.messages && result.messages.length > 0) {
           const lastMessage = result.messages[result.messages.length - 1];
           const content = lastMessage?.content;
@@ -1166,6 +1374,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"}`;
@@ -1247,6 +1475,21 @@ var AiSupervisorNode = {
         acceptTypes: ["agent"]
       }
     },
+    {
+      id: "sessionMemory",
+      label: "Session Memory",
+      type: "memory",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Session Memory",
+        name: "sessionMemory",
+        fieldType: "memory",
+        acceptTypes: ["memory"],
+        maxConnections: 1
+      }
+    },
     {
       id: "response",
       label: "Response",
@@ -1267,7 +1510,6 @@ var AiSupervisorNode = {
 var import_langgraph_supervisor = require("@langchain/langgraph-supervisor");
 var import_messages2 = require("@langchain/core/messages");
 var import_langgraph = require("@langchain/langgraph");
-var checkpointer = new import_langgraph.MemorySaver();
 var store = new import_langgraph.InMemoryStore();
 var extractSupervisorAgents = (agents) => {
   if (Array.isArray(agents)) {
@@ -1323,6 +1565,9 @@ var AiSupervisorNodeFunction = async (params) => {
   const stream = (typeof outer.stream === "boolean" ? outer.stream : inner.stream) ?? false;
   const emitter = outer.emitter ?? inner.emitter;
   const authToken = outer.authToken ?? inner.authToken;
+  const sessionMemory = inner.sessionMemory ?? outer.sessionMemory;
+  const checkpointer = sessionMemory?.checkpointer;
+  const sessionId = outer.sessionId || outer.$req?.sessionId || `supervisor-${Date.now()}`;
   if (!model) throw new Error("Model is required for AiSupervisorNode");
   if (!agents) throw new Error("Agents are required for AiSupervisorNode.");
   try {
@@ -1332,12 +1577,17 @@ var AiSupervisorNodeFunction = async (params) => {
     let llmInstance;
     if (model?.model && model?.integrationId) {
       if (!authToken) {
-        throw new Error("Auth token is required to instantiate LLM from integration 3");
+        throw new Error("Auth token is required to instantiate LLM from integration");
       }
       llmInstance = await createLLMFromModel(model, authToken, stream);
     } else {
       llmInstance = model;
     }
+    if (checkpointer) {
+      console.log(`\u{1F9E0} AiSupervisorNode: Using distributed memory (sessionId: ${sessionId})`);
+    } else {
+      console.log(`\u26A0\uFE0F AiSupervisorNode: No sessionMemory connected - stateless mode`);
+    }
     const finalSystemPrompt = systemMessage || "You are a supervisor...";
     const workflow = (0, import_langgraph_supervisor.createSupervisor)({
       llm: llmInstance,
@@ -1345,14 +1595,14 @@ var AiSupervisorNodeFunction = async (params) => {
       prompt: finalSystemPrompt
     });
     const app = workflow.compile({
-      checkpointer,
+      ...checkpointer ? { checkpointer } : {},
       store
     });
     if (stream && emitter) {
       try {
         const streamIterator = await app.stream(
           { messages: [new import_messages2.HumanMessage({ content: message })] },
-          { recursionLimit: 150, configurable: { thread_id: "conversation" } }
+          { recursionLimit: 150, configurable: { thread_id: sessionId } }
         );
         let finalMessages = [];
         const previousStepMessages = /* @__PURE__ */ new Map();
@@ -1431,7 +1681,7 @@ var AiSupervisorNodeFunction = async (params) => {
     } else {
       const result = await app.invoke(
         { messages: [new import_messages2.HumanMessage({ content: message })] },
-        { recursionLimit: 150, configurable: { thread_id: "conversation" } }
+        { recursionLimit: 150, configurable: { thread_id: sessionId } }
       );
       const finalResponse = extractFinalResponse(result?.messages);
       return {
@@ -1525,12 +1775,139 @@ var AiToolNode = {
 // src/nodes/ia/tool/function.ts
 var import_tools = require("@langchain/core/tools");
 
+// src/nodes/memory/postgres/data.ts
+var import_zod8 = require("zod");
+var PostgresMemoryNodeSchema = import_zod8.z.object({
+  connectionString: import_zod8.z.string().describe("PostgreSQL connection string")
+});
+var PostgresMemoryNode = {
+  label: "Postgres Memory",
+  type: "PostgresMemoryNode",
+  category: "memory",
+  description: "Persistent conversation memory using PostgreSQL (distributed across pods)",
+  icon: "\u{1F418}",
+  group: "Memory",
+  tags: {
+    execution: "sync",
+    group: "Memory"
+  },
+  fields: [
+    {
+      id: "connectionString",
+      label: "Connection String",
+      type: "string",
+      required: true,
+      defaultValue: "postgresql://yugabyte:yugabyte@localhost:5433/workflows",
+      placeholder: "postgresql://user:pass@host:5432/database"
+    },
+    {
+      id: "checkpointer",
+      label: "Checkpointer",
+      type: "memory",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Memory",
+        name: "checkpointer",
+        fieldType: "memory"
+      }
+    }
+  ]
+};
+
+// src/nodes/memory/postgres/function.ts
+var import_langgraph_checkpoint_postgres = require("@langchain/langgraph-checkpoint-postgres");
+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";
+  try {
+    const checkpointer = import_langgraph_checkpoint_postgres.PostgresSaver.fromConnString(connectionString);
+    await checkpointer.setup();
+    console.log("\u2705 PostgresMemory: Checkpointer initialized");
+    return {
+      checkpointer,
+      type: "PostgresMemoryNode",
+      connectionString: connectionString.replace(/:[^:@]+@/, ":***@")
+      // Hide password in output
+    };
+  } catch (error) {
+    console.error("\u274C PostgresMemory: Failed to initialize checkpointer:", error);
+    throw new Error(`PostgresMemory initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+
+// src/nodes/memory/redis/data.ts
+var import_zod9 = require("zod");
+var RedisMemoryNodeSchema = import_zod9.z.object({
+  redisUrl: import_zod9.z.string().describe("Redis connection URL")
+});
+var RedisMemoryNode = {
+  label: "Redis Memory",
+  type: "RedisMemoryNode",
+  category: "memory",
+  description: "Fast, persistent conversation memory using Redis (distributed across pods)",
+  icon: "\u{1F534}",
+  group: "Memory",
+  tags: {
+    execution: "sync",
+    group: "Memory"
+  },
+  fields: [
+    {
+      id: "redisUrl",
+      label: "Redis URL",
+      type: "string",
+      required: true,
+      defaultValue: "redis://localhost:6379",
+      placeholder: "redis://localhost:6379"
+    },
+    {
+      id: "checkpointer",
+      label: "Checkpointer",
+      type: "memory",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Memory",
+        name: "checkpointer",
+        fieldType: "memory"
+      }
+    }
+  ]
+};
+
+// src/nodes/memory/redis/function.ts
+var import_langgraph_checkpoint_redis = require("@langchain/langgraph-checkpoint-redis");
+var RedisMemoryNodeFunction = async (inputs) => {
+  const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = inputs;
+  const fieldValues = inputs.fieldValues || {};
+  const redisUrl = fieldValues.redisUrl || inputs.redisUrl || "redis://localhost:6379";
+  try {
+    const checkpointer = await import_langgraph_checkpoint_redis.RedisSaver.fromUrl(redisUrl);
+    console.log("\u2705 RedisMemory: Checkpointer initialized");
+    return {
+      checkpointer,
+      type: "RedisMemoryNode",
+      redisUrl: redisUrl.replace(/:[^:@]+@/, ":***@")
+      // Hide password in output
+    };
+  } catch (error) {
+    console.error("\u274C RedisMemory: Failed to initialize checkpointer:", error);
+    throw new Error(`RedisMemory initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+
 // src/nodes/consts/schemas.ts
 var schemas = {
   IaAgentNode: IaAgentNodeSchema,
   AiSupervisorNode: AiSupervisorNodeSchema,
   AiToolNode: AiToolNodeSchema,
-  IaMessageNode: IaMessageNodeSchema
+  IaMessageNode: IaMessageNodeSchema,
+  PostgresMemoryNode: PostgresMemoryNodeSchema,
+  RedisMemoryNode: RedisMemoryNodeSchema
 };
 
 // src/nodes/ia/tool/function.ts
@@ -1572,11 +1949,11 @@ var AiToolNodeFunction = async (params) => {
 };
 
 // src/nodes/ia/message/message.ts
-var import_zod8 = require("zod");
-var IaMessageNodeSchema = import_zod8.z.object({
-  model: import_zod8.z.any().describe("LLM model to use"),
-  systemMessage: import_zod8.z.string().optional().describe("System message for context"),
-  message: import_zod8.z.string().describe("User message to send to the LLM")
+var import_zod10 = require("zod");
+var IaMessageNodeSchema = import_zod10.z.object({
+  model: import_zod10.z.any().describe("LLM model to use"),
+  systemMessage: import_zod10.z.string().optional().describe("System message for context"),
+  message: import_zod10.z.string().describe("User message to send to the LLM")
 });
 var IaMessageNodeFunction = async (inputs) => {
   const { $field: _$field, $req: _$req, $inputs: _$inputs_var, $vars: _$vars } = inputs;
@@ -1711,10 +2088,10 @@ var IaMessageNode = {
 };
 
 // src/nodes/social/whatsapp/send-template/data.ts
-var import_zod9 = require("zod");
-var WhatsappSendTemplateNodeSchema = import_zod9.z.object({
-  phoneNumber: import_zod9.z.string().describe("Phone number to send the message to"),
-  message: import_zod9.z.string().describe("Message to send")
+var import_zod11 = require("zod");
+var WhatsappSendTemplateNodeSchema = import_zod11.z.object({
+  phoneNumber: import_zod11.z.string().describe("Phone number to send the message to"),
+  message: import_zod11.z.string().describe("Message to send")
 });
 var WhatsappSendTemplateNode = {
   label: "Whatsapp Send Template",
@@ -1755,10 +2132,10 @@ var WhatsappSendTemplateNode = {
 };
 
 // src/nodes/social/whatsapp/send-message/data.ts
-var import_zod10 = require("zod");
-var WhatsappSendMessageNodeSchema = import_zod10.z.object({
-  phoneNumber: import_zod10.z.string().describe("Phone number to send the message to"),
-  message: import_zod10.z.string().describe("Message content to send")
+var import_zod12 = require("zod");
+var WhatsappSendMessageNodeSchema = import_zod12.z.object({
+  phoneNumber: import_zod12.z.string().describe("Phone number to send the message to"),
+  message: import_zod12.z.string().describe("Message content to send")
 });
 var WhatsappSendMessageNode = {
   label: "Whatsapp Send Message",
@@ -1972,6 +2349,375 @@ var CustomCodeNode = {
   ]
 };
 
+// src/nodes/guardrails/prompt/data.ts
+var import_zod13 = require("zod");
+var PromptGuardrailNodeSchema = import_zod13.z.object({
+  name: import_zod13.z.string().describe("Nome do guardrail"),
+  prompt: import_zod13.z.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
+var import_zod14 = require("zod");
+var RuleGuardrailNodeSchema = import_zod14.z.object({
+  name: import_zod14.z.string().describe("Nome do guardrail"),
+  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")
+});
+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
+var import_zod15 = require("zod");
+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")
+});
+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
+var import_zod16 = require("zod");
+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")
+});
+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,
@@ -1989,10 +2735,16 @@ var nodes = [
   IaAgentNode,
   AiToolNode,
   AiSupervisorNode,
+  PostgresMemoryNode,
+  RedisMemoryNode,
   WhatsappSendTemplateNode,
   WhatsappSendMessageNode,
   WhatsappMessageTriggerNode,
-  CustomCodeNode
+  CustomCodeNode,
+  PromptGuardrailNode,
+  RuleGuardrailNode,
+  FunctionGuardrailNode,
+  ModelGuardrailNode
 ];
 var nodes_default = nodes;
 
@@ -2108,7 +2860,13 @@ var nodeFunctions = {
   WhatsappNode: WhatsappStartChatFunction,
   WhatsappSendMessageNode: WhatsappSendMessageFunction,
   CustomCodeNode: NodeFunction,
-  CustomNode: CustomNodeFunction
+  CustomNode: CustomNodeFunction,
+  PostgresMemoryNode: PostgresMemoryNodeFunction,
+  RedisMemoryNode: RedisMemoryNodeFunction,
+  PromptGuardrailNode: PromptGuardrailNodeFunction,
+  RuleGuardrailNode: RuleGuardrailNodeFunction,
+  FunctionGuardrailNode: FunctionGuardrailNodeFunction,
+  ModelGuardrailNode: ModelGuardrailNodeFunction
 };
 var node_functions_default = nodeFunctions;
 
@@ -2222,12 +2980,12 @@ var HttpPutInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/put/schema.ts
-var import_zod11 = require("zod");
-var HttpPutInputNodeSchema = import_zod11.z.object({
+var import_zod17 = require("zod");
+var HttpPutInputNodeSchema = import_zod17.z.object({
   route: RouteSchema,
-  queryParams: import_zod11.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: import_zod11.z.array(HeaderSchema).optional().describe("Headers configuration"),
-  body: import_zod11.z.array(BodyFieldSchema).optional().describe("Body fields configuration")
+  queryParams: import_zod17.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod17.z.array(HeaderSchema).optional().describe("Headers configuration"),
+  body: import_zod17.z.array(BodyFieldSchema).optional().describe("Body fields configuration")
 });
 
 // src/nodes/inputs/http/delete/data.ts
@@ -2319,11 +3077,11 @@ var HttpDeleteInputNodeFunction = async (params) => {
 };
 
 // src/nodes/inputs/http/delete/schema.ts
-var import_zod12 = require("zod");
-var HttpDeleteInputNodeSchema = import_zod12.z.object({
+var import_zod18 = require("zod");
+var HttpDeleteInputNodeSchema = import_zod18.z.object({
   route: RouteSchema,
-  queryParams: import_zod12.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: import_zod12.z.array(HeaderSchema).optional().describe("Headers configuration")
+  queryParams: import_zod18.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod18.z.array(HeaderSchema).optional().describe("Headers configuration")
 });
 
 // src/nodes/inputs/http/patch/data.ts
@@ -2436,12 +3194,12 @@ var HttpPatchInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/patch/schema.ts
-var import_zod13 = require("zod");
-var HttpPatchInputNodeSchema = import_zod13.z.object({
+var import_zod19 = require("zod");
+var HttpPatchInputNodeSchema = import_zod19.z.object({
   route: RouteSchema,
-  queryParams: import_zod13.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: import_zod13.z.array(HeaderSchema).optional().describe("Headers configuration"),
-  body: import_zod13.z.array(BodyFieldSchema).optional().describe("Body fields configuration")
+  queryParams: import_zod19.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod19.z.array(HeaderSchema).optional().describe("Headers configuration"),
+  body: import_zod19.z.array(BodyFieldSchema).optional().describe("Body fields configuration")
 });
 
 // src/nodes/inputs/http/utils.ts