@n8n/ai-workflow-builder 0.13.0 → 0.14.0

package/dist/chains/node-selector.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodesSelectionChain = exports.nodeSelectorPrompt = void 0;
-const messages_1 = require("@langchain/core/messages");
-const prompts_1 = require("@langchain/core/prompts");
-const tools_1 = require("@langchain/core/tools");
-const n8n_workflow_1 = require("n8n-workflow");
-const zod_1 = require("zod");
-exports.nodeSelectorPrompt = new messages_1.SystemMessage(`You are an expert in n8n workflows who selects the optimal n8n nodes to implement workflow steps.
-
-## Your Task
-For each workflow step, recommend the most appropriate n8n nodes from the allowed list.
-
-## Input Information
-- <user_request>: Original user workflow request
-- <steps>: List of workflow steps to implement
-- <allowed_n8n_nodes>: List of available n8n nodes with descriptions
-
-## CRITICAL REQUIREMENTS
-- ONLY recommend nodes that EXACTLY match names from the <allowed_n8n_nodes> list
-- NEVER suggest nodes that are not explicitly defined in <allowed_n8n_nodes>
-- ALWAYS use the COMPLETE node name as it appears in <node_name> tags (e.g., "Gmail" is NOT sufficient if the node name is "n8n-nodes-base.gmail")
-- VERIFY each recommended node exists in the allowed list before including it
-
-## Selection Criteria
-1. Functionality - Node must be able to perform the required action
-2. Integration - Prefer nodes that integrate directly with services mentioned in the user request
-3. Efficiency - Prefer nodes that accomplish the task with minimal configuration
-
-## Output Requirements
-For the planned workflow steps, provider:
-1. List of all possibly useful nodes in order of preference
-2. Concise reasoning for why each node is suitable
-3. Use EXACT, FULL node names from <node_name> tags
-4. Pay attention to case sensitivity, e.g. "n8n-nodes-base.msql" is NOT "n8n-nodes-base.mySql"!
-
-Remember: ONLY use nodes from the <allowed_n8n_nodes> list and ALWAYS use their FULL names exactly as provided.`);
-const nodeSelectorSchema = zod_1.z.object({
-    recommended_nodes: zod_1.z
-        .array(zod_1.z.object({
-        score: zod_1.z.number().describe('Matching score of the node for all the workflows steps'),
-        node: zod_1.z
-            .string()
-            .describe('The full node type identifier (e.g., "n8n-nodes-base.if") from <allowed_n8n_nodes> list'),
-        reasoning: zod_1.z
-            .string()
-            .describe('Very short explanation of why this node might be used to implement the workflow step'),
-    }))
-        .min(1)
-        .max(20)
-        .describe('Recommended n8n nodes for implementing any of the workflow steps, in order of descending preference. ONLY use nodes from the <allowed_n8n_nodes> list with EXACT full names from <node_name> tags.'),
-});
-const nodeSelectorTool = new tools_1.DynamicStructuredTool({
-    name: 'select_n8n_nodes',
-    description: 'Match each workflow step with the most appropriate n8n nodes from the allowed list, ensuring they can implement the required functionality.',
-    schema: nodeSelectorSchema,
-    func: async ({ recommended_nodes }) => {
-        return { recommended_nodes };
-    },
-});
-const humanTemplate = `
-<user_request>
-	{prompt}
-</user_request>
-<steps>
-	{steps}
-</steps>
-<allowed_n8n_nodes>
-	{allowedNodes}
-</allowed_n8n_nodes>
-`;
-const chatPrompt = prompts_1.ChatPromptTemplate.fromMessages([
-    exports.nodeSelectorPrompt,
-    prompts_1.HumanMessagePromptTemplate.fromTemplate(humanTemplate),
-]);
-const nodesSelectionChain = (llm) => {
-    if (!llm.bindTools) {
-        throw new n8n_workflow_1.OperationalError("LLM doesn't support binding tools");
-    }
-    return chatPrompt
-        .pipe(llm.bindTools([nodeSelectorTool], {
-        tool_choice: nodeSelectorTool.name,
-    }))
-        .pipe((x) => {
-        const toolCall = x.tool_calls?.[0];
-        return (toolCall?.args).recommended_nodes;
-    });
-};
-exports.nodesSelectionChain = nodesSelectionChain;
-//# sourceMappingURL=node-selector.js.map

package/dist/chains/node-selector.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-selector.js","sourceRoot":"","sources":["../../src/chains/node-selector.ts"],"names":[],"mappings":";;;AAEA,uDAAyD;AACzD,qDAAyF;AACzF,iDAA8D;AAC9D,+CAAgD;AAChD,6BAAwB;AAEX,QAAA,kBAAkB,GAAG,IAAI,wBAAa,CAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;gHA4B+G,CAC/G,CAAC;AACF,MAAM,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IACnC,iBAAiB,EAAE,OAAC;SAClB,KAAK,CACL,OAAC,CAAC,MAAM,CAAC;QACR,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wDAAwD,CAAC;QACpF,IAAI,EAAE,OAAC;aACL,MAAM,EAAE;aACR,QAAQ,CACR,yFAAyF,CACzF;QACF,SAAS,EAAE,OAAC;aACV,MAAM,EAAE;aACR,QAAQ,CACR,sFAAsF,CACtF;KACF,CAAC,CACF;SACA,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,EAAE,CAAC;SACP,QAAQ,CACR,oMAAoM,CACpM;CACF,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,IAAI,6BAAqB,CAAC;IAClD,IAAI,EAAE,kBAAkB;IACxB,WAAW,EACV,6IAA6I;IAC9I,MAAM,EAAE,kBAAkB;IAC1B,IAAI,EAAE,KAAK,EAAE,EAAE,iBAAiB,EAAE,EAAE,EAAE;QACrC,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC9B,CAAC;CACD,CAAC,CAAC;AAEH,MAAM,aAAa,GAAG;;;;;;;;;;CAUrB,CAAC;AAEF,MAAM,UAAU,GAAG,4BAAkB,CAAC,YAAY,CAAC;IAClD,0BAAkB;IAClB,oCAA0B,CAAC,YAAY,CAAC,aAAa,CAAC;CACtD,CAAC,CAAC;AAEI,MAAM,mBAAmB,GAAG,CAAC,GAAkB,EAAE,EAAE;IACzD,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QACpB,MAAM,IAAI,+BAAgB,CAAC,mCAAmC,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,UAAU;SACf,IAAI,CACJ,GAAG,CAAC,SAAS,CAAC,CAAC,gBAAgB,CAAC,EAAE;QACjC,WAAW,EAAE,gBAAgB,CAAC,IAAI;KAClC,CAAC,CACF;SACA,IAAI,CAAC,CAAC,CAAiB,EAAE,EAAE;QAC3B,MAAM,QAAQ,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;QACnC,OAAO,CAAC,QAAQ,EAAE,IAA2C,CAAA,CAAC,iBAAiB,CAAC;IACjF,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAfW,QAAA,mBAAmB,uBAe9B"}

package/dist/chains/nodes-composer.d.ts

@@ -1,8 +0,0 @@
-import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { ChatPromptTemplate } from '@langchain/core/prompts';
-export declare const nodesComposerPrompt: ChatPromptTemplate<any, any>;
-export declare const nodesComposerChain: (llm: BaseChatModel) => import("@langchain/core/runnables").Runnable<any, {
-    type: string;
-    parameters: Record<string, any>;
-    name: string;
-}[], import("@langchain/core/runnables").RunnableConfig<Record<string, any>>>;

package/dist/chains/nodes-composer.js

@@ -1,451 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodesComposerChain = exports.nodesComposerPrompt = void 0;
-const messages_1 = require("@langchain/core/messages");
-const prompts_1 = require("@langchain/core/prompts");
-const tools_1 = require("@langchain/core/tools");
-const n8n_workflow_1 = require("n8n-workflow");
-const zod_1 = require("zod");
-const systemPrompt = new messages_1.SystemMessage(`You are an expert n8n workflow architect who creates complete node configurations for complex workflows.
-
-## Your Task
-Generate fully-formed n8n node configurations with properly structured parameters for each selected node.
-
-## Reference Information
-You will receive:
-1. The original user workflow request
-2. A list of selected n8n nodes with their descriptions and parameters
-
-## Node Configuration Guidelines
-1. CREATE PROPER STRUCTURE: Include all required fields (parameters, name, type)
-2. USE DESCRIPTIVE NAMES: Each node name should clearly describe its function
-3. POPULATE KEY PARAMETERS: Set values for essential parameters based on node type
-4. MAINTAIN LOGICAL FLOW: Node parameters should enable proper data flow
-5. FOLLOW NODE PATTERNS: Use the correct structure for each node type
-6. ADD DOCUMENTATION: Include at least one sticky note, explaining the workflow. Include additional sticky notes for complex parts of the workflow.
-
-## CRITICAL: Correctly Formatting n8n Expressions
-When using expressions to reference data from other nodes:
-- ALWAYS use the format: \`={{ $('Node Name').item.json.field }}\`
-- NEVER omit the equals sign before the double curly braces
-- ALWAYS use DOUBLE curly braces, never single
-- NEVER use emojis or special characters inside expressions as they will break the expression
-- INCORRECT: \`{ $('Node Name').item.json.field }\` (missing =, single braces)
-- INCORRECT: \`{{ $('Node Name').item.json.field }}\` (missing =)
-- INCORRECT: \`={{ $('👍 Node').item.json.field }}\` (contains emoji)
-- CORRECT: \`={{ $('Previous Node').item.json.field }}\`
-
-This format is essential for n8n to properly process the expression.
-
-## IF Node Configuration (CRITICAL)
-The IF node allows conditional branching based on comparing values. It has two outputs:
-- Output 0: TRUE branch (when conditions are met)
-- Output 1: FALSE branch (when conditions are NOT met)
-
-### Key Points for IF Node:
-1. MATCH OPERATOR TYPE TO DATA TYPE - Use the correct operator type that matches your data:
-   - For string values: use "type": "string" with operations like "equals", "contains", "exists"
-   - For number values: use "type": "number" with operations like "equals", "gt", "lt"
-   - For boolean values: use "type": "boolean" with operations like "equals", "true", "false"
-   - For arrays: use "type": "array" with operations like "empty", "contains"
-   - For objects: use "type": "object" with operations like "exists", "empty"
-   - For dates: use "type": "dateTime" with operations like "before", "after"
-
-2. USE SINGLE VALUE OPERATORS CORRECTLY:
-   - Some operators like "exists", "notExists", "empty" don't need a right value
-   - For these operators, include "singleValue": true in the operator object
-   - Example: Checking if a string exists: "operator": { "type": "string", "operation": "exists", "singleValue": true }
-
-3. USE CORRECT DATA TYPES FOR RIGHT VALUES:
-   - Number comparisons: use actual numbers (without quotes) like 5, not "5"
-   - Boolean comparisons: use true or false (without quotes), not "true" or "false"
-   - String comparisons: use quoted strings like "text"
-   - When using expressions for the right value, include the proper format: "={{ expression }}"
-
-### IF Node Examples
-#### Example 1: Check if a number is greater than 5
-\`\`\`json
-{
-  "parameters": {
-    "conditions": {
-      "options": {
-        "caseSensitive": false,
-        "leftValue": "",
-        "typeValidation": "loose"
-      },
-      "conditions": [
-        {
-          "leftValue": "={{ $('Previous Node').item.json.amount }}",
-          "rightValue": 5,
-          "operator": {
-            "type": "number",
-            "operation": "gt"
-          }
-        }
-      ],
-      "combinator": "and"
-    },
-    "options": {
-      "ignoreCase": true,
-      "looseTypeValidation": true
-    }
-  }
-}
-\`\`\`
-
-#### Example 2: Check if a string exists
-\`\`\`json
-{
-  "parameters": {
-    "conditions": {
-      "options": {
-        "caseSensitive": false,
-        "leftValue": "",
-        "typeValidation": "loose"
-      },
-      "conditions": [
-        {
-          "leftValue": "={{ $('Previous Node').item.json.email }}",
-          "rightValue": "",
-          "operator": {
-            "type": "string",
-            "operation": "exists",
-            "singleValue": true
-          }
-        }
-      ],
-      "combinator": "and"
-    },
-    "options": {
-      "ignoreCase": true,
-      "looseTypeValidation": true
-    }
-  }
-}
-\`\`\`
-
-#### Example 3: Check if a boolean is true
-\`\`\`json
-{
-  "parameters": {
-    "conditions": {
-      "options": {
-        "caseSensitive": false,
-        "leftValue": "",
-        "typeValidation": "loose"
-      },
-      "conditions": [
-        {
-          "leftValue": "={{ $('Previous Node').item.json.isActive }}",
-          "rightValue": "",
-          "operator": {
-            "type": "boolean",
-            "operation": "true",
-            "singleValue": true
-          }
-        }
-      ],
-      "combinator": "and"
-    },
-    "options": {
-      "ignoreCase": true,
-      "looseTypeValidation": true
-    }
-  }
-}
-\`\`\`
-
-#### Example 4: Compare string value
-\`\`\`json
-{
-  "parameters": {
-    "conditions": {
-      "options": {
-        "caseSensitive": false,
-        "leftValue": "",
-        "typeValidation": "loose"
-      },
-      "conditions": [
-        {
-          "leftValue": "={{ $('Previous Node').item.json.status }}",
-          "rightValue": "active",
-          "operator": {
-            "type": "string",
-            "operation": "equals"
-          }
-        }
-      ],
-      "combinator": "and"
-    },
-    "options": {
-      "ignoreCase": true,
-      "looseTypeValidation": true
-    }
-  }
-}
-\`\`\`
-
-#### Example 5: Compare boolean value
-\`\`\`json
-{
-  "parameters": {
-    "conditions": {
-      "options": {
-        "caseSensitive": false,
-        "leftValue": "",
-        "typeValidation": "loose"
-      },
-      "conditions": [
-        {
-          "leftValue": "={{ $('Previous Node').item.json.isVerified }}",
-          "rightValue": true,
-          "operator": {
-            "type": "boolean",
-            "operation": "equals"
-          }
-        }
-      ],
-      "combinator": "and"
-    },
-    "options": {
-      "ignoreCase": true,
-      "looseTypeValidation": true
-    }
-  }
-}
-\`\`\`
-
-### Common Operator Types and Operations
-
-#### String Operators:
-- "exists", "notExists", "empty", "notEmpty" (use with "singleValue": true)
-- "equals", "notEquals", "contains", "notContains", "startsWith", "endsWith", "regex"
-
-#### Number Operators:
-- "exists", "notExists" (use with "singleValue": true)
-- "equals", "notEquals", "gt" (greater than), "lt" (less than), "gte" (greater than or equal), "lte" (less than or equal)
-
-#### Boolean Operators:
-- "exists", "notExists" (use with "singleValue": true)
-- "true", "false" (use with "singleValue": true)
-- "equals", "notEquals"
-
-#### Array Operators:
-- "exists", "notExists", "empty", "notEmpty" (use with "singleValue": true)
-- "contains", "notContains", "lengthEquals", "lengthNotEquals"
-
-## Other Important Node Structures
-
-### Set Node Structure
-\`\`\`json
-{
-  "parameters": {
-    "assignments": {
-      "assignments": [
-        {
-          "id": "unique-id-1",
-          "name": "property_name_1",
-          "value": "property_value_1",
-          "type": "string"
-        }
-      ]
-    },
-    "options": {}
-  }
-}
-\`\`\`
-
-### HTTP Request Node Structures
-
-#### GET Request
-\`\`\`json
-{
-  "parameters": {
-    "url": "https://example.com",
-    "sendHeaders": true,
-    "headerParameters": {
-      "parameters": [
-        {
-          "name": "header-name",
-          "value": "header-value"
-        }
-      ]
-    },
-    "options": {}
-  }
-}
-\`\`\`
-
-#### POST Request
-\`\`\`json
-{
-  "parameters": {
-    "method": "POST",
-    "url": "https://example.com",
-    "sendHeaders": true,
-    "headerParameters": {
-      "parameters": [
-        {
-          "name": "header-name",
-          "value": "header-value"
-        }
-      ]
-    },
-    "sendBody": true,
-    "bodyParameters": {
-      "parameters": [
-        {
-          "name": "field-name",
-          "value": "field-value"
-        }
-      ]
-    },
-    "options": {}
-  }
-}
-\`\`\`
-
-### Sticky Note Structure
-\`\`\`json
-{
-  "parameters": {
-    "content": "Note content here"
-  },
-  "name": "Descriptive Name",
-  "type": "n8n-nodes-base.stickyNote",
-  "notes": true
-}
-\`\`\`
-
-## Expression Examples
-1. Reference a field from another node:
-   \`\`\`
-   "value": "={{ $('Previous Node').item.json.fieldName }}"
-   \`\`\`
-
-2. Use an expression with string concatenation:
-   \`\`\`
-   "value": "={{ 'Hello ' + $('User Input').item.json.name }}"
-   \`\`\`
-
-3. Access an array item:
-   \`\`\`
-   "value": "={{ $('Data Node').item.json.items[0].id }}"
-   \`\`\`
-
-4. IMPORTANT: How to properly format text fields with expressions
-
-   ### PREFERRED METHOD: Embedding expressions directly within text
-   \`\`\`
-   "text": "=ALERT: It is currently raining in {{ $('Weather Node').item.json.city }}! Temperature: {{ $('Weather Node').item.json.main.temp }}°C"
-   \`\`\`
-
-   ### Alternative method: Using string concatenation (use only when needed for complex operations)
-   \`\`\`
-   "text": "={{ 'ALERT: It is currently raining in ' + $('Weather Node').item.json.city + '! Temperature: ' + $('Weather Node').item.json.temp + '°C' }}"
-   \`\`\`
-
-## CRITICAL: Formatting Text Fields with Expressions
-
-### KEY RULES FOR THE PREFERRED METHOD (Embedding expressions in text):
-- Start the string with just "=" (not "={{")
-- Place each expression inside {{ }} without the = prefix
-- MOST READABLE and RECOMMENDED approach
-- Example: "text": "=Status: {{ $('Node').item.json.status }} at {{ $('Node').item.json.time }}"
-
-### KEY RULES FOR THE ALTERNATIVE METHOD (String concatenation):
-- Only use when you need complex operations not possible with embedded expressions
-- Enclose the entire text in a single expression with "={{ }}"
-- Put all static text in quotes and connect with + operators
-- Example: "text": "={{ 'Status: ' + $('Node').item.json.status + ' at ' + $('Node').item.json.time }}"
-
-### EXAMPLES OF PREFERRED USAGE:
-
-1. Slack message (PREFERRED):
-\`\`\`json
-"text": "=ALERT: It is currently raining in {{ $('Weather Node').item.json.city }}! Temperature: {{ $('Weather Node').item.json.main.temp }}°C"
-\`\`\`
-
-2. Email subject (PREFERRED):
-\`\`\`json
-"subject": "=Order #{{ $('Order Node').item.json.orderId }} Status Update"
-\`\`\`
-
-3. Image prompt (PREFERRED):
-\`\`\`json
-"prompt": "=Create an image of {{ $('Location Node').item.json.city }} during {{ $('Weather Node').item.json.weather[0].description }}"
-\`\`\`
-
-4. Slack message with multiple data points (PREFERRED):
-\`\`\`json
-"text": "=Customer {{ $('Customer Data').item.json.name }} has placed order #{{ $('Order Data').item.json.id }} for {{ $('Order Data').item.json.amount }}€"
-\`\`\`
-
-5. HTTP request URL (PREFERRED):
-\`\`\`json
-"url": "=https://api.example.com/users/{{ $('User Data').item.json.id }}/orders?status={{ $('Filter').item.json.status }}"
-\`\`\`
-
-### COMMON MISTAKES TO AVOID:
-- INCORRECT: "text": "ALERT: Temperature is {{ $('Weather Node').item.json.temp }}°C" (missing = prefix)
-- INCORRECT: "text": "={{ $('Weather Node').item.json.temp }}" (using expression for dynamic part only)
-- INCORRECT: "text": "={{ $('⚠️ Weather').item.json.temp }}" (emoji in node name)
-- INCORRECT: "text": "={{ 'ALERT' }} {{ $('Weather').item.json.city }}" (mixing methods)
-
-## Output Format
-Return valid JSON that can be consumed by the n8n platform. Your response must match the tool's required schema.`);
-const humanTemplate = `
-<user_workflow_prompt>
-	{user_workflow_prompt}
-</user_workflow_prompt>
-<selected_n8n_nodes>
-	{nodes}
-</selected_n8n_nodes>
-`;
-exports.nodesComposerPrompt = prompts_1.ChatPromptTemplate.fromMessages([
-    systemPrompt,
-    prompts_1.HumanMessagePromptTemplate.fromTemplate(humanTemplate),
-]);
-const nodeConfigSchema = zod_1.z.object({
-    nodes: zod_1.z
-        .array(zod_1.z
-        .object({
-        parameters: zod_1.z
-            .record(zod_1.z.string(), zod_1.z.any())
-            .describe("The node's configuration parameters. Must include all required parameters for the node type to function properly. For expressions referencing other nodes, use the format: \"={{ $('Node Name').item.json.field }}\"")
-            .refine((data) => Object.keys(data).length > 0, {
-            message: 'Parameters cannot be empty',
-        }),
-        type: zod_1.z
-            .string()
-            .describe('The full node type identifier (e.g., "n8n-nodes-base.httpRequest")'),
-        name: zod_1.z
-            .string()
-            .describe('A descriptive name for the node that clearly indicates its purpose in the workflow'),
-    })
-        .describe('A complete n8n node configuration'))
-        .describe('Array of all nodes for the workflow with their complete configurations'),
-});
-const generateNodeConfigTool = new tools_1.DynamicStructuredTool({
-    name: 'generate_n8n_nodes',
-    description: 'Generate fully configured n8n nodes with appropriate parameters based on the workflow requirements and selected node types.',
-    schema: nodeConfigSchema,
-    func: async (input) => {
-        return { nodes: input.nodes };
-    },
-});
-const nodesComposerChain = (llm) => {
-    if (!llm.bindTools) {
-        throw new n8n_workflow_1.OperationalError("LLM doesn't support binding tools");
-    }
-    return exports.nodesComposerPrompt
-        .pipe(llm.bindTools([generateNodeConfigTool], {
-        tool_choice: generateNodeConfigTool.name,
-    }))
-        .pipe((x) => {
-        const toolCall = x.tool_calls?.[0];
-        return (toolCall?.args).nodes;
-    });
-};
-exports.nodesComposerChain = nodesComposerChain;
-//# sourceMappingURL=nodes-composer.js.map

package/dist/chains/nodes-composer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodes-composer.js","sourceRoot":"","sources":["../../src/chains/nodes-composer.ts"],"names":[],"mappings":";;;AAEA,uDAAyD;AACzD,qDAAyF;AACzF,iDAA8D;AAC9D,+CAAgD;AAChD,6BAAwB;AAIxB,MAAM,YAAY,GAAG,IAAI,wBAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iHAmY0E,CAAC,CAAC;AAEnH,MAAM,aAAa,GAAG;;;;;;;CAOrB,CAAC;AAEW,QAAA,mBAAmB,GAAG,4BAAkB,CAAC,YAAY,CAAC;IAClE,YAAY;IACZ,oCAA0B,CAAC,YAAY,CAAC,aAAa,CAAC;CACtD,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,OAAC,CAAC,MAAM,CAAC;IACjC,KAAK,EAAE,OAAC;SACN,KAAK,CACL,OAAC;SACC,MAAM,CAAC;QACP,UAAU,EAAE,OAAC;aACX,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,EAAE,OAAC,CAAC,GAAG,EAAE,CAAC;aAC3B,QAAQ,CACR,sNAAsN,CACtN;aACA,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/C,OAAO,EAAE,4BAA4B;SACrC,CAAC;QACH,IAAI,EAAE,OAAC;aACL,MAAM,EAAE;aACR,QAAQ,CAAC,oEAAoE,CAAC;QAChF,IAAI,EAAE,OAAC;aACL,MAAM,EAAE;aACR,QAAQ,CACR,oFAAoF,CACpF;KACF,CAAC;SACD,QAAQ,CAAC,mCAAmC,CAAC,CAC/C;SACA,QAAQ,CAAC,wEAAwE,CAAC;CACpF,CAAC,CAAC;AAEH,MAAM,sBAAsB,GAAG,IAAI,6BAAqB,CAAC;IACxD,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EACV,6HAA6H;IAC9H,MAAM,EAAE,gBAAgB;IACxB,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QACrB,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;CACD,CAAC,CAAC;AAEI,MAAM,kBAAkB,GAAG,CAAC,GAAkB,EAAE,EAAE;IACxD,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QACpB,MAAM,IAAI,+BAAgB,CAAC,mCAAmC,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,2BAAmB;SACxB,IAAI,CACJ,GAAG,CAAC,SAAS,CAAC,CAAC,sBAAsB,CAAC,EAAE;QACvC,WAAW,EAAE,sBAAsB,CAAC,IAAI;KACxC,CAAC,CACF;SACA,IAAI,CAAC,CAAC,CAAiB,EAAE,EAAE;QAC3B,MAAM,QAAQ,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;QACnC,OAAO,CAAC,QAAQ,EAAE,IAAyC,CAAA,CAAC,KAAK,CAAC;IACnE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAfW,QAAA,kBAAkB,sBAe7B"}

package/dist/chains/validator.d.ts

@@ -1,2 +0,0 @@
-import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-export declare const validatorChain: (llm: BaseChatModel) => import("@langchain/core/runnables").Runnable<any, boolean, import("@langchain/core/runnables").RunnableConfig<Record<string, any>>>;

package/dist/chains/validator.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatorChain = void 0;
-const messages_1 = require("@langchain/core/messages");
-const prompts_1 = require("@langchain/core/prompts");
-const tools_1 = require("@langchain/core/tools");
-const n8n_workflow_1 = require("n8n-workflow");
-const zod_1 = require("zod");
-const validatorPrompt = new messages_1.SystemMessage(`You are a workflow prompt validator for n8n. You need to analyze the user's prompt and determine
-if they're actually trying to build a workflow that connects different online services or automates a task.
-
-A workflow prompt should:
-- Describe an automation or integration task
-- Potentially mention connecting services (like Google Sheets, Slack, etc.)
-- Describe a process that could be broken down into steps
-- Mention something that could be automated
-
-Examples of VALID workflow prompts:
-- "Create a workflow that sends a Slack message when a new row is added to Google Sheets"
-- "I want to automatically save Gmail attachments to Dropbox"
-- "Build a workflow that posts new Twitter mentions to a Discord channel"
-- "When I get a new lead in my CRM, add them to my email marketing list"
-
-Examples of INVALID workflow prompts:
-- "What's the weather like today?"
-- "Tell me a joke"
-- "What is n8n?"
-- "Help me fix my computer"
-- "What time is it?"
-
-
-Analyze the prompt and determine if it's a valid workflow prompt. Respond with just true or false.`);
-const validatorSchema = zod_1.z.object({
-    isWorkflowPrompt: zod_1.z.boolean(),
-});
-const validatorTool = new tools_1.DynamicStructuredTool({
-    name: 'validate_prompt',
-    description: 'Validate if the user prompt is a workflow prompt',
-    schema: validatorSchema,
-    func: async ({ isWorkflowPrompt }) => {
-        return { isWorkflowPrompt };
-    },
-});
-const humanTemplate = `
-<user_prompt>
-	{prompt}
-</user_prompt>
-`;
-const chatPrompt = prompts_1.ChatPromptTemplate.fromMessages([
-    validatorPrompt,
-    prompts_1.HumanMessagePromptTemplate.fromTemplate(humanTemplate),
-]);
-const validatorChain = (llm) => {
-    if (!llm.bindTools) {
-        throw new n8n_workflow_1.OperationalError("LLM doesn't support binding tools");
-    }
-    return chatPrompt
-        .pipe(llm.bindTools([validatorTool], {
-        tool_choice: validatorTool.name,
-    }))
-        .pipe((x) => {
-        const toolCall = x.tool_calls?.[0];
-        return (toolCall?.args).isWorkflowPrompt;
-    });
-};
-exports.validatorChain = validatorChain;
-//# sourceMappingURL=validator.js.map

package/dist/chains/validator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../src/chains/validator.ts"],"names":[],"mappings":";;;AAEA,uDAAyD;AACzD,qDAAyF;AACzF,iDAA8D;AAC9D,+CAAgD;AAChD,6BAAwB;AAExB,MAAM,eAAe,GAAG,IAAI,wBAAa,CACxC;;;;;;;;;;;;;;;;;;;;;;;mGAuBkG,CAClG,CAAC;AAEF,MAAM,eAAe,GAAG,OAAC,CAAC,MAAM,CAAC;IAChC,gBAAgB,EAAE,OAAC,CAAC,OAAO,EAAE;CAC7B,CAAC,CAAC;AAEH,MAAM,aAAa,GAAG,IAAI,6BAAqB,CAAC;IAC/C,IAAI,EAAE,iBAAiB;IACvB,WAAW,EAAE,kDAAkD;IAC/D,MAAM,EAAE,eAAe;IACvB,IAAI,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE;QACpC,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC7B,CAAC;CACD,CAAC,CAAC;AAEH,MAAM,aAAa,GAAG;;;;CAIrB,CAAC;AAEF,MAAM,UAAU,GAAG,4BAAkB,CAAC,YAAY,CAAC;IAClD,eAAe;IACf,oCAA0B,CAAC,YAAY,CAAC,aAAa,CAAC;CACtD,CAAC,CAAC;AAEI,MAAM,cAAc,GAAG,CAAC,GAAkB,EAAE,EAAE;IACpD,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QACpB,MAAM,IAAI,+BAAgB,CAAC,mCAAmC,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,UAAU;SACf,IAAI,CACJ,GAAG,CAAC,SAAS,CAAC,CAAC,aAAa,CAAC,EAAE;QAC9B,WAAW,EAAE,aAAa,CAAC,IAAI;KAC/B,CAAC,CACF;SACA,IAAI,CAAC,CAAC,CAAiB,EAAE,EAAE;QAC3B,MAAM,QAAQ,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;QACnC,OAAO,CAAC,QAAQ,EAAE,IAA6C,CAAA,CAAC,gBAAgB,CAAC;IAClF,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAfW,QAAA,cAAc,kBAezB"}