n8n-nodes-vlm 3.1.2 → 3.2.1

package/dist/nodes/VLMComplexityWorkflow/VLMComplexityWorkflow.node.js

@@ -91,6 +91,25 @@ class VLMComplexityWorkflow {
                     placeholder: 'Add Option',
                     default: {},
                     options: [
+                        {
+                            displayName: 'Image Source',
+                            name: 'imageSource',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'From Binary',
+                                    value: 'binary',
+                                    description: 'Extract image from binary field (n8n standard)',
+                                },
+                                {
+                                    name: 'From Base64 Field',
+                                    value: 'base64field',
+                                    description: 'Use base64 string from JSON field (with or without Data URI prefix)',
+                                },
+                            ],
+                            default: 'binary',
+                            description: 'Where to get the image data from',
+                        },
                         {
                             displayName: 'Binary Field',
                             name: 'binaryField',
@@ -99,13 +118,40 @@ class VLMComplexityWorkflow {
                             placeholder: 'e.g. data (auto-detect if empty)',
                             description: 'Name of the binary field to use for classification. Leave empty to auto-detect first image.',
                         },
+                        {
+                            displayName: 'Base64 Field',
+                            name: 'base64Field',
+                            type: 'string',
+                            default: 'data',
+                            placeholder: 'e.g. data, base64Image',
+                            description: 'JSON field containing base64 string (auto-detects Data URI prefix)',
+                        },
                         {
                             displayName: 'Output Base64 Field',
                             name: 'outputBase64Field',
                             type: 'string',
                             default: '',
                             placeholder: 'e.g. base64Image',
-                            description: 'If set, the base64 image string will be added to output JSON under this field name.',
+                            description: 'If set, the base64 image will be added to output JSON under this field name.',
+                        },
+                        {
+                            displayName: 'Output Base64 Format',
+                            name: 'outputBase64Format',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'Raw Base64',
+                                    value: 'raw',
+                                    description: 'iVBORw0KGgo... (like n8n native)',
+                                },
+                                {
+                                    name: 'Data URI',
+                                    value: 'datauri',
+                                    description: 'data:image/png;base64,iVBORw0KGgo...',
+                                },
+                            ],
+                            default: 'raw',
+                            description: 'Format of the base64 output (only applies if Output Base64 Field is set)',
                         },
                         {
                             displayName: 'Request Timeout (ms)',
@@ -140,8 +186,14 @@ class VLMComplexityWorkflow {
         const model = this.getNodeParameter('model', 0);
         const options = this.getNodeParameter('options', 0, {});
         const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : 30000;
+        const imageSource = options.imageSource || 'binary';
         const binaryField = options.binaryField || '';
+        const base64Field = options.base64Field || 'data';
         const outputBase64Field = options.outputBase64Field || '';
+        const outputBase64Format = options.outputBase64Format || 'raw';
+        // DEBUG: Log options to diagnose format bug
+        this.logger.debug(`VLM DEBUG OPTIONS: imageSource='${imageSource}', outputBase64Format='${outputBase64Format}', outputBase64Field='${outputBase64Field}'`);
+        this.logger.debug(`VLM DEBUG: outputBase64Format === 'raw' ? ${outputBase64Format === 'raw'}`);
         // Verify server has classifier capability (optional check)
         const status = await (0, vlm_logic_1.checkServerStatus)(this, serverUrl, timeout);
         if (status.status === 'error') {
@@ -156,31 +208,59 @@ class VLMComplexityWorkflow {
         // Process each input item
         for (let i = 0; i < items.length; i++) {
             const item = items[i];
-            // Extract base64 image from binary
-            let base64Image;
-            if (item.binary) {
-                if (binaryField && item.binary[binaryField]) {
-                    // Use specified binary field
-                    const data = item.binary[binaryField];
-                    if (data.data) {
-                        base64Image = `data:${data.mimeType || 'image/png'};base64,${data.data}`;
-                        this.logger.debug(`Item ${i}: Using specified binary field '${binaryField}' (${data.mimeType || 'unknown'})`);
+            // Extract base64 image - track both raw and Data URI formats
+            let base64Image; // Data URI format for API
+            let rawBase64; // Raw base64 without prefix
+            let mimeType = 'image/png';
+            if (imageSource === 'base64field') {
+                // Extract from JSON field
+                const fieldValue = item.json[base64Field];
+                if (fieldValue) {
+                    // Auto-detect if it's already a Data URI
+                    const dataUriMatch = fieldValue.match(/^data:([^;]+);base64,(.+)$/);
+                    if (dataUriMatch) {
+                        mimeType = dataUriMatch[1];
+                        rawBase64 = dataUriMatch[2];
+                        base64Image = fieldValue; // Already in Data URI format
+                    }
+                    else {
+                        // Raw base64, wrap in Data URI
+                        rawBase64 = fieldValue;
+                        base64Image = `data:${mimeType};base64,${rawBase64}`;
                     }
+                    this.logger.debug(`Item ${i}: Using base64 from JSON field '${base64Field}' (${mimeType})`);
                 }
-                else {
-                    // Auto-detect first image (default behavior)
-                    for (const [binaryKey, binaryData] of Object.entries(item.binary)) {
-                        const data = binaryData;
-                        if (data.mimeType && data.mimeType.startsWith('image/') && data.data) {
-                            base64Image = `data:${data.mimeType};base64,${data.data}`;
-                            this.logger.debug(`Item ${i}: Auto-detected image from binary '${binaryKey}' (${data.mimeType})`);
-                            break;
+            }
+            else {
+                // Extract from binary (default)
+                if (item.binary) {
+                    if (binaryField && item.binary[binaryField]) {
+                        // Use specified binary field
+                        const data = item.binary[binaryField];
+                        if (data.data) {
+                            mimeType = data.mimeType || 'image/png';
+                            rawBase64 = data.data;
+                            base64Image = `data:${mimeType};base64,${rawBase64}`;
+                            this.logger.debug(`Item ${i}: Using specified binary field '${binaryField}' (${mimeType})`);
+                        }
+                    }
+                    else {
+                        // Auto-detect first image (default behavior)
+                        for (const [binaryKey, binaryData] of Object.entries(item.binary)) {
+                            const data = binaryData;
+                            if (data.mimeType && data.mimeType.startsWith('image/') && data.data) {
+                                mimeType = data.mimeType;
+                                rawBase64 = data.data;
+                                base64Image = `data:${mimeType};base64,${rawBase64}`;
+                                this.logger.debug(`Item ${i}: Auto-detected image from binary '${binaryKey}' (${mimeType})`);
+                                break;
+                            }
                         }
                     }
                 }
             }
             if (!base64Image) {
-                this.logger.warn(`Item ${i}: No image found in binary data`);
+                this.logger.warn(`Item ${i}: No image found (source: ${imageSource})`);
             }
             // Classify the document
             const classification = await (0, vlm_logic_1.classifySingleDocument)(this, {
@@ -189,6 +269,13 @@ class VLMComplexityWorkflow {
                 timeout,
             });
             this.logger.debug(`Item ${i}: Classified as ${classification.complexity} (confidence: ${classification.confidence})`);
+            // Determine base64 output value based on format preference
+            // DEBUG: Log values before output decision
+            this.logger.debug(`VLM DEBUG OUTPUT: rawBase64 defined=${!!rawBase64}, rawBase64 prefix='${rawBase64 === null || rawBase64 === void 0 ? void 0 : rawBase64.substring(0, 25)}...'`);
+            this.logger.debug(`VLM DEBUG OUTPUT: base64Image prefix='${base64Image === null || base64Image === void 0 ? void 0 : base64Image.substring(0, 35)}...'`);
+            this.logger.debug(`VLM DEBUG OUTPUT: choosing ${outputBase64Format === 'raw' ? 'rawBase64' : 'base64Image'}`);
+            const outputBase64Value = outputBase64Format === 'raw' ? rawBase64 : base64Image;
+            this.logger.debug(`VLM DEBUG OUTPUT: outputBase64Value prefix='${outputBase64Value === null || outputBase64Value === void 0 ? void 0 : outputBase64Value.substring(0, 35)}...'`);
             // Build output item with BOTH json AND binary
             const outputItem = {
                 json: {
@@ -201,8 +288,8 @@ class VLMComplexityWorkflow {
                     ...item.json,
                     // Item tracking
                     _itemIndex: i,
-                    // Optional: include base64 in output JSON
-                    ...(outputBase64Field && base64Image ? { [outputBase64Field]: base64Image } : {}),
+                    // Optional: include base64 in output JSON (format depends on outputBase64Format)
+                    ...(outputBase64Field && outputBase64Value ? { [outputBase64Field]: outputBase64Value } : {}),
                 },
                 // ALWAYS preserve binary data
                 binary: item.binary,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-vlm",
-  "version": "3.1.2",
+  "version": "3.2.1",
   "description": "Vision-Language Models for n8n - Lightweight specialized VLMs for document analysis and classification",
   "main": "dist/index.js",
   "author": "Nicolas Geysse",