n8n-nodes-lenz 0.0.1

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

@@ -0,0 +1,1099 @@
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+
+// node_modules/lenz-io/dist/index.cjs
+var require_dist = __commonJS({
+  "node_modules/lenz-io/dist/index.cjs"(exports2, module2) {
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      API_VERSION: () => API_VERSION,
+      DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+      DEFAULT_REPLAY_WINDOW_SECONDS: () => DEFAULT_REPLAY_WINDOW_SECONDS,
+      Lenz: () => Lenz2,
+      LenzAPIError: () => LenzAPIError,
+      LenzAuthError: () => LenzAuthError,
+      LenzError: () => LenzError,
+      LenzNeedsInputError: () => LenzNeedsInputError,
+      LenzPipelineError: () => LenzPipelineError,
+      LenzQuotaExceededError: () => LenzQuotaExceededError,
+      LenzRateLimitError: () => LenzRateLimitError,
+      LenzTimeoutError: () => LenzTimeoutError,
+      LenzValidationError: () => LenzValidationError,
+      LenzWebhookSignatureError: () => LenzWebhookSignatureError,
+      LenzWebhooks: () => LenzWebhooks,
+      SIGNATURE_HEADER: () => SIGNATURE_HEADER,
+      VERSION: () => VERSION,
+      mapResponseToError: () => mapResponseToError,
+      verifySignature: () => verifySignature
+    });
+    module2.exports = __toCommonJS(index_exports);
+    var import_node_crypto = require("crypto");
+    var LenzError = class extends Error {
+      cause_;
+      fix;
+      docUrl;
+      requestId;
+      statusCode;
+      body;
+      constructor(ctx = {}) {
+        super(ctx.message || new.target.name);
+        this.name = new.target.name;
+        this.cause_ = ctx.cause ?? "";
+        this.fix = ctx.fix ?? "";
+        this.docUrl = ctx.docUrl ?? "";
+        this.requestId = ctx.requestId ?? "";
+        this.statusCode = ctx.statusCode ?? 0;
+        this.body = ctx.body ?? null;
+      }
+      toString() {
+        const lines = [this.message || this.name];
+        if (this.cause_) lines.push(`  Cause:  ${this.cause_}`);
+        if (this.fix) lines.push(`  Fix:    ${this.fix}`);
+        if (this.docUrl) lines.push(`  Docs:   ${this.docUrl}`);
+        if (this.requestId) lines.push(`  Request ID: ${this.requestId}`);
+        return lines.join("\n");
+      }
+    };
+    var LenzAuthError = class extends LenzError {
+    };
+    var LenzQuotaExceededError = class extends LenzError {
+      creditsRemaining = 0;
+    };
+    var LenzValidationError = class extends LenzError {
+      errors = [];
+    };
+    var LenzRateLimitError = class extends LenzError {
+      retryAfter = 0;
+    };
+    var LenzAPIError = class extends LenzError {
+    };
+    var LenzTimeoutError = class extends LenzError {
+      taskId = "";
+    };
+    var LenzNeedsInputError = class extends LenzError {
+      taskId = "";
+      kind = "";
+      payload = {};
+    };
+    var LenzPipelineError = class extends LenzError {
+      taskId = "";
+      failureReason = "";
+    };
+    var LenzWebhookSignatureError = class extends LenzError {
+    };
+    var DOCS_BASE = "https://lenz.io/docs";
+    var STATUS_MAP = {
+      401: { cls: LenzAuthError, message: "Unauthorized", docUrl: `${DOCS_BASE}/auth` },
+      403: { cls: LenzAuthError, message: "Forbidden", docUrl: `${DOCS_BASE}/auth` },
+      402: {
+        cls: LenzQuotaExceededError,
+        message: "Payment required",
+        docUrl: `${DOCS_BASE}/billing`
+      },
+      422: {
+        cls: LenzValidationError,
+        message: "Validation failed",
+        docUrl: `${DOCS_BASE}/errors/validation`
+      },
+      429: {
+        cls: LenzRateLimitError,
+        message: "Rate limit exceeded",
+        docUrl: `${DOCS_BASE}/rate-limits`
+      }
+    };
+    var FIX_HINTS = {
+      401: "Generate a new key at https://lenz.io/api-integration.",
+      403: "This key doesn't have access to that resource.",
+      402: "Upgrade your plan or wait for the period reset.",
+      422: "Check the request body against the OpenAPI spec.",
+      429: "Wait Retry-After seconds and retry."
+    };
+    function parseBody(raw) {
+      if (!raw) return {};
+      try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+      } catch {
+        return {};
+      }
+    }
+    function getHeader(headers, name) {
+      return headers[name] ?? headers[name.toLowerCase()] ?? headers[name.toUpperCase()] ?? "";
+    }
+    function mapResponseToError(statusCode, body, headers = {}) {
+      const parsed = parseBody(body);
+      const requestId = getHeader(headers, "X-Request-ID");
+      let entry;
+      if (statusCode in STATUS_MAP) {
+        entry = STATUS_MAP[statusCode];
+      } else if (statusCode >= 500 && statusCode < 600) {
+        entry = { cls: LenzAPIError, message: "Server error", docUrl: `${DOCS_BASE}/errors` };
+      } else {
+        entry = { cls: LenzError, message: `HTTP ${statusCode}`, docUrl: `${DOCS_BASE}/errors` };
+      }
+      const detailRaw = parsed["detail"];
+      const detail = typeof detailRaw === "string" ? detailRaw : Array.isArray(detailRaw) ? "Validation failed" : entry.message;
+      const err = new entry.cls({
+        message: detail,
+        cause: detail,
+        fix: FIX_HINTS[statusCode] ?? "Retry; if the error persists, file an issue with the Request ID.",
+        docUrl: entry.docUrl,
+        requestId,
+        statusCode,
+        body: parsed
+      });
+      if (err instanceof LenzQuotaExceededError) {
+        err.creditsRemaining = Number(parsed["credits_remaining"] ?? 0);
+      } else if (err instanceof LenzValidationError) {
+        if (Array.isArray(parsed["detail"])) {
+          err.errors = parsed["detail"];
+        } else if (Array.isArray(parsed["errors"])) {
+          err.errors = parsed["errors"];
+        }
+      } else if (err instanceof LenzRateLimitError) {
+        const ra = getHeader(headers, "Retry-After") || String(parsed["retry_after"] ?? "");
+        const parsedRa = Number(ra);
+        err.retryAfter = Number.isFinite(parsedRa) ? parsedRa : 0;
+      }
+      return err;
+    }
+    var VERSION = "2.3.0";
+    var API_VERSION = "2026-05-13";
+    var DEFAULT_BASE_URL = "https://lenz.io/api/v1";
+    var DEFAULT_TIMEOUT_MS = 3e4;
+    var DEFAULT_MAX_RETRIES = 3;
+    var RETRY_BACKOFF_MS = [1e3, 2e3, 4e3];
+    var POLL_BACKOFF_MS = [2e3, 4e3, 8e3];
+    var POLL_BACKOFF_CAP_MS = 1e4;
+    function sleep(ms) {
+      return new Promise((res) => setTimeout(res, ms));
+    }
+    function retrySleepMs(attempt) {
+      return RETRY_BACKOFF_MS[Math.min(attempt, RETRY_BACKOFF_MS.length - 1)] ?? 4e3;
+    }
+    function pollSleepMs(idx, remainingMs) {
+      const base = POLL_BACKOFF_MS[Math.min(idx, POLL_BACKOFF_MS.length - 1)] ?? POLL_BACKOFF_CAP_MS;
+      return Math.min(base, POLL_BACKOFF_CAP_MS, Math.max(0, remainingMs));
+    }
+    var VerificationsNamespace = class {
+      constructor(client) {
+        this.client = client;
+      }
+      client;
+      list({ page = 1 } = {}) {
+        return this.client.request({
+          method: "GET",
+          path: "/verifications",
+          query: { page }
+        });
+      }
+      /**
+       * Fetch a single verification. Accepts anon callers — any non-hidden
+       * public claim resolves without an API key (the old `library.get`
+       * endpoint merged into this one).
+       */
+      get(verificationId) {
+        return this.client.request({
+          method: "GET",
+          path: `/verifications/${verificationId}`,
+          authRequired: false,
+          authOptional: true
+          // send the key if we have one → owner sees private rows
+        });
+      }
+      async delete(verificationId) {
+        try {
+          await this.client.request({
+            method: "DELETE",
+            path: `/verifications/${verificationId}`
+          });
+          return true;
+        } catch (exc) {
+          if (exc instanceof LenzError && exc.statusCode === 404) return true;
+          throw exc;
+        }
+      }
+      /**
+       * Public verifications semantically related to this one (pgvector ANN).
+       * Server clamps `limit` to 10. Excludes the verification itself and
+       * editorially-hidden claims. Accessible for any verification the caller
+       * owns or any public library item.
+       */
+      related(verificationId, { limit = 5 } = {}) {
+        return this.client.request({
+          method: "GET",
+          path: `/verifications/${verificationId}/related`,
+          query: { limit }
+        });
+      }
+    };
+    var AskNamespace = class {
+      constructor(client) {
+        this.client = client;
+      }
+      client;
+      history(verificationId) {
+        return this.client.request({
+          method: "GET",
+          path: `/ask/${verificationId}`
+        });
+      }
+      send(verificationId, input) {
+        const body = { message: input.message };
+        if (input.language) body.language = input.language;
+        return this.client.request({
+          method: "POST",
+          path: `/ask/${verificationId}`,
+          json: body
+        });
+      }
+      async reset(verificationId) {
+        await this.client.request({
+          method: "DELETE",
+          path: `/ask/${verificationId}`
+        });
+        return true;
+      }
+    };
+    var LibraryNamespace = class {
+      constructor(client) {
+        this.client = client;
+      }
+      client;
+      list(input = {}) {
+        return this.client.request({
+          method: "GET",
+          path: "/library",
+          query: {
+            page: input.page ?? 1,
+            sort: input.sort ?? "recent",
+            search: input.search,
+            domain: input.domain,
+            entity: input.entity
+          },
+          authRequired: false
+        });
+      }
+    };
+    var Lenz2 = class {
+      apiKey;
+      baseUrl;
+      timeoutMs;
+      maxRetries;
+      fetchImpl;
+      verifications;
+      ask;
+      library;
+      constructor(opts = {}) {
+        this.apiKey = opts.apiKey ?? process.env["LENZ_API_KEY"] ?? "";
+        this.baseUrl = (opts.baseUrl ?? process.env["LENZ_BASE_URL"] ?? DEFAULT_BASE_URL).replace(
+          /\/$/,
+          ""
+        );
+        this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+        this.verifications = new VerificationsNamespace(this);
+        this.ask = new AskNamespace(this);
+        this.library = new LibraryNamespace(this);
+      }
+      // ── Marquee verbs ──
+      async verify(input) {
+        return this.submit(input);
+      }
+      async verifyBatch(input) {
+        const body = {
+          // Per-item shape passes through verbatim — `VerifyBatchItem` allows
+          // any subset including a per-item `language` override.
+          claims: input.claims.map((c) => {
+            const item = {
+              text: c.text,
+              source_url: c.source_url ?? "",
+              webhook_url: c.webhook_url ?? ""
+            };
+            if (c.language) item.language = c.language;
+            return item;
+          })
+        };
+        if (input.webhookUrl) body["webhook_url"] = input.webhookUrl;
+        if (input.language) body["language"] = input.language;
+        const headers = {};
+        if (input.idempotencyKey) headers["Idempotency-Key"] = input.idempotencyKey;
+        return this.request({
+          method: "POST",
+          path: "/verify/batch",
+          json: body,
+          headers
+        });
+      }
+      async extract(input) {
+        const body = { text: input.text };
+        if (input.language) body.language = input.language;
+        return this.request({
+          method: "POST",
+          path: "/extract",
+          json: body
+        });
+      }
+      /**
+       * Fast 3-model panel verdict on each identified claim in the input.
+       * Sync, ~5-10s. Returns one entry per atomic_claim. For deeper analysis
+       * (citations, full audit trail), escalate low-confidence claims to
+       * `verifyAndWait`; the two endpoints share a result cache server-side.
+       *
+       * Pass `language: "es"` (or any of the 12 supported codes) to receive
+       * the claim text in that language. Verdict labels stay English.
+       */
+      async assess(input) {
+        const body = { text: input.text };
+        if (input.language) body.language = input.language;
+        return this.request({
+          method: "POST",
+          path: "/assess",
+          json: body
+        });
+      }
+      /**
+       * Resolve a needs-input interrupt by selecting one or more claims.
+       *
+       * Each selected claim fans out into its own pipeline; the returned
+       * `BatchAccepted` carries one `items` entry (each with its own `task_id`)
+       * per claim. Poll each via `getStatus` / `wait`. Every text must match a
+       * claim offered in the prior interrupt — the server rejects anything else.
+       */
+      async select(taskId, input) {
+        if (!input.texts || input.texts.length === 0) {
+          throw new Error("select requires a non-empty texts array");
+        }
+        return this.request({
+          method: "POST",
+          path: `/verify/${taskId}/select`,
+          json: { texts: input.texts }
+        });
+      }
+      async getStatus(taskId) {
+        return this.request({
+          method: "GET",
+          path: `/verify/status/${taskId}`
+        });
+      }
+      async usage() {
+        return this.request({ method: "GET", path: "/me/usage" });
+      }
+      // ── Headline ergonomic ──
+      /**
+       * Submit + poll until the pipeline terminates. Returns the completed
+       * Verification, or throws LenzNeedsInputError / LenzPipelineError /
+       * LenzTimeoutError. By default sends an auto-generated Idempotency-Key
+       * so a network retry on submit doesn't spawn a duplicate task.
+       */
+      async verifyAndWait(input) {
+        const timeoutMs = input.timeoutMs ?? 12e4;
+        const idempotencyKey = input.idempotencyKey ?? (input.idempotency !== false ? (0, import_node_crypto.randomUUID)().replace(/-/g, "") : void 0);
+        const accepted = await this.submit({ ...input, idempotencyKey });
+        console.info(`[lenz-io] Submitted task: ${accepted.task_id}`);
+        return this.wait(accepted, { timeoutMs });
+      }
+      /**
+       * Block on an already-submitted task until it terminates, then return its
+       * `Verification`. `task` is a `task_id` string OR the `TaskAccepted` returned
+       * by `verify` / `select` — so `client.wait(await client.verify({claim}))`
+       * reads naturally. Throws for an empty id, `LenzNeedsInputError` /
+       * `LenzPipelineError` on terminal non-success, and `LenzTimeoutError` on
+       * deadline.
+       */
+      async wait(task, opts = {}) {
+        const taskId = typeof task === "string" ? task : task.task_id;
+        if (!taskId) {
+          throw new Error("wait() requires a non-empty task_id (got an empty TaskAccepted.task_id).");
+        }
+        const timeoutMs = opts.timeoutMs ?? 12e4;
+        const { terminal, timedOut } = await this._pollToTerminal([taskId], timeoutMs);
+        if (timedOut.has(taskId)) {
+          const err = new LenzTimeoutError({
+            message: `wait timed out after ${timeoutMs}ms`,
+            cause: "Pipeline still running server-side.",
+            fix: `Resume via client.getStatus('${taskId}') later.`,
+            docUrl: "https://lenz.io/docs/verify#timeout"
+          });
+          err.taskId = taskId;
+          throw err;
+        }
+        return this._verificationFromTerminal(terminal.get(taskId), taskId);
+      }
+      /**
+       * Submit a batch and poll every item to a terminal state. Returns one
+       * `BatchItemResult` per task the batch accepted, in input order. Never throws
+       * on a per-item outcome — a claim that fails, pauses, or times out becomes a
+       * `BatchItemResult` with the matching `status`. (Transport/auth errors on the
+       * initial submit still throw.)
+       */
+      async verifyBatchAndWait(input) {
+        const timeoutMs = input.timeoutMs ?? 18e4;
+        const accepted = await this.verifyBatch(input);
+        const ids = accepted.items.map((it) => it.task_id).filter((id) => Boolean(id));
+        const { terminal, timedOut } = await this._pollToTerminal(ids, timeoutMs);
+        return accepted.items.map((it) => {
+          const status = terminal.get(it.task_id);
+          if (!it.task_id || timedOut.has(it.task_id) || !status) {
+            return { task_id: it.task_id, claim_text: it.claim_text, status: "timeout" };
+          }
+          if (status.status === "completed" && status.result) {
+            return {
+              task_id: it.task_id,
+              claim_text: it.claim_text,
+              status: "completed",
+              verification: status.result,
+              status_detail: status
+            };
+          }
+          if (status.status === "needs_input") {
+            return {
+              task_id: it.task_id,
+              claim_text: it.claim_text,
+              status: "needs_input",
+              status_detail: status
+            };
+          }
+          return {
+            task_id: it.task_id,
+            claim_text: it.claim_text,
+            status: "failed",
+            status_detail: status
+          };
+        });
+      }
+      // ── poll engine (shared by wait + verifyBatchAndWait) ──
+      /**
+       * Round-robin poll `taskIds` until each reaches a terminal state or the
+       * deadline elapses. Returns `{terminal, timedOut}`; a timed-out task has no
+       * `TaskStatus` (`"timeout"` is client-side, never a wire status).
+       *
+       * Each round polls every still-pending id once (via `Promise.allSettled`, so
+       * one poll's transport failure doesn't abort the batch — that id stays
+       * pending and retries next round) BEFORE the deadline check, preserving the
+       * legacy `verifyAndWait` behavior of polling once more after sleeping the
+       * remaining time. Timeout is therefore approximate. Backoff reuses the
+       * existing 2/4/8/8…ms sequence; the 10s cap is currently unreachable and kept
+       * only to preserve identical timing.
+       */
+      async _pollToTerminal(taskIds, timeoutMs) {
+        let pending = [...taskIds];
+        const terminal = /* @__PURE__ */ new Map();
+        const timedOut = /* @__PURE__ */ new Set();
+        const deadline = Date.now() + timeoutMs;
+        let backoffIdx = 0;
+        while (pending.length > 0) {
+          const settled = await Promise.allSettled(pending.map((id) => this.getStatus(id)));
+          const stillPending = [];
+          settled.forEach((res, i) => {
+            const id = pending[i];
+            if (res.status === "fulfilled") {
+              const s = res.value;
+              if (s.status === "completed" || s.status === "needs_input" || s.status === "failed") {
+                terminal.set(id, s);
+              } else {
+                stillPending.push(id);
+              }
+            } else {
+              stillPending.push(id);
+            }
+          });
+          pending = stillPending;
+          if (pending.length === 0) break;
+          const remaining = deadline - Date.now();
+          if (remaining <= 0) {
+            pending.forEach((id) => timedOut.add(id));
+            break;
+          }
+          await sleep(pollSleepMs(backoffIdx, remaining));
+          backoffIdx += 1;
+        }
+        return { terminal, timedOut };
+      }
+      /**
+       * Map a terminal `TaskStatus` to a `Verification` or throw the matching typed
+       * error. Shared by `wait` (and thus `verifyAndWait`).
+       */
+      _verificationFromTerminal(status, taskId) {
+        if (status.status === "completed") {
+          if (!status.result) {
+            throw new LenzPipelineError({
+              message: "Pipeline completed but the result is empty.",
+              cause: "Server reported status=completed without a result block.",
+              fix: "File an issue at https://github.com/lenzhq/lenz-io-node/issues with the Request ID.",
+              docUrl: "https://lenz.io/docs/errors"
+            });
+          }
+          return status.result;
+        }
+        if (status.status === "needs_input") {
+          const err2 = new LenzNeedsInputError({
+            message: `Pipeline paused: ${status.reason ?? "needs input"}`,
+            cause: "The verification needs caller input to proceed.",
+            fix: "Inspect the payload, then call client.select(taskId, { texts: [...] }) with the chosen claim(s).",
+            docUrl: "https://lenz.io/docs/verify#needs-input"
+          });
+          err2.taskId = taskId;
+          err2.kind = status.reason ?? "";
+          err2.payload = status;
+          throw err2;
+        }
+        const detail = status.error || status.failure_detail || status.failure_reason || "unknown";
+        const err = new LenzPipelineError({
+          message: `Pipeline failed: ${detail}`,
+          cause: detail,
+          fix: "Retry with a different claim, or check status.error for the diagnostic.",
+          docUrl: "https://lenz.io/docs/errors"
+        });
+        err.taskId = taskId;
+        err.failureReason = status.failure_reason ?? "";
+        throw err;
+      }
+      // ── internal helpers ──
+      async submit(input) {
+        const body = {
+          text: input.claim,
+          source_url: input.sourceUrl ?? "",
+          webhook_url: input.webhookUrl ?? ""
+        };
+        if (input.language) body.language = input.language;
+        const headers = {};
+        if (input.idempotencyKey) headers["Idempotency-Key"] = input.idempotencyKey;
+        return this.request({
+          method: "POST",
+          path: "/verify",
+          json: body,
+          headers
+        });
+      }
+      /** Internal: dispatch an HTTP call with auth + retry. Public so the
+       *  namespace classes can use it; not part of the documented surface. */
+      async request(opts) {
+        const authRequired = opts.authRequired !== false;
+        if (authRequired && !this.apiKey) {
+          throw new LenzAuthError({
+            message: "API key required",
+            cause: "This method requires authentication; no API key was provided.",
+            fix: "Pass apiKey to new Lenz(), set LENZ_API_KEY env var, or get one at https://lenz.io/api-integration. Library endpoints work without a key.",
+            docUrl: "https://lenz.io/docs/auth"
+          });
+        }
+        const url = new URL(`${this.baseUrl}${opts.path}`);
+        if (opts.query) {
+          for (const [k, v] of Object.entries(opts.query)) {
+            if (v !== void 0 && v !== "" && v !== null) {
+              url.searchParams.set(k, String(v));
+            }
+          }
+        }
+        const headers = {
+          "User-Agent": `lenz-io-node/${VERSION}`,
+          "X-Lenz-API-Version": API_VERSION,
+          Accept: "application/json",
+          ...opts.headers ?? {}
+        };
+        if (this.apiKey && (authRequired || opts.authOptional)) {
+          headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        if (opts.json !== void 0) {
+          headers["Content-Type"] = "application/json";
+        }
+        let lastErr = void 0;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          const controller = new AbortController();
+          const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+          let response;
+          try {
+            response = await this.fetchImpl(url.toString(), {
+              method: opts.method,
+              headers,
+              body: opts.json !== void 0 ? JSON.stringify(opts.json) : void 0,
+              signal: controller.signal
+            });
+          } catch (exc) {
+            lastErr = exc;
+            clearTimeout(timer);
+            if (attempt >= this.maxRetries) {
+              throw new LenzAPIError({
+                message: `${opts.method} ${opts.path} failed after ${attempt + 1} attempts: ${String(exc)}`,
+                cause: String(exc),
+                fix: "Check your network connection; verify baseUrl is reachable.",
+                docUrl: "https://lenz.io/docs/errors"
+              });
+            }
+            await sleep(retrySleepMs(attempt));
+            continue;
+          }
+          clearTimeout(timer);
+          if (response.status < 400) {
+            if (response.status === 204 || response.headers.get("content-length") === "0") {
+              return {};
+            }
+            return await response.json();
+          }
+          if (attempt < this.maxRetries && (response.status >= 500 || response.status === 429)) {
+            const ra = response.headers.get("Retry-After");
+            let waitMs = retrySleepMs(attempt);
+            if (ra) {
+              const parsed = Number(ra);
+              if (Number.isFinite(parsed)) waitMs = parsed * 1e3;
+            }
+            await sleep(waitMs);
+            continue;
+          }
+          const rawBody = await response.text();
+          const respHeaders = {};
+          response.headers.forEach((v, k) => {
+            respHeaders[k] = v;
+          });
+          throw mapResponseToError(response.status, rawBody, respHeaders);
+        }
+        if (lastErr) {
+          throw new LenzAPIError({
+            message: String(lastErr),
+            cause: String(lastErr)
+          });
+        }
+        throw new LenzAPIError({ message: `${opts.method} ${opts.path} failed without diagnostic` });
+      }
+    };
+    var import_node_crypto2 = require("crypto");
+    var import_node_buffer = require("buffer");
+    var SIGNATURE_HEADER = "X-Lenz-Signature";
+    var SIGNATURE_PREFIX = "sha256=";
+    var DEFAULT_REPLAY_WINDOW_SECONDS = 300;
+    function toBuffer(body) {
+      if (import_node_buffer.Buffer.isBuffer(body)) return body;
+      if (body instanceof Uint8Array) return import_node_buffer.Buffer.from(body);
+      return import_node_buffer.Buffer.from(body, "utf-8");
+    }
+    function sign(body, secret) {
+      const mac = (0, import_node_crypto2.createHmac)("sha256", secret).update(body).digest("hex");
+      return `${SIGNATURE_PREFIX}${mac}`;
+    }
+    function verifySignature(rawBody, signature, secret) {
+      if (!signature) {
+        throw new LenzWebhookSignatureError({
+          message: "Missing webhook signature",
+          cause: `No ${SIGNATURE_HEADER} header on the request.`,
+          fix: "Inspect the webhook delivery in /api-integration to confirm the secret is set.",
+          docUrl: "https://lenz.io/docs/webhooks"
+        });
+      }
+      const buf = toBuffer(rawBody);
+      const expected = sign(buf, secret);
+      const a = import_node_buffer.Buffer.from(expected);
+      const b = import_node_buffer.Buffer.from(signature);
+      if (a.length !== b.length || !(0, import_node_crypto2.timingSafeEqual)(a, b)) {
+        throw new LenzWebhookSignatureError({
+          message: "Webhook signature mismatch",
+          cause: "HMAC of the raw body using your secret does not match X-Lenz-Signature.",
+          fix: "Verify the secret in /api-integration matches the one you configured here.",
+          docUrl: "https://lenz.io/docs/webhooks"
+        });
+      }
+      return true;
+    }
+    function buildEvent(payload) {
+      const event = String(payload["event"] ?? "");
+      const base = {
+        event,
+        taskId: String(payload["task_id"] ?? ""),
+        attempt: Number(payload["attempt"] ?? 1) || 1,
+        deliveredAt: String(payload["delivered_at"] ?? ""),
+        verificationId: payload["verification_id"] ?? null,
+        batchId: payload["batch_id"] ?? null,
+        status: String(payload["status"] ?? ""),
+        raw: payload
+      };
+      if (event === "verification.completed") {
+        return {
+          ...base,
+          event: "verification.completed",
+          result: payload["result"] ?? {}
+        };
+      }
+      if (event === "verification.failed") {
+        return {
+          ...base,
+          event: "verification.failed",
+          error: String(payload["error"] ?? "")
+        };
+      }
+      if (event === "verification.needs_input") {
+        return {
+          ...base,
+          event: "verification.needs_input",
+          needsInput: payload["needs_input"] ?? {}
+        };
+      }
+      return base;
+    }
+    var LenzWebhooks = class {
+      secret;
+      replayWindow;
+      constructor(opts) {
+        if (!opts.secret) {
+          throw new Error("LenzWebhooks requires a non-empty secret. Get it from /api-integration.");
+        }
+        this.secret = opts.secret;
+        this.replayWindow = opts.replayWindowSeconds ?? DEFAULT_REPLAY_WINDOW_SECONDS;
+      }
+      parse(rawBody, headers) {
+        const sig = this.lookupHeader(headers, SIGNATURE_HEADER);
+        verifySignature(rawBody, sig, this.secret);
+        const text = toBuffer(rawBody).toString("utf-8");
+        let payload;
+        try {
+          payload = JSON.parse(text);
+        } catch (exc) {
+          throw new LenzWebhookSignatureError({
+            message: "Webhook body is not valid JSON",
+            cause: String(exc),
+            fix: "The signature verified but the body is malformed. Check your reverse proxy isn't rewriting payloads.",
+            docUrl: "https://lenz.io/docs/webhooks"
+          });
+        }
+        if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+          throw new LenzWebhookSignatureError({
+            message: "Webhook body must be a JSON object",
+            cause: `Got ${typeof payload}.`,
+            fix: "Confirm the request comes from Lenz; an upstream proxy may be wrapping the body.",
+            docUrl: "https://lenz.io/docs/webhooks"
+          });
+        }
+        const obj = payload;
+        this.checkReplay(obj);
+        return buildEvent(obj);
+      }
+      // ── helpers ──
+      lookupHeader(headers, name) {
+        if (typeof headers.get === "function") {
+          const v = headers.get(name);
+          return v ? String(v) : "";
+        }
+        const h = headers;
+        return h[name] ?? h[name.toLowerCase()] ?? h[name.toUpperCase()] ?? "";
+      }
+      checkReplay(payload) {
+        const raw = payload["delivered_at"];
+        if (!raw) return;
+        const ts = new Date(String(raw));
+        if (Number.isNaN(ts.getTime())) return;
+        const ageSec = (Date.now() - ts.getTime()) / 1e3;
+        if (ageSec > this.replayWindow) {
+          throw new LenzWebhookSignatureError({
+            message: "Webhook delivered_at is outside the replay window",
+            cause: `Payload is ${Math.round(ageSec)}s old; window is ${this.replayWindow}s.`,
+            fix: "Confirm your server clock is in sync; raise replayWindowSeconds if you intentionally batch deliveries.",
+            docUrl: "https://lenz.io/docs/webhooks"
+          });
+        }
+      }
+    };
+  }
+});
+
+// dist/nodes/Lenz/Lenz.node.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lenz = void 0;
+var n8n_workflow_1 = require("n8n-workflow");
+var lenz_io_1 = require_dist();
+function isPassingVerdict(verdict) {
+  return verdict === "True" || verdict === "Mostly True";
+}
+var Lenz = class {
+  constructor() {
+    this.description = {
+      displayName: "Lenz",
+      name: "lenz",
+      icon: { light: "file:lenz.svg", dark: "file:lenz.dark.svg" },
+      group: ["transform"],
+      version: [1],
+      subtitle: '={{$parameter["operation"]}}',
+      description: "Fact-check claims and catch AI hallucinations with sourced, audit-grade verdicts",
+      defaults: {
+        name: "Lenz"
+      },
+      inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+      outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+      usableAsTool: true,
+      credentials: [
+        {
+          name: "lenzApi",
+          required: true
+        }
+      ],
+      properties: [
+        {
+          displayName: "Operation",
+          name: "operation",
+          type: "options",
+          noDataExpression: true,
+          options: [
+            {
+              name: "Ask Follow-Up",
+              value: "ask",
+              description: "Ask a grounded follow-up question about a completed Verify (Deep) result",
+              action: "Ask a follow up question"
+            },
+            {
+              name: "Assess (Fast)",
+              value: "assess",
+              description: "Fast 3-model panel verdict (~5-10s), one entry per claim found in the text",
+              action: "Quickly assess text for factual claims"
+            },
+            {
+              name: "Check Usage",
+              value: "usage",
+              description: "Check remaining quota for the current API key",
+              action: "Check usage and quota"
+            },
+            {
+              name: "Extract Claims",
+              value: "extract",
+              description: "Pull verifiable claims out of text (free)",
+              action: "Extract claims from text"
+            },
+            {
+              name: "Verify (Deep)",
+              value: "verify",
+              description: "Full 8-model pipeline with sourced citations (~90s). Reserve for high-stakes claims.",
+              action: "Deeply verify a claim"
+            }
+          ],
+          default: "verify"
+        },
+        {
+          displayName: "Claim",
+          name: "claim",
+          type: "string",
+          typeOptions: { rows: 3 },
+          default: "",
+          required: true,
+          displayOptions: {
+            show: { operation: ["verify"] }
+          },
+          description: "The claim to investigate in depth. Reserve for high-stakes statements that warrant a thorough, sourced check."
+        },
+        {
+          displayName: "Text",
+          name: "text",
+          type: "string",
+          typeOptions: { rows: 3 },
+          default: "",
+          required: true,
+          displayOptions: {
+            show: { operation: ["assess", "extract"] }
+          },
+          description: "The text to check. If it contains several claims, each is handled separately."
+        },
+        {
+          displayName: "Verification ID",
+          name: "verificationId",
+          type: "string",
+          default: "",
+          required: true,
+          displayOptions: {
+            show: { operation: ["ask"] }
+          },
+          description: "The verification_id from a completed Verify (Deep) result (not a task_id)"
+        },
+        {
+          displayName: "Question",
+          name: "question",
+          type: "string",
+          default: "",
+          required: true,
+          displayOptions: {
+            show: { operation: ["ask"] }
+          },
+          description: "The follow-up question, answered from the verification full research and evidence"
+        },
+        {
+          displayName: "Language",
+          name: "language",
+          type: "string",
+          default: "",
+          placeholder: "Es",
+          description: "Optional ISO 639-1 response language code. Defaults to English.",
+          displayOptions: {
+            show: { operation: ["verify", "assess", "extract", "ask"] }
+          }
+        }
+      ]
+    };
+  }
+  async execute() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const items = this.getInputData();
+    const returnData = [];
+    const credentials = await this.getCredentials("lenzApi");
+    const client = new lenz_io_1.Lenz({ apiKey: credentials.apiKey });
+    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+      try {
+        const operation = this.getNodeParameter("operation", itemIndex);
+        const language = this.getNodeParameter("language", itemIndex, "") || void 0;
+        let responseData;
+        if (operation === "verify") {
+          const claim = this.getNodeParameter("claim", itemIndex).trim();
+          if (!claim) {
+            returnData.push({
+              json: { skipped: true, reason: "empty_input" },
+              pairedItem: { item: itemIndex }
+            });
+            continue;
+          }
+          try {
+            const result = await client.verifyAndWait({ claim, language });
+            responseData = {
+              status: "completed",
+              passed: isPassingVerdict(result.verdict),
+              verdict: (_a = result.verdict) !== null && _a !== void 0 ? _a : null,
+              confidence: (_b = result.confidence) !== null && _b !== void 0 ? _b : null,
+              lenz_score: (_c = result.lenz_score) !== null && _c !== void 0 ? _c : null,
+              executive_summary: (_d = result.executive_summary) !== null && _d !== void 0 ? _d : "",
+              citations: ((_e = result.sources) !== null && _e !== void 0 ? _e : []).filter((s) => s.url).map((s) => {
+                var _a2, _b2;
+                return { title: (_a2 = s.title) !== null && _a2 !== void 0 ? _a2 : "", url: (_b2 = s.url) !== null && _b2 !== void 0 ? _b2 : "" };
+              }),
+              verification_id: (_f = result.verification_id) !== null && _f !== void 0 ? _f : null
+            };
+          } catch (err) {
+            if (err instanceof lenz_io_1.LenzNeedsInputError) {
+              responseData = {
+                status: "needs_input",
+                reason: err.kind,
+                task_id: err.taskId,
+                message: "This claim is ambiguous or contains multiple sub-claims. Rephrase it to be more specific and re-run."
+              };
+            } else if (err instanceof lenz_io_1.LenzTimeoutError) {
+              responseData = {
+                status: "timeout",
+                task_id: err.taskId,
+                message: "The verification did not complete in time (task_id: " + err.taskId + "). It may still be running server-side."
+              };
+            } else if (err instanceof lenz_io_1.LenzPipelineError) {
+              responseData = {
+                status: "failed",
+                task_id: err.taskId,
+                message: err.message
+              };
+            } else if (err instanceof lenz_io_1.LenzError) {
+              throw new n8n_workflow_1.NodeApiError(this.getNode(), { message: err.message, description: err.toString() }, {
+                itemIndex,
+                httpCode: err.statusCode ? String(err.statusCode) : void 0
+              });
+            } else {
+              throw new n8n_workflow_1.NodeApiError(this.getNode(), { message: err.message }, { itemIndex });
+            }
+          }
+        } else if (operation === "assess") {
+          const text = this.getNodeParameter("text", itemIndex).trim();
+          if (!text) {
+            returnData.push({
+              json: { skipped: true, reason: "empty_input" },
+              pairedItem: { item: itemIndex }
+            });
+            continue;
+          }
+          const result = await client.assess({ text, language });
+          if (!result.claims.length) {
+            responseData = {
+              status: result.error_code === "ambiguous" ? "ambiguous" : "no_claim",
+              message: (_g = result.error) !== null && _g !== void 0 ? _g : "No verifiable factual claim was detected.",
+              candidate_claims: (_h = result.candidate_claims) !== null && _h !== void 0 ? _h : []
+            };
+          } else {
+            responseData = {
+              status: "ok",
+              claims: result.claims.map((c) => {
+                var _a2, _b2, _c2, _d2;
+                return {
+                  claim: (_a2 = c.claim) !== null && _a2 !== void 0 ? _a2 : "",
+                  verdict: (_b2 = c.verdict) !== null && _b2 !== void 0 ? _b2 : null,
+                  confidence: (_c2 = c.confidence) !== null && _c2 !== void 0 ? _c2 : null,
+                  passed: isPassingVerdict(c.verdict),
+                  verification_url: (_d2 = c.verification_url) !== null && _d2 !== void 0 ? _d2 : null
+                };
+              })
+            };
+          }
+        } else if (operation === "extract") {
+          const text = this.getNodeParameter("text", itemIndex).trim();
+          if (!text) {
+            returnData.push({
+              json: { skipped: true, reason: "empty_input" },
+              pairedItem: { item: itemIndex }
+            });
+            continue;
+          }
+          responseData = await client.extract({ text, language });
+        } else if (operation === "ask") {
+          const verificationId = this.getNodeParameter("verificationId", itemIndex);
+          const question = this.getNodeParameter("question", itemIndex);
+          const reply = await client.ask.send(verificationId, { message: question, language });
+          responseData = {
+            answer: (_j = reply.content) !== null && _j !== void 0 ? _j : ""
+          };
+        } else if (operation === "usage") {
+          responseData = await client.usage();
+        } else {
+          throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Unknown operation: " + operation, {
+            itemIndex
+          });
+        }
+        returnData.push({
+          json: responseData,
+          pairedItem: { item: itemIndex }
+        });
+      } catch (error) {
+        if (this.continueOnFail()) {
+          returnData.push({
+            json: { error: error.message },
+            pairedItem: { item: itemIndex }
+          });
+          continue;
+        }
+        if (error instanceof n8n_workflow_1.NodeOperationError) {
+          throw error;
+        }
+        if (error instanceof lenz_io_1.LenzError) {
+          throw new n8n_workflow_1.NodeApiError(this.getNode(), { message: error.message, description: error.toString() }, {
+            itemIndex,
+            httpCode: error.statusCode ? String(error.statusCode) : void 0
+          });
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), { message: error.message }, { itemIndex });
+      }
+    }
+    return [returnData];
+  }
+};
+exports.Lenz = Lenz;