n8n-nodes-vlm 2.0.8 → 3.1.1

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

@@ -1,16 +1,17 @@
 import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
 /**
- * VLM Complexity Classifier Workflow Node
+ * VLM Complexity Classifier Workflow Node v3
  *
- * A workflow node that classifies document complexity using Vision-Language Models.
- * Can be used as a standalone tool or chained in workflows.
+ * Routes documents to LOW or HIGH outputs based on VLM classification.
+ * Always preserves both binary data and classification results.
  */
 export declare class VLMComplexityWorkflow implements INodeType {
     description: INodeTypeDescription;
     /**
-     * Execute Method
+     * Execute Method - v3 Dual Output
      *
-     * Workflow nodes use execute() to process items through the workflow
+     * Routes items to LOW or HIGH output based on classification.
+     * Always preserves binary data alongside classification results.
      */
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

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

@@ -4,23 +4,23 @@ exports.VLMComplexityWorkflow = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const vlm_logic_1 = require("../shared/vlm-logic");
 /**
- * VLM Complexity Classifier Workflow Node
+ * VLM Complexity Classifier Workflow Node v3
  *
- * A workflow node that classifies document complexity using Vision-Language Models.
- * Can be used as a standalone tool or chained in workflows.
+ * Routes documents to LOW or HIGH outputs based on VLM classification.
+ * Always preserves both binary data and classification results.
  */
 class VLMComplexityWorkflow {
     constructor() {
         this.description = {
-            displayName: 'VLM Complexity Workflow',
+            displayName: 'VLM Complexity Classifier',
             name: 'vlmComplexityWorkflow',
             icon: 'file:vlm.svg',
             group: ['transform'],
-            version: 1,
+            version: 2,
             subtitle: '={{$parameter["model"]}}',
-            description: 'Classify document complexity using Vision-Language Models',
+            description: 'Classify document complexity and route to LOW/HIGH outputs',
             defaults: {
-                name: 'VLM Complexity Workflow',
+                name: 'VLM Complexity Classifier',
             },
             usableAsTool: true,
             codex: {
@@ -30,7 +30,8 @@ class VLMComplexityWorkflow {
                 },
             },
             inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
-            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main, n8n_workflow_1.NodeConnectionTypes.Main],
+            outputNames: ['LOW', 'HIGH'],
             credentials: [
                 {
                     name: 'ollamaApi',
@@ -84,113 +85,28 @@ class VLMComplexityWorkflow {
                     required: true,
                 },
                 {
-                    displayName: 'Document Source',
-                    name: 'documentSource',
-                    type: 'options',
-                    options: [
-                        {
-                            name: 'All Items',
-                            value: 'items',
-                            description: 'Process all items from input',
-                        },
-                        {
-                            name: 'From Field',
-                            value: 'field',
-                            description: 'Extract documents from a specific field',
-                        },
-                        {
-                            name: 'From Expression',
-                            value: 'expression',
-                            description: 'Define documents using an expression',
-                        },
-                    ],
-                    default: 'items',
-                    description: 'Where to get documents for classification',
-                },
-                {
-                    displayName: 'Field Name',
-                    name: 'fieldName',
-                    type: 'string',
-                    default: 'documents',
-                    description: 'Name of the field containing documents',
-                    displayOptions: {
-                        show: {
-                            documentSource: ['field'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Documents Expression',
-                    name: 'documentsExpression',
-                    type: 'string',
-                    default: '={{$json.documents}}',
-                    description: 'Expression to extract documents',
-                    displayOptions: {
-                        show: {
-                            documentSource: ['expression'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Classification Strategy',
-                    name: 'classificationStrategy',
-                    type: 'options',
-                    options: [
-                        {
-                            name: 'Add Metadata Only',
-                            value: 'metadata',
-                            description: 'Add complexity classification as document metadata',
-                        },
-                        {
-                            name: 'Filter Documents',
-                            value: 'filter',
-                            description: 'Filter documents based on complexity',
-                        },
-                        {
-                            name: 'Filter + Metadata',
-                            value: 'both',
-                            description: 'Both filter and add metadata',
-                        },
-                    ],
-                    default: 'metadata',
-                    description: 'How to use the classification results',
-                },
-                {
-                    displayName: 'Filter Complexity',
-                    name: 'filterComplexity',
-                    type: 'options',
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
                     options: [
                         {
-                            name: 'Low Complexity Only',
-                            value: 'LOW',
-                            description: 'Keep only simple documents (good for OCR)',
-                        },
-                        {
-                            name: 'High Complexity Only',
-                            value: 'HIGH',
-                            description: 'Keep only complex documents (good for VLM)',
+                            displayName: 'Binary Field',
+                            name: 'binaryField',
+                            type: 'string',
+                            default: '',
+                            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.',
                         },
                         {
-                            name: 'Both',
-                            value: 'both',
-                            description: 'Keep all documents regardless of complexity',
+                            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.',
                         },
-                    ],
-                    default: 'both',
-                    description: 'Which complexity level to keep when filtering',
-                    displayOptions: {
-                        show: {
-                            classificationStrategy: ['filter', 'both'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Additional Options',
-                    name: 'additionalOptions',
-                    type: 'collection',
-                    placeholder: 'Add Option',
-                    default: {},
-                    options: [
                         {
                             displayName: 'Request Timeout (ms)',
                             name: 'timeout',
@@ -202,55 +118,30 @@ class VLMComplexityWorkflow {
                             },
                             description: 'Maximum time per API request',
                         },
-                        {
-                            displayName: 'Output Format',
-                            name: 'outputFormat',
-                            type: 'options',
-                            options: [
-                                {
-                                    name: 'Separate Items',
-                                    value: 'items',
-                                    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: 'items',
-                            description: 'How to format the output',
-                        },
                     ],
                 },
             ],
         };
     }
     /**
-     * Execute Method
+     * Execute Method - v3 Dual Output
      *
-     * Workflow nodes use execute() to process items through the workflow
+     * Routes items to LOW or HIGH output based on classification.
+     * Always preserves binary data alongside classification results.
      */
     async execute() {
-        var _a, _b;
+        var _a;
         const items = this.getInputData();
-        this.logger.debug(`VLM Complexity Workflow: Processing ${items.length} input items`);
+        this.logger.debug(`VLM Complexity Classifier: Processing ${items.length} input items`);
         // Get credentials
         const credentials = await this.getCredentials('ollamaApi');
         const serverUrl = credentials.baseUrl.replace(/\/$/, '');
         // Get node parameters
         const model = this.getNodeParameter('model', 0);
-        const documentSource = this.getNodeParameter('documentSource', 0);
-        const classificationStrategy = this.getNodeParameter('classificationStrategy', 0);
-        const filterComplexity = this.getNodeParameter('filterComplexity', 0, 'both');
-        const additionalOptions = this.getNodeParameter('additionalOptions', 0, {});
-        const timeout = (_a = additionalOptions.timeout) !== null && _a !== void 0 ? _a : 30000;
-        const outputFormat = (_b = additionalOptions.outputFormat) !== null && _b !== void 0 ? _b : 'documents';
+        const options = this.getNodeParameter('options', 0, {});
+        const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : 30000;
+        const binaryField = options.binaryField || '';
+        const outputBase64Field = options.outputBase64Field || '';
         // Verify server has classifier capability (optional check)
         const status = await (0, vlm_logic_1.checkServerStatus)(this, serverUrl, timeout);
         if (status.status === 'error') {
@@ -259,206 +150,74 @@ class VLMComplexityWorkflow {
         else if (!status.hasClassifier) {
             this.logger.warn(`Server at ${serverUrl} does not explicitly report VLM classifier support. Proceeding anyway...`);
         }
-        // Extract documents based on source
-        let documents = [];
-        if (documentSource === 'items') {
-            // Use all items as documents
-            documents = items.map((item, index) => {
-                const doc = {
-                    pageContent: JSON.stringify(item.json),
-                    metadata: {
-                        _itemIndex: index,
-                        _originalBinary: item.binary, // Preserve original binary data
-                    },
-                };
-                // Extract binary image data from n8n item.binary
-                if (item.binary) {
-                    // Find first image in binary data
+        // Dual output arrays
+        const lowItems = [];
+        const highItems = [];
+        // 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'})`);
+                    }
+                }
+                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/')) {
-                            // n8n stores binary data as base64 in data.data
-                            const base64Data = data.data;
-                            // 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
-                            }
+                        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;
                         }
                     }
                 }
-                return doc;
-            });
-        }
-        else if (documentSource === 'field') {
-            // Extract from field
-            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)) {
-                    extractedDocs.push(...fieldData);
-                }
-                else if (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)) {
-                    extractedDocs.push(...expressionValue);
-                }
-                else if (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 (!base64Image) {
+                this.logger.warn(`Item ${i}: No image found in binary data`);
             }
-        }
-        if (documents.length === 0) {
-            this.logger.debug('No documents found to classify');
-            return [items];
-        }
-        // 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, {
+            // Classify the document
+            const classification = await (0, vlm_logic_1.classifySingleDocument)(this, {
                 serverUrl,
-                model,
-                documents,
+                base64Image,
                 timeout,
-                classificationStrategy,
-                filterComplexity,
             });
-            this.logger.debug(`Classification complete: ${classifiedDocs.length} documents returned`);
-            // Format output based on outputFormat option
-            if (outputFormat === 'items') {
-                // Return each document as a separate item
-                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 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,
-                    };
-                    // 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];
+            this.logger.debug(`Item ${i}: Classified as ${classification.complexity} (confidence: ${classification.confidence})`);
+            // 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
+                    ...(outputBase64Field && base64Image ? { [outputBase64Field]: base64Image } : {}),
+                },
+                // ALWAYS preserve binary data
+                binary: item.binary,
+            };
+            // Route to appropriate output
+            if (classification.complexity === 'HIGH') {
+                highItems.push(outputItem);
             }
             else {
-                // 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 } }]];
+                lowItems.push(outputItem);
             }
         }
-        catch (error) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `VLM classification failed: ${error.message}`);
-        }
+        this.logger.debug(`Classification complete: ${lowItems.length} LOW, ${highItems.length} HIGH`);
+        // Return dual outputs: [LOW, HIGH]
+        return [lowItems, highItems];
     }
 }
 exports.VLMComplexityWorkflow = VLMComplexityWorkflow;

package/dist/nodes/shared/vlm-logic.d.ts

@@ -8,6 +8,11 @@ export interface VLMConfig {
     classificationStrategy?: 'metadata' | 'filter' | 'both';
     filterComplexity?: 'LOW' | 'HIGH' | 'both';
 }
+export interface SingleDocConfig {
+    serverUrl: string;
+    base64Image?: string;
+    timeout: number;
+}
 export interface VLClassificationResult {
     complexity: 'LOW' | 'HIGH';
     confidence?: number;
@@ -26,6 +31,11 @@ export interface ServerStatus {
  * Check server status to detect VLM classifier capabilities
  */
 export declare function checkServerStatus(context: VLMContext, serverUrl: string, timeout?: number): Promise<ServerStatus>;
+/**
+ * Classify a single document - simplified API for workflow node v3
+ * Always returns a result (defaults to LOW on error)
+ */
+export declare function classifySingleDocument(context: VLMContext, config: SingleDocConfig): Promise<VLClassificationResult>;
 /**
  * Classify documents using VLM Classifier
  */

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkServerStatus = checkServerStatus;
+exports.classifySingleDocument = classifySingleDocument;
 exports.classifyDocuments = classifyDocuments;
 exports.listVLMModels = listVLMModels;
 const n8n_workflow_1 = require("n8n-workflow");
@@ -96,6 +97,47 @@ async function classifyDocumentComplexity(context, serverUrl, document, timeout)
         };
     }
 }
+/**
+ * Classify a single document - simplified API for workflow node v3
+ * Always returns a result (defaults to LOW on error)
+ */
+async function classifySingleDocument(context, config) {
+    var _a, _b, _c;
+    const { serverUrl, base64Image, timeout } = config;
+    try {
+        const requestBody = base64Image
+            ? { image: base64Image }
+            : { text: '' };
+        (_a = context.logger) === null || _a === void 0 ? void 0 : _a.debug(`VLM Single Classification: Calling ${serverUrl}/api/classify/base64 (hasImage: ${!!base64Image})`);
+        const response = await context.helpers.httpRequest({
+            method: 'POST',
+            url: `${serverUrl}/api/classify/base64`,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: requestBody,
+            json: true,
+            timeout,
+        });
+        (_b = context.logger) === null || _b === void 0 ? void 0 : _b.debug(`VLM Single Classification: Response: ${JSON.stringify(response)}`);
+        return {
+            complexity: response.class_name || response.complexity || response.classification || 'LOW',
+            confidence: response.confidence,
+            processingTime: response.processing_time || response.processingTime || response.latency_ms,
+            modelUsed: response.model || 'VLM-Classifier',
+        };
+    }
+    catch (error) {
+        (_c = context.logger) === null || _c === void 0 ? void 0 : _c.error(`VLM Single Classification FAILED: ${error.message}`);
+        return {
+            complexity: 'LOW',
+            confidence: 0,
+            processingTime: undefined,
+            modelUsed: 'ERROR - Classification failed',
+        };
+    }
+}
 /**
  * Classify documents using VLM Classifier
  */

package/package.json

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