n8n-nodes-lenz 0.4.2 → 0.5.0

package/README.md

@@ -29,7 +29,7 @@ Operations are grouped under a **Resource** picker. (Nodes added before v0.1.10
 |---|---|
 | **Verify (Deep)** *(default)* | Full multi-model pipeline (research → debate → adjudication), ~90 seconds. Returns a verdict, confidence, `lenz_score` (1-10), `key_finding`, sourced citations, and an executive summary. Reserve for high-stakes claims that need a thorough, cited answer. **Depth** trades work for price: *Low* searches fewer sources, skips the recovery fetch tiers and stops the debate after the opening arguments, for **5 credits instead of 10**. |
 | **Assess (Fast)** | A quick 3-model panel verdict, ~10 seconds, one entry per claim identified in the input text. Good default for lower-stakes checks. |
-| **Extract Claims** | Free — pulls the verifiable factual claims out of a block of text without checking them. Useful as a first step before running Assess or Verify on each claim individually. **Focus** narrows the result to the claims you describe (300 characters, no extra cost); when none of them match, `status` comes back as `no_match` with an empty list rather than the unfocused claims. |
+| **Extract Claims** | Free — pulls the verifiable factual claims out of a block of text without checking them. Useful as a first step before running Assess or Verify on each claim individually. **Focus** narrows the result to the claims you describe (300 characters, no extra cost); when none of them match, `status` comes back as `no_match` with an empty list rather than the unfocused claims. **Text** can also be a single public web page URL: Lenz reads the page, or a YouTube video's transcript, and extracts the claims from its first 50,000 characters. Pages behind a login (Facebook, Instagram, Threads, LinkedIn) can't be read, and a URL call typically takes 5-40 seconds. |
 
 ### Verification — manage submitted and stored work
 
@@ -65,9 +65,11 @@ Verify and Get also expose an **Include Audit Trail** toggle, which adds the adj
 
 ### Retry safety
 
-Billable calls (Verify, Assess, Extract, Submit Batch, Select Claims) send an `Idempotency-Key` derived from the execution ID, a hash of the node's identity, the item index, and a fingerprint of the request body. If n8n retries the node — via **Retry On Fail**, or after a dropped response — the input is identical, so Lenz replays the original response instead of charging you a second time. A fresh run of the workflow is a new execution, so it bills normally.
+Billable calls (Verify, Assess, Extract, Submit Batch, Select Claims, Ask Follow-Up) send an `Idempotency-Key` derived from the execution ID, a hash of the node's identity, the item index, and a fingerprint of the request — its path as well as its body. If n8n retries the node — via **Retry On Fail**, or after a dropped response — the input is identical, so Lenz replays the original response instead of charging you a second time. A fresh run of the workflow is a new execution, so it bills normally.
 
-Including the body in the key is what makes repeated runs safe: **Loop Over Items** and **AI Agent** tool calls both execute the node several times within a single execution, each time restarting the item index at 0, so a position-only key would send one key with different inputs and the API would reject it.
+On **Ask Follow-Up** the key also keeps the conversation clean: an unkeyed retry asks the question again, so the question and a second answer are appended to the history that **Get Ask History** returns and that the next follow-up reads as context. A retry that arrives while the first question is still being answered gets a `409` — there is no answer yet to replay.
+
+Including the request in the key is what makes repeated runs safe: **Loop Over Items** and **AI Agent** tool calls both execute the node several times within a single execution, each time restarting the item index at 0, so a position-only key would send one key with different inputs and the API would reject it. The path is part of it because **Ask Follow-Up** and **Select Claims** name what they act on in the URL rather than in the body — asking one fixed question of several verifications, the wiring suggested below, is otherwise indistinguishable from a retry of the first.
 
 Note that **Assess bills per claim found in the text**, not per request: a paragraph containing five claims spends five assess units.
 
@@ -85,6 +87,7 @@ Built against `n8n-workflow` (n8n API version 1) and tested against n8n v2.30.4.
 ## Usage
 
 - **Verify (Deep) takes ~90 seconds** — it's the full multi-model pipeline, not an instant call. The node blocks/polls until the result is ready, so no separate polling setup is needed on your end.
+- **If it outlasts Max Wait (Seconds)**, the node returns `status: "timeout"` with the `task_id` and `passed: null` instead of a verdict. Nothing is lost — giving up does not cancel anything, the verification keeps running server-side, and the credits were spent at submit either way. Collect it later with **Get Verify Status**, or raise **Max Wait (Seconds)** (default 120). A poll that fails with a 5xx, a 429 or a 408/425 is retried for as long as the window lasts rather than failing the item; a 429 waits the reopening time the API states instead of returning on the node's own cadence. A failure carrying no HTTP status at all — a DNS or TLS problem, say — is different: it could equally be a bug or a bad credential, so it gets two retries and is then surfaced as the error it is. If the window ends on a failed poll, the `timeout` result names it in `last_error` and `last_error_status`.
 - **Low depth drops a debate round, not just sources.** As well as searching fewer sources and skipping the recovery fetch tiers, *Low* stops the debate after the opening arguments — so with **Include Audit Trail** on, `audit.debate_pro.rebuttal` and `audit.debate_con.rebuttal` come back as empty strings. Every step that does run uses the same models, so Low is a volume lever rather than a model downgrade — but it is one round of argument fewer, not merely a narrower search.
 - **You are charged for the Depth you asked for, not the one you got.** A *Low* request that Lenz can answer from an existing *standard* verdict still costs 5 — and the `depth` field on the result reads `standard`, because it describes the evidence behind the verdict rather than the request. Seeing `standard` come back from a *Low* request is correct, not a bug.
 - To feed data from a previous node instead of a fixed value, toggle a field to **Expression** and reference it, e.g. `{{ $json.output }}`.
@@ -106,8 +109,11 @@ A simple "fact-check gate" pattern — verify an LLM's output before acting on i
 
 1. Add an **LLM node** (or any node producing text) upstream.
 2. Add the **Lenz node**, set Operation to **Verify (Deep)**, and set the Claim field to an expression referencing the upstream output, e.g. `{{ $json.text }}`.
-3. Add an **IF node** after Lenz with the condition `{{ $json.passed }}` **is true**.
-4. Wire the true branch to continue the workflow normally, and the false branch to whatever your "needs review" path is (Slack alert, email, a manual-approval step, etc.).
+3. Add an **IF node** after Lenz with the condition `{{ $json.status }}` **equals** `completed`. Send the false branch wherever unfinished work should go — a timeout, a `failed` pipeline or a `needs_input` interrupt is not a verdict, and its `passed` is `null`.
+4. After that, add a second **IF node** with the condition `{{ $json.passed }}` **is true**.
+5. Wire its true branch to continue the workflow normally, and its false branch to whatever your "needs review" path is (Slack alert, email, a manual-approval step, etc.).
+
+> **Check `status` before `passed`.** `passed` only means something once a verdict exists. A timeout, a `failed` pipeline or a `needs_input` interrupt has no verdict, and `passed` is `null` or absent — which an IF reads as false. Branching straight on `passed` therefore reports "this claim did not pass" for a claim nobody ever checked, and a provider outage becomes a debunking.
 
 For a lighter check on lower-stakes content, swap the Lenz operation to **Assess (Fast)** instead — same wiring, ~10s instead of ~90s.
 
@@ -218,6 +224,8 @@ So the Wait node has a number to read, the error output carries the refusal as f
 
 * **0.4.2** — Two corrections to what 0.4.x said about **Depth**, both of them wrong rather than merely unclear. The low-depth price was documented as appearing in `costs` under `verify_low`, with the advice to divide `credits.remaining` by it: that key does not exist — the API carries the four capability keys in `costs` and nothing else — so the suggested expression evaluated to `NaN`. The price is readable only at `cost_options.verify.depth.low`, which is where the docs now point. Separately, *Low* was described as searching fewer sources and skipping the recovery fetch tiers; it also stops the debate after the opening arguments, so a Low verdict has no rebuttal round and comes back with an empty `rebuttal` on its debate entries under **Include Audit Trail**. Every description of Depth in the node and the README now says so.
 
+* **0.5.0** — **Verify (Deep) no longer loses a verification you have already paid for.** Credits are debited the moment a submit is accepted, and the poll loop that waits for the verdict had no tolerance for a failed poll: one 502 or network blip on any of roughly fifteen polls threw straight out of the operation and took the `task_id` with it, leaving a verification that was charged for, still running server-side, and unreachable — not even **Get Verify Status** could fetch it back. Transient poll failures (5xx, 429, and the 408/425 an intervening proxy produces) are now retried for as long as the wait lasts, and a 429 waits the reopening time the API states rather than returning on the node's own cadence, which is what tripped the limiter to begin with. A failure carrying no HTTP status is treated differently on purpose — a DNS or TLS problem is indistinguishable from a bug or a bad credential, so it gets a small bounded number of attempts and is then surfaced as the error it is, rather than retried for the window and reported as a timeout, which would invent a fact. The `task_id` now rides every post-submit failure, on the error output and on the thrown error alike. The hardcoded 120-second deadline becomes **Max Wait (Seconds)**, validated and clamped before the claim is submitted — validated afterwards, a non-numeric expression got the claim charged and then threw an error with nowhere to carry the task id, which is the same bug by another route. Non-verdict terminals now carry `passed: null` so the key is visible in n8n's output schema; be aware that null is still falsy, so an **IF** node reading `{{ $json.passed }}` alone routes a timeout down the false arm exactly as before. Checking `status` first is the actual fix, and the README's gate pattern now leads with it — a provider outage reading as a debunking was the real bug. A timeout that ends on a failed poll names it in `last_error` and `last_error_status`, instead of reporting success-shaped JSON that implies the task was seen running. Alongside that, four correctness fixes a first external user would hit: **Get Many** duplicated and skipped rows above Limit 100 (#21), **Select Claims** collided two paused tasks that offered the same claim text onto one Idempotency-Key (#22), validation failures surfaced as API errors with no HTTP code (#23), and **Ask Follow-Up** sent no Idempotency-Key, so a retry appended a second question and answer to the stored conversation. No output field was removed or renamed.
+
   It also carries two fixes that are behaviour, not wording. The `Idempotency-Key` was built from the node's **display name**, which is user-editable free text. Node refuses to send a header value containing anything above U+00FF, so a node named in Cyrillic, Greek, Hebrew, Arabic or any CJK script — or carrying an emoji — failed **every billable call** before the request left the machine, with an error naming the header rather than the node. Latin-1 names such as `Prüfung` and `Vérification` were never affected, despite what an earlier draft of this entry said. The identity is now *hashed* into the key rather than written into it, which makes the guarantee structural rather than an assumption about what the id contains; the node id is preferred, so a rename mid-execution no longer changes the key, and the name never reaches the wire.
 
   Separately, a `sources` value that was not a list — or a list containing `null` — threw while mapping the result, failing a verification that had already completed and been charged for. A `null` entry now costs that one citation; a `sources` that is not a list returns none at all, which is worth knowing if you branch on `citations.length`. No output field was removed or renamed. Two things changed on the wire: the `User-Agent` version, and the `Idempotency-Key` format.

package/dist/nodes/Lenz/Lenz.node.js

@@ -3,10 +3,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lenz = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const BASE_URL = 'https://lenz.io/api/v1';
-const USER_AGENT = 'n8n-nodes-lenz/0.4.2';
+const USER_AGENT = 'n8n-nodes-lenz/0.5.0';
 const API_VERSION = '2026-08-05';
 const POLL_TIMEOUT_MS = 120000;
 const POLL_BACKOFF_MS = [2000, 4000, 8000];
+const MAX_WAIT_FLOOR_SECONDS = 10;
+const MAX_WAIT_CEILING_SECONDS = 900;
+const MAX_UNCLASSIFIED_POLL_RETRIES = 2;
+async function waitForNextPoll(pollIdx, deadline, overrideMs) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+        return false;
+    }
+    const backoff = overrideMs !== undefined
+        ? overrideMs
+        : POLL_BACKOFF_MS[Math.min(pollIdx, POLL_BACKOFF_MS.length - 1)];
+    await (0, n8n_workflow_1.sleep)(Math.min(backoff, remaining));
+    return true;
+}
+function submittedReceipt(taskId) {
+    return (`A verification for this item was submitted and charged before this failed — ` +
+        `its task ID is ${taskId}. It may still be running; fetch the result with ` +
+        `Get Verify Status rather than resubmitting.`);
+}
+function statedRetryAfterMs(error) {
+    const body = responseBodyOf(error);
+    for (const raw of [body.retry_after, body.reset_in_seconds]) {
+        const seconds = Number(raw);
+        if (Number.isFinite(seconds) && seconds > 0) {
+            return Math.ceil(seconds) * 1000;
+        }
+    }
+    return undefined;
+}
 const BATCH_MAX_CLAIMS = 20;
 const MAX_FOCUS_CHARS = 300;
 const MAX_PAGE_SIZE = 100;
@@ -199,6 +228,7 @@ function mapVerifyStatus(status, taskId, includeAudit) {
         const reason = status.reason;
         return {
             status: 'needs_input',
+            passed: null,
             reason: reason !== null && reason !== void 0 ? reason : null,
             task_id: taskId,
             claims: (_b = status.claims) !== null && _b !== void 0 ? _b : [],
@@ -208,10 +238,11 @@ function mapVerifyStatus(status, taskId, includeAudit) {
         };
     }
     if (state === 'failed') {
-        return { status: 'failed', task_id: taskId, ...failureFields(status) };
+        return { status: 'failed', passed: null, task_id: taskId, ...failureFields(status) };
     }
     return {
         status: 'processing',
+        passed: null,
         task_id: taskId,
         progress: (_e = status.progress) !== null && _e !== void 0 ? _e : {},
     };
@@ -285,7 +316,7 @@ class Lenz {
                         {
                             name: 'Extract Claims',
                             value: 'extract',
-                            description: 'Pull verifiable claims out of text. Free, capped at 1000 calls per account per day, shared across your API keys (resets 00:00 UTC).',
+                            description: 'Pull verifiable claims out of text, or out of a public web page given its URL. Free, capped at 1000 calls per account per day, shared across your API keys (resets 00:00 UTC).',
                             action: 'Extract claims from text',
                         },
                         {
@@ -429,7 +460,7 @@ class Lenz {
                         {
                             name: 'Extract Claims',
                             value: 'extract',
-                            description: 'Pull verifiable claims out of text. Free, capped at 1000 calls per account per day, shared across your API keys (resets 00:00 UTC).',
+                            description: 'Pull verifiable claims out of text, or out of a public web page given its URL. Free, capped at 1000 calls per account per day, shared across your API keys (resets 00:00 UTC).',
                             action: 'Extract claims from text',
                         },
                         {
@@ -475,7 +506,7 @@ class Lenz {
                     displayOptions: {
                         show: { operation: ['extract'] },
                     },
-                    description: 'The text to pull the verifiable claims out of',
+                    description: "The text to pull the verifiable claims out of, or a single public web page URL. Lenz reads the page, or a YouTube video's transcript, and extracts the claims from its first 50,000 characters; pages behind a login can't be read. A URL call typically takes 5-40 seconds.",
                 },
                 {
                     displayName: 'Claims',
@@ -633,6 +664,17 @@ class Lenz {
                     },
                     description: 'Whether to poll until the verification finishes (~90s). Turn off to return the task ID immediately and collect the result later via Get Verify Status or a webhook.',
                 },
+                {
+                    displayName: 'Max Wait (Seconds)',
+                    name: 'maxWaitSeconds',
+                    type: 'number',
+                    default: 120,
+                    typeOptions: { minValue: 10, maxValue: 900 },
+                    displayOptions: {
+                        show: { operation: ['verify'], waitForCompletion: [true] },
+                    },
+                    description: 'How long to keep polling before giving up and returning Status "timeout" with the task ID. A verification usually takes ~90s but can legitimately run longer. Giving up never cancels anything: the task keeps running server-side and stays fetchable with Get Verify Status, so the credits are not lost. Raise this only if the workflow can afford to block that long.',
+                },
                 {
                     displayName: 'Include Audit Trail',
                     name: 'includeAudit',
@@ -765,14 +807,14 @@ class Lenz {
         };
     }
     async execute() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
         const items = this.getInputData();
         const returnData = [];
         const executionId = this.getExecutionId();
         const node = this.getNode();
         const nodeKey = bodyFingerprint({ node: node.id || node.name });
-        const buildIdempotencyKey = (operation, itemIndex, body) => executionId
-            ? `n8n:${executionId}:${nodeKey}:${operation}:${itemIndex}:${bodyFingerprint(body)}`
+        const buildIdempotencyKey = (operation, itemIndex, path, body) => executionId
+            ? `n8n:${executionId}:${nodeKey}:${operation}:${itemIndex}:${bodyFingerprint({ path, body })}`
             : '';
         const lenzRequest = async (method, path, body, extra) => {
             const headers = {
@@ -780,7 +822,7 @@ class Lenz {
                 'X-Lenz-API-Version': API_VERSION,
             };
             if (extra === null || extra === void 0 ? void 0 : extra.idempotent) {
-                const key = buildIdempotencyKey(extra.idempotent.operation, extra.idempotent.itemIndex, body);
+                const key = buildIdempotencyKey(extra.idempotent.operation, extra.idempotent.itemIndex, path, body);
                 if (key) {
                     headers['Idempotency-Key'] = key;
                 }
@@ -801,6 +843,7 @@ class Lenz {
             return (await this.helpers.httpRequestWithAuthentication.call(this, 'lenzApi', options));
         };
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            let pendingTaskId = '';
             try {
                 const operation = this.getNodeParameter('operation', itemIndex);
                 const language = this.getNodeParameter('language', itemIndex, '') || undefined;
@@ -820,6 +863,14 @@ class Lenz {
                     const webhookUrl = this.getNodeParameter('webhookUrl', itemIndex, '').trim();
                     const visibility = this.getNodeParameter('visibility', itemIndex, '');
                     const depth = this.getNodeParameter('depth', itemIndex, 'standard');
+                    let waitSeconds = 0;
+                    if (waitForCompletion) {
+                        const requestedWait = Number(this.getNodeParameter('maxWaitSeconds', itemIndex, POLL_TIMEOUT_MS / 1000));
+                        if (!Number.isFinite(requestedWait)) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Max Wait (Seconds) must be a number of seconds', { itemIndex });
+                        }
+                        waitSeconds = Math.min(MAX_WAIT_CEILING_SECONDS, Math.max(MAX_WAIT_FLOOR_SECONDS, requestedWait));
+                    }
                     const submitBody = { text: claim };
                     if (language) {
                         submitBody.language = language;
@@ -843,6 +894,7 @@ class Lenz {
                     if (!taskId) {
                         throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Lenz accepted the claim but returned no task_id, so the verification cannot be polled', { itemIndex });
                     }
+                    pendingTaskId = taskId;
                     if (!waitForCompletion) {
                         responseData = {
                             status: (_b = accepted.status) !== null && _b !== void 0 ? _b : 'queued',
@@ -852,25 +904,71 @@ class Lenz {
                         };
                     }
                     else {
-                        const deadline = Date.now() + POLL_TIMEOUT_MS;
+                        const deadline = Date.now() + waitSeconds * 1000;
                         let terminal;
+                        let lastObservedStatus = '';
                         let pollIdx = 0;
+                        let unclassifiedRetries = 0;
+                        let lastPollError;
                         while (Date.now() < deadline) {
-                            const status = await lenzRequest('GET', `/verify/status/${taskId}`);
+                            let status;
+                            try {
+                                status = await lenzRequest('GET', `/verify/status/${taskId}`);
+                            }
+                            catch (pollError) {
+                                const code = statusCodeOf(pollError);
+                                const retryable = code === undefined
+                                    ? unclassifiedRetries < MAX_UNCLASSIFIED_POLL_RETRIES
+                                    : code >= 500 || code === 429 || code === 408 || code === 425;
+                                if (!retryable) {
+                                    throw describeApiError(this.getNode(), pollError, itemIndex, {
+                                        message: pollError.message,
+                                    });
+                                }
+                                lastPollError = {
+                                    message: pollError.message,
+                                    status: code !== null && code !== void 0 ? code : null,
+                                };
+                                if (code === undefined) {
+                                    unclassifiedRetries += 1;
+                                }
+                                const statedWait = code === 429 ? statedRetryAfterMs(pollError) : undefined;
+                                if (!(await waitForNextPoll(pollIdx, deadline, statedWait))) {
+                                    break;
+                                }
+                                pollIdx += 1;
+                                continue;
+                            }
+                            unclassifiedRetries = 0;
+                            lastPollError = undefined;
                             const state = status.status;
+                            lastObservedStatus = state || lastObservedStatus;
                             if (state === 'completed' || state === 'needs_input' || state === 'failed') {
                                 terminal = status;
                                 break;
                             }
-                            const backoff = POLL_BACKOFF_MS[Math.min(pollIdx, POLL_BACKOFF_MS.length - 1)];
-                            await (0, n8n_workflow_1.sleep)(Math.min(backoff, Math.max(0, deadline - Date.now())));
+                            if (!(await waitForNextPoll(pollIdx, deadline))) {
+                                break;
+                            }
                             pollIdx += 1;
                         }
                         if (!terminal) {
                             responseData = {
                                 status: 'timeout',
+                                passed: null,
                                 task_id: taskId,
-                                message: 'The verification did not complete in time (task_id: ' + taskId + '). It may still be running server-side.',
+                                last_status: lastObservedStatus || null,
+                                last_error: (_d = lastPollError === null || lastPollError === void 0 ? void 0 : lastPollError.message) !== null && _d !== void 0 ? _d : null,
+                                last_error_status: (_e = lastPollError === null || lastPollError === void 0 ? void 0 : lastPollError.status) !== null && _e !== void 0 ? _e : null,
+                                message: 'The verification did not complete within Max Wait (task_id: ' +
+                                    taskId +
+                                    '). ' +
+                                    (lastPollError
+                                        ? 'The last attempt to read its status failed with: ' +
+                                            lastPollError.message +
+                                            '. The task itself may be unaffected — '
+                                        : 'It may still be running server-side — ') +
+                                    'the credits were spent at submit either way, so fetch the result later with Get Verify Status rather than resubmitting.',
                             };
                         }
                         else {
@@ -893,7 +991,7 @@ class Lenz {
                 }
                 else if (operation === 'verifyBatch') {
                     const batchUi = this.getNodeParameter('batchClaims', itemIndex, {});
-                    const entries = ((_d = batchUi.claim) !== null && _d !== void 0 ? _d : []).filter((entry) => { var _a; return ((_a = entry.text) !== null && _a !== void 0 ? _a : '').trim() !== ''; });
+                    const entries = ((_f = batchUi.claim) !== null && _f !== void 0 ? _f : []).filter((entry) => { var _a; return ((_a = entry.text) !== null && _a !== void 0 ? _a : '').trim() !== ''; });
                     if (!entries.length) {
                         returnData.push({
                             json: { skipped: true, reason: 'empty_input' },
@@ -945,14 +1043,14 @@ class Lenz {
                     const accepted = await lenzRequest('POST', '/verify/batch', body, {
                         idempotent: { operation, itemIndex },
                     });
-                    const batchId = (_e = accepted.batch_id) !== null && _e !== void 0 ? _e : '';
+                    const batchId = (_g = accepted.batch_id) !== null && _g !== void 0 ? _g : '';
                     const partial = accepted.partial === true;
-                    for (const spawned of ((_f = accepted.items) !== null && _f !== void 0 ? _f : [])) {
+                    for (const spawned of ((_h = accepted.items) !== null && _h !== void 0 ? _h : [])) {
                         returnData.push({
                             json: {
                                 batch_id: batchId,
-                                task_id: (_g = spawned.task_id) !== null && _g !== void 0 ? _g : '',
-                                claim_text: (_h = spawned.claim_text) !== null && _h !== void 0 ? _h : '',
+                                task_id: (_j = spawned.task_id) !== null && _j !== void 0 ? _j : '',
+                                claim_text: (_k = spawned.claim_text) !== null && _k !== void 0 ? _k : '',
                                 status: 'queued',
                                 partial,
                             },
@@ -963,7 +1061,7 @@ class Lenz {
                 }
                 else if (operation === 'select') {
                     const taskId = this.getNodeParameter('taskId', itemIndex).trim();
-                    const selected = ((_j = this.getNodeParameter('selectedClaims', itemIndex, [])) !== null && _j !== void 0 ? _j : [])
+                    const selected = ((_l = this.getNodeParameter('selectedClaims', itemIndex, [])) !== null && _l !== void 0 ? _l : [])
                         .map((text) => (text !== null && text !== void 0 ? text : '').trim())
                         .filter((text) => text !== '');
                     if (!taskId || !selected.length) {
@@ -977,14 +1075,14 @@ class Lenz {
                         throw new n8n_workflow_1.NodeOperationError(this.getNode(), `At most ${BATCH_MAX_CLAIMS} claims can be selected, got ${selected.length}`, { itemIndex });
                     }
                     const accepted = await lenzRequest('POST', `/verify/${taskId}/select`, { texts: selected }, { idempotent: { operation, itemIndex } });
-                    const batchId = (_k = accepted.batch_id) !== null && _k !== void 0 ? _k : '';
+                    const batchId = (_m = accepted.batch_id) !== null && _m !== void 0 ? _m : '';
                     const partial = accepted.partial === true;
-                    for (const spawned of ((_l = accepted.items) !== null && _l !== void 0 ? _l : [])) {
+                    for (const spawned of ((_o = accepted.items) !== null && _o !== void 0 ? _o : [])) {
                         returnData.push({
                             json: {
                                 batch_id: batchId,
-                                task_id: (_m = spawned.task_id) !== null && _m !== void 0 ? _m : '',
-                                claim_text: (_o = spawned.claim_text) !== null && _o !== void 0 ? _o : '',
+                                task_id: (_p = spawned.task_id) !== null && _p !== void 0 ? _p : '',
+                                claim_text: (_q = spawned.claim_text) !== null && _q !== void 0 ? _q : '',
                                 status: 'queued',
                                 partial,
                             },
@@ -1009,12 +1107,12 @@ class Lenz {
                     const result = await lenzRequest('POST', '/assess', body, {
                         idempotent: { operation, itemIndex },
                     });
-                    const claims = ((_p = result.claims) !== null && _p !== void 0 ? _p : []);
+                    const claims = ((_r = result.claims) !== null && _r !== void 0 ? _r : []);
                     if (!claims.length) {
                         responseData = {
                             status: result.error_code === 'ambiguous' ? 'ambiguous' : 'no_claim',
-                            message: (_q = result.error) !== null && _q !== void 0 ? _q : 'No verifiable factual claim was detected.',
-                            candidate_claims: (_r = result.candidate_claims) !== null && _r !== void 0 ? _r : [],
+                            message: (_s = result.error) !== null && _s !== void 0 ? _s : 'No verifiable factual claim was detected.',
+                            candidate_claims: (_t = result.candidate_claims) !== null && _t !== void 0 ? _t : [],
                         };
                     }
                     else {
@@ -1071,9 +1169,11 @@ class Lenz {
                     if (language) {
                         body.language = language;
                     }
-                    const reply = await lenzRequest('POST', `/ask/${verificationId}`, body);
+                    const reply = await lenzRequest('POST', `/ask/${verificationId}`, body, {
+                        idempotent: { operation, itemIndex },
+                    });
                     responseData = {
-                        answer: (_s = reply.content) !== null && _s !== void 0 ? _s : '',
+                        answer: (_u = reply.content) !== null && _u !== void 0 ? _u : '',
                     };
                 }
                 else if (operation === 'askHistory') {
@@ -1113,7 +1213,7 @@ class Lenz {
                         detail.status === 'failed'
                             ? {
                                 status: 'failed',
-                                verification_id: (_t = detail.verification_id) !== null && _t !== void 0 ? _t : verificationId,
+                                verification_id: (_v = detail.verification_id) !== null && _v !== void 0 ? _v : verificationId,
                                 ...failureFields(detail),
                             }
                             : mapCompletedVerification(detail, includeAudit);
@@ -1136,12 +1236,12 @@ class Lenz {
                         : this.getNodeParameter('limit', itemIndex, 50);
                     let page = 1;
                     let collected = 0;
+                    const pageSize = returnAll ? MAX_PAGE_SIZE : Math.min(MAX_PAGE_SIZE, limit);
                     while (collected < limit) {
-                        const pageSize = returnAll ? MAX_PAGE_SIZE : Math.min(MAX_PAGE_SIZE, limit - collected);
                         const response = await lenzRequest('GET', '/verifications', undefined, {
                             qs: { page, page_size: pageSize },
                         });
-                        const pageItems = ((_u = response.items) !== null && _u !== void 0 ? _u : []);
+                        const pageItems = ((_w = response.items) !== null && _w !== void 0 ? _w : []);
                         for (const verification of pageItems) {
                             if (collected >= limit) {
                                 break;
@@ -1152,7 +1252,7 @@ class Lenz {
                             });
                             collected += 1;
                         }
-                        const total = (_v = response.total) !== null && _v !== void 0 ? _v : 0;
+                        const total = (_x = response.total) !== null && _x !== void 0 ? _x : 0;
                         if (pageItems.length < pageSize || collected >= total) {
                             break;
                         }
@@ -1171,7 +1271,7 @@ class Lenz {
                     }
                     const relatedLimit = this.getNodeParameter('relatedLimit', itemIndex, 5);
                     const response = await lenzRequest('GET', `/verifications/${verificationId}/related`, undefined, { qs: { limit: relatedLimit } });
-                    for (const related of ((_w = response.items) !== null && _w !== void 0 ? _w : [])) {
+                    for (const related of ((_y = response.items) !== null && _y !== void 0 ? _y : [])) {
                         returnData.push({
                             json: related,
                             pairedItem: { item: itemIndex },
@@ -1195,6 +1295,9 @@ class Lenz {
             catch (error) {
                 if (this.continueOnFail()) {
                     const json = { error: error.message };
+                    if (pendingTaskId) {
+                        json.task_id = pendingTaskId;
+                    }
                     const status = statusCodeOf(error);
                     if (status !== undefined) {
                         json.status_code = status;
@@ -1213,7 +1316,7 @@ class Lenz {
                     if (typeof body.credits_remaining === 'number') {
                         json.credits_remaining = body.credits_remaining;
                     }
-                    const typed = (_x = quotaMessageFor(error)) !== null && _x !== void 0 ? _x : capacityMessageFor(error);
+                    const typed = (_z = quotaMessageFor(error)) !== null && _z !== void 0 ? _z : capacityMessageFor(error);
                     if (typed) {
                         json.error_message = typed.message;
                         json.error_description = typed.description;
@@ -1224,6 +1327,13 @@ class Lenz {
                     });
                     continue;
                 }
+                if (error instanceof n8n_workflow_1.NodeOperationError) {
+                    const opReceipt = pendingTaskId ? submittedReceipt(pendingTaskId) : '';
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, {
+                        itemIndex,
+                        description: [(_0 = error.description) !== null && _0 !== void 0 ? _0 : '', opReceipt].filter(Boolean).join(' ') || undefined,
+                    });
+                }
                 const quota = quotaMessageFor(error);
                 if (quota) {
                     throw describeApiError(this.getNode(), error, itemIndex, quota, '402');
@@ -1232,8 +1342,13 @@ class Lenz {
                 if (capacity) {
                     throw describeApiError(this.getNode(), error, itemIndex, capacity, '503');
                 }
+                const existingDescription = error instanceof n8n_workflow_1.NodeApiError ? ((_1 = error.description) !== null && _1 !== void 0 ? _1 : '') : '';
+                const receipt = pendingTaskId ? submittedReceipt(pendingTaskId) : '';
                 throw describeApiError(this.getNode(), error, itemIndex, {
                     message: error.message,
+                    ...(receipt
+                        ? { description: [existingDescription, receipt].filter(Boolean).join(' ') }
+                        : {}),
                 });
             }
         }