@juspay/neurolink 12.5.3 → 12.6.1

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/sagemaker/client.js

@@ -6,6 +6,7 @@
  */
 import { handleSageMakerError, SageMakerError, isRetryableError, getRetryDelay, } from "./errors.js";
 import { logger } from "../../utils/logger.js";
+import { isAbortError } from "../../utils/errorHandling.js";
 import { tryImport } from "../../utils/tryImport.js";
 /**
  * Lazily load `@aws-sdk/client-sagemaker-runtime`.
@@ -114,7 +115,13 @@ export class SageMakerRuntimeClient {
             };
             const command = new InvokeEndpointCommand(input);
             const client = await this.getClient();
-            const response = (await this.executeWithRetry(() => client.send(command), params.EndpointName));
+            const response = (await this.executeWithRetry(
+            // The signal goes to the transport, not just to whatever loop is
+            // above us: without it an aborted call keeps its HTTP request in
+            // flight until the endpoint answers. An AbortError matches none of
+            // RETRYABLE_ERROR_CONDITIONS, so executeWithRetry surfaces it rather
+            // than re-issuing a request the caller has already abandoned.
+            () => client.send(command, { abortSignal: params.abortSignal }), params.EndpointName));
             const duration = Date.now() - startTime;
             logger.debug("SageMaker endpoint invocation successful", {
                 endpointName: params.EndpointName,
@@ -130,6 +137,15 @@ export class SageMakerRuntimeClient {
             };
         }
         catch (error) {
+            // The signal now reaches the transport, so this catch sees real
+            // AbortErrors for the first time — and must not wrap them.
+            // SageMakerError's constructor overwrites `.name`, and its generic
+            // fallback stamps `statusCode: 500`, which the retry classifier reads as
+            // "transient, try again". That fabricated status is what turned a
+            // cancellation into three attempts and 22 seconds.
+            if (isAbortError(error)) {
+                throw error;
+            }
             const duration = Date.now() - startTime;
             logger.error("SageMaker endpoint invocation failed", {
                 endpointName: params.EndpointName,
@@ -169,7 +185,10 @@ export class SageMakerRuntimeClient {
             };
             const command = new InvokeEndpointWithResponseStreamCommand(input);
             const client = await this.getClient();
-            const response = (await this.executeWithRetry(() => client.send(command), params.EndpointName));
+            const response = (await this.executeWithRetry(
+            // As above — an abort must tear down the response stream's connection,
+            // not merely stop the consumer reading from it.
+            () => client.send(command, { abortSignal: params.abortSignal }), params.EndpointName));
             logger.debug("SageMaker streaming invocation started", {
                 endpointName: params.EndpointName,
                 setupDuration: Date.now() - startTime,
@@ -192,6 +211,15 @@ export class SageMakerRuntimeClient {
             };
         }
         catch (error) {
+            // The signal now reaches the transport, so the streaming catch sees real
+            // AbortErrors for the first time — and must not wrap them.
+            // SageMakerError's constructor overwrites `.name`, and its generic
+            // fallback stamps `statusCode: 500`, which the retry classifier reads as
+            // "transient, try again". That fabricated status is what turned a
+            // cancellation into three attempts and 22 seconds.
+            if (isAbortError(error)) {
+                throw error;
+            }
             const duration = Date.now() - startTime;
             logger.error("SageMaker streaming invocation failed", {
                 endpointName: params.EndpointName,

package/dist/providers/sagemaker/language-model.d.ts

@@ -34,6 +34,15 @@ export declare class SageMakerLanguageModel implements SageMakerAsLanguageModel
     private config;
     private modelConfig;
     constructor(modelId: string, config: SageMakerConfig, modelConfig: SageMakerModelConfig);
+    /**
+     * Read the caller's abort signal out of the AI SDK's call options.
+     *
+     * `doGenerate`/`doStream` type `options` as `Record<string, unknown>`, so the
+     * value arrives as `unknown` even though `LanguageModelV2CallOptions`
+     * declares `abortSignal?: AbortSignal`. `instanceof` is a real runtime check
+     * rather than an assertion, which is what rule 14 asks for here.
+     */
+    private readAbortSignal;
     /**
      * Generate text synchronously using SageMaker endpoint
      */

package/dist/providers/sagemaker/language-model.js

@@ -10,6 +10,7 @@ import { handleSageMakerError } from "./errors.js";
 import { estimateTokenUsage, createSageMakerStream, parseUsageFromResponseBody, } from "./streaming.js";
 import { createAdaptiveSemaphore } from "./adaptive-semaphore.js";
 import { logger } from "../../utils/logger.js";
+import { isAbortError } from "../../utils/errorHandling.js";
 /**
  * Base synthetic streaming delay in milliseconds for simulating real-time response
  * Can be configured via SAGEMAKER_BASE_STREAMING_DELAY_MS environment variable
@@ -113,6 +114,18 @@ export class SageMakerLanguageModel {
             specificationVersion: this.specificationVersion,
         });
     }
+    /**
+     * Read the caller's abort signal out of the AI SDK's call options.
+     *
+     * `doGenerate`/`doStream` type `options` as `Record<string, unknown>`, so the
+     * value arrives as `unknown` even though `LanguageModelV2CallOptions`
+     * declares `abortSignal?: AbortSignal`. `instanceof` is a real runtime check
+     * rather than an assertion, which is what rule 14 asks for here.
+     */
+    readAbortSignal(options) {
+        const signal = options.abortSignal;
+        return signal instanceof AbortSignal ? signal : undefined;
+    }
     /**
      * Generate text synchronously using SageMaker endpoint
      */
@@ -134,6 +147,7 @@ export class SageMakerLanguageModel {
                 Body: JSON.stringify(sagemakerRequest),
                 ContentType: "application/json",
                 Accept: "application/json",
+                abortSignal: this.readAbortSignal(options),
             });
             // Parse SageMaker response
             const responseBody = JSON.parse(new TextDecoder().decode(response.Body));
@@ -223,6 +237,11 @@ export class SageMakerLanguageModel {
                 duration,
                 error: error instanceof Error ? error.message : String(error),
             });
+            // An abort is not a provider failure: wrapping it here would restore
+            // the fabricated 500 the client guard just avoided.
+            if (isAbortError(error)) {
+                throw error;
+            }
             throw handleSageMakerError(error, this.modelConfig.endpointName);
         }
     }
@@ -260,6 +279,7 @@ export class SageMakerLanguageModel {
                     Body: JSON.stringify(requestWithStreaming),
                     ContentType: this.modelConfig.contentType || "application/json",
                     Accept: this.modelConfig.accept || "application/json",
+                    abortSignal: this.readAbortSignal(options),
                 });
                 // Create intelligent streaming response
                 const stream = await createSageMakerStream(response.Body, this.modelConfig.endpointName, this.config, {
@@ -298,6 +318,13 @@ export class SageMakerLanguageModel {
                 };
             }
             catch (streamingError) {
+                // A cancelled turn is not a missing capability. This fallback exists
+                // for endpoints that cannot stream; re-issuing doGenerate() here with
+                // the same already-aborted signal only adds a wasted call and a
+                // misleading warning before the abort surfaces anyway.
+                if (isAbortError(streamingError)) {
+                    throw streamingError;
+                }
                 logger.warn("Streaming failed, falling back to non-streaming", {
                     endpointName: this.modelConfig.endpointName,
                     error: streamingError instanceof Error
@@ -351,6 +378,11 @@ export class SageMakerLanguageModel {
             logger.error("SageMaker doStream failed", {
                 error: error instanceof Error ? error.message : String(error),
             });
+            // An abort is not a provider failure: wrapping it here would restore
+            // the fabricated 500 the client guard just avoided.
+            if (isAbortError(error)) {
+                throw error;
+            }
             throw handleSageMakerError(error, this.modelConfig.endpointName);
         }
     }
@@ -681,6 +713,11 @@ export class SageMakerLanguageModel {
                 error: error instanceof Error ? error.message : String(error),
                 batchSize: prompts.length,
             });
+            // An abort is not a provider failure: wrapping it here would restore
+            // the fabricated 500 the client guard just avoided.
+            if (isAbortError(error)) {
+                throw error;
+            }
             throw handleSageMakerError(error, this.modelConfig.endpointName);
         }
     }

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/providers.d.ts

@@ -1282,6 +1282,16 @@ export type InvokeEndpointParams = {
     TargetVariant?: string;
     /** Inference ID for request tracking */
     InferenceId?: string;
+    /**
+     * Cancels the in-flight HTTP request, not just the loop around it.
+     *
+     * Named in camelCase deliberately: every other field here mirrors an AWS
+     * `InvokeEndpointCommandInput` member and keeps its PascalCase, whereas this
+     * one is a transport option handed to `client.send()` as
+     * `@smithy/types` `HttpHandlerOptions` — it is never part of the command
+     * payload, and spelling it differently keeps that boundary visible.
+     */
+    abortSignal?: AbortSignal;
 };
 /**
  * Response from SageMaker endpoint invocation