@juspay/neurolink 11.12.0 → 11.13.0

package/dist/lib/proxy/codexUsage.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Codex (OpenAI Responses) SSE usage tap.
+ *
+ * The Codex proxy engine relays `upstream.body` to the client untouched and
+ * logs before a single byte is read, so no Codex request has ever carried token
+ * counts. This module adds a pass-through tap that scrapes `usage` out of the
+ * stream without holding back or altering any bytes.
+ *
+ * ## Safety contract
+ *
+ * This sits in the hot path of a live proxy, so it is built to be incapable of
+ * breaking a stream:
+ *
+ * - every chunk is enqueued **before** it is inspected;
+ * - all parsing runs inside try/catch, and a throw is swallowed;
+ * - a stream whose shape is unrecognised resolves `usage` to `null`, which is
+ *   exactly today's behaviour (a log with no token fields).
+ *
+ * The worst case is therefore "no tokens recorded", never a truncated or
+ * corrupted response.
+ *
+ * ## Wire shape
+ *
+ * **Verified against real traffic.** Captured from a live `codex exec` run
+ * through the proxy on 2026-08-21; the trimmed sample is at
+ * `test/fixtures/codex-response-usage.sse` and is asserted against in the
+ * codex suite. The real shape is
+ *
+ *   event: response.completed
+ *   data: {"type":"response.completed","response":{"usage":{
+ *     "input_tokens":N,"output_tokens":M,
+ *     "input_tokens_details":{"cached_tokens":K,"cache_write_tokens":W},
+ *     "output_tokens_details":{"reasoning_tokens":R}}}}
+ *
+ * Note that `response.created` arrives first carrying `usage: null`, which is
+ * why the scanner keeps the last non-null result rather than the first.
+ *
+ * It also accepts a `usage` object at the top level of any event and the
+ * `prompt_tokens`/`completion_tokens` spellings. A `null` result means "not
+ * observed", never "zero tokens".
+ */
+import type { CodexStreamUsage } from "../types/index.js";
+/**
+ * Pull usage out of one parsed SSE `data:` payload.
+ *
+ * Returns null when the payload carries no recognisable usage object, so the
+ * caller can keep the last non-null result rather than overwriting it with a
+ * later event that happens not to carry usage.
+ */
+export declare function extractCodexUsage(payload: unknown): CodexStreamUsage | null;
+/**
+ * Scan a slice of SSE text for usage, returning the last one found.
+ *
+ * Exported for tests: it is the whole parsing decision, and driving it through
+ * a real Codex stream would need a live ChatGPT subscription.
+ */
+export declare function scanCodexSSEForUsage(text: string): CodexStreamUsage | null;
+/**
+ * A pass-through TransformStream that reports the usage seen on a Codex SSE
+ * stream.
+ *
+ * `usage` resolves when the stream ends: to the last usage observed, or null if
+ * none was. It never rejects.
+ */
+export declare function createCodexUsageTap(): {
+    stream: TransformStream<Uint8Array, Uint8Array>;
+    usage: Promise<CodexStreamUsage | null>;
+};

package/dist/lib/proxy/codexUsage.js

@@ -0,0 +1,247 @@
+/**
+ * Codex (OpenAI Responses) SSE usage tap.
+ *
+ * The Codex proxy engine relays `upstream.body` to the client untouched and
+ * logs before a single byte is read, so no Codex request has ever carried token
+ * counts. This module adds a pass-through tap that scrapes `usage` out of the
+ * stream without holding back or altering any bytes.
+ *
+ * ## Safety contract
+ *
+ * This sits in the hot path of a live proxy, so it is built to be incapable of
+ * breaking a stream:
+ *
+ * - every chunk is enqueued **before** it is inspected;
+ * - all parsing runs inside try/catch, and a throw is swallowed;
+ * - a stream whose shape is unrecognised resolves `usage` to `null`, which is
+ *   exactly today's behaviour (a log with no token fields).
+ *
+ * The worst case is therefore "no tokens recorded", never a truncated or
+ * corrupted response.
+ *
+ * ## Wire shape
+ *
+ * **Verified against real traffic.** Captured from a live `codex exec` run
+ * through the proxy on 2026-08-21; the trimmed sample is at
+ * `test/fixtures/codex-response-usage.sse` and is asserted against in the
+ * codex suite. The real shape is
+ *
+ *   event: response.completed
+ *   data: {"type":"response.completed","response":{"usage":{
+ *     "input_tokens":N,"output_tokens":M,
+ *     "input_tokens_details":{"cached_tokens":K,"cache_write_tokens":W},
+ *     "output_tokens_details":{"reasoning_tokens":R}}}}
+ *
+ * Note that `response.created` arrives first carrying `usage: null`, which is
+ * why the scanner keeps the last non-null result rather than the first.
+ *
+ * It also accepts a `usage` object at the top level of any event and the
+ * `prompt_tokens`/`completion_tokens` spellings. A `null` result means "not
+ * observed", never "zero tokens".
+ */
+import { appendFileSync } from "node:fs";
+const nonNegativeInt = (value) => typeof value === "number" && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : 0;
+/**
+ * Pull usage out of one parsed SSE `data:` payload.
+ *
+ * Returns null when the payload carries no recognisable usage object, so the
+ * caller can keep the last non-null result rather than overwriting it with a
+ * later event that happens not to carry usage.
+ */
+export function extractCodexUsage(payload) {
+    if (payload === null || typeof payload !== "object") {
+        return null;
+    }
+    const root = payload;
+    const response = root.response;
+    const usage = (response && typeof response === "object" && response.usage
+        ? response.usage
+        : root.usage);
+    if (!usage || typeof usage !== "object") {
+        return null;
+    }
+    const input = usage.input_tokens ?? usage.prompt_tokens;
+    const output = usage.output_tokens ?? usage.completion_tokens;
+    if (input === undefined && output === undefined) {
+        return null;
+    }
+    const inputDetails = usage.input_tokens_details;
+    const outputDetails = usage.output_tokens_details;
+    return {
+        inputTokens: nonNegativeInt(input),
+        outputTokens: nonNegativeInt(output),
+        cacheReadTokens: nonNegativeInt(inputDetails?.cached_tokens),
+        cacheCreationTokens: nonNegativeInt(inputDetails?.cache_write_tokens),
+        reasoningTokens: nonNegativeInt(outputDetails?.reasoning_tokens),
+    };
+}
+/**
+ * Scan a slice of SSE text for usage, returning the last one found.
+ *
+ * Exported for tests: it is the whole parsing decision, and driving it through
+ * a real Codex stream would need a live ChatGPT subscription.
+ */
+export function scanCodexSSEForUsage(text) {
+    let found = null;
+    for (const line of text.split("\n")) {
+        if (!line.startsWith("data:")) {
+            continue;
+        }
+        const raw = line.slice(5).trim();
+        if (!raw || raw === "[DONE]") {
+            continue;
+        }
+        try {
+            const usage = extractCodexUsage(JSON.parse(raw));
+            if (usage) {
+                found = usage;
+            }
+        }
+        catch {
+            // Partial or non-JSON payload — the next chunk may complete it. Never
+            // let a malformed line escape into the relay.
+        }
+    }
+    return found;
+}
+/**
+ * Maximum bytes written by the opt-in raw capture. One `response.completed`
+ * event is a few hundred bytes; 256 KiB is generous and bounds a runaway file.
+ */
+const CAPTURE_LIMIT_BYTES = 256 * 1024;
+/**
+ * Opt-in raw capture of one Codex SSE stream, for confirming the `usage` wire
+ * shape against real traffic.
+ *
+ * Off unless `NEUROLINK_PROXY_CODEX_CAPTURE` names a file. It is deliberately
+ * env-gated and undocumented in the CLI: the captured bytes are the assistant's
+ * actual response, so this is a debugging tool the operator turns on
+ * deliberately, not something that runs by default. Capture stops at the first
+ * completed stream and is capped.
+ */
+function createCaptureSink() {
+    const target = process.env.NEUROLINK_PROXY_CODEX_CAPTURE;
+    if (!target) {
+        return null;
+    }
+    let written = 0;
+    let started = false;
+    return (chunk) => {
+        if (written >= CAPTURE_LIMIT_BYTES) {
+            return;
+        }
+        try {
+            // Append only the new bytes. Rewriting the accumulated buffer on every
+            // chunk is quadratic in stream length and runs in a live relay's
+            // transform(), so a long response would do hundreds of growing
+            // synchronous writes.
+            // Slice to the remaining capacity rather than writing the whole chunk.
+            // The guard above only says the cap was not ALREADY reached, so a single
+            // large chunk arriving at 255 KiB would otherwise land in full and the
+            // file would end up far past its bound — the cap has to hold per write,
+            // not per stream.
+            const remaining = CAPTURE_LIMIT_BYTES - written;
+            const slice = chunk.byteLength > remaining ? chunk.subarray(0, remaining) : chunk;
+            appendFileSync(target, slice, { flag: started ? "a" : "w" });
+            started = true;
+            written += slice.byteLength;
+        }
+        catch {
+            // Capture is best-effort telemetry; never let it touch the relay.
+        }
+    };
+}
+/**
+ * A pass-through TransformStream that reports the usage seen on a Codex SSE
+ * stream.
+ *
+ * `usage` resolves when the stream ends: to the last usage observed, or null if
+ * none was. It never rejects.
+ */
+export function createCodexUsageTap() {
+    let settleUsage = () => { };
+    const usage = new Promise((resolve) => {
+        settleUsage = resolve;
+    });
+    // flush() and cancel() are mutually exclusive in principle, but a
+    // double-settle must be harmless rather than relied upon.
+    let settled = false;
+    const settle = (value) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        settleUsage(value);
+    };
+    const decoder = new TextDecoder();
+    const capture = createCaptureSink();
+    let carry = "";
+    let latest = null;
+    /**
+     * Ceiling on the unterminated tail we are willing to hold.
+     *
+     * `carry` normally holds a fraction of one SSE line, because every newline
+     * flushes it. A stream that never sends one — a hung upstream, a
+     * non-SSE body relayed by mistake — would otherwise grow it without bound
+     * for the life of the request. One `response.completed` event is a few
+     * hundred bytes, so a megabyte is far past any real event, and dropping the
+     * tail costs at most the usage reading this tap is allowed to miss anyway.
+     */
+    const CARRY_LIMIT_CHARS = 1024 * 1024;
+    const transformer = {
+        transform(chunk, controller) {
+            // Bytes go out first and unconditionally: nothing below can delay or
+            // alter what the client receives.
+            controller.enqueue(chunk);
+            try {
+                capture?.(chunk);
+                carry += decoder.decode(chunk, { stream: true });
+                // Keep only the trailing partial line; events are newline-delimited.
+                const lastBreak = carry.lastIndexOf("\n");
+                if (lastBreak === -1) {
+                    if (carry.length > CARRY_LIMIT_CHARS) {
+                        // No line break in a megabyte: this is not the SSE stream we can
+                        // read. Give up on the tail rather than grow forever.
+                        carry = "";
+                    }
+                    return;
+                }
+                const complete = carry.slice(0, lastBreak);
+                carry = carry.slice(lastBreak + 1);
+                const seen = scanCodexSSEForUsage(complete);
+                if (seen) {
+                    latest = seen;
+                }
+            }
+            catch {
+                // Telemetry must never break the relay.
+            }
+        },
+        flush() {
+            try {
+                const seen = scanCodexSSEForUsage(carry);
+                if (seen) {
+                    latest = seen;
+                }
+            }
+            catch {
+                // ignored — see above
+            }
+            settle(latest);
+        },
+        /**
+         * A client hanging up mid-response, or an upstream error, aborts the
+         * stream rather than closing it — so flush() never runs. Without this the
+         * usage promise would never settle and every aborted request would leak a
+         * pending handler. Report whatever was seen before the abort.
+         */
+        cancel() {
+            settle(latest);
+        },
+    };
+    const stream = new TransformStream(transformer);
+    return { stream, usage };
+}
+//# sourceMappingURL=codexUsage.js.map

package/dist/lib/proxy/proxyAnalysis.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { createInterface } from "node:readline";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { ACCOUNT_COOLING_REASONS, PROXY_ACCOUNT_TYPES, PROXY_ACCOUNT_ROUTING_MODES, PROXY_ACCOUNT_ROUTING_REASONS, PROXY_ACCOUNT_ROUTING_STRATEGIES, } from "./routingEvidence.js";
+import { calculateCost, hasPricing, isExactPricingMatch, } from "../utils/pricing.js";
 const LIFECYCLE_FILE_PATTERN = /^proxy-lifecycle-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
 const ATTEMPT_FILE_PATTERN = /^proxy-attempts-\d{4}-\d{2}-\d{2}\.jsonl$/;
@@ -358,6 +359,13 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
     let cacheReadTokens = 0;
     let cacheCreationTokens = 0;
     let inputTokens = 0;
+    let outputTokens = 0;
+    let estimatedCostUsd = 0;
+    let requestsPriced = 0;
+    let requestsPricedByPrefix = 0;
+    let requestsUnpriced = 0;
+    const modelsPricedByPrefix = new Set();
+    const unpricedModels = new Set();
     const finalRequestLatency = [];
     const singleAttemptDelta = [];
     const errorTypes = {};
@@ -394,13 +402,50 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
             singleAttemptDelta.push(request.durationMs - requestAttempts.totalDurationMs);
         }
         if (request.inputTokens !== null ||
+            request.outputTokens !== null ||
             request.cacheReadTokens !== null ||
             request.cacheCreationTokens !== null) {
             requestsWithUsage += 1;
             inputTokens += request.inputTokens ?? 0;
+            outputTokens += request.outputTokens ?? 0;
             cacheReadTokens += request.cacheReadTokens ?? 0;
             cacheCreationTokens += request.cacheCreationTokens ?? 0;
             requestsWithCacheRead += (request.cacheReadTokens ?? 0) > 0 ? 1 : 0;
+            if (request.model) {
+                // Records written before `provider` existed carry only a model name.
+                // "openai-compatible" resolves to the cross-provider table search in
+                // pricing.ts, which finds the model wherever it lives — a far better
+                // guess than assuming Anthropic and pricing a GPT model at $0.
+                const cost = calculateCost(request.provider ?? "openai-compatible", request.model, {
+                    input: request.inputTokens ?? 0,
+                    output: request.outputTokens ?? 0,
+                    total: (request.inputTokens ?? 0) +
+                        (request.outputTokens ?? 0) +
+                        (request.cacheCreationTokens ?? 0) +
+                        (request.cacheReadTokens ?? 0),
+                    cacheCreationTokens: request.cacheCreationTokens ?? 0,
+                    cacheReadTokens: request.cacheReadTokens ?? 0,
+                });
+                // Ask the table directly rather than inferring from cost > 0: a real
+                // request with trivial usage can round to $0.000000 and is priced, not
+                // unpriced.
+                const priced = hasPricing(request.provider ?? "openai-compatible", request.model);
+                if (priced) {
+                    estimatedCostUsd += cost;
+                    requestsPriced += 1;
+                    // A prefix fallback means the rate was inherited from a
+                    // similarly-named model, not quoted for this one. Surface it rather
+                    // than presenting a guess as a figure.
+                    if (!isExactPricingMatch(request.provider ?? "openai-compatible", request.model)) {
+                        requestsPricedByPrefix += 1;
+                        modelsPricedByPrefix.add(request.model);
+                    }
+                }
+                else {
+                    requestsUnpriced += 1;
+                    unpricedModels.add(request.model);
+                }
+            }
         }
     }
     return {
@@ -419,6 +464,13 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
             cacheReadTokens,
             cacheCreationTokens,
             inputTokens,
+            outputTokens,
+            estimatedCostUsd: Number(estimatedCostUsd.toFixed(6)),
+            requestsPriced,
+            requestsPricedByPrefix,
+            modelsPricedByPrefix: [...modelsPricedByPrefix].sort(),
+            requestsUnpriced,
+            unpricedModels: [...unpricedModels].sort(),
             requestHitRate: requestsWithUsage > 0
                 ? Number((requestsWithCacheRead / requestsWithUsage).toFixed(4))
                 : null,
@@ -695,13 +747,26 @@ export async function analyzeProxyLogs(options) {
     for (const filePath of requestFiles) {
         linesRead += await readJsonLines(filePath, (record) => {
             const timestamp = observeTimestamp("requests", record);
-            if (timestamp === null || timestamp < sinceMs || timestamp > untilMs) {
+            if (timestamp === null) {
                 return;
             }
             const requestId = stringValue(record.requestId);
             if (!requestId) {
                 return;
             }
+            // A streamed request is logged twice — once when the response headers
+            // are known, again when the body finishes and its token counts arrive
+            // — and those two writes can straddle the window edge. A Codex turn
+            // whose headers land at 23:59:50 and whose stream ends at 00:00:05 has
+            // every token it spent in the second record. Filtering that record out
+            // by its own timestamp would leave the request counted as completed
+            // but contributing nothing to tokens or cost, with nothing in the
+            // report to say so. A request the window already admitted therefore
+            // keeps accepting its own later records.
+            const alreadyAdmitted = finalRequests.has(requestId) || terminalStreamErrors.has(requestId);
+            if (!alreadyAdmitted && (timestamp < sinceMs || timestamp > untilMs)) {
+                return;
+            }
             if (finiteNumber(record.terminalStatus) !== null) {
                 terminalStreamErrors.add(requestId);
                 return;
@@ -723,19 +788,38 @@ export async function analyzeProxyLogs(options) {
             else {
                 absentRoutingDecisions += 1;
             }
-            finalRequests.set(requestId, {
+            const parsed = {
                 timestamp: new Date(timestamp).toISOString(),
                 status,
                 durationMs: finiteNumber(record.responseTimeMs),
                 account: stringValue(record.account) ?? "unknown",
                 accountType: stringValue(record.accountType) ?? "unknown",
+                model: stringValue(record.model),
+                provider: stringValue(record.provider),
                 inputTokens: finiteNumber(record.inputTokens),
+                outputTokens: finiteNumber(record.outputTokens),
                 cacheReadTokens: finiteNumber(record.cacheReadTokens),
                 cacheCreationTokens: finiteNumber(record.cacheCreationTokens),
                 errorType: stringValue(record.errorType),
                 errorCode: stringValue(record.errorCode),
                 routingDecision,
-            });
+            };
+            // A request may be logged twice: once when the response headers are
+            // known, and again when a streamed body finishes and its token counts
+            // become available (the Codex engine does this). Merge rather than
+            // replace, so the later usage-bearing record cannot drop an errorType
+            // the first one carried, and vice versa.
+            const previous = finalRequests.get(requestId);
+            finalRequests.set(requestId, previous
+                ? {
+                    ...previous,
+                    ...Object.fromEntries(Object.entries(parsed).filter(([, value]) => value !== null && value !== undefined)),
+                    // Attribute the request to when it was first seen. A late
+                    // completion record must not move it out of the window that
+                    // admitted it.
+                    timestamp: previous.timestamp,
+                }
+                : parsed);
         }, () => {
             malformedLines += 1;
         });

package/dist/lib/proxy/proxyFetch.d.ts

@@ -47,3 +47,4 @@ export declare function getProxyStatus(): {
     method: string;
     capabilities: string[];
 };
+export declare function warnGoogleSdkIgnoresProxy(providerLabel: string): void;

package/dist/lib/proxy/proxyFetch.js

@@ -697,4 +697,33 @@ export function getProxyStatus() {
         ],
     };
 }
+/**
+ * One-time warning that the @google/genai SDK cannot honour a configured
+ * proxy.
+ *
+ * Both Google providers passed `httpOptions: { fetch: createProxyFetch() }`,
+ * which does nothing. `HttpOptions` in @google/genai 1.46.0 declares only
+ * baseUrl, baseUrlResourceScope, apiVersion, headers, timeout, extraBody and
+ * retryOptions — there is no `fetch` on it. That property belongs to a
+ * different interface (`ClientOptions`), which `GoogleGenAIOptions` does not
+ * accept, and the SDK's request path calls global `fetch`. The option was
+ * silently dropped and requests went direct.
+ *
+ * It type-checked only because those constructors are reached through a
+ * loosely-typed local alias, which turns off excess-property checking.
+ *
+ * This SDK version offers no supported injection point, so rather than keep a
+ * line that reads like working proxy support, the situation is reported once
+ * per process — and only to someone who actually configured a proxy. Silent
+ * bypass is the worst outcome available: a corporate user believes their
+ * traffic is proxied when it is not.
+ */
+let proxyUnsupportedWarned = false;
+export function warnGoogleSdkIgnoresProxy(providerLabel) {
+    if (proxyUnsupportedWarned || !getProxyStatus().enabled) {
+        return;
+    }
+    proxyUnsupportedWarned = true;
+    logger.warn(`[${providerLabel}] A proxy is configured, but the @google/genai SDK provides no way to route its requests through it (HttpOptions has no 'fetch', and GoogleGenAIOptions accepts none). Requests from this provider go direct.`);
+}
 //# sourceMappingURL=proxyFetch.js.map

package/dist/lib/proxy/proxyTracer.d.ts

@@ -20,7 +20,18 @@ declare class ProxyTracer {
     private readonly proxyTracer;
     private readonly bridge;
     private readonly requestId;
-    private readonly model;
+    /**
+     * Model used for costing. Starts as the model the client asked for and is
+     * updated by setModelSubstitution(), so cost follows the model that actually
+     * served the request rather than the one that was requested.
+     */
+    private model;
+    /**
+     * Provider used for costing. See ProxyRequestContext.provider. Mutable for
+     * the same reason `model` is: a fallback can serve the request from a
+     * different provider, and pricing has to follow it.
+     */
+    private billingProvider;
     private readonly startTime;
     private readonly isStream;
     private accountEmail?;
@@ -60,7 +71,7 @@ declare class ProxyTracer {
      * Record that the proxy substituted a different model than was requested.
      * Sets span attributes and increments the substitution metric counter.
      */
-    setModelSubstitution(requestedModel: string, actualModel: string): void;
+    setModelSubstitution(requestedModel: string, actualModel: string, actualProvider?: string): void;
     setFallbackInfo(info: {
         triggered: boolean;
         provider?: string;

package/dist/lib/proxy/proxyTracer.js

@@ -191,16 +191,28 @@ class ProxyTracer {
     proxyTracer = getTracer("neurolink.proxy");
     bridge = new OtelBridge();
     requestId;
+    /**
+     * Model used for costing. Starts as the model the client asked for and is
+     * updated by setModelSubstitution(), so cost follows the model that actually
+     * served the request rather than the one that was requested.
+     */
     model;
+    /**
+     * Provider used for costing. See ProxyRequestContext.provider. Mutable for
+     * the same reason `model` is: a fallback can serve the request from a
+     * different provider, and pricing has to follow it.
+     */
+    billingProvider;
     startTime;
     isStream;
     accountEmail;
     usage;
     mode = "full";
-    constructor(rootSpan, requestId, model, stream) {
+    constructor(rootSpan, requestId, model, stream, billingProvider) {
         this.rootSpan = rootSpan;
         this.requestId = requestId;
         this.model = model;
+        this.billingProvider = billingProvider;
         this.startTime = Date.now();
         this.isStream = stream;
     }
@@ -257,7 +269,7 @@ class ProxyTracer {
         if (nlConversationId) {
             rootSpan.setAttribute("neurolink.conversation_id", nlConversationId);
         }
-        const instance = new ProxyTracer(rootSpan, ctx.requestId, ctx.model, ctx.stream);
+        const instance = new ProxyTracer(rootSpan, ctx.requestId, ctx.model, ctx.stream, ctx.provider ?? "anthropic");
         // Set Langfuse context (fire-and-forget — non-blocking)
         // Prefer NeuroLink session/user from calling SDK over Claude Code session
         setLangfuseContext({
@@ -370,7 +382,7 @@ class ProxyTracer {
             "gen_ai.usage.total_tokens": totalTokens,
         });
         // Cost calculation via pricing.ts
-        const cost = calculateCost("anthropic", this.model, {
+        const cost = calculateCost(this.billingProvider, this.model, {
             input: ctx.inputTokens,
             output: ctx.outputTokens,
             total: totalTokens,
@@ -433,12 +445,22 @@ class ProxyTracer {
      * Record that the proxy substituted a different model than was requested.
      * Sets span attributes and increments the substitution metric counter.
      */
-    setModelSubstitution(requestedModel, actualModel) {
+    setModelSubstitution(requestedModel, actualModel, actualProvider) {
+        // Cost must follow the model that served the request, not the alias the
+        // client typed — otherwise a claude-* alias routed to another provider is
+        // billed at Claude rates. The provider has to move with it: leaving it at
+        // the tracer's default means the substituted model is looked up in the
+        // wrong pricing table, which yields no rate and so no charge at all.
+        this.model = actualModel;
+        if (actualProvider) {
+            this.billingProvider = actualProvider;
+        }
         this.rootSpan.setAttributes({
             "proxy.model_substituted": true,
             "proxy.original_model": requestedModel,
             "proxy.actual_model": actualModel,
             "gen_ai.response.model": actualModel,
+            ...(actualProvider ? { "proxy.actual_provider": actualProvider } : {}),
         });
         const m = getProxyMetrics();
         m.modelSubstitutionTotal.add(1, {
@@ -644,7 +666,7 @@ class ProxyTracer {
                 this.usage.cacheCreationTokens +
                 this.usage.cacheReadTokens +
                 (this.usage.reasoningTokens ?? 0);
-            const cost = calculateCost("anthropic", this.model, {
+            const cost = calculateCost(this.billingProvider, this.model, {
                 input: this.usage.inputTokens,
                 output: this.usage.outputTokens,
                 total: totalTokens,
@@ -683,14 +705,14 @@ class ProxyTracer {
             this.usage.cacheReadTokens +
             (this.usage.reasoningTokens ?? 0);
         const durationMs = Date.now() - this.startTime;
-        const cost = calculateCost("anthropic", this.model, {
+        const cost = calculateCost(this.billingProvider, this.model, {
             input: this.usage.inputTokens,
             output: this.usage.outputTokens,
             total: totalTokens,
             cacheCreationTokens: this.usage.cacheCreationTokens,
             cacheReadTokens: this.usage.cacheReadTokens,
         });
-        TelemetryService.getInstance().recordAIRequest("anthropic", this.model, totalTokens, durationMs, cost > 0 ? cost : undefined);
+        TelemetryService.getInstance().recordAIRequest(this.billingProvider, this.model, totalTokens, durationMs, cost > 0 ? cost : undefined);
     }
     // -------------------------------------------------------------------------
     // Context propagation