@juspay/neurolink 10.12.7 → 10.12.8

package/dist/lib/types/proxy.d.ts

@@ -430,6 +430,21 @@ export type ProxyAccountRoutingStrategy = (typeof PROXY_ACCOUNT_ROUTING_STRATEGI
 export type ProxyAccountRoutingMode = (typeof PROXY_ACCOUNT_ROUTING_MODES)[number];
 export type ProxyAccountRoutingReason = (typeof PROXY_ACCOUNT_ROUTING_REASONS)[number];
 export type ProxyAccountType = (typeof PROXY_ACCOUNT_TYPES)[number];
+export type ProxyQuotaFreshness = "unknown" | "fresh" | "stale_known" | "refresh_due";
+export type ProxyQuotaRefreshReason = "startup_unknown" | "handoff_prewarm" | "ambiguous_snapshot" | "manual";
+export type ProxyQuotaSaturationKind = "none" | "soft" | "hard";
+export type ProxyTransportScope = "shared_provider_transport" | "connection_transport" | "account_specific";
+export type ProxyNetworkTransportScope = Exclude<ProxyTransportScope, "account_specific">;
+export type ProxyProviderTransportProbeOutcome = "recovered" | "failed" | "abandoned";
+export type ProxyProviderTransportPermit = {
+    allowed: true;
+    probe: boolean;
+    generation: number;
+} | {
+    allowed: false;
+    errorCode: string | null;
+    transportScope: ProxyNetworkTransportScope;
+};
 export type ProxyAccountRoutingCandidate = {
     account: string;
     accountType: ProxyAccountType;
@@ -440,6 +455,15 @@ export type ProxyAccountRoutingCandidate = {
     saturated: boolean;
     quotaObserved: boolean;
     quotaStale: boolean;
+    quotaFreshness?: ProxyQuotaFreshness;
+    refreshNeeded?: boolean;
+    refreshReason?: ProxyQuotaRefreshReason | null;
+    refreshInFlight?: boolean;
+    lastRefreshAttemptAt?: number | null;
+    lastRefreshSuccessAt?: number | null;
+    nextRefreshEligibleAt?: number | null;
+    saturationKind?: ProxyQuotaSaturationKind;
+    softLimitOverrideReason?: "overage" | "weekly_expiry" | null;
     quotaLastUpdated: number | null;
     quotaAgeMs: number | null;
     coolingActive: boolean;
@@ -478,7 +502,17 @@ export type ProxyAccountSortMetrics = {
     usable: boolean;
     saturated: boolean;
     hasQuota: boolean;
+    quotaEvidenceRank: number;
     quotaStale: boolean;
+    quotaFreshness: ProxyQuotaFreshness;
+    refreshNeeded: boolean;
+    refreshReason: ProxyQuotaRefreshReason | null;
+    refreshInFlight: boolean;
+    lastRefreshAttemptAt: number | null;
+    lastRefreshSuccessAt: number | null;
+    nextRefreshEligibleAt: number | null;
+    saturationKind: ProxyQuotaSaturationKind;
+    softLimitOverrideReason: "overage" | "weekly_expiry" | null;
     quotaLastUpdated: number | null;
     quotaAgeMs: number | null;
     coolingActive: boolean;
@@ -514,6 +548,8 @@ export type RequestLogEntry = {
     errorMessage?: string;
     /** Low-level transport code such as ETIMEDOUT or EADDRNOTAVAIL. */
     errorCode?: string;
+    /** Whether changing credentials can affect this transport failure. */
+    transportScope?: ProxyTransportScope;
     inputTokens?: number;
     outputTokens?: number;
     cacheCreationTokens?: number;
@@ -545,6 +581,8 @@ export type RequestAttemptLogEntry = {
     errorMessage?: string;
     /** Low-level transport code such as ETIMEDOUT or EADDRNOTAVAIL. */
     errorCode?: string;
+    /** Whether changing credentials can affect this transport failure. */
+    transportScope?: ProxyTransportScope;
     /** Whether this failed attempt may be retried without changing the request. */
     retryable?: boolean;
     /** Distinguishes short-lived admission throttles from exhausted quota windows. */
@@ -579,11 +617,15 @@ export type ClaudeFinalRequestLogger = (status: number, accountLabel: string, ac
     outputTokens?: number;
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
+    errorCode?: string;
+    transportScope?: ProxyTransportScope;
 }) => void;
 export type ClaudeLoggedErrorBuilder = (status: number, message: string, errorType?: string, extra?: {
     account?: string;
     accountType?: string;
     attempt?: number;
+    errorCode?: string;
+    transportScope?: ProxyTransportScope;
 }) => ClaudeErrorResponse;
 export type ClaudeRequestRuntimeContext = {
     tracer?: ProxyTracer;
@@ -603,6 +645,7 @@ export type AnthropicAttemptLogger = (status: number, errorType?: string, errorM
     retryable?: boolean;
     /** Low-level transport code such as ETIMEDOUT or EADDRNOTAVAIL. */
     errorCode?: string;
+    transportScope?: ProxyTransportScope;
     rateLimitKind?: "transient" | "quota";
     cooldownReason?: "transient" | "session" | "weekly" | "unified";
     /** Override for nested retries whose attempt starts after this logger. */
@@ -624,6 +667,8 @@ export type AnthropicLoopState = {
     authCooldownMessage: string | null;
     fallbackFailureMessage?: string;
     attemptNumber: number;
+    lastTransportErrorCode?: string;
+    lastTransportScope?: ProxyNetworkTransportScope;
 };
 export type AnthropicUpstreamBody = {
     bodyStr: string;
@@ -765,6 +810,8 @@ export type TransientRateLimitRetryBudget = {
 export type AnthropicUpstreamFetchResult = {
     continueLoop: boolean;
     retrySameAccount?: boolean;
+    transportScope?: ProxyNetworkTransportScope;
+    errorCode?: string;
     /** When set, the caller should wait this many ms before retrying (from upstream retry-after). */
     retryAfterMs?: number;
     /** Set on a genuine 429: how long / why to cool this account before rotating. */
@@ -1033,6 +1080,35 @@ export type AccountUsageFetchResult = {
     error: string;
     status?: number;
 };
+export type ProxyQuotaRefreshRuntimeState = {
+    inFlight: boolean;
+    lastAttemptAt?: number;
+    lastSuccessAt?: number;
+    nextEligibleAt?: number;
+    consecutiveFailures: number;
+    lastFailureReason?: string;
+    lastCompletedTrigger?: string;
+    coalesced: number;
+};
+export type ProxyQuotaRefreshMetrics = {
+    attempted: number;
+    succeeded: number;
+    failed: number;
+    coalesced: number;
+    backoffSuppressed: number;
+    triggerDeduplicated: number;
+};
+export type ProxyQuotaRefreshRunResult = {
+    kind: "completed";
+    result: AccountUsageFetchResult;
+    /** Lower bound for the freshness of the returned usage snapshot. */
+    startedAt: number;
+} | {
+    kind: "backoff";
+    nextEligibleAt: number;
+} | {
+    kind: "not_due";
+};
 /** Per-account result inside a GET /limits response. */
 export type ProxyLimitsAccountResult = {
     /** Account label (quota-store key). */
@@ -1053,6 +1129,8 @@ export type ProxyLimitsRefreshResponse = {
     /** True when served from stored state without contacting Anthropic. */
     snapshot: boolean;
     results: ProxyLimitsAccountResult[];
+    /** Process-local refresh activity; contains no credentials or response body. */
+    refreshMetrics?: ProxyQuotaRefreshMetrics;
 };
 /**
  * Provenance of the quota numbers attached to a single proxy response.
@@ -1518,6 +1596,7 @@ export type ProxyAnalysisReport = {
         errors: number;
         errorTypes: Record<string, number>;
         errorCodes: Record<string, number>;
+        transportScopes: Record<string, number>;
     };
     rateLimits: {
         attemptRateLimits: number;

package/dist/proxy/accountQuotaRefreshCoordinator.d.ts

@@ -0,0 +1,19 @@
+import type { AccountUsageFetchResult, ProxyPassthroughAccount, ProxyQuotaRefreshRunResult, ProxyQuotaRefreshMetrics, ProxyQuotaRefreshRuntimeState } from "../types/index.js";
+export declare class AccountQuotaRefreshCoordinator {
+    private readonly inFlight;
+    private readonly states;
+    private metrics;
+    getState(accountKey: string): ProxyQuotaRefreshRuntimeState;
+    /**
+     * Run one refresh per account. `trigger` must identify the quota window or
+     * handoff condition so repeated requests deduplicate without hiding a later
+     * reset window.
+     */
+    run(account: ProxyPassthroughAccount, trigger: string, fetcher: (candidate: ProxyPassthroughAccount) => Promise<AccountUsageFetchResult>, options?: {
+        force?: boolean;
+        now?: number;
+    }): Promise<ProxyQuotaRefreshRunResult>;
+    clear(): void;
+    getMetrics(): ProxyQuotaRefreshMetrics;
+    private getOrCreateState;
+}

package/dist/proxy/accountQuotaRefreshCoordinator.js

@@ -0,0 +1,104 @@
+const FAILURE_BACKOFF_MS = [30_000, 2 * 60_000, 10 * 60_000];
+const MAX_FAILURE_BACKOFF_MS = 30 * 60_000;
+export class AccountQuotaRefreshCoordinator {
+    inFlight = new Map();
+    states = new Map();
+    metrics = {
+        attempted: 0,
+        succeeded: 0,
+        failed: 0,
+        coalesced: 0,
+        backoffSuppressed: 0,
+        triggerDeduplicated: 0,
+    };
+    getState(accountKey) {
+        const state = this.states.get(accountKey);
+        return state
+            ? { ...state, inFlight: this.inFlight.has(accountKey) }
+            : { inFlight: false, consecutiveFailures: 0, coalesced: 0 };
+    }
+    /**
+     * Run one refresh per account. `trigger` must identify the quota window or
+     * handoff condition so repeated requests deduplicate without hiding a later
+     * reset window.
+     */
+    run(account, trigger, fetcher, options = {}) {
+        const existing = this.inFlight.get(account.key);
+        if (existing) {
+            const state = this.getOrCreateState(account.key);
+            state.coalesced += 1;
+            this.metrics.coalesced += 1;
+            return existing;
+        }
+        const now = options.now ?? Date.now();
+        const state = this.getOrCreateState(account.key);
+        if (!options.force && state.lastCompletedTrigger === trigger) {
+            this.metrics.triggerDeduplicated += 1;
+            return Promise.resolve({ kind: "not_due" });
+        }
+        if (!options.force && now < (state.nextEligibleAt ?? 0)) {
+            this.metrics.backoffSuppressed += 1;
+            return Promise.resolve({
+                kind: "backoff",
+                nextEligibleAt: state.nextEligibleAt ?? now,
+            });
+        }
+        state.lastAttemptAt = now;
+        this.metrics.attempted += 1;
+        const task = fetcher(account)
+            .catch((error) => ({
+            ok: false,
+            reason: "network",
+            error: error instanceof Error ? error.message : String(error),
+        }))
+            .then((result) => {
+            const completedAt = options.now ?? Date.now();
+            if (result.ok === false) {
+                this.metrics.failed += 1;
+                state.consecutiveFailures += 1;
+                state.lastFailureReason = result.reason;
+                const backoffBase = FAILURE_BACKOFF_MS[Math.max(0, state.consecutiveFailures - 1)] ??
+                    MAX_FAILURE_BACKOFF_MS;
+                const jitter = 0.9 + Math.random() * 0.2;
+                state.nextEligibleAt = completedAt + Math.round(backoffBase * jitter);
+            }
+            else {
+                this.metrics.succeeded += 1;
+                state.lastSuccessAt = completedAt;
+                state.nextEligibleAt = undefined;
+                state.consecutiveFailures = 0;
+                state.lastFailureReason = undefined;
+                state.lastCompletedTrigger = trigger;
+            }
+            return { kind: "completed", result, startedAt: now };
+        })
+            .finally(() => {
+            this.inFlight.delete(account.key);
+        });
+        this.inFlight.set(account.key, task);
+        return task;
+    }
+    clear() {
+        this.inFlight.clear();
+        this.states.clear();
+        this.metrics = {
+            attempted: 0,
+            succeeded: 0,
+            failed: 0,
+            coalesced: 0,
+            backoffSuppressed: 0,
+            triggerDeduplicated: 0,
+        };
+    }
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    getOrCreateState(accountKey) {
+        let state = this.states.get(accountKey);
+        if (!state) {
+            state = { inFlight: false, consecutiveFailures: 0, coalesced: 0 };
+            this.states.set(accountKey, state);
+        }
+        return state;
+    }
+}

package/dist/proxy/accountUsage.d.ts

@@ -1,15 +1,15 @@
 /**
  * On-Demand Account Usage Fetch
  *
- * Manual refetch path for account limits: queries Anthropic's OAuth usage
- * endpoint (the same call Claude Code's /usage makes) to get FRESH session /
- * weekly / model-scoped windows for an account without consuming any tokens
- * and without starting a 5h session window.
+ * Lightweight account-limit refresh: queries Anthropic's OAuth usage endpoint
+ * (the same call Claude Code's /usage makes) to get fresh session / weekly /
+ * model-scoped windows without consuming tokens or starting a 5h session.
  *
  * This complements — never replaces — the passive header capture in
  * accountQuota.ts: `usageToQuota` normalizes the endpoint payload into the
  * same `AccountQuota` shape so refreshed data flows through the existing
- * save/merge/cooldown chain.
+ * save/merge/cooldown chain. Manual refresh and adaptive proxy prewarming use
+ * the same transport through the route-owned single-flight coordinator.
  *
  * Only OAuth (Bearer) accounts have subscription windows; api_key accounts
  * are skipped and keep their header-derived absolute limits.

package/dist/proxy/accountUsage.js

@@ -1,15 +1,15 @@
 /**
  * On-Demand Account Usage Fetch
  *
- * Manual refetch path for account limits: queries Anthropic's OAuth usage
- * endpoint (the same call Claude Code's /usage makes) to get FRESH session /
- * weekly / model-scoped windows for an account without consuming any tokens
- * and without starting a 5h session window.
+ * Lightweight account-limit refresh: queries Anthropic's OAuth usage endpoint
+ * (the same call Claude Code's /usage makes) to get fresh session / weekly /
+ * model-scoped windows without consuming tokens or starting a 5h session.
  *
  * This complements — never replaces — the passive header capture in
  * accountQuota.ts: `usageToQuota` normalizes the endpoint payload into the
  * same `AccountQuota` shape so refreshed data flows through the existing
- * save/merge/cooldown chain.
+ * save/merge/cooldown chain. Manual refresh and adaptive proxy prewarming use
+ * the same transport through the route-owned single-flight coordinator.
  *
  * Only OAuth (Bearer) accounts have subscription windows; api_key accounts
  * are skipped and keep their header-derived absolute limits.

package/dist/proxy/providerTransportCoordinator.d.ts

@@ -0,0 +1,17 @@
+import type { ProxyProviderTransportPermit } from "../types/index.js";
+export declare class ProviderTransportCoordinator {
+    private generation;
+    private degraded;
+    private backoffUntil;
+    private lastErrorCode;
+    private lastTransportScope;
+    private probe;
+    acquire(signal?: AbortSignal): Promise<ProxyProviderTransportPermit>;
+    reportSuccess(permit: ProxyProviderTransportPermit): void;
+    reportTransportFailure(errorCode: string | undefined, transportScope: "shared_provider_transport" | "connection_transport", permit: ProxyProviderTransportPermit): void;
+    reportProbeAbandoned(permit: ProxyProviderTransportPermit): void;
+    clear(): void;
+    private wait;
+    private waitForProbe;
+    private waitForProbeOrAbort;
+}

package/dist/proxy/providerTransportCoordinator.js

@@ -0,0 +1,155 @@
+import { TimeoutError, withTimeout } from "../utils/async/withTimeout.js";
+const SHARED_TRANSPORT_BACKOFF_MS = 250;
+const RECOVERY_PROBE_WAIT_TIMEOUT_MS = 30_000;
+export class ProviderTransportCoordinator {
+    generation = 0;
+    degraded = false;
+    backoffUntil = 0;
+    lastErrorCode = null;
+    lastTransportScope = "shared_provider_transport";
+    probe;
+    async acquire(signal) {
+        if (!this.degraded) {
+            return { allowed: true, probe: false, generation: this.generation };
+        }
+        const waitMs = Math.max(0, this.backoffUntil - Date.now());
+        if (waitMs > 0) {
+            await this.wait(waitMs, signal);
+        }
+        if (!this.degraded) {
+            return { allowed: true, probe: false, generation: this.generation };
+        }
+        if (this.probe) {
+            const outcome = await this.waitForProbe(this.probe.promise, signal);
+            if (outcome === "recovered") {
+                return { allowed: true, probe: false, generation: this.generation };
+            }
+            if (outcome === "abandoned") {
+                return this.acquire(signal);
+            }
+            return {
+                allowed: false,
+                errorCode: this.lastErrorCode,
+                transportScope: this.lastTransportScope,
+            };
+        }
+        let resolveProbe;
+        const promise = new Promise((resolve) => {
+            resolveProbe = resolve;
+        });
+        this.probe = {
+            generation: this.generation,
+            promise,
+            resolve: resolveProbe,
+        };
+        return { allowed: true, probe: true, generation: this.generation };
+    }
+    reportSuccess(permit) {
+        if (!permit.allowed || permit.generation !== this.generation) {
+            return;
+        }
+        if (permit.probe && this.probe?.generation !== permit.generation) {
+            return;
+        }
+        this.degraded = false;
+        this.backoffUntil = 0;
+        this.lastErrorCode = null;
+        this.lastTransportScope = "shared_provider_transport";
+        if (permit.probe && this.probe?.generation === permit.generation) {
+            this.probe.resolve("recovered");
+            this.probe = undefined;
+        }
+    }
+    reportTransportFailure(errorCode, transportScope, permit) {
+        if (!permit.allowed || permit.generation !== this.generation) {
+            return;
+        }
+        if (permit.probe && this.probe?.generation !== permit.generation) {
+            return;
+        }
+        this.degraded = true;
+        this.backoffUntil = Date.now() + SHARED_TRANSPORT_BACKOFF_MS;
+        this.lastErrorCode = errorCode ?? null;
+        this.lastTransportScope = transportScope;
+        if (permit.probe && this.probe?.generation === permit.generation) {
+            this.probe.resolve("failed");
+            this.probe = undefined;
+        }
+        this.generation += 1;
+    }
+    reportProbeAbandoned(permit) {
+        if (!permit.allowed ||
+            !permit.probe ||
+            permit.generation !== this.generation ||
+            this.probe?.generation !== permit.generation) {
+            return;
+        }
+        this.probe.resolve("abandoned");
+        this.probe = undefined;
+        this.generation += 1;
+    }
+    clear() {
+        this.probe?.resolve("failed");
+        this.probe = undefined;
+        this.generation += 1;
+        this.degraded = false;
+        this.backoffUntil = 0;
+        this.lastErrorCode = null;
+        this.lastTransportScope = "shared_provider_transport";
+    }
+    async wait(ms, signal) {
+        if (signal?.aborted) {
+            throw signal.reason;
+        }
+        await new Promise((resolve, reject) => {
+            const timeoutRef = {};
+            const onAbort = () => {
+                if (timeoutRef.current) {
+                    clearTimeout(timeoutRef.current);
+                }
+                reject(signal?.reason);
+            };
+            timeoutRef.current = setTimeout(() => {
+                signal?.removeEventListener("abort", onAbort);
+                resolve();
+            }, ms);
+            timeoutRef.current.unref?.();
+            signal?.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    async waitForProbe(probe, signal) {
+        const boundedProbe = withTimeout(probe, RECOVERY_PROBE_WAIT_TIMEOUT_MS, "Anthropic transport recovery probe timed out");
+        try {
+            return await this.waitForProbeOrAbort(boundedProbe, signal);
+        }
+        catch (error) {
+            if (error instanceof TimeoutError && this.probe?.promise === probe) {
+                this.probe.resolve("failed");
+                this.probe = undefined;
+                this.generation += 1;
+                this.backoffUntil = Date.now() + SHARED_TRANSPORT_BACKOFF_MS;
+                return "failed";
+            }
+            throw error;
+        }
+    }
+    waitForProbeOrAbort(probe, signal) {
+        if (!signal) {
+            return probe;
+        }
+        if (signal.aborted) {
+            throw signal.reason;
+        }
+        return new Promise((resolve, reject) => {
+            const onAbort = () => reject(signal.reason);
+            signal.addEventListener("abort", onAbort, { once: true });
+            probe.then((result) => {
+                signal.removeEventListener("abort", onAbort);
+                resolve(result);
+            }, (error) => {
+                signal.removeEventListener("abort", onAbort);
+                reject(error);
+            });
+        });
+    }
+}

package/dist/proxy/proxyAnalysis.js

@@ -20,6 +20,19 @@ const ROUTING_MODES = new Set(PROXY_ACCOUNT_ROUTING_MODES);
 const ROUTING_REASONS = new Set(PROXY_ACCOUNT_ROUTING_REASONS);
 const ROUTING_ACCOUNT_TYPES = new Set(PROXY_ACCOUNT_TYPES);
 const COOLING_REASONS = new Set(ACCOUNT_COOLING_REASONS);
+const QUOTA_FRESHNESS_VALUES = new Set([
+    "unknown",
+    "fresh",
+    "stale_known",
+    "refresh_due",
+]);
+const QUOTA_REFRESH_REASONS = new Set([
+    "startup_unknown",
+    "handoff_prewarm",
+    "ambiguous_snapshot",
+    "manual",
+]);
+const QUOTA_SATURATION_KINDS = new Set(["none", "soft", "hard"]);
 const MAX_RETAINED_ROUTING_RECORDS = 200;
 const MAX_ROUTING_RECORDS_BEFORE_COMPACTION = MAX_RETAINED_ROUTING_RECORDS * 2;
 function isContainedPath(root, candidate) {
@@ -107,6 +120,37 @@ function routingCandidateValue(value) {
         ("overageEligible" in candidate &&
             candidate.overageEligible !== undefined &&
             typeof candidate.overageEligible !== "boolean") ||
+        ("quotaFreshness" in candidate &&
+            candidate.quotaFreshness !== undefined &&
+            (typeof candidate.quotaFreshness !== "string" ||
+                !QUOTA_FRESHNESS_VALUES.has(candidate.quotaFreshness))) ||
+        ("refreshNeeded" in candidate &&
+            candidate.refreshNeeded !== undefined &&
+            typeof candidate.refreshNeeded !== "boolean") ||
+        ("refreshInFlight" in candidate &&
+            candidate.refreshInFlight !== undefined &&
+            typeof candidate.refreshInFlight !== "boolean") ||
+        ("refreshReason" in candidate &&
+            candidate.refreshReason !== undefined &&
+            candidate.refreshReason !== null &&
+            (typeof candidate.refreshReason !== "string" ||
+                !QUOTA_REFRESH_REASONS.has(candidate.refreshReason))) ||
+        [
+            "lastRefreshAttemptAt",
+            "lastRefreshSuccessAt",
+            "nextRefreshEligibleAt",
+        ].some((field) => field in candidate &&
+            candidate[field] !== undefined &&
+            !isNullableFiniteNumber(candidate[field])) ||
+        ("saturationKind" in candidate &&
+            candidate.saturationKind !== undefined &&
+            (typeof candidate.saturationKind !== "string" ||
+                !QUOTA_SATURATION_KINDS.has(candidate.saturationKind))) ||
+        ("softLimitOverrideReason" in candidate &&
+            candidate.softLimitOverrideReason !== undefined &&
+            candidate.softLimitOverrideReason !== null &&
+            candidate.softLimitOverrideReason !== "overage" &&
+            candidate.softLimitOverrideReason !== "weekly_expiry") ||
         !(candidate.coolingReason === null ||
             (typeof candidate.coolingReason === "string" &&
                 COOLING_REASONS.has(candidate.coolingReason)))) {
@@ -122,6 +166,15 @@ function routingCandidateValue(value) {
         saturated: candidate.saturated,
         quotaObserved: candidate.quotaObserved,
         quotaStale: candidate.quotaStale === true,
+        quotaFreshness: candidate.quotaFreshness,
+        refreshNeeded: candidate.refreshNeeded,
+        refreshReason: candidate.refreshReason,
+        refreshInFlight: candidate.refreshInFlight,
+        lastRefreshAttemptAt: candidate.lastRefreshAttemptAt,
+        lastRefreshSuccessAt: candidate.lastRefreshSuccessAt,
+        nextRefreshEligibleAt: candidate.nextRefreshEligibleAt,
+        saturationKind: candidate.saturationKind,
+        softLimitOverrideReason: candidate.softLimitOverrideReason,
         quotaLastUpdated: candidate.quotaLastUpdated,
         quotaAgeMs: candidate.quotaAgeMs,
         coolingActive: candidate.coolingActive,
@@ -554,6 +607,7 @@ export async function analyzeProxyLogs(options) {
     let totalAttemptErrors = 0;
     const attemptErrorTypes = {};
     const attemptErrorCodes = {};
+    const attemptTransportScopes = {};
     let attemptRateLimits = 0;
     let transientRateLimits = 0;
     let quotaRateLimits = 0;
@@ -585,6 +639,10 @@ export async function analyzeProxyLogs(options) {
                     increment(attemptErrorCodes, errorCode);
                 }
             }
+            const transportScope = stringValue(record.transportScope);
+            if (transportScope) {
+                increment(attemptTransportScopes, transportScope);
+            }
             const requestAttempts = attemptsByRequest.get(requestId) ?? {
                 count: 0,
                 hadError: false,
@@ -808,6 +866,7 @@ export async function analyzeProxyLogs(options) {
             errors: totalAttemptErrors,
             errorTypes: attemptErrorTypes,
             errorCodes: attemptErrorCodes,
+            transportScopes: attemptTransportScopes,
         },
         rateLimits: {
             attemptRateLimits,

package/dist/proxy/routingEvidence.d.ts

@@ -1,6 +1,6 @@
 /** Schema-v1 routing evidence values shared by emitters and offline readers. */
 export declare const PROXY_ACCOUNT_ROUTING_STRATEGIES: readonly ["round-robin", "fill-first"];
 export declare const PROXY_ACCOUNT_ROUTING_MODES: readonly ["quota", "primary", "round_robin", "single_account"];
-export declare const PROXY_ACCOUNT_ROUTING_REASONS: readonly ["single_account", "round_robin", "configured_primary", "insertion_order", "availability", "cooldown_recovery", "quota_probe", "session_headroom", "session_reset", "weekly_reset", "weekly_utilization"];
+export declare const PROXY_ACCOUNT_ROUTING_REASONS: readonly ["single_account", "round_robin", "configured_primary", "insertion_order", "availability", "cooldown_recovery", "quota_evidence", "quota_probe", "session_headroom", "session_reset", "weekly_reset", "weekly_utilization"];
 export declare const PROXY_ACCOUNT_TYPES: readonly ["oauth", "api_key"];
 export declare const ACCOUNT_COOLING_REASONS: readonly ["weekly", "session", "unified", "transient", "auth"];

package/dist/proxy/routingEvidence.js

@@ -16,6 +16,9 @@ export const PROXY_ACCOUNT_ROUTING_REASONS = [
     "insertion_order",
     "availability",
     "cooldown_recovery",
+    "quota_evidence",
+    // Retained for backwards-compatible analysis of pre-fix logs. New routing
+    // decisions must never select a production request for quota discovery.
     "quota_probe",
     "session_headroom",
     "session_reset",