@atomoz/workflows-nodes 0.1.15 → 0.1.17

package/dist/index.cjs

@@ -0,0 +1,2394 @@
+"use strict";
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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
+var index_exports = {};
+__export(index_exports, {
+  AiSupervisorNode: () => AiSupervisorNode,
+  AiSupervisorNodeFunction: () => AiSupervisorNodeFunction,
+  AiSupervisorNodeSchema: () => AiSupervisorNodeSchema,
+  AiToolNode: () => AiToolNode,
+  AiToolNodeFunction: () => AiToolNodeFunction,
+  AiToolNodeSchema: () => AiToolNodeSchema,
+  BodyFieldSchema: () => BodyFieldSchema,
+  CustomToolSchema: () => CustomToolSchema,
+  HTTP_METHODS: () => HTTP_METHODS,
+  HTTP_NODE_TYPES: () => HTTP_NODE_TYPES,
+  HeaderSchema: () => HeaderSchema,
+  HttpDeleteInputNode: () => HttpDeleteInputNode,
+  HttpDeleteInputNodeFunction: () => HttpDeleteInputNodeFunction,
+  HttpDeleteInputNodeSchema: () => HttpDeleteInputNodeSchema,
+  HttpGetInputNode: () => HttpGetInputNode,
+  HttpGetInputNodeFunction: () => HttpGetInputNodeFunction,
+  HttpGetInputNodeSchema: () => HttpGetInputNodeSchema,
+  HttpPatchInputNode: () => HttpPatchInputNode,
+  HttpPatchInputNodeFunction: () => HttpPatchInputNodeFunction,
+  HttpPatchInputNodeSchema: () => HttpPatchInputNodeSchema,
+  HttpPostInputNode: () => HttpPostInputNode,
+  HttpPostInputNodeFunction: () => HttpPostInputNodeFunction,
+  HttpPostInputNodeSchema: () => HttpPostInputNodeSchema,
+  HttpPutInputNode: () => HttpPutInputNode,
+  HttpPutInputNodeFunction: () => HttpPutInputNodeFunction,
+  HttpPutInputNodeSchema: () => HttpPutInputNodeSchema,
+  IaAgentNode: () => IaAgentNode,
+  IaAgentNodeFunction: () => IaAgentNodeFunction,
+  IaAgentNodeSchema: () => IaAgentNodeSchema,
+  IaMessageNode: () => IaMessageNode,
+  IaMessageNodeFunction: () => IaMessageNodeFunction,
+  IaMessageNodeSchema: () => IaMessageNodeSchema,
+  QueryParamSchema: () => QueryParamSchema,
+  RouteSchema: () => RouteSchema,
+  WhatsappMessageTriggerNode: () => WhatsappMessageTriggerNode,
+  WhatsappSendMessageFunction: () => WhatsappSendMessageFunction,
+  WhatsappSendMessageNode: () => WhatsappSendMessageNode,
+  WhatsappSendMessageNodeSchema: () => WhatsappSendMessageNodeSchema,
+  WhatsappSendTemplateNode: () => WhatsappSendTemplateNode,
+  WhatsappSendTemplateNodeSchema: () => WhatsappSendTemplateNodeSchema,
+  WhatsappStartChatFunction: () => WhatsappStartChatFunction,
+  createMessageTemplate: () => createMessageTemplate,
+  extractHttpMethodFromNodeType: () => extractHttpMethodFromNodeType,
+  getHttpMethodFromFriendlyId: () => getHttpMethodFromFriendlyId,
+  getHttpMethodFromNodeType: () => getHttpMethodFromNodeType,
+  getHttpNodeTypeStrings: () => getHttpNodeTypeStrings,
+  getHttpNodeTypesArray: () => getHttpNodeTypesArray,
+  getHttpNodesTypes: () => getHttpNodesTypes,
+  getMessageTemplates: () => getMessageTemplates,
+  isAnyHttpInputNode: () => isAnyHttpInputNode,
+  isHttpInputFriendlyId: () => isHttpInputFriendlyId,
+  isHttpInputNode: () => isHttpInputNode,
+  isHttpMethodNode: () => isHttpMethodNode,
+  nodeFunctions: () => node_functions_default,
+  nodes: () => nodes_default,
+  schemas: () => schemas
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/nodes/inputs/http/get/data.ts
+var HttpGetInputNode = {
+  label: "Http GET Input",
+  type: "HttpGetInput",
+  category: "input",
+  icon: "\u{1F310}",
+  description: "Node que representa uma rota GET HTTP e recebe query/path parameters",
+  group: "HTTP",
+  tags: {
+    execution: "sync",
+    group: "HTTP"
+  },
+  fields: [
+    {
+      id: "route",
+      label: "Route",
+      type: "route",
+      required: true,
+      placeholder: "/produtos/{id}"
+    },
+    {
+      id: "queryParams",
+      label: "Query Params",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Query Params",
+        name: "queryParams",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "headers",
+      label: "Headers",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Headers",
+        name: "headers",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "ip",
+      label: "Request IP",
+      type: "string",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "IP",
+        name: "ip",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/inputs/http/get/function.ts
+var HttpGetInputNodeFunction = async (params) => {
+  const { $field: _$field, $req, $inputs: _$inputs, $vars: _$vars } = params;
+  const request = $req || params.request;
+  const fieldValues = params.fieldValues || {};
+  const { queryParams: configQueryParams, headers: configHeaders } = fieldValues || {};
+  const actualData = {
+    queryParams: request?.query || {},
+    headers: request?.headers || {},
+    ip: request?.ip || "127.0.0.1"
+  };
+  if (configQueryParams) {
+    const requiredParams = configQueryParams.filter((p) => p.required);
+    const missingParams = requiredParams.filter((p) => !actualData.queryParams[p.key]);
+    if (missingParams.length > 0) {
+      throw new Error(`Par\xE2metros obrigat\xF3rios ausentes: ${missingParams.map((p) => p.key).join(", ")}`);
+    }
+  }
+  if (configHeaders) {
+    const requiredHeaders = configHeaders.filter((h) => h.required);
+    const missingHeaders = requiredHeaders.filter((h) => !actualData.headers[h.key.toLowerCase()]);
+    if (missingHeaders.length > 0) {
+      throw new Error(`Headers obrigat\xF3rios ausentes: ${missingHeaders.map((h) => h.key).join(", ")}`);
+    }
+  }
+  return actualData;
+};
+
+// src/nodes/inputs/http/get/schema.ts
+var import_zod2 = require("zod");
+
+// src/nodes/inputs/http/schemas.ts
+var import_zod = require("zod");
+var QueryParamSchema = import_zod.z.object({
+  key: import_zod.z.string(),
+  value: import_zod.z.string().optional(),
+  required: import_zod.z.boolean().optional()
+});
+var HeaderSchema = import_zod.z.object({
+  key: import_zod.z.string(),
+  value: import_zod.z.string().optional(),
+  required: import_zod.z.boolean().optional()
+});
+var BodyFieldSchema = import_zod.z.object({
+  key: import_zod.z.string(),
+  value: import_zod.z.any().optional(),
+  required: import_zod.z.boolean().optional()
+});
+var RouteSchema = import_zod.z.string().describe("HTTP route path");
+
+// src/nodes/inputs/http/get/schema.ts
+var HttpGetInputNodeSchema = import_zod2.z.object({
+  route: RouteSchema,
+  queryParams: import_zod2.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod2.z.array(HeaderSchema).optional().describe("Headers configuration")
+});
+
+// src/nodes/inputs/http/post/data.ts
+var HttpPostInputNode = {
+  label: "Http POST Input",
+  type: "HttpPostInput",
+  category: "input",
+  icon: "\u{1F4E4}",
+  description: "Node que representa uma rota POST HTTP e recebe dados no body",
+  tags: {
+    execution: "sync",
+    group: "HTTP"
+  },
+  fields: [
+    {
+      id: "route",
+      label: "Route",
+      type: "route",
+      required: true,
+      placeholder: "/produtos/{id}"
+    },
+    {
+      id: "queryParams",
+      label: "Query Params",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Query Params",
+        name: "queryParams",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "headers",
+      label: "Headers",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Headers",
+        name: "headers",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "body",
+      label: "Body",
+      type: "object",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Body",
+        name: "body",
+        fieldType: "object",
+        required: false
+      }
+    },
+    {
+      id: "ip",
+      label: "Request IP",
+      type: "string",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "IP",
+        name: "ip",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/inputs/http/post/function.ts
+var HttpPostInputNodeFunction = (params) => {
+  const { $field: _$field, $req, $inputs: _$inputs, $vars: _$vars } = params;
+  const request = $req || params.request;
+  const fieldValues = params.fieldValues || {};
+  const { queryParams: configQueryParams, headers: configHeaders, body: configBody } = fieldValues || {};
+  if (request.method !== "POST") {
+    throw new Error("M\xE9todo HTTP inv\xE1lido");
+  }
+  const actualData = {
+    queryParams: request?.query || {},
+    headers: request?.headers || {},
+    body: request?.body || {},
+    ip: request?.ip || "127.0.0.1"
+  };
+  if (configQueryParams) {
+    const requiredParams = configQueryParams.filter((p) => p.required);
+    const missingParams = requiredParams.filter((p) => !actualData.queryParams[p.key]);
+    if (missingParams.length > 0) {
+      throw new Error(`Par\xE2metros obrigat\xF3rios ausentes: ${missingParams.map((p) => p.key).join(", ")}`);
+    }
+  }
+  if (configHeaders) {
+    const requiredHeaders = configHeaders.filter((h) => h.required);
+    const missingHeaders = requiredHeaders.filter((h) => !actualData.headers[h.key.toLowerCase()]);
+    if (missingHeaders.length > 0) {
+      throw new Error(`Headers obrigat\xF3rios ausentes: ${missingHeaders.map((h) => h.key).join(", ")}`);
+    }
+  }
+  if (configBody) {
+    const requiredBodyFields = configBody.filter((f) => f.required);
+    const missingBodyFields = requiredBodyFields.filter((f) => !actualData.body[f.key]);
+    if (missingBodyFields.length > 0) {
+      throw new Error(`Campos obrigat\xF3rios do body ausentes: ${missingBodyFields.map((f) => f.key).join(", ")}`);
+    }
+  }
+  return actualData;
+};
+
+// src/nodes/inputs/http/post/schema.ts
+var import_zod3 = require("zod");
+var HttpPostInputNodeSchema = import_zod3.z.object({
+  route: RouteSchema,
+  queryParams: import_zod3.z.array(QueryParamSchema).optional().describe("Query parameters configuration"),
+  headers: import_zod3.z.array(HeaderSchema).optional().describe("Headers configuration"),
+  body: import_zod3.z.array(BodyFieldSchema).optional().describe("Body fields configuration")
+});
+
+// src/nodes/inputs/chat/chat.ts
+var ChatInputNodeFunction = (params) => {
+  const { $field: _$field, $req, $inputs: _$inputs, $vars: _$vars } = params;
+  const request = $req || params.request;
+  const fieldValues = params.fieldValues || {};
+  const { message: configMessage, chatId: configChatId } = fieldValues || {};
+  const actualData = {
+    message: request?.message ?? configMessage ?? "",
+    chatId: request?.chatId ?? configChatId ?? null
+  };
+  if (!actualData.message || typeof actualData.message !== "string") {
+    throw new Error("Message is required for ChatInputNode");
+  }
+  return actualData;
+};
+var ChatInputNode = {
+  label: "Chat Input",
+  type: "ChatInput",
+  category: "input",
+  icon: "\u{1F4AC}",
+  description: "Entrada de mensagem de chat para iniciar conversas com IA",
+  tags: {
+    execution: "sync",
+    group: "IA"
+  },
+  fields: [
+    {
+      id: "message",
+      label: "Message",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Message",
+        name: "message",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "chatId",
+      label: "Chat ID",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Chat ID",
+        name: "chatId",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/inputs/manual/trigger.ts
+var ManualTriggerNodeFunction = (params) => {
+  const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = params;
+  const fieldValues = params.fieldValues || {};
+  return fieldValues || {};
+};
+var ManualTriggerNode = {
+  label: "Manual Trigger",
+  type: "ManualTrigger",
+  category: "input",
+  icon: "\u{1F590}\uFE0F",
+  description: "Dispara fluxo manualmente e envia campos din\xE2micos",
+  tags: {
+    execution: "sync",
+    group: "Custom"
+  },
+  fields: [
+    {
+      id: "stringExample",
+      label: "String Example",
+      type: "string",
+      handle: { type: "output", label: "String", name: "stringExample", fieldType: "string" },
+      placeholder: "Ex.: valor literal"
+    },
+    {
+      id: "numberExample",
+      label: "Number Example",
+      type: "number",
+      handle: { type: "output", label: "Number", name: "numberExample", fieldType: "number" },
+      placeholder: "Ex.: 123"
+    },
+    {
+      id: "keyValue1",
+      label: "Key/Value 1",
+      type: "keyValue",
+      handle: { type: "output", label: "Key/Value", name: "keyValue1", fieldType: "keyValue" }
+    }
+  ]
+};
+
+// src/nodes/inputs/cron/trigger.ts
+var CronTriggerNodeFunction = (params) => {
+  const { $req } = params;
+  const triggerData = $req || {};
+  const fieldValues = params.fieldValues || {};
+  return {
+    triggeredAt: triggerData.triggeredAt || (/* @__PURE__ */ new Date()).toISOString(),
+    scheduleId: triggerData.scheduleId || null,
+    cronExpression: fieldValues.cronExpression || null,
+    timezone: fieldValues.timezone || "America/Sao_Paulo",
+    success: true
+  };
+};
+var CronTriggerNode = {
+  label: "Cron Trigger",
+  type: "CronTrigger",
+  category: "input",
+  icon: "\u23F0",
+  description: "Dispara fluxo automaticamente baseado em express\xE3o cron",
+  tags: {
+    execution: "async",
+    group: "Custom"
+  },
+  fields: [
+    {
+      id: "cronExpression",
+      label: "Express\xE3o Cron",
+      type: "string",
+      required: true,
+      placeholder: "0 9 * * *  (todos os dias \xE0s 9h)"
+    },
+    {
+      id: "timezone",
+      label: "Timezone",
+      type: "select",
+      defaultValue: "America/Sao_Paulo",
+      options: [
+        { label: "S\xE3o Paulo (GMT-3)", value: "America/Sao_Paulo" },
+        { label: "UTC", value: "UTC" },
+        { label: "New York (GMT-5)", value: "America/New_York" },
+        { label: "Los Angeles (GMT-8)", value: "America/Los_Angeles" },
+        { label: "London (GMT+0)", value: "Europe/London" }
+      ]
+    },
+    {
+      id: "triggeredAt",
+      label: "Triggered At",
+      type: "string",
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Triggered At",
+        name: "triggeredAt",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "scheduleId",
+      label: "Schedule ID",
+      type: "string",
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Schedule ID",
+        name: "scheduleId",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/processors/concat.ts
+var import_zod4 = require("zod");
+var ConcatNodeFunction = (params) => {
+  const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = params;
+  const inputs_resolved = params.inputs || params || {};
+  const input1 = inputs_resolved.input1 || "";
+  const input2 = inputs_resolved.input2 || "";
+  const result = `${input1}${input2}`;
+  return {
+    output: result,
+    function: ConcatNodeFunction,
+    type: "ConcatNode"
+  };
+};
+var ConcatNodeSchema = import_zod4.z.object({
+  input1: import_zod4.z.string(),
+  input2: import_zod4.z.string()
+});
+var ConcatNode = {
+  label: "Concat Data",
+  type: "ConcatNode",
+  category: "step",
+  icon: "\u{1F504}",
+  description: "Node para concatenar dados de entrada",
+  toolable: true,
+  fields: [
+    {
+      id: "input1",
+      label: "Input 1",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Input 1",
+        name: "input1",
+        fieldType: "string",
+        required: true
+      }
+    },
+    {
+      id: "input2",
+      label: "Input 2",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Input 2",
+        name: "input2",
+        fieldType: "string",
+        required: true
+      }
+    },
+    {
+      id: "output",
+      label: "Output",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Output",
+        name: "output",
+        fieldType: "string",
+        required: true
+      }
+    }
+  ]
+};
+
+// src/nodes/output-node/index.ts
+var HttpOutputNodeFunction = (params) => {
+  const { fieldValues, results } = params;
+  let responseData = fieldValues?.data || {};
+  if (typeof responseData === "object" && responseData !== null) {
+    const processedData = {};
+    for (const [key, value] of Object.entries(responseData)) {
+      if (typeof value === "string" && value.includes("{{")) {
+        processedData[key] = processPlaceholders(value, results);
+      } else {
+        processedData[key] = value;
+      }
+    }
+    responseData = processedData;
+  } else if (typeof responseData === "string") {
+    responseData = { value: responseData };
+  }
+  const status = fieldValues?.status || 200;
+  const headers = fieldValues?.headers || {};
+  if (status && (status < 100 || status > 599)) {
+    throw new Error(`Status HTTP inv\xE1lido: ${status}`);
+  }
+  return {
+    status,
+    headers,
+    data: responseData,
+    isHttpResponse: true
+  };
+};
+function processPlaceholders(value, results) {
+  return value.replace(/\{\{(.*?)\}\}/g, (match, placeholder) => {
+    const parts = placeholder.split("-");
+    const friendlyId = parts[0];
+    const fieldName = parts[1];
+    const keyName = parts.length > 2 ? parts[2] : void 0;
+    const sourceResult = results[friendlyId];
+    if (sourceResult) {
+      if (keyName) {
+        return sourceResult[fieldName]?.[keyName] || keyName;
+      } else {
+        return sourceResult[fieldName] || "";
+      }
+    }
+    return match;
+  });
+}
+var OutputNode = {
+  label: "Http Output Node",
+  type: "HttpOutput",
+  category: "output",
+  icon: "\u{1F4E4}",
+  description: "Node de sa\xEDda do workflow que aceita qualquer entrada e retorna ela diretamente",
+  group: "HTTP",
+  tags: {
+    execution: "sync",
+    group: "HTTP"
+  },
+  fields: [
+    {
+      id: "status",
+      label: "Status Code",
+      type: "select",
+      required: true,
+      defaultValue: 200,
+      options: [
+        { label: "200 - OK", value: 200 },
+        { label: "201 - Created", value: 201 },
+        { label: "204 - No Content", value: 204 },
+        { label: "400 - Bad Request", value: 400 },
+        { label: "401 - Unauthorized", value: 401 },
+        { label: "403 - Forbidden", value: 403 },
+        { label: "404 - Not Found", value: 404 },
+        { label: "422 - Unprocessable Entity", value: 422 },
+        { label: "500 - Internal Server Error", value: 500 }
+      ],
+      handle: {
+        type: "output",
+        label: "Status",
+        name: "status",
+        fieldType: "number",
+        required: true
+      }
+    },
+    {
+      id: "headers",
+      label: "Response Headers",
+      type: "keyValue",
+      required: false,
+      defaultValue: {},
+      handle: {
+        type: "output",
+        label: "Headers",
+        name: "headers",
+        fieldType: "object",
+        required: false
+      }
+    },
+    {
+      id: "data",
+      label: "Response Data",
+      type: "json",
+      required: true,
+      handle: {
+        type: "input",
+        label: "Data",
+        name: "data",
+        fieldType: "json",
+        required: true
+      }
+    }
+  ]
+};
+
+// src/nodes/outputs/chat/output.ts
+var ChatOutputNodeFunction = async (params) => {
+  const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = params;
+  const inputs_resolved = params.inputs || {};
+  const fieldValues = params.fieldValues || {};
+  const stream = params.stream;
+  const emitter = params.emitter;
+  const content = inputs_resolved?.data ?? fieldValues?.data ?? "";
+  if (stream && emitter) {
+    try {
+      emitter.emitDone({ content });
+    } catch (_e) {
+      try {
+        emitter.emitDone({ content });
+      } catch (err) {
+        console.debug("ChatOutput emitDone error", err);
+      }
+    }
+  }
+  return {
+    output: content,
+    type: "ChatOutput"
+  };
+};
+var ChatOutputNode = {
+  label: "Chat Output",
+  type: "ChatOutput",
+  category: "output",
+  icon: "\u{1F4E4}",
+  description: "Output de chat que envia a resposta para o cliente via WebSocket",
+  tags: {
+    execution: "async",
+    group: "IA"
+  },
+  fields: [
+    {
+      id: "data",
+      label: "Data",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Data",
+        name: "data",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/ia/agent/data.ts
+var import_zod5 = require("zod");
+var IaAgentNodeSchema = import_zod5.z.object({
+  name: import_zod5.z.string().describe("Unique name for the agent"),
+  systemMessage: import_zod5.z.string().optional().describe("System context for the agent"),
+  message: import_zod5.z.string().optional().describe("Input message for the agent"),
+  model: import_zod5.z.any().describe("LLM model for the agent"),
+  tools: import_zod5.z.any().optional().describe("Tools available to the agent")
+});
+var IaAgentNode = {
+  label: "IA Agent",
+  type: "IaAgentNode",
+  category: "step",
+  description: "Creates a configurable AI agent for supervision",
+  icon: "\u{1F916}",
+  toolable: true,
+  group: "IA",
+  tags: {
+    execution: "async",
+    group: "IA"
+  },
+  fields: [
+    {
+      id: "name",
+      label: "Agent Name",
+      type: "string",
+      required: true,
+      placeholder: "e.g., researcher_agent"
+    },
+    {
+      id: "systemMessage",
+      label: "System Message",
+      type: "textarea",
+      required: true,
+      placeholder: "You are a web researcher...",
+      handle: {
+        type: "input",
+        label: "System Message",
+        name: "systemMessage",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "message",
+      label: "Message",
+      type: "string",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Message",
+        name: "message",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "model",
+      label: "Model",
+      type: "model",
+      typeable: false,
+      required: true,
+      handle: {
+        type: "input",
+        label: "Model",
+        name: "model",
+        fieldType: "model",
+        acceptTypes: ["model"],
+        maxConnections: 1
+      }
+    },
+    {
+      id: "tools",
+      label: "Tools",
+      type: "tool",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Tools",
+        name: "tools",
+        fieldType: "tool",
+        acceptTypes: ["tool"]
+      }
+    },
+    {
+      id: "agent",
+      label: "Agent",
+      type: "agent",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Agent",
+        name: "agent",
+        fieldType: "agent"
+      }
+    },
+    {
+      id: "response",
+      label: "Response",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "response",
+        name: "response",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/ia/agent/function.ts
+var import_prebuilt = require("@langchain/langgraph/prebuilt");
+var import_messages = require("@langchain/core/messages");
+
+// src/utils/llm-factory.ts
+var import_graphql_request = require("graphql-request");
+var import_google_gauth = require("@langchain/google-gauth");
+var import_openai = require("@langchain/openai");
+var GRAPHQL_ENDPOINT = process.env["GRAPHQL_URL"] || "http://localhost:3001/graphql";
+var GET_INTEGRATIONS_QUERY = import_graphql_request.gql`
+    query GetIntegrations($where: IntegrationWhereInput) {
+        getIntegrations(where: $where) {
+            status
+            message
+            data {
+                id
+                status
+                data
+            }
+        }
+    }
+`;
+async function createLLMFromModel(modelConfig, authToken, streaming = false) {
+  if (modelConfig?.invoke || modelConfig?.call) {
+    return modelConfig;
+  }
+  if (!modelConfig?.model || !modelConfig?.integrationId) {
+    throw new Error('Model config deve conter "model" e "integrationId"');
+  }
+  const { model, integrationId } = modelConfig;
+  const provider = "gemini";
+  switch (provider) {
+    case "gemini":
+      return new import_google_gauth.ChatGoogle({
+        model: "gemini-flash-latest",
+        apiKey: "AIzaSyAWS9GhesWxG4uTdJRQbBziMB1diXtXtlI",
+        streaming
+      });
+    case "openai":
+      return new import_openai.ChatOpenAI({
+        model,
+        openAIApiKey: apiKey,
+        streaming
+      });
+    case "openrouter":
+      return new import_openai.ChatOpenAI({
+        model,
+        openAIApiKey: apiKey,
+        configuration: {
+          baseURL: "https://openrouter.ai/api/v1"
+        },
+        streaming
+      });
+    default:
+      throw new Error(
+        `Provider "${provider}" n\xE3o suportado. Providers dispon\xEDveis: gemini, openai, openrouter`
+      );
+  }
+}
+
+// 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 authToken = inputs.authToken;
+  const stream = Boolean(inputs?.stream);
+  const emitter = inputs?.emitter;
+  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");
+  }
+  let toolsArray = [];
+  if (Array.isArray(tools)) {
+    toolsArray = tools;
+  } else if (tools) {
+    toolsArray = [tools];
+  }
+  const finalSystemMessageContent = `${systemMessage || ""}
+
+IMPORTANT: You must base your response on the last message in the conversation history.`;
+  const finalSystemMessage = new import_messages.SystemMessage(finalSystemMessageContent);
+  let llmInstance;
+  if (model?.integrationId) {
+    if (!authToken) {
+      throw new Error("Auth token is required to instantiate LLM from integration");
+    }
+    llmInstance = await createLLMFromModel(model, authToken, stream);
+  } else if (typeof model?.bindTools === "function") {
+    llmInstance = model;
+  } else {
+    throw new Error("Invalid model: must have integrationId or be a valid LLM instance with bindTools method");
+  }
+  const agent = (0, import_prebuilt.createReactAgent)({
+    llm: llmInstance,
+    tools: toolsArray,
+    messageModifier: finalSystemMessage
+  });
+  agent.name = name;
+  let output = "";
+  if (message) {
+    try {
+      const { HumanMessage: HumanMessage2 } = await import("@langchain/core/messages");
+      if (stream && emitter) {
+        const streamIterator = await agent.stream({
+          messages: [new HumanMessage2(message)]
+        });
+        let lastMessages = [];
+        const sentContents = /* @__PURE__ */ new Set();
+        for await (const step of streamIterator) {
+          if (step && typeof step === "object") {
+            for (const [key, value] of Object.entries(step)) {
+              if (value && typeof value === "object" && "messages" in value) {
+                const messages = value.messages;
+                if (Array.isArray(messages)) {
+                  lastMessages = messages;
+                  for (const msg of messages) {
+                    const content = msg?.content;
+                    const contentStr = typeof content === "string" ? content : Array.isArray(content) ? content.map((p) => p.type === "text" ? p.text : "").filter(Boolean).join("") : "";
+                    if (contentStr && !sentContents.has(contentStr)) {
+                      sentContents.add(contentStr);
+                      if (emitter?.emitDelta) {
+                        emitter.emitDelta({
+                          content: contentStr,
+                          actor: name,
+                          isAgent: true,
+                          isTool: false
+                        });
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (lastMessages.length > 0) {
+          const lastMessage = lastMessages[lastMessages.length - 1];
+          const content = lastMessage?.content;
+          if (typeof content === "string") {
+            output = content;
+          } else if (Array.isArray(content)) {
+            output = content.map((part) => {
+              if (typeof part === "string") return part;
+              if (part?.type === "text") return part.text;
+              return "";
+            }).filter(Boolean).join("\n");
+          }
+        }
+      } else {
+        const result = await agent.invoke({
+          messages: [new HumanMessage2(message)]
+        });
+        if (result?.messages && result.messages.length > 0) {
+          const lastMessage = result.messages[result.messages.length - 1];
+          const content = lastMessage?.content;
+          if (typeof content === "string") {
+            output = content;
+          } else if (Array.isArray(content)) {
+            output = content.map((part) => {
+              if (typeof part === "string") return part;
+              if (part?.type === "text") return part.text;
+              return "";
+            }).filter(Boolean).join("\n");
+          } else {
+            output = "";
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error processing message in agent:", error);
+      output = `Error: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  }
+  return {
+    agent,
+    output: output || ""
+  };
+};
+
+// src/nodes/ia/supervisor/data.ts
+var import_zod6 = require("zod");
+var AiSupervisorNodeSchema = import_zod6.z.object({
+  model: import_zod6.z.any().describe("LLM model for the supervisor"),
+  agents: import_zod6.z.any().optional().describe("Agent(s) to supervise"),
+  message: import_zod6.z.string().describe("Task or message for the supervisor to handle"),
+  systemMessage: import_zod6.z.string().optional().describe("Custom system message for the supervisor")
+});
+var AiSupervisorNode = {
+  label: "AI Supervisor",
+  type: "AiSupervisorNode",
+  category: "step",
+  description: "Coordinates multiple agents to perform tasks manually",
+  icon: "\u{1F440}",
+  toolable: false,
+  group: "IA",
+  tags: {
+    execution: "async",
+    group: "IA"
+  },
+  fields: [
+    {
+      id: "message",
+      label: "Message",
+      type: "string",
+      required: true,
+      handle: { type: "input", label: "Message", name: "message", fieldType: "string" }
+    },
+    {
+      id: "systemMessage",
+      label: "System Message",
+      type: "textarea",
+      required: false,
+      placeholder: "You are a supervisor... (use {members} to list agents)",
+      handle: {
+        type: "input",
+        label: "System Message",
+        name: "systemMessage",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "model",
+      label: "Model",
+      type: "model",
+      typeable: false,
+      required: true,
+      handle: {
+        type: "input",
+        label: "Model",
+        name: "model",
+        fieldType: "model",
+        acceptTypes: ["model"],
+        maxConnections: 1
+      }
+    },
+    {
+      id: "agents",
+      label: "Agents",
+      type: "agent",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Agents",
+        name: "agents",
+        fieldType: "agent",
+        acceptTypes: ["agent"]
+      }
+    },
+    {
+      id: "response",
+      label: "Response",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "response",
+        name: "response",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/ia/supervisor/function.ts
+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)) {
+    return agents.map((a) => a.agent).filter(Boolean);
+  }
+  if (agents?.agent) {
+    return [agents.agent];
+  }
+  return [agents];
+};
+var extractFinalResponse = (messages) => {
+  if (!messages || messages.length === 0) return "No response generated.";
+  const isTransferOrToolMsg = (m) => {
+    const content = m?.content;
+    const name = m?.name;
+    const hasToolCallId = typeof m?.tool_call_id === "string" || typeof m?.additional_kwargs?.tool_call_id === "string";
+    const hasToolCalls = Array.isArray(m?.additional_kwargs?.tool_calls) && m.additional_kwargs.tool_calls.length > 0;
+    const contentStr = typeof content === "string" ? content : "";
+    const nameStr = typeof name === "string" ? name : "";
+    if (hasToolCallId || hasToolCalls) return true;
+    if (/^Successfully transferred/i.test(contentStr)) return true;
+    if (/^Transferring back to supervisor/i.test(contentStr)) return true;
+    if (/^transfer_/i.test(nameStr)) return true;
+    return false;
+  };
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (isTransferOrToolMsg(msg)) continue;
+    const content = msg?.content;
+    if (typeof content === "string" && content.trim()) return content;
+    if (Array.isArray(content)) {
+      const textContent = content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+      if (textContent.trim()) return textContent;
+    }
+  }
+  const lastMessage = messages[messages.length - 1];
+  if (!lastMessage?.content) return "No response generated.";
+  if (typeof lastMessage.content === "string") return lastMessage.content;
+  if (Array.isArray(lastMessage.content)) {
+    const textContent = lastMessage.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+    return textContent || JSON.stringify(lastMessage.content);
+  }
+  return "No response generated.";
+};
+var AiSupervisorNodeFunction = async (params) => {
+  const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = params;
+  const outer = params ?? {};
+  const inner = outer && typeof outer === "object" && outer.fieldValues && typeof outer.fieldValues === "object" ? outer.fieldValues : {};
+  const model = inner.model ?? outer.model;
+  const agents = inner.agents ?? outer.agents;
+  const message = inner.message ?? outer.message;
+  const systemMessage = inner.systemMessage ?? outer.systemMessage;
+  const stream = (typeof outer.stream === "boolean" ? outer.stream : inner.stream) ?? false;
+  const emitter = outer.emitter ?? inner.emitter;
+  const authToken = outer.authToken ?? inner.authToken;
+  if (!model) throw new Error("Model is required for AiSupervisorNode");
+  if (!agents) throw new Error("Agents are required for AiSupervisorNode.");
+  try {
+    const supervisorAgents = extractSupervisorAgents(agents);
+    if (supervisorAgents.length === 0) throw new Error("No valid agents were extracted from the 'agents' input.");
+    if (supervisorAgents.some((agent) => !agent.name)) throw new Error("All agents must have a name.");
+    let llmInstance;
+    if (model?.model && model?.integrationId) {
+      if (!authToken) {
+        throw new Error("Auth token is required to instantiate LLM from integration 3");
+      }
+      llmInstance = await createLLMFromModel(model, authToken, stream);
+    } else {
+      llmInstance = model;
+    }
+    const finalSystemPrompt = systemMessage || "You are a supervisor...";
+    const workflow = (0, import_langgraph_supervisor.createSupervisor)({
+      llm: llmInstance,
+      agents: supervisorAgents,
+      prompt: finalSystemPrompt
+    });
+    const app = workflow.compile({
+      checkpointer,
+      store
+    });
+    if (stream && emitter) {
+      try {
+        const streamIterator = await app.stream(
+          { messages: [new import_messages2.HumanMessage({ content: message })] },
+          { recursionLimit: 150, configurable: { thread_id: "conversation" } }
+        );
+        let finalMessages = [];
+        const previousStepMessages = /* @__PURE__ */ new Map();
+        const sentMessages = /* @__PURE__ */ new Set();
+        let stepCount = 0;
+        for await (const step of streamIterator) {
+          stepCount++;
+          if (step && typeof step === "object") {
+            for (const [agentKey, agentData] of Object.entries(step)) {
+              if (agentData && typeof agentData === "object" && "messages" in agentData) {
+                const currentMessages = agentData.messages;
+                if (Array.isArray(currentMessages) && currentMessages.length > 0) {
+                  finalMessages = currentMessages;
+                  const previousCount = previousStepMessages.get(agentKey) || 0;
+                  const currentCount = currentMessages.length;
+                  if (currentCount > previousCount) {
+                    const newMessages = currentMessages.slice(previousCount);
+                    const structuredMessages = newMessages.map((msg) => {
+                      const msgContent = msg?.content || "";
+                      const msgName = msg?.name || "";
+                      const toolCallId = msg?.tool_call_id;
+                      const isTool = !!(toolCallId || msgName.includes("transfer_") || msgContent.includes("Successfully transferred"));
+                      const isAgent = !isTool && agentKey !== "supervisor";
+                      let name = "";
+                      if (isTool) {
+                        if (msgName.includes("transfer_")) {
+                          name = msgName;
+                        } else {
+                          name = "transfer_tool";
+                        }
+                      } else if (isAgent) {
+                        name = msgName || agentKey;
+                      } else {
+                        name = agentKey === "supervisor" ? "supervisor" : agentKey;
+                      }
+                      return {
+                        isTool,
+                        isAgent,
+                        name,
+                        message: msgContent.trim()
+                      };
+                    }).filter((item) => item.message);
+                    if (structuredMessages.length > 0) {
+                      structuredMessages.forEach((structuredMsg) => {
+                        const messageHash = `${structuredMsg.name}-${structuredMsg.message.slice(0, 100)}`;
+                        if (!sentMessages.has(messageHash)) {
+                          sentMessages.add(messageHash);
+                          if (emitter?.emitDelta) {
+                            emitter.emitDelta({
+                              content: structuredMsg.message,
+                              actor: structuredMsg.name,
+                              isAgent: structuredMsg.isAgent,
+                              isTool: structuredMsg.isTool
+                            });
+                          }
+                        }
+                      });
+                    }
+                    previousStepMessages.set(agentKey, currentCount);
+                  }
+                }
+              }
+            }
+          }
+        }
+        const finalResponse = extractFinalResponse(finalMessages);
+        return {
+          output: finalResponse,
+          function: AiSupervisorNodeFunction,
+          type: "AiSupervisorNode"
+        };
+      } catch (err) {
+        console.error("\u274C Streaming error:", err);
+        throw err;
+      }
+    } else {
+      const result = await app.invoke(
+        { messages: [new import_messages2.HumanMessage({ content: message })] },
+        { recursionLimit: 150, configurable: { thread_id: "conversation" } }
+      );
+      const finalResponse = extractFinalResponse(result?.messages);
+      return {
+        output: finalResponse,
+        function: AiSupervisorNodeFunction,
+        type: "AiSupervisorNode"
+      };
+    }
+  } catch (error) {
+    console.error("\u274C AiSupervisorNode - Error:", error);
+    return {
+      output: `Error: ${error instanceof Error ? error.message : String(error)}`,
+      function: AiSupervisorNodeFunction,
+      type: "AiSupervisorNode"
+    };
+  }
+};
+
+// src/nodes/ia/tool/data.ts
+var import_zod7 = require("zod");
+var CustomToolSchema = import_zod7.z.object({
+  input: import_zod7.z.string().optional().describe("Input for the tool")
+});
+var AiToolNodeSchema = import_zod7.z.object({
+  name: import_zod7.z.string().describe("Name of the tool"),
+  description: import_zod7.z.string().describe("Description of what the tool does"),
+  // z.function() não suporta .describe(), então usamos z.any() para aceitar qualquer função.
+  nodeFunction: import_zod7.z.any().describe("The function to execute"),
+  nodeType: import_zod7.z.string().describe("The type of the node the tool represents"),
+  originalNodeData: import_zod7.z.any().optional().describe("Original data of the node"),
+  workflowService: import_zod7.z.any().optional().describe("Service for workflow operations"),
+  currentResults: import_zod7.z.any().optional().describe("Current results in the workflow")
+});
+var AiToolNode = {
+  label: "AI Tool",
+  type: "AiToolNode",
+  category: "step",
+  description: "Wraps another node to be used as a tool by an AI agent",
+  icon: "\u{1F6E0}\uFE0F",
+  group: "IA",
+  tags: {
+    execution: "async",
+    group: "IA"
+  },
+  fields: [
+    {
+      id: "name",
+      label: "Name",
+      type: "string",
+      required: true
+    },
+    {
+      id: "description",
+      label: "Description",
+      type: "string",
+      required: true
+    },
+    {
+      id: "function",
+      label: "Function",
+      type: "any",
+      // Alterado para 'any' para corresponder ao schema z.any()
+      required: true,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Input",
+        name: "input",
+        fieldType: "string",
+        required: true
+      }
+    },
+    {
+      id: "tool",
+      label: "Tool",
+      type: "tool",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Tool",
+        name: "tool",
+        fieldType: "tool",
+        required: true,
+        acceptTypes: ["tool"]
+      }
+    }
+  ]
+};
+
+// src/nodes/ia/tool/function.ts
+var import_tools = require("@langchain/core/tools");
+
+// src/nodes/consts/schemas.ts
+var schemas = {
+  IaAgentNode: IaAgentNodeSchema,
+  AiSupervisorNode: AiSupervisorNodeSchema,
+  AiToolNode: AiToolNodeSchema,
+  IaMessageNode: IaMessageNodeSchema
+};
+
+// src/nodes/ia/tool/function.ts
+var AiToolNodeFunction = async (params) => {
+  const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = params;
+  const fieldValues = params.fieldValues || params;
+  const { name, description, nodeFunction, nodeType, originalNodeData, workflowService, currentResults } = fieldValues;
+  const schema = schemas[nodeType] || CustomToolSchema;
+  const dynamicTool = (0, import_tools.tool)(
+    async (args) => {
+      if (nodeFunction && typeof nodeFunction === "function") {
+        try {
+          let resolvedInputs = originalNodeData?.inputs || {};
+          if (workflowService && currentResults && originalNodeData?.inputs) {
+            resolvedInputs = await workflowService.resolveInputs(originalNodeData.inputs, currentResults);
+          }
+          const combinedInputs = {
+            ...resolvedInputs,
+            ...args,
+            originalNodeData
+          };
+          const result = await nodeFunction({ fieldValues: combinedInputs });
+          return result?.output || result;
+        } catch (error) {
+          return `Error: ${error instanceof Error ? error.message : String(error)}`;
+        }
+      }
+      return "Tool function not provided";
+    },
+    {
+      name: name || "Dynamic Tool",
+      description: description || "Tool created from workflow",
+      schema
+    }
+  );
+  return {
+    tool: dynamicTool
+  };
+};
+
+// 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 IaMessageNodeFunction = async (inputs) => {
+  const { $field: _$field, $req: _$req, $inputs: _$inputs_var, $vars: _$vars } = inputs;
+  const fieldValues = inputs.fieldValues || inputs;
+  const { model, systemMessage, message } = fieldValues;
+  const authToken = inputs.authToken;
+  const stream = Boolean(inputs?.stream);
+  const emitter = inputs?.emitter;
+  if (!model) {
+    throw new Error("Model is required");
+  }
+  if (!message) {
+    throw new Error("Message is required");
+  }
+  let llmInstance;
+  if (model?.model && model?.integrationId) {
+    if (!authToken) {
+      throw new Error("Auth token is required to instantiate LLM from integration");
+    }
+    llmInstance = await createLLMFromModel(model, authToken, stream);
+  } else {
+    llmInstance = model;
+  }
+  const messages = [];
+  if (systemMessage) {
+    messages.push(["system", systemMessage]);
+  }
+  messages.push(["human", message]);
+  try {
+    if (stream && emitter) {
+      let fullContent = "";
+      const streamResponse = await llmInstance.stream(messages);
+      for await (const chunk of streamResponse) {
+        const chunkContent = typeof chunk.content === "string" ? chunk.content : chunk.content?.text || "";
+        if (chunkContent) {
+          fullContent += chunkContent;
+          if (emitter?.emitDelta) {
+            emitter.emitDelta({
+              content: chunkContent,
+              actor: "IaMessageNode",
+              isAgent: false,
+              isTool: false
+            });
+          }
+        }
+      }
+      return {
+        output: fullContent,
+        response: fullContent,
+        fullResponse: { content: fullContent }
+      };
+    }
+    const response = await llmInstance.invoke(messages);
+    return {
+      output: response.content,
+      response: response.content,
+      fullResponse: response
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    throw new Error(`Error invoking Model: ${errorMessage}`);
+  }
+};
+var IaMessageNode = {
+  label: "AI Message",
+  type: "IaMessageNode",
+  category: "step",
+  description: "Send message to AI model and return response",
+  icon: "\u{1F4AC}",
+  group: "IA",
+  tags: {
+    execution: "async",
+    group: "IA"
+  },
+  fields: [
+    {
+      id: "model",
+      label: "Model",
+      type: "model",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "input",
+        label: "Model",
+        name: "model",
+        fieldType: "model",
+        acceptTypes: ["model"],
+        maxConnections: 1,
+        required: true
+      }
+    },
+    {
+      id: "systemMessage",
+      label: "System Message",
+      type: "string",
+      required: false,
+      placeholder: "You are a helpful assistant...",
+      handle: {
+        type: "input",
+        label: "System Message",
+        name: "systemMessage",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "message",
+      label: "Message",
+      type: "string",
+      required: true,
+      placeholder: "Type your message...",
+      handle: {
+        type: "input",
+        label: "Message",
+        name: "message",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "response",
+      label: "Response",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "response",
+        name: "response",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// 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 WhatsappSendTemplateNode = {
+  label: "Whatsapp Send Template",
+  type: "WhatsappSendTemplateNode",
+  category: "step",
+  description: "Send a template message to a WhatsApp number",
+  icon: "\u{1F4F1}",
+  toolable: true,
+  group: "Social",
+  tags: {
+    execution: "async",
+    group: "Social"
+  },
+  fields: [
+    {
+      id: "phoneNumber",
+      label: "Phone Number",
+      type: "string",
+      required: true,
+      placeholder: "e.g., +5511999999999",
+      handle: {
+        type: "input",
+        label: "Phone Number",
+        name: "phoneNumber",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "template",
+      label: "Template",
+      type: "select",
+      required: true,
+      optionsSource: {
+        provider: "whatsapp.messageTemplates"
+      }
+    }
+  ]
+};
+
+// 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 WhatsappSendMessageNode = {
+  label: "Whatsapp Send Message",
+  type: "WhatsappSendMessageNode",
+  category: "step",
+  description: "Send an open text message to a WhatsApp number",
+  icon: "\u{1F4AC}",
+  toolable: true,
+  group: "Social",
+  tags: {
+    execution: "async",
+    group: "Social"
+  },
+  fields: [
+    {
+      id: "phoneNumber",
+      label: "Phone Number",
+      type: "string",
+      required: true,
+      placeholder: "e.g., +5511999999999",
+      handle: {
+        type: "input",
+        label: "Phone Number",
+        name: "phoneNumber",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "message",
+      label: "Message",
+      type: "textarea",
+      required: true,
+      placeholder: "Type your message here...",
+      handle: {
+        type: "input",
+        label: "Message",
+        name: "message",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/social/whatsapp/message-trigger/data.ts
+var WhatsappMessageTriggerNode = {
+  label: "Whatsapp Message Trigger",
+  type: "WhatsappMessageTriggerNode",
+  category: "input",
+  description: "Trigger when a message is received from a WhatsApp number",
+  icon: "\u{1F4F1}",
+  toolable: false,
+  group: "Social",
+  tags: {
+    execution: "async",
+    group: "Social"
+  },
+  fields: [
+    {
+      id: "phoneNumber",
+      label: "Phone Number",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Phone Number",
+        name: "phoneNumber",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "userName",
+      label: "User Name",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "User Name",
+        name: "userName",
+        fieldType: "string"
+      }
+    },
+    {
+      id: "message",
+      label: "Message",
+      type: "string",
+      required: true,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "Message",
+        name: "message",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/processors/custom-code.ts
+var NodeFunction = (params) => {
+  let input = params?.inputValue ?? params?.input;
+  const context = params && params.fieldValues ? params.fieldValues : params || {};
+  let customCode = context?.customCode ?? params?.customCode;
+  if (input === void 0 && Array.isArray(context?.fields)) {
+    const firstInputField = context.fields.find((f) => f?.handle?.type === "input");
+    if (firstInputField && firstInputField.id) {
+      const key = String(firstInputField.id);
+      if (params && Object.prototype.hasOwnProperty.call(params, key)) input = params[key];
+      else if (context && Object.prototype.hasOwnProperty.call(context, key)) input = context[key];
+      else if (firstInputField.value !== void 0) input = firstInputField.value;
+    }
+  }
+  const looksLikeCode = (code) => {
+    if (typeof code !== "string") return false;
+    const c = code.trim();
+    if (c.length < 3) return false;
+    return /(return\s+|=>|function\s*\(|;|\n|\{|\})/.test(c);
+  };
+  if (typeof customCode === "string" && !looksLikeCode(customCode)) {
+    if (input === void 0) input = customCode;
+    customCode = "";
+  }
+  if (!customCode || typeof customCode === "string" && customCode.trim() === "") {
+    return input;
+  }
+  try {
+    const $inputs = params?.results || {};
+    const $vars = context && context.variables || params?.variables || void 0;
+    const __placeholders = params?.__codePlaceholders ?? context?.__codePlaceholders;
+    const customFunction = new Function("input", "context", "request", "params", "$inputs", "$vars", "__placeholders", customCode);
+    const result = customFunction(input, context, params?.request, params, $inputs, $vars, __placeholders);
+    return result;
+  } catch (error) {
+    throw new Error(`Erro ao executar c\xF3digo customizado: ${error instanceof Error ? error.message : "Erro desconhecido"}`);
+  }
+};
+var CustomNodeFunction = (params) => {
+  const context = params && params.fieldValues ? params.fieldValues : params || {};
+  const customCode = context?.customCode;
+  if (!customCode || typeof customCode === "string" && customCode.trim() === "") {
+    throw new Error("CustomNode sem c\xF3digo configurado");
+  }
+  const fields = Array.isArray(context?.fields) ? context.fields : [];
+  const $field = {};
+  fields.forEach((field) => {
+    const fieldId = field?.id;
+    if (!fieldId) return;
+    let value;
+    if (params && Object.prototype.hasOwnProperty.call(params, fieldId)) {
+      value = params[fieldId];
+    } else if (field.handle && field.handle.name && params && Object.prototype.hasOwnProperty.call(params, field.handle.name)) {
+      value = params[field.handle.name];
+    } else if (field.value !== void 0) {
+      value = field.value;
+    } else if (field.defaultValue !== void 0) {
+      value = field.defaultValue;
+    }
+    $field[fieldId] = value;
+  });
+  try {
+    const $inputs = params?.results || {};
+    const $vars = context && context.variables || params?.variables || void 0;
+    const customFunction = new Function("$field", "context", "request", "params", "$inputs", "$vars", customCode);
+    const result = customFunction($field, context, params?.request, params, $inputs, $vars);
+    return result;
+  } catch (error) {
+    throw new Error(`Erro ao executar CustomNode: ${error instanceof Error ? error.message : "Erro desconhecido"}`);
+  }
+};
+var CustomCodeNode = {
+  label: "Custom Code",
+  type: "CustomCodeNode",
+  category: "step",
+  icon: "\u{1F4BB}",
+  description: "Node para executar c\xF3digo JavaScript customizado",
+  fields: [
+    {
+      id: "customCode",
+      label: "C\xF3digo Customizado",
+      type: "code",
+      required: false,
+      placeholder: '// Seu c\xF3digo JavaScript aqui\n// Use "input" para acessar o valor de entrada\n// Use "context" para acessar os dados do n\xF3\nreturn input;'
+    },
+    {
+      id: "input",
+      label: "Input",
+      type: "any",
+      required: false,
+      handle: {
+        type: "input",
+        label: "Input",
+        name: "input",
+        fieldType: "any",
+        required: false
+      }
+    },
+    {
+      id: "output",
+      label: "Output",
+      type: "any",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Output",
+        name: "output",
+        fieldType: "any",
+        required: false
+      }
+    }
+  ]
+};
+
+// src/nodes/consts/nodes.ts
+var nodes = [
+  ChatInputNode,
+  ManualTriggerNode,
+  CronTriggerNode,
+  HttpGetInputNode,
+  // HttpPostInputNode,
+  // TransformNode,
+  ConcatNode,
+  OutputNode,
+  ChatOutputNode,
+  IaMessageNode,
+  IaAgentNode,
+  AiToolNode,
+  AiSupervisorNode,
+  WhatsappSendTemplateNode,
+  WhatsappSendMessageNode,
+  WhatsappMessageTriggerNode,
+  CustomCodeNode
+];
+var nodes_default = nodes;
+
+// src/nodes/social/whatsapp/send-template/functions.ts
+var BUSINESS_ACCOUNT_ID = "1079341674316936";
+var NUMBER_ID = "700207253183039";
+var TOKEN = "EAAUuy5eznhEBPQUOoF07SUTSVjgNIX9eZCWSKPYQhzHiXeEp4Qj3g47bZAPcZAgs8P2B5cZBH9YJjzq0HKNXfA14kaK5Cp2DZCmxzV60MgWlsY1yKavb2qXAQcydoHTTLKcWO53w6ZB7JNzZBeIpZBTb9cB0teRzfX3kjrZBc7utyKq2ZCZCCOQ74pZA28gnmQYzp24oZBQpf7BmuNHgndFVlTba5drxgcpERyNl1dUIDhky7NIruggZDZD";
+var WhatsappStartChatFunction = async (fieldValues) => {
+  const { phoneNumber, template } = fieldValues;
+  const response = await fetch(`https://graph.facebook.com/v23.0/${NUMBER_ID}/messages`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${TOKEN}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      messaging_product: "whatsapp",
+      to: phoneNumber,
+      type: "template",
+      template: {
+        name: template,
+        language: {
+          code: "pt_BR"
+        }
+      }
+    })
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    throw new Error(`Failed to start chat: ${response.statusText}`);
+  }
+  return data;
+};
+var getMessageTemplates = async () => {
+  const response = await fetch(`https://graph.facebook.com/v23.0/${BUSINESS_ACCOUNT_ID}/message_templates`, {
+    method: "GET",
+    headers: {
+      "Authorization": `Bearer ${TOKEN}`
+    }
+  });
+  const data = await response.json();
+  return data;
+};
+var createMessageTemplate = async (payload) => {
+  const response = await fetch(`https://graph.facebook.com/v23.0/${BUSINESS_ACCOUNT_ID}/message_templates`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${TOKEN}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(payload)
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    const errObj = data.error;
+    const msg = errObj?.message || response.statusText;
+    const enriched = new Error(`Failed to create template: ${msg}`);
+    enriched.details = data;
+    enriched.status = response.status;
+    throw enriched;
+  }
+  return data;
+};
+
+// src/nodes/social/whatsapp/send-message/functions.ts
+var NUMBER_ID2 = "700207253183039";
+var TOKEN2 = "EAAUuy5eznhEBPWw62uE6cs4oZAW6WvpsiF9RBjTGDjg8H74GouBMl1MBifCuA572AVMp53T83pBuSaMJUcWMDIGxvXbxaU6RFTyXOuKkhUPkF3Boc7QbmRuUWSFuyvkjZCyA7ngAg2NXV8nYzzZCleSuFQD487NN2mat7sHPx2pMHuN95IcaevyKLnuz5Om2Bp36JihQweodc517aH2Krv70jqNKKzBjoGVziWNnOhULQZDZD";
+var WhatsappSendMessageFunction = async (fieldValues) => {
+  const { phoneNumber, message } = fieldValues;
+  const response = await fetch(`https://graph.facebook.com/v23.0/${NUMBER_ID2}/messages`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${TOKEN2}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      messaging_product: "whatsapp",
+      to: phoneNumber,
+      type: "text",
+      text: {
+        preview_url: false,
+        body: message
+      }
+    })
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    const errObj = data.error;
+    const msg = errObj?.message || response.statusText;
+    const enriched = new Error(`Failed to send message: ${msg}`);
+    enriched.details = data;
+    enriched.status = response.status;
+    throw enriched;
+  }
+  return data;
+};
+
+// src/nodes/consts/node-functions.ts
+var nodeFunctions = {
+  ChatInput: ChatInputNodeFunction,
+  ChatOutput: ChatOutputNodeFunction,
+  HttpGetInput: HttpGetInputNodeFunction,
+  HttpPostInput: HttpPostInputNodeFunction,
+  ManualTrigger: ManualTriggerNodeFunction,
+  CronTrigger: CronTriggerNodeFunction,
+  HttpOutput: HttpOutputNodeFunction,
+  ConcatNode: ConcatNodeFunction,
+  IaMessageNode: IaMessageNodeFunction,
+  IaAgentNode: IaAgentNodeFunction,
+  AiToolNode: AiToolNodeFunction,
+  AiSupervisorNode: AiSupervisorNodeFunction,
+  WhatsappNode: WhatsappStartChatFunction,
+  WhatsappSendMessageNode: WhatsappSendMessageFunction,
+  CustomCodeNode: NodeFunction,
+  CustomNode: CustomNodeFunction
+};
+var node_functions_default = nodeFunctions;
+
+// src/nodes/inputs/http/put/data.ts
+var HttpPutInputNode = {
+  label: "Http PUT Input",
+  type: "HttpPutInput",
+  category: "input",
+  icon: "\u{1F4DD}",
+  description: "Node que representa uma rota PUT HTTP para atualiza\xE7\xE3o completa de recursos",
+  tags: {
+    execution: "sync",
+    group: "HTTP"
+  },
+  fields: [
+    {
+      id: "route",
+      label: "Route",
+      type: "route",
+      required: true,
+      placeholder: "/produtos/{id}"
+    },
+    {
+      id: "queryParams",
+      label: "Query Params",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Query Params",
+        name: "queryParams",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "headers",
+      label: "Headers",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Headers",
+        name: "headers",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "body",
+      label: "Body",
+      type: "object",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Body",
+        name: "body",
+        fieldType: "object",
+        required: false
+      }
+    },
+    {
+      id: "ip",
+      label: "Request IP",
+      type: "string",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "IP",
+        name: "ip",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/inputs/http/put/function.ts
+var HttpPutInputNodeFunction = (params) => {
+  const { request, fieldValues } = params;
+  const { queryParams: configQueryParams, headers: configHeaders, body: configBody } = fieldValues || {};
+  if (request.method !== "PUT") {
+    throw new Error("M\xE9todo HTTP inv\xE1lido");
+  }
+  const actualData = {
+    queryParams: request?.query || {},
+    headers: request?.headers || {},
+    body: request?.body || {},
+    ip: request?.ip || "127.0.0.1"
+  };
+  if (configQueryParams) {
+    const requiredParams = configQueryParams.filter((p) => p.required);
+    const missingParams = requiredParams.filter((p) => !actualData.queryParams[p.key]);
+    if (missingParams.length > 0) {
+      throw new Error(`Par\xE2metros obrigat\xF3rios ausentes: ${missingParams.map((p) => p.key).join(", ")}`);
+    }
+  }
+  if (configHeaders) {
+    const requiredHeaders = configHeaders.filter((h) => h.required);
+    const missingHeaders = requiredHeaders.filter((h) => !actualData.headers[h.key.toLowerCase()]);
+    if (missingHeaders.length > 0) {
+      throw new Error(`Headers obrigat\xF3rios ausentes: ${missingHeaders.map((h) => h.key).join(", ")}`);
+    }
+  }
+  if (configBody) {
+    const requiredBodyFields = configBody.filter((f) => f.required);
+    const missingBodyFields = requiredBodyFields.filter((f) => !actualData.body[f.key]);
+    if (missingBodyFields.length > 0) {
+      throw new Error(`Campos obrigat\xF3rios do body ausentes: ${missingBodyFields.map((f) => f.key).join(", ")}`);
+    }
+  }
+  return actualData;
+};
+
+// src/nodes/inputs/http/put/schema.ts
+var import_zod11 = require("zod");
+var HttpPutInputNodeSchema = import_zod11.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")
+});
+
+// src/nodes/inputs/http/delete/data.ts
+var HttpDeleteInputNode = {
+  label: "Http DELETE Input",
+  type: "HttpDeleteInput",
+  category: "input",
+  icon: "\u{1F5D1}\uFE0F",
+  description: "Node que representa uma rota DELETE HTTP para remo\xE7\xE3o de recursos",
+  tags: {
+    execution: "sync",
+    group: "HTTP"
+  },
+  fields: [
+    {
+      id: "route",
+      label: "Route",
+      type: "route",
+      required: true,
+      placeholder: "/produtos/{id}"
+    },
+    {
+      id: "queryParams",
+      label: "Query Params",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Query Params",
+        name: "queryParams",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "headers",
+      label: "Headers",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Headers",
+        name: "headers",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "ip",
+      label: "Request IP",
+      type: "string",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "IP",
+        name: "ip",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/inputs/http/delete/function.ts
+var HttpDeleteInputNodeFunction = async (params) => {
+  const { request, fieldValues } = params;
+  const { queryParams: configQueryParams, headers: configHeaders } = fieldValues || {};
+  if (request.method !== "DELETE") {
+    throw new Error("M\xE9todo HTTP inv\xE1lido");
+  }
+  const actualData = {
+    queryParams: request?.query || {},
+    headers: request?.headers || {},
+    ip: request?.ip || "127.0.0.1"
+  };
+  if (configQueryParams) {
+    const requiredParams = configQueryParams.filter((p) => p.required);
+    const missingParams = requiredParams.filter((p) => !actualData.queryParams[p.key]);
+    if (missingParams.length > 0) {
+      throw new Error(`Par\xE2metros obrigat\xF3rios ausentes: ${missingParams.map((p) => p.key).join(", ")}`);
+    }
+  }
+  if (configHeaders) {
+    const requiredHeaders = configHeaders.filter((h) => h.required);
+    const missingHeaders = requiredHeaders.filter((h) => !actualData.headers[h.key.toLowerCase()]);
+    if (missingHeaders.length > 0) {
+      throw new Error(`Headers obrigat\xF3rios ausentes: ${missingHeaders.map((h) => h.key).join(", ")}`);
+    }
+  }
+  return actualData;
+};
+
+// src/nodes/inputs/http/delete/schema.ts
+var import_zod12 = require("zod");
+var HttpDeleteInputNodeSchema = import_zod12.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")
+});
+
+// src/nodes/inputs/http/patch/data.ts
+var HttpPatchInputNode = {
+  label: "Http PATCH Input",
+  type: "HttpPatchInput",
+  category: "input",
+  icon: "\u{1F527}",
+  description: "Node que representa uma rota PATCH HTTP para atualiza\xE7\xE3o parcial de recursos",
+  tags: {
+    execution: "sync",
+    group: "HTTP"
+  },
+  fields: [
+    {
+      id: "route",
+      label: "Route",
+      type: "route",
+      required: true,
+      placeholder: "/produtos/{id}"
+    },
+    {
+      id: "queryParams",
+      label: "Query Params",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Query Params",
+        name: "queryParams",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "headers",
+      label: "Headers",
+      type: "keyValue",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Headers",
+        name: "headers",
+        fieldType: "keyValue"
+      }
+    },
+    {
+      id: "body",
+      label: "Body",
+      type: "object",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Body",
+        name: "body",
+        fieldType: "object",
+        required: false
+      }
+    },
+    {
+      id: "ip",
+      label: "Request IP",
+      type: "string",
+      required: false,
+      typeable: false,
+      handle: {
+        type: "output",
+        label: "IP",
+        name: "ip",
+        fieldType: "string"
+      }
+    }
+  ]
+};
+
+// src/nodes/inputs/http/patch/function.ts
+var HttpPatchInputNodeFunction = (params) => {
+  const { request, fieldValues } = params;
+  const { queryParams: configQueryParams, headers: configHeaders, body: configBody } = fieldValues || {};
+  if (request.method !== "PATCH") {
+    throw new Error("M\xE9todo HTTP inv\xE1lido");
+  }
+  const actualData = {
+    queryParams: request?.query || {},
+    headers: request?.headers || {},
+    body: request?.body || {},
+    ip: request?.ip || "127.0.0.1"
+  };
+  if (configQueryParams) {
+    const requiredParams = configQueryParams.filter((p) => p.required);
+    const missingParams = requiredParams.filter((p) => !actualData.queryParams[p.key]);
+    if (missingParams.length > 0) {
+      throw new Error(`Par\xE2metros obrigat\xF3rios ausentes: ${missingParams.map((p) => p.key).join(", ")}`);
+    }
+  }
+  if (configHeaders) {
+    const requiredHeaders = configHeaders.filter((h) => h.required);
+    const missingHeaders = requiredHeaders.filter((h) => !actualData.headers[h.key.toLowerCase()]);
+    if (missingHeaders.length > 0) {
+      throw new Error(`Headers obrigat\xF3rios ausentes: ${missingHeaders.map((h) => h.key).join(", ")}`);
+    }
+  }
+  if (configBody) {
+    const requiredBodyFields = configBody.filter((f) => f.required);
+    const missingBodyFields = requiredBodyFields.filter((f) => !actualData.body[f.key]);
+    if (missingBodyFields.length > 0) {
+      throw new Error(`Campos obrigat\xF3rios do body ausentes: ${missingBodyFields.map((f) => f.key).join(", ")}`);
+    }
+  }
+  return actualData;
+};
+
+// src/nodes/inputs/http/patch/schema.ts
+var import_zod13 = require("zod");
+var HttpPatchInputNodeSchema = import_zod13.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")
+});
+
+// src/nodes/inputs/http/utils.ts
+var HTTP_NODE_TYPES = {
+  GET: "HttpGetInput",
+  POST: "HttpPostInput",
+  PUT: "HttpPutInput",
+  DELETE: "HttpDeleteInput",
+  PATCH: "HttpPatchInput"
+};
+var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH"];
+var getHttpNodesTypes = () => {
+  return [
+    HttpGetInputNode,
+    HttpPostInputNode,
+    HttpPutInputNode,
+    HttpDeleteInputNode,
+    HttpPatchInputNode
+  ].map((node) => node.type);
+};
+var getHttpNodeTypesArray = () => {
+  return Object.values(HTTP_NODE_TYPES);
+};
+var isHttpInputNode = (nodeType) => {
+  return getHttpNodeTypesArray().some((httpType) => nodeType.includes(httpType));
+};
+var isHttpMethodNode = (nodeType, method) => {
+  return nodeType.includes(HTTP_NODE_TYPES[method]);
+};
+var extractHttpMethodFromNodeType = (nodeType) => {
+  for (const [method, nodeTypeValue] of Object.entries(HTTP_NODE_TYPES)) {
+    if (nodeType.includes(nodeTypeValue)) {
+      return method;
+    }
+  }
+  return "GET";
+};
+var getHttpMethodFromNodeType = extractHttpMethodFromNodeType;
+var isAnyHttpInputNode = (nodeType) => {
+  return nodeType.includes("Http") && nodeType.includes("Input");
+};
+var getHttpNodeTypeStrings = () => {
+  return Object.values(HTTP_NODE_TYPES);
+};
+var isHttpInputFriendlyId = (friendlyId) => {
+  return friendlyId.includes("Http") && friendlyId.includes("Input");
+};
+var getHttpMethodFromFriendlyId = (friendlyId) => {
+  return extractHttpMethodFromNodeType(friendlyId);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AiSupervisorNode,
+  AiSupervisorNodeFunction,
+  AiSupervisorNodeSchema,
+  AiToolNode,
+  AiToolNodeFunction,
+  AiToolNodeSchema,
+  BodyFieldSchema,
+  CustomToolSchema,
+  HTTP_METHODS,
+  HTTP_NODE_TYPES,
+  HeaderSchema,
+  HttpDeleteInputNode,
+  HttpDeleteInputNodeFunction,
+  HttpDeleteInputNodeSchema,
+  HttpGetInputNode,
+  HttpGetInputNodeFunction,
+  HttpGetInputNodeSchema,
+  HttpPatchInputNode,
+  HttpPatchInputNodeFunction,
+  HttpPatchInputNodeSchema,
+  HttpPostInputNode,
+  HttpPostInputNodeFunction,
+  HttpPostInputNodeSchema,
+  HttpPutInputNode,
+  HttpPutInputNodeFunction,
+  HttpPutInputNodeSchema,
+  IaAgentNode,
+  IaAgentNodeFunction,
+  IaAgentNodeSchema,
+  IaMessageNode,
+  IaMessageNodeFunction,
+  IaMessageNodeSchema,
+  QueryParamSchema,
+  RouteSchema,
+  WhatsappMessageTriggerNode,
+  WhatsappSendMessageFunction,
+  WhatsappSendMessageNode,
+  WhatsappSendMessageNodeSchema,
+  WhatsappSendTemplateNode,
+  WhatsappSendTemplateNodeSchema,
+  WhatsappStartChatFunction,
+  createMessageTemplate,
+  extractHttpMethodFromNodeType,
+  getHttpMethodFromFriendlyId,
+  getHttpMethodFromNodeType,
+  getHttpNodeTypeStrings,
+  getHttpNodeTypesArray,
+  getHttpNodesTypes,
+  getMessageTemplates,
+  isAnyHttpInputNode,
+  isHttpInputFriendlyId,
+  isHttpInputNode,
+  isHttpMethodNode,
+  nodeFunctions,
+  nodes,
+  schemas
+});