@atomoz/workflows-nodes 0.1.19 → 0.1.20

package/dist/index.js

@@ -890,6 +890,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",
@@ -969,10 +984,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.");
   }
@@ -1003,17 +1022,26 @@ IMPORTANT: You must base your response on the last message in the conversation h
   const agent = 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) {
@@ -1057,9 +1085,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;
@@ -1157,6 +1186,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",
@@ -1176,8 +1220,7 @@ var AiSupervisorNode = {
 // src/nodes/ia/supervisor/function.ts
 import { createSupervisor } from "@langchain/langgraph-supervisor";
 import { HumanMessage } from "@langchain/core/messages";
-import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
-var checkpointer = new MemorySaver();
+import { InMemoryStore } from "@langchain/langgraph";
 var store = new InMemoryStore();
 var extractSupervisorAgents = (agents) => {
   if (Array.isArray(agents)) {
@@ -1233,6 +1276,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 {
@@ -1242,12 +1288,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 = createSupervisor({
       llm: llmInstance,
@@ -1255,14 +1306,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 HumanMessage({ content: message })] },
-          { recursionLimit: 150, configurable: { thread_id: "conversation" } }
+          { recursionLimit: 150, configurable: { thread_id: sessionId } }
         );
         let finalMessages = [];
         const previousStepMessages = /* @__PURE__ */ new Map();
@@ -1341,7 +1392,7 @@ var AiSupervisorNodeFunction = async (params) => {
     } else {
       const result = await app.invoke(
         { messages: [new HumanMessage({ content: message })] },
-        { recursionLimit: 150, configurable: { thread_id: "conversation" } }
+        { recursionLimit: 150, configurable: { thread_id: sessionId } }
       );
       const finalResponse = extractFinalResponse(result?.messages);
       return {
@@ -1435,12 +1486,139 @@ var AiToolNode = {
 // src/nodes/ia/tool/function.ts
 import { tool } from "@langchain/core/tools";
 
+// src/nodes/memory/postgres/data.ts
+import { z as z8 } from "zod";
+var PostgresMemoryNodeSchema = z8.object({
+  connectionString: z8.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
+import { PostgresSaver } from "@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 = 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
+import { z as z9 } from "zod";
+var RedisMemoryNodeSchema = z9.object({
+  redisUrl: z9.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
+import { RedisSaver } from "@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 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
@@ -1482,11 +1660,11 @@ var AiToolNodeFunction = async (params) => {
 };
 
 // src/nodes/ia/message/message.ts
-import { z as z8 } from "zod";
-var IaMessageNodeSchema = z8.object({
-  model: z8.any().describe("LLM model to use"),
-  systemMessage: z8.string().optional().describe("System message for context"),
-  message: z8.string().describe("User message to send to the LLM")
+import { z as z10 } from "zod";
+var IaMessageNodeSchema = z10.object({
+  model: z10.any().describe("LLM model to use"),
+  systemMessage: z10.string().optional().describe("System message for context"),
+  message: z10.string().describe("User message to send to the LLM")
 });
 var IaMessageNodeFunction = async (inputs) => {
   const { $field: _$field, $req: _$req, $inputs: _$inputs_var, $vars: _$vars } = inputs;
@@ -1621,10 +1799,10 @@ var IaMessageNode = {
 };
 
 // src/nodes/social/whatsapp/send-template/data.ts
-import { z as z9 } from "zod";
-var WhatsappSendTemplateNodeSchema = z9.object({
-  phoneNumber: z9.string().describe("Phone number to send the message to"),
-  message: z9.string().describe("Message to send")
+import { z as z11 } from "zod";
+var WhatsappSendTemplateNodeSchema = z11.object({
+  phoneNumber: z11.string().describe("Phone number to send the message to"),
+  message: z11.string().describe("Message to send")
 });
 var WhatsappSendTemplateNode = {
   label: "Whatsapp Send Template",
@@ -1665,10 +1843,10 @@ var WhatsappSendTemplateNode = {
 };
 
 // src/nodes/social/whatsapp/send-message/data.ts
-import { z as z10 } from "zod";
-var WhatsappSendMessageNodeSchema = z10.object({
-  phoneNumber: z10.string().describe("Phone number to send the message to"),
-  message: z10.string().describe("Message content to send")
+import { z as z12 } from "zod";
+var WhatsappSendMessageNodeSchema = z12.object({
+  phoneNumber: z12.string().describe("Phone number to send the message to"),
+  message: z12.string().describe("Message content to send")
 });
 var WhatsappSendMessageNode = {
   label: "Whatsapp Send Message",
@@ -1899,6 +2077,8 @@ var nodes = [
   IaAgentNode,
   AiToolNode,
   AiSupervisorNode,
+  PostgresMemoryNode,
+  RedisMemoryNode,
   WhatsappSendTemplateNode,
   WhatsappSendMessageNode,
   WhatsappMessageTriggerNode,
@@ -2018,7 +2198,9 @@ var nodeFunctions = {
   WhatsappNode: WhatsappStartChatFunction,
   WhatsappSendMessageNode: WhatsappSendMessageFunction,
   CustomCodeNode: NodeFunction,
-  CustomNode: CustomNodeFunction
+  CustomNode: CustomNodeFunction,
+  PostgresMemoryNode: PostgresMemoryNodeFunction,
+  RedisMemoryNode: RedisMemoryNodeFunction
 };
 var node_functions_default = nodeFunctions;
 
@@ -2132,12 +2314,12 @@ var HttpPutInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/put/schema.ts
-import { z as z11 } from "zod";
-var HttpPutInputNodeSchema = z11.object({
+import { z as z13 } from "zod";
+var HttpPutInputNodeSchema = z13.object({
   route: RouteSchema,
-  queryParams: z11.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z11.array(HeaderSchema).optional().describe("Headers configuration"),
-  body: z11.array(BodyFieldSchema).optional().describe("Body fields configuration")
+  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")
 });
 
 // src/nodes/inputs/http/delete/data.ts
@@ -2229,11 +2411,11 @@ var HttpDeleteInputNodeFunction = async (params) => {
 };
 
 // src/nodes/inputs/http/delete/schema.ts
-import { z as z12 } from "zod";
-var HttpDeleteInputNodeSchema = z12.object({
+import { z as z14 } from "zod";
+var HttpDeleteInputNodeSchema = z14.object({
   route: RouteSchema,
-  queryParams: z12.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z12.array(HeaderSchema).optional().describe("Headers configuration")
+  queryParams: z14.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: z14.array(HeaderSchema).optional().describe("Headers configuration")
 });
 
 // src/nodes/inputs/http/patch/data.ts
@@ -2346,12 +2528,12 @@ var HttpPatchInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/patch/schema.ts
-import { z as z13 } from "zod";
-var HttpPatchInputNodeSchema = z13.object({
+import { z as z15 } from "zod";
+var HttpPatchInputNodeSchema = z15.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: 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")
 });
 
 // src/nodes/inputs/http/utils.ts

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atomoz/workflows-nodes",
-    "version": "0.1.19",
+    "version": "0.1.20",
     "description": "Atomoz Workflows - Node Library",
     "type": "module",
     "main": "./dist/index.js",
@@ -32,8 +32,8 @@
     "author": "Atomoz",
     "license": "MIT",
     "scripts": {
-        "build": "tsup index.ts --dts --format esm,cjs --target node18 --out-dir dist --clean --tsconfig tsconfig.build.json",
-        "dev": "tsup index.ts --dts --format esm,cjs --target node18 --out-dir dist --watch --tsconfig tsconfig.build.json"
+        "build": "tsup",
+        "dev": "tsup --watch"
     },
     "peerDependencies": {
         "zod": ">=3.0.0 || >=4.0.0"
@@ -42,11 +42,14 @@
         "@langchain/core": "^0.3.66",
         "@langchain/google-gauth": "^0.2.16",
         "@langchain/langgraph": "^0.4.3",
+        "@langchain/langgraph-checkpoint-postgres": "^1.0.0",
+        "@langchain/langgraph-checkpoint-redis": "^1.0.1",
         "@langchain/langgraph-supervisor": "^0.0.17",
         "@langchain/openai": "^0.6.3",
         "graphql-request": "^7.2.0"
     },
     "devDependencies": {
+        "@types/node": "^25.0.3",
         "tsup": "^8.2.4",
         "typescript": "^5.6.3",
         "zod": "^4.0.14"