n8n-nodes-vlm 3.3.3 → 3.3.4

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

@@ -325,6 +325,7 @@ class VLMComplexityWorkflow {
                 serverUrl,
                 base64Image,
                 timeout,
+                model, // Pass selected model to API
             });
             this.logger.debug(`VLM CLASSIFICATION [${i}]: ${classification.complexity} (confidence: ${classification.confidence}, model: ${classification.modelUsed})`);
             // Determine base64 output value based on format preference

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

@@ -8,11 +8,6 @@ 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;
@@ -31,6 +26,12 @@ export interface ServerStatus {
  * Check server status to detect VLM classifier capabilities
  */
 export declare function checkServerStatus(context: VLMContext, serverUrl: string, timeout?: number): Promise<ServerStatus>;
+export interface SingleDocConfig {
+    serverUrl: string;
+    base64Image?: string;
+    timeout: number;
+    model?: string;
+}
 /**
  * Classify a single document - simplified API for workflow node v3
  * Always returns a result (defaults to LOW on error)

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

@@ -40,29 +40,31 @@ async function checkServerStatus(context, serverUrl, timeout = 5000) {
 /**
  * Classify a single document's complexity using VLM Classifier API
  */
-async function classifyDocumentComplexity(context, serverUrl, document, timeout) {
+async function classifyDocumentComplexity(context, serverUrl, document, timeout, model) {
     var _a, _b, _c, _d, _e, _f, _g;
     try {
         // Prepare document content for classification
         const content = document.pageContent || JSON.stringify(document);
         // Check if document contains image data
         const hasImage = document.image || document.base64Image;
-        // For /api/classify/base64 endpoint, only send image field
+        // For /api/classify/base64 endpoint, send image and model
         let requestBody;
         if (hasImage) {
             requestBody = {
-                image: document.base64Image || document.image
+                image: document.base64Image || document.image,
+                model: model || 'vl-classifier', // Pass selected model to API
             };
-            (_a = context.logger) === null || _a === void 0 ? void 0 : _a.debug(`VLM Classification: Sending request with image (${requestBody.image.substring(0, 50)}...)`);
+            (_a = context.logger) === null || _a === void 0 ? void 0 : _a.debug(`VLM Classification: Sending request with image and model=${model} (${requestBody.image.substring(0, 50)}...)`);
         }
         else {
             // Fallback: send text if no image available
             requestBody = {
                 text: content,
+                model: model || 'vl-classifier',
             };
-            (_b = context.logger) === null || _b === void 0 ? void 0 : _b.debug('VLM Classification: Sending request without image (text only)');
+            (_b = context.logger) === null || _b === void 0 ? void 0 : _b.debug(`VLM Classification: Sending request without image (text only, model=${model})`);
         }
-        (_c = context.logger) === null || _c === void 0 ? void 0 : _c.debug(`VLM Classification: Calling ${serverUrl}/api/classify/base64`);
+        (_c = context.logger) === null || _c === void 0 ? void 0 : _c.debug(`VLM Classification: Calling ${serverUrl}/api/classify/base64 with model=${model}`);
         const response = await context.helpers.httpRequest({
             method: 'POST',
             url: `${serverUrl}/api/classify/base64`,
@@ -79,7 +81,7 @@ async function classifyDocumentComplexity(context, serverUrl, document, timeout)
             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',
+            modelUsed: response.model || model || 'VLM-Classifier',
         };
     }
     catch (error) {
@@ -103,12 +105,12 @@ async function classifyDocumentComplexity(context, serverUrl, document, timeout)
  */
 async function classifySingleDocument(context, config) {
     var _a, _b, _c;
-    const { serverUrl, base64Image, timeout } = config;
+    const { serverUrl, base64Image, timeout, model } = 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})`);
+            ? { image: base64Image, model: model || 'vl-classifier' }
+            : { text: '', model: model || 'vl-classifier' };
+        (_a = context.logger) === null || _a === void 0 ? void 0 : _a.debug(`VLM Single Classification: Calling ${serverUrl}/api/classify/base64 (hasImage: ${!!base64Image}, model: ${model})`);
         const response = await context.helpers.httpRequest({
             method: 'POST',
             url: `${serverUrl}/api/classify/base64`,
@@ -125,7 +127,7 @@ async function classifySingleDocument(context, config) {
             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',
+            modelUsed: response.model || model || 'VLM-Classifier',
         };
     }
     catch (error) {
@@ -142,10 +144,10 @@ async function classifySingleDocument(context, config) {
  * Classify documents using VLM Classifier
  */
 async function classifyDocuments(context, config) {
-    const { serverUrl, documents, timeout, classificationStrategy = 'metadata', filterComplexity = 'both' } = config;
+    const { serverUrl, model, documents, timeout, classificationStrategy = 'metadata', filterComplexity = 'both' } = config;
     // Step 1: Classify all documents
     const classificationPromises = documents.map(async (doc, index) => {
-        const classification = await classifyDocumentComplexity(context, serverUrl, doc, timeout);
+        const classification = await classifyDocumentComplexity(context, serverUrl, doc, timeout, model);
         return { doc, index, classification };
     });
     const classifiedDocs = await Promise.all(classificationPromises);

package/package.json

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