@juspay/neurolink 12.23.0 → 12.23.1

package/dist/proxy/accountRanking.d.ts

@@ -0,0 +1,22 @@
+import type { ProxyAccountRoutingReason, ProxyAccountSortMetrics, ProxyPassthroughAccount } from "../types/index.js";
+/**
+ * The pre-existing "spend the soonest-expiring weekly allowance first" order.
+ * Moved verbatim from claudeProxyRoutes.ts — availability → quota-evidence
+ * quality → session saturation → model-scoped saturation → soonest weekly
+ * reset → soonest session-reset bucket → model-scoped utilization → highest
+ * weekly utilization → configured primary → insertion order.
+ */
+export declare function compareExpiryFirst(a: ProxyPassthroughAccount, b: ProxyPassthroughAccount, metricsByKey: ReadonlyMap<string, ProxyAccountSortMetrics>, primaryKey: string | undefined): [number, ProxyAccountRoutingReason];
+/**
+ * Orders accounts by the configured ranking and reports the reason that
+ * placed rank 0. PR1 ships only `expiry-first`; PR2 (Task 11) adds
+ * `headroom-first` plus the affinity/prefer-primary precedence layer.
+ */
+export declare function rankAccounts(args: {
+    accounts: ProxyPassthroughAccount[];
+    metricsByKey: ReadonlyMap<string, ProxyAccountSortMetrics>;
+    primaryKey: string | undefined;
+}): {
+    orderedAccounts: ProxyPassthroughAccount[];
+    reason: ProxyAccountRoutingReason;
+};

package/dist/proxy/accountRanking.js

@@ -0,0 +1,86 @@
+/**
+ * The pre-existing "spend the soonest-expiring weekly allowance first" order.
+ * Moved verbatim from claudeProxyRoutes.ts — availability → quota-evidence
+ * quality → session saturation → model-scoped saturation → soonest weekly
+ * reset → soonest session-reset bucket → model-scoped utilization → highest
+ * weekly utilization → configured primary → insertion order.
+ */
+export function compareExpiryFirst(a, b, metricsByKey, primaryKey) {
+    const ma = metricsByKey.get(a.key);
+    const mb = metricsByKey.get(b.key);
+    if (!ma || !mb) {
+        return [0, "insertion_order"];
+    }
+    if (ma.usable !== mb.usable) {
+        return [ma.usable ? -1 : 1, "availability"];
+    }
+    if (!ma.usable && !mb.usable) {
+        const au = ma.coolingUntil || Number.POSITIVE_INFINITY;
+        const bu = mb.coolingUntil || Number.POSITIVE_INFINITY;
+        return [
+            au === bu ? 0 : au - bu,
+            au === bu ? "insertion_order" : "cooldown_recovery",
+        ];
+    }
+    if (ma.quotaEvidenceRank !== mb.quotaEvidenceRank) {
+        return [ma.quotaEvidenceRank - mb.quotaEvidenceRank, "quota_evidence"];
+    }
+    if (ma.saturated !== mb.saturated) {
+        return [ma.saturated ? 1 : -1, "session_headroom"];
+    }
+    // Per-model headroom, after overall session capacity: an account whose cap
+    // for THIS model is nearly spent is demoted even when its 5h/7d are healthy.
+    // No-op when neither account reports a scoped window for the model.
+    if (ma.scopedSaturated !== mb.scopedSaturated) {
+        return [ma.scopedSaturated ? 1 : -1, "scoped_headroom"];
+    }
+    if (ma.saturated && mb.saturated) {
+        if (ma.sessionResetBucket !== mb.sessionResetBucket) {
+            return [ma.sessionResetBucket - mb.sessionResetBucket, "session_reset"];
+        }
+        if (ma.weeklyReset !== mb.weeklyReset) {
+            return [ma.weeklyReset - mb.weeklyReset, "weekly_reset"];
+        }
+    }
+    else {
+        if (ma.weeklyReset !== mb.weeklyReset) {
+            return [ma.weeklyReset - mb.weeklyReset, "weekly_reset"];
+        }
+        if (ma.sessionResetBucket !== mb.sessionResetBucket) {
+            return [ma.sessionResetBucket - mb.sessionResetBucket, "session_reset"];
+        }
+    }
+    // Fill-first within the per-model allowance: finish off the account closest
+    // to spending its cap for this model before opening a fresher one. Ranked
+    // above overall weekly utilization because it is the tighter constraint.
+    // Both sides must actually report a scoped window. Comparing a real
+    // utilization against the "absent" sentinel would rank the account that has a
+    // window above one that does not — and since only the account serving a model
+    // gets that model's window, it would funnel all of a model's traffic onto
+    // whichever account happened to serve it first.
+    if (ma.scopedUsed !== null &&
+        mb.scopedUsed !== null &&
+        ma.scopedUsedForSort !== mb.scopedUsedForSort) {
+        return [mb.scopedUsedForSort - ma.scopedUsedForSort, "scoped_utilization"];
+    }
+    if (ma.weeklyUsedForSort !== mb.weeklyUsedForSort) {
+        return [mb.weeklyUsedForSort - ma.weeklyUsedForSort, "weekly_utilization"];
+    }
+    if (primaryKey && (a.key === primaryKey) !== (b.key === primaryKey)) {
+        return [a.key === primaryKey ? -1 : 1, "configured_primary"];
+    }
+    return [0, "insertion_order"];
+}
+/**
+ * Orders accounts by the configured ranking and reports the reason that
+ * placed rank 0. PR1 ships only `expiry-first`; PR2 (Task 11) adds
+ * `headroom-first` plus the affinity/prefer-primary precedence layer.
+ */
+export function rankAccounts(args) {
+    const { accounts, metricsByKey, primaryKey } = args;
+    const orderedAccounts = [...accounts].sort((a, b) => compareExpiryFirst(a, b, metricsByKey, primaryKey)[0]);
+    const reason = orderedAccounts.length < 2
+        ? "single_account"
+        : compareExpiryFirst(orderedAccounts[0], orderedAccounts[1], metricsByKey, primaryKey)[1];
+    return { orderedAccounts, reason };
+}

package/dist/proxy/proxyConfig.js

@@ -213,6 +213,36 @@ const CODEX_REASONING_EFFORTS = [
 function isCodexReasoningEffort(value) {
     return CODEX_REASONING_EFFORTS.some((effort) => effort === value);
 }
+function kebabToCamelRoutingKey(kebabKey) {
+    return kebabKey.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+/**
+ * Read one of the eight routing keys that predate #1787's five newer keys,
+ * accepting either spelling and treating a `null` value under either
+ * spelling as "unset" so it falls back to the caller's default instead of
+ * failing validation.
+ *
+ * `??` already treats a `null` kebab value the same as an absent one and
+ * falls through to the camel spelling — that precedence must not change (a
+ * `null` kebab key must not mask a non-null camel value) — so the only gap
+ * is a combined value that still resolves to `null` (camel-only `null`, or
+ * both spellings `null`): that case is mapped to `undefined` here so every
+ * existing `!== undefined` guard and default keeps working unchanged.
+ *
+ * `wasNull` is true exactly when the resolved value became `undefined`
+ * *because* one of the spellings was explicitly `null` — never merely
+ * because both were absent — so callers can warn once per null key without
+ * warning on ordinary omission.
+ */
+function readLegacyRoutingKey(routing, kebabKey) {
+    const camelKey = kebabToCamelRoutingKey(kebabKey);
+    const rawKebab = routing[kebabKey];
+    const rawCamel = routing[camelKey];
+    const combined = rawKebab ?? rawCamel;
+    const value = combined === null ? undefined : combined;
+    const wasNull = value === undefined && (rawKebab === null || rawCamel === null);
+    return { value, wasNull };
+}
 /**
  * Validate the shape of a parsed proxy config.
  * Returns an array of human-readable error strings (empty = valid).
@@ -239,7 +269,7 @@ export function validateProxyConfig(config) {
     }
     if (hasRouting) {
         const routing = cfg.routing;
-        const rawFallback = routing["fallback-chain"] ?? routing.fallbackChain;
+        const rawFallback = readLegacyRoutingKey(routing, "fallback-chain").value;
         if (Array.isArray(rawFallback)) {
             rawFallback.forEach((entry, index) => {
                 if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
@@ -261,7 +291,7 @@ export function validateProxyConfig(config) {
                 }
             });
         }
-        const rawAccountAllowlist = routing["account-allowlist"] ?? routing.accountAllowlist;
+        const rawAccountAllowlist = readLegacyRoutingKey(routing, "account-allowlist").value;
         if (rawAccountAllowlist !== undefined) {
             if (!Array.isArray(rawAccountAllowlist)) {
                 errors.push("routing.account-allowlist must be an array of non-empty strings");
@@ -274,7 +304,7 @@ export function validateProxyConfig(config) {
                 });
             }
         }
-        const rawQuotaRouting = routing["quota-routing"] ?? routing.quotaRouting;
+        const rawQuotaRouting = readLegacyRoutingKey(routing, "quota-routing").value;
         const normalizedQuotaRouting = typeof rawQuotaRouting === "string"
             ? rawQuotaRouting.trim().toLowerCase()
             : undefined;
@@ -287,14 +317,14 @@ export function validateProxyConfig(config) {
         // Without this a typo (`use-overage: nevr`) loads cleanly and silently
         // falls back to "auto" — the operator asked to block paid extra usage and
         // gets provider-driven overage instead.
-        const rawUseOverage = routing["use-overage"] ?? routing.useOverage;
+        const rawUseOverage = readLegacyRoutingKey(routing, "use-overage").value;
         if (rawUseOverage !== undefined &&
             !["auto", "always", "never"].includes(typeof rawUseOverage === "string"
                 ? rawUseOverage.trim().toLowerCase()
                 : "")) {
             errors.push("routing.use-overage must be auto, always, or never");
         }
-        const rawAutoFallback = routing["auto-fallback"] ?? routing.autoFallback;
+        const rawAutoFallback = readLegacyRoutingKey(routing, "auto-fallback").value;
         const normalizedAutoFallback = typeof rawAutoFallback === "string"
             ? rawAutoFallback.trim().toLowerCase()
             : undefined;
@@ -304,7 +334,7 @@ export function validateProxyConfig(config) {
             normalizedAutoFallback !== "false") {
             errors.push("routing.auto-fallback must be a boolean");
         }
-        const rawMaxInflight = routing["max-inflight-per-account"] ?? routing.maxInflightPerAccount;
+        const rawMaxInflight = readLegacyRoutingKey(routing, "max-inflight-per-account").value;
         if (rawMaxInflight !== undefined &&
             (typeof rawMaxInflight !== "number" ||
                 !Number.isInteger(rawMaxInflight) ||
@@ -312,7 +342,7 @@ export function validateProxyConfig(config) {
                 rawMaxInflight > MAX_MAX_INFLIGHT_PER_ACCOUNT)) {
             errors.push("routing.max-inflight-per-account must be an integer between 1 and 20");
         }
-        const rawSessionSoftLimit = routing["session-soft-limit"] ?? routing.sessionSoftLimit;
+        const rawSessionSoftLimit = readLegacyRoutingKey(routing, "session-soft-limit").value;
         if (rawSessionSoftLimit !== undefined) {
             const sessionSoftLimit = Number(rawSessionSoftLimit);
             if (!Number.isFinite(sessionSoftLimit) ||
@@ -321,7 +351,7 @@ export function validateProxyConfig(config) {
                 errors.push("routing.session-soft-limit must be a number in (0, 1]");
             }
         }
-        const rawSessionResetToleranceMs = routing["session-reset-tolerance-ms"] ?? routing.sessionResetToleranceMs;
+        const rawSessionResetToleranceMs = readLegacyRoutingKey(routing, "session-reset-tolerance-ms").value;
         if (rawSessionResetToleranceMs !== undefined) {
             const sessionResetToleranceMs = Number(rawSessionResetToleranceMs);
             if (!Number.isInteger(sessionResetToleranceMs) ||
@@ -439,7 +469,11 @@ function parseRoutingConfig(raw) {
             .filter((m) => m !== null);
     }
     // Fallback chain (accept kebab-case or camelCase)
-    const rawFallback = (raw["fallback-chain"] ?? raw.fallbackChain);
+    const fallbackChainRead = readLegacyRoutingKey(raw, "fallback-chain");
+    if (fallbackChainRead.wasNull) {
+        logger.warn("[proxy-config] routing.fallback-chain is null; using the default");
+    }
+    const rawFallback = fallbackChainRead.value;
     if (Array.isArray(rawFallback)) {
         result.fallbackChain = rawFallback
             .filter((e) => e !== null && typeof e === "object")
@@ -469,7 +503,11 @@ function parseRoutingConfig(raw) {
     if (Array.isArray(rawPassthrough)) {
         result.passthroughModels = rawPassthrough.map(String);
     }
-    const rawQuotaRouting = raw["quota-routing"] ?? raw.quotaRouting;
+    const quotaRoutingRead = readLegacyRoutingKey(raw, "quota-routing");
+    if (quotaRoutingRead.wasNull) {
+        logger.warn("[proxy-config] routing.quota-routing is null; using the default");
+    }
+    const rawQuotaRouting = quotaRoutingRead.value;
     if (rawQuotaRouting !== undefined) {
         if (typeof rawQuotaRouting === "boolean") {
             result.quotaRouting = rawQuotaRouting;
@@ -482,7 +520,11 @@ function parseRoutingConfig(raw) {
             logger.warn(`[proxy-config] Ignoring routing.quotaRouting: expected boolean, got ${typeof rawQuotaRouting}`);
         }
     }
-    const rawUseOverage = raw["use-overage"] ?? raw.useOverage;
+    const useOverageRead = readLegacyRoutingKey(raw, "use-overage");
+    if (useOverageRead.wasNull) {
+        logger.warn("[proxy-config] routing.use-overage is null; using the default");
+    }
+    const rawUseOverage = useOverageRead.value;
     if (rawUseOverage !== undefined) {
         const normalized = typeof rawUseOverage === "string"
             ? rawUseOverage.trim().toLowerCase()
@@ -496,7 +538,11 @@ function parseRoutingConfig(raw) {
             logger.warn(`[proxy-config] Ignoring routing.useOverage: expected auto|always|never, got ${String(rawUseOverage)}`);
         }
     }
-    const rawAutoFallback = raw["auto-fallback"] ?? raw.autoFallback;
+    const autoFallbackRead = readLegacyRoutingKey(raw, "auto-fallback");
+    if (autoFallbackRead.wasNull) {
+        logger.warn("[proxy-config] routing.auto-fallback is null; using the default");
+    }
+    const rawAutoFallback = autoFallbackRead.value;
     if (rawAutoFallback !== undefined) {
         if (typeof rawAutoFallback === "boolean") {
             result.autoFallback = rawAutoFallback;
@@ -509,7 +555,11 @@ function parseRoutingConfig(raw) {
             logger.warn(`[proxy-config] Ignoring routing.autoFallback: expected boolean, got ${typeof rawAutoFallback}`);
         }
     }
-    const rawMaxInflight = raw["max-inflight-per-account"] ?? raw.maxInflightPerAccount;
+    const maxInflightRead = readLegacyRoutingKey(raw, "max-inflight-per-account");
+    if (maxInflightRead.wasNull) {
+        logger.warn("[proxy-config] routing.max-inflight-per-account is null; using the default");
+    }
+    const rawMaxInflight = maxInflightRead.value;
     if (rawMaxInflight !== undefined) {
         if (typeof rawMaxInflight === "number" &&
             Number.isInteger(rawMaxInflight) &&
@@ -521,7 +571,11 @@ function parseRoutingConfig(raw) {
             logger.warn(`[proxy-config] Ignoring routing.maxInflightPerAccount: expected integer between 1 and 20, got ${String(rawMaxInflight)}`);
         }
     }
-    const rawSessionSoftLimit = raw["session-soft-limit"] ?? raw.sessionSoftLimit;
+    const sessionSoftLimitRead = readLegacyRoutingKey(raw, "session-soft-limit");
+    if (sessionSoftLimitRead.wasNull) {
+        logger.warn("[proxy-config] routing.session-soft-limit is null; using the default");
+    }
+    const rawSessionSoftLimit = sessionSoftLimitRead.value;
     if (rawSessionSoftLimit !== undefined) {
         const sessionSoftLimit = Number(rawSessionSoftLimit);
         if (Number.isFinite(sessionSoftLimit) &&
@@ -533,7 +587,11 @@ function parseRoutingConfig(raw) {
             logger.warn(`[proxy-config] Ignoring routing.sessionSoftLimit: expected number in (0, 1], got ${String(rawSessionSoftLimit)}`);
         }
     }
-    const rawSessionResetToleranceMs = raw["session-reset-tolerance-ms"] ?? raw.sessionResetToleranceMs;
+    const sessionResetToleranceMsRead = readLegacyRoutingKey(raw, "session-reset-tolerance-ms");
+    if (sessionResetToleranceMsRead.wasNull) {
+        logger.warn("[proxy-config] routing.session-reset-tolerance-ms is null; using the default");
+    }
+    const rawSessionResetToleranceMs = sessionResetToleranceMsRead.value;
     if (rawSessionResetToleranceMs !== undefined) {
         const sessionResetToleranceMs = Number(rawSessionResetToleranceMs);
         if (Number.isInteger(sessionResetToleranceMs) &&
@@ -558,8 +616,11 @@ function parseRoutingConfig(raw) {
                 `string, got ${typeof rawPrimary}`);
         }
     }
-    const rawAccountAllowlist = (raw["account-allowlist"] ??
-        raw.accountAllowlist);
+    const accountAllowlistRead = readLegacyRoutingKey(raw, "account-allowlist");
+    if (accountAllowlistRead.wasNull) {
+        logger.warn("[proxy-config] routing.account-allowlist is null; using the default");
+    }
+    const rawAccountAllowlist = accountAllowlistRead.value;
     if (Array.isArray(rawAccountAllowlist)) {
         result.accountAllowlist = [
             ...new Set(rawAccountAllowlist.map((entry) => String(entry).trim())),

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

@@ -3,10 +3,12 @@ import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
 import type { ProxyAccountDirectoryOverride } from "../../types/index.js";
 import type { AccountAllowlist, AccountAdmissionLease, JsonObject, AccountCooldownPlan, AccountQuota, AccountQuotaWindow, AccountUsageFetchResult, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicEntitlementFailure, AnthropicInvalidRequestFailure, AnthropicLoopState, AnthropicScopedExhaustion, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamBody, AnthropicUpstreamBodyBuilder, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyLimitsRefreshResponse, ProxyQuotaCooldownUpdate, ProxyOveragePolicy, 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>;
-declare function acquireFirstAvailableAccountAdmission(accountKeys: string[], capacity: number, abortSignal?: AbortSignal, timeoutMs?: number): Promise<{
+declare function tryAcquireAccountAdmission(accountKey: string, capacity: number | undefined, generation?: number): AccountAdmissionLease | undefined;
+/** Current in-flight request count for one account, unlimited or capped. */
+declare function getAccountInflight(accountKey: string): number;
+declare function enqueueAccountAdmission(accountKey: string, capacity: number, generation?: number): QueuedAccountAdmission;
+declare function acquireAccountAdmission(accountKey: string, capacity: number, abortSignal?: AbortSignal, timeoutMs?: number, generation?: number): Promise<AccountAdmissionLease | undefined>;
+declare function acquireFirstAvailableAccountAdmission(accountKeys: string[], capacity: number, abortSignal?: AbortSignal, timeoutMs?: number, generation?: number): Promise<{
     accountKey: string;
     lease: AccountAdmissionLease;
 } | undefined>;
@@ -119,6 +121,10 @@ declare function evaluateScopedExhaustion(accounts: ProxyPassthroughAccount[], r
     eligible: ProxyPassthroughAccount[];
     exhaustion: AnthropicScopedExhaustion | null;
 };
+declare function orderAccountsByQuotaWithMetrics(accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit: number, sessionResetToleranceMs: number, requestedModel?: string): {
+    orderedAccounts: ProxyPassthroughAccount[];
+    metricsByKey: Map<string, ProxyAccountSortMetrics>;
+};
 /**
  * Order accounts to MAXIMIZE quota utilization (fill-first, smart order):
  * spend the overall weekly allowance that expires SOONEST first, so quota
@@ -496,6 +502,7 @@ export declare const __testHooks: {
     getStreamFailureDetails: typeof getStreamFailureDetails;
     trackUpstreamReadableStream: typeof trackUpstreamReadableStream;
     orderAccountsByQuota: typeof orderAccountsByQuota;
+    orderAccountsByQuotaWithMetrics: typeof orderAccountsByQuotaWithMetrics;
     scheduleAdaptiveQuotaRefreshes: typeof scheduleAdaptiveQuotaRefreshes;
     scheduleHandoffQuotaRefresh: typeof scheduleHandoffQuotaRefresh;
     getQuotaRefreshState: (key: string) => import("../../index.js").ProxyQuotaRefreshRuntimeState;
@@ -526,6 +533,7 @@ export declare const __testHooks: {
     acquireFirstAvailableAccountAdmission: typeof acquireFirstAvailableAccountAdmission;
     tryAcquireAccountAdmission: typeof tryAcquireAccountAdmission;
     enqueueAccountAdmission: typeof enqueueAccountAdmission;
+    getAccountInflight: typeof getAccountInflight;
     getAccountAdmissionSnapshot: (accountKey: string) => {
         active: number;
         waiting: number;

package/dist/server/routes/claudeProxyRoutes.js

@@ -24,6 +24,7 @@ import { fetchCodexAccountUsage, listCodexAccountsForUsage, resolveProxyStatusAc
 import { AccountQuotaRefreshCoordinator } from "../../proxy/accountQuotaRefreshCoordinator.js";
 import { ProviderTransportCoordinator } from "../../proxy/providerTransportCoordinator.js";
 import { MAX_COOLDOWN_MS_BY_REASON } from "../../proxy/routingEvidence.js";
+import { compareExpiryFirst, rankAccounts, } from "../../proxy/accountRanking.js";
 import { buildProxyLimitHeaders, summarizePoolHeadroom, } from "../../proxy/quotaHeaders.js";
 import { buildClaudeError, ClaudeStreamSerializer, parseClaudeRequest, serializeClaudeResponse, } from "../../proxy/claudeFormat.js";
 import { getProxyUpstreamFailure } from "../../proxy/proxyFailureDetails.js";
@@ -261,9 +262,6 @@ const transientCooldownAdmissionSchedules = new Map();
  * make room for another stream on the same account.
  */
 const accountAdmissionStates = new Map();
-const unlimitedAccountAdmissionLease = {
-    release: () => undefined,
-};
 function getAccountAdmissionState(accountKey) {
     let state = accountAdmissionStates.get(accountKey);
     if (!state) {
@@ -282,6 +280,32 @@ function drainAccountAdmissionWaiters(accountKey, state) {
         waiter.resolve(createAccountAdmissionLease(accountKey, state));
     }
 }
+/**
+ * Admits, in FIFO order and ignoring the capacity each one queued with, every
+ * waiter that queued under an older runtime-config generation than the
+ * uncapped request now acquiring. Each request reads the cap from the snapshot
+ * it arrived with, so only a NEWER uncapped snapshot shows that a reload
+ * removed the waiter's cap — and uncapped arrivals count toward `active`, so
+ * that waiter would otherwise never drain. An uncapped request from an older
+ * snapshot (one that predates a reload adding the cap) or from the same one
+ * leaves waiters queued: their cap is still current. With no generation there
+ * is no runtime config store, the cap cannot change, and nothing is admitted.
+ */
+function admitWaitersOfRemovedCap(accountKey, state, generation) {
+    if (generation === undefined) {
+        return;
+    }
+    const queuedUnderOlderSnapshot = (waiter) => waiter.generation !== undefined && waiter.generation < generation;
+    const admitted = state.waiters.filter(queuedUnderOlderSnapshot);
+    if (admitted.length === 0) {
+        return;
+    }
+    state.waiters = state.waiters.filter((waiter) => !queuedUnderOlderSnapshot(waiter));
+    for (const waiter of admitted) {
+        state.active += 1;
+        waiter.resolve(createAccountAdmissionLease(accountKey, state));
+    }
+}
 function createAccountAdmissionLease(accountKey, state) {
     let released = false;
     return {
@@ -301,18 +325,24 @@ function discardAccountAdmissionState(accountKey, state) {
         accountAdmissionStates.delete(accountKey);
     }
 }
-function tryAcquireAccountAdmission(accountKey, capacity) {
+function tryAcquireAccountAdmission(accountKey, capacity, generation) {
     const normalizedCapacity = normalizeMaxInflightPerAccount(capacity);
+    const state = getAccountAdmissionState(accountKey);
     if (normalizedCapacity === undefined) {
-        return unlimitedAccountAdmissionLease;
+        admitWaitersOfRemovedCap(accountKey, state, generation);
+        state.active += 1;
+        return createAccountAdmissionLease(accountKey, state);
     }
-    const state = getAccountAdmissionState(accountKey);
     if (state.waiters.length > 0 || state.active >= normalizedCapacity) {
         return undefined;
     }
     state.active += 1;
     return createAccountAdmissionLease(accountKey, state);
 }
+/** Current in-flight request count for one account, unlimited or capped. */
+function getAccountInflight(accountKey) {
+    return accountAdmissionStates.get(accountKey)?.active ?? 0;
+}
 function isAccountAdmissionAvailable(accountKey, capacity) {
     const normalizedCapacity = normalizeMaxInflightPerAccount(capacity);
     if (normalizedCapacity === undefined) {
@@ -321,7 +351,7 @@ function isAccountAdmissionAvailable(accountKey, capacity) {
     const state = accountAdmissionStates.get(accountKey);
     return (!state || (state.waiters.length === 0 && state.active < normalizedCapacity));
 }
-function enqueueAccountAdmission(accountKey, capacity) {
+function enqueueAccountAdmission(accountKey, capacity, generation) {
     // Validate BEFORE getAccountAdmissionState(), which inserts into the map as a
     // side effect. Throwing after it would strand an empty entry for an account
     // that never got admitted — and the throw path never calls
@@ -339,6 +369,7 @@ function enqueueAccountAdmission(accountKey, capacity) {
     });
     const waiter = {
         capacity: normalizedCapacity,
+        generation,
         resolve: (lease) => {
             queued = false;
             grantedLease = lease;
@@ -370,8 +401,8 @@ function enqueueAccountAdmission(accountKey, capacity) {
         },
     };
 }
-async function acquireAccountAdmission(accountKey, capacity, abortSignal, timeoutMs = MAX_TRANSIENT_QUEUE_WAIT_MS) {
-    const queued = enqueueAccountAdmission(accountKey, capacity);
+async function acquireAccountAdmission(accountKey, capacity, abortSignal, timeoutMs = MAX_TRANSIENT_QUEUE_WAIT_MS, generation) {
+    const queued = enqueueAccountAdmission(accountKey, capacity, generation);
     try {
         return await withTimeout(raceWithAbort(queued.promise, abortSignal), timeoutMs, `Account admission for ${accountKey} timed out after ${timeoutMs}ms`);
     }
@@ -383,8 +414,8 @@ async function acquireAccountAdmission(accountKey, capacity, abortSignal, timeou
         return undefined;
     }
 }
-async function acquireFirstAvailableAccountAdmission(accountKeys, capacity, abortSignal, timeoutMs = MAX_TRANSIENT_QUEUE_WAIT_MS) {
-    const queuedAdmissions = [...new Set(accountKeys)].map((accountKey) => enqueueAccountAdmission(accountKey, capacity));
+async function acquireFirstAvailableAccountAdmission(accountKeys, capacity, abortSignal, timeoutMs = MAX_TRANSIENT_QUEUE_WAIT_MS, generation) {
+    const queuedAdmissions = [...new Set(accountKeys)].map((accountKey) => enqueueAccountAdmission(accountKey, capacity, generation));
     let winnerKey;
     try {
         return await withTimeout(raceWithAbort(Promise.race(queuedAdmissions.map((queued) => queued.promise.then((lease) => {
@@ -1475,81 +1506,17 @@ function accountSortMetrics(accountKey, now, sessionSoftLimit, sessionResetToler
         weeklyUsedForSort: weeklyUsed ?? -1,
     };
 }
-function compareAccountRoutingFactors(a, b, metricsByKey, primaryKey) {
-    const ma = metricsByKey.get(a.key);
-    const mb = metricsByKey.get(b.key);
-    if (!ma || !mb) {
-        return [0, "insertion_order"];
-    }
-    if (ma.usable !== mb.usable) {
-        return [ma.usable ? -1 : 1, "availability"];
-    }
-    if (!ma.usable && !mb.usable) {
-        const au = ma.coolingUntil || Number.POSITIVE_INFINITY;
-        const bu = mb.coolingUntil || Number.POSITIVE_INFINITY;
-        return [
-            au === bu ? 0 : au - bu,
-            au === bu ? "insertion_order" : "cooldown_recovery",
-        ];
-    }
-    if (ma.quotaEvidenceRank !== mb.quotaEvidenceRank) {
-        return [ma.quotaEvidenceRank - mb.quotaEvidenceRank, "quota_evidence"];
-    }
-    if (ma.saturated !== mb.saturated) {
-        return [ma.saturated ? 1 : -1, "session_headroom"];
-    }
-    // Per-model headroom, after overall session capacity: an account whose cap
-    // for THIS model is nearly spent is demoted even when its 5h/7d are healthy.
-    // No-op when neither account reports a scoped window for the model.
-    if (ma.scopedSaturated !== mb.scopedSaturated) {
-        return [ma.scopedSaturated ? 1 : -1, "scoped_headroom"];
-    }
-    if (ma.saturated && mb.saturated) {
-        if (ma.sessionResetBucket !== mb.sessionResetBucket) {
-            return [ma.sessionResetBucket - mb.sessionResetBucket, "session_reset"];
-        }
-        if (ma.weeklyReset !== mb.weeklyReset) {
-            return [ma.weeklyReset - mb.weeklyReset, "weekly_reset"];
-        }
-    }
-    else {
-        if (ma.weeklyReset !== mb.weeklyReset) {
-            return [ma.weeklyReset - mb.weeklyReset, "weekly_reset"];
-        }
-        if (ma.sessionResetBucket !== mb.sessionResetBucket) {
-            return [ma.sessionResetBucket - mb.sessionResetBucket, "session_reset"];
-        }
-    }
-    // Fill-first within the per-model allowance: finish off the account closest
-    // to spending its cap for this model before opening a fresher one. Ranked
-    // above overall weekly utilization because it is the tighter constraint.
-    // Both sides must actually report a scoped window. Comparing a real
-    // utilization against the "absent" sentinel would rank the account that has a
-    // window above one that does not — and since only the account serving a model
-    // gets that model's window, it would funnel all of a model's traffic onto
-    // whichever account happened to serve it first.
-    if (ma.scopedUsed !== null &&
-        mb.scopedUsed !== null &&
-        ma.scopedUsedForSort !== mb.scopedUsedForSort) {
-        return [mb.scopedUsedForSort - ma.scopedUsedForSort, "scoped_utilization"];
-    }
-    if (ma.weeklyUsedForSort !== mb.weeklyUsedForSort) {
-        return [mb.weeklyUsedForSort - ma.weeklyUsedForSort, "weekly_utilization"];
-    }
-    if (primaryKey && (a.key === primaryKey) !== (b.key === primaryKey)) {
-        return [a.key === primaryKey ? -1 : 1, "configured_primary"];
-    }
-    return [0, "insertion_order"];
-}
 function orderAccountsByQuotaWithMetrics(accounts, now, primaryKey, sessionSoftLimit, sessionResetToleranceMs, requestedModel) {
     const metricsByKey = new Map(accounts.map((account) => [
         account.key,
         accountSortMetrics(account.key, now, sessionSoftLimit, sessionResetToleranceMs, requestedModel),
     ]));
-    return {
-        orderedAccounts: [...accounts].sort((a, b) => compareAccountRoutingFactors(a, b, metricsByKey, primaryKey)[0]),
+    const { orderedAccounts } = rankAccounts({
+        accounts,
         metricsByKey,
-    };
+        primaryKey,
+    });
+    return { orderedAccounts, metricsByKey };
 }
 /**
  * Order accounts to MAXIMIZE quota utilization (fill-first, smart order):
@@ -1706,7 +1673,7 @@ function buildRoutingDecision(args) {
     }
     else if (quotaOrdered) {
         mode = "quota";
-        selectionReason = compareAccountRoutingFactors(orderedAccounts[0], orderedAccounts[1], metricsByKey, primaryKey)[1];
+        selectionReason = compareExpiryFirst(orderedAccounts[0], orderedAccounts[1], metricsByKey, primaryKey)[1];
     }
     else if (strategy === "round-robin") {
         mode = "round_robin";
@@ -6783,7 +6750,7 @@ function buildDeferredClaudeAccountFailureResponse(args) {
     return buildLoggedClaudeError(failure.status, failure.message, failure.errorType);
 }
 async function handleAnthropicRoutedClaudeRequest(args) {
-    const { ctx, body, modelRouter, tracer, requestStartTime, accountStrategy, primaryAccountKey, accountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), buildLoggedClaudeError, logProxyBody, logFinalRequest, setRoutingDecision, } = args;
+    const { ctx, body, modelRouter, configGeneration, tracer, requestStartTime, accountStrategy, primaryAccountKey, accountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), buildLoggedClaudeError, logProxyBody, logFinalRequest, setRoutingDecision, } = args;
     const parsedRequest = parseClaudeRequest(body);
     const configuredFallbackPlan = buildProxyTranslationPlan({ provider: "anthropic", model: body.model }, modelRouter?.getFallbackChain() ?? [], body.model, parsedRequest);
     const hasConfiguredFallback = configuredFallbackPlan.attempts
@@ -6931,7 +6898,7 @@ async function handleAnthropicRoutedClaudeRequest(args) {
         if (accountAdmissionCapacity !== undefined &&
             effectiveAccounts.length > 0 &&
             effectiveAccounts.every((account) => !isAccountAdmissionAvailable(account.key, accountAdmissionCapacity))) {
-            queuedAccountAdmission = await acquireFirstAvailableAccountAdmission(effectiveAccounts.map((account) => account.key), accountAdmissionCapacity, ctx.abortSignal);
+            queuedAccountAdmission = await acquireFirstAvailableAccountAdmission(effectiveAccounts.map((account) => account.key), accountAdmissionCapacity, ctx.abortSignal, MAX_TRANSIENT_QUEUE_WAIT_MS, configGeneration);
         }
         accountLoop: for (const [accountIndex, account,] of effectiveAccounts.entries()) {
             const hasNextAccount = accountIndex < effectiveAccounts.length - 1;
@@ -7016,7 +6983,7 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                     queuedAccountAdmission = undefined;
                 }
                 else {
-                    admissionLease = tryAcquireAccountAdmission(account.key, accountAdmissionCapacity);
+                    admissionLease = tryAcquireAccountAdmission(account.key, accountAdmissionCapacity, configGeneration);
                     if (admissionLease && queuedAccountAdmission) {
                         // A preferred account became available while the race was being
                         // established; release the lower-priority reservation.
@@ -7636,6 +7603,7 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
                                 ctx,
                                 body,
                                 modelRouter: requestModelRouter,
+                                configGeneration: requestRouting.generation,
                                 tracer,
                                 requestStartTime,
                                 accountStrategy: requestRouting.strategy,
@@ -8850,6 +8818,7 @@ export const __testHooks = {
     getStreamFailureDetails,
     trackUpstreamReadableStream,
     orderAccountsByQuota,
+    orderAccountsByQuotaWithMetrics,
     scheduleAdaptiveQuotaRefreshes,
     scheduleHandoffQuotaRefresh,
     getQuotaRefreshState: (key) => accountQuotaRefreshCoordinator.getState(key),
@@ -8910,6 +8879,7 @@ export const __testHooks = {
     acquireFirstAvailableAccountAdmission,
     tryAcquireAccountAdmission,
     enqueueAccountAdmission,
+    getAccountInflight,
     getAccountAdmissionSnapshot: (accountKey) => {
         const state = accountAdmissionStates.get(accountKey);
         return state

package/dist/types/proxy.d.ts

@@ -1100,6 +1100,9 @@ export type QueuedAccountAdmission = {
 /** One queued request waiting for per-account admission capacity. */
 export type AccountAdmissionWaiter = {
     capacity: number;
+    /** Runtime-config generation of the snapshot the request queued under;
+     *  absent when no runtime config store publishes one. */
+    generation?: number;
     resolve: (lease: AccountAdmissionLease) => void;
 };
 /** In-process request admission state for an OAuth account. */