@juspay/neurolink 12.5.2 → 12.6.0

package/dist/localUsage/qwenCodeReader.js

@@ -0,0 +1,279 @@
+/**
+ * Reads token usage out of Qwen Code's own session transcripts.
+ *
+ * Layout, confirmed on a real machine: `~/.qwen/projects/<sanitized-cwd>/chats/
+ * <sessionId>.jsonl`, where the sanitized cwd is the absolute working-directory
+ * path with every `/` replaced by `-` — the same convention Claude Code uses
+ * for its own `~/.claude/projects` layout, which is unsurprising since Qwen
+ * Code's chat-recording model traces back to the same lineage as Gemini CLI's.
+ * `~/.qwen/projects/<slug>/` also holds a sibling `memory/` directory with a
+ * `MEMORY.md` file and no JSONL, so the walk below is scoped to `chats/`
+ * specifically rather than the whole project directory.
+ *
+ * The bundled CLI (`@qwen-code/qwen-code`, installed copy inspected directly)
+ * references `parentSessionId` the same way Gemini CLI's engine does for
+ * subagent transcripts, so this reader recurses under each project's `chats/`
+ * directory at any depth rather than globbing one level — the same lesson
+ * `claudeCodeReader.ts` already paid for.
+ *
+ * Each line is a flat record with `type`, `uuid`, and (for `type: "assistant"`)
+ * a `model` and `usageMetadata` object shaped like Google's GenAI
+ * `usageMetadata`: `promptTokenCount`, `candidatesTokenCount`,
+ * `thoughtsTokenCount`, `totalTokenCount`, `cachedContentTokenCount`. On a real
+ * machine, `totalTokenCount` equalled `promptTokenCount + candidatesTokenCount
+ * + thoughtsTokenCount` exactly across all 21 real assistant records sampled —
+ * so `thoughtsTokenCount` is additive into output, not a separate bucket.
+ *
+ * `cachedContentTokenCount` is a SUBSET of `promptTokenCount`, not disjoint —
+ * confirmed by reading the installed CLI's own converters rather than
+ * inferring from samples, because every real sample on this machine had zero
+ * cache tokens. `buildAnthropicUsageMetadata` in
+ * `chunks/anthropicContentGenerator-*.js` and the OpenAI-compatible converter
+ * in `chunks/chunk-*.js` both derive `cachedContentTokenCount` from the
+ * upstream response's own cache-read field and leave `promptTokenCount` as the
+ * upstream's full prompt count — the cached portion is never added on top. So
+ * `inputTokens` here is `prompt - cached`, matching the convention this
+ * subsystem's `LocalUsageTotals` type expects (`inputTokens` +
+ * `cacheReadTokens` must sum to the true prompt size without double-counting),
+ * the same subtraction `codexReader.ts` does for the same reason.
+ *
+ * Cost is deliberately `unavailable`. Two independent reasons, either one
+ * sufficient on its own: (1) no provider identifier is logged alongside the
+ * model name, and Qwen Code is pluggable to arbitrary OpenAI- or
+ * Anthropic-compatible backends — on the machine this was written against, the
+ * model names logged were `claude-sonnet-4-5` and `claude-haiku-4-5`, i.e. this
+ * particular install was routed through a custom/litellm endpoint rather than
+ * Alibaba's own Qwen models, so even the model name does not reliably identify
+ * a vendor to price against; (2) Qwen Code's own hosted models are commonly
+ * used via a subscription/OAuth flow rather than metered API keys, the same
+ * situation that keeps Codex's confidence `unavailable`.
+ */
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { resolveScanCutoffMs } from "./scanWindow.js";
+const CLI_ID = "qwen-code";
+function projectsRoot() {
+    return join(homedir(), ".qwen", "projects");
+}
+function emptyTotals() {
+    return {
+        requests: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        costUsd: 0,
+        costConfidence: "unavailable",
+        unpricedRequests: 0,
+        unpricedModels: [],
+    };
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+ * A scan that cannot read a directory must say so.
+ *
+ * Swallowing every readdir failure made an unreadable tree indistinguishable
+ * from an empty one: the report showed zero usage, no failure entry, and an
+ * operator with a permissions problem had nothing to look at. ENOENT stays
+ * silent because a missing root legitimately means "nothing recorded yet";
+ * anything else is a real failure and is surfaced.
+ */
+function isMissing(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        error.code === "ENOENT");
+}
+/** Every `chats/` directory, one per project, under the Qwen projects root. */
+async function collectChatsDirs(root, errors) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        if (!isMissing(error)) {
+            errors.push({
+                cliId: CLI_ID,
+                filePath: root,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return [];
+    }
+    const dirs = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const chatsDir = join(root, entry.name, "chats");
+        try {
+            const info = await stat(chatsDir);
+            if (info.isDirectory()) {
+                dirs.push(chatsDir);
+            }
+        }
+        catch {
+            // No `chats/` for this project — nothing recorded yet.
+        }
+    }
+    return dirs;
+}
+/** Every `.jsonl` transcript at any depth under a `chats/` directory. */
+async function collectTranscripts(dir, out, errors) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (!isMissing(error)) {
+            errors.push({
+                cliId: CLI_ID,
+                filePath: dir,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectTranscripts(full, out, errors);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            out.push(full);
+        }
+    }
+}
+/**
+ * Dedup is by `uuid`, keeping the LARGEST total-token count seen for that id
+ * — the same "resumed session re-logs a turn" protection `claudeCodeReader.ts`
+ * uses, applied here on the off chance a resumed Qwen session does the same.
+ * The map is per-file and discarded after, so it stays bounded regardless of
+ * how many files a scan covers.
+ */
+async function foldTranscript(filePath, totals, unpriced) {
+    const seen = new Map();
+    const rl = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of rl) {
+            if (!line || line.charCodeAt(0) !== 123 /* '{' */) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                // A transcript being appended to while we read it ends in a partial
+                // line. That is normal, not corruption — skip it.
+                continue;
+            }
+            const record = parsed;
+            if (record.type !== "assistant" || !record.usageMetadata) {
+                continue;
+            }
+            const id = record.uuid;
+            if (typeof id !== "string" || id.length === 0) {
+                continue;
+            }
+            const usage = record.usageMetadata;
+            const prompt = num(usage.promptTokenCount);
+            const cached = num(usage.cachedContentTokenCount);
+            const candidate = {
+                model: record.model ?? "unknown",
+                input: Math.max(0, prompt - cached),
+                output: num(usage.candidatesTokenCount) + num(usage.thoughtsTokenCount),
+                cached,
+            };
+            const existing = seen.get(id);
+            // Cached tokens are part of the raw prompt, so a record can carry more
+            // total usage and still lose on input+output alone — keep-max would then
+            // keep the smaller of two duplicates.
+            const candidateTotal = candidate.input + candidate.output + candidate.cached;
+            const existingTotal = existing
+                ? existing.input + existing.output + existing.cached
+                : -1;
+            if (!existing || candidateTotal > existingTotal) {
+                seen.set(id, candidate);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+    for (const turn of seen.values()) {
+        totals.requests += 1;
+        totals.inputTokens += turn.input;
+        totals.outputTokens += turn.output;
+        totals.cacheReadTokens += turn.cached;
+        // Cost is unavailable for this reader (see module header), so every turn
+        // is unpriced by construction rather than by a failed lookup.
+        totals.unpricedRequests += 1;
+        unpriced.add(turn.model);
+    }
+}
+export async function createQwenCodeReader() {
+    return {
+        descriptor: {
+            id: CLI_ID,
+            displayName: "Qwen Code",
+            verified: true,
+            dedupStrategy: "message-id-keep-max",
+            costConfidence: "unavailable",
+            requiresSqlite: false,
+        },
+        detect: async () => {
+            try {
+                const info = await stat(projectsRoot());
+                return info.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        scan: async (options) => {
+            const totals = emptyTotals();
+            const errors = [];
+            const unpriced = new Set();
+            const chatsDirs = await collectChatsDirs(projectsRoot(), errors);
+            const files = [];
+            for (const dir of chatsDirs) {
+                await collectTranscripts(dir, files, errors);
+            }
+            // Only Infinity means "no time filter" — see scanWindow.ts. A cutoff of
+            // `undefined` reads everything; any finite number is an mtime floor.
+            const cutoff = resolveScanCutoffMs(options?.sinceDays);
+            let filesScanned = 0;
+            for (const file of files) {
+                try {
+                    if (cutoff !== undefined) {
+                        const info = await stat(file);
+                        if (info.mtimeMs < cutoff) {
+                            continue;
+                        }
+                    }
+                    await foldTranscript(file, totals, unpriced);
+                    filesScanned += 1;
+                }
+                catch (error) {
+                    // One unreadable transcript is a reportable fact, not a reason to
+                    // lose the totals from every other file in the scan.
+                    errors.push({
+                        cliId: CLI_ID,
+                        filePath: file,
+                        message: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            totals.unpricedModels = [...unpriced].sort();
+            return { cliId: CLI_ID, totals, filesScanned, errors };
+        },
+    };
+}

package/dist/providers/amazonBedrock/loopAdapter.js

@@ -223,7 +223,15 @@ export function createBedrockLoopAdapter(config) {
                 const response = await withInferenceProfileFallback(commandInput.modelId ?? "", config.region, (effectiveModelId) => withTimeout(config.client.send(new ConverseCommand({
                     ...commandInput,
                     modelId: effectiveModelId,
-                })), STEP_TIMEOUT_MS, new Error("Bedrock API call timed out")));
+                }), 
+                // Hand the signal to the transport, not just to the loop.
+                // `abortSignal` is documented public API, and loopEngine
+                // already honours it — but only *between* steps. Without this
+                // the HTTP request stays in flight after an abort until it
+                // answers or STEP_TIMEOUT_MS (120s) elapses, because nothing
+                // ever told the socket. `@smithy/types` HttpHandlerOptions
+                // takes the same AbortSignal the adapter is already given.
+                { abortSignal: signal }), STEP_TIMEOUT_MS, new Error("Bedrock API call timed out")));
                 if (!response.output?.message) {
                     throw new Error("Invalid response structure from Bedrock API");
                 }
@@ -232,7 +240,11 @@ export function createBedrockLoopAdapter(config) {
             const response = await withInferenceProfileFallback(commandInput.modelId ?? "", config.region, (effectiveModelId) => withTimeout(config.client.send(new ConverseStreamCommand({
                 ...commandInput,
                 modelId: effectiveModelId,
-            })), STEP_TIMEOUT_MS, new Error("Bedrock streaming API call timed out")));
+            }), 
+            // As above: the streaming send needs the signal too, so an
+            // abort tears down the eventstream connection rather than
+            // leaving it open for the rest of the step budget.
+            { abortSignal: signal }), STEP_TIMEOUT_MS, new Error("Bedrock streaming API call timed out")));
             return readStreamedStep(response, channel, signal);
         },
         buildToolResultMessages(conversation, stepResult, toolResults) {

package/dist/proxy/clientAttribution.js

@@ -16,13 +16,49 @@
  *   client is then still attributable by its own User-Agent rather than
  *   collapsing into one bucket with every other unknown.
  */
-/** Longest prefix wins, so a more specific match cannot be shadowed. */
+/**
+ * Longest prefix wins, so a more specific match cannot be shadowed.
+ *
+ * Every entry below was read out of this machine's proxy request log or a
+ * header capture, never guessed. The measured string is quoted beside each so
+ * a future reader can tell an observation from an assumption.
+ */
 const CLIENT_PREFIXES = [
-    // Verified against this machine's proxy logs.
+    // "claude-cli/2.1.251 (external, cli)"
     ["claude-cli/", "claude-code"],
-    // Verified: the AI SDK's own UA, used by NeuroLink's SDK callers.
+    // "ai/4.x" — the AI SDK's own UA, used by NeuroLink's SDK callers.
     ["ai/", "sdk"],
+    // "opencode/1.3.13 ai-sdk/provider-utils/4.0.21 runtime/bun/1.3.13"
+    ["opencode/", "opencode"],
+    // "QwenCode/0.17.0 (darwin; arm64)"
+    ["QwenCode/", "qwen-code"],
+    // "GeminiCLI-tui/0.53.0/gemini-3.1-pro-preview (darwin; arm64; terminal)"
+    ["GeminiCLI-", "gemini-cli"],
+    // "codex_exec/0.147.0 (Mac OS 26.6.0; arm64)". Only the non-interactive
+    // `codex exec` binary has been observed; the interactive TUI may well send a
+    // different token, and it is left unmapped until someone measures it rather
+    // than pattern-matched on a guess.
+    ["codex_exec/", "codex"],
 ];
+/**
+ * Deliberately NOT mapped, with the measurement that ruled each one out.
+ *
+ * Copilot CLI is the one client here that cannot be identified from its
+ * User-Agent, and both of the strings it sends are actively unsafe to key on:
+ *
+ * - `OpenAI/JS 5.20.1` — the stock OpenAI JS SDK UA, sent by every caller of
+ *   that SDK. Mapping it to Copilot would file unrelated OpenAI-SDK traffic
+ *   under Copilot's name, which is worse than leaving it unattributed.
+ * - `Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)` — a
+ *   spoofed browser string. It looks like a fingerprint and is not one: it was
+ *   captured from **both** Copilot CLI and Gemini CLI, so it identifies no
+ *   client at all. (It also accounts for the largest single block of
+ *   `unknown` rows in this machine's log, which is what made it tempting.)
+ *
+ * Copilot does send `x-initiator` and `x-interaction-type`, but neither is
+ * exclusive to it either. Attributing it needs a signal nobody has found yet,
+ * so it stays `unknown` and remains traceable through the stored raw header.
+ */
 /** Cap stored User-Agents. They are attacker-influenced and unbounded. */
 const MAX_USER_AGENT_CHARS = 200;
 /**

package/dist/proxy/proxyTranslationEngine.js

@@ -16,6 +16,7 @@ import { buildGeminiResponse, createGeminiSerializerAdapter, } from "./geminiFor
 import { generateOpenAIToolCallId, OpenAIStreamSerializer, serializeOpenAIResponse, } from "./openaiFormat.js";
 import { DEFAULT_PROXY_MODEL_IDS } from "../constants/proxyModels.js";
 import { logRequest } from "./requestLogger.js";
+import { buildClientAttribution } from "./clientAttribution.js";
 import { recordAttempt, recordAttemptError, recordFinalError, recordFinalSuccess, } from "./usageStats.js";
 import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
 import { withTimeout } from "../utils/async/withTimeout.js";
@@ -484,6 +485,11 @@ export async function handleTranslatedStreamRequest(args) {
                     toolCount: Object.keys(parsed.tools).length,
                     account: "translation",
                     accountType: "translation",
+                    // Without this the translated doors record no calling client at all.
+                    // The Gemini door serves every request through this engine, so its
+                    // rows carried a null clientApp and a null userAgent — not merely
+                    // "unknown", but nothing to attribute after the fact either.
+                    ...buildClientAttribution(ctx.headers),
                     responseStatus: terminalStatus,
                     responseTimeMs: Date.now() - requestStartTime,
                     ...(terminalErrorType ? { errorType: terminalErrorType } : {}),
@@ -588,6 +594,7 @@ export async function handleTranslatedJsonRequest(args) {
                 toolCount: Object.keys(parsed.tools).length,
                 account: "translation",
                 accountType: "translation",
+                ...buildClientAttribution(ctx.headers),
                 responseStatus: 200,
                 responseTimeMs: Date.now() - requestStartTime,
                 inputTokens: resolvedUsage.input,
@@ -631,6 +638,7 @@ export async function handleTranslatedJsonRequest(args) {
         toolCount: Object.keys(parsed.tools).length,
         account: "translation",
         accountType: "translation",
+        ...buildClientAttribution(ctx.headers),
         responseStatus: terminalFailureStatus,
         responseTimeMs: Date.now() - requestStartTime,
         errorType: "generation_error",

package/dist/types/localUsage.d.ts

@@ -15,7 +15,14 @@
  * Kebab-case, matching `CliProxyClientConfigurator.id`'s convention — a
  * different registry, but the same repo-wide convention for CLI identifiers.
  */
-export type LocalUsageCliId = "claude-code" | "codex" | "gemini-cli" | "opencode" | "qwen-code" | "copilot-cli" | "cursor" | "amp" | "hermes" | "kiro" | "antigravity" | "grok";
+export type LocalUsageCliId = "claude-code" | "codex" | "gemini-cli" | "opencode" | "qwen-code" | "copilot"
+/**
+ * @deprecated Use "copilot". Retained because this literal is already part
+ * of the published `LocalUsageCliId`, so dropping it would break any caller
+ * that names it. `usage local --cli copilot-cli` still resolves, normalised
+ * to "copilot" at the input boundary.
+ */
+ | "copilot-cli" | "cursor" | "amp" | "hermes" | "kiro" | "antigravity" | "grok";
 /**
  * How much to trust a computed cost figure.
  *
@@ -123,6 +130,15 @@ export type LocalUsageAggregateReport = {
     totals: Partial<Record<LocalUsageCliId, LocalUsageTotals>>;
     /** CLIs whose reader could not be created, detected, or scanned, and why. */
     failures: LocalUsageReaderFailure[];
+    /**
+     * Per-file problems from readers that otherwise succeeded.
+     *
+     * Distinct from `failures`, which is a reader that threw. A scan can read
+     * nine of ten transcripts and still be wrong by the tenth; without this the
+     * shortfall is invisible and the totals look authoritative. Readers have
+     * always collected these — nothing consumed them until now.
+     */
+    scanErrors: LocalUsageScanError[];
     /** CLIs with no local store on this machine — absent, not failed. */
     notInstalled: LocalUsageCliId[];
 };
@@ -151,6 +167,61 @@ export type LocalUsageCodexSessionRollup = {
     /** token_count events where the cumulative total actually advanced. */
     billableEvents: number;
 };
+/**
+ * The `usageMetadata` object exactly as Qwen Code writes it into a transcript
+ * line — Google GenAI's `usageMetadata` shape, camelCase, every field
+ * optional because not every assistant record carries one. See
+ * `qwenCodeReader.ts` for why `cachedContentTokenCount` is subtracted out of
+ * `promptTokenCount` rather than added.
+ */
+export type LocalUsageQwenRawUsage = {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    thoughtsTokenCount?: number;
+    totalTokenCount?: number;
+    cachedContentTokenCount?: number;
+};
+/**
+ * The `tokens` object exactly as Gemini CLI writes it onto a `type: "gemini"`
+ * message record — mapped straight from the GenAI response's own
+ * `usageMetadata` by the CLI's own `recordMessageTokens()`. See
+ * `geminiCliReader.ts` for why `cached` is subtracted out of `input` rather
+ * than added, and why `thoughts`/`tool` fold into output.
+ */
+export type LocalUsageGeminiCliTokens = {
+    input?: number;
+    output?: number;
+    cached?: number;
+    thoughts?: number;
+    tool?: number;
+    total?: number;
+};
+/**
+ * A `type: "gemini"` message record as read out of a chat transcript line —
+ * whether it arrived bare-appended or unwrapped from a `$set.messages[]`
+ * bootstrap entry. See `geminiCliReader.ts` for both shapes.
+ */
+export type LocalUsageGeminiMessageRecord = {
+    id?: string;
+    type?: string;
+    model?: string;
+    tokens?: LocalUsageGeminiCliTokens;
+};
+/**
+ * One row of Copilot CLI's `assistant_usage_events` SQLite table, restricted
+ * to the columns `copilotCliReader.ts` actually reads. `cache_read_tokens`
+ * and `cache_write_tokens` are both subsets of `input_tokens` — see that
+ * reader's module header for the arithmetic proof.
+ */
+export type LocalUsageCopilotUsageRow = {
+    model: string | null;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    cache_read_tokens: number | null;
+    cache_write_tokens: number | null;
+    reasoning_tokens: number | null;
+    created_at: string | null;
+};
 /**
  * The slice of `node:sqlite`'s `DatabaseSync` the OpenCode reader uses.
  *

package/dist/types/proxyClient.d.ts

@@ -29,6 +29,17 @@ export type CliProxyClientConfigurator = {
      * alone and return false.
      */
     restore: (proxyBaseUrl: string) => Promise<boolean>;
+    /**
+     * Something the user must still do for apply() to take effect.
+     *
+     * Writing a file is not the same as being in effect. Copilot reads its
+     * provider settings from the environment only, so its configurator writes a
+     * script the user has to source; until they do, the proxy reports a green
+     * check for a file nothing reads. Returning a string here lets a client say
+     * "written, but not yet live, and here is the one line that fixes it".
+     * Return null when nothing is outstanding.
+     */
+    postApplyNote?: (proxyBaseUrl: string) => Promise<string | null>;
 };
 /** Outcome of applying one configurator, for per-client CLI reporting. */
 export type CliProxyClientApplyResult = {
@@ -36,6 +47,12 @@ export type CliProxyClientApplyResult = {
     displayName: string;
     /** True only when the configurator actually wrote configuration. */
     applied: boolean;
+    /**
+     * Set when the write landed but is not yet in effect — see
+     * CliProxyClientConfigurator.postApplyNote. Callers must render this; a
+     * silent note is the failure it exists to prevent.
+     */
+    note?: string;
     /** Present when the configurator threw; the caller decides how loud to be. */
     error?: Error;
 };

package/dist/utils/providerRetry.js

@@ -13,7 +13,7 @@
  *
  * @module utils/providerRetry
  */
-import { NeuroLinkError } from "./errorHandling.js";
+import { NeuroLinkError, isAbortError } from "./errorHandling.js";
 import { logger } from "./logger.js";
 import { APICallError } from "./generationErrors.js";
 import { parseRetryAfterMs } from "./retryAfter.js";
@@ -143,7 +143,50 @@ export function isOpenAIQuotaExhaustedError(error) {
     }
     return false;
 }
+/**
+ * True when `error` is an abort, or wraps one at any depth via `cause`.
+ *
+ * `isAbortError` alone is not enough here because it inspects one value, and
+ * by the time a provider failure reaches the retry wrapper it has usually been
+ * re-thrown inside a provider-specific error whose `name` no longer says
+ * "AbortError". The depth bound stops a self-referential or maliciously deep
+ * `cause` chain from hanging the classifier; nothing legitimate nests further.
+ */
+function isAbortLike(error, depth = 0) {
+    if (depth > 8 || error === null || typeof error !== "object") {
+        return isAbortError(error);
+    }
+    if (isAbortError(error)) {
+        return true;
+    }
+    const { cause } = error;
+    return cause === undefined || cause === error
+        ? false
+        : isAbortLike(cause, depth + 1);
+}
 export function isRetryableProviderError(error) {
+    // Ahead of everything, for the same reason as the quota branch below but a
+    // worse failure: the caller has already walked away. Retrying a cancelled
+    // turn cannot succeed — the signal stays aborted, so every further attempt
+    // rejects without reaching the network — and it costs the full ladder,
+    // 2 retries at the NO_HINT_FLOOR_MS floor, before the turn ends.
+    //
+    // Measured on SageMaker before this guard: abort at 400ms, provider failed
+    // at 232ms with "Request aborted", then two more attempts 10s apart each
+    // failing in 1ms without a request leaving the process, and the turn finally
+    // threw at 21,996ms — 55x the time the cancellation should have taken, with
+    // `name` by then reading "Error" rather than "AbortError".
+    //
+    // The cause chain matters and is not defensive padding. Providers wrap
+    // transport failures in their own error class on the way up: SageMaker's
+    // handleSageMakerError() stamps an unrecognised error `statusCode: 500`
+    // while keeping the original as `cause`. That fabricated 500 is what made an
+    // abort look retryable here — the duck-typed status branch below reads it
+    // and returns true, outranking the wrapper's own `retryable: false`. Reading
+    // through `cause` finds the abort whatever wrapped it.
+    if (isAbortLike(error)) {
+        return false;
+    }
     // Before every other branch, including the SDK's own flag: a 429 carrying
     // `insufficient_quota` is marked retryable by the AI SDK because it only
     // looks at the status code. Retrying it burns the full ladder — 3 attempts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.5.2",
+  "version": "12.6.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {