@n8n/ai-workflow-builder 0.13.0 → 0.14.1

package/dist/chains/prompts/examples/basic/set-node-examples.d.ts

@@ -0,0 +1 @@
+export declare const SET_NODE_EXAMPLES = "\n### Set Node Examples\n\n#### Example 1: Simple String Assignment\nCurrent Parameters: {}\nRequested Changes: Set message to \"Hello World\"\nExpected Output:\n{\n  \"assignments\": {\n    \"assignments\": [\n      {\n        \"id\": \"id-1\",\n        \"name\": \"message\",\n        \"value\": \"Hello World\",\n        \"type\": \"string\"\n      }\n    ]\n  },\n  \"options\": {}\n}\n\n#### Example 2: Multiple Type Assignments\nCurrent Parameters: {}\nRequested Changes:\n- Set productName to \"Widget\"\n- Set price to 19.99\n- Set inStock to true\n- Set categories to electronics and gadgets\n\nExpected Output:\n{\n  \"assignments\": {\n    \"assignments\": [\n      {\n        \"id\": \"id-1\",\n        \"name\": \"productName\",\n        \"value\": \"Widget\",\n        \"type\": \"string\"\n      },\n      {\n        \"id\": \"id-2\",\n        \"name\": \"price\",\n        \"value\": 19.99,\n        \"type\": \"number\"\n      },\n      {\n        \"id\": \"id-3\",\n        \"name\": \"inStock\",\n        \"value\": true,\n        \"type\": \"boolean\"\n      },\n      {\n        \"id\": \"id-4\",\n        \"name\": \"categories\",\n        \"value\": \"[\\\"electronics\\\", \\\"gadgets\\\"]\",\n        \"type\": \"array\"\n      }\n    ]\n  },\n  \"options\": {}\n}\n\n#### Example 3: Expression-Based Assignments\nCurrent Parameters: {}\nRequested Changes:\n- Set userId from HTTP Request node\n- Calculate totalPrice from quantity and unit price\n\nExpected Output:\n{\n  \"assignments\": {\n    \"assignments\": [\n      {\n        \"id\": \"id-1\",\n        \"name\": \"userId\",\n        \"value\": \"={{ $('HTTP Request').item.json.id }}\",\n        \"type\": \"string\"\n      },\n      {\n        \"id\": \"id-2\",\n        \"name\": \"totalPrice\",\n        \"value\": \"={{ $('Set').item.json.quantity * $('Set').item.json.unitPrice }}\",\n        \"type\": \"number\"\n      }\n    ]\n  },\n  \"options\": {}\n}\n\n#### Example 4: Set Node - Complex Object and Array Creation\nCurrent Parameters:\n{\n  \"assignments\": {\n    \"assignments\": [\n      {\n        \"id\": \"existing-1\",\n        \"name\": \"orderId\",\n        \"value\": \"12345\",\n        \"type\": \"string\"\n      }\n    ]\n  },\n  \"options\": {}\n}\n\nRequested Changes:\n- Keep orderId\n- Add customer object with name and email from previous nodes\n- Add items array from JSON string\n- Set processed timestamp\n\nExpected Output:\n{\n  \"assignments\": {\n    \"assignments\": [\n      {\n        \"id\": \"existing-1\",\n        \"name\": \"orderId\",\n        \"value\": \"12345\",\n        \"type\": \"string\"\n      },\n      {\n        \"id\": \"id-2\",\n        \"name\": \"customer\",\n        \"value\": \"={{ JSON.stringify({ \\\"name\\\": $('Form').item.json.customerName, \\\"email\\\": $('Form').item.json.customerEmail }) }}\",\n        \"type\": \"object\"\n      },\n      {\n        \"id\": \"id-3\",\n        \"name\": \"items\",\n        \"value\": \"={{ $('HTTP Request').item.json.itemsJson }}\",\n        \"type\": \"array\"\n      },\n      {\n        \"id\": \"id-4\",\n        \"name\": \"processedAt\",\n        \"value\": \"={{ $now.toISO() }}\",\n        \"type\": \"string\"\n      }\n    ]\n  },\n  \"options\": {}\n}\n";

package/dist/chains/prompts/examples/basic/set-node-examples.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SET_NODE_EXAMPLES = void 0;
+exports.SET_NODE_EXAMPLES = `
+### Set Node Examples
+
+#### Example 1: Simple String Assignment
+Current Parameters: {}
+Requested Changes: Set message to "Hello World"
+Expected Output:
+{
+  "assignments": {
+    "assignments": [
+      {
+        "id": "id-1",
+        "name": "message",
+        "value": "Hello World",
+        "type": "string"
+      }
+    ]
+  },
+  "options": {}
+}
+
+#### Example 2: Multiple Type Assignments
+Current Parameters: {}
+Requested Changes:
+- Set productName to "Widget"
+- Set price to 19.99
+- Set inStock to true
+- Set categories to electronics and gadgets
+
+Expected Output:
+{
+  "assignments": {
+    "assignments": [
+      {
+        "id": "id-1",
+        "name": "productName",
+        "value": "Widget",
+        "type": "string"
+      },
+      {
+        "id": "id-2",
+        "name": "price",
+        "value": 19.99,
+        "type": "number"
+      },
+      {
+        "id": "id-3",
+        "name": "inStock",
+        "value": true,
+        "type": "boolean"
+      },
+      {
+        "id": "id-4",
+        "name": "categories",
+        "value": "[\\"electronics\\", \\"gadgets\\"]",
+        "type": "array"
+      }
+    ]
+  },
+  "options": {}
+}
+
+#### Example 3: Expression-Based Assignments
+Current Parameters: {}
+Requested Changes:
+- Set userId from HTTP Request node
+- Calculate totalPrice from quantity and unit price
+
+Expected Output:
+{
+  "assignments": {
+    "assignments": [
+      {
+        "id": "id-1",
+        "name": "userId",
+        "value": "={{ $('HTTP Request').item.json.id }}",
+        "type": "string"
+      },
+      {
+        "id": "id-2",
+        "name": "totalPrice",
+        "value": "={{ $('Set').item.json.quantity * $('Set').item.json.unitPrice }}",
+        "type": "number"
+      }
+    ]
+  },
+  "options": {}
+}
+
+#### Example 4: Set Node - Complex Object and Array Creation
+Current Parameters:
+{
+  "assignments": {
+    "assignments": [
+      {
+        "id": "existing-1",
+        "name": "orderId",
+        "value": "12345",
+        "type": "string"
+      }
+    ]
+  },
+  "options": {}
+}
+
+Requested Changes:
+- Keep orderId
+- Add customer object with name and email from previous nodes
+- Add items array from JSON string
+- Set processed timestamp
+
+Expected Output:
+{
+  "assignments": {
+    "assignments": [
+      {
+        "id": "existing-1",
+        "name": "orderId",
+        "value": "12345",
+        "type": "string"
+      },
+      {
+        "id": "id-2",
+        "name": "customer",
+        "value": "={{ JSON.stringify({ \\"name\\": $('Form').item.json.customerName, \\"email\\": $('Form').item.json.customerEmail }) }}",
+        "type": "object"
+      },
+      {
+        "id": "id-3",
+        "name": "items",
+        "value": "={{ $('HTTP Request').item.json.itemsJson }}",
+        "type": "array"
+      },
+      {
+        "id": "id-4",
+        "name": "processedAt",
+        "value": "={{ $now.toISO() }}",
+        "type": "string"
+      }
+    ]
+  },
+  "options": {}
+}
+`;
+//# sourceMappingURL=set-node-examples.js.map

package/dist/chains/prompts/examples/basic/set-node-examples.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-node-examples.js","sourceRoot":"","sources":["../../../../../src/chains/prompts/examples/basic/set-node-examples.ts"],"names":[],"mappings":";;;AAAa,QAAA,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+IhC,CAAC"}

package/dist/chains/prompts/examples/basic/simple-updates.d.ts

@@ -0,0 +1 @@
+export declare const SIMPLE_UPDATE_EXAMPLES = "\n## Examples of Parameter Updates\n\n### Example 1: Update HTTP Request URL\nChange: \"Set the URL to call the weather API for London\"\nCurrent parameters: { \"url\": \"https://api.example.com\", \"method\": \"GET\" }\nUpdated parameters: { \"url\": \"https://api.openweathermap.org/data/2.5/weather?q=London\", \"method\": \"GET\" }\n\n### Example 2: Add a header\nChange: \"Add an API key header with value from credentials\"\nCurrent parameters: { \"url\": \"...\", \"sendHeaders\": false }\nUpdated parameters: {\n  \"url\": \"...\",\n  \"sendHeaders\": true,\n  \"headerParameters\": {\n    \"parameters\": [\n      {\n        \"name\": \"X-API-Key\",\n        \"value\": \"={{ $credentials.apiKey }}\"\n      }\n    ]\n  }\n}\n\n### Example 3: Update condition\nChange: \"Check if temperature is above 25 degrees\"\nCurrent parameters: { \"conditions\": { \"conditions\": [] } }\nUpdated parameters: {\n  \"conditions\": {\n    \"options\": {\n      \"caseSensitive\": false,\n      \"leftValue\": \"\",\n      \"typeValidation\": \"loose\"\n    },\n    \"conditions\": [\n      {\n        \"leftValue\": \"={{ $('Weather Node').item.json.main.temp }}\",\n        \"rightValue\": 25,\n        \"operator\": {\n          \"type\": \"number\",\n          \"operation\": \"gt\"\n        }\n      }\n    ],\n    \"combinator\": \"and\"\n  }\n}";

package/dist/chains/prompts/examples/basic/simple-updates.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIMPLE_UPDATE_EXAMPLES = void 0;
+exports.SIMPLE_UPDATE_EXAMPLES = `
+## Examples of Parameter Updates
+
+### Example 1: Update HTTP Request URL
+Change: "Set the URL to call the weather API for London"
+Current parameters: { "url": "https://api.example.com", "method": "GET" }
+Updated parameters: { "url": "https://api.openweathermap.org/data/2.5/weather?q=London", "method": "GET" }
+
+### Example 2: Add a header
+Change: "Add an API key header with value from credentials"
+Current parameters: { "url": "...", "sendHeaders": false }
+Updated parameters: {
+  "url": "...",
+  "sendHeaders": true,
+  "headerParameters": {
+    "parameters": [
+      {
+        "name": "X-API-Key",
+        "value": "={{ $credentials.apiKey }}"
+      }
+    ]
+  }
+}
+
+### Example 3: Update condition
+Change: "Check if temperature is above 25 degrees"
+Current parameters: { "conditions": { "conditions": [] } }
+Updated parameters: {
+  "conditions": {
+    "options": {
+      "caseSensitive": false,
+      "leftValue": "",
+      "typeValidation": "loose"
+    },
+    "conditions": [
+      {
+        "leftValue": "={{ $('Weather Node').item.json.main.temp }}",
+        "rightValue": 25,
+        "operator": {
+          "type": "number",
+          "operation": "gt"
+        }
+      }
+    ],
+    "combinator": "and"
+  }
+}`;
+//# sourceMappingURL=simple-updates.js.map

package/dist/chains/prompts/examples/basic/simple-updates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-updates.js","sourceRoot":"","sources":["../../../../../src/chains/prompts/examples/basic/simple-updates.ts"],"names":[],"mappings":";;;AAAa,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8CpC,CAAC"}

package/dist/chains/prompts/node-types/http-request.d.ts

@@ -0,0 +1 @@
+export declare const HTTP_REQUEST_GUIDE = "\n### HTTP Request Node Updates\n\n#### Common Parameters\n- **url**: The endpoint URL (can use expressions)\n- **method**: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS\n- **authentication**: Type of auth (none, genericCredentialType, etc.)\n- **sendHeaders**: Boolean to enable custom headers\n- **headerParameters**: Array of header key-value pairs\n- **sendBody**: Boolean to enable request body (for POST/PUT/PATCH)\n- **bodyParameters**: Array of body parameters or raw body content\n- **contentType**: json, form, raw, etc.\n- **options**: Additional options like timeout, proxy, etc.\n\n#### Header Structure\n{\n  \"sendHeaders\": true,\n  \"headerParameters\": {\n    \"parameters\": [\n      {\n        \"name\": \"Header-Name\",\n        \"value\": \"Header Value or {{ expression }}\"\n      }\n    ]\n  }\n}\n\n#### Body Structure (JSON)\n{\n  \"sendBody\": true,\n  \"contentType\": \"json\",\n  \"bodyParameters\": {\n    \"parameters\": [\n      {\n        \"name\": \"fieldName\",\n        \"value\": \"fieldValue or {{ expression }}\"\n      }\n    ]\n  }\n}\n\n#### Authentication Options\n- **none**: No authentication\n- **genericCredentialType**: Use stored credentials\n- **predefinedCredentialType**: Use specific credential type\n- Can also set custom auth headers\n\n#### Common Patterns\n1. **Adding API Key Header**:\n   - Enable sendHeaders\n   - Add header with name \"X-API-Key\" or \"Authorization\"\n\n2. **Setting Request Body**:\n   - Enable sendBody\n   - Set contentType (usually \"json\")\n   - Add parameters to bodyParameters.parameters array\n\n3. **Dynamic URLs**:\n   - Can use expressions: \"=https://api.example.com/{{ $('Set').item.json.endpoint }}\"\n   - Can reference previous node data\n\n4. **Query Parameters**:\n   - Can be part of URL or set in options.queryParameters\n\n#### Example: HTTP Request with Headers and Body\nCurrent Parameters:\n{\n  \"method\": \"GET\",\n  \"url\": \"https://api.example.com/data\"\n}\n\nRequested Changes:\n- Change to POST method\n- Add API key header\n- Add JSON body with user ID and status\n\nExpected Output:\n{\n  \"method\": \"POST\",\n  \"url\": \"https://api.example.com/data\",\n  \"sendHeaders\": true,\n  \"headerParameters\": {\n    \"parameters\": [\n      {\n        \"name\": \"X-API-Key\",\n        \"value\": \"={{ $credentials.apiKey }}\"\n      },\n      {\n        \"name\": \"Content-Type\",\n        \"value\": \"application/json\"\n      }\n    ]\n  },\n  \"sendBody\": true,\n  \"contentType\": \"json\",\n  \"bodyParameters\": {\n    \"parameters\": [\n      {\n        \"name\": \"userId\",\n        \"value\": \"={{ $('Previous Node').item.json.id }}\"\n      },\n      {\n        \"name\": \"status\",\n        \"value\": \"active\"\n      }\n    ]\n  },\n  \"options\": {}\n}";

package/dist/chains/prompts/node-types/http-request.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_REQUEST_GUIDE = void 0;
+exports.HTTP_REQUEST_GUIDE = `
+### HTTP Request Node Updates
+
+#### 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 Headers and Body
+Current Parameters:
+{
+  "method": "GET",
+  "url": "https://api.example.com/data"
+}
+
+Requested Changes:
+- Change to POST method
+- Add API key header
+- Add JSON body with user ID and status
+
+Expected Output:
+{
+  "method": "POST",
+  "url": "https://api.example.com/data",
+  "sendHeaders": true,
+  "headerParameters": {
+    "parameters": [
+      {
+        "name": "X-API-Key",
+        "value": "={{ $credentials.apiKey }}"
+      },
+      {
+        "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": {}
+}`;
+//# sourceMappingURL=http-request.js.map

package/dist/chains/prompts/node-types/http-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-request.js","sourceRoot":"","sources":["../../../../src/chains/prompts/node-types/http-request.ts"],"names":[],"mappings":";;;AAAa,QAAA,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4GhC,CAAC"}

package/dist/chains/prompts/node-types/if-node.d.ts

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

package/dist/chains/prompts/node-types/if-node.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IF_NODE_GUIDE = void 0;
+exports.IF_NODE_GUIDE = `
+### IF Node Updates - Comprehensive Guide
+
+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/chains/prompts/node-types/if-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"if-node.js","sourceRoot":"","sources":["../../../../src/chains/prompts/node-types/if-node.ts"],"names":[],"mappings":";;;AAAa,QAAA,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2FAyJ8D,CAAC"}

package/dist/chains/prompts/node-types/set-node.d.ts

@@ -0,0 +1 @@
+export declare const SET_NODE_GUIDE = "\n### Set Node Updates - Comprehensive Type Handling Guide\n\nThe 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.\n\n#### Assignment Structure\n```json\n{\n  \"id\": \"unique-id\",\n  \"name\": \"field_name\",\n  \"value\": \"field_value\",  // Format depends on type\n  \"type\": \"string|number|boolean|array|object\"\n}\n```\n\n**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.\n\n#### Type-Specific Value Formatting\n\n##### String Type\n- **Format**: Direct string value or expression\n- **Examples**:\n  - Literal: `\"Hello World\"`\n  - Expression: `\"={{ $('Previous Node').item.json.message }}\"`\n  - With embedded expressions: `\"=Order #{{ $('Set').item.json.orderId }} processed\"`\n- **Use when**: Text data, IDs, names, messages, dates as strings\n\n##### Number Type\n- **Format**: Direct numeric value (NOT as a string)\n- **Examples**:\n  - Integer: `123`\n  - Decimal: `45.67`\n  - Negative: `-100`\n  - Expression: `\"={{ $('HTTP Request').item.json.count }}\"`\n- **CRITICAL**: Use actual numbers, not strings: `123` not `\"123\"`\n- **Use when**: Quantities, prices, scores, numeric calculations\n\n##### Boolean Type\n- **Format**: Direct boolean value (NOT as a string)\n- **Examples**:\n  - True: `true`\n  - False: `false`\n  - Expression: `\"={{ $('IF').item.json.isActive }}\"`\n- **CRITICAL**: Use actual booleans, not strings: `true` not `\"true\"`\n- **CRITICAL**: The field name is \"value\", NOT \"booleanValue\"\n- **Use when**: Flags, toggles, yes/no values, active/inactive states\n\n##### Array Type\n- **Format**: JSON stringified array\n- **Examples**:\n  - Simple array: `\"[1, 2, 3]\"`\n  - String array: `\"[\\\"apple\\\", \\\"banana\\\", \\\"orange\\\"]\"`\n  - Mixed array: `\"[\\\"item1\\\", 123, true]\"`\n  - Expression: `\"={{ JSON.stringify($('Previous Node').item.json.items) }}\"`\n- **CRITICAL**: Arrays must be JSON stringified\n- **Use when**: Lists, collections, multiple values\n\n##### Object Type\n- **Format**: JSON stringified object\n- **Examples**:\n  - Simple object: `\"{ \\\"name\\\": \\\"John\\\", \\\"age\\\": 30 }\"`\n  - Nested object: `\"{ \\\"user\\\": { \\\"id\\\": 123, \\\"role\\\": \\\"admin\\\" } }\"`\n  - Expression: `\"={{ JSON.stringify($('Set').item.json.userData) }}\"`\n- **CRITICAL**: Objects must be JSON stringified with escaped quotes\n- **Use when**: Complex data structures, grouped properties\n\n#### Important Type Selection Rules\n\n1. **Analyze the requested data type**:\n   - \"Set count to 5\" \u2192 number type with value: `5`\n   - \"Set message to hello\" \u2192 string type with value: `\"hello\"`\n   - \"Set active to true\" \u2192 boolean type with value: `true`\n   - \"Set tags to apple, banana\" \u2192 array type with value: `\"[\\\"apple\\\", \\\"banana\\\"]\"`\n\n2. **Expression handling**:\n   - All types can use expressions with `\"={{ ... }}\"`\n   - For arrays/objects from expressions, use `JSON.stringify()`\n\n3. **Common mistakes to avoid**:\n   - WRONG: Setting number as string: `{ \"value\": \"123\", \"type\": \"number\" }`\n   - CORRECT: `{ \"value\": 123, \"type\": \"number\" }`\n   - WRONG: Setting boolean as string: `{ \"value\": \"false\", \"type\": \"boolean\" }`\n   - CORRECT: `{ \"value\": false, \"type\": \"boolean\" }`\n   - WRONG: Using type-specific field names: `{ \"booleanValue\": true, \"type\": \"boolean\" }`\n   - CORRECT: `{ \"value\": true, \"type\": \"boolean\" }`\n   - WRONG: Setting array without stringification: `{ \"value\": [1,2,3], \"type\": \"array\" }`\n   - CORRECT: `{ \"value\": \"[1,2,3]\", \"type\": \"array\" }`";

package/dist/chains/prompts/node-types/set-node.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SET_NODE_GUIDE = void 0;
+exports.SET_NODE_GUIDE = `
+### 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/chains/prompts/node-types/set-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-node.js","sourceRoot":"","sources":["../../../../src/chains/prompts/node-types/set-node.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAsF4B,CAAC"}

package/dist/chains/prompts/node-types/tool-nodes.d.ts

@@ -0,0 +1 @@
+export declare const TOOL_NODES_GUIDE = "\n## CRITICAL: $fromAI Expression Support for Tool Nodes\n\nTool 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.\n\n### When to Use $fromAI\n- ONLY available in tool nodes (node types ending with \"Tool\")\n- Use when the AI should determine the value based on context\n- Ideal for parameters that vary based on user input or conversation context\n\n### $fromAI Syntax\n`={{ $fromAI('key', 'description', 'type', defaultValue) }}`\n\n### Parameters\n- key: Unique identifier (1-64 chars, alphanumeric/underscore/hyphen)\n- description: Optional description for the AI (use empty string '' if not needed)\n- type: 'string' | 'number' | 'boolean' | 'json' (defaults to 'string')\n- defaultValue: Optional fallback value\n\n### Tool Node Examples\n\n#### Gmail Tool - Sending Email\n{\n  \"sendTo\": \"={{ $fromAI('to') }}\",\n  \"subject\": \"={{ $fromAI('subject') }}\",\n  \"message\": \"={{ $fromAI('message_html') }}\"\n}\n\n#### Google Calendar Tool - Filtering Events\n{\n  \"timeMin\": \"={{ $fromAI('After', '', 'string') }}\",\n  \"timeMax\": \"={{ $fromAI('Before', '', 'string') }}\"\n}\n\n### Mixed Usage Examples\nYou can combine $fromAI with regular text:\n- \"Subject: {{ $fromAI('subject') }} - Automated\"\n- \"Dear {{ $fromAI('recipientName', 'Customer name', 'string', 'Customer') }},\"\n\n### Important Rules\n1. ONLY use $fromAI in tool nodes (check if node type ends with \"Tool\")\n2. For timeMin/timeMax and similar date fields, use appropriate key names\n3. The AI will fill these values based on context during execution\n4. Don't use $fromAI in regular nodes like Set, IF, HTTP Request, etc.\n\n## Tool Node Parameter Guidelines\n\n### Identifying Tool Nodes\n1. CHECK NODE TYPE: If the node type ends with \"Tool\", it supports $fromAI expressions\n2. COMMON TOOL NODES:\n   - Gmail Tool (gmailTool): to, subject, message \u2192 use $fromAI\n   - Google Calendar Tool (googleCalendarTool): timeMin, timeMax \u2192 use $fromAI\n   - Slack Tool (slackTool): channel, message \u2192 use $fromAI\n   - Microsoft Teams Tool: channel, message \u2192 use $fromAI\n   - Telegram Tool: chatId, text \u2192 use $fromAI\n   - Other communication/document tools: content fields \u2192 use $fromAI\n\n### When to Use $fromAI in Tool Nodes\n1. DYNAMIC VALUES: Use $fromAI for values that should be determined by AI based on context\n2. USER INPUT FIELDS: Recipients, subjects, messages, date ranges\n3. PRESERVE EXISTING: If a parameter already uses $fromAI, keep it unless explicitly asked to change\n4. DATE/TIME FIELDS: Use descriptive key names for clarity\n\n### Tool Node Parameter Patterns\n- Email recipients: \"={{ $fromAI('to') }}\"\n- Email subjects: \"={{ $fromAI('subject') }}\"\n- Message content: \"={{ $fromAI('message_html') }}\" or \"={{ $fromAI('message') }}\"\n- Date ranges: \"={{ $fromAI('After', '', 'string') }}\"\n- Channel IDs: \"={{ $fromAI('channel') }}\"";