@n8n/ai-workflow-builder 0.2.0

package/dist/chains/nodes-composer.js

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

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

@@ -0,0 +1,4 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { SystemMessage } from '@langchain/core/messages';
+export declare const plannerPrompt: SystemMessage;
+export declare const plannerChain: (llm: BaseChatModel) => import("@langchain/core/runnables").Runnable<any, string[], import("@langchain/core/runnables").RunnableConfig<Record<string, any>>>;

package/dist/chains/planner.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plannerChain = exports.plannerPrompt = 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.plannerPrompt = new messages_1.SystemMessage(`You are a Workflow Planner for n8n, a platform that helps users automate processes across different services and APIs.
+
+## Your Task
+Convert user requests into clear, sequential workflow steps that can be implemented with n8n nodes. ONLY include steps that are explicitly stated or directly implied in the user request.
+
+## Guidelines
+1. Analyze the user request to understand their end goal and required process
+2. Break down the automation into logical steps based on complexity - simpler workflows need fewer steps, complex ones may need more
+3. Focus ONLY on actions mentioned directly in the user prompt 
+4. Create steps that can be mapped to n8n nodes later
+5. Order steps sequentially from trigger to final action
+6. Be specific about data transformations needed ONLY if mentioned in the request
+7. NEVER add extra steps like storing data or sending notifications unless explicitly requested
+8. Only recommend raw HTTP requests if you think there isn't a suitable n8n node
+
+## CRITICAL REQUIREMENTS
+- DO NOT add any steps not directly mentioned or implied in the user request
+- DO NOT assume the user wants to store data in a database unless explicitly stated
+- DO NOT assume the user wants to send notifications or emails unless explicitly stated
+- DO NOT add any "nice to have" steps that aren't clearly part of the user's request
+- Keep the workflow EXACTLY focused on what was requested, nothing more
+
+## Output Format
+Return ONLY a JSON object with this structure:
+\`\`\`json
+{
+  "steps": [
+    "[Brief action-oriented description]",
+    "[Brief action-oriented description]",
+    ...
+  ]
+}
+\`\`\`
+
+## Examples of Good Step Descriptions
+- "Trigger when a new email arrives in Gmail inbox"
+- "Filter emails to only include those with attachments"
+- "Extract data from CSV attachments"
+- "Transform data to required format for the API"
+- "Send HTTP request to external API with extracted data"
+- "Post success message to Slack channel"
+
+IMPORTANT: Do not include HTML tags, markdown formatting, or explanations outside the JSON.`);
+const planSchema = zod_1.z.object({
+    steps: zod_1.z
+        .array(zod_1.z
+        .string()
+        .describe('A clear, action-oriented description of a single workflow step. Do not include "Step N" or similar, just the action'))
+        .min(1)
+        .describe('An ordered list of workflow steps that, when implemented, will fulfill the user request. Each step should be concise, action-oriented, and implementable with n8n nodes.'),
+});
+const generatePlanTool = new tools_1.DynamicStructuredTool({
+    name: 'generate_plan',
+    description: 'Convert a user workflow request into a logical sequence of clear, achievable steps that can be implemented with n8n nodes.',
+    schema: planSchema,
+    func: async (input) => {
+        return { steps: input.steps };
+    },
+});
+const humanTemplate = '{prompt}';
+const chatPrompt = prompts_1.ChatPromptTemplate.fromMessages([
+    exports.plannerPrompt,
+    prompts_1.HumanMessagePromptTemplate.fromTemplate(humanTemplate),
+]);
+const plannerChain = (llm) => {
+    if (!llm.bindTools) {
+        throw new n8n_workflow_1.OperationalError("LLM doesn't support binding tools");
+    }
+    return chatPrompt
+        .pipe(llm.bindTools([generatePlanTool], {
+        tool_choice: generatePlanTool.name,
+    }))
+        .pipe((x) => {
+        const toolCall = x.tool_calls?.[0];
+        return (toolCall?.args).steps;
+    });
+};
+exports.plannerChain = plannerChain;
+//# sourceMappingURL=planner.js.map

package/dist/chains/planner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/chains/planner.ts"],"names":[],"mappings":";;;AAEA,uDAAyD;AACzD,qDAAyF;AACzF,iDAA8D;AAC9D,+CAAgD;AAChD,6BAAwB;AAEX,QAAA,aAAa,GAAG,IAAI,wBAAa,CAC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4FA0C2F,CAC3F,CAAC;AAEF,MAAM,UAAU,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3B,KAAK,EAAE,OAAC;SACN,KAAK,CACL,OAAC;SACC,MAAM,EAAE;SACR,QAAQ,CACR,qHAAqH,CACrH,CACF;SACA,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,CACR,0KAA0K,CAC1K;CACF,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,IAAI,6BAAqB,CAAC;IAClD,IAAI,EAAE,eAAe;IACrB,WAAW,EACV,4HAA4H;IAC7H,MAAM,EAAE,UAAU;IAClB,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QACrB,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;CACD,CAAC,CAAC;AAEH,MAAM,aAAa,GAAG,UAAU,CAAC;AACjC,MAAM,UAAU,GAAG,4BAAkB,CAAC,YAAY,CAAC;IAClD,qBAAa;IACb,oCAA0B,CAAC,YAAY,CAAC,aAAa,CAAC;CACtD,CAAC,CAAC;AAEI,MAAM,YAAY,GAAG,CAAC,GAAkB,EAAE,EAAE;IAClD,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,IAAmC,CAAA,CAAC,KAAK,CAAC;IAC7D,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAfW,QAAA,YAAY,gBAevB"}

package/dist/chains/validator.d.ts

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

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

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ai-workflow-builder.service';
+export * from './types';
+export * from './workflow-state';
+export * from './interfaces';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ai-workflow-builder.service"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./workflow-state"), exports);
+__exportStar(require("./interfaces"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gEAA8C;AAC9C,0CAAwB;AACxB,mDAAiC;AACjC,+CAA6B"}

package/dist/interfaces.d.ts

@@ -0,0 +1,4 @@
+export interface ILicenseService {
+    loadCertStr(): Promise<string>;
+    getConsumerId(): string;
+}

package/dist/interfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interfaces.js.map

package/dist/interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":""}