@atomoz/workflows-nodes 0.1.16 → 0.1.18

package/dist/index.js

@@ -60,7 +60,9 @@ var HttpGetInputNode = {
 
 // src/nodes/inputs/http/get/function.ts
 var HttpGetInputNodeFunction = async (params) => {
-  const { request, fieldValues } = 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 || {},
@@ -187,7 +189,9 @@ var HttpPostInputNode = {
 
 // src/nodes/inputs/http/post/function.ts
 var HttpPostInputNodeFunction = (params) => {
-  const { request, fieldValues } = 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");
@@ -233,7 +237,9 @@ var HttpPostInputNodeSchema = z3.object({
 
 // src/nodes/inputs/chat/chat.ts
 var ChatInputNodeFunction = (params) => {
-  const { request, fieldValues } = 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 ?? "",
@@ -286,7 +292,8 @@ var ChatInputNode = {
 
 // src/nodes/inputs/manual/trigger.ts
 var ManualTriggerNodeFunction = (params) => {
-  const { fieldValues } = params || {};
+  const { $field: _$field, $req: _$req, $inputs: _$inputs, $vars: _$vars } = params;
+  const fieldValues = params.fieldValues || {};
   return fieldValues || {};
 };
 var ManualTriggerNode = {
@@ -323,11 +330,143 @@ var ManualTriggerNode = {
   ]
 };
 
+// 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/delay/index.ts
+var DelayNode = {
+  label: "Delay",
+  type: "DelayNode",
+  category: "step",
+  icon: "\u23F3",
+  description: "Pausa o workflow por um tempo determinado",
+  tags: {
+    execution: "async",
+    group: "Control"
+  },
+  fields: [
+    {
+      id: "input",
+      label: "Trigger",
+      type: "any",
+      required: false,
+      handle: {
+        type: "input",
+        label: "Start",
+        name: "trigger",
+        fieldType: "any"
+      }
+    },
+    {
+      id: "duration",
+      label: "Dura\xE7\xE3o",
+      type: "number",
+      required: true,
+      defaultValue: 1
+    },
+    {
+      id: "unit",
+      label: "Unidade",
+      type: "select",
+      defaultValue: "minutes",
+      required: true,
+      options: [
+        { label: "Segundos", value: "seconds" },
+        { label: "Minutos", value: "minutes" },
+        { label: "Horas", value: "hours" },
+        { label: "Dias", value: "days" }
+      ]
+    },
+    {
+      id: "output",
+      label: "Continue",
+      type: "any",
+      required: false,
+      handle: {
+        type: "output",
+        label: "Continue",
+        name: "continue",
+        fieldType: "any"
+      }
+    }
+  ]
+};
+
 // src/nodes/processors/concat.ts
 import { z as z4 } from "zod";
-var ConcatNodeFunction = (inputs) => {
-  const input1 = inputs.input1 || "";
-  const input2 = inputs.input2 || "";
+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,
@@ -507,8 +646,12 @@ var OutputNode = {
 
 // src/nodes/outputs/chat/output.ts
 var ChatOutputNodeFunction = async (params) => {
-  const { inputs, fieldValues, stream, emitter } = params || {};
-  const content = inputs?.data ?? fieldValues?.data ?? "";
+  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 });
@@ -670,7 +813,7 @@ import { createReactAgent } from "@langchain/langgraph/prebuilt";
 import { SystemMessage } from "@langchain/core/messages";
 
 // src/utils/llm-factory.ts
-import { GraphQLClient, gql } from "graphql-request";
+import { 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";
@@ -695,44 +838,12 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
     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);
+  const provider = "gemini";
   switch (provider) {
     case "gemini":
       return new ChatGoogle({
         model: "gemini-flash-latest",
-        apiKey,
+        apiKey: "AIzaSyAWS9GhesWxG4uTdJRQbBziMB1diXtXtlI",
         streaming
       });
     case "openai":
@@ -756,21 +867,14 @@ async function createLLMFromModel(modelConfig, authToken, streaming = false) {
       );
   }
 }
-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 { $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.");
   }
@@ -792,8 +896,7 @@ IMPORTANT: You must base your response on the last message in the conversation h
     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);
+    llmInstance = await createLLMFromModel(model, authToken, stream);
   } else if (typeof model?.bindTools === "function") {
     llmInstance = model;
   } else {
@@ -809,22 +912,70 @@ IMPORTANT: You must base your response on the last message in the conversation h
   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 = "";
+      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) {
@@ -973,8 +1124,9 @@ var extractFinalResponse = (messages) => {
   }
   return "No response generated.";
 };
-var AiSupervisorNodeFunction = async (fieldValues) => {
-  const outer = fieldValues ?? {};
+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;
@@ -1194,7 +1346,9 @@ var schemas = {
 };
 
 // src/nodes/ia/tool/function.ts
-var AiToolNodeFunction = async (fieldValues) => {
+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 = tool(
@@ -1237,9 +1391,12 @@ var IaMessageNodeSchema = z8.object({
   message: z8.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");
   }
@@ -1249,10 +1406,9 @@ var IaMessageNodeFunction = async (inputs) => {
   let llmInstance;
   if (model?.model && model?.integrationId) {
     if (!authToken) {
-      throw new Error("Auth token is required to instantiate LLM from integration2 ");
+      throw new Error("Auth token is required to instantiate LLM from integration");
     }
-    const streaming = Boolean(inputs?.stream);
-    llmInstance = await createLLMFromModel(model, authToken, streaming);
+    llmInstance = await createLLMFromModel(model, authToken, stream);
   } else {
     llmInstance = model;
   }
@@ -1262,6 +1418,29 @@ var IaMessageNodeFunction = async (inputs) => {
   }
   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,
@@ -1493,19 +1672,75 @@ var WhatsappMessageTriggerNode = {
 
 // src/nodes/processors/custom-code.ts
 var NodeFunction = (params) => {
-  const { inputValue, fieldValues } = params;
-  const { customCode } = fieldValues;
-  if (!customCode) {
-    return inputValue;
+  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 customFunction = new Function("input", "context", "request", "params", customCode);
-    const result = customFunction(inputValue, fieldValues, params.request, params);
+    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",
@@ -1518,7 +1753,13 @@ var CustomCodeNode = {
       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;',
+      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",
@@ -1547,6 +1788,8 @@ var CustomCodeNode = {
 var nodes = [
   ChatInputNode,
   ManualTriggerNode,
+  CronTriggerNode,
+  DelayNode,
   HttpGetInputNode,
   // HttpPostInputNode,
   // TransformNode,
@@ -1665,6 +1908,7 @@ var nodeFunctions = {
   HttpGetInput: HttpGetInputNodeFunction,
   HttpPostInput: HttpPostInputNodeFunction,
   ManualTrigger: ManualTriggerNodeFunction,
+  CronTrigger: CronTriggerNodeFunction,
   HttpOutput: HttpOutputNodeFunction,
   ConcatNode: ConcatNodeFunction,
   IaMessageNode: IaMessageNodeFunction,
@@ -1673,7 +1917,8 @@ var nodeFunctions = {
   AiSupervisorNode: AiSupervisorNodeFunction,
   WhatsappNode: WhatsappStartChatFunction,
   WhatsappSendMessageNode: WhatsappSendMessageFunction,
-  CustomCodeNode: NodeFunction
+  CustomCodeNode: NodeFunction,
+  CustomNode: CustomNodeFunction
 };
 var node_functions_default = nodeFunctions;
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@atomoz/workflows-nodes",
-    "version": "0.1.16",
+    "version": "0.1.18",
     "description": "Atomoz Workflows - Node Library",
     "type": "module",
     "main": "./dist/index.js",
@@ -35,17 +35,20 @@
         "build": "tsup index.ts --dts --format esm,cjs --target node18 --out-dir dist --clean --tsconfig tsconfig.build.json",
         "dev": "tsup index.ts --dts --format esm,cjs --target node18 --out-dir dist --watch --tsconfig tsconfig.build.json"
     },
+    "peerDependencies": {
+        "zod": ">=3.0.0 || >=4.0.0"
+    },
     "dependencies": {
         "@langchain/core": "^0.3.66",
         "@langchain/google-gauth": "^0.2.16",
         "@langchain/langgraph": "^0.4.3",
         "@langchain/langgraph-supervisor": "^0.0.17",
         "@langchain/openai": "^0.6.3",
-        "graphql-request": "^7.2.0",
-        "zod": "^4.0.14"
+        "graphql-request": "^7.2.0"
     },
     "devDependencies": {
         "tsup": "^8.2.4",
-        "typescript": "^5.6.3"
+        "typescript": "^5.6.3",
+        "zod": "^4.0.14"
     }
-}
+}