n8n-nodes-berget-mk 0.4.2 → 0.4.4

package/README.md

@@ -4,7 +4,7 @@ n8n community nodes for [Berget AI](https://berget.ai), packaged as a single ins
 
 Three nodes:
 
-- **Berget AI** — multi-resource action node for one-shot calls: **Chat** (completions, classification), **OCR** (document text extraction), **Rerank** (document reranking), and **Speech to Text** (Swedish-tuned KB-Whisper). Can also be exposed as a tool to an AI Agent.
+- **Berget AI** — multi-resource action node for one-shot calls: **Chat** (completions, classification), **Rerank** (document reranking), and **Speech to Text** (Swedish-tuned KB-Whisper). Can also be exposed as a tool to an AI Agent. (OCR is temporarily hidden — see [CHANGELOG.md](CHANGELOG.md) for `0.4.4` for details.)
 - **Berget AI Chat Model** — sub-node that plugs into n8n's built-in **AI Agent**, **Basic LLM Chain**, and other LangChain-based nodes. Exposes `reasoning_effort` and the full standard LLM parameter set.
 - **Berget AI Embeddings Model** — sub-node that plugs into n8n's **Vector Store** nodes (Supabase, Qdrant, Pinecone, PGVector, etc.) and **Question and Answer Chain**.
 
@@ -38,10 +38,6 @@ Then add a **Berget AI API** credential with your API key from [berget.ai](https
 2. Add **Berget AI Embeddings Model** and connect it to the Embedding socket.
 3. Index documents or query as usual.
 
-### Document extraction
-
-1. Drop **Berget AI** onto the canvas, pick Resource = **OCR**, provide a document URL or base64 data, and pick your output format (Markdown or JSON).
-
 ### Swedish speech transcription
 
 1. Drop **Berget AI** onto the canvas, pick Resource = **Speech to Text**, pick a model (defaults to `KB-Whisper-Large`), and point at an audio file.

package/dist/nodes/BergetAi/BergetAi.node.js

@@ -4,10 +4,33 @@ exports.BergetAi = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const n8n_workflow_2 = require("n8n-workflow");
 const chat_1 = require("./chat");
-const ocr_1 = require("./ocr");
+// OCR temporarily disabled — see the block comment below the BergetAi class
+// header for the re-enable procedure.
+// import { executeOcr, ocrProperties } from './ocr';
 const rerank_1 = require("./rerank");
 const speech_1 = require("./speech");
 const shared_1 = require("./shared");
+// ---------------------------------------------------------------------------
+// OCR is temporarily hidden from the UI (since v0.4.4, 2026-04-10).
+//
+// Why: Berget AI removed OCR from their public pricing/models page, and the
+// sync /v1/ocr endpoint returns HTTP 500 OCR_SERVICE_ERROR on every request.
+// Async submissions are accepted but jobs sit in 'processing' indefinitely.
+// The endpoint looks like an orphaned API surface whose backend has been
+// retired. Rather than confuse users with a broken option, we hide it.
+//
+// The full implementation is intact at nodes/BergetAi/ocr.ts and will
+// continue to compile and ship in the tarball (as dead code). If Berget
+// brings OCR back, or someone confirms it works again, re-enabling is four
+// uncomments in this file:
+//
+//   1. The `import { executeOcr, ocrProperties } from './ocr';` line above.
+//   2. The OCR entry in the `resource` dropdown options array.
+//   3. The `...ocrProperties` spread in the properties array.
+//   4. The `case 'ocr':` branch in the execute() switch.
+//
+// All four are marked with "OCR:" comments below. No code needs to change.
+// ---------------------------------------------------------------------------
 class BergetAi {
     constructor() {
         this.description = {
@@ -48,11 +71,12 @@ class BergetAi {
                             value: 'chat',
                             description: 'Create a chat completion',
                         },
-                        {
-                            name: 'OCR',
-                            value: 'ocr',
-                            description: 'Extract text from a document (PDF, DOCX, images)',
-                        },
+                        // OCR: uncomment this block to re-enable the OCR resource.
+                        // {
+                        // 	name: 'OCR',
+                        // 	value: 'ocr',
+                        // 	description: 'Extract text from a document (PDF, DOCX, images)',
+                        // },
                         {
                             name: 'Rerank',
                             value: 'rerank',
@@ -66,7 +90,8 @@ class BergetAi {
                     ],
                 },
                 ...chat_1.chatProperties,
-                ...ocr_1.ocrProperties,
+                // OCR: uncomment to re-enable the OCR resource properties.
+                // ...ocrProperties,
                 ...rerank_1.rerankProperties,
                 ...speech_1.speechProperties,
             ],
@@ -96,9 +121,10 @@ class BergetAi {
                     case 'chat':
                         result = await (0, chat_1.executeChat)(this, i);
                         break;
-                    case 'ocr':
-                        result = await (0, ocr_1.executeOcr)(this, i);
-                        break;
+                    // OCR: uncomment to re-enable the OCR execute branch.
+                    // case 'ocr':
+                    // 	result = await executeOcr(this, i);
+                    // 	break;
                     case 'rerank':
                         result = await (0, rerank_1.executeRerank)(this, i);
                         break;

package/dist/nodes/BergetAi/ocr.js

@@ -11,6 +11,8 @@ const showForOcr = {
         },
     },
 };
+const DEFAULT_POLLING_TIMEOUT_SECONDS = 360;
+const DEFAULT_POLLING_INTERVAL_SECONDS = 3;
 exports.ocrProperties = [
     {
         displayName: 'Document Type',
@@ -54,11 +56,11 @@ exports.ocrProperties = [
         },
     },
     {
-        displayName: 'Processing Mode',
-        name: 'ocrAsync',
+        displayName: 'Return Task ID Immediately',
+        name: 'ocrReturnTaskIdImmediately',
         type: 'boolean',
         default: false,
-        description: 'Whether to process the document asynchronously (recommended for large documents)',
+        description: 'Whether to submit the document and return immediately with a taskId instead of waiting for the result. When off (default), the node submits the job and polls internally until the OCR is done, returning the extracted content. When on, the node returns { taskId, resultUrl, status } right away so you can poll the result yourself with an HTTP Request node in a separate step — useful for very slow documents or when you want to decouple submission from retrieval.',
         ...showForOcr,
     },
     {
@@ -102,51 +104,44 @@ exports.ocrProperties = [
                     { name: 'TesserOCR', value: 'tesserocr' },
                 ],
                 default: 'easyocr',
-                description: 'OCR engine to use',
-            },
-            {
-                displayName: 'Perform OCR',
-                name: 'doOcr',
-                type: 'boolean',
-                default: true,
-                description: 'Whether to perform OCR on the document',
-            },
-            {
-                displayName: 'Extract Table Structure',
-                name: 'doTableStructure',
-                type: 'boolean',
-                default: true,
-                description: 'Whether to extract table structure',
+                description: 'OCR engine to use. Not all engines are guaranteed to be available on Berget\'s infrastructure — "easyocr" is the default and most reliable. Try another engine only if easyocr fails for a specific document.',
             },
             {
                 displayName: 'Include Images',
                 name: 'includeImages',
                 type: 'boolean',
                 default: false,
-                description: 'Whether to include base64-encoded images in the output',
+                description: 'Whether to include base64-encoded images in the extracted output',
             },
             {
-                displayName: 'Input Formats',
-                name: 'inputFormat',
-                type: 'multiOptions',
-                options: [
-                    { name: 'PDF', value: 'pdf' },
-                    { name: 'HTML', value: 'html' },
-                    { name: 'DOCX', value: 'docx' },
-                    { name: 'PPTX', value: 'pptx' },
-                ],
-                default: ['pdf'],
-                description: 'Input formats to accept',
+                displayName: 'Polling Timeout (Seconds)',
+                name: 'pollingTimeoutSeconds',
+                type: 'number',
+                typeOptions: { minValue: 10 },
+                default: DEFAULT_POLLING_TIMEOUT_SECONDS,
+                description: "Maximum number of seconds to wait for OCR to complete when Return Task ID Immediately is off. If the job hasn't finished by then, the node throws a timeout error that still includes the taskId so you can retrieve the result later with a separate HTTP Request.",
+            },
+            {
+                displayName: 'Polling Interval (Seconds)',
+                name: 'pollingIntervalSeconds',
+                type: 'number',
+                typeOptions: { minValue: 1 },
+                default: DEFAULT_POLLING_INTERVAL_SECONDS,
+                description: 'How many seconds to wait between polls when checking the OCR task status. Berget suggests ~2s, so values of 2–5 are reasonable. The server may override this with a Retry-After header.',
             },
         ],
         ...showForOcr,
     },
 ];
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function executeOcr(context, itemIndex) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     const credentials = await context.getCredentials('bergetAiApi');
+    const apiKey = credentials.apiKey;
     const documentType = context.getNodeParameter('ocrDocumentType', itemIndex);
-    const asyncMode = context.getNodeParameter('ocrAsync', itemIndex);
+    const returnImmediately = context.getNodeParameter('ocrReturnTaskIdImmediately', itemIndex, false);
     const options = context.getNodeParameter('ocrOptions', itemIndex, {});
     let documentUrl;
     if (documentType === 'url') {
@@ -156,22 +151,28 @@ async function executeOcr(context, itemIndex) {
         const documentData = context.getNodeParameter('ocrDocumentData', itemIndex);
         documentUrl = `data:application/pdf;base64,${documentData}`;
     }
-    const body = {
+    // Always submit async. Berget's sync /ocr endpoint returns HTTP 500
+    // OCR_SERVICE_ERROR on every request as of 2026-04; the async path is
+    // the only one that actually works. We wrap polling so the user sees a
+    // synchronous result by default.
+    const requestBody = {
         document: { url: documentUrl, type: 'document' },
-        async: asyncMode,
+        async: true,
         options: {
             outputFormat: (_a = options.outputFormat) !== null && _a !== void 0 ? _a : 'md',
             tableMode: (_b = options.tableMode) !== null && _b !== void 0 ? _b : 'accurate',
             ocrMethod: (_c = options.ocrMethod) !== null && _c !== void 0 ? _c : 'easyocr',
-            doOcr: options.doOcr !== false,
-            doTableStructure: options.doTableStructure !== false,
             includeImages: (_d = options.includeImages) !== null && _d !== void 0 ? _d : false,
-            inputFormat: (_e = options.inputFormat) !== null && _e !== void 0 ? _e : ['pdf'],
         },
     };
-    const { status, data } = await (0, shared_1.bergetRequest)(credentials.apiKey, 'POST', '/ocr', body);
-    if (status === 200) {
-        const d = data;
+    const submission = await (0, shared_1.bergetRequest)(apiKey, 'POST', '/ocr', requestBody);
+    if (submission.status !== 202 && submission.status !== 200) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), (0, shared_1.formatBergetError)('OCR submission', submission.status, submission.data), { itemIndex });
+    }
+    // If Berget ever starts honoring sync again, it'll return a full result at 200.
+    // Pass that through directly.
+    if (submission.status === 200) {
+        const d = submission.data;
         return {
             content: d.content,
             usage: d.usage,
@@ -179,15 +180,54 @@ async function executeOcr(context, itemIndex) {
             processing_mode: 'synchronous',
         };
     }
-    if (status === 202) {
-        const d = data;
+    const submissionData = submission.data;
+    const taskId = submissionData.taskId;
+    const resultUrl = submissionData.resultUrl;
+    if (!taskId) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Berget AI OCR submission accepted but returned no taskId', { itemIndex });
+    }
+    if (returnImmediately) {
         return {
-            taskId: d.taskId,
-            status: d.status,
-            resultUrl: d.resultUrl,
+            taskId,
+            resultUrl,
+            status: (_e = submissionData.status) !== null && _e !== void 0 ? _e : 'pending',
             processing_mode: 'asynchronous',
-            message: 'Document processing started. Use the taskId to check status.',
+            message: 'Document processing started. Use the taskId with an HTTP Request node against resultUrl to retrieve the extracted content later.',
         };
     }
-    throw new n8n_workflow_1.NodeOperationError(context.getNode(), (0, shared_1.formatBergetError)('OCR', status, data), { itemIndex });
+    // Poll loop.
+    const timeoutSeconds = (_f = options.pollingTimeoutSeconds) !== null && _f !== void 0 ? _f : DEFAULT_POLLING_TIMEOUT_SECONDS;
+    const intervalSeconds = Math.max((_g = options.pollingIntervalSeconds) !== null && _g !== void 0 ? _g : DEFAULT_POLLING_INTERVAL_SECONDS, 1);
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    while (Date.now() < deadline) {
+        const poll = await (0, shared_1.bergetRequest)(apiKey, 'GET', `/ocr/result/${encodeURIComponent(taskId)}`);
+        if (poll.status === 200) {
+            const d = poll.data;
+            return {
+                content: d.content,
+                usage: d.usage,
+                metadata: d.metadata,
+                taskId,
+                processing_mode: 'asynchronous',
+            };
+        }
+        if (poll.status === 202) {
+            // Berget has returned multiple response shapes on 202:
+            //   { id, status: 'processing', retryAfter: 2000 }
+            //   { error: { message: 'OCR job is still processing', type: 'OCR_JOB_PROCESSING', param: { status, retryAfter } } }
+            // If status is 'failed', surface that as an error instead of looping.
+            const d = poll.data;
+            const observedStatus = (_h = d.status) !== null && _h !== void 0 ? _h : (_k = (_j = d.error) === null || _j === void 0 ? void 0 : _j.param) === null || _k === void 0 ? void 0 : _k.status;
+            if (observedStatus === 'failed') {
+                throw new n8n_workflow_1.NodeOperationError(context.getNode(), (0, shared_1.formatBergetError)('OCR', 202, poll.data) + ` — taskId: ${taskId}`, { itemIndex });
+            }
+            await sleep(intervalSeconds * 1000);
+            continue;
+        }
+        if (poll.status === 404) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Berget AI OCR error: task ${taskId} not found (HTTP 404). The task may have been deleted or never existed.`, { itemIndex });
+        }
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), (0, shared_1.formatBergetError)('OCR polling', poll.status, poll.data) + ` — taskId: ${taskId}`, { itemIndex });
+    }
+    throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Berget AI OCR polling timed out after ${timeoutSeconds}s. The job may still be running on Berget's side. You can retrieve the result later by doing GET /v1/ocr/result/${taskId} with your API key. To avoid this, increase the Polling Timeout option or enable 'Return Task ID Immediately'.`, { itemIndex });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-berget-mk",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "n8n community node for Berget AI. Multi-resource action node (chat, OCR, rerank, speech-to-text) plus Chat Model and Embeddings Model sub-nodes that plug into n8n's built-in AI Agent and Vector Store nodes.",
   "keywords": [
     "n8n-community-node-package",