@atomoz/workflows-nodes 0.1.18 → 0.1.20

package/dist/index.cjs

@@ -550,6 +550,104 @@ var DelayNode = {
   ]
 };
 
+// src/nodes/processors/http-request/index.ts
+var HttpRequestNodeFunction = async (params, input, context) => {
+  const { url, method, headers, body } = params;
+  console.log(`\u{1F4E1} Making HTTP Request: ${method} ${url}`);
+  const headersObj = typeof headers === "string" ? JSON.parse(headers || "{}") : headers || {};
+  const bodyObj = typeof body === "string" ? body : JSON.stringify(body);
+  const response = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headersObj
+    },
+    body: method !== "GET" && method !== "HEAD" ? bodyObj : void 0
+  });
+  const responseText = await response.text();
+  let responseData;
+  try {
+    responseData = JSON.parse(responseText);
+  } catch (e) {
+    responseData = responseText;
+  }
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    headers: Object.fromEntries(response.headers.entries()),
+    data: responseData
+  };
+};
+var HttpRequestNode = {
+  label: "HTTP Request",
+  type: "HttpRequestNode",
+  category: "step",
+  // or 'api'?
+  icon: "\u{1F310}",
+  description: "Faz uma requisi\xE7\xE3o HTTP externa",
+  tags: {
+    execution: "async",
+    group: "HTTP"
+  },
+  fields: [
+    {
+      id: "input",
+      label: "Input",
+      type: "any",
+      handle: {
+        type: "input",
+        label: "Start",
+        name: "input",
+        fieldType: "any"
+      }
+    },
+    {
+      id: "url",
+      label: "URL",
+      type: "string",
+      required: true,
+      placeholder: "https://api.example.com"
+    },
+    {
+      id: "method",
+      label: "Method",
+      type: "select",
+      required: true,
+      defaultValue: "GET",
+      options: [
+        { label: "GET", value: "GET" },
+        { label: "POST", value: "POST" },
+        { label: "PUT", value: "PUT" },
+        { label: "DELETE", value: "DELETE" },
+        { label: "PATCH", value: "PATCH" }
+      ]
+    },
+    {
+      id: "headers",
+      label: "Headers (JSON)",
+      type: "json",
+      defaultValue: "{}"
+    },
+    {
+      id: "body",
+      label: "Body (JSON)",
+      type: "json",
+      defaultValue: "{}"
+    },
+    {
+      id: "output",
+      label: "Output",
+      type: "any",
+      handle: {
+        type: "output",
+        label: "Response",
+        name: "output",
+        fieldType: "any"
+      }
+    }
+  ]
+};
+
 // src/nodes/processors/concat.ts
 var import_zod4 = require("zod");
 var ConcatNodeFunction = (params) => {
@@ -882,6 +980,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",
@@ -961,10 +1074,14 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
 // 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 } = 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 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.");
   }
@@ -995,17 +1112,26 @@ 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 HumanMessage2(message)] },
+          invokeConfig
+        );
         let lastMessages = [];
         const sentContents = /* @__PURE__ */ new Set();
         for await (const step of streamIterator) {
@@ -1049,9 +1175,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 HumanMessage2(message)] },
+          invokeConfig
+        );
         if (result?.messages && result.messages.length > 0) {
           const lastMessage = result.messages[result.messages.length - 1];
           const content = lastMessage?.content;
@@ -1149,6 +1276,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",
@@ -1169,7 +1311,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)) {
@@ -1225,6 +1366,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 {
@@ -1234,12 +1378,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,
@@ -1247,14 +1396,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();
@@ -1333,7 +1482,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 {
@@ -1427,12 +1576,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://postgres:postgres@localhost:5432/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
@@ -1474,11 +1750,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;
@@ -1613,10 +1889,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",
@@ -1657,10 +1933,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",
@@ -1880,6 +2156,7 @@ var nodes = [
   ManualTriggerNode,
   CronTriggerNode,
   DelayNode,
+  HttpRequestNode,
   HttpGetInputNode,
   // HttpPostInputNode,
   // TransformNode,
@@ -1890,6 +2167,8 @@ var nodes = [
   IaAgentNode,
   AiToolNode,
   AiSupervisorNode,
+  PostgresMemoryNode,
+  RedisMemoryNode,
   WhatsappSendTemplateNode,
   WhatsappSendMessageNode,
   WhatsappMessageTriggerNode,
@@ -2001,6 +2280,7 @@ var nodeFunctions = {
   CronTrigger: CronTriggerNodeFunction,
   HttpOutput: HttpOutputNodeFunction,
   ConcatNode: ConcatNodeFunction,
+  HttpRequestNode: HttpRequestNodeFunction,
   IaMessageNode: IaMessageNodeFunction,
   IaAgentNode: IaAgentNodeFunction,
   AiToolNode: AiToolNodeFunction,
@@ -2008,7 +2288,9 @@ var nodeFunctions = {
   WhatsappNode: WhatsappStartChatFunction,
   WhatsappSendMessageNode: WhatsappSendMessageFunction,
   CustomCodeNode: NodeFunction,
-  CustomNode: CustomNodeFunction
+  CustomNode: CustomNodeFunction,
+  PostgresMemoryNode: PostgresMemoryNodeFunction,
+  RedisMemoryNode: RedisMemoryNodeFunction
 };
 var node_functions_default = nodeFunctions;
 
@@ -2122,12 +2404,12 @@ var HttpPutInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/put/schema.ts
-var import_zod11 = require("zod");
-var HttpPutInputNodeSchema = import_zod11.z.object({
+var import_zod13 = require("zod");
+var HttpPutInputNodeSchema = import_zod13.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_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")
 });
 
 // src/nodes/inputs/http/delete/data.ts
@@ -2219,11 +2501,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_zod14 = require("zod");
+var HttpDeleteInputNodeSchema = import_zod14.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_zod14.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod14.z.array(HeaderSchema).optional().describe("Headers configuration")
 });
 
 // src/nodes/inputs/http/patch/data.ts
@@ -2336,12 +2618,12 @@ var HttpPatchInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/patch/schema.ts
-var import_zod13 = require("zod");
-var HttpPatchInputNodeSchema = import_zod13.z.object({
+var import_zod15 = require("zod");
+var HttpPatchInputNodeSchema = import_zod15.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_zod15.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod15.z.array(HeaderSchema).optional().describe("Headers configuration"),
+  body: import_zod15.z.array(BodyFieldSchema).optional().describe("Body fields configuration")
 });
 
 // src/nodes/inputs/http/utils.ts