@atom8n/ai-workflow-builder 1.2.0

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWITCH_NODE_EXAMPLES = void 0;
+exports.SWITCH_NODE_EXAMPLES = {
+    patterns: ['n8n-nodes-base.switch'],
+    content: `
+### Switch Node Examples
+
+#### Example 1: Route by Amount Tiers (Purchase Approval)
+Current Parameters: { "mode": "rules" }
+Requested Changes: Route under $100 to auto-approve, $100-$1000 to manager, over $1000 to finance
+
+Expected Output:
+{
+  "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": "Auto-Approve"
+      },
+      {
+        "conditions": {
+          "options": { "caseSensitive": true, "leftValue": "", "typeValidation": "strict" },
+          "conditions": [
+            {
+              "leftValue": "={{ $json.amount }}",
+              "rightValue": 100,
+              "operator": { "type": "number", "operation": "gte" }
+            },
+            {
+              "leftValue": "={{ $json.amount }}",
+              "rightValue": 1000,
+              "operator": { "type": "number", "operation": "lte" }
+            }
+          ],
+          "combinator": "and"
+        },
+        "renameOutput": true,
+        "outputKey": "Manager Review"
+      },
+      {
+        "conditions": {
+          "options": { "caseSensitive": true, "leftValue": "", "typeValidation": "strict" },
+          "conditions": [
+            {
+              "leftValue": "={{ $json.amount }}",
+              "rightValue": 1000,
+              "operator": { "type": "number", "operation": "gt" }
+            }
+          ],
+          "combinator": "and"
+        },
+        "renameOutput": true,
+        "outputKey": "Finance Review"
+      }
+    ]
+  }
+}
+
+#### Example 2: Route by Status String
+Current Parameters: { "mode": "rules" }
+Requested Changes: Route by order status - pending, processing, completed
+
+Expected Output:
+{
+  "mode": "rules",
+  "rules": {
+    "values": [
+      {
+        "conditions": {
+          "options": { "caseSensitive": false, "leftValue": "", "typeValidation": "loose" },
+          "conditions": [
+            {
+              "leftValue": "={{ $json.status }}",
+              "rightValue": "pending",
+              "operator": { "type": "string", "operation": "equals" }
+            }
+          ],
+          "combinator": "and"
+        },
+        "renameOutput": true,
+        "outputKey": "Pending"
+      },
+      {
+        "conditions": {
+          "options": { "caseSensitive": false, "leftValue": "", "typeValidation": "loose" },
+          "conditions": [
+            {
+              "leftValue": "={{ $json.status }}",
+              "rightValue": "processing",
+              "operator": { "type": "string", "operation": "equals" }
+            }
+          ],
+          "combinator": "and"
+        },
+        "renameOutput": true,
+        "outputKey": "Processing"
+      },
+      {
+        "conditions": {
+          "options": { "caseSensitive": false, "leftValue": "", "typeValidation": "loose" },
+          "conditions": [
+            {
+              "leftValue": "={{ $json.status }}",
+              "rightValue": "completed",
+              "operator": { "type": "string", "operation": "equals" }
+            }
+          ],
+          "combinator": "and"
+        },
+        "renameOutput": true,
+        "outputKey": "Completed"
+      }
+    ]
+  }
+}
+`,
+};
+//# sourceMappingURL=switch-node.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"switch-node.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/examples/switch-node.ts"],"names":[],"mappings":";;;AAEa,QAAA,oBAAoB,GAAqB;IACrD,QAAQ,EAAE,CAAC,uBAAuB,CAAC;IACnC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2HT;CACA,CAAC"}

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

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

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_NODE_EXAMPLES = void 0;
+exports.TOOL_NODE_EXAMPLES = {
+    patterns: ['*Tool'],
+    content: `
+### Tool Node Examples
+
+#### Example 1: Gmail Tool - Send Email with AI
+Current Parameters: {}
+Requested Changes: Let AI determine recipient, subject, and message
+Expected Output:
+{
+  "sendTo": "={{ $fromAI('to') }}",
+  "subject": "={{ $fromAI('subject') }}",
+  "message": "={{ $fromAI('message_html') }}",
+  "options": {}
+}
+
+#### Example 2: Google Calendar Tool - Filter by Date
+Current Parameters:
+{
+  "operation": "getAll",
+  "calendar": {
+    "__rl": true,
+    "value": "primary",
+    "mode": "list"
+  }
+}
+
+Requested Changes: Let AI determine date range for filtering
+
+Expected Output:
+{
+  "operation": "getAll",
+  "calendar": {
+    "__rl": true,
+    "value": "primary",
+    "mode": "list"
+  },
+  "timeMin": "={{ $fromAI('After', '', 'string') }}",
+  "timeMax": "={{ $fromAI('Before', '', 'string') }}"
+}
+
+#### Example 3: Slack Tool - Send Message
+Current Parameters:
+{
+  "resource": "message"
+}
+
+Requested Changes: Let AI determine channel and message content
+
+Expected Output:
+{
+  "resource": "message",
+  "channelId": "={{ $fromAI('channel') }}",
+  "messageText": "={{ $fromAI('message') }}"
+}
+
+#### Example 4: Tool Node with Mixed Content
+Current Parameters:
+{
+  "sendTo": "admin@company.com"
+}
+
+Requested Changes: Keep admin email but let AI add additional recipients and determine subject
+
+Expected Output:
+{
+  "sendTo": "=admin@company.com, {{ $fromAI('additional_recipients') }}",
+  "subject": "={{ $fromAI('subject') }} - Automated Report"
+}`,
+};
+//# sourceMappingURL=tool-nodes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-nodes.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/examples/tool-nodes.ts"],"names":[],"mappings":";;;AAEa,QAAA,kBAAkB,GAAqB;IACnD,QAAQ,EAAE,CAAC,OAAO,CAAC;IACnB,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkER;CACD,CAAC"}

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

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

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMBEDDING_NODES_GUIDE = void 0;
+exports.EMBEDDING_NODES_GUIDE = {
+    patterns: ['@n8n/n8n-nodes-langchain.embeddings*'],
+    content: `
+## CRITICAL: Embedding Models vs Chat Models
+
+Embedding nodes (nodes with "embeddings" in their type name) MUST use embedding models, NOT chat/language models. Using a chat model in an embedding node will cause the workflow to fail.
+
+### Common Mistake to Avoid
+NEVER configure an embedding node with chat models like:
+- gpt-4, gpt-4o, gpt-4o-mini, gpt-3.5-turbo (OpenAI chat models)
+- claude-3-opus, claude-3-sonnet (Anthropic chat models)
+- gemini-pro, gemini-1.5-pro (Google chat models)
+- llama-3, mixtral (general LLM models)
+
+These are language/chat models designed for text generation, NOT for creating embeddings.
+
+### Correct Embedding Models by Provider
+
+#### OpenAI Embeddings
+- text-embedding-3-small (RECOMMENDED - default)
+- text-embedding-3-large
+- text-embedding-ada-002 (legacy)
+
+#### AWS Bedrock Embeddings
+- amazon.titan-embed-text-v1
+- amazon.titan-embed-text-v2:0
+- cohere.embed-english-v3
+- cohere.embed-multilingual-v3
+
+#### Google Gemini Embeddings
+- models/text-embedding-004 (RECOMMENDED - default)
+- models/embedding-001
+
+#### Cohere Embeddings
+- embed-english-v3.0 (1024 dimensions)
+- embed-multilingual-v3.0 (1024 dimensions)
+- embed-english-light-v3.0 (384 dimensions)
+- embed-multilingual-light-v3.0 (384 dimensions)
+- embed-english-v2.0 (4096 dimensions)
+
+#### Mistral Embeddings
+- mistral-embed (default)
+
+#### Ollama Embeddings
+- nomic-embed-text
+- mxbai-embed-large
+- all-minilm
+- snowflake-arctic-embed
+
+### How to Identify Embedding Models
+Embedding model names typically contain:
+- "embed" or "embedding" in the name
+- "e5", "bge", "gte" (common embedding model families)
+- "nomic", "minilm", "arctic" (embedding-specific models)
+
+### Key Rules
+1. ALWAYS check if the node type contains "embeddings" - if so, use an embedding model
+2. If the user mentions a chat model (gpt-4, claude, gemini-pro, etc.) for embeddings, do NOT use it
+3. Suggest the appropriate embedding model from the same provider instead
+4. When in doubt, use the provider's default embedding model
+
+### Parameter Names
+The model parameter may be named:
+- "model" (OpenAI, Bedrock, Mistral, Ollama, Azure)
+- "modelName" (Google Gemini, Cohere)`,
+};
+//# sourceMappingURL=embedding-nodes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-nodes.js","sourceRoot":"","sources":["../../../../../src/prompts/chains/parameter-updater/guides/embedding-nodes.ts"],"names":[],"mappings":";;;AAEa,QAAA,qBAAqB,GAAkB;IACnD,QAAQ,EAAE,CAAC,sCAAsC,CAAC;IAClD,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCA8D4B;CACrC,CAAC"}

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GMAIL_GUIDE = void 0;
+exports.GMAIL_GUIDE = {
+    patterns: ['n8n-nodes-base.gmail'],
+    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
+
+#### Common Patterns
+1. **Sending Email**:
+   - Set resource to "message"
+   - Set operation to "send"
+   - Configure to, subject, and message fields
+
+2. **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

@@ -0,0 +1 @@
+{"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,CAAC;IAClC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;CAoBT;CACA,CAAC"}

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"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/index.d.ts

@@ -0,0 +1,10 @@
+export { SET_NODE_GUIDE } from './set-node';
+export { IF_NODE_GUIDE } from './if-node';
+export { SWITCH_NODE_GUIDE } from './switch-node';
+export { HTTP_REQUEST_GUIDE } from './http-request';
+export { TOOL_NODES_GUIDE } from './tool-nodes';
+export { GMAIL_GUIDE } from './gmail';
+export { EMBEDDING_NODES_GUIDE } from './embedding-nodes';
+export { RESOURCE_LOCATOR_GUIDE } from './resource-locator';
+export { SYSTEM_MESSAGE_GUIDE } from './system-message';
+export { TEXT_FIELDS_GUIDE } from './text-fields';