n8n-nodes-comfyui-all 2.2.9 → 2.2.11

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 wwrs
+Copyright (c) 2025 wwrs
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -131,22 +131,74 @@ By default, the first output image/video uses `data` as the binary property name
 
 ## 🤖 AI Agent Integration
 
-Use ComfyUI as a tool in AI Agent workflows:
+Use ComfyUI as a tool in AI Agent workflows.
 
-1. Add an **AI Agent** node (e.g., OpenAI Conversational Agent)
-2. In the **Tools** section, add **ComfyUI**
-3. Configure the ComfyUI node parameters
-4. Start chatting!
+### Quick Setup
 
-**Example:**
+**Step 1: Create AI Agent**
+1. Add **OpenAI Conversational Agent** node
+2. Configure Chat Model (GPT-4/GPT-3.5)
+3. Add Memory (optional but recommended)
+
+**Step 2: Add ComfyUI Tool**
+1. Click AI Agent node
+2. In **Tools** section, click **+ Add Tool**
+3. Search and select **ComfyUI**
+4. Configure:
+   - **ComfyUI URL**: `http://127.0.0.1:8188`
+   - **Workflow JSON**: Your ComfyUI workflow (API format)
+   - **Node Parameters**: Configure text parameter override
+
+**Step 3: Start Chatting**
+Execute workflow and start conversing!
+
+### Example Conversations
+
+**Basic Image Generation:**
+
+**User:**
+```
+Generate a picture of a cute cat sitting on a fence
+```
+
+**AI:**
+```
+I'll generate that for you.
+[Executes ComfyUI with prompt: "a cute cat sitting on a fence"]
+Done! Here's the image.
+```
+
+**With Parameters:**
+
+**User:**
+```
+Create a cyberpunk city, size:1024x768, steps:30
 ```
-User: Generate a cute cat picture
 
-AI: I'll generate that for you using ComfyUI.
-    [Calls ComfyUI tool]
-    Done! Here's your cute cat picture.
+**Supported Parameters:**
+- `size:WIDTHxHEIGHT` - Image dimensions
+- `steps:N` - Sampling steps
+- `cfg:N` - CFG strength
+- `seed:N` - Random seed
+- `negative:TEXT` - Negative prompt
+
+**Negative Prompts:**
+
+**User:**
+```
+Draw a beautiful sunset, negative: blurry, low quality
 ```
 
+### Configuring Node Parameters for AI Agent
+
+In the ComfyUI node, configure parameter overrides:
+
+- **Node ID**: `6` (your CLIP text node)
+- **Parameter Mode**: Single Parameter
+- **Parameter Name**: `text`
+- **Type**: Text
+- **Value**: [Leave empty - AI Agent will fill this]
+
 ### Tool Mode Output Format
 
 When used as an AI Agent tool, ComfyUI returns both binary data and URL information:
@@ -167,7 +219,70 @@ When used as an AI Agent tool, ComfyUI returns both binary data and URL informat
 
 This ensures compatibility with both workflow mode (binary data) and tool mode (URLs for AI Agent).
 
-For detailed AI Agent usage, see [AI-AGENT-USAGE.md](AI-AGENT-USAGE.md).
+### Best Practices
+
+**1. Clear Prompts**
+
+**Good:** "Generate a landscape painting of mountains at sunset"
+
+**Bad:** "Make a picture"
+
+**2. Use Specific Parameters**
+
+**Good:** "Create a portrait, size:512x768, steps:25"
+
+**Bad:** "Create a high-quality portrait"
+
+**3. Negative Prompts**
+
+Always use negative prompts for better quality:
+
+```
+A beautiful landscape, negative: blurry, distorted, low quality
+```
+
+### Advanced Usage
+
+**Style Transfer:**
+
+**User:**
+```
+Transform this image to oil painting style
+```
+
+Setup:
+- Upload input image as binary data
+- Configure style parameters
+
+**Multi-Modal Workflows:**
+
+Combine ComfyUI with other tools:
+
+**User:**
+```
+Generate an image of a futuristic city, then write a poem about it
+```
+
+AI Agent:
+1. Calls ComfyUI to generate image
+2. Calls Chat Model to write poem
+3. Returns both results
+
+### Troubleshooting
+
+**AI Agent Doesn't Call ComfyUI**
+
+**Check:**
+1. ComfyUI tool added to Tools list?
+2. Workflow JSON configured?
+3. ComfyUI server running?
+
+**Images Don't Match Prompts**
+
+**Check:**
+1. Correct node ID (e.g., `6` for CLIP text)
+2. Parameter name matches workflow (`text`)
+3. Workflow uses dynamic text input
 
 ## 🔧 Configuration Reference
 

package/dist/agent-tools/ComfyUIAgentTool.d.ts

@@ -0,0 +1,62 @@
+/**
+ * ComfyUI Agent Tool - Custom Code Tool for n8n AI Agent
+ *
+ * This tool allows AI Agents to directly call ComfyUI API to generate images
+ *
+ * Usage:
+ * 1. Create a "Custom Code Tool" node in n8n
+ * 2. Copy this code into the JavaScript code box
+ * 3. Fill in the Description: Generates images using ComfyUI. Use this tool when the user asks to create, generate, or make images.
+ * 4. Add this tool to the tools list of the AI Agent node
+ */
+import { Workflow, ImageInfo, ParsedParameters, ToolInputOptions, ToolResult } from '../nodes/types';
+/**
+ * Cancel any ongoing ComfyUI workflow execution
+ * @returns {boolean} True if a request was cancelled, false if no request was in progress
+ */
+export declare function cancelComfyUIExecution(): boolean;
+/**
+ * Parse user input to extract image generation parameters
+ * @param query - User query text
+ * @returns Parsed parameters object
+ */
+declare function parseInput(query: string): ParsedParameters;
+/**
+ * Find node ID by node type
+ * @param workflow - Workflow object
+ * @param classType - Node type
+ * @returns Node ID or null
+ */
+declare function findNodeByClassType(workflow: Workflow, classType: string): string | null;
+/**
+ * Update workflow parameters
+ * @param workflow - ComfyUI workflow object
+ * @param params - Parameters object
+ * @returns Updated workflow
+ */
+declare function updateWorkflow(workflow: Workflow, params: ParsedParameters): Workflow;
+/**
+ * Extract image information from output nodes
+ * @param outputs - ComfyUI output object
+ * @param url - ComfyUI server URL
+ * @returns Array of image information
+ */
+declare function extractImagesFromOutputs(outputs: Record<string, unknown>, url: string): ImageInfo[];
+/**
+ * Process single image object
+ * @param image - Image object
+ * @param nodeId - Node ID
+ * @param url - ComfyUI server URL
+ * @returns Processed image information or null
+ */
+declare function processImage(image: unknown, nodeId: string, url: string): ImageInfo | null;
+/**
+ * Main function: Handle tool invocation
+ * @param query - User query text
+ * @param options - Optional configuration parameters
+ * @param options.comfyUiUrl - ComfyUI server URL
+ * @param options.workflowConfig - Workflow configuration options
+ */
+export declare function handleToolInput(query: string, options?: ToolInputOptions): Promise<ToolResult>;
+export { parseInput, updateWorkflow, findNodeByClassType, extractImagesFromOutputs, processImage };
+//# sourceMappingURL=ComfyUIAgentTool.d.ts.map

package/dist/agent-tools/ComfyUIAgentTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComfyUIAgentTool.d.ts","sourceRoot":"","sources":["../../agent-tools/ComfyUIAgentTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAGL,QAAQ,EACR,SAAS,EACT,gBAAgB,EAEhB,gBAAgB,EAChB,UAAU,EAGX,MAAM,gBAAgB,CAAC;AA0BxB;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAQhD;AA2ED;;;;GAIG;AACH,iBAAS,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CA4CnD;AAED;;;;;GAKG;AACH,iBAAS,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOjF;AAED;;;;;GAKG;AACH,iBAAS,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,GAAG,QAAQ,CAyC9E;AAED;;;;;GAKG;AACH,iBAAS,wBAAwB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,CA2B5F;AAED;;;;;;GAMG;AACH,iBAAS,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAsBnF;AA0ID;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,CA4CxG;AAaD,OAAO,EACL,UAAU,EACV,cAAc,EACd,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACb,CAAC"}

package/dist/agent-tools/ComfyUIAgentTool.js

@@ -0,0 +1,440 @@
+"use strict";
+/**
+ * ComfyUI Agent Tool - Custom Code Tool for n8n AI Agent
+ *
+ * This tool allows AI Agents to directly call ComfyUI API to generate images
+ *
+ * Usage:
+ * 1. Create a "Custom Code Tool" node in n8n
+ * 2. Copy this code into the JavaScript code box
+ * 3. Fill in the Description: Generates images using ComfyUI. Use this tool when the user asks to create, generate, or make images.
+ * 4. Add this tool to the tools list of the AI Agent node
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelComfyUIExecution = cancelComfyUIExecution;
+exports.handleToolInput = handleToolInput;
+exports.parseInput = parseInput;
+exports.updateWorkflow = updateWorkflow;
+exports.findNodeByClassType = findNodeByClassType;
+exports.extractImagesFromOutputs = extractImagesFromOutputs;
+exports.processImage = processImage;
+const crypto_1 = require("crypto");
+const workflowConfig_1 = require("../nodes/workflowConfig");
+const HttpClient_1 = require("../nodes/HttpClient");
+const AxiosAdapter_1 = require("../nodes/AxiosAdapter");
+const logger_1 = require("../nodes/logger");
+// Default configuration
+const DEFAULT_COMFYUI_URL = 'http://127.0.0.1:8188';
+// Request timeout configuration
+const QUEUE_REQUEST_TIMEOUT = 30000; // Queue request timeout 30 seconds
+const HISTORY_REQUEST_TIMEOUT = 10000; // History request timeout 10 seconds
+// Create logger instance
+const logger = new logger_1.Logger(undefined, ['ComfyUI Tool']);
+// Create HTTP client instance
+const httpClient = new HttpClient_1.HttpClient({
+    adapter: new AxiosAdapter_1.AxiosAdapter(),
+    logger,
+    defaultTimeout: QUEUE_REQUEST_TIMEOUT,
+});
+// Global AbortController for cancelling requests
+let currentAbortController = null;
+/**
+ * Cancel any ongoing ComfyUI workflow execution
+ * @returns {boolean} True if a request was cancelled, false if no request was in progress
+ */
+function cancelComfyUIExecution() {
+    if (currentAbortController) {
+        currentAbortController.abort();
+        currentAbortController = null;
+        logger.info('ComfyUI workflow execution cancelled');
+        return true;
+    }
+    return false;
+}
+// Parameter default values
+const DEFAULT_NEGATIVE_PROMPT = 'ugly, blurry, low quality, distorted';
+const DEFAULT_WIDTH = 512;
+const DEFAULT_HEIGHT = 512;
+const DEFAULT_STEPS = 20;
+const DEFAULT_CFG = 8;
+// Maximum random seed value (32-bit signed integer max value)
+const MAX_SEED_VALUE = 2147483647;
+// Polling configuration
+const POLLING_MAX_ATTEMPTS = 120; // Maximum wait time of 2 minutes (120 seconds)
+const POLLING_INTERVAL_MS = 1000; // Polling interval of 1 second
+/**
+ * Promise-based delay function
+ * @param ms - Delay time in milliseconds
+ * @returns Promise object
+ */
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// Parameter extraction rules configuration
+const PARAM_PATTERNS = {
+    negative: {
+        regex: /(?<=\s|,|，|^)negative:\s*([^\n]+)/i,
+        paramKey: 'negative_prompt',
+        parser: (match) => match[1].trim()
+    },
+    size: {
+        regex: /(?<=\s|,|，|^)size:\s*(\d+)x(\d+)/i,
+        paramKeys: ['width', 'height'],
+        parser: (match) => ({
+            width: parseInt(match[1]),
+            height: parseInt(match[2])
+        })
+    },
+    steps: {
+        regex: /(?<=\s|,|，|^)steps:\s*(\d+)/i,
+        paramKey: 'steps',
+        parser: (match) => parseInt(match[1])
+    },
+    cfg: {
+        regex: /(?<=\s|,|，|^)cfg:\s*([\d.]+)/i,
+        paramKey: 'cfg',
+        parser: (match) => parseFloat(match[1])
+    },
+    seed: {
+        regex: /(?<=\s|,|，|^)seed:\s*(\d+)/i,
+        paramKey: 'seed',
+        parser: (match) => parseInt(match[1])
+    }
+};
+/**
+ * Extract parameter from query
+ * @param query - User query text
+ * @param pattern - Parameter pattern configuration
+ * @returns Extracted parameter and cleaned query
+ */
+function extractParameter(query, pattern) {
+    const match = query.match(pattern.regex);
+    if (!match) {
+        return { value: null, cleanedQuery: query };
+    }
+    const value = pattern.parser(match);
+    const cleanedQuery = query.replace(pattern.regex, '').trim();
+    return { value, cleanedQuery };
+}
+/**
+ * Parse user input to extract image generation parameters
+ * @param query - User query text
+ * @returns Parsed parameters object
+ */
+function parseInput(query) {
+    const params = {
+        prompt: '',
+        negative_prompt: DEFAULT_NEGATIVE_PROMPT,
+        width: DEFAULT_WIDTH,
+        height: DEFAULT_HEIGHT,
+        steps: DEFAULT_STEPS,
+        cfg: DEFAULT_CFG,
+        seed: (0, crypto_1.randomInt)(0, MAX_SEED_VALUE)
+    };
+    let currentQuery = query.trim();
+    for (const [, pattern] of Object.entries(PARAM_PATTERNS)) {
+        const { value, cleanedQuery } = extractParameter(currentQuery, pattern);
+        if (value !== null) {
+            if (pattern.paramKeys) {
+                // Type guard: check if value is an object with keys
+                if (typeof value === 'object' && value !== null) {
+                    const valueRecord = value;
+                    const valueKeys = Object.keys(valueRecord);
+                    pattern.paramKeys.forEach((key, index) => {
+                        params[key] = valueRecord[valueKeys[index]];
+                    });
+                }
+            }
+            else if (pattern.paramKey) {
+                params[pattern.paramKey] = value;
+            }
+            currentQuery = cleanedQuery;
+        }
+    }
+    // Clean up remaining parameter markers and extra punctuation
+    currentQuery = currentQuery
+        .replace(/，\s*，/g, '，') // Remove consecutive Chinese commas
+        .replace(/,\s*,/g, ',') // Remove consecutive English commas
+        .replace(/[，,]\s*[，,]/g, ' ') // Remove extra spaces between commas
+        .replace(/^\s*[，,]+/g, '') // Remove all leading commas
+        .replace(/[，,]+\s*$/g, '') // Remove all trailing commas
+        .trim();
+    params.prompt = currentQuery;
+    return params;
+}
+/**
+ * Find node ID by node type
+ * @param workflow - Workflow object
+ * @param classType - Node type
+ * @returns Node ID or null
+ */
+function findNodeByClassType(workflow, classType) {
+    for (const nodeId in workflow) {
+        if (workflow[nodeId] && workflow[nodeId].class_type === classType) {
+            return nodeId;
+        }
+    }
+    return null;
+}
+/**
+ * Update workflow parameters
+ * @param workflow - ComfyUI workflow object
+ * @param params - Parameters object
+ * @returns Updated workflow
+ */
+function updateWorkflow(workflow, params) {
+    const updatedWorkflow = JSON.parse(JSON.stringify(workflow));
+    // Find and update positive and negative prompt nodes
+    const clipTextEncodeNodes = [];
+    for (const nodeId in updatedWorkflow) {
+        if (updatedWorkflow[nodeId] && updatedWorkflow[nodeId].class_type === 'CLIPTextEncode') {
+            clipTextEncodeNodes.push(nodeId);
+        }
+    }
+    if (clipTextEncodeNodes.length >= 1) {
+        updatedWorkflow[clipTextEncodeNodes[0]].inputs.text = params.prompt;
+    }
+    if (clipTextEncodeNodes.length >= 2) {
+        updatedWorkflow[clipTextEncodeNodes[1]].inputs.text = params.negative_prompt;
+    }
+    // Find and update image size node
+    const latentNodeId = findNodeByClassType(updatedWorkflow, 'EmptyLatentImage') ||
+        findNodeByClassType(updatedWorkflow, 'EmptySD3LatentImage');
+    if (latentNodeId && updatedWorkflow[latentNodeId].inputs) {
+        updatedWorkflow[latentNodeId].inputs.width = params.width;
+        updatedWorkflow[latentNodeId].inputs.height = params.height;
+    }
+    // Find and update sampling parameters node
+    const samplerNodeId = findNodeByClassType(updatedWorkflow, 'KSampler');
+    if (samplerNodeId && updatedWorkflow[samplerNodeId].inputs) {
+        updatedWorkflow[samplerNodeId].inputs.steps = params.steps;
+        updatedWorkflow[samplerNodeId].inputs.cfg = params.cfg;
+        updatedWorkflow[samplerNodeId].inputs.seed = params.seed;
+    }
+    // Find and update edit instruction node (for image editing workflows)
+    const primitiveNodeId = findNodeByClassType(updatedWorkflow, 'PrimitiveStringMultiline');
+    if (primitiveNodeId && updatedWorkflow[primitiveNodeId].inputs) {
+        updatedWorkflow[primitiveNodeId].inputs.value = params.prompt;
+    }
+    return updatedWorkflow;
+}
+/**
+ * Extract image information from output nodes
+ * @param outputs - ComfyUI output object
+ * @param url - ComfyUI server URL
+ * @returns Array of image information
+ */
+function extractImagesFromOutputs(outputs, url) {
+    const images = [];
+    for (const nodeId in outputs) {
+        const nodeOutput = outputs[nodeId];
+        if (!nodeOutput || typeof nodeOutput !== 'object') {
+            continue;
+        }
+        const nodeImages = nodeOutput.images;
+        if (!nodeImages) {
+            continue;
+        }
+        if (!Array.isArray(nodeImages) || nodeImages.length === 0) {
+            continue;
+        }
+        for (const image of nodeImages) {
+            const imageInfo = processImage(image, nodeId, url);
+            if (imageInfo) {
+                images.push(imageInfo);
+            }
+        }
+    }
+    return images;
+}
+/**
+ * Process single image object
+ * @param image - Image object
+ * @param nodeId - Node ID
+ * @param url - ComfyUI server URL
+ * @returns Processed image information or null
+ */
+function processImage(image, nodeId, url) {
+    if (!image || typeof image !== 'object') {
+        logger.warn(`Invalid image object in node ${nodeId}`);
+        return null;
+    }
+    const imageObj = image;
+    const filename = imageObj.filename;
+    const subfolder = imageObj.subfolder || '';
+    const type = imageObj.type || 'output';
+    if (!filename) {
+        logger.warn(`Image missing filename in node ${nodeId}`);
+        return null;
+    }
+    return {
+        filename: filename,
+        subfolder: subfolder,
+        type: type,
+        url: `${url}/view?filename=${filename}&subfolder=${subfolder}&type=${type}`
+    };
+}
+/**
+ * Execute ComfyUI workflow
+ * @param workflow - ComfyUI workflow object
+ * @param comfyUiUrl - ComfyUI server URL
+ * @param signal - Optional AbortSignal for cancelling the request
+ */
+async function executeComfyUIWorkflow(workflow, comfyUiUrl, signal) {
+    const url = comfyUiUrl || DEFAULT_COMFYUI_URL;
+    // Create new AbortController for this execution if not provided
+    const abortController = signal ? null : new AbortController();
+    const effectiveSignal = signal || abortController?.signal;
+    if (abortController) {
+        currentAbortController = abortController;
+    }
+    try {
+        // Check if already aborted
+        if (effectiveSignal?.aborted) {
+            throw new Error('Workflow execution was cancelled before starting');
+        }
+        // 1. Queue prompt
+        let promptResponse;
+        try {
+            promptResponse = await httpClient.post(`${url}/prompt`, {
+                prompt: workflow
+            }, {
+                timeout: QUEUE_REQUEST_TIMEOUT,
+                abortSignal: effectiveSignal,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === 'CanceledError' || effectiveSignal?.aborted) {
+                    throw new Error('Workflow execution was cancelled');
+                }
+                const httpError = error;
+                const errorCode = httpError.code;
+                if (errorCode === 'ECONNREFUSED') {
+                    throw new Error(`Failed to connect to ComfyUI server at ${url}. Please check if the server is running.`);
+                }
+                else if (errorCode === 'ETIMEDOUT' || errorCode === 'ECONNABORTED') {
+                    throw new Error(`Connection timeout while connecting to ComfyUI server at ${url}.`);
+                }
+                else if (httpError.response) {
+                    throw new Error(`ComfyUI server returned error: ${httpError.response.statusCode} ${httpError.response.statusMessage}`);
+                }
+                else {
+                    throw new Error(`Failed to queue workflow: ${error.message}`);
+                }
+            }
+            throw new Error(`Failed to queue workflow: ${String(error)}`);
+        }
+        if (!promptResponse || !promptResponse.prompt_id) {
+            throw new Error('Invalid response from ComfyUI server: missing prompt_id');
+        }
+        const promptId = promptResponse.prompt_id;
+        logger.info(`Workflow queued with ID: ${promptId}`);
+        // 2. Poll for results
+        let attempts = 0;
+        while (attempts < POLLING_MAX_ATTEMPTS) {
+            // Check if aborted before each polling attempt
+            if (effectiveSignal?.aborted) {
+                throw new Error('Workflow execution was cancelled');
+            }
+            await delay(POLLING_INTERVAL_MS);
+            // Check history
+            let historyResponse;
+            try {
+                historyResponse = await httpClient.get(`${url}/history/${promptId}`, {
+                    timeout: HISTORY_REQUEST_TIMEOUT,
+                    abortSignal: effectiveSignal,
+                });
+            }
+            catch (error) {
+                if (effectiveSignal?.aborted || (error instanceof Error && error.name === 'CanceledError')) {
+                    throw new Error('Workflow execution was cancelled');
+                }
+                const httpError = error instanceof Error ? error : undefined;
+                const errorCode = httpError?.code;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorCode === 'ECONNREFUSED') {
+                    throw new Error(`Lost connection to ComfyUI server at ${url}.`);
+                }
+                else if (errorCode === 'ETIMEDOUT' || errorCode === 'ECONNABORTED') {
+                    logger.warn(`Timeout checking history (attempt ${attempts + 1}/${POLLING_MAX_ATTEMPTS})`);
+                    attempts++;
+                    continue;
+                }
+                else {
+                    logger.warn(`Error checking history: ${errorMessage}`);
+                    attempts++;
+                    continue;
+                }
+            }
+            if (historyResponse && historyResponse[promptId]) {
+                const outputs = historyResponse[promptId].outputs;
+                if (outputs) {
+                    const images = extractImagesFromOutputs(outputs, url);
+                    if (images.length === 0) {
+                        throw new Error('Workflow completed but no images were generated');
+                    }
+                    return {
+                        success: true,
+                        prompt_id: promptId,
+                        images: images
+                    };
+                }
+            }
+            attempts++;
+        }
+        throw new Error(`Workflow execution timeout after ${POLLING_MAX_ATTEMPTS} seconds (prompt_id: ${promptId}). The workflow may still be running on ComfyUI server.`);
+    }
+    finally {
+        // Clean up AbortController
+        if (abortController) {
+            currentAbortController = null;
+        }
+    }
+}
+/**
+ * Main function: Handle tool invocation
+ * @param query - User query text
+ * @param options - Optional configuration parameters
+ * @param options.comfyUiUrl - ComfyUI server URL
+ * @param options.workflowConfig - Workflow configuration options
+ */
+async function handleToolInput(query, options = {}) {
+    try {
+        const { comfyUiUrl, workflowConfig } = options;
+        logger.info(`Received query: ${query}`);
+        if (comfyUiUrl) {
+            logger.info(`Using ComfyUI URL: ${comfyUiUrl}`);
+        }
+        // Parse input parameters
+        const params = parseInput(query);
+        logger.debug('Parsed parameters:', JSON.stringify(params, null, 2));
+        // Get workflow template from configuration
+        const workflowTemplate = (0, workflowConfig_1.getWorkflowTemplate)(workflowConfig);
+        // Update workflow
+        const workflow = updateWorkflow(workflowTemplate, params);
+        // Execute workflow
+        const result = await executeComfyUIWorkflow(workflow, comfyUiUrl);
+        logger.info(`Generated ${result.images.length} image(s)`);
+        // Return result
+        return {
+            success: true,
+            message: `Successfully generated ${result.images.length} image(s) with prompt: "${params.prompt}"`,
+            data: {
+                prompt: params.prompt,
+                images: result.images.map(img => img.url),
+                parameters: params
+            }
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error('Error:', errorMessage);
+        return {
+            success: false,
+            error: errorMessage,
+            message: `Failed to generate image: ${errorMessage}`
+        };
+    }
+}
+//# sourceMappingURL=ComfyUIAgentTool.js.map