@juspay/neurolink 10.12.7 → 10.12.8

package/dist/cli/commands/proxyAnalyze.js

@@ -28,6 +28,9 @@ function printAnalysis(report) {
     }
     if (report.coverage.attempts) {
         logger.always(`    Attempts: ${report.attempts.total}, ${report.attempts.errors} errors${report.attempts.errors > 0 ? ` ${JSON.stringify(report.attempts.errorTypes)}` : ""}`);
+        if (Object.keys(report.attempts.transportScopes).length > 0) {
+            logger.always(`    Transport scopes: ${JSON.stringify(report.attempts.transportScopes)}`);
+        }
     }
     logger.always(report.coverage.lifecycle
         ? `    Lifecycle: ${report.lifecycle.accepted} accepted, ${report.lifecycle.terminal} terminal, ${report.lifecycle.unsettled} unsettled`
@@ -49,6 +52,10 @@ function printAnalysis(report) {
     if (report.coverage.routingDecisions) {
         logger.always(`    Decisions: ${report.routing.totalRecords} (${report.routing.records.length} retained), modes: ${JSON.stringify(report.routing.modes)}`);
         logger.always(`    Selection reasons: ${JSON.stringify(report.routing.selectionReasons)}`);
+        const productionQuotaProbes = report.routing.selectionReasons.quota_probe ?? 0;
+        if (productionQuotaProbes > 0) {
+            logger.always(chalk.yellow(`    WARNING: ${productionQuotaProbes} production request(s) were selected for quota discovery`));
+        }
         logger.always(`    Initial accounts: ${JSON.stringify(report.routing.initialAccounts)}`);
         logger.always(`    Final account changed after retry: ${report.routing.finalAccountChanges}, outside candidate set: ${report.routing.finalOutsideCandidateSet}`);
     }

package/dist/lib/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/lib/proxy/accountQuotaRefreshCoordinator.js

@@ -0,0 +1,105 @@
+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;
+    }
+}
+//# sourceMappingURL=accountQuotaRefreshCoordinator.js.map

package/dist/lib/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/lib/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/lib/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/lib/proxy/providerTransportCoordinator.js

@@ -0,0 +1,156 @@
+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);
+            });
+        });
+    }
+}
+//# sourceMappingURL=providerTransportCoordinator.js.map

package/dist/lib/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/lib/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/lib/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",

package/dist/lib/server/routes/claudeProxyRoutes.d.ts

@@ -12,7 +12,7 @@
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
-import type { AccountAllowlist, AccountAdmissionLease, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyLimitsRefreshResponse, ProxyQuotaCooldownUpdate, ProxyPassthroughAccount, QueuedAccountAdmission, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountAdmissionLease, AccountCooldownPlan, AccountQuota, AccountUsageFetchResult, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyLimitsRefreshResponse, ProxyQuotaCooldownUpdate, ProxyPassthroughAccount, QueuedAccountAdmission, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
 declare function tryAcquireAccountAdmission(accountKey: string, capacity: number | undefined): AccountAdmissionLease | undefined;
 declare function enqueueAccountAdmission(accountKey: string, capacity: number): QueuedAccountAdmission;
 declare function acquireAccountAdmission(accountKey: string, capacity: number, abortSignal?: AbortSignal, timeoutMs?: number): Promise<AccountAdmissionLease | undefined>;
@@ -75,6 +75,7 @@ declare function reconcileCooldownFromQuota(state: RuntimeAccountState, quota: A
  * headers can change admission state.
  */
 declare function seedRuntimeQuotasFromDisk(accounts: ProxyPassthroughAccount[]): Promise<void>;
+declare function applyAccountUsageResult(account: ProxyPassthroughAccount, fetchResult: AccountUsageFetchResult, observedAt: number, prior?: AccountQuota | null): Promise<AccountQuota | null>;
 /**
  * Fetch fresh limits from Anthropic's usage endpoint for every eligible OAuth
  * account and write them through the exact same chain the passive header
@@ -95,9 +96,8 @@ declare function refreshAccountLimits(options?: {
  * temporarily demoted until that session resets.
  *
  * Priority among usable accounts:
- *   1. no quota data yet — probe first: one request reveals its windows and
- *      self-corrects the ordering. (Ranking unknowns last would starve them
- *      forever: never picked → never observed → never comparable.)
+ *   1. known healthy quota before unknown or ambiguous stale evidence. Quota
+ *      discovery is handled by a lightweight usage GET, never a user request.
  *   2. session headroom before session-saturated (>= soft limit or
  *      "throttled") — do not re-hammer an urgent weekly account while its 5h
  *      capacity is temporarily unavailable.
@@ -113,6 +113,8 @@ declare function refreshAccountLimits(options?: {
  * last resort.
  */
 declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number): ProxyPassthroughAccount[];
+declare function scheduleAdaptiveQuotaRefreshes(accounts: ProxyPassthroughAccount[], orderedAccounts: ProxyPassthroughAccount[], sessionSoftLimit: number, routingMetrics?: ReadonlyMap<string, ProxyAccountSortMetrics>): void;
+declare function scheduleHandoffQuotaRefresh(current: ProxyPassthroughAccount, candidate: ProxyPassthroughAccount | undefined, handoffEpoch: number, sessionSoftLimit: number): void;
 declare function buildRoutingDecision(args: {
     accounts: ProxyPassthroughAccount[];
     orderedAccounts: ProxyPassthroughAccount[];
@@ -160,6 +162,8 @@ declare function buildClaudeAnthropicFailureResponse(args: {
     sawTransientFailure: boolean;
     sawRateLimit: boolean;
     lastError: unknown;
+    lastTransportErrorCode?: string;
+    lastTransportScope?: "shared_provider_transport" | "connection_transport";
     fallbackFailureMessage?: string;
     orderedAccounts: ProxyPassthroughAccount[];
     buildLoggedClaudeError: ClaudeLoggedErrorBuilder;
@@ -360,12 +364,16 @@ export declare const __testHooks: {
     planCooldownFor429: typeof planCooldownFor429;
     reconcileCooldownFromQuota: typeof reconcileCooldownFromQuota;
     refreshAccountLimits: typeof refreshAccountLimits;
+    applyAccountUsageResult: typeof applyAccountUsageResult;
     clearLimitsRefreshStateForTests: () => void;
     isRetryableNetworkError: typeof isRetryableNetworkError;
     isPermanentRefreshFailure: typeof isPermanentRefreshFailure;
     getStreamFailureDetails: typeof getStreamFailureDetails;
     trackUpstreamReadableStream: typeof trackUpstreamReadableStream;
     orderAccountsByQuota: typeof orderAccountsByQuota;
+    scheduleAdaptiveQuotaRefreshes: typeof scheduleAdaptiveQuotaRefreshes;
+    scheduleHandoffQuotaRefresh: typeof scheduleHandoffQuotaRefresh;
+    getQuotaRefreshState: (key: string) => import("../../types/proxy.js").ProxyQuotaRefreshRuntimeState;
     buildQuotaRoutingDecision: (accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number) => ProxyAccountRoutingDecision | undefined;
     buildRoutingDecision: typeof buildRoutingDecision;
     resetEpochToMs: typeof resetEpochToMs;