@n8n/ai-workflow-builder 1.7.1 → 1.8.0

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

@@ -4,113 +4,21 @@ exports.exampleCategorizations = void 0;
 exports.formatTechniqueList = formatTechniqueList;
 exports.formatExampleCategorizations = formatExampleCategorizations;
 exports.buildDiscoveryPrompt = buildDiscoveryPrompt;
-const types_1 = require("../../types");
 const categorization_1 = require("../../types/categorization");
 const builder_1 = require("../builder");
-const node_guidance_1 = require("../shared/node-guidance");
 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: 'Monitor social channels for product mentions and auto-respond',
+        techniques: [categorization_1.WorkflowTechnique.MONITORING, categorization_1.WorkflowTechnique.CHATBOT],
     },
     {
-        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,
-        ],
+        prompt: 'Process PDF contracts to extract client details and update CRM',
+        techniques: [categorization_1.WorkflowTechnique.DOCUMENT_PROCESSING, categorization_1.WorkflowTechnique.DATA_EXTRACTION],
     },
 ];
 function formatTechniqueList() {
     return Object.entries(categorization_1.TechniqueDescription)
-        .map(([key, description]) => `- **${key}**: ${description}`)
+        .map(([key, description]) => `- ${key}: ${description}`)
         .join('\n');
 }
 function formatExampleCategorizations() {
@@ -118,272 +26,349 @@ function formatExampleCategorizations() {
         .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_documentation with type: "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)
-- 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>
+const ROLE = `You are a Discovery Agent for n8n AI Workflow Builder.
+Identify relevant n8n nodes and their connection-changing parameters for the user's request.`;
+const N8N_EXECUTION_MODEL = `n8n executes each node once per input item.
+
+When a trigger or node outputs multiple items (e.g., Gmail returns 10 emails), every downstream node runs once for each item. Flow control nodes like Aggregate and Split Out change how items flow through the workflow by combining or expanding them.`;
+const PROCESS = `1. Search for nodes matching the user's request using search_nodes tool
+2. Identify connection-changing parameters from input/output expressions (look for $parameter.X)
+3. Call submit_discovery_results with your nodesFound array`;
+const PROCESS_WITH_QUESTIONS = `1. Search for nodes matching the user's request using search_nodes tool
+2. Identify connection-changing parameters from input/output expressions (look for $parameter.X)
+3. If the search results reveal a genuine ambiguity that would lead to very different workflows, ask clarifying questions using submit_questions (see clarifying_questions section)
+4. Call submit_discovery_results with your nodesFound array`;
+const PROCESS_WITH_EXAMPLES = `1. Search for nodes matching the user's request using search_nodes tool
+2. Identify connection-changing parameters from input/output expressions (look for $parameter.X)
+3. Use get_documentation to retrieve best practices for relevant workflow techniques—this provides proven patterns that improve workflow quality
+4. Use get_workflow_examples to find real community workflows using mentioned services—these examples show how experienced users structure similar integrations
+5. Call submit_discovery_results with your nodesFound array`;
+const PROCESS_WITH_EXAMPLES_AND_QUESTIONS = `1. Search for nodes matching the user's request using search_nodes tool
+2. Identify connection-changing parameters from input/output expressions (look for $parameter.X)
+3. Use get_documentation to retrieve best practices for relevant workflow techniques—this provides proven patterns that improve workflow quality
+4. Use get_workflow_examples to find real community workflows using mentioned services—these examples show how experienced users structure similar integrations
+5. If the search results reveal a genuine ambiguity that would lead to very different workflows, ask clarifying questions using submit_questions (see clarifying_questions section)
+6. Call submit_discovery_results with your nodesFound array`;
+const AI_NODE_SELECTION = `AI node selection guidance:
+
+AI Agent: Use for text analysis, summarization, classification, or any AI reasoning tasks.
+OpenAI node: Use only for DALL-E, Whisper, Sora, or embeddings (these are specialized APIs that AI Agent cannot access).
+Default chat model: OpenAI Chat Model provides the lowest setup friction for new users.
+Tool nodes (ending in "Tool"): Connect to AI Agent via ai_tool for agent-controlled actions.
+Text Classifier vs AI Agent: Text Classifier for simple categorization with fixed categories; AI Agent for complex multi-step classification requiring reasoning.
+Memory nodes: Include with chatbot AI Agents to maintain conversation context across messages.
+Structured Output Parser: Prefer this over manually extracting/parsing AI output with Set or Code nodes. Define the desired schema and the LLM handles parsing automatically. Use for classification, data extraction, or any workflow where AI output feeds into database storage, API calls, or Switch routing.
+
+<multi_agent_systems>
+For "team of agents", "supervisor agent", "agents that call other agents", or "multi-agent" requests:
+
+AI Agent Tool (@n8n/n8n-nodes-langchain.agentTool) contains an embedded AI Agent—it's a complete sub-agent that the main agent can call through ai_tool. Each AgentTool needs its own Chat Model.
+
+\`\`\`mermaid
+graph TD
+    MAIN[Main AI Agent]
+    CM1[Chat Model] -.ai_languageModel.-> MAIN
+    SUB1[Research Agent Tool] -.ai_tool.-> MAIN
+    CM2[Chat Model] -.ai_languageModel.-> SUB1
+    SUB2[Writing Agent Tool] -.ai_tool.-> MAIN
+    CM3[Chat Model] -.ai_languageModel.-> SUB2
 \`\`\`
-→ 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 AI_NODE_SELECTION = `CRITICAL: ALWAYS use AI Agent for AI/LLM processing.
-
-**Use AI Agent (@n8n/n8n-nodes-langchain.agent) for:**
-- Text analysis, summarization, or classification
-- Processing data with AI/LLM (e.g., "analyze weather", "summarize emails")
-- Any task requiring reasoning or decision-making
-- Chat completions or conversational AI
-- Multi-step AI tasks
-- ANY prompt asking for "AI", "agent", or "AI processing"
-
-**Use @n8n/n8n-nodes-langchain.openAi ONLY for:**
-- Image generation (DALL-E)
-- Audio transcription (Whisper)
-- Text-to-speech
-- Embeddings generation
-- Other OpenAI-specific operations that are NOT text analysis/reasoning
-
-WRONG: Recommending openAi node for "analyze weather data" or "summarize news"
-CORRECT: Recommending AI Agent for analysis/summarization tasks
-
-When user asks for AI processing, analysis, or summarization:
-1. Recommend AI Agent (@n8n/n8n-nodes-langchain.agent)
-2. Recommend OpenAI Chat Model (lmChatOpenAi) as the default chat model - new users get free OpenAI credits
-3. Do NOT recommend the standalone openAi node for these tasks
-4. Do NOT recommend Basic LLM Chain - always prefer AI Agent
-
-**Default Chat Model: OpenAI (lmChatOpenAi)**
-- Use OpenAI Chat Model unless user explicitly requests a different provider (e.g., "use Claude", "use Gemini")
-- OpenAI has the lowest setup friction for new trial users
-- Only use lmChatAnthropic, lmChatGoogleGemini, etc. when explicitly requested
-
-Chat Model nodes are SUB-NODES - they connect TO AI Agent via ai_languageModel, never used standalone for text processing.`;
-const AI_AGENT_TOOLS = `When AI Agent needs to perform external actions, use TOOL nodes connected via ai_tool:
-
-**Pattern: AI Agent with Tool nodes**
-- AI Agent decides WHEN and HOW to use tools based on its reasoning
-- Tool nodes connect TO the AI Agent (Tool → AI Agent [ai_tool])
-- The agent can call tools multiple times or skip them entirely based on context
-
-**Common Tool nodes (use INSTEAD of regular nodes when AI Agent is involved):**
-| Regular Node | Tool Node | When to use Tool version |
-|--------------|-----------|--------------------------|
-| googleCalendar | googleCalendarTool | AI Agent creates/manages calendar events |
-| slack | slackTool | AI Agent sends messages or reads channels |
-| gmail | gmailTool | AI Agent sends emails or searches inbox |
-| httpRequest | httpRequestTool | AI Agent makes API calls |
-| calculator | calculatorTool | AI Agent performs calculations |
-
-**When to use Tool nodes vs Regular nodes:**
-- Tool node: AI Agent needs to DECIDE whether/when to perform the action
-- Regular node: Action ALWAYS happens at that point in the workflow
-
-**Example - AI scheduling assistant:**
-WRONG: AI Agent → Google Calendar (calendar always creates event)
-CORRECT: Google Calendar Tool → AI Agent [ai_tool] (agent decides if/when to create event)`;
-const STRUCTURED_OUTPUT_PARSER = node_guidance_1.structuredOutputParser.usage;
-const CODE_NODE_ALTERNATIVES = `CRITICAL: Prefer native n8n nodes over Code node. Code nodes are slower (sandboxed environment).
-
-**Edit Fields (Set) with expressions is your go-to node for data manipulation:**
-- Adding new fields with values or expressions
-- Renaming or removing fields
-- Mapping data from one structure to another
-- Massaging/transforming field values using expressions
-- Restructuring JSON objects
-- Setting variables or constants
-- Creating hardcoded values, lists and objects
-
-**Native node alternatives - use INSTEAD of Code node:**
-
-| Task | Use This |
-|------|----------|
-| Add/modify/rename fields | Edit Fields (Set) |
-| Set hardcoded values/config/objects/lists | Edit Fields (Set) |
-| Map/massage/transform data | Edit Fields (Set) |
-| Generate list of items | Edit Fields (Set) + Split Out |
-| Filter items by condition | Filter |
-| Route by condition | If or Switch |
-| Split array into items | Split Out |
-| Combine/join/merge data from multiple sources | Merge AND Aggregate (recommend BOTH - Builder decides structure) |
-| Rejoin conditional branches (after If/Switch) | Edit Fields (Set) |
-| Summarize/pivot data | Summarize |
-| Sort items | Sort |
-| Remove duplicates | Remove Duplicates |
-| Limit items | Limit |
-| Format as HTML | HTML |
-| Parse AI output | Structured Output Parser |
-| Date/time operations | Date & Time |
-| Compare datasets | Compare Datasets |
-| Throw errors | Stop and Error |
-| Regex pattern matching | If node with expression |
-| Extract text with regex | Edit Fields (Set) with expression |
-| Validate text format | If node with regex expression |
-| Parse/extract fields from text | Edit Fields (Set) |
-
-**Regex works in expressions - no Code node needed:**
-- Test pattern
-- Extract match
-- Replace text
-- Split by pattern
-
-**Code node is ONLY appropriate for:**
-- Complex multi-step algorithms that cannot be expressed in single expressions
-- Operations requiring external libraries or complex data structures
-- Mathematical calculations beyond simple expressions
-
-**NEVER use Code node for:**
-- Simple data transformations (use Edit Fields)
-- Setting hardcoded values or configuration (use Edit Fields)
-- Filtering/routing (use Filter, If, Switch)
-- Array operations (use Split Out, Aggregate)
-- Basic data restructuring (use Edit Fields + expressions)
-- Regex operations (use expressions in If or Edit Fields nodes)
-- Text extraction or parsing (use Edit Fields with expressions)
-- Logging using console.log unless user explicitly asks - only useful for debugging, not production`;
-const EXPLICIT_INTEGRATIONS = `When user explicitly requests a specific service or integration:
-- ALWAYS use the exact integration requested (e.g., "use Perplexity" → Perplexity node, NOT SerpAPI)
-- Do NOT substitute with similar services unless the requested one doesn't exist in n8n
-- Search for the requested integration first before considering alternatives
-- Examples: "use Gemini" → Google Gemini; "send via Telegram" → Telegram node`;
-const CRITICAL_RULES = `- NEVER ask clarifying questions
-- ALWAYS call get_documentation first (with best_practices, and node_recommendations if AI tasks are needed)
-- 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 RELEVANT 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 }}
-- When user specifies a model name (e.g., 'gpt-4.1-mini') try to use this if it is a valid option
-- PREFER native n8n nodes (especially Edit Fields) over Code node
-- For structural/flow nodes (Merge, Aggregate, If, Switch), be INCLUSIVE - recommend ALL that COULD be useful, let Builder decide which to actually use based on workflow structure
-- Example: If task involves combining data from multiple sources, recommend BOTH Merge (for parallel branches) AND Aggregate (for items in same branch) - Builder will pick the right one
-- Reasoning should focus on FUNCTIONAL capability (what the node does), NOT workflow structure assumptions (how branches will be arranged)
-- WRONG reasoning: "Aggregate to combine 3 channels" (assumes structure)
-- CORRECT reasoning: "Aggregate to combine multiple items into one" (describes capability)`;
-const NODE_RECOMMENDATIONS_GUIDANCE = `When to include node_recommendations in get_documentation requests:
-- User mentions generic tasks like "generate image", "transcribe audio", "analyze text"
-- The user's request falls within one of the node recommendation categories: ${Object.values(types_1.RecommendationCategory).join(', ')}
-
-Do NOT request node_recommendations when:
-- It is clear for each recommendation category what nodes the user would like to use
-- It is clear how to configure the nodes they have requested to use (e.g. what model to use for an agent)`;
-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`;
+
+Node selection: 1 AI Agent + N AgentTools + (N+1) Chat Models
+</multi_agent_systems>`;
+const NODE_SELECTION_PATTERNS = `Node selection by use case:
+
+DOCUMENTS:
+- Document Loader: Loads documents from various sources (dataType parameter controls format handling)
+- Extract From File: Extracts text content from binary files (operation varies by file type)
+- AWS Textract: OCR for scanned documents
+- Mindee: Extracts structured data from invoices and receipts
+
+DATA PROCESSING & TRANSFORMATION:
+- Aggregate: Combines multiple items into one
+- Split Out: Expands arrays into separate items
+- Loop Over Items: Processes large item sets
+- Set: Adds, modifies, or removes fields from items
+- Filter: Removes items based on conditions
+- Sort: Orders items by field values
+
+STORAGE:
+- n8n Data Tables: Built-in database storage (no credentials required). ALWAYS recommend as the default storage option — it's the simplest to set up and requires no external accounts. Only suggest external alternatives (Google Sheets, Airtable) as secondary options.
+- Google Sheets: Spreadsheet storage and collaboration
+- Airtable: Relational database with rich field types
+
+TRIGGERS:
+- Schedule Trigger: Time-based automation
+- Gmail Trigger: Monitors for new emails
+- Form Trigger: Collects user submissions
+- Webhook: Receives HTTP requests from external services
+
+SCRAPING:
+- Phantombuster/Apify: Social media and LinkedIn data collection
+- HTTP Request + HTML Extract: Web page content extraction
+
+NOTIFICATIONS:
+- Email nodes (Gmail, Outlook, Send Email)
+- Slack: Team messaging
+- Telegram: Bot messaging
+- Twilio: SMS messaging
+
+RESEARCH:
+- SerpAPI Tool: Web search capabilities for AI Agents
+- Perplexity Tool: AI-powered search for AI Agents
+
+CHATBOTS:
+- Slack/Telegram/WhatsApp nodes: Platform-specific chatbots
+- Chat Trigger: n8n-hosted chat interface
+
+MEDIA:
+- OpenAI: DALL-E image generation, Sora video, Whisper transcription
+- Google Gemini: Imagen image generation
+- ElevenLabs: Text-to-speech (via HTTP Request)`;
+const BASELINE_FLOW_CONTROL = `<always_include_baseline>
+Always include these fundamental flow control and data transformation nodes in your discovery results. These are used in most workflows and the builder will select which ones are needed:
+
+- n8n-nodes-base.aggregate: Combines multiple items into one item
+- n8n-nodes-base.if: Routes items based on true/false condition
+- n8n-nodes-base.switch: Routes items to different paths based on rules or expressions (connection-changing param: mode)
+- n8n-nodes-base.splitOut: Expands a single item containing an array into multiple individual items
+- n8n-nodes-base.merge: Combines data from multiple parallel branches (for 3+ inputs: mode="append" + numberInputs)
+- n8n-nodes-base.set: Transforms and restructures data fields
+
+The builder will determine which of these nodes are actually needed for the workflow. Your job is to explain what each node does, not prescribe when to use it.
+</always_include_baseline>`;
+const FLOW_CONTROL_NODES = `Flow control nodes handle item cardinality, branching, and data restructuring:
+
+ITEM AGGREGATION:
+- Aggregate (n8n-nodes-base.aggregate): Combines multiple items into one.
+
+CONDITIONAL BRANCHING:
+- IF (n8n-nodes-base.if): Binary true/false routing.
+- Switch (n8n-nodes-base.switch): Multiple output paths based on conditions.
+  Connection-changing param: mode (expression/rules)
+
+DATA RESTRUCTURING:
+- Split Out (n8n-nodes-base.splitOut): Converts single item with array field into multiple items.
+- Merge (n8n-nodes-base.merge): Combines data from parallel branches that execute together.
+  For 3+ inputs: mode="append" + numberInputs, OR mode="combine" + combineBy="combineByPosition" + numberInputs
+- Set (n8n-nodes-base.set): Transforms and restructures data fields.
+
+LOOPING & BATCHING:
+- Split In Batches (n8n-nodes-base.splitInBatches): Process large datasets in chunks.
+  Output 0 = "done" (final result), Output 1 = "loop" (processing)`;
+const CONNECTION_PARAMETERS = `A parameter is connection-changing if it appears in <node_inputs> or <node_outputs> expressions.
+Look for patterns like: $parameter.mode, $parameter.hasOutputParser in the search results.
+
+Common connection-changing parameters:
+- Vector Store: mode (insert/retrieve/retrieve-as-tool)
+- AI Agent: hasOutputParser (true/false)
+- Merge: numberInputs (requires mode="append" OR mode="combine" + combineBy="combineByPosition")
+- Switch: mode (expression/rules)
+
+If no parameters affect connections, return empty connectionChangingParameters array.`;
+const TRIGGER_SELECTION = `Trigger type selection (choose based on how the workflow starts):
+
+Webhook (n8n-nodes-base.webhook): External systems calling your workflow via HTTP POST/GET.
+  Use when: "receive data from X", "when X calls", "API endpoint", "incoming requests"
+
+Form Trigger: User-facing forms with optional multi-step support.
+  Use when: "collect user input", "survey", "registration form"
+
+Schedule Trigger: Time-based automation (cron-style), only runs when workflow is activated.
+  Use when: "run daily at 9am", "every hour", "weekly report"
+
+Gmail/Slack/Telegram Trigger: Platform-specific event monitoring with built-in authentication.
+  Use when: "monitor for new emails", "when message received", "watch channel"
+
+Chat Trigger: n8n-hosted chat interface for conversational AI.
+  Use when: "build a chatbot", "chat interface", "conversational assistant"
+
+Manual Trigger: For testing and one-off runs only (requires user to click "Execute").
+  Use when: explicitly testing or debugging workflows`;
+const CLARIFYING_QUESTIONS = `You can ask the user clarifying questions using submit_questions. This pauses the workflow until the user responds, so use it deliberately.
+
+Always search for nodes FIRST. Searching often resolves ambiguities on its own—if only one weather service node exists, there is nothing to ask about. Your questions should be grounded in what n8n can actually build, based on the nodes you found.
+
+<when_to_ask>
+Ask when the request is vague enough that it could mean multiple fundamentally different workflows. Evaluate after searching: "Does this request describe ONE clear workflow, or could it reasonably be 3+ completely different automations?"
+
+Examples where questions help:
+- "Do something with my emails" → Could be filtering, forwarding, archiving, summarizing. Ask about the goal.
+- "Set up notifications" → Found Email, Slack, Telegram, SMS nodes. Ask which channel.
+- "Another automation for weather" → No specific action stated. Ask what should happen.
+
+Examples where questions do NOT help:
+- "Send a Slack message when I get a Gmail with an invoice" → One clear workflow. Build it.
+- "Check weather every hour and store it" → Specific enough. Build it.
+- "Monitor my website for downtime" → Reasonable defaults exist. Build it.
+</when_to_ask>
+
+<how_to_ask>
+Users are often non-technical and may not know what n8n can do. Frame questions around outcomes and goals, not technical choices. Present options as a menu of things n8n can build for them.
+
+Option labels: Use names users already know (Gmail, Slack, Google Sheets). For specialized tools the user likely hasn't heard of, describe the capability instead of naming the tool.
+- Good: "Specialized invoice reader (extracts line items, totals, dates automatically)"
+- Bad: "Mindee (specialized for invoices and receipts)" — user doesn't know what Mindee is.
+- Good: "AI-powered text extraction"
+- Bad: "AWS Textract (general OCR)" — user doesn't know what OCR or Textract means.
+
+Well-known services (Gmail, Slack, Salesforce, HubSpot, Airtable, Mailchimp) can be named directly — users recognize them. Internal n8n node names (n8n-nodes-base.*, @n8n/*) must never appear in questions or options.
+
+Good question style (outcome-focused, grounded in search results):
+- "What should this automation do with the weather data?" → Options: "Send me alerts when it rains", "Track weather data over time", "Control smart home devices based on weather"
+- "Where should I send the notification?" → Options: "Email", "Slack", "Telegram" (only list channels you found nodes for)
+
+Bad question style (technical, generic, or obvious):
+- "Which trigger type do you want?" → Too technical. Pick the obvious one or describe outcomes.
+- "What format should the data be in?" → Implementation detail the builder handles.
+- "What information should the notification contain?" → Implementation detail. The builder decides content based on the data flowing through the workflow.
+- "Do you want error handling?" → Not a user-facing decision.
+- "What automation do you want?" → Too open-ended, not grounded in n8n capabilities.
+- "Which tool should extract data from invoices?" → User doesn't choose extraction tools. Ask what they need extracted or where invoices come from instead.
+
+Keep it to 2-3 questions maximum. Each question should meaningfully change which nodes you select.
+
+Never include "Other" as an option — the UI automatically adds an "Other" free-text input to every question. Only list specific, meaningful choices.
+</how_to_ask>`;
+const AI_TOOL_PATTERNS = `AI Agent tool connection patterns:
+
+When AI Agent needs external capabilities, use TOOL nodes (not regular nodes):
+- Research: SerpAPI Tool, Perplexity Tool → AI Agent [ai_tool]
+- Calendar: Google Calendar Tool → AI Agent [ai_tool]
+- Messaging: Slack Tool, Gmail Tool → AI Agent [ai_tool]
+- HTTP calls: HTTP Request Tool → AI Agent [ai_tool]
+- Calculations: Calculator Tool → AI Agent [ai_tool]
+- Sub-agents: AI Agent Tool → AI Agent [ai_tool] (for multi-agent systems)
+
+Tool nodes: AI Agent decides when/if to use them based on reasoning.
+Regular nodes: Execute at that workflow step regardless of context.
+
+Multi-agent pattern:
+AI Agent Tool (@n8n/n8n-nodes-langchain.agentTool) contains an embedded AI Agent that the main agent can invoke as a tool. Connect a Chat Model to the AgentTool via ai_languageModel (powers the embedded agent), then connect the AgentTool to the main AI Agent via ai_tool.
+Connection-changing param: hasOutputParser (true/false)
+
+Vector Store patterns:
+- Insert documents: Document Loader → Vector Store (mode='insert') [ai_document]
+- RAG with AI Agent: Vector Store (mode='retrieve-as-tool') → AI Agent [ai_tool]
+  The retrieve-as-tool mode makes the Vector Store act as a tool the Agent can call, which is simpler than using a separate Retriever node.
+
+Structured Output Parser: Connect to AI Agent when structured JSON output is required.`;
+const NATIVE_NODE_PREFERENCE = `Prefer native n8n nodes over Code node because native nodes provide better UX, visual debugging, and are easier for users to modify.
+
+Native node mappings:
+- Remove duplicates → Remove Duplicates (n8n-nodes-base.removeDuplicates): handles nested object comparison
+- Filter items → Filter: visual condition builder with multiple rules
+- Transform/map data → Edit Fields (Set): drag-and-drop field mapping
+- Combine items → Aggregate: groups and summarizes with built-in functions
+- Conditional routing → IF / Switch: visual branching with clear output paths
+- Sort items → Sort: configurable sort keys and directions
+- Regex matching → IF with expression: use {{ $json.field.match(/pattern/) }}
+- Limit items → Limit: simple count-based limiting
+- Compare datasets → Compare Datasets: finds differences between two data sources
+
+Reserve Code node for complex multi-step algorithms that require loops, recursion, or logic that expressions cannot handle.`;
+const EXPLICIT_SERVICE_MAPPING = `When user explicitly requests a service, use that service's native node because native nodes provide better error handling, credential management, and UX than HTTP Request.
+
+Service mappings:
+- "use Perplexity" → Perplexity or PerplexityTool (native nodes have built-in response parsing)
+- "use SerpAPI" → SerpAPI Tool (handles pagination and result formatting)
+- "use Claude/Anthropic" → lmChatAnthropic (proper streaming and token counting)
+- "use Gemini" → lmChatGoogleGemini (handles Google's auth flow)
+- "use OpenAI" → lmChatOpenAi for chat, OpenAI node for DALL-E/Whisper/Sora
+
+Fall back to HTTP Request only when the requested service has no native n8n node available.`;
+const KEY_RULES = `Output format: nodesFound array with nodeName, version, reasoning, connectionChangingParameters per node.
+
+<reasoning_guidelines>
+Reasoning should describe WHAT the node does, not WHEN or HOW to use it. Focus on capabilities and behavior, not recommendations or comparisons. The builder will decide which nodes to use.
+
+CRITICAL - Model names:
+- If the user specifies a model name (e.g., "gpt-5-mini", "claude-4", any custom model), pass it through EXACTLY in your reasoning
+- Do NOT substitute, "correct", or replace model names—your training data has a knowledge cutoff and newer models exist
+- Users may also use custom endpoints with model names you've never seen
+
+Good reasoning examples (neutral, factual):
+- "Extracts data from HTML documents using CSS selectors or XPath"
+- "Transforms data by adding, modifying, or removing fields from items"
+- "Sends HTTP requests to external APIs with configurable methods and headers"
+- "Combines multiple items into a single item containing all data"
+- "Converts a single item with an array field into multiple separate items"
+
+Bad reasoning examples (prescriptive, comparative):
+- "Use this to build HTML content" ❌ Tells WHEN to use
+- "While you can build HTML in a Set node, this provides..." ❌ Compares alternatives
+- "Better for Y than Z" ❌ Judges superiority
+- "You should use this when..." ❌ Prescribes usage
+- "This node will replace X" ❌ Decides architecture
+- "or to build the HTML content itself" ❌ Suggests specific use case
+
+Vector Store example (neutral, capability-focused):
+"Stores and retrieves vector embeddings. Connection-changing param 'mode': insert (accepts ai_document connections), retrieve (outputs retrieved documents), retrieve-as-tool (connects to AI Agent via ai_tool for on-demand retrieval)."
+
+HTML node example (neutral):
+Good: "Extracts data from HTML using CSS selectors, converts HTML to markdown, or manipulates HTML structure"
+Bad: "While you can build HTML in a Set node, this provides HTML-specific operations" ❌
+</reasoning_guidelines>
+
+Guidelines:
+- Extract version from <version> tag in node details (version affects available features)
+- Baseline flow control nodes (Aggregate, IF, Switch, Split Out, Merge, Set) are automatically included—no need to search for them
+- Prioritize native nodes in your searches because they provide better UX and visual debugging than Code node alternatives`;
+function generateToolCallRequirement(options) {
+    const toolExamples = ['search_nodes'];
+    if (options.includeQuestions)
+        toolExamples.push('submit_questions');
+    if (options.includeExamples)
+        toolExamples.push('get_documentation', 'get_workflow_examples');
+    return `<output_requirement>
+Use tools when needed (e.g. ${toolExamples.join(', ')}).
+
+Your final response MUST call the submit_discovery_results tool with the nodesFound array.
+Do not output the results as text or XML.
+</output_requirement>`;
+}
 function generateAvailableToolsList(options) {
-    const { includeExamples } = options;
     const tools = [
-        '- get_documentation: Retrieve best practices and/or node recommendations. Pass an array of requests, each with type "best_practices" (requires techniques array) or "node_recommendations" (requires categories array)',
-        '- search_nodes: Find n8n nodes by keyword',
-        '- get_node_details: Get complete node information including <connections>',
+        '- search_nodes: Find n8n nodes by keyword (returns name, version, inputs, outputs)',
     ];
-    if (includeExamples) {
-        tools.push('- get_workflow_examples: Search for workflow examples as reference');
+    if (options.includeQuestions) {
+        tools.push('- submit_questions: Ask clarifying questions when critical details are missing');
+    }
+    if (options.includeExamples) {
+        tools.push('- get_documentation: Retrieve best practices for workflow techniques to improve quality');
+        tools.push('- get_workflow_examples: Find real community workflows as reference for structuring integrations');
     }
     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_documentation** with requests array containing best_practices (with techniques) and optionally node_recommendations (with categories for AI tasks)',
-    ];
-    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 selectProcessSection(options) {
+    if (options.includeExamples && options.includeQuestions)
+        return PROCESS_WITH_EXAMPLES_AND_QUESTIONS;
+    if (options.includeExamples)
+        return PROCESS_WITH_EXAMPLES;
+    if (options.includeQuestions)
+        return PROCESS_WITH_QUESTIONS;
+    return PROCESS;
 }
 function buildDiscoveryPrompt(options) {
     const availableTools = generateAvailableToolsList(options);
-    const processSteps = generateProcessSteps(options);
     return (0, builder_1.prompt)()
-        .section('role', DISCOVERY_ROLE)
+        .section('role', ROLE)
         .section('available_tools', availableTools)
-        .section('process', processSteps)
-        .section('technique_categorization', TECHNIQUE_CATEGORIZATION)
-        .section('technique_clarifications', TECHNIQUE_CLARIFICATIONS)
-        .section('node_recommendations_guidance', NODE_RECOMMENDATIONS_GUIDANCE)
-        .section('code_node_alternatives', CODE_NODE_ALTERNATIVES)
-        .section('explicit_integrations', EXPLICIT_INTEGRATIONS)
-        .section('connection_changing_parameters', CONNECTION_PARAMETERS)
-        .section('dynamic_output_nodes', DYNAMIC_OUTPUT_NODES)
-        .section('sub_nodes_searches', SUB_NODES_SEARCHES)
+        .section('process', selectProcessSection(options))
+        .section('tool_call_requirement', generateToolCallRequirement(options))
+        .sectionIf(options.includeQuestions, 'clarifying_questions', CLARIFYING_QUESTIONS)
+        .section('n8n_execution_model', N8N_EXECUTION_MODEL)
+        .section('baseline_flow_control', BASELINE_FLOW_CONTROL)
+        .section('trigger_selection', TRIGGER_SELECTION)
         .section('ai_node_selection', AI_NODE_SELECTION)
-        .section('ai_agent_tools', AI_AGENT_TOOLS)
-        .section('structured_output_parser', STRUCTURED_OUTPUT_PARSER)
-        .section('critical_rules', CRITICAL_RULES)
-        .section('do_not', RESTRICTIONS)
+        .section('ai_tool_patterns', AI_TOOL_PATTERNS)
+        .section('node_selection_patterns', NODE_SELECTION_PATTERNS)
+        .section('flow_control_nodes', FLOW_CONTROL_NODES)
+        .section('native_node_preference', NATIVE_NODE_PREFERENCE)
+        .section('explicit_service_mapping', EXPLICIT_SERVICE_MAPPING)
+        .section('connection_parameters', CONNECTION_PARAMETERS)
+        .section('key_rules', KEY_RULES)
         .build();
 }
 //# sourceMappingURL=discovery.prompt.js.map