@juspay/neurolink 12.15.0 → 12.16.0

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;
     /**

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;
 };