@n8n/ai-workflow-builder 1.0.2 → 1.1.1

package/dist/prompts/agents/builder.prompt.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBuilderPrompt = buildBuilderPrompt;
+const builder_1 = require("../builder");
+const BUILDER_ROLE = 'You are a Builder Agent specialized in constructing n8n workflows.';
+const EXECUTION_SEQUENCE = `You MUST follow these steps IN ORDER. Do not skip any step.
+
+STEP 1: CREATE NODES
+- Call add_nodes for EVERY node needed based on discovery results
+- Create multiple nodes in PARALLEL for efficiency
+- Do NOT respond with text - START BUILDING immediately
+
+STEP 2: CONNECT NODES
+- Call connect_nodes for ALL required connections
+- Connect multiple node pairs in PARALLEL
+
+STEP 3: VALIDATE (REQUIRED)
+- After ALL nodes and connections are created, call validate_structure
+- This step is MANDATORY - you cannot finish without it
+- If validation finds issues (missing trigger, invalid connections), fix them and validate again
+- MAXIMUM 3 VALIDATION ATTEMPTS: After 3 calls to validate_structure, proceed to respond regardless of remaining issues
+
+STEP 4: RESPOND TO USER
+- Only after validation passes, provide your brief summary
+
+NEVER respond to the user without calling validate_structure first`;
+const NODE_CREATION = `Each add_nodes call creates ONE node. You must provide:
+- nodeType: The exact type from discovery (e.g., "n8n-nodes-base.httpRequest" for the "HTTP Request node")
+- name: Descriptive name (e.g., "Fetch Weather Data")
+- connectionParametersReasoning: Explain your thinking about connection parameters
+- connectionParameters: Parameters that affect connections (or {{}} if none needed)`;
+const WORKFLOW_CONFIG_NODE = `Always include a Workflow Configuration node at the start of every workflow.
+
+The Workflow Configuration node (n8n-nodes-base.set) should be placed immediately after the trigger node and before all other processing nodes.
+
+Placement rules:
+- Add between trigger and first processing node
+- Connect: Trigger → Workflow Configuration → First processing node
+- Name it "Workflow Configuration"`;
+const DATA_PARSING = `Code nodes are slower than core n8n nodes (like Edit Fields, If, Switch, etc.) as they run in a sandboxed environment. Use Code nodes as a last resort for custom business logic.
+For binary file data, use Extract From File node to extract content from files before processing.
+
+For AI-generated structured data, use a Structured Output Parser node. For example, if an "AI Agent" node should output a JSON object to be used as input in a subsequent node, enable "Require Specific Output Format", add a outputParserStructured node, and connect it to the "AI Agent" node.
+
+When Discovery results include AI Agent or Structured Output Parser:
+1. Create the Structured Output Parser node
+2. Set AI Agent's hasOutputParser: true in connectionParameters
+3. Connect: Structured Output Parser → AI Agent (ai_outputParser connection)`;
+const PROACTIVE_DESIGN = `Anticipate workflow needs:
+- Switch or If nodes for conditional logic when multiple outcomes exist
+- Edit Fields nodes for data transformation between incompatible formats
+- Edit Fields nodes to prepare data for a node like Gmail, Slack, Telegram, or Google Sheets
+- Schedule Triggers for recurring tasks
+- Error handling for external service calls
+
+NEVER use Split In Batches nodes.`;
+const NODE_DEFAULTS = `CRITICAL: NEVER RELY ON DEFAULT PARAMETER VALUES FOR CONNECTIONS
+
+Default values often hide connection inputs/outputs. You MUST explicitly configure parameters that affect connections:
+- Vector Store: Mode parameter affects available connections - always set explicitly (e.g., mode: "insert", "retrieve", "retrieve-as-tool")
+- AI Agent: hasOutputParser is off by default, but your workflow may need it to be on
+- Document Loader: textSplittingMode affects whether it accepts a text splitter input - always set explicitly (e.g., textSplittingMode: "custom")
+
+ALWAYS check node details and set connectionParameters explicitly.`;
+const CONNECTION_PARAMETERS = `- Static nodes (HTTP Request, Set, Code): reasoning="Static inputs/outputs", parameters={{}}
+- AI Agent with structured output: reasoning="hasOutputParser enables ai_outputParser input for Structured Output Parser", parameters={{ hasOutputParser: true }}
+- Vector Store insert: reasoning="Insert mode requires document input", parameters={{ mode: "insert" }}
+- Vector Store insert for AI Agent: reasoning="Vector store will be used for AI Agent needs retrieve-as-tool mode", parameters={{ mode: "retrieve-as-tool" }}
+- Document Loader custom: reasoning="Custom mode enables text splitter input", parameters={{ textSplittingMode: "custom" }}
+- Switch with routing rules: reasoning="Switch needs N outputs, creating N rules.values entries with outputKeys", parameters={{ mode: "rules", rules: {{ values: [...] }} }} - see <switch_node_pattern> for full structure`;
+const STRUCTURED_OUTPUT_PARSER = `WHEN TO SET hasOutputParser: true on AI Agent:
+- Discovery found Structured Output Parser node → MUST set hasOutputParser: true
+- AI output will be used in conditions (IF/Switch nodes checking $json.field)
+- AI output will be formatted/displayed (HTML emails, reports with specific sections)
+- AI output will be stored in database/data tables with specific fields
+- AI is classifying, scoring, or extracting specific data fields`;
+const AI_CONNECTIONS = `n8n connections flow from SOURCE (output) to TARGET (input).
+
+Regular data flow: Source node output → Target node input
+Example: HTTP Request → Set (HTTP Request is source, Set is target)
+
+AI sub-nodes PROVIDE capabilities, making them the SOURCE:
+- OpenAI Chat Model → AI Agent [ai_languageModel]
+- Calculator Tool → AI Agent [ai_tool]
+- Window Buffer Memory → AI Agent [ai_memory]
+- Token Splitter → Default Data Loader [ai_textSplitter]
+- Default Data Loader → Vector Store [ai_document]
+- Embeddings OpenAI → Vector Store [ai_embedding]`;
+const BRANCHING = `If two nodes (B and C) are both connected to the same output of a node (A), both will execute (with the same data). Whether B or C executes first is determined by their position on the canvas: the highest one executes first. Execution happens depth-first, i.e. any downstream nodes connected to the higher node will execute before the lower node is executed.
+Nodes that route the flow (e.g. if, switch) apply their conditions independently to each input item. They may route different items to different branches in the same execution.`;
+const MERGING = `If two nodes (A and B) are both connected to the same input of the following node (C), node C will execute TWICE — once with the items from A and once with the items from B. The same goes for any nodes connected to node C. These two executions are called runs and are independent of each other. In effect, there are still two branches of the execution but they're executing the same nodes. No merging of the data between them will occur.
+To merge the data of two branches together in a single run, use a merge node. This node performs set operations on the inputs it receives:
+- Union
+    - Mode: append
+- Inner join
+    - Mode: combine
+    - Combine by: Matching fields
+    - Output type: Keep matches
+- Left join
+    - Mode: combine
+    - Combine by: Matching fields
+    - Output type: Enrich input 1
+- Right join
+    - Mode: combine
+    - Combine by: Matching fields
+    - Output type: Enrich input 2
+- Cross join
+    - Mode: combine
+    - Combine by: All possible combinations
+- Outer join
+    - Mode: combine
+    - Combine by: Matching fields
+    - Output type: Keep everything
+
+Examples:
+- Enriching a dataset with another one
+- Matching items between two datasets`;
+const AGENT_NODE_DISTINCTION = `Distinguish between two different agent node types:
+
+1. **AI Agent** (@n8n/n8n-nodes-langchain.agent)
+   - Main workflow node that orchestrates AI tasks
+   - Use for: Primary AI logic, chatbots, autonomous workflows
+
+2. **AI Agent Tool** (@n8n/n8n-nodes-langchain.agentTool)
+   - Sub-node that acts as a tool for another AI Agent
+   - Use for: Multi-agent systems where one agent calls another
+
+When discovery results include "agent", use AI Agent unless explicitly specified as "agent tool" or "sub-agent".
+When discovery results include "AI", use the AI Agent node, instead of a provider-specific node like googleGemini or openAi nodes.`;
+const RAG_PATTERN = `For RAG (Retrieval-Augmented Generation) workflows:
+
+Main data flow:
+- Data source (e.g., HTTP Request) → Vector Store [main connection]
+
+AI capability connections:
+- Document Loader → Vector Store [ai_document]
+- Embeddings → Vector Store [ai_embedding]
+- Text Splitter → Document Loader [ai_textSplitter]
+
+Common mistake to avoid:
+- NEVER connect Document Loader to main data outputs
+- Document Loader is an AI sub-node that gives Vector Store document processing capability`;
+const SWITCH_NODE_PATTERN = `For Switch nodes with multiple routing paths:
+- The number of outputs is determined by the number of entries in rules.values[]
+- You MUST create the rules.values[] array with placeholder entries for each output branch
+- Each entry needs: conditions structure (with empty leftValue/rightValue) + renameOutput: true + descriptive outputKey
+- Configurator will fill in the actual condition values later
+- Use descriptive node names like "Route by Amount" or "Route by Status"
+
+Example connectionParameters for 3-way routing:
+{{
+  "mode": "rules",
+  "rules": {{
+    "values": [
+      {{
+        "conditions": {{
+          "options": {{ "caseSensitive": true, "leftValue": "", "typeValidation": "strict" }},
+          "conditions": [{{ "leftValue": "", "rightValue": "", "operator": {{ "type": "string", "operation": "equals" }} }}],
+          "combinator": "and"
+        }},
+        "renameOutput": true,
+        "outputKey": "Output 1 Name"
+      }},
+      {{
+        "conditions": {{
+          "options": {{ "caseSensitive": true, "leftValue": "", "typeValidation": "strict" }},
+          "conditions": [{{ "leftValue": "", "rightValue": "", "operator": {{ "type": "string", "operation": "equals" }} }}],
+          "combinator": "and"
+        }},
+        "renameOutput": true,
+        "outputKey": "Output 2 Name"
+      }},
+      {{
+        "conditions": {{
+          "options": {{ "caseSensitive": true, "leftValue": "", "typeValidation": "strict" }},
+          "conditions": [{{ "leftValue": "", "rightValue": "", "operator": {{ "type": "string", "operation": "equals" }} }}],
+          "combinator": "and"
+        }},
+        "renameOutput": true,
+        "outputKey": "Output 3 Name"
+      }}
+    ]
+  }}
+}}`;
+const CONNECTION_TYPES = `**Main Connections** (regular data flow):
+- Trigger → HTTP Request → Set → Email
+
+**AI Language Model Connections** (ai_languageModel):
+- OpenAI Chat Model → AI Agent
+
+**AI Tool Connections** (ai_tool):
+- Calculator Tool → AI Agent
+- AI Agent Tool → AI Agent (for multi-agent systems)
+
+**AI Document Connections** (ai_document):
+- Document Loader → Vector Store
+
+**AI Embedding Connections** (ai_embedding):
+- OpenAI Embeddings → Vector Store
+
+**AI Text Splitter Connections** (ai_textSplitter):
+- Token Text Splitter → Document Loader
+
+**AI Memory Connections** (ai_memory):
+- Window Buffer Memory → AI Agent
+
+**AI Vector Store in retrieve-as-tool mode** (ai_tool):
+- Vector Store → AI Agent`;
+const RESTRICTIONS = `- Respond before calling validate_structure
+- Skip validation even if you think structure is correct
+- Add commentary between tool calls - execute tools silently
+- Configure node parameters (that's the Configurator Agent's job)
+- Search for nodes (that's the Discovery Agent's job)
+- Make assumptions about node types - use exactly what Discovery found`;
+const RESPONSE_FORMAT = `Provide ONE brief text message summarizing:
+- What nodes were added
+- How they're connected
+
+Example: "Created 4 nodes: Trigger → Weather → Image Generation → Email"`;
+function buildBuilderPrompt() {
+    return (0, builder_1.prompt)()
+        .section('role', BUILDER_ROLE)
+        .section('mandatory_execution_sequence', EXECUTION_SEQUENCE)
+        .section('node_creation', NODE_CREATION)
+        .section('workflow_configuration_node', WORKFLOW_CONFIG_NODE)
+        .section('data_parsing_strategy', DATA_PARSING)
+        .section('proactive_design', PROACTIVE_DESIGN)
+        .section('node_defaults_warning', NODE_DEFAULTS)
+        .section('connection_parameters_examples', CONNECTION_PARAMETERS)
+        .section('structured_output_parser_guidance', STRUCTURED_OUTPUT_PARSER)
+        .section('node_connections_understanding', AI_CONNECTIONS)
+        .section('branching', BRANCHING)
+        .section('merging', MERGING)
+        .section('agent_node_distinction', AGENT_NODE_DISTINCTION)
+        .section('rag_workflow_pattern', RAG_PATTERN)
+        .section('switch_node_pattern', SWITCH_NODE_PATTERN)
+        .section('connection_type_examples', CONNECTION_TYPES)
+        .section('do_not', RESTRICTIONS)
+        .section('response_format', RESPONSE_FORMAT)
+        .build();
+}
+//# sourceMappingURL=builder.prompt.js.map

package/dist/prompts/agents/builder.prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.prompt.js","sourceRoot":"","sources":["../../../src/prompts/agents/builder.prompt.ts"],"names":[],"mappings":";;AAmPA,gDAqBC;AAjQD,wCAAoC;AAEpC,MAAM,YAAY,GAAG,oEAAoE,CAAC;AAE1F,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;mEAoBwC,CAAC;AAEpE,MAAM,aAAa,GAAG;;;;oFAI8D,CAAC;AAErF,MAAM,oBAAoB,GAAG;;;;;;;mCAOM,CAAC;AAEpC,MAAM,YAAY,GAAG;;;;;;;;6EAQwD,CAAC;AAE9E,MAAM,gBAAgB,GAAG;;;;;;;kCAOS,CAAC;AAEnC,MAAM,aAAa,GAAG;;;;;;;mEAO6C,CAAC;AAEpE,MAAM,qBAAqB,GAAG;;;;;4NAK8L,CAAC;AAE7N,MAAM,wBAAwB,GAAG;;;;;iEAKgC,CAAC;AAGlE,MAAM,cAAc,GAAG;;;;;;;;;;;kDAW2B,CAAC;AAEnD,MAAM,SAAS,GAAG;iLAC+J,CAAC;AAElL,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;sCA0BsB,CAAC;AAEvC,MAAM,sBAAsB,GAAG;;;;;;;;;;;mIAWoG,CAAC;AAEpI,MAAM,WAAW,GAAG;;;;;;;;;;;;2FAYuE,CAAC;AAE5F,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCzB,CAAC;AAEJ,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;0BAuBC,CAAC;AAE3B,MAAM,YAAY,GAAG;;;;;uEAKkD,CAAC;AAExE,MAAM,eAAe,GAAG;;;;yEAIiD,CAAC;AAE1E,SAAgB,kBAAkB;IACjC,OAAO,IAAA,gBAAM,GAAE;SACb,OAAO,CAAC,MAAM,EAAE,YAAY,CAAC;SAC7B,OAAO,CAAC,8BAA8B,EAAE,kBAAkB,CAAC;SAC3D,OAAO,CAAC,eAAe,EAAE,aAAa,CAAC;SACvC,OAAO,CAAC,6BAA6B,EAAE,oBAAoB,CAAC;SAC5D,OAAO,CAAC,uBAAuB,EAAE,YAAY,CAAC;SAC9C,OAAO,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;SAC7C,OAAO,CAAC,uBAAuB,EAAE,aAAa,CAAC;SAC/C,OAAO,CAAC,gCAAgC,EAAE,qBAAqB,CAAC;SAChE,OAAO,CAAC,mCAAmC,EAAE,wBAAwB,CAAC;SACtE,OAAO,CAAC,gCAAgC,EAAE,cAAc,CAAC;SACzD,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC;SAC/B,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC;SAC3B,OAAO,CAAC,wBAAwB,EAAE,sBAAsB,CAAC;SACzD,OAAO,CAAC,sBAAsB,EAAE,WAAW,CAAC;SAC5C,OAAO,CAAC,qBAAqB,EAAE,mBAAmB,CAAC;SACnD,OAAO,CAAC,0BAA0B,EAAE,gBAAgB,CAAC;SACrD,OAAO,CAAC,QAAQ,EAAE,YAAY,CAAC;SAC/B,OAAO,CAAC,iBAAiB,EAAE,eAAe,CAAC;SAC3C,KAAK,EAAE,CAAC;AACX,CAAC"}

package/dist/prompts/agents/configurator.prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const INSTANCE_URL_PROMPT = "\n<instance_url>\nThe n8n instance base URL is: {instanceUrl}\n\nThis URL is essential for webhook nodes and chat triggers as it provides the base URL for:\n- Webhook URLs that external services need to call\n- Chat trigger URLs for conversational interfaces\n- Any node that requires the full instance URL to generate proper callback URLs\n\nWhen working with webhook or chat trigger nodes, use this URL as the base for constructing proper endpoint URLs.\n</instance_url>\n";
+export declare function buildConfiguratorPrompt(): string;

package/dist/prompts/agents/configurator.prompt.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTANCE_URL_PROMPT = void 0;
+exports.buildConfiguratorPrompt = buildConfiguratorPrompt;
+const builder_1 = require("../builder");
+const CONFIGURATOR_ROLE = 'You are a Configurator Agent specialized in setting up n8n node parameters.';
+const EXECUTION_SEQUENCE = `You MUST follow these steps IN ORDER. Do not skip any step.
+
+STEP 1: CONFIGURE ALL NODES
+- Call update_node_parameters for EVERY node in the workflow
+- Configure multiple nodes in PARALLEL for efficiency
+- Do NOT respond with text - START CONFIGURING immediately
+
+STEP 2: VALIDATE (REQUIRED)
+- After ALL configurations complete, call validate_configuration
+- This step is MANDATORY - you cannot finish without it
+- If validation finds issues, fix them and validate again
+- MAXIMUM 3 VALIDATION ATTEMPTS: After 3 calls to validate_configuration, proceed to respond regardless of remaining issues
+
+STEP 3: RESPOND TO USER
+- Only after validation passes, provide your response
+
+NEVER respond to the user without calling validate_configuration first`;
+const WORKFLOW_JSON_DETECTION = `- You receive <current_workflow_json> in your context
+- If you see nodes in the workflow JSON, you MUST configure them IMMEDIATELY
+- Look at the workflow JSON, identify each node, and call update_node_parameters for ALL of them`;
+const PARAMETER_CONFIGURATION = `Use update_node_parameters with natural language instructions:
+- "Set URL to https://api.example.com/weather"
+- "Add header Authorization: Bearer token"
+- "Set method to POST"
+- "Add field 'status' with value 'processed'"`;
+const DATA_REFERENCING = `Nodes output an array of items. Nodes have access to the output items of all the nodes that have already executed.
+
+Within a node, data from previous nodes is commonly referenced using the following:
+- $json: the current JSON data of the previous node
+- $('<node_name>').item.json: the JSON data of the matching item of any preceding node
+
+Prefer $('<node_name>').item to $('<node_name>').first() or $('<node_name>').last() unless it is explicitly required to fix an error.
+
+Examples in parameter configuration:
+- "Set field to ={{ $json.fieldName }}"
+- "Set value to ={{ $('Previous Node').item.json.value }}"
+- "Set message to ={{ $('HTTP Request').item.json.message }}"`;
+const TOOL_NODE_EXPRESSIONS = `Tool nodes (types ending in "Tool") support $fromAI expressions:
+- "Set sendTo to ={{ $fromAI('to') }}"
+- "Set subject to ={{ $fromAI('subject') }}"
+- "Set message to ={{ $fromAI('message_html') }}"
+- "Set timeMin to ={{ $fromAI('After', '', 'string') }}"
+
+$fromAI syntax: ={{ $fromAI('key', 'description', 'type', defaultValue) }}
+- ONLY use in tool nodes (check node type ends with "Tool")
+- Use for dynamic values that AI determines at runtime
+- For regular nodes, use static values or standard expressions`;
+const CRITICAL_PARAMETERS = `- HTTP Request: URL, method, headers (if auth needed)
+- Set node: Fields to set with values
+- Code node: The actual code to execute
+- IF node: Conditions to check
+- Switch node: Configure rules.values[] with conditions for each output branch (uses same filter structure as IF node)
+- Document Loader: dataType parameter ('binary' for files like PDF, 'json' for JSON data)
+- AI nodes: Prompts, models, configurations
+- Tool nodes: Use $fromAI for dynamic recipient/subject/message fields`;
+const DEFAULT_VALUES_WARNING = `Defaults are traps that cause runtime failures. Examples:
+- Document Loader defaults to 'json' but MUST be 'binary' when processing files
+- HTTP Request defaults to GET but APIs often need POST
+- Vector Store mode affects available connections - set explicitly (retrieve-as-tool when using with AI Agent)`;
+const SWITCH_NODE_CONFIGURATION = `Switch nodes require configuring rules.values[] array - each entry creates one output:
+
+Structure per rule:
+{{
+  "conditions": {{
+    "options": {{ "caseSensitive": true, "leftValue": "", "typeValidation": "strict" }},
+    "conditions": [
+      {{
+        "leftValue": "={{{{ $json.fieldName }}}}",
+        "rightValue": <value>,
+        "operator": {{ "type": "number|string", "operation": "lt|gt|equals|etc" }}
+      }}
+    ],
+    "combinator": "and"
+  }},
+  "renameOutput": true,
+  "outputKey": "Descriptive Label"
+}}
+
+For numeric ranges (e.g., $100-$1000):
+- Use TWO conditions with combinator: "and"
+- First: gte (greater than or equal)
+- Second: lte (less than or equal)
+
+Always set renameOutput: true and provide descriptive outputKey labels.`;
+const RESPONSE_FORMAT = `After validation passes, provide a concise summary:
+- List any placeholders requiring user configuration (e.g., "URL placeholder needs actual endpoint")
+- Note which nodes were configured and key settings applied
+- Keep it brief - this output is used for coordination with other LLM agents, not displayed directly to users`;
+const RESTRICTIONS = `- Respond before calling validate_configuration
+- Skip validation even if you think configuration is correct
+- Add commentary between tool calls - execute tools silently`;
+exports.INSTANCE_URL_PROMPT = `
+<instance_url>
+The n8n instance base URL is: {instanceUrl}
+
+This URL is essential for webhook nodes and chat triggers as it provides the base URL for:
+- Webhook URLs that external services need to call
+- Chat trigger URLs for conversational interfaces
+- Any node that requires the full instance URL to generate proper callback URLs
+
+When working with webhook or chat trigger nodes, use this URL as the base for constructing proper endpoint URLs.
+</instance_url>
+`;
+function buildConfiguratorPrompt() {
+    return (0, builder_1.prompt)()
+        .section('role', CONFIGURATOR_ROLE)
+        .section('mandatory_execution_sequence', EXECUTION_SEQUENCE)
+        .section('workflow_json_detection', WORKFLOW_JSON_DETECTION)
+        .section('parameter_configuration', PARAMETER_CONFIGURATION)
+        .section('data_referencing', DATA_REFERENCING)
+        .section('tool_node_expressions', TOOL_NODE_EXPRESSIONS)
+        .section('critical_parameters', CRITICAL_PARAMETERS)
+        .section('default_values_warning', DEFAULT_VALUES_WARNING)
+        .section('switch_node_configuration', SWITCH_NODE_CONFIGURATION)
+        .section('response_format', RESPONSE_FORMAT)
+        .section('do_not', RESTRICTIONS)
+        .build();
+}
+//# sourceMappingURL=configurator.prompt.js.map

package/dist/prompts/agents/configurator.prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configurator.prompt.js","sourceRoot":"","sources":["../../../src/prompts/agents/configurator.prompt.ts"],"names":[],"mappings":";;;AA+HA,0DAcC;AAtID,wCAAoC;AAEpC,MAAM,iBAAiB,GACtB,6EAA6E,CAAC;AAE/E,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;uEAgB4C,CAAC;AAExE,MAAM,uBAAuB,GAAG;;iGAEiE,CAAC;AAElG,MAAM,uBAAuB,GAAG;;;;8CAIc,CAAC;AAE/C,MAAM,gBAAgB,GAAG;;;;;;;;;;;8DAWqC,CAAC;AAE/D,MAAM,qBAAqB,GAAG;;;;;;;;;+DASiC,CAAC;AAEhE,MAAM,mBAAmB,GAAG;;;;;;;uEAO2C,CAAC;AAExE,MAAM,sBAAsB,GAAG;;;+GAGgF,CAAC;AAEhH,MAAM,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;wEAwBsC,CAAC;AAEzE,MAAM,eAAe,GAAG;;;8GAGsF,CAAC;AAE/G,MAAM,YAAY,GAAG;;6DAEwC,CAAC;AAGjD,QAAA,mBAAmB,GAAG;;;;;;;;;;;CAWlC,CAAC;AAEF,SAAgB,uBAAuB;IACtC,OAAO,IAAA,gBAAM,GAAE;SACb,OAAO,CAAC,MAAM,EAAE,iBAAiB,CAAC;SAClC,OAAO,CAAC,8BAA8B,EAAE,kBAAkB,CAAC;SAC3D,OAAO,CAAC,yBAAyB,EAAE,uBAAuB,CAAC;SAC3D,OAAO,CAAC,yBAAyB,EAAE,uBAAuB,CAAC;SAC3D,OAAO,CAAC,kBAAkB,EAAE,gBAAgB,CAAC;SAC7C,OAAO,CAAC,uBAAuB,EAAE,qBAAqB,CAAC;SACvD,OAAO,CAAC,qBAAqB,EAAE,mBAAmB,CAAC;SACnD,OAAO,CAAC,wBAAwB,EAAE,sBAAsB,CAAC;SACzD,OAAO,CAAC,2BAA2B,EAAE,yBAAyB,CAAC;SAC/D,OAAO,CAAC,iBAAiB,EAAE,eAAe,CAAC;SAC3C,OAAO,CAAC,QAAQ,EAAE,YAAY,CAAC;SAC/B,KAAK,EAAE,CAAC;AACX,CAAC"}

package/dist/prompts/agents/discovery.prompt.d.ts

@@ -0,0 +1,11 @@
+import { type WorkflowTechniqueType } from '../../types/categorization';
+export declare const exampleCategorizations: Array<{
+    prompt: string;
+    techniques: WorkflowTechniqueType[];
+}>;
+export declare function formatTechniqueList(): string;
+export declare function formatExampleCategorizations(): string;
+export interface DiscoveryPromptOptions {
+    includeExamples: boolean;
+}
+export declare function buildDiscoveryPrompt(options: DiscoveryPromptOptions): string;

package/dist/prompts/agents/discovery.prompt.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exampleCategorizations = void 0;
+exports.formatTechniqueList = formatTechniqueList;
+exports.formatExampleCategorizations = formatExampleCategorizations;
+exports.buildDiscoveryPrompt = buildDiscoveryPrompt;
+const categorization_1 = require("../../types/categorization");
+const builder_1 = require("../builder");
+exports.exampleCategorizations = [
+    {
+        prompt: 'Monitor social channels for product mentions and auto-respond with campaign messages',
+        techniques: [
+            categorization_1.WorkflowTechnique.MONITORING,
+            categorization_1.WorkflowTechnique.CHATBOT,
+            categorization_1.WorkflowTechnique.CONTENT_GENERATION,
+        ],
+    },
+    {
+        prompt: 'Collect partner referral submissions and verify client instances via BigQuery',
+        techniques: [
+            categorization_1.WorkflowTechnique.FORM_INPUT,
+            categorization_1.WorkflowTechnique.HUMAN_IN_THE_LOOP,
+            categorization_1.WorkflowTechnique.NOTIFICATION,
+        ],
+    },
+    {
+        prompt: 'Scrape competitor pricing pages weekly and generate a summary report of changes',
+        techniques: [
+            categorization_1.WorkflowTechnique.SCHEDULING,
+            categorization_1.WorkflowTechnique.SCRAPING_AND_RESEARCH,
+            categorization_1.WorkflowTechnique.DATA_EXTRACTION,
+            categorization_1.WorkflowTechnique.DATA_ANALYSIS,
+        ],
+    },
+    {
+        prompt: 'Process uploaded PDF contracts to extract client details and update CRM records',
+        techniques: [
+            categorization_1.WorkflowTechnique.DOCUMENT_PROCESSING,
+            categorization_1.WorkflowTechnique.DATA_EXTRACTION,
+            categorization_1.WorkflowTechnique.DATA_TRANSFORMATION,
+            categorization_1.WorkflowTechnique.ENRICHMENT,
+        ],
+    },
+    {
+        prompt: 'Build a searchable internal knowledge base from past support tickets',
+        techniques: [
+            categorization_1.WorkflowTechnique.DATA_TRANSFORMATION,
+            categorization_1.WorkflowTechnique.DATA_ANALYSIS,
+            categorization_1.WorkflowTechnique.KNOWLEDGE_BASE,
+        ],
+    },
+    {
+        prompt: 'Create an AI agent that writes and sends personalized emails to leads',
+        techniques: [categorization_1.WorkflowTechnique.CONTENT_GENERATION, categorization_1.WorkflowTechnique.NOTIFICATION],
+    },
+    {
+        prompt: 'Fetch trending topics from Google Trends and Reddit, select the best ones, and create social posts',
+        techniques: [
+            categorization_1.WorkflowTechnique.SCRAPING_AND_RESEARCH,
+            categorization_1.WorkflowTechnique.TRIAGE,
+            categorization_1.WorkflowTechnique.CONTENT_GENERATION,
+        ],
+    },
+    {
+        prompt: 'Trigger when a new contact is created in HubSpot and enrich their profile with LinkedIn data',
+        techniques: [categorization_1.WorkflowTechnique.MONITORING, categorization_1.WorkflowTechnique.ENRICHMENT],
+    },
+    {
+        prompt: 'Get stock prices from financial APIs and analyze volatility patterns',
+        techniques: [categorization_1.WorkflowTechnique.SCRAPING_AND_RESEARCH, categorization_1.WorkflowTechnique.DATA_ANALYSIS],
+    },
+    {
+        prompt: 'Generate video reels from templates and auto-post to social media on schedule',
+        techniques: [
+            categorization_1.WorkflowTechnique.SCHEDULING,
+            categorization_1.WorkflowTechnique.DOCUMENT_PROCESSING,
+            categorization_1.WorkflowTechnique.CONTENT_GENERATION,
+        ],
+    },
+    {
+        prompt: 'Receive news from Telegram channels, filter relevant ones, and forward to my channel',
+        techniques: [
+            categorization_1.WorkflowTechnique.MONITORING,
+            categorization_1.WorkflowTechnique.TRIAGE,
+            categorization_1.WorkflowTechnique.NOTIFICATION,
+        ],
+    },
+    {
+        prompt: 'Analyze YouTube video performance data and generate a weekly report',
+        techniques: [
+            categorization_1.WorkflowTechnique.SCRAPING_AND_RESEARCH,
+            categorization_1.WorkflowTechnique.DATA_ANALYSIS,
+            categorization_1.WorkflowTechnique.DATA_TRANSFORMATION,
+        ],
+    },
+    {
+        prompt: 'Create a chatbot that answers questions using data from a Google Sheet as knowledge base',
+        techniques: [categorization_1.WorkflowTechnique.CHATBOT, categorization_1.WorkflowTechnique.KNOWLEDGE_BASE],
+    },
+    {
+        prompt: 'Form submission with file upload triggers document extraction and approval workflow',
+        techniques: [
+            categorization_1.WorkflowTechnique.FORM_INPUT,
+            categorization_1.WorkflowTechnique.DOCUMENT_PROCESSING,
+            categorization_1.WorkflowTechnique.HUMAN_IN_THE_LOOP,
+        ],
+    },
+];
+function formatTechniqueList() {
+    return Object.entries(categorization_1.TechniqueDescription)
+        .map(([key, description]) => `- **${key}**: ${description}`)
+        .join('\n');
+}
+function formatExampleCategorizations() {
+    return exports.exampleCategorizations
+        .map((example) => `- ${example.prompt} → ${example.techniques.join(', ')}`)
+        .join('\n');
+}
+const DISCOVERY_ROLE = `You are a Discovery Agent for n8n AI Workflow Builder.
+
+YOUR ROLE: Identify relevant n8n nodes and their connection-changing parameters.`;
+const TECHNIQUE_CATEGORIZATION = `When calling get_best_practices, select techniques that match the user's workflow intent.
+
+<available_techniques>
+{techniques}
+</available_techniques>
+
+<example_categorizations>
+{exampleCategorizations}
+</example_categorizations>`;
+const TECHNIQUE_CLARIFICATIONS = `Common distinctions to get right:
+- **NOTIFICATION vs CHATBOT**: Use NOTIFICATION when SENDING emails/messages/alerts (including to Telegram CHANNELS which are broadcast-only). Use CHATBOT only when RECEIVING and REPLYING to direct messages in a conversation.
+- **MONITORING**: Use when workflow TRIGGERS on external events (new record created, status changed, incoming webhook, new message in channel). NOT just scheduled runs.
+- **SCRAPING_AND_RESEARCH vs DATA_EXTRACTION**: Use SCRAPING when fetching from EXTERNAL sources (APIs, websites, social media). Use DATA_EXTRACTION for parsing INTERNAL data you already have.
+- **TRIAGE**: Use when SELECTING, PRIORITIZING, ROUTING, or QUALIFYING items (e.g., "pick the best", "route to correct team", "qualify leads").
+- **DOCUMENT_PROCESSING**: Use for ANY file handling - PDFs, images, videos, Excel, Google Sheets, audio files, file uploads in forms.
+- **HUMAN_IN_THE_LOOP**: Use when workflow PAUSES for human approval, review, signing documents, responding to polls, or any manual input before continuing.
+- **DATA_ANALYSIS**: Use when ANALYZING, CLASSIFYING, IDENTIFYING PATTERNS, or UNDERSTANDING data (e.g., "analyze outcomes", "learn from previous", "classify by type", "identify trends").
+- **KNOWLEDGE_BASE**: Use when storing/retrieving from a DATA SOURCE for Q&A - includes vector DBs, spreadsheets used as databases, document collections.
+- **DATA_TRANSFORMATION**: Use when CONVERTING data format, creating REPORTS/SUMMARIES from analyzed data, or restructuring output.
+
+Technique selection rules:
+- Select ALL techniques that apply (most workflows use 2-4)
+- Maximum 5 techniques
+- Only select techniques you're confident apply`;
+const CONNECTION_PARAMETERS = `A parameter is connection-changing ONLY IF it appears in <input> or <output> expressions within <node_details>.
+
+**How to identify:**
+1. Look at the <connections> section in node details
+2. Check if <input> or <output> uses expressions like: ={{...parameterName...}}
+3. If a parameter is referenced in these expressions, it IS connection-changing
+4. If a parameter is NOT in <input>/<output> expressions, it is NOT connection-changing
+
+**Example from AI Agent:**
+\`\`\`xml
+<input>={{...hasOutputParser, needsFallback...}}</input>
+\`\`\`
+→ hasOutputParser and needsFallback ARE connection-changing (they control which inputs appear)
+
+**Counter-example:**
+\`\`\`xml
+<properties>
+  <property name="promptType">...</property>  <!-- NOT in <input>/<output> -->
+  <property name="systemMessage">...</property>  <!-- NOT in <input>/<output> -->
+</properties>
+\`\`\`
+→ promptType and systemMessage are NOT connection-changing (they don't affect connections)
+
+**Common connection-changing parameters:**
+- Vector Store: mode (appears in <input>/<output> expressions)
+- AI Agent: hasOutputParser, needsFallback (appears in <input> expression)
+- Merge: numberInputs (appears in <input> expression)
+- Webhook: responseMode (appears in <output> expression)`;
+const DYNAMIC_OUTPUT_NODES = `Some nodes have DYNAMIC outputs that depend on parameter values:
+
+**Switch Node** (n8n-nodes-base.switch):
+- When mode is "rules", the number of outputs equals the number of routing rules
+- Connection parameter: mode: "rules" - CRITICAL for enabling rule-based routing
+- Each rule in rules.values[] creates one output
+- The rules parameter uses the same filter structure as IF node conditions
+- ALWAYS flag mode as connection-changing with possibleValues: ["rules", "expression"]
+
+**Merge Node** (n8n-nodes-base.merge):
+- numberInputs parameter controls how many inputs the node accepts
+
+When you find these nodes, ALWAYS flag mode/numberInputs as connection-changing parameters with possibleValues.`;
+const SUB_NODES_SEARCHES = `When searching for AI nodes, ALSO search for their required sub-nodes:
+- "AI Agent" → also search for "Chat Model", "Memory", "Output Parser"
+- "Basic LLM Chain" → also search for "Chat Model", "Output Parser"
+- "Vector Store" → also search for "Embeddings", "Document Loader"`;
+const STRUCTURED_OUTPUT_PARSER = `Search for "Structured Output Parser" (@n8n/n8n-nodes-langchain.outputParserStructured) when:
+- AI output will be used programmatically (conditions, formatting, database storage, API calls)
+- AI needs to extract specific fields (e.g., score, category, priority, action items)
+- AI needs to classify/categorize data into defined categories
+- Downstream nodes need to access specific fields from AI response (e.g., $json.score, $json.category)
+- Output will be displayed in a formatted way (e.g., HTML email with specific sections)
+- Data needs validation against a schema before processing
+
+- Always use search_nodes to find the exact node names and versions - NEVER guess versions`;
+const CRITICAL_RULES = `- NEVER ask clarifying questions
+- ALWAYS call get_best_practices first
+- THEN Call search_nodes to learn about available nodes and their inputs and outputs
+- FINALLY call get_node_details IN PARALLEL for speed to get more details about RELVANT node
+- ALWAYS extract version number from <version> tag in node details
+- NEVER guess node versions - always use search_nodes to find exact versions
+- ONLY flag connectionChangingParameters if they appear in <input> or <output> expressions
+- If no parameters appear in connection expressions, return empty array []
+- Output ONLY: nodesFound with {{ nodeName, version, reasoning, connectionChangingParameters }}`;
+const RESTRICTIONS = `- Output text commentary between tool calls
+- Include bestPractices or categorization in submit_discovery_results
+- Flag parameters that don't affect connections
+- Stop without calling submit_discovery_results`;
+function generateAvailableToolsList(options) {
+    const { includeExamples } = options;
+    const tools = [
+        '- get_best_practices: Retrieve best practices (internal context)',
+        '- search_nodes: Find n8n nodes by keyword',
+        '- get_node_details: Get complete node information including <connections>',
+    ];
+    if (includeExamples) {
+        tools.push('- get_workflow_examples: Search for workflow examples as reference');
+    }
+    tools.push('- submit_discovery_results: Submit final results');
+    return tools.join('\n');
+}
+function generateProcessSteps(options) {
+    const { includeExamples } = options;
+    const steps = [
+        '**Analyze user prompt** - Extract services, models, and technologies mentioned',
+        '**Call get_best_practices** with identified techniques (internal context)',
+    ];
+    if (includeExamples) {
+        steps.push('**Call get_workflow_examples** with search queries for mentioned services/models');
+    }
+    const examplesContext = includeExamples ? ', and examples' : '';
+    steps.push(`**Identify workflow components** from user request, best practices${examplesContext}`, '**Call search_nodes IN PARALLEL** for all components (e.g., "Gmail", "OpenAI", "Schedule")', '**Call get_node_details IN PARALLEL** for ALL promising nodes (batch multiple calls)', `**Extract node information** from each node_details response:
+   - Node name from <name> tag
+   - Version number from <version> tag (required - extract the number)
+   - Connection-changing parameters from <connections> section`, '**Call submit_discovery_results** with complete nodesFound array');
+    return steps.map((step, index) => `${index + 1}. ${step}`).join('\n');
+}
+function buildDiscoveryPrompt(options) {
+    const availableTools = generateAvailableToolsList(options);
+    const processSteps = generateProcessSteps(options);
+    return (0, builder_1.prompt)()
+        .section('role', DISCOVERY_ROLE)
+        .section('available_tools', availableTools)
+        .section('process', processSteps)
+        .section('technique_categorization', TECHNIQUE_CATEGORIZATION)
+        .section('technique_clarifications', TECHNIQUE_CLARIFICATIONS)
+        .section('connection_changing_parameters', CONNECTION_PARAMETERS)
+        .section('dynamic_output_nodes', DYNAMIC_OUTPUT_NODES)
+        .section('sub_nodes_searches', SUB_NODES_SEARCHES)
+        .section('structured_output_parser', STRUCTURED_OUTPUT_PARSER)
+        .section('critical_rules', CRITICAL_RULES)
+        .section('do_not', RESTRICTIONS)
+        .build();
+}
+//# sourceMappingURL=discovery.prompt.js.map