@juspay/neurolink 12.15.0 → 12.15.1

package/dist/proxy/proxyTracer.js

@@ -16,6 +16,7 @@
 import { SpanStatusCode, SpanKind, ROOT_CONTEXT, isSpanContextValid, propagation, context, metrics, trace, } from "@opentelemetry/api";
 import { getTracer, setLangfuseContext, } from "../services/server/ai/observability/instrumentation.js";
 import { OtelBridge } from "../observability/otelBridge.js";
+import { proxyTokenUsage } from "./proxyTokenUsage.js";
 import { calculateCost } from "../utils/pricing.js";
 import { TelemetryService } from "../telemetry/telemetryService.js";
 import { logger } from "../utils/logger.js";
@@ -360,17 +361,22 @@ class ProxyTracer {
             // Non-fatal
         });
     }
+    /** Attribute fallback metrics to the account that actually served them. */
+    setServedAccount(account, accountType) {
+        this.accountEmail = account;
+        this.rootSpan.setAttributes({
+            "proxy.account.served": account,
+            "proxy.account.served_type": accountType,
+        });
+    }
     /** Record token usage and cost on the root span. */
     setUsage(ctx) {
         this.usage = ctx;
-        const totalTokens = ctx.inputTokens +
-            ctx.outputTokens +
-            ctx.cacheCreationTokens +
-            ctx.cacheReadTokens +
-            (ctx.reasoningTokens ?? 0);
-        // NeuroLink-format token attributes (from SpanAttributes)
+        const billingUsage = proxyTokenUsage(ctx);
+        const totalTokens = billingUsage.total;
+        // Custom token buckets are disjoint; standard GenAI input includes cache.
         this.rootSpan.setAttributes({
-            "ai.tokens.input": ctx.inputTokens,
+            "ai.tokens.input": billingUsage.input,
             "ai.tokens.output": ctx.outputTokens,
             "ai.tokens.total": totalTokens,
             "ai.tokens.cache_creation": ctx.cacheCreationTokens,
@@ -381,18 +387,12 @@ class ProxyTracer {
         }
         // GenAI semantic convention attributes (for Langfuse compatibility)
         this.rootSpan.setAttributes({
-            "gen_ai.usage.input_tokens": ctx.inputTokens,
+            "gen_ai.usage.input_tokens": totalTokens - ctx.outputTokens,
             "gen_ai.usage.output_tokens": ctx.outputTokens,
             "gen_ai.usage.total_tokens": totalTokens,
         });
         // Cost calculation via pricing.ts
-        const cost = calculateCost(this.billingProvider, this.model, {
-            input: ctx.inputTokens,
-            output: ctx.outputTokens,
-            total: totalTokens,
-            cacheCreationTokens: ctx.cacheCreationTokens,
-            cacheReadTokens: ctx.cacheReadTokens,
-        });
+        const cost = calculateCost(this.billingProvider, this.model, billingUsage);
         if (cost > 0) {
             this.rootSpan.setAttributes({
                 "ai.cost.total": cost,
@@ -665,7 +665,7 @@ class ProxyTracer {
                 model: this.model,
                 account: this.accountEmail ?? "unknown",
             };
-            m.tokensInput.add(this.usage.inputTokens, tokenLabels);
+            m.tokensInput.add(proxyTokenUsage(this.usage).input, tokenLabels);
             m.tokensOutput.add(this.usage.outputTokens, tokenLabels);
             m.tokensCacheRead.add(this.usage.cacheReadTokens, tokenLabels);
             m.tokensCacheCreation.add(this.usage.cacheCreationTokens, tokenLabels);
@@ -673,18 +673,8 @@ class ProxyTracer {
                 m.tokensReasoning.add(this.usage.reasoningTokens, tokenLabels);
             }
             // Cost
-            const totalTokens = this.usage.inputTokens +
-                this.usage.outputTokens +
-                this.usage.cacheCreationTokens +
-                this.usage.cacheReadTokens +
-                (this.usage.reasoningTokens ?? 0);
-            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,
-            });
+            const billingUsage = proxyTokenUsage(this.usage);
+            const cost = calculateCost(this.billingProvider, this.model, billingUsage);
             if (cost > 0) {
                 m.costTotal.add(cost, tokenLabels);
             }
@@ -711,19 +701,10 @@ class ProxyTracer {
         if (!this.usage) {
             return;
         }
-        const totalTokens = this.usage.inputTokens +
-            this.usage.outputTokens +
-            this.usage.cacheCreationTokens +
-            this.usage.cacheReadTokens +
-            (this.usage.reasoningTokens ?? 0);
+        const billingUsage = proxyTokenUsage(this.usage);
+        const totalTokens = billingUsage.total;
         const durationMs = Date.now() - this.startTime;
-        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,
-        });
+        const cost = calculateCost(this.billingProvider, this.model, billingUsage);
         TelemetryService.getInstance().recordAIRequest(this.billingProvider, this.model, totalTokens, durationMs, cost > 0 ? cost : undefined);
     }
     // -------------------------------------------------------------------------

package/dist/proxy/quotaHeaders.js

@@ -133,10 +133,14 @@ export function buildQuotaResponseHeaders(context, now = Date.now()) {
     }
     const quota = context.quota;
     if (quota && context.source !== "none") {
-        set("x-neurolink-quota-session-left-pct", utilizationToLeftPct(quota.sessionUsed));
+        set("x-neurolink-quota-session-left-pct", quota.sessionStatus === "unknown"
+            ? undefined
+            : utilizationToLeftPct(quota.sessionUsed));
         set("x-neurolink-quota-session-status", quota.sessionStatus);
         set("x-neurolink-quota-session-resets-in", secondsUntil(quota.sessionResetAt, now));
-        set("x-neurolink-quota-weekly-left-pct", utilizationToLeftPct(quota.weeklyUsed));
+        set("x-neurolink-quota-weekly-left-pct", quota.weeklyStatus === "unknown"
+            ? undefined
+            : utilizationToLeftPct(quota.weeklyUsed));
         set("x-neurolink-quota-weekly-status", quota.weeklyStatus);
         set("x-neurolink-quota-weekly-resets-in", secondsUntil(quota.weeklyResetAt, now));
         set("x-neurolink-quota-unified-status", quota.unifiedStatus);
@@ -173,7 +177,7 @@ export function summarizePoolHeadroom(entries, now = Date.now()) {
             continue;
         }
         available += 1;
-        if (entry.quota) {
+        if (entry.quota && entry.quota.sessionStatus !== "unknown") {
             const left = utilizationToLeftPct(entry.quota.sessionUsed);
             if (bestSessionLeftPct === undefined || left > bestSessionLeftPct) {
                 bestSessionLeftPct = left;

package/dist/server/routes/claudeProxyRoutes.js

@@ -3693,6 +3693,25 @@ async function executeClaudeCodexFallback(args) {
     registerProxyResponseObserver(ctx.metadata, {
         onTerminal: () => childAccounting,
     });
+    const recordCodexUsage = (result) => {
+        ctx.metadata.codexFallbackModel = model;
+        try {
+            tracer?.setModelSubstitution(body.model, model, "openai");
+            tracer?.setServedAccount(codexHeaders["x-neurolink-account"] ?? "unknown", "codex-oauth");
+            if (result?.usage) {
+                tracer?.setUsage({
+                    inputTokens: result.usage.input,
+                    outputTokens: result.usage.output,
+                    cacheReadTokens: result.usage.cacheReadTokens ?? 0,
+                    cacheCreationTokens: result.usage.cacheCreationTokens ?? 0,
+                    reasoningTokens: result.usage.reasoning,
+                });
+            }
+        }
+        catch {
+            // Instrumentation must never turn completed output into a failed stream.
+        }
+    };
     const codexHeaders = { ...(codexCtx.responseHeaders ?? {}) };
     if (body.stream) {
         const bridge = await createCodexFallbackStream(codexResponse, body.model);
@@ -3712,12 +3731,14 @@ async function executeClaudeCodexFallback(args) {
             if (status >= 400) {
                 ctx.metadata.terminalErrorType = errorType;
             }
+            recordCodexUsage(result);
             tracer?.end(status, Date.now() - requestStartTime);
             logFinalRequest(status, account, accountType, errorType, message, {
                 inputTokens: result?.usage?.input,
                 outputTokens: result?.usage?.output,
                 cacheCreationTokens: result?.usage?.cacheCreationTokens,
                 cacheReadTokens: result?.usage?.cacheReadTokens,
+                reasoningTokens: result?.usage?.reasoning,
             });
             recordFallbackAttempt({
                 provider: "codex",
@@ -3862,6 +3883,7 @@ async function executeClaudeCodexFallback(args) {
         ...(parsed.usage ? { usage: parsed.usage } : {}),
         toolCalls: parsed.toolCalls,
     };
+    recordCodexUsage(parsed);
     tracer?.end(200, Date.now() - requestStartTime);
     const clientResponse = serializeClaudeResponse(internal, body.model);
     observeClaudeJsonOutput(ctx.metadata, clientResponse);
@@ -3870,6 +3892,7 @@ async function executeClaudeCodexFallback(args) {
         outputTokens: parsed.usage?.output,
         cacheCreationTokens: parsed.usage?.cacheCreationTokens,
         cacheReadTokens: parsed.usage?.cacheReadTokens,
+        reasoningTokens: parsed.usage?.reasoning,
     });
     const clientResponseText = JSON.stringify(clientResponse);
     logProxyBody({
@@ -6009,7 +6032,15 @@ function createClaudeRequestRuntimeContext(args) {
             requestId: ctx.requestId,
             method: ctx.method,
             path: ctx.path,
-            model: body.model,
+            model: typeof ctx.metadata.codexFallbackModel === "string"
+                ? ctx.metadata.codexFallbackModel
+                : body.model,
+            ...(typeof ctx.metadata.codexFallbackModel === "string"
+                ? {
+                    requestedModel: body.model,
+                    inputIncludesCachedTokens: false,
+                }
+                : {}),
             stream: !!body.stream,
             toolCount: Array.isArray(body.tools) ? body.tools.length : 0,
             account: finalAccountLabel ?? "",
@@ -6042,6 +6073,9 @@ function createClaudeRequestRuntimeContext(args) {
             ...(extra?.cacheReadTokens !== undefined
                 ? { cacheReadTokens: extra.cacheReadTokens }
                 : {}),
+            ...(extra?.reasoningTokens !== undefined
+                ? { reasoningTokens: extra.reasoningTokens }
+                : {}),
             ...(traceCtx
                 ? { traceId: traceCtx.traceId, spanId: traceCtx.spanId }
                 : {}),

package/dist/server/routes/codexProxyRoutes.d.ts

@@ -35,19 +35,15 @@ declare function refreshCodexTokenOnce(key: string, refreshToken: string): Promi
  */
 declare function loadCodexProxyAccounts(): Promise<CodexRuntimeAccount[]>;
 /**
- * Order accounts fill-first by quota: eligible (not cooling) first, then least
- * session utilization, treating unknown quota as "probe first" so a fresh
- * account gets observed rather than starved.
+ * Order non-cooling accounts ahead of cooling ones, then defer rejected quota.
+ * Within each group, probe unknown quota first and otherwise fill the least-used
+ * session so fresh accounts get observed rather than starved.
  */
 declare function orderCodexAccounts(accounts: CodexRuntimeAccount[], now: number): CodexRuntimeAccount[];
 /** Build the upstream request headers, replacing client auth with the account's. */
 declare function buildCodexUpstreamHeaders(clientHeaders: Record<string, string>, account: CodexRuntimeAccount): Record<string, string>;
-/**
- * Classify a 429 into a cooldown plan. Codex reports primary (session) and
- * secondary (weekly) windows; a rejected window cools until its reset, a plain
- * burst limit cools briefly and clamps to 15 min.
- */
-declare function planCodexCooldown(quota: AccountQuota | null, retryAfterMs: number, now: number): {
+/** Honor known quota resets while bounding unscoped or transient account cooldowns. */
+declare function planCodexCooldown(quota: AccountQuota | null, retryAfterMs: number, now: number, errorText?: string): {
     coolingUntil: number;
     reason: RateLimitCoolingReason;
 };

package/dist/server/routes/codexProxyRoutes.js

@@ -188,9 +188,9 @@ async function loadCodexProxyAccounts() {
     return accounts;
 }
 /**
- * Order accounts fill-first by quota: eligible (not cooling) first, then least
- * session utilization, treating unknown quota as "probe first" so a fresh
- * account gets observed rather than starved.
+ * Order non-cooling accounts ahead of cooling ones, then defer rejected quota.
+ * Within each group, probe unknown quota first and otherwise fill the least-used
+ * session so fresh accounts get observed rather than starved.
  */
 function orderCodexAccounts(accounts, now) {
     return [...accounts].sort((a, b) => {
@@ -199,8 +199,13 @@ function orderCodexAccounts(accounts, now) {
         if (aCooling !== bCooling) {
             return aCooling ? 1 : -1;
         }
-        const aUsed = a.quota ? a.quota.sessionUsed : -1;
-        const bUsed = b.quota ? b.quota.sessionUsed : -1;
+        const aRejected = a.quota?.unifiedStatus === "rejected";
+        const bRejected = b.quota?.unifiedStatus === "rejected";
+        if (aRejected !== bRejected) {
+            return aRejected ? 1 : -1;
+        }
+        const aUsed = a.quota && a.quota.sessionStatus !== "unknown" ? a.quota.sessionUsed : -1;
+        const bUsed = b.quota && b.quota.sessionStatus !== "unknown" ? b.quota.sessionUsed : -1;
         return aUsed - bUsed;
     });
 }
@@ -231,12 +236,51 @@ function buildCodexUpstreamHeaders(clientHeaders, account) {
     }
     return headers;
 }
-/**
- * Classify a 429 into a cooldown plan. Codex reports primary (session) and
- * secondary (weekly) windows; a rejected window cools until its reset, a plain
- * burst limit cools briefly and clamps to 15 min.
- */
-function planCodexCooldown(quota, retryAfterMs, now) {
+/** Extract explicit plan-exhaustion evidence without guessing account-wide scope. */
+function parseCodexQuotaError(errorText, now) {
+    try {
+        const payload = JSON.parse(errorText);
+        const error = payload?.error;
+        if (!error ||
+            typeof error !== "object" ||
+            (error.type !== "usage_limit_reached" &&
+                error.code !== "usage_limit_reached")) {
+            return null;
+        }
+        const absolute = error.resets_at ?? error.reset_at;
+        const relative = error.resets_in_seconds ?? error.reset_after_seconds;
+        const resetAt = typeof absolute === "number" && Number.isFinite(absolute) && absolute > 0
+            ? absolute > 4_102_444_800
+                ? absolute
+                : absolute * 1000
+            : typeof relative === "number" &&
+                Number.isFinite(relative) &&
+                relative > 0
+                ? now + relative * 1000
+                : 0;
+        // Only explicit account-wide window evidence permits a long cooldown.
+        // A model/surface-scoped or unscoped rejection must not park the entire pool.
+        const window = error.limit_type;
+        const scoped = error.model || (error.scope !== undefined && error.scope !== "account");
+        const scope = scoped
+            ? "unknown"
+            : window === "primary" || window === "session"
+                ? "session"
+                : window === "secondary" || window === "weekly"
+                    ? "weekly"
+                    : "unknown";
+        return {
+            errorCode: "usage_limit_reached",
+            resetAt: Number.isFinite(resetAt) ? resetAt : 0,
+            scope,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Honor known quota resets while bounding unscoped or transient account cooldowns. */
+function planCodexCooldown(quota, retryAfterMs, now, errorText = "") {
     // A reported reset can already be in the past — a stale header, or a clock
     // skew. Taken literally the account is eligible again immediately and the
     // pool re-sends to something the provider just rejected.
@@ -255,8 +299,25 @@ function planCodexCooldown(quota, retryAfterMs, now) {
             };
         }
     }
+    const bodyQuota = parseCodexQuotaError(errorText, now);
+    if (bodyQuota) {
+        if (bodyQuota.scope !== "unknown" && bodyQuota.resetAt > 0) {
+            return {
+                coolingUntil: Math.max(bodyQuota.resetAt, floor),
+                reason: bodyQuota.scope,
+            };
+        }
+        return {
+            coolingUntil: now +
+                Math.min(MAX_TRANSIENT_COOLDOWN_MS, Math.max(bodyQuota.resetAt - now, retryAfterMs, DEFAULT_TRANSIENT_COOLDOWN_MS)),
+            reason: "unified",
+        };
+    }
     const delay = Math.min(MAX_TRANSIENT_COOLDOWN_MS, Math.max(retryAfterMs, DEFAULT_TRANSIENT_COOLDOWN_MS));
-    return { coolingUntil: now + delay, reason: "transient" };
+    return {
+        coolingUntil: now + delay,
+        reason: quota?.unifiedStatus === "rejected" ? "unified" : "transient",
+    };
 }
 /** Set the x-neurolink-* attribution headers on the context. */
 function publishCodexHeaders(ctx, account, attempt, quota) {
@@ -268,9 +329,14 @@ function publishCodexHeaders(ctx, account, attempt, quota) {
     ctx.responseHeaders["x-neurolink-served-by"] = "codex";
     ctx.responseHeaders["x-neurolink-attempt"] = String(attempt);
     ctx.responseHeaders["x-neurolink-quota-source"] = quota ? "live" : "none";
-    if (quota) {
+    if (quota && quota.sessionStatus !== "unknown") {
         ctx.responseHeaders["x-neurolink-quota-session-left-pct"] = String(Math.round((1 - quota.sessionUsed) * 100));
-        ctx.responseHeaders["x-neurolink-weekly-left-pct"] = String(Math.round((1 - quota.weeklyUsed) * 100));
+    }
+    if (quota && quota.weeklyStatus !== "unknown") {
+        const remaining = String(Math.round((1 - quota.weeklyUsed) * 100));
+        ctx.responseHeaders["x-neurolink-quota-weekly-left-pct"] = remaining;
+        // Preserve the original Codex header for existing clients.
+        ctx.responseHeaders["x-neurolink-weekly-left-pct"] = remaining;
     }
 }
 /** Core pooled handler for POST /backend-api/codex/responses. */
@@ -389,6 +455,7 @@ async function executeCodexResponsesRequest(ctx) {
         // This is the cost provider. accountKey and the response header identify
         // the actual Codex pool that supplied the credential.
         provider: "openai",
+        inputIncludesCachedTokens: true,
         ...tracer?.getTraceContext(),
         ...(reasoningEffort ? { reasoningEffort } : {}),
         firstUsefulOutputStatus: extra.firstUsefulOutputMs !== undefined ? "observed" : "not_observed",
@@ -679,11 +746,20 @@ async function executeCodexResponsesRequest(ctx) {
                                         outputTokens: usage.outputTokens,
                                         cacheReadTokens: usage.cacheReadTokens,
                                         cacheCreationTokens: usage.cacheCreationTokens,
+                                        reasoningTokens: usage.reasoningTokensObserved
+                                            ? usage.reasoningTokens
+                                            : undefined,
                                     }
                                     : {};
                                 if (usage) {
                                     try {
-                                        tracer?.setUsage(usage);
+                                        tracer?.setUsage({
+                                            ...usage,
+                                            reasoningTokens: usage.reasoningTokensObserved
+                                                ? usage.reasoningTokens
+                                                : undefined,
+                                            inputIncludesCachedTokens: true,
+                                        });
                                     }
                                     catch {
                                         // Pricing/metrics must never change the stream outcome.
@@ -825,7 +901,9 @@ async function executeCodexResponsesRequest(ctx) {
                         saveAccountQuota(account.key, quota).catch(() => undefined);
                     }
                     const retryAfterMs = parseRetryAfterMs(upstream.headers.get("retry-after"));
-                    const plan = planCodexCooldown(quota, retryAfterMs, Date.now());
+                    const now = Date.now();
+                    const bodyQuota = parseCodexQuotaError(errText, now);
+                    const plan = planCodexCooldown(quota, retryAfterMs, now, errText);
                     await saveAccountCooldown(account.key, plan.coolingUntil, plan.reason).catch(() => undefined);
                     const rateLimitKind = plan.reason === "transient" ? "transient" : "quota";
                     const errorMessage = summarizeCodexUpstreamError(errText, "Codex account rate-limited");
@@ -833,11 +911,21 @@ async function executeCodexResponsesRequest(ctx) {
                     writeAttempt(account, attempt, attemptStartedAt, upstream.status, {
                         errorType: "rate_limit_error",
                         errorMessage,
-                        retryable: true,
+                        retryable: rateLimitKind === "transient",
                         rateLimitKind,
                         cooldownReason: plan.reason,
+                        ...(bodyQuota
+                            ? {
+                                errorCode: bodyQuota.errorCode,
+                                quotaResetAt: bodyQuota.resetAt || undefined,
+                                quotaScope: bodyQuota.scope,
+                            }
+                            : {}),
                     });
-                    lastFailure = { errorType: "rate_limit_error" };
+                    lastFailure = {
+                        errorType: "rate_limit_error",
+                        errorCode: bodyQuota?.errorCode,
+                    };
                     lastErrorStatus = 429;
                     lastErrorMessage = "Codex account rate-limited";
                     break; // rotate

package/dist/types/codex.d.ts

@@ -64,6 +64,8 @@ export type CodexRateLimitWindow = {
 };
 /** Codex rate-limit block: a primary (short) and secondary (long) window. */
 export type CodexRateLimits = {
+    allowed?: boolean;
+    limit_reached?: boolean;
     primary?: CodexRateLimitWindow | null;
     secondary?: CodexRateLimitWindow | null;
 };
@@ -73,6 +75,8 @@ export type CodexUsageResponse = {
     rate_limits?: CodexRateLimits | null;
     /** Current ChatGPT WHAM account-usage payload. */
     rate_limit?: {
+        allowed?: boolean;
+        limit_reached?: boolean;
         primary_window?: CodexRateLimitWindow | null;
         secondary_window?: CodexRateLimitWindow | null;
     } | null;
@@ -86,6 +90,12 @@ export type CodexUsageFetchResult = {
     ok: false;
     reason: "not_oauth" | "auth" | "rate_limited" | "http" | "network" | "parse";
 };
+/** Explicit plan-exhaustion evidence from a Codex error response. */
+export type CodexQuotaError = {
+    errorCode: string;
+    resetAt: number;
+    scope: "session" | "weekly" | "unknown";
+};
 /** A Codex account with its runtime cooldown/quota state hydrated from disk. */
 export type CodexRuntimeAccount = {
     key: string;

package/dist/types/proxy.d.ts

@@ -221,6 +221,7 @@ export type InternalResult = {
         total: number;
         cacheCreationTokens?: number;
         cacheReadTokens?: number;
+        reasoning?: number;
     };
     toolCalls?: Array<{
         toolCallId: string;
@@ -576,6 +577,8 @@ export type RequestLogEntry = {
     method: string;
     path: string;
     model: string;
+    /** Client model when a different upstream model served the request. */
+    requestedModel?: string;
     stream: boolean;
     toolCount: number;
     account: string;
@@ -590,10 +593,14 @@ export type RequestLogEntry = {
     errorCode?: string;
     /** Whether changing credentials can affect this transport failure. */
     transportScope?: ProxyTransportScope;
+    /** True when input includes the cache breakdown (native Codex wire usage). */
+    inputIncludesCachedTokens?: boolean;
     inputTokens?: number;
     outputTokens?: number;
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
+    /** Reasoning tokens are a subset of output, never additional usage. */
+    reasoningTokens?: number;
     /**
      * Provider that actually served the request, for costing. Absent on records
      * written before this field existed; `proxyAnalysis` then falls back to a
@@ -814,6 +821,10 @@ export type RequestAttemptLogEntry = {
     rateLimitKind?: "transient" | "quota";
     /** Reset-aware cooldown reason selected for a rate-limited attempt. */
     cooldownReason?: "transient" | "session" | "weekly" | "unified";
+    /** Reset reported by a structured quota rejection, epoch milliseconds. */
+    quotaResetAt?: number;
+    /** Unknown scope never implies an account-wide long-window rejection. */
+    quotaScope?: "session" | "weekly" | "unknown";
     inputTokens?: number;
     outputTokens?: number;
     cacheCreationTokens?: number;
@@ -828,9 +839,9 @@ export type RequestAttemptLogEntry = {
     traceFlags?: number;
 };
 /** Additional fields recorded when a Codex response becomes client-final. */
-export type CodexFinalLogExtra = Partial<Pick<RequestLogEntry, "errorType" | "errorMessage" | "errorCode" | "transportScope" | "inputTokens" | "outputTokens" | "cacheReadTokens" | "cacheCreationTokens" | "terminalOutcome" | "firstUsefulOutputMs" | "firstUsefulOutputStatus" | "firstUsefulOutputEvent">>;
+export type CodexFinalLogExtra = Partial<Pick<RequestLogEntry, "errorType" | "errorMessage" | "errorCode" | "transportScope" | "inputTokens" | "outputTokens" | "cacheReadTokens" | "cacheCreationTokens" | "reasoningTokens" | "terminalOutcome" | "firstUsefulOutputMs" | "firstUsefulOutputStatus" | "firstUsefulOutputEvent">>;
 /** Additional fields recorded for each upstream Codex account attempt. */
-export type CodexAttemptLogExtra = Partial<Pick<RequestAttemptLogEntry, "errorType" | "errorMessage" | "errorCode" | "transportScope" | "retryable" | "rateLimitKind" | "cooldownReason">>;
+export type CodexAttemptLogExtra = Partial<Pick<RequestAttemptLogEntry, "errorType" | "errorMessage" | "errorCode" | "transportScope" | "retryable" | "rateLimitKind" | "cooldownReason" | "quotaResetAt" | "quotaScope">>;
 /** Minimal persistence contract needed by Codex rotating-token refreshes. */
 export type CodexRefreshTokenStore = {
     peekTokens(provider: string): Promise<StoredOAuthTokens | null>;
@@ -863,6 +874,7 @@ export type ClaudeFinalRequestLogger = (status: number, accountLabel: string, ac
     outputTokens?: number;
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
+    reasoningTokens?: number;
     errorCode?: string;
     transportScope?: ProxyTransportScope;
 }) => void;
@@ -1246,15 +1258,15 @@ export type AccountQuota = {
     /** Top-level unified status. A rejected value can be authoritative even
      *  while both 5h and 7d sub-window statuses still report allowed. */
     unifiedStatus?: string;
-    /** 0.0-1.0  (from unified-5h-utilization) */
+    /** 0.0-1.0 utilization; ignore the numeric placeholder when status is unknown. */
     sessionUsed: number;
-    /** "allowed" | "throttled" | "rejected" */
+    /** "allowed" | "throttled" | "rejected" | "unknown" */
     sessionStatus: string;
     /** Unix timestamp (seconds) when the 5h window resets */
     sessionResetAt: number;
-    /** 0.0-1.0  (from unified-7d-utilization) */
+    /** 0.0-1.0 utilization; ignore the numeric placeholder when status is unknown. */
     weeklyUsed: number;
-    /** "allowed" | "throttled" | "rejected" */
+    /** "allowed" | "throttled" | "rejected" | "unknown" */
     weeklyStatus: string;
     /** Unix timestamp (seconds) when the 7d window resets */
     weeklyResetAt: number;
@@ -1700,6 +1712,8 @@ export type UpstreamAttemptContext = {
 };
 /** Token usage and rate-limit utilisation recorded at end of request. */
 export type UsageContext = {
+    /** True when input includes the cache breakdown (native Codex wire usage). */
+    inputIncludesCachedTokens?: boolean;
     inputTokens: number;
     outputTokens: number;
     cacheCreationTokens: number;
@@ -2008,6 +2022,7 @@ export type ProxyAnalysisReport = {
         requestsWithCacheRead: number;
         cacheReadTokens: number;
         cacheCreationTokens: number;
+        /** Ordinary input, excluding the separately reported cache read/write buckets. */
         inputTokens: number;
         outputTokens: number;
         requestHitRate: number | null;
@@ -2068,6 +2083,7 @@ export type ProxyAnalysisFinalRequestRecord = {
     accountType: string;
     model: string | null;
     provider: string | null;
+    inputIncludesCachedTokens?: boolean;
     inputTokens: number | null;
     outputTokens: number | null;
     cacheReadTokens: number | null;
@@ -2104,6 +2120,8 @@ export type CodexStreamUsage = {
     /** Cache writes, which bill at a premium over both reads and plain input. */
     cacheCreationTokens: number;
     reasoningTokens: number;
+    /** Whether the provider supplied a valid reasoning breakdown. */
+    reasoningTokensObserved?: boolean;
 };
 /** Semantic completion evidence observed in native Codex SSE bytes. */
 export type CodexStreamEvidence = {

package/dist/utils/pricing.js

@@ -899,8 +899,10 @@ export function calculateCost(provider, model, usage) {
         // priced providers still get the cheaper cacheRead rate.
         cost += usage.cacheReadTokens * (rates.cacheRead ?? rates.input);
     }
-    if (usage.cacheCreationTokens && rates.cacheCreation) {
-        cost += usage.cacheCreationTokens * rates.cacheCreation;
+    if (usage.cacheCreationTokens) {
+        // Like cache reads, disjoint cache writes must not silently become free
+        // when a model has no separate creation rate. Preserve explicit zero rates.
+        cost += usage.cacheCreationTokens * (rates.cacheCreation ?? rates.input);
     }
     return Math.round(cost * 1_000_000) / 1_000_000; // Round to 6 decimal places
 }