@atomoz/workflows-nodes 0.1.10 → 0.1.12

package/dist/index.js

@@ -1,2063 +0,0 @@
-// 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 { request, fieldValues } = params;
-  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
-import { z as z2 } from "zod";
-
-// src/nodes/inputs/http/schemas.ts
-import { z } from "zod";
-var QueryParamSchema = z.object({
-  key: z.string(),
-  value: z.string().optional(),
-  required: z.boolean().optional()
-});
-var HeaderSchema = z.object({
-  key: z.string(),
-  value: z.string().optional(),
-  required: z.boolean().optional()
-});
-var BodyFieldSchema = z.object({
-  key: z.string(),
-  value: z.any().optional(),
-  required: z.boolean().optional()
-});
-var RouteSchema = z.string().describe("HTTP route path");
-
-// src/nodes/inputs/http/get/schema.ts
-var HttpGetInputNodeSchema = z2.object({
-  route: RouteSchema,
-  queryParams: z2.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z2.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 { request, fieldValues } = params;
-  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
-import { z as z3 } from "zod";
-var HttpPostInputNodeSchema = z3.object({
-  route: RouteSchema,
-  queryParams: z3.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z3.array(HeaderSchema).optional().describe("Headers configuration"),
-  body: z3.array(BodyFieldSchema).optional().describe("Body fields configuration")
-});
-
-// src/nodes/inputs/chat/chat.ts
-var ChatInputNodeFunction = (params) => {
-  const { request, fieldValues } = params;
-  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 { fieldValues } = params || {};
-  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/processors/concat.ts
-import { z as z4 } from "zod";
-var ConcatNodeFunction = (inputs) => {
-  const input1 = inputs.input1 || "";
-  const input2 = inputs.input2 || "";
-  const result = `${input1}${input2}`;
-  return {
-    output: result,
-    function: ConcatNodeFunction,
-    type: "ConcatNode"
-  };
-};
-var ConcatNodeSchema = z4.object({
-  input1: z4.string(),
-  input2: z4.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 { inputs, fieldValues, stream, emitter } = params || {};
-  const content = inputs?.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
-import { z as z5 } from "zod";
-var IaAgentNodeSchema = z5.object({
-  name: z5.string().describe("Unique name for the agent"),
-  systemMessage: z5.string().optional().describe("System context for the agent"),
-  message: z5.string().optional().describe("Input message for the agent"),
-  model: z5.any().describe("LLM model for the agent"),
-  tools: z5.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
-import { createReactAgent } from "@langchain/langgraph/prebuilt";
-import { SystemMessage } from "@langchain/core/messages";
-
-// src/utils/llm-factory.ts
-import { GraphQLClient, gql } from "graphql-request";
-import { ChatGoogle } from "@langchain/google-gauth";
-import { ChatOpenAI } from "@langchain/openai";
-var GRAPHQL_ENDPOINT = process.env["GRAPHQL_URL"] || "http://localhost:3001/graphql";
-var GET_INTEGRATIONS_QUERY = 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 client = new GraphQLClient(GRAPHQL_ENDPOINT, {
-    headers: {
-      Authorization: `Bearer ${authToken}`,
-      "x-tenant-id": "65d62c52-0c09-473a-8895-359afbed3f5a"
-    }
-  });
-  let integrationData;
-  try {
-    const response = await client.request(
-      GET_INTEGRATIONS_QUERY,
-      {
-        where: {
-          id: {
-            eq: integrationId
-          }
-        }
-      }
-    );
-    if (!response.getIntegrations?.data?.[0]) {
-      throw new Error(`Integra\xE7\xE3o ${integrationId} n\xE3o encontrada`);
-    }
-    integrationData = response.getIntegrations.data[0];
-  } catch (error) {
-    console.error("Erro ao buscar integra\xE7\xE3o:", error);
-    throw new Error(
-      `Falha ao buscar integra\xE7\xE3o: ${error instanceof Error ? error.message : "Erro desconhecido"}`
-    );
-  }
-  const apiKey = integrationData.data?.["token"] || integrationData.data?.["token"];
-  if (!apiKey) {
-    throw new Error(`API Key n\xE3o encontrada na integra\xE7\xE3o ${integrationId}`);
-  }
-  const provider = integrationData.data?.provider?.toLowerCase() || inferProviderFromModel(model);
-  switch (provider) {
-    case "gemini":
-      return new ChatGoogle({
-        model: "gemini-flash-latest",
-        apiKey,
-        streaming
-      });
-    case "openai":
-      return new ChatOpenAI({
-        model,
-        openAIApiKey: apiKey,
-        streaming
-      });
-    case "openrouter":
-      return new 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`
-      );
-  }
-}
-function inferProviderFromModel(model) {
-  const modelLower = model.toLowerCase();
-  if (modelLower.includes("gemini") || modelLower.includes("palm")) {
-    return "gemini";
-  }
-  if (modelLower.includes("gpt") || modelLower.includes("o1") || modelLower.includes("o3")) {
-    return "openai";
-  }
-  return "openrouter";
-}
-
-// src/nodes/ia/agent/function.ts
-var IaAgentNodeFunction = async (inputs) => {
-  const { model, tools, systemMessage, name, message } = inputs.fieldValues;
-  const authToken = inputs.authToken;
-  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 SystemMessage(finalSystemMessageContent);
-  let llmInstance;
-  if (model?.integrationId) {
-    if (!authToken) {
-      throw new Error("Auth token is required to instantiate LLM from integration");
-    }
-    const streaming = Boolean(inputs?.stream);
-    llmInstance = await createLLMFromModel(model, authToken, streaming);
-  } 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 = createReactAgent({
-    llm: llmInstance,
-    tools: toolsArray,
-    messageModifier: finalSystemMessage
-  });
-  agent.name = name;
-  let output = "";
-  if (message) {
-    try {
-      const { HumanMessage: HumanMessage2 } = await import("@langchain/core/messages");
-      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
-import { z as z6 } from "zod";
-var AiSupervisorNodeSchema = z6.object({
-  model: z6.any().describe("LLM model for the supervisor"),
-  agents: z6.any().optional().describe("Agent(s) to supervise"),
-  message: z6.string().describe("Task or message for the supervisor to handle"),
-  systemMessage: z6.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
-import { createSupervisor } from "@langchain/langgraph-supervisor";
-import { HumanMessage } from "@langchain/core/messages";
-import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
-var checkpointer = new MemorySaver();
-var store = new 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 (fieldValues) => {
-  const outer = fieldValues ?? {};
-  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 = createSupervisor({
-      llm: llmInstance,
-      agents: supervisorAgents,
-      prompt: finalSystemPrompt
-    });
-    const app = workflow.compile({
-      checkpointer,
-      store
-    });
-    if (stream && emitter) {
-      try {
-        const streamIterator = await app.stream(
-          { messages: [new 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 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
-import { z as z7 } from "zod";
-var CustomToolSchema = z7.object({
-  input: z7.string().optional().describe("Input for the tool")
-});
-var AiToolNodeSchema = z7.object({
-  name: z7.string().describe("Name of the tool"),
-  description: z7.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: z7.any().describe("The function to execute"),
-  nodeType: z7.string().describe("The type of the node the tool represents"),
-  originalNodeData: z7.any().optional().describe("Original data of the node"),
-  workflowService: z7.any().optional().describe("Service for workflow operations"),
-  currentResults: z7.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
-import { tool } from "@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 (fieldValues) => {
-  const { name, description, nodeFunction, nodeType, originalNodeData, workflowService, currentResults } = fieldValues;
-  const schema = schemas[nodeType] || CustomToolSchema;
-  const dynamicTool = 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
-import { z as z8 } from "zod";
-var IaMessageNodeSchema = z8.object({
-  model: z8.any().describe("LLM model to use"),
-  systemMessage: z8.string().optional().describe("System message for context"),
-  message: z8.string().describe("User message to send to the LLM")
-});
-var IaMessageNodeFunction = async (inputs) => {
-  const fieldValues = inputs.fieldValues || inputs;
-  const { model, systemMessage, message } = fieldValues;
-  const authToken = inputs.authToken;
-  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 integration2 ");
-    }
-    const streaming = Boolean(inputs?.stream);
-    llmInstance = await createLLMFromModel(model, authToken, streaming);
-  } else {
-    llmInstance = model;
-  }
-  const messages = [];
-  if (systemMessage) {
-    messages.push(["system", systemMessage]);
-  }
-  messages.push(["human", message]);
-  try {
-    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
-import { z as z9 } from "zod";
-var WhatsappSendTemplateNodeSchema = z9.object({
-  phoneNumber: z9.string().describe("Phone number to send the message to"),
-  message: z9.string().describe("Message to send")
-});
-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
-import { z as z10 } from "zod";
-var WhatsappSendMessageNodeSchema = z10.object({
-  phoneNumber: z10.string().describe("Phone number to send the message to"),
-  message: z10.string().describe("Message content to send")
-});
-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/consts/nodes.ts
-var nodes = [
-  ChatInputNode,
-  ManualTriggerNode,
-  HttpGetInputNode,
-  // HttpPostInputNode,
-  // TransformNode,
-  ConcatNode,
-  OutputNode,
-  ChatOutputNode,
-  IaMessageNode,
-  IaAgentNode,
-  AiToolNode,
-  AiSupervisorNode,
-  WhatsappSendTemplateNode,
-  WhatsappSendMessageNode,
-  WhatsappMessageTriggerNode
-];
-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,
-  HttpOutput: HttpOutputNodeFunction,
-  ConcatNode: ConcatNodeFunction,
-  IaMessageNode: IaMessageNodeFunction,
-  IaAgentNode: IaAgentNodeFunction,
-  AiToolNode: AiToolNodeFunction,
-  AiSupervisorNode: AiSupervisorNodeFunction,
-  WhatsappNode: WhatsappStartChatFunction,
-  WhatsappSendMessageNode: WhatsappSendMessageFunction
-};
-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
-import { z as z11 } from "zod";
-var HttpPutInputNodeSchema = z11.object({
-  route: RouteSchema,
-  queryParams: z11.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z11.array(HeaderSchema).optional().describe("Headers configuration"),
-  body: z11.array(BodyFieldSchema).optional().describe("Body fields configuration")
-});
-
-// 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
-import { z as z12 } from "zod";
-var HttpDeleteInputNodeSchema = z12.object({
-  route: RouteSchema,
-  queryParams: z12.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z12.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
-import { z as z13 } from "zod";
-var HttpPatchInputNodeSchema = z13.object({
-  route: RouteSchema,
-  queryParams: z13.array(QueryParamSchema).optional().describe("Query parameters configuration"),
-  headers: z13.array(HeaderSchema).optional().describe("Headers configuration"),
-  body: z13.array(BodyFieldSchema).optional().describe("Body fields configuration")
-});
-
-// 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);
-};
-export {
-  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,
-  node_functions_default as nodeFunctions,
-  nodes_default as nodes,
-  schemas
-};