@n8n/ai-workflow-builder 1.16.0 → 1.17.1

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

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GMAIL_GUIDE = void 0;
-exports.GMAIL_GUIDE = {
-    patterns: ['n8n-nodes-base.gmail', 'n8n-nodes-base.gmailTrigger'],
-    content: `
-### Gmail Node Updates
-
-#### Common Parameters
-- **resource**: message, draft, label, thread
-- **operation**: send, get, list, etc.
-- **to**: Recipient email address
-- **subject**: Email subject line
-- **message**: Email body/content
-- **authentication**: OAuth2 or Service Account
-
-#### Simplify Option (CRITICAL)
-- **simplify: false** - Returns FULL email with body, attachments, headers
-- **simplify: true** - Returns LIMITED data (subject, snippet only, NO body)
-
-ALWAYS set simplify to FALSE when:
-- Workflow needs to analyze email content/body
-- AI Agent will process or summarize emails
-- Email content is used for decision making
-- Attachments need to be accessed
-
-#### Gmail Filter Queries
-For Gmail Trigger nodes, use comprehensive search filters with OR operators:
-- Multiple keywords: "subject:(delivery OR shipment OR package OR tracking)"
-- From specific senders: "from:example@domain.com"
-- With attachments: "has:attachment"
-- Unread only: "is:unread"
-
-Example for package tracking: "subject:(delivery OR shipment OR package OR tracking OR shipped)"
-NOT just: "subject:delivery" (misses many relevant emails)
-
-#### Common Patterns
-1. **Sending Email**:
-   - Set resource to "message"
-   - Set operation to "send"
-   - Configure to, subject, and message fields
-
-2. **Reading Emails for AI Analysis**:
-   - Set simplify to false (required for full email body)
-   - Configure appropriate filter query
-   - Pass full email data to AI Agent
-
-3. **Using Expressions**:
-   - Can use expressions: "={{ $('Previous Node').item.json.email }}"
-   - Can reference previous node data for dynamic values
-`,
-};
-//# sourceMappingURL=gmail.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"gmail.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/gmail.ts"],"names":[],"mappings":";;;AAEa,QAAA,WAAW,GAAkB;IACzC,QAAQ,EAAE,CAAC,sBAAsB,EAAE,6BAA6B,CAAC;IACjE,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CT;CACA,CAAC"}

package/dist/prompts/chains/parameter-updater/guides/http-request.d.ts

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

package/dist/prompts/chains/parameter-updater/guides/http-request.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTP_REQUEST_GUIDE = void 0;
-exports.HTTP_REQUEST_GUIDE = {
-    patterns: ['n8n-nodes-base.httpRequest', 'n8n-nodes-base.webhook'],
-    content: `
-### HTTP Request Node Updates
-
-#### IMPORTANT - Credential Security
-
-**NEVER hardcode credentials** (API keys, tokens, passwords, secrets) in the HTTP Request node parameters.
-Instead, ALWAYS use n8n's built-in credential system:
-
-1. Set \`authentication\` to \`"genericCredentialType"\`
-2. Set \`genericAuthType\` to the appropriate credential type:
-   - \`"httpHeaderAuth"\` - For API keys sent in headers (X-API-Key, Authorization, etc.)
-   - \`"httpBearerAuth"\` - For Bearer token authentication
-   - \`"httpQueryAuth"\` - For API keys sent as query parameters
-   - \`"httpBasicAuth"\` - For username/password authentication
-   - \`"oAuth2Api"\` - For OAuth 2.0 authentication
-
-**DO NOT:**
-- Put API keys or tokens directly in header values
-- Store credentials in Set nodes and reference them with expressions
-- Hardcode Bearer tokens in Authorization headers
-
-**DO:**
-- Use the authentication parameter with the appropriate credential type
-- Let users configure their credentials securely in n8n's credential manager
-
-#### Common Parameters
-- **url**: The endpoint URL (can use expressions)
-- **method**: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
-- **authentication**: Type of auth (none, genericCredentialType, etc.)
-- **sendHeaders**: Boolean to enable custom headers
-- **headerParameters**: Array of header key-value pairs
-- **sendBody**: Boolean to enable request body (for POST/PUT/PATCH)
-- **bodyParameters**: Array of body parameters or raw body content
-- **contentType**: json, form, raw, etc.
-- **options**: Additional options like timeout, proxy, etc.
-
-#### Header Structure
-{
-  "sendHeaders": true,
-  "headerParameters": {
-    "parameters": [
-      {
-        "name": "Header-Name",
-        "value": "Header Value or {{ expression }}"
-      }
-    ]
-  }
-}
-
-#### Body Structure (JSON)
-{
-  "sendBody": true,
-  "contentType": "json",
-  "bodyParameters": {
-    "parameters": [
-      {
-        "name": "fieldName",
-        "value": "fieldValue or {{ expression }}"
-      }
-    ]
-  }
-}
-
-#### Authentication Options
-- **none**: No authentication
-- **genericCredentialType**: Use stored credentials
-- **predefinedCredentialType**: Use specific credential type
-- Can also set custom auth headers
-
-#### Common Patterns
-1. **Adding API Key Header**:
-   - Enable sendHeaders
-   - Add header with name "X-API-Key" or "Authorization"
-
-2. **Setting Request Body**:
-   - Enable sendBody
-   - Set contentType (usually "json")
-   - Add parameters to bodyParameters.parameters array
-
-3. **Dynamic URLs**:
-   - Can use expressions: "=https://api.example.com/{{ $('Set').item.json.endpoint }}"
-   - Can reference previous node data
-
-4. **Query Parameters**:
-   - Can be part of URL or set in options.queryParameters
-
-#### Example: HTTP Request with Authentication and Body
-Current Parameters:
-{
-  "method": "GET",
-  "url": "https://api.example.com/data"
-}
-
-Requested Changes:
-- Change to POST method
-- Add API key authentication (using n8n credentials)
-- Add JSON body with user ID and status
-
-Expected Output:
-{
-  "method": "POST",
-  "url": "https://api.example.com/data",
-  "authentication": "genericCredentialType",
-  "genericAuthType": "httpHeaderAuth",
-  "sendHeaders": true,
-  "headerParameters": {
-    "parameters": [
-      {
-        "name": "Content-Type",
-        "value": "application/json"
-      }
-    ]
-  },
-  "sendBody": true,
-  "contentType": "json",
-  "bodyParameters": {
-    "parameters": [
-      {
-        "name": "userId",
-        "value": "={{ $('Previous Node').item.json.id }}"
-      },
-      {
-        "name": "status",
-        "value": "active"
-      }
-    ]
-  },
-  "options": {}
-}
-
-Note: The API key is handled by the httpHeaderAuth credential, NOT hardcoded in the header parameters.
-The user will configure their API key securely in n8n's credential manager.`,
-};
-//# sourceMappingURL=http-request.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"http-request.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/http-request.ts"],"names":[],"mappings":";;;AAEa,QAAA,kBAAkB,GAAkB;IAChD,QAAQ,EAAE,CAAC,4BAA4B,EAAE,wBAAwB,CAAC;IAClE,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAmIkE;CAC3E,CAAC"}

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

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

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

@@ -1,159 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IF_NODE_GUIDE = void 0;
-exports.IF_NODE_GUIDE = {
-    patterns: ['n8n-nodes-base.if'],
-    content: `
-### The IF node uses a complex filter structure for conditional logic. Understanding the correct operator format is crucial.
-
-#### IF Node Structure
-\`\`\`json
-{
-  "conditions": {
-    "options": {
-      "caseSensitive": false,      // For string comparisons
-      "leftValue": "",              // Optional default left value
-      "typeValidation": "loose"     // "strict" or "loose"
-    },
-    "conditions": [
-      {
-        "id": "unique-id",          // Optional, auto-generated
-        "leftValue": "={{ $('Node').item.json.field }}",
-        "rightValue": "value",      // Can be expression or literal
-        "operator": {
-          "type": "string|number|boolean|dateTime|array|object",
-          "operation": "specific-operation"
-        }
-      }
-    ],
-    "combinator": "and"  // "and" or "or"
-  }
-}
-\`\`\`
-
-#### Complete Operator Reference
-
-##### String Operators
-- **exists**: Check if value exists (singleValue: true, no rightValue needed)
-  \`{ "type": "string", "operation": "exists" }\`
-- **notExists**: Check if value doesn't exist (singleValue: true)
-  \`{ "type": "string", "operation": "notExists" }\`
-- **empty**: Check if string is empty (singleValue: true)
-  \`{ "type": "string", "operation": "empty" }\`
-- **notEmpty**: Check if string is not empty (singleValue: true)
-  \`{ "type": "string", "operation": "notEmpty" }\`
-- **equals**: Exact match
-  \`{ "type": "string", "operation": "equals" }\`
-- **notEquals**: Not equal
-  \`{ "type": "string", "operation": "notEquals" }\`
-- **contains**: Contains substring
-  \`{ "type": "string", "operation": "contains" }\`
-- **notContains**: Doesn't contain substring
-  \`{ "type": "string", "operation": "notContains" }\`
-- **startsWith**: Starts with string
-  \`{ "type": "string", "operation": "startsWith" }\`
-- **notStartsWith**: Doesn't start with
-  \`{ "type": "string", "operation": "notStartsWith" }\`
-- **endsWith**: Ends with string
-  \`{ "type": "string", "operation": "endsWith" }\`
-- **notEndsWith**: Doesn't end with
-  \`{ "type": "string", "operation": "notEndsWith" }\`
-- **regex**: Matches regex pattern
-  \`{ "type": "string", "operation": "regex" }\`
-- **notRegex**: Doesn't match regex
-  \`{ "type": "string", "operation": "notRegex" }\`
-
-##### Number Operators
-- **exists**: Check if number exists (singleValue: true)
-  \`{ "type": "number", "operation": "exists" }\`
-- **notExists**: Check if number doesn't exist (singleValue: true)
-  \`{ "type": "number", "operation": "notExists" }\`
-- **equals**: Equal to
-  \`{ "type": "number", "operation": "equals" }\`
-- **notEquals**: Not equal to
-  \`{ "type": "number", "operation": "notEquals" }\`
-- **gt**: Greater than
-  \`{ "type": "number", "operation": "gt" }\`
-- **lt**: Less than
-  \`{ "type": "number", "operation": "lt" }\`
-- **gte**: Greater than or equal
-  \`{ "type": "number", "operation": "gte" }\`
-- **lte**: Less than or equal
-  \`{ "type": "number", "operation": "lte" }\`
-
-##### DateTime Operators
-- **exists**: Check if date exists (singleValue: true)
-  \`{ "type": "dateTime", "operation": "exists" }\`
-- **notExists**: Check if date doesn't exist (singleValue: true)
-  \`{ "type": "dateTime", "operation": "notExists" }\`
-- **equals**: Same date/time
-  \`{ "type": "dateTime", "operation": "equals" }\`
-- **notEquals**: Different date/time
-  \`{ "type": "dateTime", "operation": "notEquals" }\`
-- **after**: After date
-  \`{ "type": "dateTime", "operation": "after" }\`
-- **before**: Before date
-  \`{ "type": "dateTime", "operation": "before" }\`
-- **afterOrEquals**: After or same date
-  \`{ "type": "dateTime", "operation": "afterOrEquals" }\`
-- **beforeOrEquals**: Before or same date
-  \`{ "type": "dateTime", "operation": "beforeOrEquals" }\`
-
-##### Boolean Operators
-- **exists**: Check if boolean exists (singleValue: true)
-  \`{ "type": "boolean", "operation": "exists" }\`
-- **notExists**: Check if boolean doesn't exist (singleValue: true)
-  \`{ "type": "boolean", "operation": "notExists" }\`
-- **true**: Is true (singleValue: true)
-  \`{ "type": "boolean", "operation": "true" }\`
-- **false**: Is false (singleValue: true)
-  \`{ "type": "boolean", "operation": "false" }\`
-- **equals**: Equal to boolean value
-  \`{ "type": "boolean", "operation": "equals" }\`
-- **notEquals**: Not equal to boolean value
-  \`{ "type": "boolean", "operation": "notEquals" }\`
-
-##### Array Operators
-- **exists**: Check if array exists (singleValue: true)
-  \`{ "type": "array", "operation": "exists" }\`
-- **notExists**: Check if array doesn't exist (singleValue: true)
-  \`{ "type": "array", "operation": "notExists" }\`
-- **empty**: Array is empty (singleValue: true)
-  \`{ "type": "array", "operation": "empty" }\`
-- **notEmpty**: Array is not empty (singleValue: true)
-  \`{ "type": "array", "operation": "notEmpty" }\`
-- **contains**: Array contains value
-  \`{ "type": "array", "operation": "contains" }\`
-- **notContains**: Array doesn't contain value
-  \`{ "type": "array", "operation": "notContains" }\`
-- **lengthEquals**: Array length equals
-  \`{ "type": "array", "operation": "lengthEquals" }\`
-- **lengthNotEquals**: Array length not equals
-  \`{ "type": "array", "operation": "lengthNotEquals" }\`
-- **lengthGt**: Array length greater than
-  \`{ "type": "array", "operation": "lengthGt" }\`
-- **lengthLt**: Array length less than
-  \`{ "type": "array", "operation": "lengthLt" }\`
-- **lengthGte**: Array length greater or equal
-  \`{ "type": "array", "operation": "lengthGte" }\`
-- **lengthLte**: Array length less or equal
-  \`{ "type": "array", "operation": "lengthLte" }\`
-
-##### Object Operators
-- **exists**: Check if object exists (singleValue: true)
-  \`{ "type": "object", "operation": "exists" }\`
-- **notExists**: Check if object doesn't exist (singleValue: true)
-  \`{ "type": "object", "operation": "notExists" }\`
-- **empty**: Object is empty (singleValue: true)
-  \`{ "type": "object", "operation": "empty" }\`
-- **notEmpty**: Object is not empty (singleValue: true)
-  \`{ "type": "object", "operation": "notEmpty" }\`
-
-#### Important Notes:
-1. **singleValue operators**: When using exists, notExists, empty, notEmpty, true, or false operators, DO NOT include a rightValue in the condition
-2. **Expression values**: Both leftValue and rightValue can be expressions using \`={{ ... }}\` syntax
-3. **Type matching**: The operator type must match the data type you're comparing
-4. **Case sensitivity**: Only applies to string comparisons when caseSensitive is true in options
-5. **Type validation**: "loose" allows type coercion, "strict" requires exact type matches`,
-};
-//# sourceMappingURL=if-node.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"if-node.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/if-node.ts"],"names":[],"mappings":";;;AAEa,QAAA,aAAa,GAAkB;IAC3C,QAAQ,EAAE,CAAC,mBAAmB,CAAC;IAC/B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2FAuJiF;CAC1F,CAAC"}

package/dist/prompts/chains/parameter-updater/guides/predecessor-output.d.ts

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

package/dist/prompts/chains/parameter-updater/guides/predecessor-output.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PREDECESSOR_OUTPUT_GUIDE = void 0;
-exports.PREDECESSOR_OUTPUT_GUIDE = {
-    patterns: ['*'],
-    content: `
-### Referencing Output from Special Node Types
-
-#### AI Agent Output Structure
-AI Agent nodes (n8n-nodes-langchain.agent) wrap their response in an "output" object:
-- Without Structured Output Parser: Use \`$json.output\` to access the response string
-- With Structured Output Parser (hasOutputParser: true in node settings): Use \`$json.output.fieldName\` to access parsed fields
-- Use \`$('AI Agent').item.json.output.fieldName\` when referencing a node, instead of \`$('AI Agent').item.json.fieldName\`
-- WRONG: \`$json.summary\` → CORRECT: \`$json.output.summary\`
-
-#### Webhook Node Output Structure
-When referencing data from a Webhook node (n8n-nodes-base.webhook), the incoming request is structured under \`$json\`:
-- \`$json.headers\` - HTTP headers, example: \`$json.headers.authorization\`
-- \`$json.params\` - URL path parameters, example route: \`/users/:id\`, access: \`$json.params.id\`
-- \`$json.query\` - Query string parameters, example URL: \`?user_id=123\`, access: \`$json.query.user_id\`
-- \`$json.body\` - Request payload, example JSON: \`{ "userName": "sam" }\`, access: \`$json.body.userName\`
-
-CRITICAL: When referencing data from a Webhook node, do NOT use \`$json.fieldName\` directly - always specify the container (body, query, params, or headers).`,
-};
-//# sourceMappingURL=predecessor-output.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"predecessor-output.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/predecessor-output.ts"],"names":[],"mappings":";;;AASa,QAAA,wBAAwB,GAAkB;IACtD,QAAQ,EAAE,CAAC,GAAG,CAAC;IACf,OAAO,EAAE;;;;;;;;;;;;;;;;;+JAiBqJ;CAC9J,CAAC"}

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

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

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

@@ -1,40 +0,0 @@
-"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 (required fields):
-\`\`\`json
-{
-  "__rl": true,
-  "mode": "id" | "url" | "list" | "name",
-  "value": "the-actual-value"
-}
-\`\`\`
-
-### Mode Detection Guidelines:
-- Use the node type definition to determine the default mode and available modes for specific parameter
-- Prefer default mode from node type definition when possible
-- Switch the mode based on the input value format when necessary
-- Use mode "list" when the value is an ID + display name (e.g. "Marketing Team (ID: C0122KQ70S7E)"). Value should be set to the ID part, and cachedResultName to the display name part
-- 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, UUID, or other identifier)
-
-List mode structure with optional cached fields:
-\`\`\`json
-{
-  "__rl": true,
-  "mode": "list",
-  "value": "actual-id-from-list",
-  "cachedResultName": "Display Name"
-}
-\`\`\`
-`,
-};
-//# sourceMappingURL=resource-locator.js.map

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

@@ -1 +0,0 @@
-{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BT;CACA,CAAC"}

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

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

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

@@ -1,94 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1,75 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

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