n8n-nodes-vlm 2.0.4 → 2.0.6

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

@@ -207,23 +207,23 @@ class VLMComplexityWorkflow {
                             name: 'outputFormat',
                             type: 'options',
                             options: [
-                                {
-                                    name: 'Documents Array',
-                                    value: 'documents',
-                                    description: 'Return classified documents in an array',
-                                },
                                 {
                                     name: 'Separate Items',
                                     value: 'items',
-                                    description: 'Return each document as a separate item',
+                                    description: 'Return each document as a separate item (recommended for binary data)',
                                 },
                                 {
                                     name: 'Original Format',
                                     value: 'original',
                                     description: 'Maintain original input structure with classifications added',
                                 },
+                                {
+                                    name: 'Documents Array',
+                                    value: 'documents',
+                                    description: 'Return classified documents in an array',
+                                },
                             ],
-                            default: 'documents',
+                            default: 'items',
                             description: 'How to format the output',
                         },
                     ],
@@ -297,31 +297,88 @@ class VLMComplexityWorkflow {
             const fieldName = this.getNodeParameter('fieldName', 0);
             for (let i = 0; i < items.length; i++) {
                 const fieldData = items[i].json[fieldName];
+                const extractedDocs = [];
                 if (Array.isArray(fieldData)) {
-                    documents.push(...fieldData);
+                    extractedDocs.push(...fieldData);
                 }
                 else if (fieldData) {
-                    documents.push(fieldData);
+                    extractedDocs.push(fieldData);
                 }
+                // For each extracted document, also attach binary data if available
+                extractedDocs.forEach((doc) => {
+                    const enhancedDoc = typeof doc === 'object' ? { ...doc } : { content: doc };
+                    // Extract binary image data from n8n item.binary
+                    const itemBinary = items[i].binary;
+                    if (itemBinary) {
+                        enhancedDoc.metadata = enhancedDoc.metadata || {};
+                        enhancedDoc.metadata._originalBinary = itemBinary;
+                        enhancedDoc.metadata._itemIndex = i;
+                        // Find first image in binary data
+                        for (const [binaryKey, binaryData] of Object.entries(itemBinary)) {
+                            const data = binaryData;
+                            if (data.mimeType && data.mimeType.startsWith('image/')) {
+                                const base64Data = data.data;
+                                if (base64Data) {
+                                    enhancedDoc.base64Image = `data:${data.mimeType};base64,${base64Data}`;
+                                    enhancedDoc.metadata._binaryKey = binaryKey;
+                                    this.logger.debug(`Extracted image from binary '${binaryKey}' (${data.mimeType}) for item ${i} (field source)`);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    documents.push(enhancedDoc);
+                });
             }
         }
         else if (documentSource === 'expression') {
             // Extract from expression
             for (let i = 0; i < items.length; i++) {
                 const expressionValue = this.getNodeParameter('documentsExpression', i);
+                const extractedDocs = [];
                 if (Array.isArray(expressionValue)) {
-                    documents.push(...expressionValue);
+                    extractedDocs.push(...expressionValue);
                 }
                 else if (expressionValue) {
-                    documents.push(expressionValue);
+                    extractedDocs.push(expressionValue);
                 }
+                // For each extracted document, also attach binary data if available
+                extractedDocs.forEach((doc) => {
+                    const enhancedDoc = typeof doc === 'object' ? { ...doc } : { content: doc };
+                    // Extract binary image data from n8n item.binary
+                    const itemBinary = items[i].binary;
+                    if (itemBinary) {
+                        enhancedDoc.metadata = enhancedDoc.metadata || {};
+                        enhancedDoc.metadata._originalBinary = itemBinary;
+                        enhancedDoc.metadata._itemIndex = i;
+                        // Find first image in binary data
+                        for (const [binaryKey, binaryData] of Object.entries(itemBinary)) {
+                            const data = binaryData;
+                            if (data.mimeType && data.mimeType.startsWith('image/')) {
+                                const base64Data = data.data;
+                                if (base64Data) {
+                                    enhancedDoc.base64Image = `data:${data.mimeType};base64,${base64Data}`;
+                                    enhancedDoc.metadata._binaryKey = binaryKey;
+                                    this.logger.debug(`Extracted image from binary '${binaryKey}' (${data.mimeType}) for item ${i} (expression source)`);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    documents.push(enhancedDoc);
+                });
             }
         }
         if (documents.length === 0) {
             this.logger.debug('No documents found to classify');
             return [items];
         }
-        this.logger.debug(`Classifying ${documents.length} documents with model: ${model}`);
+        // Debug: Log how many documents have images
+        const docsWithImages = documents.filter((doc) => doc.base64Image).length;
+        this.logger.debug(`Classifying ${documents.length} documents with model: ${model} (${docsWithImages} have images)`);
+        if (docsWithImages === 0) {
+            this.logger.warn('⚠️  No images found in documents! Binary extraction may have failed. Check that input items have binary data.');
+        }
         try {
             // Classify documents
             const classifiedDocs = await (0, vlm_logic_1.classifyDocuments)(this, {

package/dist/nodes/shared/vlm-logic.js

@@ -40,6 +40,7 @@ async function checkServerStatus(context, serverUrl, timeout = 5000) {
  * Classify a single document's complexity using VLM Classifier API
  */
 async function classifyDocumentComplexity(context, serverUrl, document, timeout) {
+    var _a, _b, _c, _d, _e, _f, _g;
     try {
         // Prepare document content for classification
         const content = document.pageContent || JSON.stringify(document);
@@ -50,7 +51,12 @@ async function classifyDocumentComplexity(context, serverUrl, document, timeout)
         };
         if (hasImage) {
             requestBody.image = document.image || document.base64Image;
+            (_a = context.logger) === null || _a === void 0 ? void 0 : _a.debug(`VLM Classification: Sending request with image (${requestBody.image.substring(0, 50)}...)`);
         }
+        else {
+            (_b = context.logger) === null || _b === void 0 ? void 0 : _b.debug('VLM Classification: Sending request without image');
+        }
+        (_c = context.logger) === null || _c === void 0 ? void 0 : _c.debug(`VLM Classification: Calling ${serverUrl}/api/classify`);
         const response = await context.helpers.httpRequest({
             method: 'POST',
             url: `${serverUrl}/api/classify`,
@@ -62,6 +68,7 @@ async function classifyDocumentComplexity(context, serverUrl, document, timeout)
             json: true,
             timeout,
         });
+        (_d = context.logger) === null || _d === void 0 ? void 0 : _d.debug(`VLM Classification: Received response: ${JSON.stringify(response)}`);
         return {
             complexity: response.complexity || response.classification || 'LOW',
             confidence: response.confidence,
@@ -71,10 +78,16 @@ async function classifyDocumentComplexity(context, serverUrl, document, timeout)
     }
     catch (error) {
         // On error, default to LOW complexity to not filter out documents
+        (_e = context.logger) === null || _e === void 0 ? void 0 : _e.error(`VLM Classification FAILED: ${error.message}`, ((_f = error.response) === null || _f === void 0 ? void 0 : _f.body) || error);
         console.warn('Classification failed, defaulting to LOW complexity:', error.message);
+        if ((_g = error.response) === null || _g === void 0 ? void 0 : _g.body) {
+            console.warn('Error response body:', error.response.body);
+        }
         return {
             complexity: 'LOW',
             confidence: 0,
+            processingTime: undefined,
+            modelUsed: 'ERROR - Classification failed',
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-vlm",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Vision-Language Models for n8n - Lightweight specialized VLMs for document analysis and classification",
   "main": "index.js",
   "author": "Gabriel BRUMENT",