@juspay/neurolink 12.15.0 → 12.16.0

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/providerCatalog.generated.d.ts

@@ -1,2 +1,2 @@
-export type CatalogProviderName = "baseten" | "cerebras" | "cloudflare" | "fireworks" | "gmicloud" | "groq" | "inception-labs" | "io-intelligence" | "mancer" | "mistral" | "perplexity" | "sambanova" | "together-ai" | "upstage" | "xai";
-export type CatalogCredentialKey = "baseten" | "cerebras" | "cloudflare" | "fireworks" | "gmicloud" | "groq" | "inceptionLabs" | "ioIntelligence" | "mancer" | "mistral" | "perplexity" | "sambanova" | "together" | "upstage" | "xai";
+export type CatalogProviderName = "api-route" | "baseten" | "cerebras" | "cloudflare" | "fireworks" | "gmicloud" | "groq" | "inception-labs" | "io-intelligence" | "mancer" | "mistral" | "perplexity" | "sambanova" | "together-ai" | "upstage" | "xai";
+export type CatalogCredentialKey = "apiRoute" | "baseten" | "cerebras" | "cloudflare" | "fireworks" | "gmicloud" | "groq" | "inceptionLabs" | "ioIntelligence" | "mancer" | "mistral" | "perplexity" | "sambanova" | "together" | "upstage" | "xai";

package/dist/types/providers.d.ts

@@ -178,6 +178,10 @@ export type NeurolinkCredentials = {
         apiKey?: string;
         baseURL?: string;
     };
+    apiRoute?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
     baseten?: {
         apiKey?: string;
         baseURL?: 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
 }