@atom8n/ai-workflow-builder 1.2.0

package/dist/tools/best-practices/scraping-and-research.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScrapingAndResearchBestPractices = void 0;
+const categorization_1 = require("../../types/categorization");
+class ScrapingAndResearchBestPractices {
+    technique = categorization_1.WorkflowTechnique.SCRAPING_AND_RESEARCH;
+    version = '1.0.0';
+    documentation = `# Best Practices: Scraping & Research Workflows
+
+## Performance & Resource Management
+
+Batch requests and introduce delays to avoid hitting API rate limits or overloading target servers. Use Wait nodes and
+batching options in HTTP Request nodes. When 429 rate limiting errors occur due to receiving too many requests,
+implement batching to reduce request frequency or use the "Retry on Fail" feature to automatically handle throttled
+responses.
+
+Workflows processing large datasets can crash due to memory constraints. Use the Split In Batches node to process 200
+rows at a time to reduce memory usage, leverage built-in nodes instead of custom code, and increase execution timeouts
+via environment variables for better resource management.
+
+## Looping & Pagination
+
+Implement robust looping for paginated data. Use Set, IF, and Code nodes to manage page numbers and loop conditions,
+ensuring you don't miss data or create infinite loops. Leverage n8n's built-in mechanisms rather than manual approaches:
+use the $runIndex variable to track iterations without additional code nodes, and employ workflow static data or node
+run indexes to maintain state across loop cycles.
+
+## Recommended Nodes
+
+### HTTP Request (n8n-nodes-base.httpRequest)
+
+Purpose: Fetches web pages or API data for scraping and research workflows
+
+Pitfalls:
+
+- Depending on the data which the user wishes to scrape/research, it maybe against the terms of service to attempt to
+fetch it from the site directly. Using scraping nodes is the best way to get around this.
+
+Pitfalls:
+
+- Double-check URL formatting, query parameters, and ensure all required fields are present to avoid bad request errors
+- Be aware of 429 rate limiting errors when the service receives too many requests - implement batching or use "Retry on
+Fail" feature
+- Refresh expired tokens, verify API keys, and ensure correct permissions to avoid authentication failures
+
+### SerpAPI (@n8n/n8n-nodes-langchain.toolSerpApi)
+
+Purpose: Give an agent the ability to search for research materials and fact-checking results that have been retrieved
+from other sources.
+
+### Perplexity (n8n-nodes-base.perplexityTool)
+
+Purpose: Give an agent the ability to search utilising Perplexity, a powerful tool for finding sources/material for
+generating reports and information.
+
+### HTML Extract (n8n-nodes-base.htmlExtract)
+
+Purpose: Parses HTML and extracts data using CSS selectors for web scraping
+
+Pitfalls:
+
+- Some sites use JavaScript to render content, which may not be accessible via simple HTTP requests. Consider using
+browser automation tools or APIs if the HTML appears empty
+- Validate that the CSS selectors match the actual page structure to avoid extraction failures
+
+### Split Out (n8n-nodes-base.splitOut)
+
+Purpose: Processes lists of items one by one for sequential operations
+
+Pitfalls:
+- Can cause performance issues with very large datasets - consider using Split In Batches instead
+
+### Loop Over Items (Split in Batches) (n8n-nodes-base.splitInBatches)
+
+Purpose: Processes lists of items in batches to manage memory and performance
+
+Pitfalls:
+- Ensure proper loop configuration to avoid infinite loops or skipped data. The index 0
+(first connection) of the loop is treated as the done state, while the index 1 (second connection)
+is the connection that loops.
+- Use appropriate batch sizes (e.g., 200 rows) to balance memory usage and performance
+
+### Edit Fields (Set) (n8n-nodes-base.set)
+
+Purpose: Manipulates data, sets variables for loop control and state management
+
+### Code (n8n-nodes-base.code)
+
+Purpose: Implements custom logic for complex data transformations or pagination
+
+Pitfalls:
+
+- Prefer built-in nodes over custom code to reduce memory usage and improve maintainability
+- Avoid processing very large datasets in a single code execution - use batching
+
+### If (n8n-nodes-base.if)
+
+Purpose: Adds conditional logic for error handling, loop control, or data filtering
+
+Pitfalls:
+- Validate expressions carefully to avoid unexpected branching behavior
+
+### Wait (n8n-nodes-base.wait)
+
+Purpose: Introduces delays to respect rate limits and avoid overloading servers
+
+### Data Tables (n8n-nodes-base.dataTable)
+
+Purpose: Stores scraped data in n8n's built-in persistent data storage
+
+### Google Sheets (n8n-nodes-base.googleSheets)
+
+Purpose: Stores scraped data in spreadsheets for easy access and sharing
+
+### Microsoft Excel 365 (n8n-nodes-base.microsoftExcel)
+
+Purpose: Stores scraped data in Excel files for offline analysis
+
+### Airtable (n8n-nodes-base.airtable)
+
+Purpose: Saves structured data to a database with rich data types and relationships
+
+### AI Agent (@n8n/n8n-nodes-langchain.agent)
+
+Purpose: For research, summarization, and advanced data extraction. AI agents can autonomously gather information
+from websites, analyze content, and organize findings into structured formats, integrating tools for web scraping,
+content analysis, and database storage
+
+### Scraping Nodes
+
+- Phantombuster (n8n-nodes-base.phantombuster)
+- Apify (use HTTP Request or community node)
+- BrightData (use HTTP Request or community node)
+
+Purpose: If the user wishes to scrap data from sites like LinkedIn, Facebook, Instagram, Twitter/X, Indeed, Glassdoor
+or any other service similar to these large providers it is better to use a node designed for this. The scraping
+nodes provide access to these datasets while avoiding issues like rate limiting or breaking terms of service for
+sites like these.
+
+## Common Pitfalls to Avoid
+
+Bad Request Errors: Double-check URL formatting, query parameters, and ensure all required fields are present to
+avoid 400 errors when making HTTP requests.
+
+Rate Limits: Use batching and Wait nodes to avoid 429 errors. When the service receives too many requests, implement
+batching to reduce request frequency or use the "Retry on Fail" feature.
+
+Memory Issues: Avoid processing very large datasets in a single run; use batching and increase server resources if
+needed. Use Split In Batches node to process 200 rows at a time, leverage built-in nodes instead of custom code, and
+increase execution timeouts via environment variables.
+
+Empty or Unexpected Data: Some sites use JavaScript to render content, which may not be accessible via simple HTTP
+requests. Standard HTTP and HTML parsing nodes fail because sites load data asynchronously via JavaScript, leaving the
+initial HTML empty of actual content. Web scraping nodes can be used to avoid this.
+`;
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.ScrapingAndResearchBestPractices = ScrapingAndResearchBestPractices;
+//# sourceMappingURL=scraping-and-research.js.map

package/dist/tools/best-practices/scraping-and-research.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scraping-and-research.js","sourceRoot":"","sources":["../../../src/tools/best-practices/scraping-and-research.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,gCAAgC;IACnC,SAAS,GAAG,kCAAiB,CAAC,qBAAqB,CAAC;IACpD,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmJjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AA5JD,4EA4JC"}

package/dist/tools/best-practices/triage.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../../types/best-practices';
+export declare class TriageBestPractices implements BestPracticesDocument {
+    readonly technique: "triage";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/tools/best-practices/triage.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriageBestPractices = void 0;
+const categorization_1 = require("../../types/categorization");
+class TriageBestPractices {
+    technique = categorization_1.WorkflowTechnique.TRIAGE;
+    version = '1.0.0';
+    documentation = `# Best Practices: Triage Workflows
+
+## Workflow Design
+
+Triage workflows automatically classify incoming data and route it based on priority or category. Common use cases include sorting support tickets by urgency, categorizing emails for follow-up, or scoring leads for sales routing.
+
+Define clear categories and outcomes before building. Design in logical stages:
+
+1. **Trigger & Input**: Capture incoming items (webhook, email trigger, form submission, schedule)
+2. **Preprocessing**: Fetch additional data if needed (CRM lookup, field normalization)
+3. **Classification**: Assign categories via rules or AI
+4. **Routing**: Direct items to appropriate branches using Switch node
+5. **Actions**: Execute category-specific tasks (create tasks, send alerts, update records)
+6. **Logging**: Track outcomes for monitoring and analysis
+
+CRITICAL: Always include a default/fallback path to catch unclassified items. Never allow data to drop silently.
+
+## Classification Strategies
+
+### Rule-Based Classification
+Use IF/Switch nodes for keyword detection, sender addresses, or numeric thresholds. Chain multiple conditions or use Switch for multi-way branching.
+
+Example: IF email contains "urgent" → High Priority branch
+
+### AI-Powered Classification
+For unstructured text or nuanced decisions, use AI nodes with clear prompts and defined output labels.
+
+Example prompt: "Classify this email as INTERESTED, NOT_INTERESTED, or QUESTION"
+
+Best practices:
+- Use structured output format (JSON with specific fields)
+- Set low temperature (0-0.2) for consistency
+- Include few-shot examples for accuracy
+- Implement error handling for unexpected outputs
+
+## Routing & Branching
+
+Use Switch node as primary traffic controller:
+- Configure cases for each classification value
+- Always define Default case for unexpected values
+- Each item follows exactly one branch
+- Keep branches modular using Execute Workflow node for complex logic
+
+Avoid parallel IF nodes that could match multiple conditions - use Switch or chain IF nodes with Execute Once setting.
+
+## Recommended Nodes
+
+### Trigger Nodes
+
+**Webhook** (n8n-nodes-base.webhook):
+- Purpose: Capture incoming items for triage via HTTP requests
+- Best for: Form submissions, webhook integrations
+
+**Gmail Trigger** (n8n-nodes-base.gmailTrigger):
+- Purpose: Automatically process new emails
+- Best for: Email-based triage workflows
+
+**Schedule Trigger** (n8n-nodes-base.scheduleTrigger):
+- Purpose: Periodic batch processing of items
+- Best for: Regular review of database records or API data
+
+### Classification Nodes
+
+**IF** (n8n-nodes-base.if):
+- Purpose: Simple binary decisions
+- Use when: Two-way branching based on conditions
+- Example: Check if priority field equals "high"
+
+**Switch** (n8n-nodes-base.switch):
+- Purpose: Multi-way branching based on field values
+- Use when: Multiple categories (3+ outcomes)
+- CRITICAL: Always configure Default output for unmatched items
+
+**OpenAI** (@n8n/n8n-nodes-langchain.openAi):
+- Purpose: AI-powered text classification
+- Best practices:
+  - Use structured output format
+  - Set low temperature (0-0.2) for consistency
+  - Include few-shot examples
+
+**AI Agent** (@n8n/n8n-nodes-langchain.agent):
+- Purpose: Complex classification requiring multiple steps or tool use
+- Use when: Classification needs context lookup or multi-step reasoning
+
+### Data Processing
+
+**Set** (n8n-nodes-base.set):
+- Purpose: Normalize fields, add metadata, store classification results
+- Use early: Standardize incoming data structure
+
+**Function** (n8n-nodes-base.function):
+- Purpose: Custom classification logic using JavaScript
+- Use when: Complex rules that can't be expressed in IF/Switch
+
+**HTTP Request** (n8n-nodes-base.httpRequest):
+- Purpose: Fetch additional context (CRM data, user history)
+- Use before: Classification to enrich decision context
+
+### Integration & Action Nodes
+
+**Slack** (n8n-nodes-base.slack):
+- Purpose: Send notifications, create channels by category
+- Example: Alert #urgent-tickets channel for high-priority items
+
+**HubSpot** (n8n-nodes-base.hubspot):
+- Purpose: Update contact records, create tasks, set lead scores
+- Example: Tag contacts based on classification
+
+**JIRA** (n8n-nodes-base.jira):
+- Purpose: Create issues with appropriate priority/assignee
+- Example: Auto-assign bugs to engineering team
+
+**Database Nodes**:
+- Postgres (n8n-nodes-base.postgres)
+- MySQL (n8n-nodes-base.mySql)
+- MongoDB (n8n-nodes-base.mongoDb)
+
+Purpose: Log triage outcomes, track metrics, store classification history
+
+**Google Sheets** (n8n-nodes-base.googleSheets):
+- Purpose: Simple logging and reporting
+- Example: Track daily triage volumes by category
+
+### Workflow Control
+
+**Execute Workflow** (n8n-nodes-base.executeWorkflow):
+- Purpose: Modular branch logic
+- Use when: Category-specific actions are complex
+- Pattern: Switch → Execute Workflow (per category)
+
+**Error Trigger** (n8n-nodes-base.errorTrigger):
+- Purpose: Catch and handle classification failures
+- CRITICAL: Always implement for production triage workflows
+
+**Merge** (n8n-nodes-base.merge):
+- Purpose: Consolidate branches for unified logging
+- Use after: Category-specific actions before final logging step
+
+## Common Pitfalls to Avoid
+
+### No Default Path
+**Problem**: Every Switch must have a Default output. Unmatched items should go to manual review or logging, never drop silently.
+
+**Solution**: Always configure Default case to route unclassified items to a fallback action (e.g., manual review queue, admin notification)
+
+### Overlapping Conditions
+**Problem**: Categories must be mutually exclusive. Items matching multiple conditions cause unpredictable routing.
+
+**Solution**:
+- Order checks from most specific to general
+- Use Switch with distinct values instead of multiple IF nodes
+- Test edge cases thoroughly
+
+### Costly API Overuse
+**Problem**: Calling AI APIs multiple times for same item wastes resources.
+
+**Solution**:
+- Use pin data feature during development
+- Classify each item only once, store result in variable for reuse
+- Enable caching where available
+- Batch similar items when possible
+
+### Missing Error Handling
+**Problem**: AI calls can fail or return unexpected formats, breaking the workflow.
+
+**Solution**:
+- Implement Error Trigger workflow to catch failures
+- Add validation after AI classification
+- Handle unexpected outputs gracefully with default categorization
+- Log all errors for review
+
+### Poor Documentation
+**Problem**: Generic node names make workflows hard to maintain.
+
+**Solution**:
+- Name nodes clearly (e.g., "Classify with OpenAI", "Route by Priority")
+- Use Sticky Notes for complex sections
+- Store constants in Set nodes or environment variables
+- Document classification criteria
+
+### Relying 100% on AI
+**Problem**: AI can misclassify critical items, leading to wrong actions.
+
+**Solution**:
+- For critical decisions, combine AI with rule validation
+- Monitor accuracy metrics
+- Implement human verification for high-risk categories
+- Use confidence thresholds to route uncertain items to manual review
+
+### No Monitoring
+**Problem**: Can't track accuracy, volume trends, or system health.
+
+**Solution**:
+- Log all triage outcomes to database/sheets
+- Track metrics: category volumes, error rates, processing times
+- Set up alerts for anomalies (e.g., sudden spike in unclassified items)
+- Review misclassifications regularly to improve rules/prompts
+`;
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.TriageBestPractices = TriageBestPractices;
+//# sourceMappingURL=triage.js.map

package/dist/tools/best-practices/triage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage.js","sourceRoot":"","sources":["../../../src/tools/best-practices/triage.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,mBAAmB;IACtB,SAAS,GAAG,kCAAiB,CAAC,MAAM,CAAC;IACrC,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqMjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AA9MD,kDA8MC"}

package/dist/tools/builder-tools.d.ts

@@ -0,0 +1,16 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { Logger } from '@n8n/backend-common';
+import type { INodeTypeDescription } from 'n8n-workflow';
+import type { BuilderTool, BuilderToolBase } from '../utils/stream-processor';
+import type { BuilderFeatureFlags } from '../workflow-builder-agent';
+export declare function getBuilderTools({ parsedNodeTypes, logger, llmComplexTask, instanceUrl, featureFlags, }: {
+    parsedNodeTypes: INodeTypeDescription[];
+    llmComplexTask: BaseChatModel;
+    logger?: Logger;
+    instanceUrl?: string;
+    featureFlags?: BuilderFeatureFlags;
+}): BuilderTool[];
+export declare function getBuilderToolsForDisplay({ nodeTypes, featureFlags, }: {
+    nodeTypes: INodeTypeDescription[];
+    featureFlags?: BuilderFeatureFlags;
+}): BuilderToolBase[];

package/dist/tools/builder-tools.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuilderTools = getBuilderTools;
+exports.getBuilderToolsForDisplay = getBuilderToolsForDisplay;
+const add_node_tool_1 = require("./add-node.tool");
+const categorize_prompt_tool_1 = require("./categorize-prompt.tool");
+const connect_nodes_tool_1 = require("./connect-nodes.tool");
+const get_best_practices_tool_1 = require("./get-best-practices.tool");
+const get_node_parameter_tool_1 = require("./get-node-parameter.tool");
+const get_workflow_examples_tool_1 = require("./get-workflow-examples.tool");
+const node_details_tool_1 = require("./node-details.tool");
+const node_search_tool_1 = require("./node-search.tool");
+const remove_connection_tool_1 = require("./remove-connection.tool");
+const remove_node_tool_1 = require("./remove-node.tool");
+const update_node_parameters_tool_1 = require("./update-node-parameters.tool");
+const validate_workflow_tool_1 = require("./validate-workflow.tool");
+function getBuilderTools({ parsedNodeTypes, logger, llmComplexTask, instanceUrl, featureFlags, }) {
+    const tools = [
+        (0, categorize_prompt_tool_1.createCategorizePromptTool)(llmComplexTask, logger),
+        (0, get_best_practices_tool_1.createGetBestPracticesTool)(),
+    ];
+    if (featureFlags?.templateExamples === true) {
+        tools.push((0, get_workflow_examples_tool_1.createGetWorkflowExamplesTool)(logger));
+    }
+    tools.push((0, node_search_tool_1.createNodeSearchTool)(parsedNodeTypes), (0, node_details_tool_1.createNodeDetailsTool)(parsedNodeTypes, logger), (0, add_node_tool_1.createAddNodeTool)(parsedNodeTypes), (0, connect_nodes_tool_1.createConnectNodesTool)(parsedNodeTypes, logger), (0, remove_connection_tool_1.createRemoveConnectionTool)(logger), (0, remove_node_tool_1.createRemoveNodeTool)(logger), (0, update_node_parameters_tool_1.createUpdateNodeParametersTool)(parsedNodeTypes, llmComplexTask, logger, instanceUrl), (0, get_node_parameter_tool_1.createGetNodeParameterTool)(), (0, validate_workflow_tool_1.createValidateWorkflowTool)(parsedNodeTypes, logger));
+    return tools;
+}
+function getBuilderToolsForDisplay({ nodeTypes, featureFlags, }) {
+    const tools = [categorize_prompt_tool_1.CATEGORIZE_PROMPT_TOOL, get_best_practices_tool_1.GET_BEST_PRACTICES_TOOL];
+    if (featureFlags?.templateExamples === true) {
+        tools.push(get_workflow_examples_tool_1.GET_WORKFLOW_EXAMPLES_TOOL);
+    }
+    tools.push(node_search_tool_1.NODE_SEARCH_TOOL, node_details_tool_1.NODE_DETAILS_TOOL, (0, add_node_tool_1.getAddNodeToolBase)(nodeTypes), connect_nodes_tool_1.CONNECT_NODES_TOOL, remove_connection_tool_1.REMOVE_CONNECTION_TOOL, remove_node_tool_1.REMOVE_NODE_TOOL, update_node_parameters_tool_1.UPDATING_NODE_PARAMETER_TOOL, get_node_parameter_tool_1.GET_NODE_PARAMETER_TOOL, validate_workflow_tool_1.VALIDATE_WORKFLOW_TOOL);
+    return tools;
+}
+//# sourceMappingURL=builder-tools.js.map

package/dist/tools/builder-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder-tools.js","sourceRoot":"","sources":["../../src/tools/builder-tools.ts"],"names":[],"mappings":";;AA0BA,0CAsCC;AAOD,8DA6BC;AA7FD,mDAAwE;AACxE,qEAA8F;AAC9F,6DAAkF;AAClF,uEAAgG;AAChG,uEAAgG;AAChG,6EAGsC;AACtC,2DAA+E;AAC/E,yDAA4E;AAC5E,qEAA8F;AAC9F,yDAA4E;AAC5E,+EAGuC;AACvC,qEAA8F;AAE9F,SAAgB,eAAe,CAAC,EAC/B,eAAe,EACf,MAAM,EACN,cAAc,EACd,WAAW,EACX,YAAY,GAOZ;IACA,MAAM,KAAK,GAAkB;QAC5B,IAAA,mDAA0B,EAAC,cAAc,EAAE,MAAM,CAAC;QAClD,IAAA,oDAA0B,GAAE;KAC5B,CAAC;IAIF,IAAI,YAAY,EAAE,gBAAgB,KAAK,IAAI,EAAE,CAAC;QAC7C,KAAK,CAAC,IAAI,CAAC,IAAA,0DAA6B,EAAC,MAAM,CAAC,CAAC,CAAC;IACnD,CAAC;IAGD,KAAK,CAAC,IAAI,CACT,IAAA,uCAAoB,EAAC,eAAe,CAAC,EACrC,IAAA,yCAAqB,EAAC,eAAe,EAAE,MAAM,CAAC,EAC9C,IAAA,iCAAiB,EAAC,eAAe,CAAC,EAClC,IAAA,2CAAsB,EAAC,eAAe,EAAE,MAAM,CAAC,EAC/C,IAAA,mDAA0B,EAAC,MAAM,CAAC,EAClC,IAAA,uCAAoB,EAAC,MAAM,CAAC,EAC5B,IAAA,4DAA8B,EAAC,eAAe,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,CAAC,EACpF,IAAA,oDAA0B,GAAE,EAC5B,IAAA,mDAA0B,EAAC,eAAe,EAAE,MAAM,CAAC,CACnD,CAAC;IAEF,OAAO,KAAK,CAAC;AACd,CAAC;AAOD,SAAgB,yBAAyB,CAAC,EACzC,SAAS,EACT,YAAY,GAIZ;IACA,MAAM,KAAK,GAAsB,CAAC,+CAAsB,EAAE,iDAAuB,CAAC,CAAC;IAInF,IAAI,YAAY,EAAE,gBAAgB,KAAK,IAAI,EAAE,CAAC;QAC7C,KAAK,CAAC,IAAI,CAAC,uDAA0B,CAAC,CAAC;IACxC,CAAC;IAGD,KAAK,CAAC,IAAI,CACT,mCAAgB,EAChB,qCAAiB,EACjB,IAAA,kCAAkB,EAAC,SAAS,CAAC,EAC7B,uCAAkB,EAClB,+CAAsB,EACtB,mCAAgB,EAChB,0DAA4B,EAC5B,iDAAuB,EACvB,+CAAsB,CACtB,CAAC;IAEF,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/tools/categorize-prompt.tool.d.ts

@@ -0,0 +1,5 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { Logger } from '@n8n/backend-common';
+import type { BuilderTool, BuilderToolBase } from '../utils/stream-processor';
+export declare const CATEGORIZE_PROMPT_TOOL: BuilderToolBase;
+export declare function createCategorizePromptTool(llm: BaseChatModel, logger?: Logger): BuilderTool;

package/dist/tools/categorize-prompt.tool.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATEGORIZE_PROMPT_TOOL = void 0;
+exports.createCategorizePromptTool = createCategorizePromptTool;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
+const prompt_categorization_1 = require("../chains/prompt-categorization");
+const errors_1 = require("../errors");
+const progress_1 = require("../tools/helpers/progress");
+const response_1 = require("../tools/helpers/response");
+const categorizePromptSchema = zod_1.z.object({
+    prompt: zod_1.z.string().min(1).describe('The user prompt to categorize'),
+});
+function buildCategorizationMessage(categorization) {
+    const parts = [];
+    parts.push('Prompt categorized');
+    if (categorization.techniques.length > 0) {
+        parts.push(`- Techniques: ${categorization.techniques.join(', ')}`);
+    }
+    if (categorization.confidence !== undefined) {
+        parts.push(`- Confidence: ${(categorization.confidence * 100).toFixed(0)}%`);
+    }
+    return parts.join('\n');
+}
+exports.CATEGORIZE_PROMPT_TOOL = {
+    toolName: 'categorize_prompt',
+    displayTitle: 'Categorizing prompt',
+};
+function createCategorizePromptTool(llm, logger) {
+    const dynamicTool = (0, tools_1.tool)(async (input, config) => {
+        const reporter = (0, progress_1.createProgressReporter)(config, exports.CATEGORIZE_PROMPT_TOOL.toolName, exports.CATEGORIZE_PROMPT_TOOL.displayTitle);
+        try {
+            const validatedInput = categorizePromptSchema.parse(input);
+            const { prompt } = validatedInput;
+            reporter.start(validatedInput);
+            logger?.debug('Categorizing user prompt using LLM...');
+            reporter.progress('Analyzing prompt to identify use case and techniques...');
+            const categorization = await (0, prompt_categorization_1.promptCategorizationChain)(llm, prompt);
+            logger?.debug('Prompt categorized', {
+                techniques: categorization.techniques,
+                confidence: categorization.confidence,
+            });
+            const output = {
+                categorization,
+            };
+            reporter.complete(output);
+            return (0, response_1.createSuccessResponse)(config, buildCategorizationMessage(categorization), {
+                categorization,
+                techniqueCategories: categorization.techniques,
+            });
+        }
+        catch (error) {
+            if (error instanceof zod_1.z.ZodError) {
+                const validationError = new errors_1.ValidationError('Invalid input parameters', {
+                    extra: { errors: error.errors },
+                });
+                reporter.error(validationError);
+                return (0, response_1.createErrorResponse)(config, validationError);
+            }
+            const toolError = new errors_1.ToolExecutionError(error instanceof Error ? error.message : 'Unknown error occurred', {
+                toolName: exports.CATEGORIZE_PROMPT_TOOL.toolName,
+                cause: error instanceof Error ? error : undefined,
+            });
+            reporter.error(toolError);
+            return (0, response_1.createErrorResponse)(config, toolError);
+        }
+    }, {
+        name: exports.CATEGORIZE_PROMPT_TOOL.toolName,
+        description: `Categorize a user's workflow request to identify the use case and required techniques.
+
+This helps understand what type of workflow the user wants to build and which automation patterns will be needed.
+
+Use this tool when you receive an initial workflow request to:
+- Detect required techniques (e.g., scraping, data transformation, notifications)
+- Better understand the user's needs and context
+
+The categorization allows retrieving relevant best practice documentation to improve workflow structure and node selection.`,
+        schema: categorizePromptSchema,
+    });
+    return {
+        tool: dynamicTool,
+        ...exports.CATEGORIZE_PROMPT_TOOL,
+    };
+}
+//# sourceMappingURL=categorize-prompt.tool.js.map

package/dist/tools/categorize-prompt.tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"categorize-prompt.tool.js","sourceRoot":"","sources":["../../src/tools/categorize-prompt.tool.ts"],"names":[],"mappings":"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"}

package/dist/tools/connect-nodes.tool.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from '@n8n/backend-common';
+import { type INodeTypeDescription } from 'n8n-workflow';
+import { z } from 'zod';
+import type { BuilderTool, BuilderToolBase } from '../utils/stream-processor';
+export declare const nodeConnectionSchema: z.ZodObject<{
+    sourceNodeId: z.ZodString;
+    targetNodeId: z.ZodString;
+    sourceOutputIndex: z.ZodOptional<z.ZodNumber>;
+    targetInputIndex: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sourceNodeId: string;
+    targetNodeId: string;
+    sourceOutputIndex?: number | undefined;
+    targetInputIndex?: number | undefined;
+}, {
+    sourceNodeId: string;
+    targetNodeId: string;
+    sourceOutputIndex?: number | undefined;
+    targetInputIndex?: number | undefined;
+}>;
+export declare const CONNECT_NODES_TOOL: BuilderToolBase;
+export declare function createConnectNodesTool(nodeTypes: INodeTypeDescription[], logger?: Logger): BuilderTool;