@timo972/cc-router 0.13.0-rc.2 → 0.13.0-rc.3

package/dist/proxy/anthropic-response-capture.js

@@ -1,4 +1,4 @@
-import { applyAnthropicInputUsage, applyAnthropicOutputUsage } from "./stats.js";
+import { applyAnthropicInputUsage, applyAnthropicOutputUsage, setUsageModel, finishUsageAttempt } from "./stats.js";
 import { createAnthropicUsageCapture } from "./usage-capture.js";
 import { createStreamLifecycleTracker } from "./stream-lifecycle.js";
 export function attachAnthropicResponseCapture(upstream, downstream, entry, startedAt, hooks = {}) {
@@ -9,19 +9,30 @@ export function attachAnthropicResponseCapture(upstream, downstream, entry, star
     entry.streamLifecycle = streamTracker.state;
     streamTracker.attach(upstream, downstream);
     upstream.on("data", (chunk) => streamTracker.observeChunk(chunk));
+    let terminal = false;
+    let ended = false;
     const usageCapture = createAnthropicUsageCapture({
         contentType,
         contentEncoding: encoding,
         onInputUsage: usage => applyAnthropicInputUsage(entry, usage),
         onOutputUsage: usage => applyAnthropicOutputUsage(entry, usage),
-        onSettled: () => hooks.onUsageSettled?.(),
-        ...(hooks.onMessageStop ? { onMessageStop: hooks.onMessageStop } : {}),
+        onModel: model => setUsageModel(entry, model),
+        onJSONComplete: () => { terminal = true; },
+        onSettled: () => { finishUsageAttempt(entry, terminal); hooks.onUsageSettled?.(); },
+        onMessageStop: () => { terminal = true; hooks.onMessageStop?.(); },
     });
     if (usageCapture) {
         upstream.on("data", (chunk) => usageCapture.write(chunk));
-        upstream.on("end", () => usageCapture.end());
+        upstream.on("end", () => { ended = true; usageCapture.end(); });
+        upstream.once("close", () => { if (!ended)
+            usageCapture.abort(); });
+        upstream.once("error", () => { if (!ended)
+            usageCapture.abort(); });
+        downstream.once("close", () => { if (!ended)
+            usageCapture.abort(); });
     }
     else {
+        finishUsageAttempt(entry, false);
         hooks.onUsageSettled?.();
     }
 }

package/dist/proxy/anthropic-routing.js

@@ -1,3 +1,4 @@
+import { boundModelId, discardUsageAttempt } from "./stats.js";
 import { acquireRequestRoute } from "./lease-lifecycle.js";
 import { normalizeSessionId } from "./session-router.js";
 import { EmptyPoolError, NoEligibleAccountError } from "./token-pool.js";
@@ -69,6 +70,13 @@ export function createAnthropicRoutingMiddleware(options) {
             routedRequest._ccRoute = selected.route;
             routedRequest._ccReleaseLease = selected.release;
             routedRequest._ccAccount = selected.route.account;
+            // The generic /v1 transport also handles token-count preflights. They are
+            // not inference attempts, even though they borrow an account/lease.
+            if (options.usageRuntime && request.method === "POST" && /^\/v1\/messages\/?(?:\?|$)/i.test(request.originalUrl)) {
+                const entry = { ts: Date.now(), accountId: selected.route.account.id, model: boundModelId(request._ccRouteContext?.requestedModel ?? "-"), type: "route" };
+                options.usageRuntime.bind(entry, "anthropic_subscription");
+                request._ccUsageEntry = entry;
+            }
             next();
         }
         catch (error) {
@@ -102,10 +110,14 @@ export function createAnthropicRefreshMiddleware(options) {
             if (options.needsRefresh(account)) {
                 const ok = await options.refresh(account);
                 if (requestTerminated(request, response)) {
+                    if (request._ccUsageEntry)
+                        discardUsageAttempt(request._ccUsageEntry);
                     release();
                     return;
                 }
                 if (!ok) {
+                    if (request._ccUsageEntry)
+                        discardUsageAttempt(request._ccUsageEntry);
                     release();
                     options.onRefreshFailure(account);
                     response.status(401).json({
@@ -119,12 +131,16 @@ export function createAnthropicRefreshMiddleware(options) {
                 }
             }
             if (requestTerminated(request, response)) {
+                if (request._ccUsageEntry)
+                    discardUsageAttempt(request._ccUsageEntry);
                 release();
                 return;
             }
             next();
         }
         catch (error) {
+            if (request._ccUsageEntry)
+                discardUsageAttempt(request._ccUsageEntry);
             release();
             if (requestTerminated(request, response))
                 return;

package/dist/proxy/messages-cross-route.js

@@ -8,7 +8,7 @@ import { encodeSseEvent, parseSseLines } from "../protocol/sse.js";
 import { forwardOpenAICodexResponse } from "../providers/openai/codex-transport.js";
 import { terminalResponsePayload, usageFromTerminalEvent, usageFromResponseBody, } from "../protocol/openai-responses-collect.js";
 import { extractAnthropicRouteContext } from "./request-model.js";
-import { stats, applyCodexUsage } from "./stats.js";
+import { stats, applyCodexUsage, captureCodexResponse } from "./stats.js";
 import { extractCodexSessionKey } from "./openai-routing.js";
 import { sendAnthropicNoEligibleResponse, detectAnthropicClientSource } from "./anthropic-routing.js";
 import { mirrorUpstreamHeaders, runOpenAIIngress, } from "./openai-ingress.js";
@@ -101,7 +101,7 @@ async function sendOpenAIAsAnthropic(upstream, res, requestedStream, entry, repo
             const failure = await sendOpenAIStreamAsAnthropic(upstream, res, entry, onUsage, report, now);
             return { statusCode: failure === undefined ? upstream.status : 502 };
         }
-        const collected = await collectOpenAIStreamAsAnthropicMessage(upstream, report);
+        const collected = await collectOpenAIStreamAsAnthropicMessage(upstream, report, entry);
         onUsage(collected.usage);
         if (collected.failure !== undefined) {
             // Mirrors collectCodexResponseStream on the /v1/responses path: a stream
@@ -122,11 +122,12 @@ async function sendOpenAIAsAnthropic(upstream, res, requestedStream, entry, repo
         return { statusCode: upstream.status };
     }
     const json = await upstream.json();
+    captureCodexResponse(entry, json);
     onUsage(usageFromResponseBody(json));
     res.status(upstream.status).json(openAIResponseToAnthropicMessage(json));
     return { statusCode: upstream.status };
 }
-async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
+async function collectOpenAIStreamAsAnthropicMessage(upstream, report, entry) {
     const reader = upstream.body?.getReader();
     if (!reader) {
         // An event-stream response with no body cannot have reached a terminal
@@ -156,6 +157,8 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
     const pendingCallsByIndex = new Map();
     const callsByIndex = new Map();
     const applyEvent = (event) => {
+        if (event && typeof event === "object")
+            captureCodexResponse(entry, event.response);
         if (typeof event !== "object" || event === null)
             return;
         const openAIEvent = event;
@@ -340,6 +343,8 @@ async function sendOpenAIStreamAsAnthropic(upstream, res, entry, onUsage, report
         }));
     };
     const inspect = (event) => {
+        if (event && typeof event === "object")
+            captureCodexResponse(entry, event.response);
         totals = usageFromTerminalEvent(event) ?? totals;
         if (typeof event !== "object" || event === null)
             return;
@@ -480,6 +485,7 @@ export function mountMessagesCrossProviderRoute(app, opts) {
             source: detectAnthropicClientSource(req.headers),
             openAIRouter: opts.openAIRouter,
             openAIPool: opts.openAIPool,
+            usageRuntime: opts.usageRuntime,
             prepareOpenAIAccount,
             forwardOpenAI,
             forwardBody: body,

package/dist/proxy/openai-ingress.js

@@ -2,7 +2,7 @@ import { applyCodexRateLimits } from "../providers/openai/account-state.js";
 import { headersToRecord, parseCodexRateLimits } from "../providers/openai/usage.js";
 import { applyCodexFailureRouting } from "../providers/openai/failure-routing.js";
 import { needsOpenAIRefresh } from "../providers/openai/token-refresher.js";
-import { stats, boundModelId, createLocalRoutingErrorLog } from "./stats.js";
+import { stats, boundModelId, createLocalRoutingErrorLog, finishUsageAttempt, discardUsageAttempt } from "./stats.js";
 import { logError, logRoute } from "./logger.js";
 import { EmptyPoolError, NoEligibleAccountError } from "./account-pool.js";
 import { acquireRequestRoute, routeReasonDetails, routeFailureDetails } from "./lease-lifecycle.js";
@@ -206,7 +206,18 @@ export async function runOpenAIIngress(opts) {
      * sends instead is its own decision — the first attempt answers a local
      * 401, a retry attempt relays the upstream failure it already holds.
      */
+    const attemptEntries = new WeakMap();
+    const entryFor = (routed) => {
+        let entry = attemptEntries.get(routed);
+        if (!entry) {
+            entry = { ts: now(), accountId: routed.route.account.id, model: requestedModel, type: "route", path };
+            opts.usageRuntime?.bind(entry, "openai_subscription");
+            attemptEntries.set(routed, entry);
+        }
+        return entry;
+    };
     const prepareRoute = async (routed) => {
+        entryFor(routed); // Bind immutable identity before token refresh can yield to account rename.
         const account = routed.route.account;
         const needed = needsOpenAIRefresh(account);
         const refreshStartedAt = now();
@@ -224,6 +235,7 @@ export async function runOpenAIIngress(opts) {
         const refreshDurationMs = now() - refreshStartedAt;
         refreshDurations.set(account, refreshDurationMs);
         if (!ready) {
+            discardUsageAttempt(entryFor(routed));
             routed.release();
             // Intentionally does not touch `account.healthy`: a single failed
             // refresh fails only this request. Disabling the account here would
@@ -275,6 +287,7 @@ export async function runOpenAIIngress(opts) {
         // Just release the lease and stop — no response to send, and it is safe to
         // release again even if the response's own close/finish listener already
         // did so (`attachLeaseLifecycle`'s release() is idempotent).
+        discardUsageAttempt(entryFor(selected));
         selected.release();
         return;
     }
@@ -287,6 +300,7 @@ export async function runOpenAIIngress(opts) {
     let attemptCount = 0;
     /** Close the attempt's span exactly once, on the outcome it ended with. */
     const endAttemptSpan = (outcome, extra = {}) => {
+        finishUsageAttempt(entryFor(selected), false);
         attemptSpan?.annotate({
             ...extra,
             outcome,
@@ -459,6 +473,7 @@ export async function runOpenAIIngress(opts) {
         // background and readies (or cools down) the account for later requests.
         const prepared = await boundedWait(prepareRoute(next), retryRefreshTimeoutMs, "still-pending", clientGone.signal);
         if (prepared === "still-pending") {
+            discardUsageAttempt(entryFor(next));
             if (!clientGone.signal.aborted) {
                 logError(next.route.account.id, 0, `failover token refresh still pending after ${retryRefreshTimeoutMs}ms — relaying held upstream failure`);
             }
@@ -497,6 +512,7 @@ export async function runOpenAIIngress(opts) {
         if (sameAccount)
             await retryDelay(sameAccountDelayMs, clientGone.signal);
         if (clientGone.signal.aborted || responseTerminated(res)) {
+            discardUsageAttempt(entryFor(selected));
             selected.release();
             settleProxyRequestSpan(res, {
                 outcome: "cancelled",
@@ -508,7 +524,8 @@ export async function runOpenAIIngress(opts) {
         }
     }
     const account = selected.route.account;
-    const entry = {
+    const entry = entryFor(selected);
+    Object.assign(entry, {
         ts: startedAt,
         accountId: account.id,
         model: requestedModel,
@@ -520,7 +537,7 @@ export async function runOpenAIIngress(opts) {
         headerDurationMs,
         correlationId,
         details,
-    };
+    });
     let finalStatus = upstream.status;
     let relayFailed = false;
     let relayFailureMessage = "";
@@ -618,6 +635,7 @@ export async function runOpenAIIngress(opts) {
         account.consecutiveErrors = 0;
         stats.totalRequests++;
     }
+    finishUsageAttempt(entry, !relayFailed && !clientCancelled && finalStatus < 400);
     entry.type = failedFinal ? "error" : "route";
     entry.statusCode = finalStatus;
     entry.durationMs = now() - startedAt;

package/dist/proxy/responses-server.js

@@ -2,7 +2,7 @@ import express from "express";
 import { selectRoute } from "../providers/route-selector.js";
 import { forwardOpenAICodexResponse } from "../providers/openai/codex-transport.js";
 import { collectCodexResponseStream, createCodexUsageObserver, usageFromResponseBody, } from "../protocol/openai-responses-collect.js";
-import { stats, applyCodexUsage, boundModelId } from "./stats.js";
+import { stats, applyCodexUsage, boundModelId, captureCodexResponse } from "./stats.js";
 import { logWarn } from "./logger.js";
 import { extractCodexSessionKey, sendOpenAINoEligibleResponse } from "./openai-routing.js";
 import { runOpenAIIngress, mirrorUpstreamHeaders, } from "./openai-ingress.js";
@@ -146,6 +146,7 @@ export function mountResponsesRoutes(app, opts) {
             source: "codex",
             openAIRouter: opts.openAIRouter,
             openAIPool: opts.openAIPool,
+            usageRuntime: opts.usageRuntime,
             prepareOpenAIAccount,
             forwardOpenAI,
             forwardBody: body,
@@ -163,7 +164,7 @@ export function mountResponsesRoutes(app, opts) {
                 : {}),
             relay: async (upstream, res, entry, report) => {
                 if (body.stream === true) {
-                    const observer = createCodexUsageObserver();
+                    const observer = createCodexUsageObserver(body => captureCodexResponse(entry, body), upstream.headers.get("content-type") ?? "");
                     // Only an upstream that actually promised a successful event stream
                     // can be judged on whether that stream completed. A non-OK response
                     // (a plain 401/429/5xx body) has no SSE events to observe, so
@@ -176,14 +177,18 @@ export function mountResponsesRoutes(app, opts) {
                     // Reported per chunk, not once at the end: this relay can throw
                     // (or be cut short) after upstream has already announced a failure,
                     // and the verdict has to survive that.
-                    await sendUpstreamResponse(upstream, res, chunk => {
-                        if (entry.firstByteDurationMs === undefined)
-                            entry.firstByteDurationMs = now() - entry.ts;
-                        observer.push(chunk);
-                        if (observer.explicitFailure() !== undefined)
-                            report.upstreamReportedFailure = true;
-                    });
-                    applyCodexUsage(entry, observer.finish());
+                    try {
+                        await sendUpstreamResponse(upstream, res, chunk => {
+                            if (entry.firstByteDurationMs === undefined)
+                                entry.firstByteDurationMs = now() - entry.ts;
+                            observer.push(chunk);
+                            if (observer.explicitFailure() !== undefined)
+                                report.upstreamReportedFailure = true;
+                        });
+                    }
+                    finally {
+                        applyCodexUsage(entry, observer.finish());
+                    }
                     // Bytes already written to the client are untouched — this only
                     // changes the REPORTED status (used for stats/activity/cooldown),
                     // matching a stream that upstream answered `200` but that ended in
@@ -197,7 +202,7 @@ export function mountResponsesRoutes(app, opts) {
                 }
                 const collected = await collectCodexResponseStream(upstream, () => {
                     report.upstreamReportedFailure = true;
-                });
+                }, body => captureCodexResponse(entry, body));
                 // Mirror upstream headers (e.g. Retry-After, x-codex-*) before sending the
                 // collected body, so failure responses reach the client unchanged per the
                 // same contract the streaming path already honors via sendUpstreamResponse.

package/dist/proxy/server.js

@@ -1,3 +1,7 @@
+import { finishUsageAttempt } from "./stats.js";
+import { startUsageRuntime } from "../usage/runtime.js";
+import { createUsageRouter } from "../usage/http.js";
+import { usageDirectoryForAccounts, withUsageRename } from "../usage/account-lifecycle.js";
 import { consumeCodexResetCredit } from "../providers/openai/usage-reset.js";
 import { createUsageResetHandler } from "./account-usage-reset.js";
 import express from "express";
@@ -372,6 +376,7 @@ export async function startServer(opts = {}) {
     const target = litellmUrl ?? "https://api.anthropic.com";
     const mode = litellmUrl ? "litellm" : "standalone";
     const accountsPath = opts.accountsPath;
+    const accountsFile = accountsPath ?? ACCOUNTS_PATH;
     const persistOpenAIAccounts = createOpenAIPersister(accountsPath);
     // Every Anthropic write goes through this, never `saveAccounts` directly, so
     // a server started with `--accounts <path>` writes back to the file it read.
@@ -389,6 +394,11 @@ export async function startServer(opts = {}) {
         console.error(chalk.yellow("  Run: cc-router setup\n"));
         process.exit(1);
     }
+    const usageRuntime = startUsageRuntime(usageDirectoryForAccounts(accountsFile), [
+        ...accounts.map(a => ({ id: a.id, provider: "anthropic_subscription" })),
+        ...openAIAccounts,
+        ...loadXaiAccounts(accountsPath),
+    ], { unmeasuredProviders: litellmUrl ? ["anthropic_subscription"] : [] });
     const pool = new TokenPool(accounts);
     const sessionRouter = new SessionRouter(pool);
     const createRoutingMetricsResolver = () => {
@@ -528,6 +538,7 @@ export async function startServer(opts = {}) {
             next();
         });
     }
+    app.use("/cc-router/usage", createUsageRouter(usageRuntime));
     // ─── Health endpoint (cc-router internal, NOT proxied) ────────────────────
     // Always reachable without auth so PM2/monitoring liveness checks keep
     // working — but the DETAILED payload (account IDs, plan tier, usage, recent
@@ -877,12 +888,12 @@ export async function startServer(opts = {}) {
                     ? {
                         rename: (oldId, nextId) => pool.renameAccount(oldId, nextId) !== null,
                         renameSessions: (oldId, nextId) => { sessionRouter.renameAccount(oldId, nextId); },
-                        persist: () => persistAnthropicAccounts(pool.getAll()),
+                        persist: () => withUsageRename(accountsFile, id, newId, () => persistAnthropicAccounts(pool.getAll())),
                     }
                     : {
                         rename: (oldId, nextId) => openAIPool.renameAccount(oldId, nextId) !== null,
                         renameSessions: (oldId, nextId) => { openAIRouter.renameAccount(oldId, nextId); },
-                        persist: () => persistOpenAIAccounts(openAIAccounts),
+                        persist: () => withUsageRename(accountsFile, id, newId, () => persistOpenAIAccounts(openAIAccounts)),
                     });
             }
             catch (err) {
@@ -1060,7 +1071,7 @@ export async function startServer(opts = {}) {
                     expiresAt: body.expiresAt,
                     scopes: Array.isArray(body.scopes) ? body.scopes : [],
                     enabled: body.enabled !== false,
-                });
+                }, accountsFile);
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -1233,6 +1244,7 @@ export async function startServer(opts = {}) {
     mountResponsesRoutes(app, {
         openAIRouter,
         openAIPool,
+        usageRuntime,
         prepareOpenAIAccount: (account) => prepareOpenAIAccountForRequest(account, openAIAccounts, persistOpenAIAccounts),
         modelRouting,
         onUpstreamAuthFailure: onOpenAIUpstreamAuthFailure,
@@ -1242,6 +1254,7 @@ export async function startServer(opts = {}) {
     mountMessagesCrossProviderRoute(app, {
         openAIRouter,
         openAIPool,
+        usageRuntime,
         prepareOpenAIAccount: (account) => prepareOpenAIAccountForRequest(account, openAIAccounts, persistOpenAIAccounts),
         modelRouting,
         onUpstreamAuthFailure: onOpenAIUpstreamAuthFailure,
@@ -1276,6 +1289,7 @@ export async function startServer(opts = {}) {
         timeoutMs: proxyRequestTimeoutMs,
         pool,
         sessionRouter,
+        usageRuntime,
         ...upstreamAttempts,
         needsRefresh,
         refresh: account => refreshAccountIfCurrent(account, pool, { persist: persistAnthropicAccounts }),
@@ -1434,6 +1448,8 @@ export async function startServer(opts = {}) {
             },
             error: (err, _req, res) => {
                 const request = _req;
+                if (request._ccUsageEntry)
+                    finishUsageAttempt(request._ccUsageEntry, false);
                 request._ccReleaseLease?.();
                 stats.totalErrors++;
                 logError("proxy", 0, err.message);
@@ -1466,6 +1482,7 @@ export async function startServer(opts = {}) {
     // CRITICAL: Do NOT use express.json() here — it consumes the body stream
     // and breaks SSE streaming passthrough.
     app.use("/v1", createAnthropicRoutingMiddleware({
+        usageRuntime,
         sessionRouter,
         onEmptyPool: onAnthropicEmptyPool,
         onNoEligibleAccount: onAnthropicNoEligibleAccount,
@@ -1521,15 +1538,18 @@ export async function startServer(opts = {}) {
         usageRefresher.stop();
         openAIUsageRefresher.stop();
         accountInfoCache.stop();
-        persistAnthropicAccounts(pool.getAll());
+        try {
+            persistAnthropicAccounts(pool.getAll());
+        }
+        finally {
+            usageRuntime.close();
+        }
         if (managesPidFile()) {
             removePid();
         }
         await shutdownTelemetryWithin(TELEMETRY_SHUTDOWN_DEADLINE_MS);
         process.exit(0);
     };
-    process.on("SIGTERM", () => { void shutdown(); });
-    process.on("SIGINT", () => { void shutdown(); });
     // ─── Update handling ──────────────────────────────────────────────────────
     // Auto-update is OFF by default: installing code unattended from the npm
     // registry (no signature/provenance check) turns any publish-channel
@@ -1551,6 +1571,7 @@ export async function startServer(opts = {}) {
                 if (ok) {
                     console.log(chalk.green("[auto-update] Restarting with new version..."));
                     persistAnthropicAccounts(pool.getAll());
+                    usageRuntime.close();
                     restartSelf();
                 }
             }
@@ -1588,7 +1609,26 @@ export async function startServer(opts = {}) {
             `  unset HOST (or set HOST=127.0.0.1).\n`));
         process.exit(1);
     }
-    app.listen(port, host, () => {
+    const server = app.listen(port, host);
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            usageRefresher.stop();
+            openAIUsageRefresher.stop();
+            accountInfoCache.stop();
+            usageRuntime.close();
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+    });
+    process.on("SIGTERM", () => { void shutdown(); });
+    process.on("SIGINT", () => { void shutdown(); });
+    {
         // Write PID for daemon/service process management
         if (managesPidFile()) {
             writePid(process.pid);
@@ -1606,5 +1646,6 @@ export async function startServer(opts = {}) {
             : chalk.gray("  Auto-failover: off — upstream failures pass through; clients own retries"));
         recordProxyStarted(totalAccountCount);
         startProxyHeartbeat(() => pool.getAll().length + openAIPool.getAll().length);
-    });
+    }
+    server.once("close", () => usageRuntime.close());
 }

package/dist/proxy/stats.js

@@ -58,23 +58,36 @@ export const stats = new ProxyStats();
  * entry that is typically already stored — the dashboard picks the values up
  * on its next poll.
  */
+function applyCumulativeAnthropicCount(entry, field, total, value) {
+    // Usage snapshots are cumulative. Absent or malformed fields are not new zeroes.
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+        return;
+    const previous = entry[field] ?? 0;
+    if (value < previous)
+        return;
+    stats[total] += value - previous;
+    entry[field] = value;
+}
+function applyAnthropicUsageSnapshot(entry, usage) {
+    applyCumulativeAnthropicCount(entry, "inputTokens", "totalInputTokens", usage.input_tokens);
+    applyCumulativeAnthropicCount(entry, "cacheReadTokens", "totalCacheReadTokens", usage.cache_read_input_tokens);
+    applyCumulativeAnthropicCount(entry, "cacheCreationTokens", "totalCacheCreationTokens", usage.cache_creation_input_tokens);
+    applyCumulativeAnthropicCount(entry, "outputTokens", "totalOutputTokens", usage.output_tokens);
+}
 export function applyAnthropicInputUsage(entry, usage) {
-    entry.cacheReadTokens = usage["cache_read_input_tokens"] ?? 0;
-    entry.cacheCreationTokens = usage["cache_creation_input_tokens"] ?? 0;
-    entry.inputTokens = usage["input_tokens"] ?? 0;
-    stats.totalCacheReadTokens += entry.cacheReadTokens;
-    stats.totalCacheCreationTokens += entry.cacheCreationTokens;
-    stats.totalInputTokens += entry.inputTokens;
+    notifyUsage(entry, { kind: "input", usage });
+    applyAnthropicUsageSnapshot(entry, usage);
 }
-/** Record Anthropic output-side usage (message_delta) — see input counterpart. */
+/** Record the positive difference from the preceding cumulative output snapshot. */
 export function applyAnthropicOutputUsage(entry, usage) {
-    entry.outputTokens = usage["output_tokens"] ?? 0;
-    stats.totalOutputTokens += entry.outputTokens;
+    notifyUsage(entry, { kind: "output", usage });
+    applyAnthropicUsageSnapshot(entry, usage);
 }
 /** Record Codex token usage on both the request's log entry and the running totals. */
 export function applyCodexUsage(entry, usage) {
     if (!usage)
         return;
+    notifyUsage(entry, { kind: "codex", usage });
     entry.inputTokens = Math.max(0, usage.inputTokens - usage.cachedInputTokens);
     entry.outputTokens = usage.outputTokens;
     entry.cacheReadTokens = usage.cachedInputTokens;
@@ -82,3 +95,19 @@ export function applyCodexUsage(entry, usage) {
     stats.totalOutputTokens += usage.outputTokens;
     stats.totalCacheReadTokens += usage.cachedInputTokens;
 }
+const usageObservers = new WeakMap();
+export function observeEntryUsage(entry, observer) { usageObservers.set(entry, observer); }
+function notifyUsage(entry, event) {
+    try {
+        usageObservers.get(entry)?.(event);
+    }
+    catch { /* Persistence must never change routing/response bytes. */ }
+}
+export function setUsageModel(entry, model) { notifyUsage(entry, { kind: "model", model }); }
+export function captureCodexResponse(entry, body) { notifyUsage(entry, { kind: "codex-response", body }); }
+export function finishUsageAttempt(entry, complete) { notifyUsage(entry, { kind: "finish", complete }); }
+/** A bound candidate was never forwarded: release capture without inventing missing usage. */
+export function discardUsageAttempt(entry) {
+    notifyUsage(entry, { kind: "discard" });
+    usageObservers.delete(entry);
+}

package/dist/proxy/usage-capture.js

@@ -1,3 +1,4 @@
+import { StringDecoder } from "node:string_decoder";
 import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
 import { MAX_RETAINED_SSE_LINE_BYTES } from "./stream-lifecycle.js";
 /** Non-streaming bodies are buffered for one parse at end-of-stream; a body
@@ -26,6 +27,7 @@ export function createAnthropicUsageCapture(options) {
     const decoder = createDecoder(options.contentEncoding);
     if (decoder === undefined)
         return null;
+    const textDecoder = new StringDecoder("utf8");
     let dead = false;
     const die = () => {
         if (dead)
@@ -70,15 +72,17 @@ export function createAnthropicUsageCapture(options) {
         for (const line of lines) {
             if (dead)
                 return;
-            if (!line.startsWith("data: "))
+            if (line.length > MAX_RETAINED_SSE_LINE_BYTES || !line.startsWith("data:"))
                 continue;
             try {
-                const evt = JSON.parse(line.slice(6));
+                const evt = JSON.parse(line.slice(5).trimStart());
+                if (evt.type === "message_start")
+                    options.onModel?.(evt.message?.model);
                 if (!gotInput && evt.type === "message_start" && evt.message?.usage) {
                     options.onInputUsage(evt.message.usage);
                     gotInput = true;
                 }
-                if (!gotOutput && evt.type === "message_delta" && evt.usage) {
+                if ((!gotOutput || options.onMessageStop) && evt.type === "message_delta" && evt.usage) {
                     options.onOutputUsage(evt.usage);
                     gotOutput = true;
                 }
@@ -102,9 +106,11 @@ export function createAnthropicUsageCapture(options) {
     const parseJSONBody = () => {
         try {
             const body = JSON.parse(jsonBuf);
+            options.onModel?.(body.model);
             if (body.usage) {
                 options.onInputUsage(body.usage);
                 options.onOutputUsage(body.usage);
+                options.onJSONComplete?.();
             }
         }
         catch { /* not a JSON body after all */ }
@@ -113,20 +119,26 @@ export function createAnthropicUsageCapture(options) {
         if (dead)
             return;
         if (isSSE) {
-            parseSSEChunk(chunk.toString("utf8"));
+            parseSSEChunk(textDecoder.write(chunk));
             return;
         }
         if (jsonBuf.length + chunk.length > MAX_JSON_BODY_BYTES) {
             die();
             return;
         }
-        jsonBuf += chunk.toString("utf8");
+        jsonBuf += textDecoder.write(chunk);
     };
     const finish = () => {
         if (dead)
             return;
-        if (isJSON)
+        if (isJSON) {
+            jsonBuf += textDecoder.end();
             parseJSONBody();
+        }
+        else
+            parseSSEChunk(textDecoder.end() + "\n");
+        if (dead)
+            return;
         dead = true;
         options.onSettled?.();
     };
@@ -134,6 +146,7 @@ export function createAnthropicUsageCapture(options) {
         return {
             write: (chunk) => consume(chunk),
             end: () => finish(),
+            abort: die,
         };
     }
     decoder.on("data", (chunk) => consume(chunk));
@@ -141,16 +154,17 @@ export function createAnthropicUsageCapture(options) {
     // Corrupt or truncated compressed data — the capture just stops; the
     // proxied bytes were never ours to begin with.
     decoder.on("error", () => die());
+    let ending = false;
+    const endDecoder = () => { if (dead || ending)
+        return; ending = true; decoder.end(); };
     return {
+        // Flush already received compressed input even when its gzip trailer never arrived.
+        abort: endDecoder,
         write: (chunk) => {
-            if (dead)
+            if (dead || ending)
                 return;
             decoder.write(chunk);
         },
-        end: () => {
-            if (dead)
-                return;
-            decoder.end();
-        },
+        end: endDecoder,
     };
 }