n8n-nodes-vlm 2.0.2 → 2.0.4

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

@@ -266,7 +266,10 @@ class VLMComplexityWorkflow {
             documents = items.map((item, index) => {
                 const doc = {
                     pageContent: JSON.stringify(item.json),
-                    metadata: { _itemIndex: index },
+                    metadata: {
+                        _itemIndex: index,
+                        _originalBinary: item.binary, // Preserve original binary data
+                    },
                 };
                 // Extract binary image data from n8n item.binary
                 if (item.binary) {
@@ -279,6 +282,7 @@ class VLMComplexityWorkflow {
                             // Add base64 image with data URI format
                             if (base64Data) {
                                 doc.base64Image = `data:${data.mimeType};base64,${base64Data}`;
+                                doc.metadata._binaryKey = binaryKey; // Remember which binary key was used
                                 this.logger.debug(`Extracted image from binary '${binaryKey}' (${data.mimeType}) for item ${index}`);
                                 break; // Use first image found
                             }
@@ -332,21 +336,67 @@ class VLMComplexityWorkflow {
             // Format output based on outputFormat option
             if (outputFormat === 'items') {
                 // Return each document as a separate item
-                return [classifiedDocs.map((doc) => ({ json: doc }))];
+                return [
+                    classifiedDocs.map((doc) => {
+                        // Flatten structure for better n8n usability
+                        const flattenedJson = {
+                            // Classification results (top level for visibility)
+                            complexityClass: doc._complexityClass,
+                            complexityConfidence: doc._complexityConfidence,
+                            processingTime: doc._processingTime,
+                            modelUsed: doc._modelUsed,
+                            // Document content
+                            content: doc.pageContent,
+                            // Original metadata (if any)
+                            ...(doc.metadata && doc.metadata._itemIndex !== undefined ? { itemIndex: doc.metadata._itemIndex } : {}),
+                            ...(doc._originalIndex !== undefined ? { originalIndex: doc._originalIndex } : {}),
+                        };
+                        const outputItem = { json: flattenedJson };
+                        // Restore original binary data if it was preserved
+                        if (doc.metadata && doc.metadata._originalBinary) {
+                            outputItem.binary = doc.metadata._originalBinary;
+                        }
+                        return outputItem;
+                    }),
+                ];
             }
             else if (outputFormat === 'original') {
-                // Maintain original structure but add classifications
-                const outputItems = items.map((item) => ({
-                    json: {
+                // Maintain original structure but add flattened classification metadata
+                const outputItems = items.map((item, index) => {
+                    // Find classification for this item
+                    const itemClassification = classifiedDocs.find((doc) => { var _a; return ((_a = doc.metadata) === null || _a === void 0 ? void 0 : _a._itemIndex) === index || doc._originalIndex === index; });
+                    const enhancedJson = {
                         ...item.json,
-                        _classifications: classifiedDocs,
-                    },
-                }));
+                    };
+                    // Add classification metadata at top level
+                    if (itemClassification) {
+                        enhancedJson.complexityClass = itemClassification._complexityClass;
+                        enhancedJson.complexityConfidence = itemClassification._complexityConfidence;
+                        enhancedJson.processingTime = itemClassification._processingTime;
+                        enhancedJson.modelUsed = itemClassification._modelUsed;
+                    }
+                    return {
+                        json: enhancedJson,
+                        binary: item.binary, // Preserve original binaries
+                    };
+                });
                 return [outputItems];
             }
             else {
-                // Default: return documents array
-                return [[{ json: { documents: classifiedDocs } }]];
+                // Default: return documents array with flattened structure
+                const flattenedDocs = classifiedDocs.map((doc) => {
+                    var _a;
+                    return ({
+                        complexityClass: doc._complexityClass,
+                        complexityConfidence: doc._complexityConfidence,
+                        processingTime: doc._processingTime,
+                        modelUsed: doc._modelUsed,
+                        content: doc.pageContent,
+                        itemIndex: (_a = doc.metadata) === null || _a === void 0 ? void 0 : _a._itemIndex,
+                        originalIndex: doc._originalIndex,
+                    });
+                });
+                return [[{ json: { documents: flattenedDocs } }]];
             }
         }
         catch (error) {

package/package.json

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