@atom8n/ai-workflow-builder 1.2.0

package/dist/prompts/chains/parameter-updater/guides/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEXT_FIELDS_GUIDE = exports.SYSTEM_MESSAGE_GUIDE = exports.RESOURCE_LOCATOR_GUIDE = exports.EMBEDDING_NODES_GUIDE = exports.GMAIL_GUIDE = exports.TOOL_NODES_GUIDE = exports.HTTP_REQUEST_GUIDE = exports.SWITCH_NODE_GUIDE = exports.IF_NODE_GUIDE = exports.SET_NODE_GUIDE = void 0;
+var set_node_1 = require("./set-node");
+Object.defineProperty(exports, "SET_NODE_GUIDE", { enumerable: true, get: function () { return set_node_1.SET_NODE_GUIDE; } });
+var if_node_1 = require("./if-node");
+Object.defineProperty(exports, "IF_NODE_GUIDE", { enumerable: true, get: function () { return if_node_1.IF_NODE_GUIDE; } });
+var switch_node_1 = require("./switch-node");
+Object.defineProperty(exports, "SWITCH_NODE_GUIDE", { enumerable: true, get: function () { return switch_node_1.SWITCH_NODE_GUIDE; } });
+var http_request_1 = require("./http-request");
+Object.defineProperty(exports, "HTTP_REQUEST_GUIDE", { enumerable: true, get: function () { return http_request_1.HTTP_REQUEST_GUIDE; } });
+var tool_nodes_1 = require("./tool-nodes");
+Object.defineProperty(exports, "TOOL_NODES_GUIDE", { enumerable: true, get: function () { return tool_nodes_1.TOOL_NODES_GUIDE; } });
+var gmail_1 = require("./gmail");
+Object.defineProperty(exports, "GMAIL_GUIDE", { enumerable: true, get: function () { return gmail_1.GMAIL_GUIDE; } });
+var embedding_nodes_1 = require("./embedding-nodes");
+Object.defineProperty(exports, "EMBEDDING_NODES_GUIDE", { enumerable: true, get: function () { return embedding_nodes_1.EMBEDDING_NODES_GUIDE; } });
+var resource_locator_1 = require("./resource-locator");
+Object.defineProperty(exports, "RESOURCE_LOCATOR_GUIDE", { enumerable: true, get: function () { return resource_locator_1.RESOURCE_LOCATOR_GUIDE; } });
+var system_message_1 = require("./system-message");
+Object.defineProperty(exports, "SYSTEM_MESSAGE_GUIDE", { enumerable: true, get: function () { return system_message_1.SYSTEM_MESSAGE_GUIDE; } });
+var text_fields_1 = require("./text-fields");
+Object.defineProperty(exports, "TEXT_FIELDS_GUIDE", { enumerable: true, get: function () { return text_fields_1.TEXT_FIELDS_GUIDE; } });
+//# sourceMappingURL=index.js.map

package/dist/prompts/chains/parameter-updater/guides/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/index.ts"],"names":[],"mappings":";;;AACA,uCAA4C;AAAnC,0GAAA,cAAc,OAAA;AACvB,qCAA0C;AAAjC,wGAAA,aAAa,OAAA;AACtB,6CAAkD;AAAzC,gHAAA,iBAAiB,OAAA;AAC1B,+CAAoD;AAA3C,kHAAA,kBAAkB,OAAA;AAC3B,2CAAgD;AAAvC,8GAAA,gBAAgB,OAAA;AACzB,iCAAsC;AAA7B,oGAAA,WAAW,OAAA;AACpB,qDAA0D;AAAjD,wHAAA,qBAAqB,OAAA;AAG9B,uDAA4D;AAAnD,0HAAA,sBAAsB,OAAA;AAC/B,mDAAwD;AAA/C,sHAAA,oBAAoB,OAAA;AAC7B,6CAAkD;AAAzC,gHAAA,iBAAiB,OAAA"}

package/dist/prompts/chains/parameter-updater/guides/resource-locator.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeGuide } from '../types';
+export declare const RESOURCE_LOCATOR_GUIDE: NodeTypeGuide;

package/dist/prompts/chains/parameter-updater/guides/resource-locator.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCE_LOCATOR_GUIDE = void 0;
+exports.RESOURCE_LOCATOR_GUIDE = {
+    patterns: ['*'],
+    condition: (ctx) => ctx.hasResourceLocatorParams === true,
+    content: `
+## IMPORTANT: ResourceLocator Parameter Handling
+
+ResourceLocator parameters are special fields used for selecting resources like Slack channels, Google Drive files, Notion pages, etc. They MUST have a specific structure:
+
+### Required ResourceLocator Structure:
+\`\`\`json
+{
+  "__rl": true,
+  "mode": "id" | "url" | "list" | "name",
+  "value": "the-actual-value"
+}
+\`\`\`
+
+### Mode Detection Guidelines:
+- Use mode "url" when the value is a URL (starts with http:// or https://)
+- Use mode "id" when the value looks like an ID (alphanumeric string)
+- Use mode "name" when the value has a prefix like # (Slack channels) or @ (users)
+- Use mode "list" when referencing a dropdown selection (rarely needed in updates)
+
+### ResourceLocator Examples:
+
+#### Example 1: Slack Channel by ID
+Parameter name: channelId
+Change: "Set channel to C0122KQ70S7E"
+Output:
+\`\`\`json
+{
+  "channelId": {
+    "__rl": true,
+    "mode": "id",
+    "value": "C0122KQ70S7E"
+  }
+}
+\`\`\`
+
+#### Example 2: Google Drive File by URL
+Parameter name: fileId
+Change: "Use file https://drive.google.com/file/d/1Nvdl7bEfDW33cKQuwfItPhIk479--WYY/view"
+Output:
+\`\`\`json
+{
+  "fileId": {
+    "__rl": true,
+    "mode": "url",
+    "value": "https://drive.google.com/file/d/1Nvdl7bEfDW33cKQuwfItPhIk479--WYY/view"
+  }
+}
+\`\`\`
+
+#### Example 3: Notion Page by ID
+Parameter name: pageId
+Change: "Set page ID to 123e4567-e89b-12d3"
+Output:
+\`\`\`json
+{
+  "pageId": {
+    "__rl": true,
+    "mode": "id",
+    "value": "123e4567-e89b-12d3"
+  }
+}
+\`\`\`
+
+#### Example 4: Slack Channel by Name
+Parameter name: channelId
+Change: "Send to #general channel"
+Output:
+\`\`\`json
+{
+  "channelId": {
+    "__rl": true,
+    "mode": "name",
+    "value": "#general"
+  }
+}
+\`\`\`
+
+#### Example 5: Using Expression with ResourceLocator
+Parameter name: channelId
+Change: "Use channel ID from previous node"
+Output:
+\`\`\`json
+{
+  "channelId": {
+    "__rl": true,
+    "mode": "id",
+    "value": "={{ $('Previous Node').item.json.channelId }}"
+  }
+}
+\`\`\``,
+};
+//# sourceMappingURL=resource-locator.js.map

package/dist/prompts/chains/parameter-updater/guides/resource-locator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-locator.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/resource-locator.ts"],"names":[],"mappings":";;;AAEa,QAAA,sBAAsB,GAAkB;IACpD,QAAQ,EAAE,CAAC,GAAG,CAAC;IACf,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,wBAAwB,KAAK,IAAI;IACzD,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0FH;CACN,CAAC"}

package/dist/prompts/chains/parameter-updater/guides/set-node.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeGuide } from '../types';
+export declare const SET_NODE_GUIDE: NodeTypeGuide;

package/dist/prompts/chains/parameter-updater/guides/set-node.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SET_NODE_GUIDE = void 0;
+exports.SET_NODE_GUIDE = {
+    patterns: ['n8n-nodes-base.set'],
+    content: `
+### Set Node Updates - Comprehensive Type Handling Guide
+
+The Set node uses assignments to create or modify data fields. Each assignment has a specific type that determines how the value is formatted and processed.
+
+#### Assignment Structure
+\`\`\`json
+{
+  "id": "unique-id",
+  "name": "field_name",
+  "value": "field_value",  // Format depends on type
+  "type": "string|number|boolean|array|object"
+}
+\`\`\`
+
+**CRITICAL**: ALWAYS use "value" field for ALL types. NEVER use type-specific fields like "stringValue", "numberValue", "booleanValue", etc. The field is ALWAYS named "value" regardless of the type.
+
+#### Type-Specific Value Formatting
+
+##### String Type
+- **Format**: Direct string value or expression
+- **Examples**:
+  - Literal: \`"Hello World"\`
+  - Expression: \`"={{ $('Previous Node').item.json.message }}"\`
+  - With embedded expressions: \`"=Order #{{ $('Set').item.json.orderId }} processed"\`
+- **Use when**: Text data, IDs, names, messages, dates as strings
+
+##### Number Type
+- **Format**: Direct numeric value (NOT as a string)
+- **Examples**:
+  - Integer: \`123\`
+  - Decimal: \`45.67\`
+  - Negative: \`-100\`
+  - Expression: \`"={{ $('HTTP Request').item.json.count }}"\`
+- **CRITICAL**: Use actual numbers, not strings: \`123\` not \`"123"\`
+- **Use when**: Quantities, prices, scores, numeric calculations
+
+##### Boolean Type
+- **Format**: Direct boolean value (NOT as a string)
+- **Examples**:
+  - True: \`true\`
+  - False: \`false\`
+  - Expression: \`"={{ $('IF').item.json.isActive }}"\`
+- **CRITICAL**: Use actual booleans, not strings: \`true\` not \`"true"\`
+- **CRITICAL**: The field name is "value", NOT "booleanValue"
+- **Use when**: Flags, toggles, yes/no values, active/inactive states
+
+##### Array Type
+- **Format**: JSON stringified array
+- **Examples**:
+  - Simple array: \`"[1, 2, 3]"\`
+  - String array: \`"[\\"apple\\", \\"banana\\", \\"orange\\"]"\`
+  - Mixed array: \`"[\\"item1\\", 123, true]"\`
+  - Expression: \`"={{ JSON.stringify($('Previous Node').item.json.items) }}"\`
+- **CRITICAL**: Arrays must be JSON stringified
+- **Use when**: Lists, collections, multiple values
+
+##### Object Type
+- **Format**: JSON stringified object
+- **Examples**:
+  - Simple object: \`"{ \\"name\\": \\"John\\", \\"age\\": 30 }"\`
+  - Nested object: \`"{ \\"user\\": { \\"id\\": 123, \\"role\\": \\"admin\\" } }"\`
+  - Expression: \`"={{ JSON.stringify($('Set').item.json.userData) }}"\`
+- **CRITICAL**: Objects must be JSON stringified with escaped quotes
+- **Use when**: Complex data structures, grouped properties
+
+#### Important Type Selection Rules
+
+1. **Analyze the requested data type**:
+   - "Set count to 5" → number type with value: \`5\`
+   - "Set message to hello" → string type with value: \`"hello"\`
+   - "Set active to true" → boolean type with value: \`true\`
+   - "Set tags to apple, banana" → array type with value: \`"[\\"apple\\", \\"banana\\"]"\`
+
+2. **Expression handling**:
+   - All types can use expressions with \`"={{ ... }}"\`
+   - For arrays/objects from expressions, use \`JSON.stringify()\`
+
+3. **Common mistakes to avoid**:
+   - WRONG: Setting number as string: \`{ "value": "123", "type": "number" }\`
+   - CORRECT: \`{ "value": 123, "type": "number" }\`
+   - WRONG: Setting boolean as string: \`{ "value": "false", "type": "boolean" }\`
+   - CORRECT: \`{ "value": false, "type": "boolean" }\`
+   - WRONG: Using type-specific field names: \`{ "booleanValue": true, "type": "boolean" }\`
+   - CORRECT: \`{ "value": true, "type": "boolean" }\`
+   - WRONG: Setting array without stringification: \`{ "value": [1,2,3], "type": "array" }\`
+   - CORRECT: \`{ "value": "[1,2,3]", "type": "array" }\``,
+};
+//# sourceMappingURL=set-node.js.map

package/dist/prompts/chains/parameter-updater/guides/set-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-node.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/set-node.ts"],"names":[],"mappings":";;;AAEa,QAAA,cAAc,GAAkB;IAC5C,QAAQ,EAAE,CAAC,oBAAoB,CAAC;IAChC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAsFgD;CACzD,CAAC"}

package/dist/prompts/chains/parameter-updater/guides/switch-node.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeGuide } from '../types';
+export declare const SWITCH_NODE_GUIDE: NodeTypeGuide;

package/dist/prompts/chains/parameter-updater/guides/switch-node.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWITCH_NODE_GUIDE = void 0;
+exports.SWITCH_NODE_GUIDE = {
+    patterns: ['n8n-nodes-base.switch'],
+    content: `
+### Switch Node Configuration Guide
+
+The Switch node routes items to different outputs based on conditions. Uses the same filter structure as IF node but for multi-way branching.
+
+#### Switch Node Structure (mode: 'rules')
+\`\`\`json
+{
+  "mode": "rules",
+  "rules": {
+    "values": [
+      {
+        "conditions": {
+          "options": {
+            "caseSensitive": true,
+            "leftValue": "",
+            "typeValidation": "strict"
+          },
+          "conditions": [
+            {
+              "leftValue": "={{ $json.amount }}",
+              "rightValue": 100,
+              "operator": {
+                "type": "number",
+                "operation": "lt"
+              }
+            }
+          ],
+          "combinator": "and"
+        },
+        "renameOutput": true,
+        "outputKey": "Under $100"
+      }
+    ]
+  }
+}
+\`\`\`
+
+#### Key Points:
+1. Each entry in rules.values[] creates ONE output
+2. Conditions use the same filter structure as IF node
+3. Multiple conditions per rule are combined with combinator ("and" or "or")
+4. Use renameOutput: true + outputKey to label outputs descriptively
+
+#### Numeric Operators
+- lt: Less than
+- gt: Greater than
+- lte: Less than or equal
+- gte: Greater than or equal
+- equals: Equal to
+
+#### String Operators
+- equals: Exact match
+- contains: Contains substring
+- startsWith: Starts with
+- endsWith: Ends with
+
+#### Common Patterns:
+
+**Numeric Range Routing** (for ranges like $100-$1000):
+Use two conditions with combinator: "and":
+- First condition: gte (greater than or equal to lower bound)
+- Second condition: lte (less than or equal to upper bound)
+
+**String-Based Routing** (status/type values):
+- Use type: "string" with operation: "equals"
+- Set caseSensitive: false in options for case-insensitive matching
+`,
+};
+//# sourceMappingURL=switch-node.js.map

package/dist/prompts/chains/parameter-updater/guides/switch-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch-node.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/switch-node.ts"],"names":[],"mappings":";;;AAEa,QAAA,iBAAiB,GAAkB;IAC/C,QAAQ,EAAE,CAAC,uBAAuB,CAAC;IACnC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmET;CACA,CAAC"}

package/dist/prompts/chains/parameter-updater/guides/system-message.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeGuide } from '../types';
+export declare const SYSTEM_MESSAGE_GUIDE: NodeTypeGuide;

package/dist/prompts/chains/parameter-updater/guides/system-message.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYSTEM_MESSAGE_GUIDE = void 0;
+function hasSystemMessageParameters(nodeDefinition) {
+    if (!nodeDefinition.properties)
+        return false;
+    return nodeDefinition.properties.some((prop) => {
+        if (prop.name === 'messages' &&
+            (prop.type === 'fixedCollection' || prop.type === 'collection')) {
+            return true;
+        }
+        if (prop.name === 'options' && prop.type === 'collection' && Array.isArray(prop.options)) {
+            return prop.options.some((opt) => typeof opt === 'object' &&
+                opt !== null &&
+                'name' in opt &&
+                (opt.name === 'systemMessage' || opt.name === 'system'));
+        }
+        return false;
+    });
+}
+exports.SYSTEM_MESSAGE_GUIDE = {
+    patterns: ['*'],
+    condition: (ctx) => hasSystemMessageParameters(ctx.nodeDefinition),
+    content: `
+## CRITICAL: System Message vs User Prompt Separation
+
+AI nodes (AI Agent, LLM Chain, Anthropic, OpenAI, etc.) have TWO distinct prompt fields that MUST be used correctly:
+
+### Field Separation
+1. **System Message** - Model's persistent identity, role, and instructions
+2. **User Message/Text** - Dynamic user context and data references per execution
+
+**Node-specific field names:**
+- AI Agent: \`options.systemMessage\` and \`text\`
+- LLM Chain: \`messages.messageValues[]\` with system role and \`text\`
+- Anthropic: \`options.system\` and \`messages.values[]\`
+- OpenAI: \`messages.values[]\` with role "system" vs "user"
+
+### System Message
+Use for STATIC, ROLE-DEFINING content:
+- Agent identity: "You are a [role] agent..."
+- Task description: "Your task is to..."
+- Step-by-step instructions: "1. Do X, 2. Do Y, 3. Do Z"
+- Behavioral guidelines: "Always...", "Never..."
+- Tool coordination: "Call the Research Tool to..., then call..."
+
+### Text Parameter
+Use for DYNAMIC, EXECUTION-SPECIFIC content:
+- User input: "={{ $json.chatInput }}"
+- Workflow context: "=The research topic is: {{ $json.topic }}"
+- Data from previous nodes: "=Process this data: {{ $json.data }}"
+- Variable context: "=Analyze for user: {{ $json.userId }}"
+
+### Common Mistakes to Avoid
+
+**WRONG - Everything in text field:**
+{
+  "text": "=You are an orchestrator agent that coordinates specialized agents. Your task is to: 1) Call Research Agent Tool, 2) Call Fact-Check Agent Tool, 3) Generate report. Research topic: {{ $json.researchTopic }}"
+}
+
+**CORRECT - Properly separated:**
+{
+  "text": "=The research topic is: {{ $json.researchTopic }}",
+  "options": {
+    "systemMessage": "You are an orchestrator agent that coordinates specialized agents.\\n\\nYour task is to:\\n1. Call the Research Agent Tool to gather information\\n2. Call the Fact-Check Agent Tool to verify findings\\n3. Generate a comprehensive report\\n\\nReturn ONLY the final report."
+  }
+}
+
+### Update Pattern Examples
+
+Example 1 - AI Agent with orchestration:
+Instructions: [
+  "Set text to '=Research topic: {{ $json.researchTopic }}'",
+  "Set system message to 'You are an orchestrator coordinating research tasks.\\n\\nSteps:\\n1. Call Research Agent Tool\\n2. Call Fact-Check Agent Tool\\n3. Call Report Writer Agent Tool\\n4. Return final HTML report'"
+]
+
+Example 2 - Chat-based AI node:
+Instructions: [
+  "Set text to '=User question: {{ $json.chatInput }}'",
+  "Set system message to 'You are a helpful customer support assistant. Answer questions clearly and professionally. Escalate to human if needed.'"
+]
+
+Example 3 - Data processing with AI:
+Instructions: [
+  "Set text to '=Process this data: {{ $json.inputData }}'",
+  "Set system message to 'You are a data analysis assistant.\\n\\nTasks:\\n1. Validate data structure\\n2. Calculate statistics\\n3. Identify anomalies\\n4. Return JSON with findings'"
+]
+
+### Why This Matters
+- **Consistency**: System message stays the same across executions
+- **Maintainability**: Easy to update AI behavior without touching data flow
+- **Best Practice**: Follows standard AI prompt engineering patterns
+- **Clarity**: Separates "what the AI model is" from "what data to process"
+`,
+};
+//# sourceMappingURL=system-message.js.map

package/dist/prompts/chains/parameter-updater/guides/system-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-message.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/system-message.ts"],"names":[],"mappings":";;;AAMA,SAAS,0BAA0B,CAAC,cAEnC;IACA,IAAI,CAAC,cAAc,CAAC,UAAU;QAAE,OAAO,KAAK,CAAC;IAE7C,OAAO,cAAc,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;QAE9C,IACC,IAAI,CAAC,IAAI,KAAK,UAAU;YACxB,CAAC,IAAI,CAAC,IAAI,KAAK,iBAAiB,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,EAC9D,CAAC;YACF,OAAO,IAAI,CAAC;QACb,CAAC;QAGD,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1F,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CACvB,CAAC,GAAG,EAAE,EAAE,CACP,OAAO,GAAG,KAAK,QAAQ;gBACvB,GAAG,KAAK,IAAI;gBACZ,MAAM,IAAI,GAAG;gBACb,CAAC,GAAG,CAAC,IAAI,KAAK,eAAe,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAC,CACxD,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACd,CAAC,CAAC,CAAC;AACJ,CAAC;AAEY,QAAA,oBAAoB,GAAkB;IAClD,QAAQ,EAAE,CAAC,GAAG,CAAC;IACf,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,0BAA0B,CAAC,GAAG,CAAC,cAAc,CAAC;IAClE,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsET;CACA,CAAC"}

package/dist/prompts/chains/parameter-updater/guides/text-fields.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeGuide } from '../types';
+export declare const TEXT_FIELDS_GUIDE: NodeTypeGuide;

package/dist/prompts/chains/parameter-updater/guides/text-fields.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEXT_FIELDS_GUIDE = void 0;
+function hasTextFields(nodeDefinition) {
+    if (!nodeDefinition.properties)
+        return false;
+    return nodeDefinition.properties.some((prop) => prop.type === 'string' && prop.typeOptions?.multipleValues !== true);
+}
+exports.TEXT_FIELDS_GUIDE = {
+    patterns: ['*'],
+    condition: (ctx) => hasTextFields(ctx.nodeDefinition),
+    content: `
+## Text Field Expression Formatting
+
+### PREFERRED METHOD: Embedding expressions directly within text
+\`\`\`
+"text": "=ALERT: It is currently {{ $('Weather Node').item.json.weather }} in {{ $('Weather Node').item.json.city }}!"
+\`\`\`
+
+### Alternative method: Using string concatenation (use only when needed)
+\`\`\`
+"text": "={{ 'ALERT: It is currently ' + $('Weather Node').item.json.weather + ' in ' + $('Weather Node').item.json.city + '!' }}"
+\`\`\`
+
+### Key Points:
+- Use the embedded expression format when mixing static text with dynamic values
+- The entire string must start with = when using expressions
+- Expressions within text use single curly braces {{ }}
+- The outer expression wrapper uses double curly braces ={{ }}`,
+};
+//# sourceMappingURL=text-fields.js.map

package/dist/prompts/chains/parameter-updater/guides/text-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-fields.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/text-fields.ts"],"names":[],"mappings":";;;AAKA,SAAS,aAAa,CAAC,cAEtB;IACA,IAAI,CAAC,cAAc,CAAC,UAAU;QAAE,OAAO,KAAK,CAAC;IAE7C,OAAO,cAAc,CAAC,UAAU,CAAC,IAAI,CACpC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,WAAW,EAAE,cAAc,KAAK,IAAI,CAC7E,CAAC;AACH,CAAC;AAEY,QAAA,iBAAiB,GAAkB;IAC/C,QAAQ,EAAE,CAAC,GAAG,CAAC;IACf,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,aAAa,CAAC,GAAG,CAAC,cAAc,CAAC;IACrD,OAAO,EAAE;;;;;;;;;;;;;;;;;+DAiBqD;CAC9D,CAAC"}

package/dist/prompts/chains/parameter-updater/guides/tool-nodes.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeGuide } from '../types';
+export declare const TOOL_NODES_GUIDE: NodeTypeGuide;

package/dist/prompts/chains/parameter-updater/guides/tool-nodes.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_NODES_GUIDE = void 0;
+exports.TOOL_NODES_GUIDE = {
+    patterns: ['*Tool'],
+    content: `
+## 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') }}"`,
+};
+//# sourceMappingURL=tool-nodes.js.map

package/dist/prompts/chains/parameter-updater/guides/tool-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-nodes.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/tool-nodes.ts"],"names":[],"mappings":";;;AAEa,QAAA,gBAAgB,GAAkB;IAC9C,QAAQ,EAAE,CAAC,OAAO,CAAC;IACnB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAoEiC;CAC1C,CAAC"}

package/dist/prompts/chains/parameter-updater/index.d.ts

@@ -0,0 +1,8 @@
+export { getMatchingGuides, getMatchingExamples, matchesPattern } from './registry';
+export type { NodeTypeGuide, NodeTypeExamples, NodeTypePattern, PromptContext, } from './types';
+export { hasResourceLocatorParameters } from './utils';
+export { instanceUrlPrompt } from './instance-url';
+export { CORE_INSTRUCTIONS, EXPRESSION_RULES, COMMON_PATTERNS, OUTPUT_FORMAT, } from './parameter-updater.prompt';
+export { SET_NODE_GUIDE, IF_NODE_GUIDE, SWITCH_NODE_GUIDE, HTTP_REQUEST_GUIDE, TOOL_NODES_GUIDE, GMAIL_GUIDE, } from './guides';
+export { RESOURCE_LOCATOR_GUIDE, SYSTEM_MESSAGE_GUIDE, TEXT_FIELDS_GUIDE, } from './guides';
+export { SET_NODE_EXAMPLES, IF_NODE_EXAMPLES, SWITCH_NODE_EXAMPLES, SIMPLE_UPDATE_EXAMPLES, TOOL_NODE_EXAMPLES, RESOURCE_LOCATOR_EXAMPLES, } from './examples';

package/dist/prompts/chains/parameter-updater/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCE_LOCATOR_EXAMPLES = exports.TOOL_NODE_EXAMPLES = exports.SIMPLE_UPDATE_EXAMPLES = exports.SWITCH_NODE_EXAMPLES = exports.IF_NODE_EXAMPLES = exports.SET_NODE_EXAMPLES = exports.TEXT_FIELDS_GUIDE = exports.SYSTEM_MESSAGE_GUIDE = exports.RESOURCE_LOCATOR_GUIDE = exports.GMAIL_GUIDE = exports.TOOL_NODES_GUIDE = exports.HTTP_REQUEST_GUIDE = exports.SWITCH_NODE_GUIDE = exports.IF_NODE_GUIDE = exports.SET_NODE_GUIDE = exports.OUTPUT_FORMAT = exports.COMMON_PATTERNS = exports.EXPRESSION_RULES = exports.CORE_INSTRUCTIONS = exports.instanceUrlPrompt = exports.hasResourceLocatorParameters = exports.matchesPattern = exports.getMatchingExamples = exports.getMatchingGuides = void 0;
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "getMatchingGuides", { enumerable: true, get: function () { return registry_1.getMatchingGuides; } });
+Object.defineProperty(exports, "getMatchingExamples", { enumerable: true, get: function () { return registry_1.getMatchingExamples; } });
+Object.defineProperty(exports, "matchesPattern", { enumerable: true, get: function () { return registry_1.matchesPattern; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "hasResourceLocatorParameters", { enumerable: true, get: function () { return utils_1.hasResourceLocatorParameters; } });
+var instance_url_1 = require("./instance-url");
+Object.defineProperty(exports, "instanceUrlPrompt", { enumerable: true, get: function () { return instance_url_1.instanceUrlPrompt; } });
+var parameter_updater_prompt_1 = require("./parameter-updater.prompt");
+Object.defineProperty(exports, "CORE_INSTRUCTIONS", { enumerable: true, get: function () { return parameter_updater_prompt_1.CORE_INSTRUCTIONS; } });
+Object.defineProperty(exports, "EXPRESSION_RULES", { enumerable: true, get: function () { return parameter_updater_prompt_1.EXPRESSION_RULES; } });
+Object.defineProperty(exports, "COMMON_PATTERNS", { enumerable: true, get: function () { return parameter_updater_prompt_1.COMMON_PATTERNS; } });
+Object.defineProperty(exports, "OUTPUT_FORMAT", { enumerable: true, get: function () { return parameter_updater_prompt_1.OUTPUT_FORMAT; } });
+var guides_1 = require("./guides");
+Object.defineProperty(exports, "SET_NODE_GUIDE", { enumerable: true, get: function () { return guides_1.SET_NODE_GUIDE; } });
+Object.defineProperty(exports, "IF_NODE_GUIDE", { enumerable: true, get: function () { return guides_1.IF_NODE_GUIDE; } });
+Object.defineProperty(exports, "SWITCH_NODE_GUIDE", { enumerable: true, get: function () { return guides_1.SWITCH_NODE_GUIDE; } });
+Object.defineProperty(exports, "HTTP_REQUEST_GUIDE", { enumerable: true, get: function () { return guides_1.HTTP_REQUEST_GUIDE; } });
+Object.defineProperty(exports, "TOOL_NODES_GUIDE", { enumerable: true, get: function () { return guides_1.TOOL_NODES_GUIDE; } });
+Object.defineProperty(exports, "GMAIL_GUIDE", { enumerable: true, get: function () { return guides_1.GMAIL_GUIDE; } });
+var guides_2 = require("./guides");
+Object.defineProperty(exports, "RESOURCE_LOCATOR_GUIDE", { enumerable: true, get: function () { return guides_2.RESOURCE_LOCATOR_GUIDE; } });
+Object.defineProperty(exports, "SYSTEM_MESSAGE_GUIDE", { enumerable: true, get: function () { return guides_2.SYSTEM_MESSAGE_GUIDE; } });
+Object.defineProperty(exports, "TEXT_FIELDS_GUIDE", { enumerable: true, get: function () { return guides_2.TEXT_FIELDS_GUIDE; } });
+var examples_1 = require("./examples");
+Object.defineProperty(exports, "SET_NODE_EXAMPLES", { enumerable: true, get: function () { return examples_1.SET_NODE_EXAMPLES; } });
+Object.defineProperty(exports, "IF_NODE_EXAMPLES", { enumerable: true, get: function () { return examples_1.IF_NODE_EXAMPLES; } });
+Object.defineProperty(exports, "SWITCH_NODE_EXAMPLES", { enumerable: true, get: function () { return examples_1.SWITCH_NODE_EXAMPLES; } });
+Object.defineProperty(exports, "SIMPLE_UPDATE_EXAMPLES", { enumerable: true, get: function () { return examples_1.SIMPLE_UPDATE_EXAMPLES; } });
+Object.defineProperty(exports, "TOOL_NODE_EXAMPLES", { enumerable: true, get: function () { return examples_1.TOOL_NODE_EXAMPLES; } });
+Object.defineProperty(exports, "RESOURCE_LOCATOR_EXAMPLES", { enumerable: true, get: function () { return examples_1.RESOURCE_LOCATOR_EXAMPLES; } });
+//# sourceMappingURL=index.js.map

package/dist/prompts/chains/parameter-updater/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/prompts/chains/parameter-updater/index.ts"],"names":[],"mappings":";;;AACA,uCAAoF;AAA3E,6GAAA,iBAAiB,OAAA;AAAE,+GAAA,mBAAmB,OAAA;AAAE,0GAAA,cAAc,OAAA;AAS/D,iCAAuD;AAA9C,qHAAA,4BAA4B,OAAA;AACrC,+CAAmD;AAA1C,iHAAA,iBAAiB,OAAA;AAG1B,uEAKoC;AAJnC,6HAAA,iBAAiB,OAAA;AACjB,4HAAA,gBAAgB,OAAA;AAChB,2HAAA,eAAe,OAAA;AACf,yHAAA,aAAa,OAAA;AAId,mCAOkB;AANjB,wGAAA,cAAc,OAAA;AACd,uGAAA,aAAa,OAAA;AACb,2GAAA,iBAAiB,OAAA;AACjB,4GAAA,kBAAkB,OAAA;AAClB,0GAAA,gBAAgB,OAAA;AAChB,qGAAA,WAAW,OAAA;AAIZ,mCAIkB;AAHjB,gHAAA,sBAAsB,OAAA;AACtB,8GAAA,oBAAoB,OAAA;AACpB,2GAAA,iBAAiB,OAAA;AAIlB,uCAOoB;AANnB,6GAAA,iBAAiB,OAAA;AACjB,4GAAA,gBAAgB,OAAA;AAChB,gHAAA,oBAAoB,OAAA;AACpB,kHAAA,sBAAsB,OAAA;AACtB,8GAAA,kBAAkB,OAAA;AAClB,qHAAA,yBAAyB,OAAA"}

package/dist/prompts/chains/parameter-updater/instance-url.d.ts

@@ -0,0 +1 @@
+export declare const instanceUrlPrompt: string;

package/dist/prompts/chains/parameter-updater/instance-url.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceUrlPrompt = void 0;
+const builder_1 = require("../../../prompts/builder");
+exports.instanceUrlPrompt = new builder_1.PromptBuilder()
+    .section('instance_url', `The n8n instance base URL is: {instanceUrl}
+
+This URL is essential for webhook nodes and chat triggers as it provides the base URL for:
+- Webhook URLs that external services need to call
+- Chat trigger URLs for conversational interfaces
+- Any node that requires the full instance URL to generate proper callback URLs
+
+When working with webhook or chat trigger nodes, use this URL as the base for constructing proper endpoint URLs.`)
+    .build();
+//# sourceMappingURL=instance-url.js.map

package/dist/prompts/chains/parameter-updater/instance-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-url.js","sourceRoot":"","sources":["../../../../src/prompts/chains/parameter-updater/instance-url.ts"],"names":[],"mappings":";;;AAAA,+CAAkD;AAErC,QAAA,iBAAiB,GAAG,IAAI,uBAAa,EAAE;KAClD,OAAO,CACP,cAAc,EACd;;;;;;;iHAO+G,CAC/G;KACA,KAAK,EAAE,CAAC"}

package/dist/prompts/chains/parameter-updater/parameter-updater.prompt.d.ts

@@ -0,0 +1,4 @@
+export declare const CORE_INSTRUCTIONS = "You are an expert n8n workflow architect who updates node parameters based on natural language instructions.\n\n## Your Task\nUpdate the parameters of an existing n8n node based on the requested changes. Return the COMPLETE parameters object with both modified and unmodified parameters. Only modify the parameters that are explicitly mentioned in the changes, preserving all other existing parameters exactly as they are.\n\n## Reference Information\nYou will receive:\n1. The original user workflow request\n2. The current workflow JSON\n3. The selected node's current configuration (id, name, type, parameters)\n4. The node type's parameter definitions\n5. Natural language changes to apply\n\n## Parameter Update Guidelines\n1. START WITH CURRENT: If current parameters is empty {}, start with an empty object and add the requested parameters\n2. PRESERVE EXISTING VALUES: Only modify parameters mentioned in the requested changes\n3. MAINTAIN STRUCTURE: Keep the exact parameter structure required by the node type\n4. CHECK FOR RESOURCELOCATOR: If a parameter is type 'resourceLocator' in the node definition, it MUST use the ResourceLocator structure with __rl, mode, and value fields\n5. USE PROPER EXPRESSIONS: Follow n8n expression syntax when referencing other nodes\n6. VALIDATE TYPES: Ensure parameter values match their expected types\n7. HANDLE NESTED PARAMETERS: Correctly update nested structures like headers, conditions, etc.\n8. SIMPLE VALUES: For simple parameter updates like \"Set X to Y\", directly set the parameter without unnecessary nesting\n9. GENERATE IDS: When adding new items to arrays (like assignments, headers, etc.), generate unique IDs using a simple pattern like \"id-1\", \"id-2\", etc.\n10. TOOL NODE DETECTION: Check if node type ends with \"Tool\" to determine if $fromAI expressions are available\n11. PLACEHOLDER FORMAT: When changes specify a placeholder, copy it exactly as \"<__PLACEHOLDER_VALUE__VALUE_LABEL__>\" (no extra quotes or expressions) and keep VALUE_LABEL descriptive for the user";
+export declare const EXPRESSION_RULES = "\n## CRITICAL: Correctly Formatting n8n Expressions\nWhen using expressions to reference data from other nodes:\n- ALWAYS use the format: `={{ $('Node Name').item.json.field }}`\n- NEVER omit the equals sign before the double curly braces\n- ALWAYS use DOUBLE curly braces, never single\n- NEVER use emojis or special characters inside expressions as they will break the expression\n- INCORRECT: `{ $('Node Name').item.json.field }` (missing =, single braces)\n- INCORRECT: `{{ $('Node Name').item.json.field }}` (missing =)\n- INCORRECT: `={{ $('\uD83D\uDC4D Node').item.json.field }}` (contains emoji)\n- CORRECT: `={{ $('Previous Node').item.json.field }}`";
+export declare const COMMON_PATTERNS = "\n## Common Parameter Update Patterns\n\n### HTTP Request Node Updates\n- URL: Set directly or use expressions\n- Method: GET, POST, PUT, DELETE, etc.\n- Headers: Add/update in headerParameters.parameters array\n- Body: Update bodyParameters.parameters for POST/PUT\n- Authentication: Update authentication settings";
+export declare const OUTPUT_FORMAT = "\n## Output Format\nReturn ONLY the complete updated parameters object that matches the node's parameter structure. Include ALL parameters, both modified and unmodified.";