@juspay/neurolink 12.15.0 → 12.15.1

package/dist/cli/commands/auth.js

@@ -248,8 +248,12 @@ function formatQuotaColumns(quota) {
         return chalk.green(text);
     };
     return {
-        sessionText: colorize(sessionRemaining, `${sessionRemaining}% left`),
-        weeklyText: colorize(weeklyRemaining, `${weeklyRemaining}% left`),
+        sessionText: quota.sessionStatus === "unknown"
+            ? chalk.gray("unknown")
+            : colorize(sessionRemaining, `${sessionRemaining}% left`),
+        weeklyText: quota.weeklyStatus === "unknown"
+            ? chalk.gray("unknown")
+            : colorize(weeklyRemaining, `${weeklyRemaining}% left`),
         sessionReset: quota.sessionResetAt > 0
             ? chalk.gray(`resets ${formatTimeUntil(quota.sessionResetAt)}`)
             : "",

package/dist/cli/commands/proxy.d.ts

@@ -82,6 +82,10 @@ export declare function createProxyStartApp(params: {
     app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
     readiness: ProxyReadinessState;
 }>;
+/** Reload only the ready serving worker. A candidate still starting must not
+ * receive SIGHUP before it has installed its handlers. It loads fresh config
+ * during startup; draining workers already hold their request snapshots. */
+export declare function registerProxySupervisorReload(activeWorkerPid: () => number | undefined): () => void;
 export declare const proxyStartCommand: CommandModule<object, ProxyStartArgs>;
 export declare function sanitizeProxyStatusTerminalErrorMessage(message: string): string;
 export declare const proxyStatusCommand: CommandModule<object, ProxyStatusArgs>;

package/dist/cli/commands/proxy.js

@@ -1,4 +1,5 @@
 import { initializeProxyOtelLogs, routeProxyConsoleToOtel, flushProxyOtelLogs, shutdownProxyOtelLogs, isProxyOtelOnly, withProxyOtelLogShutdown, } from "../../proxy/otelLogSink.js";
+import { registerCliShutdownOwner } from "../lifecycle.js";
 import { writeFileAtomic } from "../proxy-clients/snapshot.js";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
@@ -60,6 +61,9 @@ const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/obse
  */
 const gatedShareRequests = new WeakSet();
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
+// Allow the normal 30-second worker drain plus startup settlement, leaving
+// telemetry and scheduling headroom inside launchd's 45-second stop budget.
+const PROXY_SUPERVISOR_DRAIN_TIMEOUT_MS = 35_000;
 /** How long shutdown waits on the share listener before moving on. */
 const SHARE_LISTENER_CLOSE_TIMEOUT_MS = 10_000;
 const PROXY_STATUS_RECONCILE_TIMEOUT_MS = 750;
@@ -2504,10 +2508,12 @@ function registerProxyShutdownHandlers(params) {
         }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../services/server/ai/observability/instrumentation.js");
-            await flushProxyOtelLogs();
-            await shutdownProxyOtelLogs();
-            await flushOpenTelemetry();
-            await shutdownOpenTelemetry();
+            await withShutdownDeadline((async () => {
+                await flushProxyOtelLogs();
+                await shutdownProxyOtelLogs();
+                await flushOpenTelemetry();
+                await shutdownOpenTelemetry();
+            })(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "telemetry shutdown");
         }
         catch {
             // non-fatal — proxy shutdown must not block on OTel
@@ -2535,12 +2541,7 @@ function registerProxyShutdownHandlers(params) {
         process.exit(1);
     };
     if (params.registerSignals ?? true) {
-        process.on("SIGTERM", () => {
-            void shutdown("SIGTERM").catch(forceExitAfterShutdownFailure);
-        });
-        process.on("SIGINT", () => {
-            void shutdown("SIGINT").catch(forceExitAfterShutdownFailure);
-        });
+        registerCliShutdownOwner((signal) => shutdown(signal).catch(forceExitAfterShutdownFailure));
     }
     return shutdown;
 }
@@ -2866,10 +2867,81 @@ async function startProxyRuntime(params) {
  * serving-process exits.
  */
 async function runLaunchdProxySupervisor(argv, spinner) {
+    let stopping = false;
+    let activeWorkerPid;
+    let rollingServerTask;
+    let restartControlTask;
+    let updaterSupervisor;
+    let activatePendingUpdate;
+    let otelInitialized = false;
+    /** Own startup as well as serving: await resources already being created,
+     * then drain each independently so one cleanup failure cannot skip the rest. */
+    const shutdown = async (signal) => {
+        if (stopping) {
+            return;
+        }
+        stopping = true;
+        logger.always(`[proxy-supervisor] shutting down (${signal})`);
+        if (activatePendingUpdate) {
+            process.off("SIGUSR2", activatePendingUpdate);
+        }
+        let exitCode = process.exitCode ?? 0;
+        const reportCleanupFailure = (error) => {
+            exitCode = 1;
+            logger.warn(`[proxy-supervisor] cleanup failed: ${String(error)}`);
+        };
+        const cleanup = async (operation, timeoutMs = PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, timeoutMessage = "supervisor resource shutdown deadline exceeded") => {
+            try {
+                await withTimeout(Promise.resolve().then(operation), timeoutMs, timeoutMessage);
+            }
+            catch (error) {
+                reportCleanupFailure(error);
+            }
+        };
+        // Close independently: a stalled control must not delay the worker drain.
+        // The operations retain their continuations after a deadline, so a resource
+        // returned during telemetry cleanup is still closed without extending exit.
+        await Promise.all([
+            cleanup(async () => {
+                // Setup errors are already reported by the control-plane startup path.
+                const control = await restartControlTask?.catch(() => undefined);
+                await control?.close();
+            }),
+            cleanup(() => updaterSupervisor?.stop()),
+            cleanup(async () => {
+                const server = await rollingServerTask;
+                await server?.close();
+            }, PROXY_SUPERVISOR_DRAIN_TIMEOUT_MS),
+        ]);
+        if (otelInitialized) {
+            await cleanup(async () => {
+                await flushProxyLifecycleEvents().catch(reportCleanupFailure);
+                await flushProxyOtelLogs().catch(reportCleanupFailure);
+                await shutdownProxyOtelLogs();
+            }, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "supervisor telemetry shutdown deadline exceeded");
+        }
+        await cleanup(() => {
+            const supervisorState = loadProxySupervisorState();
+            if (supervisorState?.pid === process.pid) {
+                clearProxySupervisorState();
+            }
+        });
+        process.exit(exitCode);
+    };
+    registerCliShutdownOwner(shutdown);
+    // Protect every startup await; a worker loads fresh config before readiness.
+    registerProxySupervisorReload(() => stopping ? undefined : activeWorkerPid?.());
     await loadProxyStartEnv(argv, spinner);
+    if (stopping) {
+        return;
+    }
     initializeProxyOtelLogs("supervisor");
+    otelInitialized = true;
     routeProxyConsoleToOtel();
     await ensureProxyStartAllowed(spinner);
+    if (stopping) {
+        return;
+    }
     const entryScript = process.argv[1];
     if (!entryScript) {
         throw new Error("proxy supervisor cannot resolve the CLI entry script");
@@ -2885,7 +2957,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     });
     let currentUpdaterPid;
     let restartControl;
-    const rollingServer = await startRollingProxyServer({
+    rollingServerTask = startRollingProxyServer({
         onEvent: (event) => logProxyLifecycleEvent({
             event: "supervisor_event",
             requestId: "-",
@@ -2920,9 +2992,20 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         },
         log: (message) => logger.always(message),
     });
+    // Retain the creation promise before awaiting it so shutdown owns late results.
+    const rollingServer = await rollingServerTask.catch((error) => {
+        if (!stopping) {
+            throw error;
+        }
+        return undefined;
+    });
+    if (stopping || !rollingServer) {
+        return;
+    }
+    activeWorkerPid = () => rollingServer.snapshot().active?.pid;
     let rollingReplacement = null;
-    const activatePendingUpdate = () => {
-        if (rollingReplacement) {
+    activatePendingUpdate = () => {
+        if (stopping || rollingReplacement) {
             return;
         }
         let pendingVersion;
@@ -2953,7 +3036,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     process.on("SIGUSR2", activatePendingUpdate);
     const readinessHost = host === "0.0.0.0" ? "127.0.0.1" : host;
     try {
-        restartControl = await startProxyRestartControl({
+        restartControlTask = startProxyRestartControl({
             stateDir: join(homedir(), ".neurolink"),
             server: rollingServer,
             getTelemetry: getProxyProcessTelemetry,
@@ -2977,11 +3060,15 @@ async function runLaunchdProxySupervisor(argv, spinner) {
                 return response.json();
             },
         });
+        restartControl = await restartControlTask;
     }
     catch (error) {
         // A control-plane setup failure must not stop an otherwise serving proxy.
         logger.warn(`[proxy-supervisor] safe restart control unavailable: ${error instanceof Error ? error.message : String(error)}`);
     }
+    if (stopping) {
+        return;
+    }
     const updatePersistedUpdaterPid = (updaterPid) => {
         currentUpdaterPid = updaterPid;
         const state = loadProxySupervisorState();
@@ -2994,7 +3081,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
             restartControl: restartControl?.identity,
         });
     };
-    const updaterSupervisor = startUpdaterWorkerSupervisor({
+    updaterSupervisor = startUpdaterWorkerSupervisor({
         spawnWorker: () => spawnProxyUpdater(readinessHost, rollingServer.address.port, process.pid, true),
         isProcessRunning,
         stopWorker: (pid) => process.kill(pid, "SIGTERM"),
@@ -3006,34 +3093,27 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         spinner.succeed(chalk.green("Claude proxy supervisor started successfully"));
     }
     logger.always(`[proxy-supervisor] listening on ${host}:${rollingServer.address.port} workerPid=${rollingServer.snapshot().active?.pid ?? "unknown"} version=${PROXY_VERSION}`);
-    let stopping = false;
-    /** Drain the rolling workers and flush the supervisor journal before clearing ownership. */
-    const shutdown = async (signal) => {
-        if (stopping) {
+    await new Promise(() => undefined);
+}
+/** Reload only the ready serving worker. A candidate still starting must not
+ * receive SIGHUP before it has installed its handlers. It loads fresh config
+ * during startup; draining workers already hold their request snapshots. */
+export function registerProxySupervisorReload(activeWorkerPid) {
+    const reload = () => {
+        const pid = activeWorkerPid();
+        if (!pid) {
             return;
         }
-        stopping = true;
-        logger.always(`[proxy-supervisor] shutting down (${signal})`);
-        process.off("SIGUSR2", activatePendingUpdate);
-        await restartControl?.close();
-        updaterSupervisor.stop();
-        await rollingServer.close();
-        await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));
-        await flushProxyOtelLogs().catch(() => undefined);
-        await shutdownProxyOtelLogs().catch(() => undefined);
-        const supervisorState = loadProxySupervisorState();
-        if (supervisorState?.pid === process.pid) {
-            clearProxySupervisorState();
+        try {
+            process.kill(pid, "SIGHUP");
+            logger.always(`[proxy-supervisor] forwarded configuration reload to worker pid=${pid}`);
+        }
+        catch (error) {
+            logger.warn(`[proxy-supervisor] configuration reload failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        process.exit(0);
     };
-    process.once("SIGTERM", () => {
-        void shutdown("SIGTERM");
-    });
-    process.once("SIGINT", () => {
-        void shutdown("SIGINT");
-    });
-    await new Promise(() => undefined);
+    process.on("SIGHUP", reload);
+    return () => process.off("SIGHUP", reload);
 }
 async function startProxyCommandHandler(argv) {
     const spinner = argv.quiet ? null : ora("Starting Claude proxy...").start();

package/dist/cli/index.js

@@ -9,6 +9,7 @@ process.env.DOTENV_CONFIG_QUIET = "true";
  */
 import { initializeCliParser } from "./parser.js";
 import chalk from "chalk";
+import { initializeCliLifecycle, cleanupCliLifecycle } from "./lifecycle.js";
 // Clean up pnpm-specific environment variables that cause npm warnings
 // These variables are set by pnpm but cause "Unknown env config" warnings in npm
 if (process.env.npm_config_verify_deps_before_run) {
@@ -30,34 +31,23 @@ catch {
 }
 // Enhanced CLI with Professional UX
 const cli = initializeCliParser();
+initializeCliLifecycle(async () => {
+    const { flushOpenTelemetry } = await import("../services/server/ai/observability/instrumentation.js");
+    await flushOpenTelemetry();
+});
 // Execute CLI
 (async () => {
     try {
         // Parse and execute commands
         await cli.parse();
-        await cleanup();
+        await cleanupCliLifecycle();
     }
     catch (error) {
         // Global error handler - should not reach here due to fail() handler
         process.stderr.write(chalk.red(`Unexpected CLI _error: ${error.message}\n`));
-        await cleanup();
+        process.exitCode = 1;
+        await cleanupCliLifecycle();
         process.exit(1);
     }
 })();
-// Cleanup on exit
-process.on("SIGINT", async () => {
-    await cleanup();
-    process.exit(0);
-});
-process.on("SIGTERM", async () => {
-    await cleanup();
-    process.exit(0);
-});
-process.on("beforeExit", async () => {
-    await cleanup();
-});
-async function cleanup() {
-    const { flushOpenTelemetry } = await import("../services/server/ai/observability/instrumentation.js");
-    await flushOpenTelemetry();
-}
 //# sourceMappingURL=index.js.map

package/dist/cli/lifecycle.d.ts

@@ -0,0 +1,8 @@
+/** Install ordinary-command cleanup and its maximum flush duration. */
+export declare function initializeCliLifecycle(cleanup: () => Promise<void>, timeoutMs?: number): void;
+/** Delegate signals to a long-lived command that owns draining and exit. */
+export declare function registerCliShutdownOwner(handler: (signal: NodeJS.Signals) => Promise<void>): void;
+/** Flush ordinary commands once; an active shutdown owner manages its own cleanup. */
+export declare function cleanupCliLifecycle(): Promise<void>;
+/** Bound best-effort cleanup without allowing rejection to escape a signal handler. */
+export declare function runBoundedCliCleanup(cleanup: () => Promise<unknown>, timeoutMs?: number, onTimeout?: () => void): Promise<void>;

package/dist/cli/lifecycle.js

@@ -0,0 +1,90 @@
+/** One signal owner per CLI process. Proxy lifecycles own their drain and exit;
+ * ordinary commands only need a bounded, best-effort telemetry flush. */
+let owner;
+let cleanupTask;
+let cleanupPromise;
+let shutdownPromise;
+let installed = false;
+let cleanupTimeoutMs = 5_000;
+/** Install ordinary-command cleanup and its maximum flush duration. */
+export function initializeCliLifecycle(cleanup, timeoutMs = 5_000) {
+    cleanupTask = cleanup;
+    cleanupTimeoutMs = timeoutMs;
+    installSignals();
+}
+/** Delegate signals to a long-lived command that owns draining and exit. */
+export function registerCliShutdownOwner(handler) {
+    owner = handler;
+    installSignals();
+}
+/** Flush ordinary commands once; an active shutdown owner manages its own cleanup. */
+export function cleanupCliLifecycle() {
+    if (owner) {
+        return Promise.resolve();
+    }
+    cleanupPromise ??= runBoundedCliCleanup(() => cleanupTask?.() ?? Promise.resolve(), cleanupTimeoutMs, () => {
+        // A stalled exporter may retain handles after Promise.race settles.
+        // A newly registered owner still retains control of draining and exit.
+        if (!owner) {
+            process.exit(process.exitCode ?? 0);
+        }
+    });
+    return cleanupPromise;
+}
+/** Bound best-effort cleanup without allowing rejection to escape a signal handler. */
+export async function runBoundedCliCleanup(cleanup, timeoutMs = 5_000, onTimeout) {
+    let timer;
+    let timedOut = false;
+    try {
+        await Promise.race([
+            Promise.resolve().then(cleanup),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    timedOut = true;
+                    reject(new Error("telemetry flush deadline exceeded"));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        process.stderr.write(`[cli] cleanup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (timedOut) {
+        onTimeout?.();
+    }
+}
+/** Install one process-wide signal dispatcher and reuse the first shutdown promise. */
+function installSignals() {
+    if (installed) {
+        return;
+    }
+    installed = true;
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.on(signal, () => {
+            shutdownPromise ??= Promise.resolve()
+                .then(async () => {
+                if (!owner) {
+                    await cleanupCliLifecycle();
+                }
+                // Startup may register the proxy owner while the flush is pending.
+                if (owner) {
+                    await owner(signal);
+                }
+                else {
+                    process.exit(process.exitCode ?? 0);
+                }
+            })
+                .catch((error) => {
+                process.stderr.write(`[cli] shutdown failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                process.exit(1);
+            });
+        });
+    }
+    process.once("beforeExit", () => {
+        void cleanupCliLifecycle();
+    });
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/proxy/codexAccountUsage.js

@@ -103,9 +103,14 @@ function windowResetEpochSeconds(window, nowSeconds) {
     }
     return 0;
 }
-function deriveWindowStatus(usedFraction) {
-    return usedFraction >= 1 ? "rejected" : "allowed";
+/** Classify only finite, nonnegative utilization; invalid measurements stay unknown. */
+function deriveWindowStatus(percent) {
+    if (typeof percent !== "number" || !Number.isFinite(percent) || percent < 0) {
+        return "unknown";
+    }
+    return percent >= 100 ? "rejected" : "allowed";
 }
+/** Normalize a reported window while retaining uncertainty in its status. */
 function toQuotaWindow(kind, group, window, nowSeconds) {
     if (!window) {
         return null;
@@ -115,7 +120,7 @@ function toQuotaWindow(kind, group, window, nowSeconds) {
         kind,
         group,
         used,
-        status: deriveWindowStatus(used),
+        status: deriveWindowStatus(window.used_percent),
         resetsAt: windowResetEpochSeconds(window, nowSeconds),
         isActive: true,
     };
@@ -137,11 +142,16 @@ export function codexRateLimitsToQuota(rateLimits, now = Date.now()) {
         windows.push(secondaryWindow);
     }
     return {
+        unifiedStatus: rateLimits?.limit_reached === true || rateLimits?.allowed === false
+            ? "rejected"
+            : rateLimits?.allowed === true
+                ? "allowed"
+                : "unknown",
         sessionUsed,
-        sessionStatus: deriveWindowStatus(sessionUsed),
+        sessionStatus: deriveWindowStatus(primary?.used_percent),
         sessionResetAt: windowResetEpochSeconds(primary, nowSeconds),
         weeklyUsed,
-        weeklyStatus: deriveWindowStatus(weeklyUsed),
+        weeklyStatus: deriveWindowStatus(secondary?.used_percent),
         weeklyResetAt: windowResetEpochSeconds(secondary, nowSeconds),
         // Codex has no overage/fallback concept; keep neutral defaults.
         fallbackPercentage: 0,
@@ -169,7 +179,7 @@ export function parseCodexRateLimitHeaders(headers, now = Date.now()) {
         const rateLimits = "rate_limits" in parsed && parsed.rate_limits
             ? parsed.rate_limits
             : parsed;
-        return codexRateLimitsToQuota(rateLimits, now);
+        return { ...codexRateLimitsToQuota(rateLimits, now), source: "headers" };
     }
     catch {
         return null;
@@ -204,6 +214,8 @@ export async function fetchCodexAccountUsage(account, options = {}) {
         const usage = (await response.json());
         const rateLimits = usage.rate_limit
             ? {
+                allowed: usage.rate_limit.allowed,
+                limit_reached: usage.rate_limit.limit_reached,
                 primary: usage.rate_limit.primary_window,
                 secondary: usage.rate_limit.secondary_window,
             }

package/dist/proxy/codexFallback.js

@@ -8,6 +8,7 @@
  */
 import { ClaudeStreamSerializer, generateToolUseId } from "./claudeFormat.js";
 import { extractCodexUsage } from "./codexUsage.js";
+import { proxyTokenUsage } from "./proxyTokenUsage.js";
 export class CodexFallbackResponseError extends Error {
     status;
     responseBody;
@@ -367,13 +368,16 @@ export function parseCodexFallbackSSE(sse) {
         }
         const parsedUsage = extractCodexUsage(payload);
         if (parsedUsage) {
-            usage = {
-                input: parsedUsage.inputTokens,
-                output: parsedUsage.outputTokens,
-                total: parsedUsage.inputTokens + parsedUsage.outputTokens,
+            usage = proxyTokenUsage({
+                inputTokens: parsedUsage.inputTokens,
+                outputTokens: parsedUsage.outputTokens,
+                reasoningTokens: parsedUsage.reasoningTokensObserved
+                    ? parsedUsage.reasoningTokens
+                    : undefined,
                 cacheReadTokens: parsedUsage.cacheReadTokens,
                 cacheCreationTokens: parsedUsage.cacheCreationTokens,
-            };
+                inputIncludesCachedTokens: true,
+            });
         }
         textFromResponse = outputTextFromResponse(payload);
     }
@@ -516,13 +520,16 @@ export async function createCodexFallbackStream(response, model) {
                     completed = true;
                     const parsedUsage = extractCodexUsage(payload);
                     if (parsedUsage) {
-                        usage = {
-                            input: parsedUsage.inputTokens,
-                            output: parsedUsage.outputTokens,
-                            total: parsedUsage.inputTokens + parsedUsage.outputTokens,
+                        usage = proxyTokenUsage({
+                            inputTokens: parsedUsage.inputTokens,
+                            outputTokens: parsedUsage.outputTokens,
+                            reasoningTokens: parsedUsage.reasoningTokensObserved
+                                ? parsedUsage.reasoningTokens
+                                : undefined,
                             cacheReadTokens: parsedUsage.cacheReadTokens,
                             cacheCreationTokens: parsedUsage.cacheCreationTokens,
-                        };
+                            inputIncludesCachedTokens: true,
+                        });
                     }
                     const responseBody = payload.response;
                     if (isRecord(responseBody) && Array.isArray(responseBody.output)) {

package/dist/proxy/codexUsage.js

@@ -107,6 +107,9 @@ export function extractCodexUsage(payload) {
         cacheReadTokens: nonNegativeInt(inputDetails?.cached_tokens),
         cacheCreationTokens: nonNegativeInt(inputDetails?.cache_write_tokens),
         reasoningTokens: nonNegativeInt(outputDetails?.reasoning_tokens),
+        reasoningTokensObserved: typeof outputDetails?.reasoning_tokens === "number" &&
+            Number.isFinite(outputDetails.reasoning_tokens) &&
+            outputDetails.reasoning_tokens >= 0,
     };
 }
 /**

package/dist/proxy/proxyAnalysis.js

@@ -1,3 +1,4 @@
+import { proxyTokenUsage } from "./proxyTokenUsage.js";
 import { createReadStream } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
 import { isProxyAuxiliaryRequest } from "./proxyRequestKind.js";
@@ -411,8 +412,15 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
             request.outputTokens !== null ||
             request.cacheReadTokens !== null ||
             request.cacheCreationTokens !== null) {
+            const billingUsage = proxyTokenUsage({
+                inputIncludesCachedTokens: request.inputIncludesCachedTokens,
+                inputTokens: request.inputTokens ?? 0,
+                outputTokens: request.outputTokens ?? 0,
+                cacheCreationTokens: request.cacheCreationTokens ?? 0,
+                cacheReadTokens: request.cacheReadTokens ?? 0,
+            });
             requestsWithUsage += 1;
-            inputTokens += request.inputTokens ?? 0;
+            inputTokens += billingUsage.input;
             outputTokens += request.outputTokens ?? 0;
             cacheReadTokens += request.cacheReadTokens ?? 0;
             cacheCreationTokens += request.cacheCreationTokens ?? 0;
@@ -422,16 +430,7 @@ function summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByR
                 // "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,
-                });
+                const cost = calculateCost(request.provider ?? "openai-compatible", request.model, billingUsage);
                 // 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.
@@ -982,6 +981,10 @@ export async function analyzeProxyLogs(options) {
                 accountType: stringValue(record.accountType) ?? "unknown",
                 model: stringValue(record.model),
                 provider: stringValue(record.provider),
+                inputIncludesCachedTokens: typeof record.inputIncludesCachedTokens === "boolean"
+                    ? record.inputIncludesCachedTokens
+                    : typeof record.path === "string" &&
+                        record.path.includes("/backend-api/codex/"),
                 inputTokens: finiteNumber(record.inputTokens),
                 outputTokens: finiteNumber(record.outputTokens),
                 cacheReadTokens: finiteNumber(record.cacheReadTokens),

package/dist/proxy/proxyTokenUsage.d.ts

@@ -0,0 +1,7 @@
+import type { TokenUsage, UsageContext } from "../types/index.js";
+/** Convert proxy wire usage into disjoint billing buckets. Codex input already
+ * includes cache tokens; reasoning is included in output for both providers.
+ * OpenAI's documented formula subtracts both cached_tokens and cache_write_tokens:
+ * https://developers.openai.com/api/docs/guides/prompt-caching#monitor-cache-performance
+ */
+export declare function proxyTokenUsage(usage: UsageContext): TokenUsage;

package/dist/proxy/proxyTokenUsage.js

@@ -0,0 +1,21 @@
+/** Convert proxy wire usage into disjoint billing buckets. Codex input already
+ * includes cache tokens; reasoning is included in output for both providers.
+ * OpenAI's documented formula subtracts both cached_tokens and cache_write_tokens:
+ * https://developers.openai.com/api/docs/guides/prompt-caching#monitor-cache-performance
+ */
+export function proxyTokenUsage(usage) {
+    const cached = usage.cacheReadTokens + usage.cacheCreationTokens;
+    const input = usage.inputIncludesCachedTokens
+        ? Math.max(0, usage.inputTokens - cached)
+        : usage.inputTokens;
+    return {
+        input,
+        output: usage.outputTokens,
+        total: usage.inputIncludesCachedTokens
+            ? usage.inputTokens + usage.outputTokens
+            : input + cached + usage.outputTokens,
+        cacheReadTokens: usage.cacheReadTokens,
+        cacheCreationTokens: usage.cacheCreationTokens,
+        reasoning: usage.reasoningTokens,
+    };
+}

package/dist/proxy/proxyTracer.d.ts

@@ -57,6 +57,8 @@ declare class ProxyTracer {
     startStream(): Span;
     /** Record account selection outcome on the root span. */
     setAccountSelection(ctx: AccountSelectionContext): void;
+    /** Attribute fallback metrics to the account that actually served them. */
+    setServedAccount(account: string, accountType: string): void;
     /** Record token usage and cost on the root span. */
     setUsage(ctx: UsageContext): void;
     /**