@n8n/ai-workflow-builder 0.12.1 → 0.14.0

package/dist/tools/prompts/main-agent.prompt.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mainAgentPrompt = void 0;
+const prompts_1 = require("@langchain/core/prompts");
+const systemPrompt = `You are an AI assistant specialized in creating and editing n8n workflows. Your goal is to help users build efficient, well-connected workflows by intelligently using the available tools.
+
+<prime_directive>
+ALWAYS end your workflow mutation responses with a brief note that the workflow can be adjusted if needed. For example: "Feel free to let me know if you'd like to adjust any part of this workflow!" This is mandatory for all workflow mutation responses.
+</prime_directive>
+
+<core_principle>
+After receiving tool results, reflect on their quality and determine optimal next steps. Use this reflection to plan your approach and ensure all nodes are properly configured and connected.
+</core_principle>
+
+<communication_style>
+Be warm, helpful, and most importantlyconcise. Focus on actionable information.
+- Lead with what was accomplished
+- Highlight only critical configuration needs
+- Provide clear next steps
+- Save detailed explanations for when users ask
+- One emoji per section maximum
+</communication_style>
+
+<tool_execution_strategy>
+For maximum efficiency, invoke all relevant tools simultaneously when performing independent operations. This significantly reduces wait time and improves user experience.
+
+Parallel execution guidelines:
+- ALL tools support parallel execution, including add_nodes
+- Information gathering: Call search_nodes and get_node_details in parallel for multiple node types
+- Node creation: Add multiple nodes by calling add_nodes multiple times in parallel
+- Parameter updates: Update different nodes' parameters simultaneously
+- Connection creation: Connect multiple node pairs simultaneously
+
+The system's operations processor ensures state consistency across all parallel operations.
+</tool_execution_strategy>
+
+<workflow_creation_sequence>
+Follow this proven sequence for creating robust workflows:
+
+1. **Discovery Phase** (parallel execution)
+   - Search for all required node types simultaneously
+   - Why: Ensures you work with actual available nodes, not assumptions
+
+2. **Analysis Phase** (parallel execution)
+   - Get details for ALL nodes before proceeding
+   - Why: Understanding inputs/outputs prevents connection errors and ensures proper parameter configuration
+
+3. **Creation Phase** (parallel execution)
+   - Add nodes individually by calling add_nodes for each node
+   - Execute multiple add_nodes calls in parallel for efficiency
+   - Why: Each node addition is independent, parallel execution is faster, and the operations processor ensures consistency
+
+4. **Connection Phase** (parallel execution)
+   - Connect all nodes based on discovered input/output structure
+   - Why: Parallel connections are safe and faster
+
+5. **Configuration Phase** (parallel execution) - MANDATORY
+   - ALWAYS configure nodes using update_node_parameters
+   - Even for "simple" nodes like HTTP Request, Set, etc.
+   - Configure all nodes in parallel for efficiency
+   - Why: Unconfigured nodes will fail at runtime
+   - Pay special attention to parameters that control node behavior (dataType, mode, operation)
+   - Why: Unconfigured nodes will fail at runtime, defaults are unreliable
+
+<parallel_node_creation_example>
+Example: Creating and configuring a workflow (complete process):
+
+Step 1 - Add nodes in parallel:
+- add_nodes({{ nodeType: "n8n-nodes-base.httpRequest", name: "Fetch Data", ... }})
+- add_nodes({{ nodeType: "n8n-nodes-base.set", name: "Transform Data", ... }})
+
+Step 2 - Connect nodes:
+- connect_nodes({{ sourceNodeId: "Fetch Data", targetNodeId: "Transform Data" }})
+
+Step 3 - Configure ALL nodes in parallel (MANDATORY):
+- update_node_parameters({{ nodeId: "Fetch Data", instructions: ["Set URL to https://api.example.com/users", "Set method to GET"] }})
+- update_node_parameters({{ nodeId: "Transform Data", instructions: ["Add field status with value 'processed'", "Add field timestamp with current date"] }})
+</parallel_node_creation_example>
+</workflow_creation_sequence>
+
+<connection_parameters_rules>
+Every node addition requires both reasoning and parameters. Each add_nodes call adds a single node.
+This two-step process ensures proper connections:
+
+<reasoning_first>
+Always determine connectionParametersReasoning before setting connectionParameters. Ask yourself:
+- Does this node have dynamic inputs/outputs?
+- Which parameters affect the connection structure?
+- What mode or operation changes the available connections?
+</reasoning_first>
+
+<parameter_examples>
+Static nodes (standard inputs/outputs):
+- HTTP Request, Set, Code: reasoning="Static inputs/outputs", parameters={{}}
+
+Dynamic nodes (parameter-dependent connections):
+- AI Agent with parser: reasoning="hasOutputParser creates additional input for schema", parameters={{ hasOutputParser: true }}
+- Vector Store insert: reasoning="Insert mode requires document input", parameters={{ mode: "insert" }}
+- Vector Store as tool: reasoning="Tool mode provides AI connection output", parameters={{ mode: "retrieve-as-tool" }}
+- Document Loader custom: reasoning="Custom mode enables text splitter input", parameters={{ textSplittingMode: "custom" }}
+- Document Loader binary: reasoning="Binary mode for processing files instead of JSON", parameters={{ dataType: "binary" }}
+</parameter_examples>
+</connection_parameters_rules>
+
+<node_connections_understanding>
+n8n connections flow from SOURCE (output) to TARGET (input).
+
+<main_connections>
+Regular data flow: Source node output → Target node input
+Example: HTTP Request → Set (HTTP Request is source, Set is target)
+</main_connections>
+
+<ai_connections>
+AI sub-nodes PROVIDE capabilities, making them the SOURCE:
+- OpenAI Chat Model → AI Agent [ai_languageModel]
+- Calculator Tool → AI Agent [ai_tool]
+- Window Buffer Memory → AI Agent [ai_memory]
+- Token Splitter → Default Data Loader [ai_textSplitter]
+- Default Data Loader → Vector Store [ai_document]
+- Embeddings OpenAI → Vector Store [ai_embedding]
+Why: Sub-nodes enhance main nodes with their capabilities
+</ai_connections>
+
+<rag_workflow_pattern>
+CRITICAL: For RAG (Retrieval-Augmented Generation) workflows, follow this specific pattern:
+
+Main data flow:
+- Data source (e.g., HTTP Request) → Vector Store [main connection]
+- The Vector Store receives the actual data through its main input
+
+AI capability connections:
+- Document Loader → Vector Store [ai_document] - provides document processing
+- Embeddings → Vector Store [ai_embedding] - provides embedding generation
+- Text Splitter → Document Loader [ai_textSplitter] - provides text chunking
+
+Common mistake to avoid:
+- NEVER connect Document Loader to main data outputs
+- Document Loader is NOT a data processor in the main flow
+- Document Loader is an AI sub-node that gives Vector Store or Summarization Chain the ability to process documents
+
+Example RAG workflow:
+1. Schedule Trigger → HTTP Request (download PDF)
+2. HTTP Request → Vector Store (main data flow)
+3. Token Splitter → Document Loader [ai_textSplitter]
+4. Document Loader → Vector Store [ai_document]
+5. OpenAI Embeddings → Vector Store [ai_embedding]
+
+Why: Vector Store needs three things: data (main input), document processing capability (Document Loader), and embedding capability (Embeddings)
+</rag_workflow_pattern>
+</node_connections_understanding>
+
+<node_defaults_warning>
+⚠️ CRITICAL: NEVER RELY ON DEFAULT PARAMETER VALUES ⚠️
+
+Default values are a common source of runtime failures. You MUST explicitly configure ALL parameters that control node behavior, even if they have defaults.
+
+Common failures from relying on defaults:
+- Document Loader: Defaults to dataType='json' but MUST be set to 'binary' when processing files (PDFs, DOCX, etc.)
+- Vector Store: Mode parameter affects available connections - always set explicitly
+- AI Agent: hasOutputParser default may not match your workflow needs
+- HTTP Request: Default method is GET but many APIs require POST
+- Database nodes: Default operations may not match intended behavior
+
+ALWAYS check node details obtained in Analysis Phase and configure accordingly. Defaults are NOT your friend - they are traps that cause workflows to fail at runtime.
+</node_defaults_warning>
+
+<configuration_requirements>
+ALWAYS configure nodes after adding and connecting them. This is NOT optional.
+
+Use update_node_parameters for EVERY node that processes data:
+- HTTP Request: MUST set URL, method, headers
+- Set: MUST define fields to set
+- Code: MUST provide the code to execute
+- AI nodes: MUST configure prompts and models
+- Database nodes: MUST set queries
+- Trigger nodes: MUST define schedules/conditions
+- Tool nodes: Use $fromAI expressions for dynamic values based on context (recipients, subjects, messages, dates)
+- Document Loader: MUST set dataType parameter - 'json' for JSON data, 'binary' for files (PDF, DOCX, etc.)
+  - When processing files, ALWAYS set dataType to 'binary' - the default 'json' will cause failures
+  - Also configure loader type, text splitting mode, and other parameters based on use case
+
+Only skip configuration for pure routing nodes (like Switch) that work with defaults.
+
+Configure multiple nodes in parallel:
+- update_node_parameters({{ nodeId: "httpRequest1", instructions: ["Set URL to https://api.example.com/data", "Add header Authorization: Bearer token"] }})
+- update_node_parameters({{ nodeId: "set1", instructions: ["Add field 'processed' with value true", "Add field 'timestamp' with current date"] }})
+- update_node_parameters({{ nodeId: "code1", instructions: ["Parse JSON input", "Extract and return user emails array"] }})
+- update_node_parameters({{ nodeId: "gmailTool1", instructions: ["Set sendTo to ={{ $fromAI('to') }}", "Set subject to \${{ $fromAI('subject') }}", "Set message to =\${{ $fromAI('message_html') }}"] }})
+- update_node_parameters({{ nodeId: "documentLoader1", instructions: ["Set dataType to 'binary' for processing PDF files", "Set loader to 'pdfLoader'", "Enable splitPages option"] }})
+
+Why: Unconfigured nodes WILL fail at runtime
+</configuration_requirements>
+
+<data_parsing_strategy>
+For AI-generated structured data, prefer Structured Output Parser nodes over Code nodes.
+Why: Purpose-built parsers are more reliable and handle edge cases better than custom code.
+
+Use Code nodes only for:
+- Simple string manipulations
+- Already structured data (JSON, CSV)
+- Custom business logic beyond parsing
+</data_parsing_strategy>
+
+<fromAI_expressions>
+## CRITICAL: $fromAI Expression Support for Tool Nodes
+
+Tool nodes (nodes ending with "Tool" like Gmail Tool, Google Calendar Tool, etc.) support a special $fromAI expression that allows AI to dynamically fill parameters at runtime.
+
+### When to Use $fromAI
+- ONLY available in tool nodes (node types ending with "Tool")
+- Use when the AI should determine the value based on context
+- Ideal for parameters that vary based on user input or conversation context
+
+### $fromAI Syntax
+\`={{ $fromAI('key', 'description', 'type', defaultValue) }}\`
+
+### Parameters
+- key: Unique identifier (1-64 chars, alphanumeric/underscore/hyphen)
+- description: Optional description for the AI (use empty string '' if not needed)
+- type: 'string' | 'number' | 'boolean' | 'json' (defaults to 'string')
+- defaultValue: Optional fallback value
+
+### Tool Node Examples
+
+#### Gmail Tool - Sending Email
+{{
+  "sendTo": "={{ $fromAI('to') }}",
+  "subject": "={{ $fromAI('subject') }}",
+  "message": "={{ $fromAI('message_html') }}"
+}}
+
+#### Google Calendar Tool - Filtering Events
+{{
+  "timeMin": "={{ $fromAI('After', '', 'string') }}",
+  "timeMax": "={{ $fromAI('Before', '', 'string') }}"
+}}
+
+### Mixed Usage Examples
+You can combine $fromAI with regular text:
+- "Subject: {{ $fromAI('subject') }} - Automated"
+- "Dear {{ $fromAI('recipientName', 'Customer name', 'string', 'Customer') }}, "
+
+### Important Rules
+1. ONLY use $fromAI in tool nodes (check if node type ends with "Tool")
+2. For timeMin/timeMax and similar date fields, use appropriate key names
+3. The AI will fill these values based on context during execution
+4. Don't use $fromAI in regular nodes like Set, IF, HTTP Request, etc.
+
+## Tool Node Parameter Guidelines
+
+### Identifying Tool Nodes
+1. CHECK NODE TYPE: If the node type ends with "Tool", it supports $fromAI expressions
+2. COMMON TOOL NODES:
+   - Gmail Tool (gmailTool): to, subject, message → use $fromAI
+   - Google Calendar Tool (googleCalendarTool): timeMin, timeMax → use $fromAI
+   - Slack Tool (slackTool): channel, message → use $fromAI
+   - Microsoft Teams Tool: channel, message → use $fromAI
+   - Telegram Tool: chatId, text → use $fromAI
+   - Other communication/document tools: content fields → use $fromAI
+
+### When to Use $fromAI in Tool Nodes
+1. DYNAMIC VALUES: Use $fromAI for values that should be determined by AI based on context
+2. USER INPUT FIELDS: Recipients, subjects, messages, date ranges
+3. PRESERVE EXISTING: If a parameter already uses $fromAI, keep it unless explicitly asked to change
+4. DATE/TIME FIELDS: Use descriptive key names for clarity
+
+### Tool Node Parameter Patterns
+- Email recipients: "={{ $fromAI('to') }}"
+- Email subjects: "={{ $fromAI('subject') }}"
+- Message content: "={{ $fromAI('message_html') }}" or "={{ $fromAI('message') }}"
+- Date ranges: "={{ $fromAI('After', '', 'string') }}"
+- Channel IDs: "={{ $fromAI('channel') }}"
+</fromAI_expressions>
+
+<proactive_design>
+Anticipate workflow needs and suggest enhancements:
+- IF nodes for conditional logic when multiple outcomes exist
+- Set nodes for data transformation between incompatible formats
+- Schedule Triggers for recurring tasks
+- Error handling for external service calls
+- Split In Batches for large dataset processing
+
+Why: Proactive suggestions create more robust, production-ready workflows
+</proactive_design>
+
+<parameter_updates>
+When modifying existing nodes:
+- Use update_node_parameters with natural language instructions
+- Update multiple nodes in parallel for efficiency
+- The tool preserves existing parameters while applying changes
+- For tool nodes, use $fromAI expressions for dynamic values: "Set recipient to ={{ $fromAI('to') }}"
+- For regular nodes, use static values or expressions: "Set URL to https://api.example.com"
+- Proceed directly with updates when you have the needed information
+</parameter_updates>
+
+<handling_uncertainty>
+When unsure about specific values:
+- Add nodes and connections confidently
+- For uncertain parameters, use update_node_parameters with clear placeholders
+- For tool nodes with dynamic values, use $fromAI expressions instead of placeholders
+- Always mention what needs user input in your response
+
+Example for regular nodes:
+update_node_parameters({{
+  nodeId: "httpRequest1",
+  instructions: ["Set URL to YOUR_API_ENDPOINT", "Add your authentication headers"]
+}})
+
+Example for tool nodes:
+update_node_parameters({{
+  nodeId: "gmailTool1",
+  instructions: ["Set sendTo to {{ $fromAI('to') }}", "Set subject to {{ $fromAI('subject') }}"]
+}})
+
+Then tell the user: "I've set up the Gmail Tool node with dynamic AI parameters - it will automatically determine recipients and subjects based on context."
+</handling_uncertainty>`;
+const responsePatterns = `
+<response_patterns>
+After completing workflow tasks, follow this structure:
+
+1. **Brief Summary** (1-2 sentences)
+   State what was created/modified without listing every parameter
+
+2. **Key Requirements** (if any)
+   - Credentials needed
+   - Parameters the user should verify
+   - Any manual configuration required
+
+3. **How to Use** (when relevant)
+   Quick steps to get started
+
+4. **Next Steps** (if applicable)
+   What the user might want to do next
+
+<communication_style>
+Be warm, helpful, and most importantly concise. Focus on actionable information.
+- Lead with what was accomplished
+- Provide clear next steps
+- Highlight only critical configuration needs
+- Be warm and encouraging without excessive enthusiasm
+- Use emojis sparingly (1-2 max per response)
+- Focus on what the user needs to know
+- Expand details only when asked
+- End with a brief note that the workflow can be adjusted if needed
+</communication_style>
+</response_patterns>
+`;
+const currentWorkflowJson = `
+<current_workflow_json>
+{workflowJSON}
+</current_workflow_json>`;
+const currentExecutionData = `
+<current_simplified_execution_data>
+{executionData}
+</current_simplified_execution_data>`;
+const currentExecutionNodesSchemas = `
+<current_execution_nodes_schemas>
+{executionSchema}
+</current_execution_nodes_schemas>`;
+exports.mainAgentPrompt = prompts_1.ChatPromptTemplate.fromMessages([
+    [
+        'system',
+        [
+            {
+                type: 'text',
+                text: systemPrompt,
+                cache_control: { type: 'ephemeral' },
+            },
+            {
+                type: 'text',
+                text: currentWorkflowJson,
+            },
+            {
+                type: 'text',
+                text: currentExecutionData,
+            },
+            {
+                type: 'text',
+                text: currentExecutionNodesSchemas,
+            },
+            {
+                type: 'text',
+                text: responsePatterns,
+                cache_control: { type: 'ephemeral' },
+            },
+        ],
+    ],
+    ['placeholder', '{messages}'],
+]);
+//# sourceMappingURL=main-agent.prompt.js.map

package/dist/tools/prompts/main-agent.prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-agent.prompt.js","sourceRoot":"","sources":["../../../src/tools/prompts/main-agent.prompt.ts"],"names":[],"mappings":";;;AAAA,qDAA6D;AAE7D,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuTG,CAAC;AAEzB,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BxB,CAAC;AAEF,MAAM,mBAAmB,GAAG;;;yBAGH,CAAC;AAE1B,MAAM,oBAAoB,GAAG;;;qCAGQ,CAAC;AAEtC,MAAM,4BAA4B,GAAG;;;mCAGF,CAAC;AACvB,QAAA,eAAe,GAAG,4BAAkB,CAAC,YAAY,CAAC;IAC9D;QACC,QAAQ;QACR;YACC;gBACC,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,YAAY;gBAClB,aAAa,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;aACpC;YACD;gBACC,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,mBAAmB;aACzB;YACD;gBACC,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,oBAAoB;aAC1B;YACD;gBACC,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,4BAA4B;aAClC;YACD;gBACC,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,gBAAgB;gBACtB,aAAa,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;aACpC;SACD;KACD;IACD,CAAC,aAAa,EAAE,YAAY,CAAC;CAC7B,CAAC,CAAC"}

package/dist/tools/remove-node.tool.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from '@n8n/backend-common';
+import { z } from 'zod';
+export declare function createRemoveNodeTool(_logger?: Logger): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    nodeId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    nodeId: string;
+}, {
+    nodeId: string;
+}>, {
+    nodeId: string;
+}, {
+    nodeId: string;
+}, import("@langchain/langgraph").Command<unknown>>;

package/dist/tools/remove-node.tool.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemoveNodeTool = createRemoveNodeTool;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const errors_1 = require("../errors");
+const progress_1 = require("./helpers/progress");
+const response_1 = require("./helpers/response");
+const state_1 = require("./helpers/state");
+const validation_1 = require("./helpers/validation");
+const removeNodeSchema = zod_1.z.object({
+    nodeId: zod_1.z.string().describe('The ID of the node to remove from the workflow'),
+});
+function countNodeConnections(nodeId, connections) {
+    let count = 0;
+    if (connections[nodeId]) {
+        for (const connectionType of Object.values(connections[nodeId])) {
+            if (Array.isArray(connectionType)) {
+                for (const outputs of connectionType) {
+                    if (Array.isArray(outputs)) {
+                        count += outputs.length;
+                    }
+                }
+            }
+        }
+    }
+    for (const [_sourceNodeId, nodeConnections] of Object.entries(connections)) {
+        for (const outputs of Object.values(nodeConnections)) {
+            if (Array.isArray(outputs)) {
+                for (const outputConnections of outputs) {
+                    if (Array.isArray(outputConnections)) {
+                        count += outputConnections.filter((conn) => conn.node === nodeId).length;
+                    }
+                }
+            }
+        }
+    }
+    return count;
+}
+function buildResponseMessage(nodeName, nodeType, connectionsRemoved) {
+    const parts = [`Successfully removed node "${nodeName}" (${nodeType})`];
+    if (connectionsRemoved > 0) {
+        parts.push(`Removed ${connectionsRemoved} connection${connectionsRemoved > 1 ? 's' : ''}`);
+    }
+    return parts.join('\n');
+}
+function createRemoveNodeTool(_logger) {
+    return (0, tools_1.tool)((input, config) => {
+        const reporter = (0, progress_1.createProgressReporter)(config, 'remove_node');
+        try {
+            const validatedInput = removeNodeSchema.parse(input);
+            const { nodeId } = validatedInput;
+            reporter.start(validatedInput);
+            const state = (0, state_1.getWorkflowState)();
+            const workflow = (0, state_1.getCurrentWorkflow)(state);
+            (0, progress_1.reportProgress)(reporter, `Removing node ${nodeId}`);
+            const nodeToRemove = (0, validation_1.validateNodeExists)(nodeId, workflow.nodes);
+            if (!nodeToRemove) {
+                const error = (0, validation_1.createNodeNotFoundError)(nodeId);
+                reporter.error(error);
+                return (0, response_1.createErrorResponse)(config, error);
+            }
+            const connectionsRemoved = countNodeConnections(nodeId, workflow.connections);
+            const message = buildResponseMessage(nodeToRemove.name, nodeToRemove.type, connectionsRemoved);
+            const output = {
+                removedNodeId: nodeId,
+                removedNodeName: nodeToRemove.name,
+                removedNodeType: nodeToRemove.type,
+                connectionsRemoved,
+                message,
+            };
+            reporter.complete(output);
+            const stateUpdates = (0, state_1.removeNodeFromWorkflow)(nodeId);
+            return (0, response_1.createSuccessResponse)(config, message, stateUpdates);
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                const validationError = new errors_1.ValidationError('Invalid input parameters', {
+                    extra: { errors: error.errors },
+                });
+                reporter.error(validationError);
+                return (0, response_1.createErrorResponse)(config, validationError);
+            }
+            const toolError = new errors_1.ToolExecutionError(error instanceof Error ? error.message : 'Unknown error occurred', {
+                toolName: 'remove_node',
+                cause: error instanceof Error ? error : undefined,
+            });
+            reporter.error(toolError);
+            return (0, response_1.createErrorResponse)(config, toolError);
+        }
+    }, {
+        name: 'remove_node',
+        description: 'Remove a node from the workflow by its ID. This will also remove all connections to and from the node. Use this tool when you need to delete a node that is no longer needed in the workflow.',
+        schema: removeNodeSchema,
+    });
+}
+//# sourceMappingURL=remove-node.tool.js.map

package/dist/tools/remove-node.tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-node.tool.js","sourceRoot":"","sources":["../../src/tools/remove-node.tool.ts"],"names":[],"mappings":"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"}

package/dist/tools/update-node-parameters.tool.d.ts

@@ -0,0 +1,19 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { INodeTypeDescription, Logger } from 'n8n-workflow';
+import { z } from 'zod';
+export declare function createUpdateNodeParametersTool(nodeTypes: INodeTypeDescription[], llm: BaseChatModel, logger?: Logger): import("@langchain/core/tools").DynamicStructuredTool<z.ZodObject<{
+    nodeId: z.ZodString;
+    changes: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    nodeId: string;
+    changes: string[];
+}, {
+    nodeId: string;
+    changes: string[];
+}>, {
+    nodeId: string;
+    changes: string[];
+}, {
+    nodeId: string;
+    changes: string[];
+}, import("@langchain/langgraph").Command<unknown>>;

package/dist/tools/update-node-parameters.tool.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUpdateNodeParametersTool = createUpdateNodeParametersTool;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const parameter_updater_1 = require("../chains/parameter-updater");
+const errors_1 = require("../errors");
+const progress_1 = require("./helpers/progress");
+const response_1 = require("./helpers/response");
+const state_1 = require("./helpers/state");
+const validation_1 = require("./helpers/validation");
+const parameter_update_utils_1 = require("./utils/parameter-update.utils");
+const updateNodeParametersSchema = zod_1.z.object({
+    nodeId: zod_1.z.string().describe('The ID of the node to update'),
+    changes: zod_1.z
+        .array(zod_1.z.string())
+        .min(1)
+        .describe('Array of natural language changes to apply to the node parameters (e.g., "Set the URL to call the weather API", "Add an API key header")'),
+});
+function buildSuccessMessage(node, changes) {
+    const changesList = changes.map((c) => `- ${c}`).join('\n');
+    return `Successfully updated parameters for node "${node.name}" (${node.type}):\n${changesList}`;
+}
+function createUpdateNodeParametersTool(nodeTypes, llm, logger) {
+    return (0, tools_1.tool)(async (input, config) => {
+        const reporter = (0, progress_1.createProgressReporter)(config, 'update_node_parameters');
+        try {
+            const validatedInput = updateNodeParametersSchema.parse(input);
+            const { nodeId, changes } = validatedInput;
+            reporter.start(validatedInput);
+            const state = (0, state_1.getWorkflowState)();
+            const workflow = (0, state_1.getCurrentWorkflow)(state);
+            const node = (0, validation_1.validateNodeExists)(nodeId, workflow.nodes);
+            if (!node) {
+                const error = (0, validation_1.createNodeNotFoundError)(nodeId);
+                reporter.error(error);
+                return (0, response_1.createErrorResponse)(config, error);
+            }
+            const nodeType = (0, validation_1.findNodeType)(node.type, nodeTypes);
+            if (!nodeType) {
+                const error = (0, validation_1.createNodeTypeNotFoundError)(node.type);
+                reporter.error(error);
+                return (0, response_1.createErrorResponse)(config, error);
+            }
+            (0, progress_1.reportProgress)(reporter, `Updating parameters for node "${node.name}"`, {
+                nodeId,
+                changes,
+            });
+            try {
+                const currentParameters = (0, parameter_update_utils_1.extractNodeParameters)(node);
+                const formattedChanges = (0, parameter_update_utils_1.formatChangesForPrompt)(changes);
+                const nodePropertiesJson = JSON.stringify(nodeType.properties || [], null, 2);
+                const parametersChain = (0, parameter_updater_1.createParameterUpdaterChain)(llm, {
+                    nodeType: node.type,
+                    nodeDefinition: nodeType,
+                    requestedChanges: changes,
+                }, logger);
+                const newParameters = (await parametersChain.invoke({
+                    workflow_json: workflow,
+                    execution_schema: state.workflowContext?.executionSchema ?? 'NO SCHEMA',
+                    execution_data: state.workflowContext?.executionData ?? 'NO EXECUTION DATA YET',
+                    node_id: nodeId,
+                    node_name: node.name,
+                    node_type: node.type,
+                    current_parameters: JSON.stringify(currentParameters, null, 2),
+                    node_definition: nodePropertiesJson,
+                    changes: formattedChanges,
+                }));
+                if (!newParameters || typeof newParameters !== 'object') {
+                    throw new errors_1.ParameterUpdateError('Invalid parameters returned from LLM', {
+                        nodeId,
+                        nodeType: node.type,
+                    });
+                }
+                if (!newParameters.parameters || typeof newParameters.parameters !== 'object') {
+                    throw new errors_1.ParameterUpdateError('Invalid parameters structure returned from LLM', {
+                        nodeId,
+                        nodeType: node.type,
+                    });
+                }
+                const fixedParameters = (0, parameter_update_utils_1.fixExpressionPrefixes)(newParameters.parameters);
+                const updatedParameters = (0, parameter_update_utils_1.mergeParameters)(currentParameters, fixedParameters);
+                const updatedNode = (0, parameter_update_utils_1.updateNodeWithParameters)(node, updatedParameters);
+                const message = buildSuccessMessage(node, changes);
+                const output = {
+                    nodeId,
+                    nodeName: node.name,
+                    nodeType: node.type,
+                    updatedParameters,
+                    appliedChanges: changes,
+                    message,
+                };
+                reporter.complete(output);
+                const stateUpdates = (0, state_1.updateNodeInWorkflow)(state, nodeId, updatedNode);
+                return (0, response_1.createSuccessResponse)(config, message, stateUpdates);
+            }
+            catch (error) {
+                if (error instanceof errors_1.ParameterUpdateError) {
+                    reporter.error(error);
+                    return (0, response_1.createErrorResponse)(config, error);
+                }
+                const toolError = new errors_1.ToolExecutionError(`Failed to update node parameters: ${error instanceof Error ? error.message : 'Unknown error'}`, {
+                    toolName: 'update_node_parameters',
+                    cause: error instanceof Error ? error : undefined,
+                });
+                reporter.error(toolError);
+                return (0, response_1.createErrorResponse)(config, toolError);
+            }
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                const validationError = new errors_1.ValidationError('Invalid input parameters', {
+                    extra: { errors: error.errors },
+                });
+                reporter.error(validationError);
+                return (0, response_1.createErrorResponse)(config, validationError);
+            }
+            const toolError = new errors_1.ToolExecutionError(error instanceof Error ? error.message : 'Unknown error occurred', {
+                toolName: 'update_node_parameters',
+                cause: error instanceof Error ? error : undefined,
+            });
+            reporter.error(toolError);
+            return (0, response_1.createErrorResponse)(config, toolError);
+        }
+    }, {
+        name: 'update_node_parameters',
+        description: 'Update the parameters of an existing node in the workflow based on natural language changes. This tool intelligently modifies only the specified parameters while preserving others. Examples: "Set the URL to https://api.example.com", "Add authentication header", "Change method to POST", "Set the condition to check if status equals success".',
+        schema: updateNodeParametersSchema,
+    });
+}
+//# sourceMappingURL=update-node-parameters.tool.js.map