@atomoz/workflows-nodes 0.1.11 → 0.1.12

package/src/nodes/ia/supervisor/data.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+export const AiSupervisorNodeSchema = z.object({
+    model: z.any().describe("LLM model for the supervisor"),
+    agents: z.any().optional().describe("Agent(s) to supervise"),
+    message: z.string().describe("Task or message for the supervisor to handle"),
+    systemMessage: z.string().optional().describe("Custom system message for the supervisor"),
+});
+export const AiSupervisorNode = {
+    label: "AI Supervisor",
+    type: "AiSupervisorNode",
+    category: "step",
+    description: "Coordinates multiple agents to perform tasks manually",
+    icon: "👀",
+    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',
+            }
+        }
+    ]
+};

package/src/nodes/ia/supervisor/function.d.ts

@@ -0,0 +1,2 @@
+export declare const AiSupervisorNodeFunction: (fieldValues: any) => Promise<any>;
+//# sourceMappingURL=function.d.ts.map

package/src/nodes/ia/supervisor/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/ia/supervisor/function.ts"],"names":[],"mappings":"AAwEA,eAAO,MAAM,wBAAwB,GAAU,aAAa,GAAG,KAAG,OAAO,CAAC,GAAG,CAmL5E,CAAA"}

package/src/nodes/ia/supervisor/function.js

@@ -0,0 +1,227 @@
+"use server";
+import { createSupervisor } from "@langchain/langgraph-supervisor";
+import { HumanMessage } from "@langchain/core/messages";
+import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
+import { createLLMFromModel } from "../../../utils/llm-factory";
+const checkpointer = new MemorySaver();
+const store = new InMemoryStore();
+const extractSupervisorAgents = (agents) => {
+    if (Array.isArray(agents)) {
+        return agents.map((a) => a.agent).filter(Boolean);
+    }
+    if (agents?.agent) {
+        return [agents.agent];
+    }
+    return [agents];
+};
+const extractFinalResponse = (messages) => {
+    if (!messages || messages.length === 0)
+        return 'No response generated.';
+    // Heurísticas para ignorar mensagens de ferramenta/transferência
+    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;
+    };
+    // Preferir a última mensagem textual que não seja de ferramenta nem de transferência
+    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;
+        }
+    }
+    // Fallback: tenta última mensagem com conteúdo textual
+    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.';
+};
+export const AiSupervisorNodeFunction = async (fieldValues) => {
+    // Merge outer-level (transport flags/emitter) with inner-level (node inputs)
+    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.");
+        // Instanciar LLM a partir do model config
+        let llmInstance;
+        if (model?.model && model?.integrationId) {
+            // Model é um objeto com integrationId, criar instância
+            if (!authToken) {
+                throw new Error("Auth token is required to instantiate LLM from integration 3");
+            }
+            llmInstance = await createLLMFromModel(model, authToken, stream);
+        }
+        else {
+            // Model já é uma instância de LLM
+            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 {
+                // Use a consistent thread_id to maintain conversation context
+                const streamIterator = await app.stream({ messages: [new HumanMessage({ content: message })] }, { recursionLimit: 150, configurable: { thread_id: 'conversation' } });
+                let finalMessages = [];
+                const previousStepMessages = new Map(); // Track message count per agent
+                const sentMessages = new Set(); // Track already sent messages by content hash
+                let stepCount = 0;
+                for await (const step of streamIterator) {
+                    stepCount++;
+                    // Process each agent in this step and show only NEW messages added in THIS step
+                    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;
+                                    // Get how many messages this agent had in previous steps
+                                    const previousCount = previousStepMessages.get(agentKey) || 0;
+                                    const currentCount = currentMessages.length;
+                                    // Only show messages that are NEW in this step (beyond previous count)
+                                    if (currentCount > previousCount) {
+                                        const newMessages = currentMessages.slice(previousCount);
+                                        // Process each new message and create structured data
+                                        const structuredMessages = newMessages.map((msg) => {
+                                            const msgContent = msg?.content || '';
+                                            const msgName = msg?.name || '';
+                                            const toolCallId = msg?.tool_call_id;
+                                            // Detect if it's a tool message
+                                            const isTool = !!(toolCallId || msgName.includes('transfer_') || msgContent.includes('Successfully transferred'));
+                                            // Detect if it's an agent (not tool AND not supervisor)
+                                            const isAgent = !isTool && agentKey !== 'supervisor';
+                                            // Extract name (agent name or tool name)
+                                            let name = '';
+                                            if (isTool) {
+                                                if (msgName.includes('transfer_')) {
+                                                    name = msgName;
+                                                }
+                                                else {
+                                                    name = 'transfer_tool';
+                                                }
+                                            }
+                                            else if (isAgent) {
+                                                name = msgName || agentKey;
+                                            }
+                                            else {
+                                                // Always use 'supervisor' for supervisor messages
+                                                name = agentKey === 'supervisor' ? 'supervisor' : agentKey;
+                                            }
+                                            return {
+                                                isTool,
+                                                isAgent,
+                                                name,
+                                                message: msgContent.trim()
+                                            };
+                                        }).filter(item => item.message); // Only include messages with content
+                                        if (structuredMessages.length > 0) {
+                                            structuredMessages.forEach((structuredMsg) => {
+                                                // Create unique hash for deduplication
+                                                const messageHash = `${structuredMsg.name}-${structuredMsg.message.slice(0, 100)}`;
+                                                if (!sentMessages.has(messageHash)) {
+                                                    sentMessages.add(messageHash);
+                                                    // Send complete message via delta for natural streaming display
+                                                    if (emitter?.emitDelta) {
+                                                        emitter.emitDelta({
+                                                            content: structuredMsg.message,
+                                                            actor: structuredMsg.name,
+                                                            isAgent: structuredMsg.isAgent,
+                                                            isTool: structuredMsg.isTool
+                                                        });
+                                                    }
+                                                }
+                                            });
+                                        }
+                                        // Update the count for this agent
+                                        previousStepMessages.set(agentKey, currentCount);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                const finalResponse = extractFinalResponse(finalMessages);
+                return {
+                    output: finalResponse,
+                    function: AiSupervisorNodeFunction,
+                    type: "AiSupervisorNode"
+                };
+            }
+            catch (err) {
+                console.error('❌ Streaming error:', err);
+                throw err;
+            }
+        }
+        else {
+            // Use consistent thread_id for non-streaming mode too
+            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('❌ AiSupervisorNode - Error:', error);
+        return {
+            output: `Error: ${error instanceof Error ? error.message : String(error)}`,
+            function: AiSupervisorNodeFunction,
+            type: "AiSupervisorNode"
+        };
+    }
+};

package/src/nodes/ia/supervisor/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data';
+export * from './function';
+//# sourceMappingURL=index.d.ts.map

package/src/nodes/ia/supervisor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/ia/supervisor/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC"}

package/src/nodes/ia/supervisor/index.js

@@ -0,0 +1,2 @@
+export * from './data';
+export * from './function';

package/src/nodes/ia/tool/data.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { NodeData } from "../../types/base-node";
+export declare const CustomToolSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AiToolNodeSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    nodeFunction: z.ZodAny;
+    nodeType: z.ZodString;
+    originalNodeData: z.ZodOptional<z.ZodAny>;
+    workflowService: z.ZodOptional<z.ZodAny>;
+    currentResults: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export declare const AiToolNode: NodeData;
+//# sourceMappingURL=data.d.ts.map

package/src/nodes/ia/tool/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/ia/tool/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGjD,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;iBAS3B,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,QAsDxB,CAAA"}

package/src/nodes/ia/tool/data.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+// Schema para o CustomTool como fallback
+export const CustomToolSchema = z.object({
+    input: z.string().optional().describe("Input for the tool"),
+});
+export const AiToolNodeSchema = z.object({
+    name: z.string().describe("Name of the tool"),
+    description: 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: z.any().describe("The function to execute"),
+    nodeType: z.string().describe("The type of the node the tool represents"),
+    originalNodeData: z.any().optional().describe("Original data of the node"),
+    workflowService: z.any().optional().describe("Service for workflow operations"),
+    currentResults: z.any().optional().describe("Current results in the workflow"),
+});
+export const AiToolNode = {
+    label: 'AI Tool',
+    type: 'AiToolNode',
+    category: 'step',
+    description: 'Wraps another node to be used as a tool by an AI agent',
+    icon: '🛠️',
+    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'],
+            }
+        }
+    ]
+};

package/src/nodes/ia/tool/function.d.ts

@@ -0,0 +1,4 @@
+export declare const AiToolNodeFunction: (fieldValues: any) => Promise<{
+    tool: any;
+}>;
+//# sourceMappingURL=function.d.ts.map

package/src/nodes/ia/tool/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/ia/tool/function.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,kBAAkB,GAAU,aAAa,GAAG,KAAG,OAAO,CAAC;IAAE,IAAI,EAAE,GAAG,CAAA;CAAE,CAwChF,CAAA"}

package/src/nodes/ia/tool/function.js

@@ -0,0 +1,36 @@
+"use server";
+import { tool } from "@langchain/core/tools";
+import { schemas } from "../../consts/schemas";
+import { CustomToolSchema } from "./data";
+export const 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: 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: schema,
+    });
+    return {
+        tool: dynamicTool
+    };
+};

package/src/nodes/ia/tool/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data';
+export * from './function';
+//# sourceMappingURL=index.d.ts.map

package/src/nodes/ia/tool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/ia/tool/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC"}

package/src/nodes/ia/tool/index.js

@@ -0,0 +1,2 @@
+export * from './data';
+export * from './function';

package/src/nodes/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types/base-node';
+export * from './types/base-node.types';
+export { default as nodes } from './consts/nodes';
+export { default as nodeFunctions } from './consts/node-functions';
+export * from './ia';
+export * from './inputs/http';
+export * from './consts/schemas';
+export * from './social';
+//# sourceMappingURL=index.d.ts.map

package/src/nodes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../libs/nodes/src/nodes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACnE,cAAc,MAAM,CAAC;AACrB,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC"}

package/src/nodes/index.js

@@ -0,0 +1,8 @@
+export * from './types/base-node';
+export * from './types/base-node.types';
+export { default as nodes } from './consts/nodes';
+export { default as nodeFunctions } from './consts/node-functions';
+export * from './ia';
+export * from './inputs/http';
+export * from './consts/schemas';
+export * from './social';

package/src/nodes/inputs/chat/chat.d.ts

@@ -0,0 +1,4 @@
+import { NodeData } from "../../types/base-node";
+export declare const ChatInputNodeFunction: (params: any) => any;
+export declare const ChatInputNode: NodeData;
+//# sourceMappingURL=chat.d.ts.map

package/src/nodes/inputs/chat/chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../../../../../libs/nodes/src/nodes/inputs/chat/chat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,eAAO,MAAM,qBAAqB,GAAI,QAAQ,GAAG,KAAG,GAcnD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAsC3B,CAAC"}

package/src/nodes/inputs/chat/chat.js

@@ -0,0 +1,51 @@
+export const 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;
+};
+export const ChatInputNode = {
+    label: "Chat Input",
+    type: "ChatInput",
+    category: "input",
+    icon: "💬",
+    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",
+            },
+        },
+    ],
+};

package/src/nodes/inputs/http/delete/data.d.ts

@@ -0,0 +1,3 @@
+import { NodeData } from "../../../types/base-node";
+export declare const HttpDeleteInputNode: NodeData;
+//# sourceMappingURL=data.d.ts.map

package/src/nodes/inputs/http/delete/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/nodes/src/nodes/inputs/http/delete/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,eAAO,MAAM,mBAAmB,EAAE,QAwDjC,CAAC"}

package/src/nodes/inputs/http/delete/data.js

@@ -0,0 +1,57 @@
+export const HttpDeleteInputNode = {
+    label: 'Http DELETE Input',
+    type: 'HttpDeleteInput',
+    category: 'input',
+    icon: '🗑️',
+    description: 'Node que representa uma rota DELETE HTTP para remoção 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',
+            }
+        }
+    ]
+};

package/src/nodes/inputs/http/delete/function.d.ts

@@ -0,0 +1,2 @@
+export declare const HttpDeleteInputNodeFunction: (params: any) => Promise<any>;
+//# sourceMappingURL=function.d.ts.map

package/src/nodes/inputs/http/delete/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/nodes/src/nodes/inputs/http/delete/function.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,GAAU,QAAQ,GAAG,KAAG,OAAO,CAAC,GAAG,CA+B1E,CAAC"}