@juspay/neurolink 12.7.3 → 12.7.5

package/dist/server/routes/codexProxyRoutes.js

@@ -24,8 +24,10 @@ import { loadAccountQuotas, saveAccountQuota, } from "../../proxy/accountQuota.j
 import { createCodexUsageTap } from "../../proxy/codexUsage.js";
 import { CODEX_ACCOUNT_PREFIX, parseCodexRateLimitHeaders, } from "../../proxy/codexAccountUsage.js";
 import { buildClientAttribution } from "../../proxy/clientAttribution.js";
-import { logRequest } from "../../proxy/requestLogger.js";
+import { trackProxyResponse } from "../../proxy/proxyActivity.js";
+import { logRequest, logRequestAttempt } from "../../proxy/requestLogger.js";
 import { parseRetryAfterMs } from "../../proxy/routingPolicy.js";
+import { recordAttempt, recordAttemptError, recordFinalError, recordFinalSuccess, } from "../../proxy/usageStats.js";
 import { sanitizeForLog } from "../../utils/logSanitize.js";
 import { logger } from "../../utils/logger.js";
 const CODEX_UPSTREAM_TIMEOUT_MS = 15 * 60 * 1000; // 15 min, matches Claude path
@@ -33,6 +35,32 @@ const DEFAULT_TRANSIENT_COOLDOWN_MS = 60_000;
 const MAX_TRANSIENT_COOLDOWN_MS = 15 * 60 * 1000;
 /** Brief park after a refresh attempt that never reached a verdict. */
 const CODEX_AUTH_COOLDOWN_MS = 60_000;
+const CODEX_ACCOUNT_TYPE = "codex-oauth";
+const CODEX_FALLBACK_METADATA_KEY = "neurolink.codexFallback";
+function getCodexTransportErrorCode(error) {
+    if (!error || typeof error !== "object") {
+        return undefined;
+    }
+    const directCode = error.code;
+    if (typeof directCode === "string") {
+        return directCode;
+    }
+    const cause = error.cause;
+    if (!cause || typeof cause !== "object") {
+        return undefined;
+    }
+    const causeCode = cause.code;
+    return typeof causeCode === "string" ? causeCode : undefined;
+}
+function codexTransportScope(error) {
+    const code = getCodexTransportErrorCode(error);
+    return code === "ENOTFOUND" || code === "EAI_AGAIN"
+        ? "shared_provider_transport"
+        : "connection_transport";
+}
+function summarizeCodexUpstreamError(errorText, fallback) {
+    return sanitizeForLog(errorText).slice(0, 200) || fallback;
+}
 /**
  * In-flight proactive refreshes, keyed by account.
  *
@@ -43,8 +71,7 @@ const CODEX_AUTH_COOLDOWN_MS = 60_000;
  * that is perfectly healthy.
  */
 const codexRefreshInFlight = new Map();
-/** Refresh an account's token at most once at a time. */
-async function refreshCodexTokenOnce(key, refreshToken) {
+async function refreshCodexTokenOnceWithDependencies(key, refreshToken, store, refresh) {
     const existing = codexRefreshInFlight.get(key);
     if (existing) {
         return existing;
@@ -54,20 +81,36 @@ async function refreshCodexTokenOnce(key, refreshToken) {
         // request that captured the pool just before a previous refresh completed
         // holds a token that has since been rotated; using it would spend a real
         // attempt on a grant the server has already invalidated.
-        const latest = await tokenStore.peekTokens(key).catch(() => null);
+        const latest = await store.peekTokens(key).catch(() => null);
         const current = latest?.refreshToken ?? refreshToken;
-        const refreshed = await refreshCodexToken(current);
-        return {
+        const refreshed = await refresh(current);
+        const resolved = {
             accessToken: refreshed.accessToken,
             refreshToken: refreshed.refreshToken ?? current,
-            expiresAt: refreshed.expiresAt,
+            expiresAt: refreshed.expiresAt ?? latest?.expiresAt ?? Date.now() + 3_600_000,
         };
+        // Hold the single-flight slot through persistence. Releasing it after the
+        // OAuth response but before this write lets a third request read the old
+        // rotating refresh token, receive an invalid_grant, and disable an account
+        // another request has already healed.
+        if (latest) {
+            await store.saveTokens(key, {
+                ...resolved,
+                tokenType: "Bearer",
+                ...(latest.scope ? { scope: latest.scope } : {}),
+            });
+        }
+        return resolved;
     })().finally(() => {
         codexRefreshInFlight.delete(key);
     });
     codexRefreshInFlight.set(key, pending);
     return pending;
 }
+/** Refresh an account's token at most once at a time. */
+async function refreshCodexTokenOnce(key, refreshToken) {
+    return refreshCodexTokenOnceWithDependencies(key, refreshToken, tokenStore, refreshCodexToken);
+}
 // Headers we never forward upstream (hop-by-hop, client creds, or things we
 // re-derive). The client's own auth is replaced with the pooled account's.
 const BLOCKED_UPSTREAM_HEADERS = new Set([
@@ -114,13 +157,6 @@ async function loadCodexProxyAccounts() {
                 const refreshed = await refreshCodexTokenOnce(key, tokens.refreshToken);
                 accessToken = refreshed.accessToken;
                 expiresAt = refreshed.expiresAt ?? expiresAt;
-                await tokenStore.saveTokens(key, {
-                    accessToken,
-                    refreshToken: refreshed.refreshToken,
-                    expiresAt: expiresAt ?? Date.now() + 3_600_000,
-                    tokenType: "Bearer",
-                    scope: tokens.scope,
-                });
             }
             catch (error) {
                 // Keep the stale token; a 401 upstream will trigger rotation.
@@ -241,7 +277,11 @@ export async function handleCodexResponsesRequest(ctx) {
     const model = typeof body.model === "string"
         ? body.model
         : "-";
-    const writeLog = (account, responseStatus, extra = {}) => logRequest({
+    // A Codex call made as an inner Anthropic fallback is an upstream attempt,
+    // not an independently final client request. The parent fallback owns the
+    // final status and can still recover with a later provider.
+    const isFallbackRequest = ctx.metadata?.[CODEX_FALLBACK_METADATA_KEY] === true;
+    const writeFinalLog = (account, responseStatus, extra = {}) => logRequest({
         timestamp: new Date().toISOString(),
         requestId: ctx.requestId,
         method: ctx.method,
@@ -251,16 +291,63 @@ export async function handleCodexResponsesRequest(ctx) {
         toolCount: Array.isArray(body.tools)
             ? body.tools.length
             : 0,
-        account,
-        accountType: "codex-oauth",
+        account: account?.label ?? "",
+        ...(account ? { accountKey: account.key } : {}),
+        accountType: account ? CODEX_ACCOUNT_TYPE : "",
+        // This is the cost provider. accountKey and the response header identify
+        // the actual Codex pool that supplied the credential.
+        provider: "openai",
         ...buildClientAttribution(ctx.headers),
         responseStatus,
         responseTimeMs: Date.now() - requestStartTime,
         ...extra,
     });
+    let finalOutcomeRecorded = false;
+    const recordFinalOutcome = async (account, responseStatus, extra = {}) => {
+        if (isFallbackRequest || finalOutcomeRecorded) {
+            return;
+        }
+        finalOutcomeRecorded = true;
+        if (responseStatus >= 400) {
+            recordFinalError(responseStatus, account?.label, account ? CODEX_ACCOUNT_TYPE : undefined, {
+                requestId: ctx.requestId,
+                ...(account ? { accountKey: account.key } : {}),
+                errorType: extra.errorType,
+                terminalOutcome: extra.terminalOutcome ?? "handler_error",
+                message: extra.errorMessage,
+                errorCode: extra.errorCode,
+            });
+        }
+        else {
+            recordFinalSuccess(account?.label, account ? CODEX_ACCOUNT_TYPE : undefined);
+        }
+        await writeFinalLog(account, responseStatus, extra);
+    };
+    const writeAttempt = (account, attempt, startedAt, responseStatus, extra = {}) => {
+        void logRequestAttempt({
+            timestamp: new Date().toISOString(),
+            requestId: ctx.requestId,
+            attempt,
+            method: ctx.method,
+            path: ctx.path,
+            model,
+            stream: true,
+            toolCount: Array.isArray(body.tools)
+                ? body.tools.length
+                : 0,
+            account: account.label,
+            accountKey: account.key,
+            accountType: CODEX_ACCOUNT_TYPE,
+            provider: "openai",
+            responseStatus,
+            responseTimeMs: Date.now() - requestStartTime,
+            attemptDurationMs: Date.now() - startedAt,
+            ...extra,
+        }).catch(() => undefined);
+    };
     const accounts = await loadCodexProxyAccounts();
     if (accounts.length === 0) {
-        await writeLog("", 401, {
+        await recordFinalOutcome(undefined, 401, {
             errorType: "no_accounts",
             errorMessage: "No Codex accounts",
         });
@@ -280,7 +367,7 @@ export async function handleCodexResponsesRequest(ctx) {
         const retryAfterSec = soonest
             ? Math.max(1, Math.ceil((soonest - now) / 1000))
             : 60;
-        await writeLog("", 429, {
+        await recordFinalOutcome(undefined, 429, {
             errorType: "all_accounts_cooling",
             errorMessage: "All Codex accounts are rate-limited",
         });
@@ -300,11 +387,15 @@ export async function handleCodexResponsesRequest(ctx) {
     let attempt = 0;
     let lastErrorMessage = "All Codex accounts failed";
     let lastErrorStatus = 502;
+    let lastAttemptedAccount;
     for (const account of eligible) {
-        attempt += 1;
         let authRetried = false;
         // Same-account loop only re-runs once, for a post-401 token refresh.
         for (;;) {
+            attempt += 1;
+            const attemptStartedAt = Date.now();
+            lastAttemptedAccount = account;
+            recordAttempt(account.label, CODEX_ACCOUNT_TYPE);
             let upstream;
             try {
                 upstream = await fetch(CODEX_RESPONSES_URL, {
@@ -320,6 +411,17 @@ export async function handleCodexResponsesRequest(ctx) {
                 // can act on. Keep the detail in the log and return a fixed string, so
                 // internal topology never reaches the client.
                 logger.debug(`Codex upstream fetch failed (${account.label}): ${sanitizeForLog(error instanceof Error ? error.message : String(error))}`);
+                const errorMessage = summarizeCodexUpstreamError(error instanceof Error ? error.message : String(error), "Codex upstream request failed");
+                const errorCode = getCodexTransportErrorCode(error);
+                const transportScope = codexTransportScope(error);
+                recordAttemptError(account.label, CODEX_ACCOUNT_TYPE, 502);
+                writeAttempt(account, attempt, attemptStartedAt, 502, {
+                    errorType: "network_error",
+                    errorMessage,
+                    ...(errorCode ? { errorCode } : {}),
+                    transportScope,
+                    retryable: true,
+                });
                 lastErrorMessage = "Codex upstream request failed";
                 lastErrorStatus = 502;
                 break; // rotate to next account
@@ -336,50 +438,72 @@ export async function handleCodexResponsesRequest(ctx) {
                     clearAccountCooldown(account.key, account.expiredCooldownUntil).catch(() => undefined);
                 }
                 publishCodexHeaders(ctx, account, attempt, quota);
-                await writeLog(account.label, upstream.status);
+                writeAttempt(account, attempt, attemptStartedAt, upstream.status);
                 const headers = {
                     "content-type": upstream.headers.get("content-type") ?? "text/event-stream",
                     "cache-control": "no-cache",
                     connection: "keep-alive",
                     ...(ctx.responseHeaders ?? {}),
                 };
-                // Tap the relay for token usage. The log above is written first and
-                // unconditionally so a request is never lost when a client hangs up
-                // mid-stream; this emits a second record for the same requestId
-                // carrying the counts, which proxyAnalysis merges. If the stream shape
-                // is not recognised, usage resolves null and nothing extra is written —
-                // i.e. exactly the previous behaviour.
                 if (!upstream.body) {
+                    await recordFinalOutcome(account, upstream.status, {
+                        terminalOutcome: "bodyless",
+                    });
                     return new Response(upstream.body, {
                         status: upstream.status,
                         headers,
                     });
                 }
                 const { stream: usageTap, usage: usageSeen } = createCodexUsageTap();
-                usageSeen
-                    .then((usage) => {
-                    if (!usage) {
-                        return;
-                    }
-                    return writeLog(account.label, upstream.status, {
-                        provider: "openai",
-                        inputTokens: usage.inputTokens,
-                        outputTokens: usage.outputTokens,
-                        cacheReadTokens: usage.cacheReadTokens,
-                        cacheCreationTokens: usage.cacheCreationTokens,
-                    });
-                })
-                    .catch(() => undefined);
-                return new Response(upstream.body.pipeThrough(usageTap), {
+                const relay = new Response(upstream.body.pipeThrough(usageTap), {
                     status: upstream.status,
                     headers,
                 });
+                return trackProxyResponse(relay, () => undefined, {
+                    onTerminal: ({ outcome }) => {
+                        void usageSeen
+                            .then((usage) => {
+                            const usageExtra = usage
+                                ? {
+                                    inputTokens: usage.inputTokens,
+                                    outputTokens: usage.outputTokens,
+                                    cacheReadTokens: usage.cacheReadTokens,
+                                    cacheCreationTokens: usage.cacheCreationTokens,
+                                }
+                                : {};
+                            if (outcome === "completed" || outcome === "bodyless") {
+                                return recordFinalOutcome(account, upstream.status, {
+                                    terminalOutcome: outcome,
+                                    ...usageExtra,
+                                });
+                            }
+                            return recordFinalOutcome(account, outcome === "client_cancelled" ? 499 : 502, {
+                                errorType: outcome === "client_cancelled"
+                                    ? "client_cancelled"
+                                    : "stream_error",
+                                errorMessage: outcome === "client_cancelled"
+                                    ? "Client cancelled Codex stream"
+                                    : "Codex upstream stream failed",
+                                terminalOutcome: outcome,
+                                ...usageExtra,
+                            });
+                        })
+                            .catch(() => undefined);
+                    },
+                });
             }
             const errText = await upstream.text().catch(() => "");
             // 401/403 → try a forced token refresh once, then rotate.
             if ((upstream.status === 401 || upstream.status === 403) &&
                 !authRetried &&
                 account.refreshToken) {
+                const errorMessage = summarizeCodexUpstreamError(errText, "Codex authentication rejected upstream");
+                recordAttemptError(account.label, CODEX_ACCOUNT_TYPE, upstream.status);
+                writeAttempt(account, attempt, attemptStartedAt, upstream.status, {
+                    errorType: "authentication_error",
+                    errorMessage,
+                    retryable: true,
+                });
                 authRetried = true;
                 const staleTokens = {
                     accessToken: account.token,
@@ -387,17 +511,11 @@ export async function handleCodexResponsesRequest(ctx) {
                     expiresAt: account.expiresAt ?? 0,
                 };
                 try {
-                    const refreshed = await refreshCodexToken(account.refreshToken);
+                    const refreshed = await refreshCodexTokenOnce(account.key, account.refreshToken);
                     account.token = refreshed.accessToken;
                     account.refreshToken = refreshed.refreshToken ?? account.refreshToken;
                     account.expiresAt = refreshed.expiresAt ?? account.expiresAt;
                     account.accountId = resolveCodexAccountId(refreshed.accessToken);
-                    await tokenStore.saveTokens(account.key, {
-                        accessToken: account.token,
-                        refreshToken: account.refreshToken,
-                        expiresAt: account.expiresAt ?? Date.now() + 3_600_000,
-                        tokenType: "Bearer",
-                    });
                     continue; // retry same account with the fresh token
                 }
                 catch (error) {
@@ -432,6 +550,16 @@ export async function handleCodexResponsesRequest(ctx) {
                 const retryAfterMs = parseRetryAfterMs(upstream.headers.get("retry-after"));
                 const plan = planCodexCooldown(quota, retryAfterMs, Date.now());
                 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");
+                recordAttemptError(account.label, CODEX_ACCOUNT_TYPE, upstream.status, rateLimitKind);
+                writeAttempt(account, attempt, attemptStartedAt, upstream.status, {
+                    errorType: "rate_limit_error",
+                    errorMessage,
+                    retryable: true,
+                    rateLimitKind,
+                    cooldownReason: plan.reason,
+                });
                 lastErrorStatus = 429;
                 lastErrorMessage = "Codex account rate-limited";
                 break; // rotate
@@ -443,12 +571,22 @@ export async function handleCodexResponsesRequest(ctx) {
                 // of letting it stay first in line with unknown quota.
                 await saveAccountCooldown(account.key, Date.now() + CODEX_AUTH_COOLDOWN_MS, "auth").catch(() => undefined);
             }
+            const errorMessage = summarizeCodexUpstreamError(errText, "Codex error");
+            const errorType = upstream.status === 401 || upstream.status === 403
+                ? "authentication_error"
+                : "api_error";
+            recordAttemptError(account.label, CODEX_ACCOUNT_TYPE, upstream.status);
+            writeAttempt(account, attempt, attemptStartedAt, upstream.status, {
+                errorType,
+                errorMessage,
+                retryable: upstream.status >= 500,
+            });
             lastErrorStatus = upstream.status >= 500 ? 502 : upstream.status;
-            lastErrorMessage = sanitizeForLog(errText).slice(0, 200) || "Codex error";
+            lastErrorMessage = errorMessage;
             break; // rotate
         }
     }
-    await writeLog("", lastErrorStatus, {
+    await recordFinalOutcome(lastAttemptedAccount, lastErrorStatus, {
         errorType: "all_accounts_failed",
         errorMessage: lastErrorMessage,
     });
@@ -529,18 +667,12 @@ async function handleCodexModelsRequest(ctx) {
                 if (!authRetried && account.refreshToken) {
                     authRetried = true;
                     try {
-                        const refreshed = await refreshCodexToken(account.refreshToken);
+                        const refreshed = await refreshCodexTokenOnce(account.key, account.refreshToken);
                         account.token = refreshed.accessToken;
                         account.refreshToken =
                             refreshed.refreshToken ?? account.refreshToken;
                         account.expiresAt = refreshed.expiresAt ?? account.expiresAt;
                         account.accountId = resolveCodexAccountId(refreshed.accessToken);
-                        await tokenStore.saveTokens(account.key, {
-                            accessToken: account.token,
-                            refreshToken: account.refreshToken,
-                            expiresAt: account.expiresAt ?? Date.now() + 3_600_000,
-                            tokenType: "Bearer",
-                        });
                         continue; // retry this account with the fresh token
                     }
                     catch {
@@ -605,5 +737,6 @@ export const __testHooks = {
     buildCodexUpstreamHeaders,
     planCodexCooldown,
     refreshCodexTokenOnce,
+    refreshCodexTokenOnceWithDependencies,
     codexRefreshInFlightSize: () => codexRefreshInFlight.size,
 };

package/dist/types/cli.d.ts

@@ -11,7 +11,7 @@ import type { PPTGenerationResult } from "./ppt.js";
 import type { AvatarResult } from "./avatar.js";
 import type { MusicResult } from "./music.js";
 import type { OAuthTokens } from "./auth.js";
-import type { AccountQuota } from "./proxy.js";
+import type { AccountQuota, ProxyPassthroughAccount } from "./proxy.js";
 import type { ClaudeSubscriptionTier } from "./subscription.js";
 import type { ServerFramework } from "./server.js";
 import type { AuthProviderType } from "./auth.js";
@@ -954,7 +954,7 @@ export type AuthCommandArgs = BaseCommandArgs & {
     label?: string;
     account?: string;
     force?: boolean;
-    /** `auth list --refresh`: fetch fresh limits from Anthropic before listing */
+    /** `auth list --refresh`: fetch fresh provider limits before listing */
     refresh?: boolean;
     /** Path to the proxy config YAML, used by set-/get-/clear-primary */
     config?: string;
@@ -969,12 +969,44 @@ export type AuthCommandArgs = BaseCommandArgs & {
     /** Yargs positional arguments */
     _?: (string | number)[];
 };
+/** Refresh state for a provider-qualified account. */
+export type AuthListRefreshStatus = "refreshed" | "snapshot" | "unavailable" | "not_supported";
+/** Fresh-limit result for one provider-qualified account. */
+export type AuthListRefreshAccountResult = {
+    /** Provider prefix parsed from the configured account key. */
+    provider: string;
+    /** A missing limit is explicit rather than being rendered as an unexplained dash. */
+    status: AuthListRefreshStatus;
+    error?: string;
+};
+/** One direct quota-adapter result used by `auth list --refresh`. */
+export type AuthListDirectQuotaRefreshResult = {
+    status: "refreshed";
+    quota: AccountQuota;
+} | {
+    status: "unavailable" | "not_supported";
+    error?: string;
+};
+/** Provider-specific quota capability used by the generic auth-list refresh. */
+export type AuthListQuotaRefreshAdapter = {
+    /** A successful local proxy `/limits` response is authoritative for this provider. */
+    supportsProxyRefresh?: boolean;
+    listAccounts: () => Promise<ProxyPassthroughAccount[]>;
+    priorQuotaKeys: (account: ProxyPassthroughAccount) => readonly string[];
+    refreshAccount: (account: ProxyPassthroughAccount, options: {
+        prior: AccountQuota | null;
+    }) => Promise<AuthListDirectQuotaRefreshResult>;
+};
+/** Applies one account's explicit auth-list refresh state. */
+export type AuthListRefreshResultSetter = (key: string, status: AuthListRefreshStatus, error?: string) => void;
 /** Outcome of the `auth list --refresh` fresh-limit fetch. */
 export type AuthListRefreshOutcome = {
     /** How the fresh limits were obtained ("none" when every path failed). */
-    via: "proxy" | "direct" | "none";
-    /** Freshly fetched quotas keyed by account label; null when none fetched. */
+    via: "proxy" | "direct" | "mixed" | "none";
+    /** Freshly fetched quotas keyed by provider-qualified account key. */
     quotas: Record<string, AccountQuota> | null;
+    /** Per-account refresh status, also keyed by provider-qualified account key. */
+    accounts: Record<string, AuthListRefreshAccountResult>;
     /** Per-account and transport errors, already formatted for display. */
     errors: string[];
 };
@@ -1220,7 +1252,7 @@ export type ProviderSetupConfig = {
     endpoint?: string;
     isReconfiguring?: boolean;
 };
-/** Providers supported by the `neurolink auth` command. */
+/** Providers with first-class credential flows implemented by `neurolink auth`. */
 export type SupportedProvider = "anthropic" | "codex";
 /** Arguments for `neurolink autoresearch init`. */
 export type AutoresearchInitArgs = {

package/dist/types/proxy.d.ts

@@ -21,6 +21,7 @@ import type { ProxyTracer } from "../proxy/proxyTracer.js";
 import type { ACCOUNT_COOLING_REASONS, PROXY_ACCOUNT_TYPES, PROXY_ACCOUNT_ROUTING_MODES, PROXY_ACCOUNT_ROUTING_REASONS, PROXY_ACCOUNT_ROUTING_STRATEGIES } from "../proxy/routingEvidence.js";
 import type { FallbackEntry, ModelMapping, ProxyRoutingConfig, CloakingConfig } from "./subscription.js";
 import type { RouteDeprecation } from "./server.js";
+import type { StoredOAuthTokens } from "./auth.js";
 /**
  * Type describing the ModelRouter contract.
  * Defined here to avoid a circular dependency between types and implementation.
@@ -557,6 +558,8 @@ export type RequestLogEntry = {
     stream: boolean;
     toolCount: number;
     account: string;
+    /** Provider-qualified account key for collision-free reconstruction. */
+    accountKey?: string;
     accountType: string;
     responseStatus: number;
     responseTimeMs: number;
@@ -576,6 +579,8 @@ export type RequestLogEntry = {
      * cross-provider model lookup rather than assuming Anthropic.
      */
     provider?: string;
+    /** Terminal state of the client-facing response when known. */
+    terminalOutcome?: "completed" | "bodyless" | "client_cancelled" | "stream_error" | "handler_error";
     /**
      * Which CLI made the request, derived from User-Agent, and the raw header it
      * was derived from.
@@ -605,6 +610,8 @@ export type RequestAttemptLogEntry = {
     stream: boolean;
     toolCount: number;
     account: string;
+    /** Provider-qualified account key for collision-free reconstruction. */
+    accountKey?: string;
     accountType: string;
     responseStatus: number;
     /** End-to-end request age when this attempt completed. */
@@ -627,11 +634,28 @@ export type RequestAttemptLogEntry = {
     outputTokens?: number;
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
+    /** Provider that received this upstream attempt. */
+    provider?: string;
     /** OTel trace ID for correlation with distributed traces */
     traceId?: string;
     /** OTel span ID for correlation with distributed traces */
     spanId?: string;
 };
+/** 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">>;
+/** Additional fields recorded for each upstream Codex account attempt. */
+export type CodexAttemptLogExtra = Partial<Pick<RequestAttemptLogEntry, "errorType" | "errorMessage" | "errorCode" | "transportScope" | "retryable" | "rateLimitKind" | "cooldownReason">>;
+/** Minimal persistence contract needed by Codex rotating-token refreshes. */
+export type CodexRefreshTokenStore = {
+    peekTokens(provider: string): Promise<StoredOAuthTokens | null>;
+    saveTokens(provider: string, tokens: StoredOAuthTokens): Promise<void>;
+};
+/** Result contract for a Codex OAuth refresh operation. */
+export type CodexTokenRefresher = (refreshToken: string) => Promise<{
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+}>;
 export type ProxyBodyCaptureInput = {
     phase: string;
     headers?: Record<string, string>;
@@ -880,6 +904,8 @@ export type ProxyTerminalErrorSummary = {
     category: ProxyTerminalErrorCategory;
     requestId?: string;
     account?: string;
+    /** Provider-qualified account identity when the failure was attributable. */
+    accountKey?: string;
     accountType?: string;
     errorType?: string;
     errorCode?: string;
@@ -889,12 +915,20 @@ export type ProxyTerminalErrorSummary = {
 /** Optional terminal context supplied when a final request error is recorded. */
 export type ProxyTerminalErrorDetails = {
     requestId?: string;
+    /** Exact provider-qualified account key when the caller has it. */
+    accountKey?: string;
     errorType?: string;
     errorCode?: string;
     terminalOutcome?: string;
     message?: string;
 };
 export type AccountStats = {
+    /**
+     * Provider-qualified account identity for rows written by current builds.
+     * Omitted only by legacy snapshots whose bare map keys are intentionally
+     * treated as unattributed rather than guessed at during status rendering.
+     */
+    key?: string;
     label: string;
     type: string;
     attemptCount: number;
@@ -2611,6 +2645,9 @@ export type StatusStats = {
     /** Whether this status response reconciled shared state or used local memory. */
     snapshotSource?: "reconciled" | "memory";
     accounts?: {
+        /** Provider-qualified key; null for explicitly unattributed legacy rows. */
+        key?: string | null;
+        provider?: "anthropic" | "codex" | "other" | "unknown";
         label: string;
         type: string;
         attempts?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.7.3",
+  "version": "12.7.5",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -407,7 +407,7 @@
     "zod-to-json-schema": "^3.25.1"
   },
   "peerDependencies": {
-    "@juspay/hippocampus": ">=0.1.4",
+    "@juspay/hippocampus": ">=0.1.8",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/sdk-trace-node": "^2.6.0",
     "react": ">=18.0.0",