n8n-nodes-comfyui-all 2.2.24 → 2.3.1

package/dist/nodes/ComfyUiTool/ComfyUiTool.node.d.ts

@@ -29,6 +29,12 @@ export declare class ComfyUiTool {
         notes: string[];
         inputSample: {
             query: string;
+            parameters: {
+                seed: number;
+                steps: number;
+                width: number;
+                height: number;
+            };
         };
         outputSample: {
             json: {
@@ -45,13 +51,6 @@ export declare class ComfyUiTool {
                     seed: number;
                 };
             };
-            binary: {
-                data: {
-                    data: string;
-                    mimeType: string;
-                    fileName: string;
-                };
-            };
         };
         properties: ({
             displayName: string;
@@ -62,8 +61,10 @@ export declare class ComfyUiTool {
             description: string;
             minValue?: undefined;
             maxValue?: undefined;
+            typeOptions?: undefined;
+            validate?: undefined;
             placeholder?: undefined;
-            options?: undefined;
+            displayOptions?: undefined;
         } | {
             displayName: string;
             name: string;
@@ -73,55 +74,84 @@ export declare class ComfyUiTool {
             minValue: number;
             maxValue: number;
             required?: undefined;
+            typeOptions?: undefined;
+            validate?: undefined;
             placeholder?: undefined;
-            options?: undefined;
+            displayOptions?: undefined;
         } | {
             displayName: string;
             name: string;
             type: string;
+            required: boolean;
+            typeOptions: {
+                rows: number;
+                loadOptionsMethod?: undefined;
+            };
             default: string;
             description: string;
+            validate: (parameterValue: string) => Promise<string | undefined>;
+            minValue?: undefined;
+            maxValue?: undefined;
+            placeholder?: undefined;
+            displayOptions?: undefined;
+        } | {
+            displayName: string;
+            name: string;
+            type: string;
+            description: string;
+            typeOptions: {
+                loadOptionsMethod: string;
+                rows?: undefined;
+            };
             placeholder: string;
+            default: string;
             required?: undefined;
             minValue?: undefined;
             maxValue?: undefined;
-            options?: undefined;
+            validate?: undefined;
+            displayOptions?: undefined;
         } | {
             displayName: string;
             name: string;
             type: string;
+            description: string;
+            typeOptions: {
+                loadOptionsMethod: string;
+                rows?: undefined;
+            };
             placeholder: string;
-            default: {};
-            options: ({
-                displayName: string;
-                name: string;
-                type: string;
-                typeOptions: {
-                    rows: number;
+            default: never[];
+            displayOptions: {
+                show: {
+                    nodeId: (string | null | undefined)[];
+                    mode: string;
                 };
-                default: string;
-                description: string;
-                minValue?: undefined;
-                maxValue?: undefined;
-            } | {
-                displayName: string;
-                name: string;
-                type: string;
-                default: number;
-                description: string;
-                minValue: number;
-                maxValue: number;
-                typeOptions?: undefined;
-            })[];
+            };
             required?: undefined;
-            description?: undefined;
             minValue?: undefined;
             maxValue?: undefined;
+            validate?: undefined;
         })[];
     };
     /**
      * Execute function - called when the node runs
      */
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+    /**
+     * Load all nodes from workflow JSON for Node ID dropdown
+     */
+    getWorkflowNodes(this: IExecuteFunctions): Promise<{
+        name: string;
+        value: string;
+        description?: string;
+    }[]>;
+    /**
+     * Load parameters for a specific node for Allowed Parameters multi-select
+     */
+    getNodeParameters(this: IExecuteFunctions): Promise<{
+        name: string;
+        value: string;
+        description?: string;
+    }[]>;
 }
 //# sourceMappingURL=ComfyUiTool.node.d.ts.map

package/dist/nodes/ComfyUiTool/ComfyUiTool.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComfyUiTool.node.d.ts","sourceRoot":"","sources":["../../../nodes/ComfyUiTool/ComfyUiTool.node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAEnB,MAAM,cAAc,CAAC;AAgBtB,qBAAa,WAAW;IACtB;;OAEG;IACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2IT;IAEF;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC;CAiLxE"}
+{"version":3,"file":"ComfyUiTool.node.d.ts","sourceRoot":"","sources":["../../../nodes/ComfyUiTool/ComfyUiTool.node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAEnB,MAAM,cAAc,CAAC;AAiBtB,qBAAa,WAAW;IACtB;;OAEG;IACH,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA+E4B,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuD3C;IAEF;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC;IA+OvE;;OAEG;IACG,gBAAgB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAmCjH;;OAEG;IACG,iBAAiB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAsDnH"}

package/dist/nodes/ComfyUiTool/ComfyUiTool.node.js

@@ -13,7 +13,6 @@ const ComfyUiClient_1 = require("../ComfyUiClient");
 const validation_1 = require("../validation");
 const logger_1 = require("../logger");
 const agentToolHelpers_1 = require("../agentToolHelpers");
-const workflowConfig_1 = require("../workflowConfig");
 class ComfyUiTool {
     constructor() {
         /**
@@ -36,14 +35,23 @@ class ComfyUiTool {
             outputs: ['main'],
             subtitle: 'AI Image Generator',
             notes: [
-                'Optimized for AI Agent usage',
-                'Automatically detects and handles both text-to-image and image-to-image',
-                'For image editing: pass image binary + text description',
-                'Supports size, steps, cfg, seed, and negative prompt parameters',
-                'Examples: "A beautiful sunset, size:1024x768, steps:30"',
+                'AI Agent-friendly ComfyUI tool',
+                'Requires ComfyUI workflow JSON in API format',
+                'Export workflow: ComfyUI Menu > Export > API Format',
+                'Supports both text-to-image and image-to-image workflows',
+                'Configure which node/parameters AI can modify using "Node ID" and "Allowed Parameters"',
+                'AI Agent provides: { query: "...", parameters: { seed: 123456, steps: 30 } }',
+                'Only parameters in "Allowed Parameters" list will be applied',
+                'Legacy format supported: "A sunset, size:1024x768, steps:30"',
             ],
             inputSample: {
                 query: 'A beautiful landscape painting',
+                parameters: {
+                    seed: 123456,
+                    steps: 30,
+                    width: 1024,
+                    height: 768,
+                },
             },
             outputSample: {
                 json: {
@@ -53,18 +61,11 @@ class ComfyUiTool {
                     prompt: 'A beautiful landscape painting',
                     mode: 'text-to-image',
                     parameters: {
-                        width: 512,
-                        height: 512,
-                        steps: 20,
+                        width: 1024,
+                        height: 768,
+                        steps: 30,
                         cfg: 8,
-                        seed: 123456789,
-                    },
-                },
-                binary: {
-                    data: {
-                        data: 'base64_encoded_image_data',
-                        mimeType: 'image/png',
-                        fileName: 'ComfyUI_00001.png',
+                        seed: 123456,
                     },
                 },
             },
@@ -87,75 +88,63 @@ class ComfyUiTool {
                     maxValue: 600,
                 },
                 {
-                    displayName: 'Output Binary Key',
-                    name: 'outputBinaryKey',
+                    displayName: 'Workflow JSON',
+                    name: 'workflowJson',
                     type: 'string',
-                    default: 'data',
-                    description: 'Property name for the output binary data (e.g., "data", "image", "output")',
-                    placeholder: 'data',
+                    required: true,
+                    typeOptions: {
+                        rows: 20,
+                    },
+                    default: '',
+                    description: 'ComfyUI workflow JSON in API format. Export your workflow from ComfyUI (Menu > Export > API Format) and paste here.',
+                    validate: async (parameterValue) => {
+                        if (!parameterValue || parameterValue.trim().length === 0) {
+                            // eslint-disable-next-line n8n-nodes-base/node-execute-block-wrong-error-thrown
+                            throw new Error('Workflow JSON is required');
+                        }
+                        const validation = (0, validation_1.validateComfyUIWorkflowEnhanced)(parameterValue);
+                        if (!validation.valid) {
+                            // eslint-disable-next-line n8n-nodes-base/node-execute-block-wrong-error-thrown
+                            throw new Error(validation.error || 'Invalid workflow format');
+                        }
+                        if (validation.warnings && validation.warnings.length > 0) {
+                            const warningMessage = 'Workflow validation warnings:\n' +
+                                validation.warnings.map((w, i) => `${i + 1}. ${w}`).join('\n') +
+                                '\n\nSuggestions:\n' +
+                                (validation.suggestions?.map((s, i) => `${i + 1}. ${s}`).join('\n') || '');
+                            // Return warning message (doesn't block save, but shows warning)
+                            return warningMessage;
+                        }
+                        return undefined;
+                    },
                 },
                 {
-                    displayName: 'Default Negative Prompt',
-                    name: 'defaultNegativePrompt',
-                    type: 'string',
-                    default: 'ugly, blurry, low quality, distorted',
-                    description: 'Default negative prompt to use when not specified in query',
-                    placeholder: 'ugly, blurry, low quality',
+                    displayName: 'Node Name or ID',
+                    name: 'nodeId',
+                    type: 'options',
+                    description: 'Select a node from your workflow. AI will be able to modify parameters of this node. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    typeOptions: {
+                        loadOptionsMethod: 'getWorkflowNodes',
+                    },
+                    placeholder: 'Select a node to configure AI-accessible parameters...',
+                    default: '',
                 },
                 {
-                    displayName: 'Advanced Options',
-                    name: 'advancedOptions',
-                    type: 'collection',
-                    placeholder: 'Add Option',
-                    default: {},
-                    options: [
-                        {
-                            displayName: 'Custom Workflow JSON',
-                            name: 'customWorkflow',
-                            type: 'string',
-                            typeOptions: {
-                                rows: 20,
-                            },
-                            default: '',
-                            description: 'Optional: Custom ComfyUI workflow JSON (API Format). If empty, uses default workflow. Only use this if you want to override the default template.',
-                        },
-                        {
-                            displayName: 'Default CFG',
-                            name: 'defaultCfg',
-                            type: 'number',
-                            default: 8,
-                            description: 'Default CFG scale when not specified in query',
-                            minValue: 1,
-                            maxValue: 30,
-                        },
-                        {
-                            displayName: 'Default Height',
-                            name: 'defaultHeight',
-                            type: 'number',
-                            default: 512,
-                            description: 'Default image height when not specified in query',
-                            minValue: 64,
-                            maxValue: 4096,
-                        },
-                        {
-                            displayName: 'Default Steps',
-                            name: 'defaultSteps',
-                            type: 'number',
-                            default: 20,
-                            description: 'Default sampling steps when not specified in query',
-                            minValue: 1,
-                            maxValue: 150,
-                        },
-                        {
-                            displayName: 'Default Width',
-                            name: 'defaultWidth',
-                            type: 'number',
-                            default: 512,
-                            description: 'Default image width when not specified in query',
-                            minValue: 64,
-                            maxValue: 4096,
+                    displayName: 'Allowed Parameter Names or IDs',
+                    name: 'allowedParameters',
+                    type: 'multiOptions',
+                    description: 'Select which parameters of this node AI can modify. Parameters will be loaded from the selected node. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                    typeOptions: {
+                        loadOptionsMethod: 'getNodeParameters',
+                    },
+                    placeholder: 'Select parameters...',
+                    default: [],
+                    displayOptions: {
+                        show: {
+                            nodeId: ['', null, undefined],
+                            mode: 'invert',
                         },
-                    ],
+                    },
                 },
             ],
         };
@@ -168,16 +157,15 @@ class ComfyUiTool {
         // Get node parameters
         const comfyUiUrl = this.getNodeParameter('comfyUiUrl', 0);
         const timeout = this.getNodeParameter('timeout', 0);
-        const outputBinaryKey = this.getNodeParameter('outputBinaryKey', 0);
-        const defaultNegativePrompt = this.getNodeParameter('defaultNegativePrompt', 0);
-        const advancedOptions = this.getNodeParameter('advancedOptions', 0);
-        const { customWorkflow = '', defaultWidth = 512, defaultHeight = 512, defaultSteps = 20, defaultCfg = 8, } = advancedOptions || {};
+        const workflowJson = this.getNodeParameter('workflowJson', 0);
         // Validate URL
         if (!(0, validation_1.validateUrl)(comfyUiUrl)) {
             throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid ComfyUI URL. Must be a valid HTTP/HTTPS URL.');
         }
-        // Validate output binary key
-        (0, validation_1.validateOutputBinaryKey)(outputBinaryKey);
+        // Validate workflow JSON
+        if (!workflowJson || workflowJson.trim().length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Workflow JSON is required. Please export your ComfyUI workflow (Menu > Export > API Format) and paste it in the "Workflow JSON" field.');
+        }
         // Get input data
         const inputData = this.getInputData();
         if (!inputData || inputData.length === 0) {
@@ -195,32 +183,83 @@ class ComfyUiTool {
         if (!query || query.trim().length === 0) {
             throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No query found in input. Please provide a "query", "text", or "prompt" field with a description of the image you want to generate.');
         }
-        // Determine mode based on input
-        const mode = hasInputImage ? 'image-to-image' : 'text-to-image';
-        logger.info('Processing image generation request', { query, comfyUiUrl, timeout, mode });
-        // Parse the query to extract parameters
-        const params = (0, agentToolHelpers_1.parseInput)(query, {
-            negativePrompt: defaultNegativePrompt,
-            width: defaultWidth,
-            height: defaultHeight,
-            steps: defaultSteps,
-            cfg: defaultCfg,
-        });
-        logger.debug('Parsed parameters', {
-            prompt: params.prompt,
-            width: params.width,
-            height: params.height,
-            steps: params.steps,
-            cfg: params.cfg,
-            seed: params.seed,
-        });
-        // Get workflow template
+        // Parse workflow JSON (already validated in parameter validation)
         let workflowTemplate;
-        if (customWorkflow && customWorkflow.trim().length > 0) {
-            workflowTemplate = (0, validation_1.safeJsonParse)(customWorkflow, 'Custom workflow JSON');
+        try {
+            workflowTemplate = (0, validation_1.safeJsonParse)(workflowJson, 'Workflow JSON');
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid Workflow JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Check if structured parameters are provided
+        const structuredParams = firstItem.json.parameters;
+        // Get node configuration (which node/parameters AI can modify)
+        const configuredNodeId = this.getNodeParameter('nodeId', 0);
+        const allowedParams = this.getNodeParameter('allowedParameters', 0) || [];
+        let params;
+        let workflow = workflowTemplate;
+        let usedStructuredParams = false;
+        if (structuredParams && typeof structuredParams === 'object' && Object.keys(structuredParams).length > 0) {
+            // Use structured parameters from AI Agent
+            logger.info('Using structured parameters from input', { parameters: structuredParams });
+            // Filter parameters based on allowed list
+            let filteredParams = structuredParams;
+            if (configuredNodeId && allowedParams.length > 0) {
+                filteredParams = {};
+                for (const paramName of allowedParams) {
+                    if (paramName in structuredParams) {
+                        filteredParams[paramName] = structuredParams[paramName];
+                    }
+                }
+                logger.info('Filtered parameters based on allowed list', {
+                    configuredNodeId,
+                    allowedParams,
+                    filteredParams,
+                });
+            }
+            // Convert structured parameters to ParsedParameters format
+            // Use filteredParams when available to ensure response only includes allowed parameters
+            const sourceParams = (configuredNodeId && allowedParams.length > 0) ? filteredParams : structuredParams;
+            params = {
+                prompt: query,
+                negative_prompt: sourceParams.negative_prompt ||
+                    sourceParams.negative ||
+                    structuredParams.negative_prompt ||
+                    structuredParams.negative ||
+                    'ugly, blurry, low quality, distorted',
+                width: sourceParams.width || 512,
+                height: sourceParams.height || 512,
+                steps: sourceParams.steps || 20,
+                cfg: sourceParams.cfg || 8,
+                seed: sourceParams.seed || Math.floor(Math.random() * 2147483647),
+            };
+            // Apply filtered parameters to the configured node
+            if (configuredNodeId && Object.keys(filteredParams).length > 0) {
+                workflow = (0, agentToolHelpers_1.applyParametersToNode)(workflowTemplate, configuredNodeId, filteredParams);
+                usedStructuredParams = true;
+                logger.debug('Applied filtered parameters to configured node', {
+                    nodeId: configuredNodeId,
+                    params: filteredParams,
+                });
+            }
+            else if (Object.keys(structuredParams).length > 0) {
+                // Fallback to old behavior if no node configured
+                workflow = (0, agentToolHelpers_1.applyStructuredParameters)(workflowTemplate, structuredParams);
+                usedStructuredParams = true;
+                logger.debug('Applied structured parameters (auto-mapped)', structuredParams);
+            }
         }
         else {
-            workflowTemplate = (0, workflowConfig_1.getWorkflowTemplate)({ mode });
+            // Parse the query to extract parameters (legacy behavior)
+            params = (0, agentToolHelpers_1.parseInput)(query);
+            logger.debug('Parsed parameters from query', {
+                prompt: params.prompt,
+                width: params.width,
+                height: params.height,
+                steps: params.steps,
+                cfg: params.cfg,
+                seed: params.seed,
+            });
         }
         // Create ComfyUI client
         const client = new ComfyUiClient_1.ComfyUIClient({
@@ -251,8 +290,11 @@ class ComfyUiTool {
                 uploadedImageFilename = await client.uploadImage(buffer, binaryData.fileName || 'input_image.png');
                 logger.info('Successfully uploaded input image', { filename: uploadedImageFilename });
             }
-            // Update workflow with parsed parameters
-            let workflow = (0, agentToolHelpers_1.updateWorkflow)(workflowTemplate, params);
+            // Update workflow with parsed parameters (only in legacy mode)
+            // Skip if structured parameters were already applied
+            if (!usedStructuredParams) {
+                workflow = (0, agentToolHelpers_1.updateWorkflow)(workflow, params);
+            }
             // If we uploaded an image, update workflow with the image filename
             if (uploadedImageFilename) {
                 workflow = (0, agentToolHelpers_1.updateWorkflowWithImage)(workflow, uploadedImageFilename);
@@ -263,13 +305,24 @@ class ComfyUiTool {
                 logger.error('Workflow execution failed', result.error);
                 throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to generate image: ${result.error}`);
             }
-            // Process results
-            const { json, binary } = await client.processResults(result, outputBinaryKey);
-            // Add metadata to JSON output
+            // Only return URLs without downloading (for AI Agent)
+            // Fix URL concatenation to handle trailing/leading slashes
+            const baseUrl = comfyUiUrl.endsWith('/') ? comfyUiUrl.slice(0, -1) : comfyUiUrl;
+            const imageUrls = result.images ? result.images.map(img => {
+                const imagePath = img.startsWith('/') ? img : `/${img}`;
+                return `${baseUrl}${imagePath}`;
+            }) : [];
+            const videoUrls = result.videos ? result.videos.map(vid => {
+                const videoPath = vid.startsWith('/') ? vid : `/${vid}`;
+                return `${baseUrl}${videoPath}`;
+            }) : [];
             const enhancedJson = {
-                ...json,
+                success: true,
+                imageUrls,
+                videoUrls,
+                imageCount: result.images?.length || 0,
+                videoCount: result.videos?.length || 0,
                 prompt: params.prompt,
-                mode: mode,
                 parameters: {
                     width: params.width,
                     height: params.height,
@@ -280,10 +333,10 @@ class ComfyUiTool {
                 },
             };
             logger.info('Image generation completed successfully', {
-                imageCount: json.imageCount,
-                mode,
+                imageCount: enhancedJson.imageCount,
             });
-            return [this.helpers.constructExecutionMetaData([{ json: enhancedJson, binary }], { itemData: { item: 0 } })];
+            // Return result (no binary data for AI Agent)
+            return [this.helpers.constructExecutionMetaData([{ json: enhancedJson }], { itemData: { item: 0 } })];
         }
         catch (error) {
             logger.error('Error during workflow execution', error);
@@ -294,6 +347,89 @@ class ComfyUiTool {
             logger.debug('Client destroyed');
         }
     }
+    /**
+     * Load all nodes from workflow JSON for Node ID dropdown
+     */
+    async getWorkflowNodes() {
+        try {
+            const workflowJson = this.getNodeParameter('workflowJson', 0);
+            if (!workflowJson || workflowJson.trim().length === 0) {
+                return [];
+            }
+            const workflow = (0, validation_1.safeJsonParse)(workflowJson, 'Workflow JSON');
+            const nodes = [];
+            for (const [nodeId, nodeData] of Object.entries(workflow)) {
+                if (nodeData && nodeData.class_type) {
+                    nodes.push({
+                        name: `${nodeId} - ${nodeData.class_type}`,
+                        value: nodeId,
+                        description: nodeData.class_type,
+                    });
+                }
+            }
+            // Sort by node ID (numeric)
+            nodes.sort((a, b) => {
+                const aNum = parseInt(a.value);
+                const bNum = parseInt(b.value);
+                return aNum - bNum;
+            });
+            return nodes;
+        }
+        catch (error) {
+            // Silently return empty array on error
+            return [];
+        }
+    }
+    /**
+     * Load parameters for a specific node for Allowed Parameters multi-select
+     */
+    async getNodeParameters() {
+        try {
+            const workflowJson = this.getNodeParameter('workflowJson', 0);
+            const nodeId = this.getNodeParameter('nodeId', 0);
+            if (!workflowJson || workflowJson.trim().length === 0 || !nodeId) {
+                return [];
+            }
+            const workflow = (0, validation_1.safeJsonParse)(workflowJson, 'Workflow JSON');
+            const nodeData = workflow[nodeId];
+            if (!nodeData || !nodeData.inputs) {
+                return [];
+            }
+            const parameters = [];
+            for (const [paramName, paramValue] of Object.entries(nodeData.inputs)) {
+                // Skip array values (these are connections to other nodes)
+                if (Array.isArray(paramValue)) {
+                    continue;
+                }
+                // Auto-detect type for display
+                let detectedType = 'text';
+                if (paramName.toLowerCase().includes('image') || paramName.toLowerCase().includes('upload')) {
+                    detectedType = 'image';
+                }
+                else if (typeof paramValue === 'boolean') {
+                    detectedType = 'boolean';
+                }
+                else if (typeof paramValue === 'number') {
+                    detectedType = 'number';
+                }
+                // Add parameter with value and type as description
+                const valueStr = String(paramValue);
+                const description = `Type: ${detectedType} | Current value: ${valueStr.length > 50 ? valueStr.substring(0, 50) + '...' : valueStr}`;
+                parameters.push({
+                    name: paramName,
+                    value: paramName,
+                    description: description,
+                });
+            }
+            // Sort alphabetically
+            parameters.sort((a, b) => a.name.localeCompare(b.name));
+            return parameters;
+        }
+        catch (error) {
+            // Silently return empty array on error
+            return [];
+        }
+    }
 }
 exports.ComfyUiTool = ComfyUiTool;
 //# sourceMappingURL=ComfyUiTool.node.js.map