@atomoz/workflows-nodes 0.1.27 → 0.1.29

package/dist/index.cjs

@@ -36,7 +36,13 @@ __export(index_exports, {
   AiToolNodeFunction: () => AiToolNodeFunction,
   AiToolNodeSchema: () => AiToolNodeSchema,
   BodyFieldSchema: () => BodyFieldSchema,
+  ChatLogNode: () => ChatLogNode,
+  ChatLogNodeFunction: () => ChatLogNodeFunction,
+  ChatLogSchema: () => ChatLogSchema,
   CustomToolSchema: () => CustomToolSchema,
+  GetOrCreateThreadNode: () => GetOrCreateThreadNode,
+  GetOrCreateThreadNodeFunction: () => GetOrCreateThreadNodeFunction,
+  GetOrCreateThreadSchema: () => GetOrCreateThreadSchema,
   HTTP_METHODS: () => HTTP_METHODS,
   HTTP_NODE_TYPES: () => HTTP_NODE_TYPES,
   HeaderSchema: () => HeaderSchema,
@@ -61,8 +67,13 @@ __export(index_exports, {
   IaMessageNode: () => IaMessageNode,
   IaMessageNodeFunction: () => IaMessageNodeFunction,
   IaMessageNodeSchema: () => IaMessageNodeSchema,
+  IsHumanActiveData: () => IsHumanActiveData,
   QueryParamSchema: () => QueryParamSchema,
   RouteSchema: () => RouteSchema,
+  SwitchNode: () => SwitchNode,
+  SwitchNodeFunction: () => SwitchNodeFunction,
+  VarNode: () => VarNode,
+  VarNodeFunction: () => VarNodeFunction,
   WhatsappMessageTriggerNode: () => WhatsappMessageTriggerNode,
   WhatsappSendMessageFunction: () => WhatsappSendMessageFunction,
   WhatsappSendMessageNode: () => WhatsappSendMessageNode,
@@ -82,6 +93,7 @@ __export(index_exports, {
   isHttpInputFriendlyId: () => isHttpInputFriendlyId,
   isHttpInputNode: () => isHttpInputNode,
   isHttpMethodNode: () => isHttpMethodNode,
+  isHumanActiveFunc: () => isHumanActiveFunc,
   nodeFunctions: () => node_functions_default,
   nodes: () => nodes_default,
   schemas: () => schemas
@@ -333,7 +345,11 @@ var ChatInputNodeFunction = (params) => {
   const { message: configMessage, chatId: configChatId } = fieldValues || {};
   const actualData = {
     message: request?.message ?? configMessage ?? "",
-    chatId: request?.chatId ?? configChatId ?? null
+    chatId: request?.chatId ?? configChatId ?? null,
+    roomId: request?.sessionId ?? request?.chatId ?? configChatId ?? null,
+    // Room = Session/Chat
+    source: "chat"
+    // Hardcoded source for web chat
   };
   if (!actualData.message || typeof actualData.message !== "string") {
     throw new Error("Message is required for ChatInputNode");
@@ -376,6 +392,33 @@ var ChatInputNode = {
         name: "chatId",
         fieldType: "string"
       }
+    },
+    {
+      id: "roomId",
+      label: "Room ID",
+      type: "string",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Room ID",
+        name: "roomId",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "source",
+      label: "Source",
+      type: "string",
+      required: false,
+      typeable: false,
+      defaultValue: "chat",
+      handle: {
+        type: "output",
+        label: "Source",
+        name: "source",
+        fieldType: "string"
+      }
     }
   ]
 };
@@ -1098,7 +1141,7 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
     case "gemini":
       return new import_google_gauth.ChatGoogle({
         model: "gemini-flash-latest",
-        apiKey: "AIzaSyAWj0Al2sVJ8vqaRN4UY7c6imAg7a3NbEc",
+        apiKey: "AIzaSyBLeXr43XWg1lOQfsUTZQ85IX-IYYpZIW0",
         streaming
       });
     case "openai":
@@ -1124,6 +1167,18 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
 }
 
 // src/utils/guardrail-executor.ts
+function emitGuardrailEvent(context, name, passed, action, details) {
+  if (context?.emitter?.emitThought) {
+    context.emitter.emitThought({
+      content: `guardrail:${passed ? "passed" : "failed"}:${name}`,
+      type: "guardrail",
+      name,
+      passed,
+      action: action || "evaluate",
+      details
+    });
+  }
+}
 async function loadChatHistory(context) {
   const checkpointer = context?.checkpointer;
   const sessionId = context?.sessionId;
@@ -1218,6 +1273,7 @@ async function executeGuardrails(guardrails, content, mode = "fail-first", conte
       if (!guardPassed && actionInstruction) {
         violationMessage = actionInstruction;
       }
+      emitGuardrailEvent(context, guard.name, guardPassed, guard.action, violationMessage || "Rule passed");
     } else if (guard.type === "function") {
       const { nodeFunction, name, actionInstruction } = guard;
       if (typeof nodeFunction === "function") {
@@ -1250,6 +1306,7 @@ async function executeGuardrails(guardrails, content, mode = "fail-first", conte
           guardPassed = false;
           violationMessage = `Erro na fun\xE7\xE3o guardrail: ${error instanceof Error ? error.message : String(error)}`;
         }
+        emitGuardrailEvent(context, name, guardPassed, guard.action, violationMessage || "Function passed");
       }
     } else if (guard.type === "model") {
       const { model, evaluationPrompt, name, actionInstruction } = guard;
@@ -1317,6 +1374,7 @@ Reescreva o conte\xFAdo corrigindo a viola\xE7\xE3o. Retorne APENAS o texto corr
                   message: violationMessage,
                   action: "fix"
                 });
+                emitGuardrailEvent(context, name, false, "fix", `Content fixed: ${fixedContent.slice(0, 100)}...`);
               } catch (fixError) {
                 console.error(`[GUARDRAIL LLM] Erro ao corrigir conte\xFAdo:`, fixError);
               }
@@ -1328,8 +1386,10 @@ Reescreva o conte\xFAdo corrigindo a viola\xE7\xE3o. Retorne APENAS o texto corr
               guardPassed = false;
               violationMessage = actionInstruction || `Modelo de avalia\xE7\xE3o "${name}" detectou viola\xE7\xE3o de seguran\xE7a/pol\xEDtica.`;
               console.log(`[GUARDRAIL LLM] Resultado: UNSAFE - Bloqueado`);
+              emitGuardrailEvent(context, name, false, guard.action, violationMessage);
             } else {
               console.log(`[GUARDRAIL LLM] Resultado: SAFE - Aprovado`);
+              emitGuardrailEvent(context, name, true, "approve", "Content passed evaluation");
             }
           }
         } catch (error) {
@@ -2034,7 +2094,8 @@ 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")
+  connectionString: import_zod8.z.string().describe("PostgreSQL connection string"),
+  threadId: import_zod8.z.string().optional().describe("Thread ID for conversation isolation")
 });
 var PostgresMemoryNode = {
   label: "Postgres Memory",
@@ -2056,6 +2117,20 @@ var PostgresMemoryNode = {
       defaultValue: "postgresql://yugabyte:yugabyte@localhost:5433/workflows",
       placeholder: "postgresql://user:pass@host:5432/database"
     },
+    {
+      id: "threadId",
+      label: "Thread ID",
+      type: "string",
+      required: false,
+      typeable: true,
+      placeholder: "Thread/Session ID for conversation isolation",
+      handle: {
+        type: "input",
+        label: "Thread ID",
+        name: "threadId",
+        fieldType: "string"
+      }
+    },
     {
       id: "checkpointer",
       label: "Checkpointer",
@@ -2078,12 +2153,15 @@ 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://yugabyte:yugabyte@localhost:5433/workflows";
+  const threadId = inputs.threadId ?? fieldValues.threadId;
   try {
     const checkpointer = import_langgraph_checkpoint_postgres.PostgresSaver.fromConnString(connectionString);
     await checkpointer.setup();
-    console.log("\u2705 PostgresMemory: Checkpointer initialized");
+    console.log(`\u2705 PostgresMemory: Checkpointer initialized${threadId ? ` with threadId: ${threadId}` : ""}`);
     return {
       checkpointer,
+      threadId,
+      // Pass threadId to agent for conversation isolation
       type: "PostgresMemoryNode",
       connectionString: connectionString.replace(/:[^:@]+@/, ":***@")
       // Hide password in output
@@ -2487,6 +2565,20 @@ var WhatsappMessageTriggerNode = {
         name: "message",
         fieldType: "string"
       }
+    },
+    {
+      id: "source",
+      label: "Source",
+      type: "string",
+      required: false,
+      typeable: false,
+      defaultValue: "whatsapp",
+      handle: {
+        type: "output",
+        label: "Source",
+        name: "source",
+        fieldType: "string"
+      }
     }
   ]
 };
@@ -3307,6 +3399,595 @@ var ModelGuardrailNodeFunction = async (inputs) => {
   };
 };
 
+// src/nodes/chat/getOrCreateThread/data.ts
+var import_zod17 = require("zod");
+var GetOrCreateThreadSchema = import_zod17.z.object({
+  source: import_zod17.z.string().describe("Channel source: whatsapp, telegram, web, etc."),
+  identifier: import_zod17.z.string().describe("User identifier: phone number, chat_id, userId"),
+  timeoutMinutes: import_zod17.z.number().optional().describe("Inactivity timeout in minutes (default: 1440 = 24h)")
+});
+var GetOrCreateThreadNode = {
+  label: "Get or Create Thread",
+  type: "GetOrCreateThreadNode",
+  category: "chat",
+  description: "Generates or retrieves a threadId based on identifier + timeout. Ensures tenant isolation.",
+  icon: "\u{1F9F5}",
+  group: "Chat",
+  tags: {
+    execution: "async",
+    group: "Chat"
+  },
+  fields: [
+    {
+      id: "source",
+      label: "Source",
+      type: "string",
+      required: true,
+      defaultValue: "whatsapp",
+      placeholder: "whatsapp, telegram, web",
+      handle: {
+        type: "input",
+        label: "Source",
+        name: "source",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "identifier",
+      label: "Identifier",
+      type: "string",
+      required: true,
+      placeholder: "+5511999999999",
+      handle: {
+        type: "input",
+        label: "Identifier",
+        name: "identifier",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "timeoutMinutes",
+      label: "Timeout (minutes)",
+      type: "number",
+      required: false,
+      defaultValue: "1440",
+      placeholder: "1440 (24 hours)"
+    },
+    {
+      id: "threadId",
+      label: "Thread ID",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Thread ID",
+        name: "threadId",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "isNew",
+      label: "Is New Thread",
+      type: "boolean",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Is New",
+        name: "isNew",
+        fieldType: "boolean"
+      }
+    }
+  ]
+};
+
+// src/nodes/chat/getOrCreateThread/function.ts
+var GetOrCreateThreadNodeFunction = async (inputs) => {
+  const fieldValues = inputs.fieldValues || {};
+  const context = inputs.context || {};
+  const source = fieldValues.source;
+  const identifier = fieldValues.identifier;
+  const timeoutMinutes = Number(fieldValues.timeoutMinutes) || 1440;
+  const companyId = context?.companyId;
+  if (!companyId) {
+    throw new Error("GetOrCreateThread requires companyId in context for tenant isolation");
+  }
+  if (!source || !identifier) {
+    throw new Error("GetOrCreateThread requires source and identifier");
+  }
+  const timeoutMs = timeoutMinutes * 60 * 1e3;
+  const thresholdDate = new Date(Date.now() - timeoutMs);
+  const db = context?.db;
+  if (!db) {
+    throw new Error("GetOrCreateThread requires database connection in context");
+  }
+  try {
+    const existingSessions = await db.query(`
+            SELECT id, session_id, updated_at 
+            FROM chat_sessions 
+            WHERE company_id = $1 
+              AND metadata->>'source' = $2 
+              AND metadata->>'identifier' = $3
+              AND updated_at > $4
+            ORDER BY updated_at DESC
+            LIMIT 1
+        `, [companyId, source, identifier, thresholdDate]);
+    if (existingSessions.rows && existingSessions.rows.length > 0) {
+      const session = existingSessions.rows[0];
+      await db.query(`
+                UPDATE chat_sessions 
+                SET updated_at = NOW() 
+                WHERE id = $1 AND company_id = $2
+            `, [session.id, companyId]);
+      return {
+        threadId: session.session_id,
+        isNew: false
+      };
+    }
+    const newSessionId = crypto.randomUUID();
+    const workflowId = context?.workflowId;
+    await db.query(`
+            INSERT INTO chat_sessions (workflow_id, company_id, chat_id, session_id, metadata)
+            VALUES ($1, $2, $3, $4, $5)
+        `, [
+      workflowId || companyId,
+      // fallback to companyId if no workflowId
+      companyId,
+      `${source}:${identifier}`,
+      // chatId as composite key
+      newSessionId,
+      JSON.stringify({ source, identifier })
+    ]);
+    return {
+      threadId: newSessionId,
+      isNew: true
+    };
+  } catch (error) {
+    console.error("[GetOrCreateThread] Error:", error);
+    throw error;
+  }
+};
+
+// src/nodes/chat/chatLog/data.ts
+var import_zod18 = require("zod");
+var ChatLogSchema = import_zod18.z.object({
+  threadId: import_zod18.z.string().describe("Thread ID from GetOrCreateThread"),
+  direction: import_zod18.z.enum(["inbound", "outbound"]).describe("Message direction"),
+  content: import_zod18.z.string().describe("Message content"),
+  source: import_zod18.z.string().optional().describe("Channel source"),
+  identifier: import_zod18.z.string().optional().describe("User identifier"),
+  metadata: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.any()).optional().describe("Additional metadata")
+});
+var ChatLogNode = {
+  label: "Chat Log",
+  type: "ChatLogNode",
+  category: "chat",
+  description: "Saves a message to the chat history. Supports inbound (user) and outbound (assistant) messages.",
+  icon: "\u{1F4AC}",
+  group: "Chat",
+  tags: {
+    execution: "async",
+    group: "Chat"
+  },
+  fields: [
+    {
+      id: "threadId",
+      label: "Thread ID",
+      type: "string",
+      required: true,
+      placeholder: "From GetOrCreateThread node",
+      handle: {
+        type: "input",
+        label: "Thread ID",
+        name: "threadId",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "direction",
+      label: "Direction",
+      type: "select",
+      required: true,
+      defaultValue: "inbound",
+      options: [
+        { label: "Inbound (User \u2192 System)", value: "inbound" },
+        { label: "Outbound (System \u2192 User)", value: "outbound" }
+      ]
+    },
+    {
+      id: "content",
+      label: "Content",
+      type: "string",
+      required: true,
+      placeholder: "Message content",
+      handle: {
+        type: "input",
+        label: "Content",
+        name: "content",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "source",
+      label: "Source",
+      type: "string",
+      required: false,
+      defaultValue: "whatsapp",
+      placeholder: "whatsapp, telegram, web",
+      handle: {
+        type: "input",
+        label: "Source",
+        name: "source",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "identifier",
+      label: "Identifier",
+      type: "string",
+      required: false,
+      placeholder: "+5511999999999",
+      handle: {
+        type: "input",
+        label: "Identifier",
+        name: "identifier",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "messageId",
+      label: "Message ID",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Message ID",
+        name: "messageId",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "success",
+      label: "Success",
+      type: "boolean",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Success",
+        name: "success",
+        fieldType: "boolean"
+      }
+    }
+  ]
+};
+
+// src/nodes/chat/chatLog/function.ts
+var ChatLogNodeFunction = async (inputs) => {
+  const fieldValues = inputs.fieldValues || {};
+  const context = inputs.context || {};
+  const threadId = fieldValues.threadId;
+  const direction = fieldValues.direction;
+  const content = fieldValues.content;
+  const source = fieldValues.source;
+  const identifier = fieldValues.identifier;
+  const companyId = context?.companyId;
+  if (!companyId) {
+    throw new Error("ChatLog requires companyId in context for tenant isolation");
+  }
+  if (!threadId || !content) {
+    throw new Error("ChatLog requires threadId and content");
+  }
+  const role = direction === "inbound" ? "user" : "assistant";
+  const db = context?.db;
+  if (!db) {
+    throw new Error("ChatLog requires database connection in context");
+  }
+  try {
+    const sessionResult = await db.query(`
+            SELECT id FROM chat_sessions 
+            WHERE session_id = $1 AND company_id = $2
+            LIMIT 1
+        `, [threadId, companyId]);
+    if (!sessionResult.rows || sessionResult.rows.length === 0) {
+      throw new Error(`Session not found for threadId: ${threadId}`);
+    }
+    const sessionId = sessionResult.rows[0].id;
+    const messageId = crypto.randomUUID();
+    await db.query(`
+            INSERT INTO chat_messages (id, session_id, role, content, metadata)
+            VALUES ($1, $2, $3, $4, $5)
+        `, [
+      messageId,
+      sessionId,
+      role,
+      content,
+      JSON.stringify({
+        direction,
+        source: source || null,
+        identifier: identifier || null
+      })
+    ]);
+    await db.query(`
+            UPDATE chat_sessions 
+            SET updated_at = NOW() 
+            WHERE id = $1 AND company_id = $2
+        `, [sessionId, companyId]);
+    return {
+      messageId,
+      success: true
+    };
+  } catch (error) {
+    console.error("[ChatLog] Error:", error);
+    return {
+      messageId: null,
+      success: false
+    };
+  }
+};
+
+// src/nodes/chat/isHumanActive/data.ts
+var IsHumanActiveData = {
+  label: "Is Human Active?",
+  type: "isHumanActive",
+  category: "chat",
+  description: "Checks if a human agent is currently handling the conversation (handoff mode).",
+  icon: "\u{1F464}",
+  group: "Chat",
+  tags: {
+    execution: "async",
+    group: "Chat"
+  },
+  fields: [
+    {
+      id: "threadId",
+      label: "Thread ID",
+      type: "string",
+      required: false,
+      typeable: true,
+      placeholder: "Session/Thread ID (optional, uses context if empty)",
+      handle: {
+        type: "input",
+        label: "Thread ID",
+        name: "threadId",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "active",
+      label: "Active",
+      type: "boolean",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Active",
+        name: "active",
+        fieldType: "continue"
+      }
+    },
+    {
+      id: "inactive",
+      label: "Inactive",
+      type: "boolean",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Inactive",
+        name: "inactive",
+        fieldType: "continue"
+      }
+    }
+  ]
+};
+
+// src/nodes/chat/isHumanActive/function.ts
+var isHumanActiveFunc = async (inputs) => {
+  const fieldValues = inputs.fieldValues || {};
+  const context = inputs.context || {};
+  const sessionId = inputs.threadId || fieldValues.threadId || context?.sessionId || context?.chatId;
+  if (!sessionId) {
+    console.warn("[IsHumanActive] No sessionId found in input or context.");
+    return {
+      active: false,
+      inactive: true
+    };
+  }
+  const db = context?.db;
+  if (!db) {
+    console.warn("[IsHumanActive] No database connection in context.");
+    return { active: false, inactive: true };
+  }
+  try {
+    const result = await db.query(`
+            SELECT human_active_until 
+            FROM chat_sessions 
+            WHERE session_id = $1
+            LIMIT 1
+        `, [sessionId]);
+    const session = result.rows?.[0];
+    if (!session) {
+      console.warn(`[IsHumanActive] Session not found: ${sessionId}`);
+      return { active: false, inactive: true };
+    }
+    const now = /* @__PURE__ */ new Date();
+    const isActive = session.human_active_until && new Date(session.human_active_until) > now;
+    console.log(`[IsHumanActive] Session: ${sessionId}, Until: ${session.human_active_until}, Active: ${isActive}`);
+    return {
+      active: !!isActive,
+      inactive: !isActive
+    };
+  } catch (error) {
+    console.error("[IsHumanActive] Error querying session:", error);
+    return { active: false, inactive: true };
+  }
+};
+
+// src/nodes/logic/varNode/data.ts
+var VarNode = {
+  label: "Variable",
+  type: "VarNode",
+  category: "logic",
+  description: "Stores a value from multiple inputs. Strategy: keep first or last value received.",
+  icon: "\u{1F4E6}",
+  group: "Control",
+  tags: {
+    execution: "sync",
+    group: "Control"
+  },
+  fields: [
+    {
+      id: "strategy",
+      label: "Strategy",
+      type: "select",
+      required: true,
+      defaultValue: "first",
+      options: [
+        { label: "First Value", value: "first" },
+        { label: "Last Value", value: "last" }
+      ]
+    },
+    {
+      id: "value",
+      label: "Value",
+      type: "any",
+      required: false,
+      typeable: true,
+      handle: {
+        type: "input",
+        label: "Value",
+        name: "value",
+        fieldType: "any",
+        maxConnections: 10
+        // Allow multiple connections
+      }
+    },
+    {
+      id: "output",
+      label: "Output",
+      type: "any",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Value",
+        name: "output",
+        fieldType: "any"
+      }
+    },
+    // Continue handle (hidden by default)
+    {
+      id: "continue",
+      label: "Continue",
+      type: "continue",
+      typeable: false,
+      active: false,
+      // Hidden by default
+      handle: {
+        type: "output",
+        label: "Continue",
+        name: "continue",
+        fieldType: "continue"
+      }
+    }
+  ]
+};
+
+// src/nodes/logic/varNode/function.ts
+var VarNodeFunction = async (inputs) => {
+  const fieldValues = inputs.fieldValues || {};
+  const strategy = fieldValues.strategy || "first";
+  let values = inputs.value ?? fieldValues.value;
+  if (!Array.isArray(values)) {
+    values = values !== void 0 ? [values] : [];
+  }
+  const validValues = values.filter((v) => v !== void 0 && v !== null);
+  if (validValues.length === 0) {
+    return { output: void 0, continue: true };
+  }
+  const result = strategy === "first" ? validValues[0] : validValues[validValues.length - 1];
+  return {
+    output: result,
+    continue: true
+  };
+};
+
+// src/nodes/logic/switchNode/data.ts
+var SwitchNode = {
+  label: "Switch",
+  type: "SwitchNode",
+  category: "logic",
+  description: "Routes execution based on input value. Each case triggers its corresponding path.",
+  icon: "\u{1F500}",
+  group: "Control",
+  tags: {
+    execution: "sync",
+    group: "Control"
+  },
+  fields: [
+    {
+      id: "value",
+      label: "Value",
+      type: "string",
+      required: true,
+      typeable: true,
+      placeholder: "Value to match",
+      handle: {
+        type: "input",
+        label: "Value",
+        name: "value",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "cases",
+      label: "Cases",
+      type: "keyValue",
+      required: true,
+      defaultValue: [
+        { key: "whatsapp", value: "WhatsApp" },
+        { key: "chat", value: "Web Chat" }
+      ],
+      placeholder: "Add cases (key = match value, value = label)"
+    },
+    {
+      id: "includeDefault",
+      label: "Include Default Path",
+      type: "boolean",
+      required: false,
+      defaultValue: true
+    }
+    // Note: Dynamic outputs are generated based on 'cases' at runtime
+    // Each case.key becomes an output handle of type 'continue'
+    // Plus optional 'default' output if includeDefault is true
+  ]
+};
+
+// src/nodes/logic/switchNode/function.ts
+var SwitchNodeFunction = async (inputs) => {
+  const fieldValues = inputs.fieldValues || {};
+  const inputValue = inputs.value ?? fieldValues.value;
+  const cases = fieldValues.cases || [];
+  const includeDefault = fieldValues.includeDefault ?? true;
+  const outputs = {};
+  for (const c of cases) {
+    outputs[c.key] = false;
+  }
+  if (includeDefault) {
+    outputs["default"] = false;
+  }
+  const matchedCase = cases.find((c) => c.key === inputValue);
+  if (matchedCase) {
+    outputs[matchedCase.key] = true;
+  } else if (includeDefault) {
+    outputs["default"] = true;
+  }
+  return outputs;
+};
+
 // src/nodes/consts/nodes.ts
 var nodes = [
   ChatInputNode,
@@ -3333,7 +4014,12 @@ var nodes = [
   PromptGuardrailNode,
   RuleGuardrailNode,
   FunctionGuardrailNode,
-  ModelGuardrailNode
+  ModelGuardrailNode,
+  GetOrCreateThreadNode,
+  ChatLogNode,
+  IsHumanActiveData,
+  VarNode,
+  SwitchNode
 ];
 var nodes_default = nodes;
 
@@ -3455,7 +4141,12 @@ var nodeFunctions = {
   PromptGuardrailNode: PromptGuardrailNodeFunction,
   RuleGuardrailNode: RuleGuardrailNodeFunction,
   FunctionGuardrailNode: FunctionGuardrailNodeFunction,
-  ModelGuardrailNode: ModelGuardrailNodeFunction
+  ModelGuardrailNode: ModelGuardrailNodeFunction,
+  GetOrCreateThreadNode: GetOrCreateThreadNodeFunction,
+  ChatLogNode: ChatLogNodeFunction,
+  isHumanActive: isHumanActiveFunc,
+  VarNode: VarNodeFunction,
+  SwitchNode: SwitchNodeFunction
 };
 var node_functions_default = nodeFunctions;
 
@@ -3569,12 +4260,12 @@ var HttpPutInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/put/schema.ts
-var import_zod17 = require("zod");
-var HttpPutInputNodeSchema = import_zod17.z.object({
+var import_zod19 = require("zod");
+var HttpPutInputNodeSchema = import_zod19.z.object({
   route: RouteSchema,
-  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")
+  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/delete/data.ts
@@ -3666,11 +4357,11 @@ var HttpDeleteInputNodeFunction = async (params) => {
 };
 
 // src/nodes/inputs/http/delete/schema.ts
-var import_zod18 = require("zod");
-var HttpDeleteInputNodeSchema = import_zod18.z.object({
+var import_zod20 = require("zod");
+var HttpDeleteInputNodeSchema = import_zod20.z.object({
   route: RouteSchema,
-  queryParams: import_zod18.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: import_zod18.z.array(HeaderSchema).optional().describe("Headers configuration")
+  queryParams: import_zod20.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod20.z.array(HeaderSchema).optional().describe("Headers configuration")
 });
 
 // src/nodes/inputs/http/patch/data.ts
@@ -3783,12 +4474,12 @@ var HttpPatchInputNodeFunction = (params) => {
 };
 
 // src/nodes/inputs/http/patch/schema.ts
-var import_zod19 = require("zod");
-var HttpPatchInputNodeSchema = import_zod19.z.object({
+var import_zod21 = require("zod");
+var HttpPatchInputNodeSchema = import_zod21.z.object({
   route: RouteSchema,
-  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")
+  queryParams: import_zod21.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod21.z.array(HeaderSchema).optional().describe("Headers configuration"),
+  body: import_zod21.z.array(BodyFieldSchema).optional().describe("Body fields configuration")
 });
 
 // src/nodes/inputs/http/utils.ts
@@ -3848,7 +4539,13 @@ var getHttpMethodFromFriendlyId = (friendlyId) => {
   AiToolNodeFunction,
   AiToolNodeSchema,
   BodyFieldSchema,
+  ChatLogNode,
+  ChatLogNodeFunction,
+  ChatLogSchema,
   CustomToolSchema,
+  GetOrCreateThreadNode,
+  GetOrCreateThreadNodeFunction,
+  GetOrCreateThreadSchema,
   HTTP_METHODS,
   HTTP_NODE_TYPES,
   HeaderSchema,
@@ -3873,8 +4570,13 @@ var getHttpMethodFromFriendlyId = (friendlyId) => {
   IaMessageNode,
   IaMessageNodeFunction,
   IaMessageNodeSchema,
+  IsHumanActiveData,
   QueryParamSchema,
   RouteSchema,
+  SwitchNode,
+  SwitchNodeFunction,
+  VarNode,
+  VarNodeFunction,
   WhatsappMessageTriggerNode,
   WhatsappSendMessageFunction,
   WhatsappSendMessageNode,
@@ -3894,6 +4596,7 @@ var getHttpMethodFromFriendlyId = (friendlyId) => {
   isHttpInputFriendlyId,
   isHttpInputNode,
   isHttpMethodNode,
+  isHumanActiveFunc,
   nodeFunctions,
   nodes,
   schemas