n8n-nodes-vlm 3.3.0 → 3.3.2

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

@@ -181,12 +181,7 @@ class VLMComplexityWorkflow {
                         },
                     ],
                     default: 'raw',
-                    description: 'Format of the base64 in the output field',
-                    displayOptions: {
-                        hide: {
-                            outputBase64Field: [''],
-                        },
-                    },
+                    description: 'Format of the base64 in the output field. Only used when Output Base64 Field is set.',
                 },
                 // ═══════════════════════════════════════════════════════════════
                 // ADVANCED OPTIONS
@@ -288,23 +283,35 @@ class VLMComplexityWorkflow {
                     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;
+                        mimeType = data.mimeType || 'image/png';
+                        try {
+                            // Use getBinaryDataBuffer for n8n filesystem binary mode compatibility
+                            const buffer = await this.helpers.getBinaryDataBuffer(i, binaryField);
+                            rawBase64 = buffer.toString('base64');
                             base64Image = `data:${mimeType};base64,${rawBase64}`;
-                            this.logger.debug(`VLM DEBUG INPUT [${i}]: Using specified binary field '${binaryField}' (${mimeType})`);
+                            this.logger.debug(`VLM DEBUG INPUT [${i}]: Using specified binary field '${binaryField}' (${mimeType}), size=${buffer.length}`);
+                        }
+                        catch (err) {
+                            this.logger.warn(`VLM WARNING [${i}]: Failed to read binary field '${binaryField}': ${err}`);
                         }
                     }
                     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) {
+                            if (data.mimeType && data.mimeType.startsWith('image/')) {
                                 mimeType = data.mimeType;
-                                rawBase64 = data.data;
-                                base64Image = `data:${mimeType};base64,${rawBase64}`;
-                                this.logger.debug(`VLM DEBUG INPUT [${i}]: Auto-detected image from binary '${binaryKey}' (${mimeType})`);
-                                break;
+                                try {
+                                    // Use getBinaryDataBuffer for n8n filesystem binary mode compatibility
+                                    const buffer = await this.helpers.getBinaryDataBuffer(i, binaryKey);
+                                    rawBase64 = buffer.toString('base64');
+                                    base64Image = `data:${mimeType};base64,${rawBase64}`;
+                                    this.logger.debug(`VLM DEBUG INPUT [${i}]: Auto-detected image from binary '${binaryKey}' (${mimeType}), size=${buffer.length}`);
+                                    break;
+                                }
+                                catch (err) {
+                                    this.logger.warn(`VLM WARNING [${i}]: Failed to read binary '${binaryKey}': ${err}`);
+                                }
                             }
                         }
                     }
@@ -327,21 +334,27 @@ class VLMComplexityWorkflow {
             this.logger.debug(`VLM DEBUG OUTPUT [${i}]: format='${outputBase64Format}', choosing ${outputBase64Format === 'raw' ? 'rawBase64' : 'base64Image'}`);
             const outputBase64Value = outputBase64Format === 'raw' ? rawBase64 : base64Image;
             this.logger.debug(`VLM DEBUG OUTPUT [${i}]: outputBase64Value prefix='${outputBase64Value === null || outputBase64Value === void 0 ? void 0 : outputBase64Value.substring(0, 40)}...'`);
+            this.logger.debug(`VLM DEBUG OUTPUT [${i}]: Will add to JSON? outputBase64Field='${outputBase64Field}' (truthy=${!!outputBase64Field}), hasValue=${!!outputBase64Value}`);
+            // Build base JSON output
+            const outputJson = {
+                // Classification results (top level for visibility)
+                complexityClass: classification.complexity,
+                complexityConfidence: classification.confidence,
+                processingTime: classification.processingTime,
+                modelUsed: classification.modelUsed,
+                // Original JSON data merged in
+                ...item.json,
+                // Item tracking
+                _itemIndex: i,
+            };
+            // Add base64 to output if field name is specified
+            if (outputBase64Field && outputBase64Field.trim() !== '' && outputBase64Value) {
+                outputJson[outputBase64Field] = outputBase64Value;
+                this.logger.debug(`VLM DEBUG OUTPUT [${i}]: Added '${outputBase64Field}' = '${outputBase64Value.substring(0, 30)}...'`);
+            }
             // Build output item with BOTH json AND binary
             const outputItem = {
-                json: {
-                    // Classification results (top level for visibility)
-                    complexityClass: classification.complexity,
-                    complexityConfidence: classification.confidence,
-                    processingTime: classification.processingTime,
-                    modelUsed: classification.modelUsed,
-                    // Original JSON data merged in
-                    ...item.json,
-                    // Item tracking
-                    _itemIndex: i,
-                    // Optional: include base64 in output JSON (format depends on outputBase64Format)
-                    ...(outputBase64Field && outputBase64Value ? { [outputBase64Field]: outputBase64Value } : {}),
-                },
+                json: outputJson,
                 // ALWAYS preserve binary data
                 binary: item.binary,
             };

package/package.json

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