@juspay/neurolink 9.54.4 → 9.54.6

package/dist/lib/providers/googleNativeGemini3.d.ts

@@ -9,8 +9,7 @@
  * providers so they can share a single implementation.
  */
 import { type Tool } from "ai";
-import type { ThinkingConfig, CollectedChunkResult, NativeFunctionCall, NativeFunctionDeclaration, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel } from "../types/index.js";
-export type { CollectedChunkResult, NativeFunctionCall, NativeFunctionDeclaration, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel, };
+import type { ThinkingConfig, CollectedChunkResult, NativeFunctionCall, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel } from "../types/index.js";
 /**
  * Sanitize a JSON Schema for Gemini's proto-based API.
  *

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

@@ -1,5 +1,4 @@
 import type { ProxyHealthResponse, ProxyReadinessState } from "../types/index.js";
-export type { ProxyHealthResponse, ProxyReadinessState };
 export declare function createProxyReadinessState(startTimeMs?: number): ProxyReadinessState;
 export declare function markProxyReady(state: ProxyReadinessState, readyAtMs?: number): void;
 export declare function buildProxyHealthResponse(state: ProxyReadinessState, options: {

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

@@ -1,5 +1,4 @@
-import type { ClaudeProxyModelTier, CooldownSkippedAccount, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan, RuntimeAccountState } from "../types/index.js";
-export type { ClaudeProxyModelTier, ProxyTranslationAttempt, ProxyTranslationPlan, };
+import type { ClaudeProxyModelTier, FallbackEntry, ParsedClaudeRequest, ProxyTranslationPlan } from "../types/index.js";
 export declare function inferClaudeProxyModelTier(modelName: string): ClaudeProxyModelTier;
 /**
  * Build a translation plan for a Claude-compatible proxy request.
@@ -12,32 +11,7 @@ export declare function buildProxyTranslationPlan(primary: {
     model?: string;
 }, fallbackChain: FallbackEntry[], requestedModel: string, _parsed: ParsedClaudeRequest): ProxyTranslationPlan;
 /**
- * Check whether an account is currently cooling down.
- * Returns the cooldown timestamp if active, null otherwise.
+ * Parse the retry-after header from an upstream 429 response.
+ * Returns milliseconds to wait, or 0 if no valid header present.
  */
-export declare function getAccountCooldownUntil(state: RuntimeAccountState, now?: number): number | null;
-/**
- * Partition accounts into eligible (no cooldown) and skipped (cooling down).
- */
-export declare function partitionAccountsByCooldown<T extends {
-    key: string;
-}>(accounts: T[], getState: (account: T) => RuntimeAccountState, now?: number): {
-    eligible: T[];
-    skipped: CooldownSkippedAccount<T>[];
-};
-/**
- * Apply a rate-limit cooldown to an account.
- * Uses simple exponential backoff with a floor and cap.
- */
-export declare function applyRateLimitCooldown(args: {
-    state: RuntimeAccountState;
-    retryAfterMs?: number;
-    now?: number;
-    capMs: number;
-}): {
-    backoffMs: number;
-};
-/**
- * Clear cooldown state for an account after a successful request.
- */
-export declare function clearAccountCooldown(state: RuntimeAccountState): void;
+export declare function parseRetryAfterMs(retryAfterHeader: string | null): number;

package/dist/lib/proxy/routingPolicy.js

@@ -1,4 +1,3 @@
-const DEFAULT_COOLDOWN_FLOOR_MS = 1_000;
 export function inferClaudeProxyModelTier(modelName) {
     const normalized = modelName.toLowerCase();
     if (normalized.includes("opus")) {
@@ -50,55 +49,24 @@ export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel
     };
 }
 // ---------------------------------------------------------------------------
-// Simple per-account cooldown
+// Retry-after parsing helper
 // ---------------------------------------------------------------------------
 /**
- * Check whether an account is currently cooling down.
- * Returns the cooldown timestamp if active, null otherwise.
+ * Parse the retry-after header from an upstream 429 response.
+ * Returns milliseconds to wait, or 0 if no valid header present.
  */
-export function getAccountCooldownUntil(state, now = Date.now()) {
-    if (state.coolingUntil && state.coolingUntil > now) {
-        return state.coolingUntil;
+export function parseRetryAfterMs(retryAfterHeader) {
+    if (!retryAfterHeader) {
+        return 0;
     }
-    return null;
-}
-/**
- * Partition accounts into eligible (no cooldown) and skipped (cooling down).
- */
-export function partitionAccountsByCooldown(accounts, getState, now = Date.now()) {
-    const eligible = [];
-    const skipped = [];
-    for (const account of accounts) {
-        const state = getState(account);
-        const until = getAccountCooldownUntil(state, now);
-        if (until !== null) {
-            skipped.push({
-                account,
-                cooldown: { until, backoffLevel: state.backoffLevel },
-            });
-            continue;
-        }
-        eligible.push(account);
+    const seconds = parseInt(retryAfterHeader, 10);
+    if (!Number.isNaN(seconds)) {
+        return Math.max(1, seconds) * 1000;
     }
-    return { eligible, skipped };
-}
-/**
- * Apply a rate-limit cooldown to an account.
- * Uses simple exponential backoff with a floor and cap.
- */
-export function applyRateLimitCooldown(args) {
-    const now = args.now ?? Date.now();
-    const baseCooldownMs = Math.max(args.retryAfterMs ?? 0, DEFAULT_COOLDOWN_FLOOR_MS);
-    const backoffMs = Math.min(baseCooldownMs * 2 ** args.state.backoffLevel, args.capMs);
-    args.state.coolingUntil = now + backoffMs;
-    args.state.backoffLevel += 1;
-    return { backoffMs };
-}
-/**
- * Clear cooldown state for an account after a successful request.
- */
-export function clearAccountCooldown(state) {
-    state.coolingUntil = undefined;
-    state.backoffLevel = 0;
+    const date = new Date(retryAfterHeader);
+    if (!Number.isNaN(date.getTime())) {
+        return Math.max(1000, date.getTime() - Date.now());
+    }
+    return 0;
 }
 //# sourceMappingURL=routingPolicy.js.map

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

@@ -8,7 +8,6 @@ export declare function recordAttempt(accountLabel: string, accountType: string)
 export declare function recordFinalSuccess(accountLabel?: string, accountType?: string): void;
 export declare function recordAttemptError(accountLabel: string, accountType: string, status: number): void;
 export declare function recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
-export declare function recordCooldown(accountLabel: string, accountType: string, cooldownUntil: number, backoffLevel: number): void;
 export declare function getStats(): ProxyStats;
 export declare function getAccountStats(label: string): AccountStats | undefined;
 export declare function resetStats(): void;

package/dist/lib/proxy/usageStats.js

@@ -24,7 +24,6 @@ export function recordFinalSuccess(accountLabel, accountType) {
     if (accountLabel && accountType) {
         const acct = ensureAccount(accountLabel, accountType);
         acct.successCount++;
-        acct.currentBackoffLevel = 0;
     }
 }
 export function recordAttemptError(accountLabel, accountType, status) {
@@ -45,11 +44,6 @@ export function recordFinalError(_status, accountLabel, accountType) {
         acct.lastErrorAt = Date.now();
     }
 }
-export function recordCooldown(accountLabel, accountType, cooldownUntil, backoffLevel) {
-    const acct = ensureAccount(accountLabel, accountType);
-    acct.coolingUntil = cooldownUntil;
-    acct.currentBackoffLevel = backoffLevel;
-}
 export function getStats() {
     const accounts = {};
     for (const [label, account] of Object.entries(stats.accounts)) {
@@ -80,7 +74,6 @@ function ensureAccount(label, type) {
             errorCount: 0,
             rateLimitCount: 0,
             lastAttemptAt: 0,
-            currentBackoffLevel: 0,
         };
     }
     return stats.accounts[label];

package/dist/lib/server/routes/claudeProxyRoutes.js

@@ -20,9 +20,9 @@ import { createRawStreamCapture } from "../../proxy/rawStreamCapture.js";
 import { logBodyCapture, logRequest, logRequestAttempt, logStreamError, } from "../../proxy/requestLogger.js";
 import { createSSEInterceptor } from "../../proxy/sseInterceptor.js";
 import { needsRefresh, persistTokens, refreshToken, } from "../../proxy/tokenRefresh.js";
-import { applyRateLimitCooldown, buildProxyTranslationPlan, clearAccountCooldown, getAccountCooldownUntil, partitionAccountsByCooldown, } from "../../proxy/routingPolicy.js";
+import { buildProxyTranslationPlan, parseRetryAfterMs, } from "../../proxy/routingPolicy.js";
 import { writeJsonSnapshotAtomically } from "../../proxy/snapshotPersistence.js";
-import { recordAttempt, recordAttemptError, recordCooldown, recordFinalError, recordFinalSuccess, } from "../../proxy/usageStats.js";
+import { recordAttempt, recordAttemptError, recordFinalError, recordFinalSuccess, } from "../../proxy/usageStats.js";
 import { logger } from "../../utils/logger.js";
 import { ProviderHealthChecker } from "../../utils/providerHealth.js";
 // ---------------------------------------------------------------------------
@@ -41,7 +41,7 @@ const BLOCKED_UPSTREAM_HEADERS = new Set([
 // Module-level state
 // ---------------------------------------------------------------------------
 /** Fill-first: index of the current primary account. Only advances when
- *  the current account hits a 429 or auth failure that puts it on cooldown. */
+ *  the current account exhausts 429 retries or auth retries fail. */
 let primaryAccountIndex = 0;
 /** Track account count so we can reset primaryAccountIndex when it changes. */
 let lastKnownAccountCount = 0;
@@ -49,9 +49,12 @@ const MAX_AUTH_RETRIES = 5;
 const MAX_CONSECUTIVE_REFRESH_FAILURES = 15;
 const MAX_TRANSIENT_SAME_ACCOUNT_RETRIES = 2;
 const TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS = [250, 1_000];
-/** Decision 8: Cooldowns only for 401 and 429. */
-const AUTH_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes for 401
-const RATE_LIMIT_BACKOFF_CAP_MS = 10 * 60 * 1000; // 10 minute cap for 429
+/** Maximum upstream 429 attempts per account before rotating to the next account.
+ *  Total attempts per account = this + 1 (the initial call plus this many retries). */
+const MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES = 5;
+/** Max time to sleep between 429 retries. Caps large upstream retry-after values
+ *  so we don't hold the client connection open for minutes. */
+const MAX_RATE_LIMIT_RETRY_DELAY_MS = 30_000;
 /** Timeout for upstream requests to Anthropic. Must be generous enough
  *  to cover the full lifecycle of streaming responses, including extended
  *  thinking from Opus models (which can exceed 5 minutes for large contexts). */
@@ -59,10 +62,10 @@ const UPSTREAM_FETCH_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
 const accountRuntimeState = new Map();
 /** Track whether we've run the one-time startup prune. */
 let startupPruneDone = false;
-/** Advance the primary account index when the current primary is put on cooldown.
- *  This is what makes fill-first work: we stick to one account until it's unusable.
- *  Only advances when the account being cooled IS the current primary; otherwise
- *  it's already a fallback and advancing would disrupt the fill-first ordering. */
+/** Advance the primary account index when the current primary is exhausted
+ *  (429 retries exhausted or auth failure). This is what makes fill-first work:
+ *  we stick to one account until it's unusable. Only advances when the exhausted
+ *  account IS the current primary; otherwise it's already a fallback. */
 function advancePrimaryIfCurrent(accountKey, enabledCount, primaryAccountKey) {
     if (enabledCount <= 1) {
         return;
@@ -1089,8 +1092,6 @@ async function loadClaudeProxyAccounts(args) {
                 await tokenStore.markEnabled(key);
                 logger.always(`[proxy] account=${key.split(":")[1] ?? key} re-enabled (credentials changed)`);
                 existingState.permanentlyDisabled = false;
-                existingState.coolingUntil = undefined;
-                existingState.backoffLevel = 0;
                 existingState.consecutiveRefreshFailures = 0;
             }
             else {
@@ -1187,8 +1188,6 @@ async function loadClaudeProxyAccounts(args) {
             if (state.permanentlyDisabled) {
                 logger.always(`[proxy] account=${account.label} credentials changed, re-enabling`);
             }
-            state.coolingUntil = undefined;
-            state.backoffLevel = 0;
             state.consecutiveRefreshFailures = 0;
             state.permanentlyDisabled = false;
         }
@@ -1513,16 +1512,10 @@ function buildClaudeAnthropicFailureResponse(args) {
         tracer?.end(502, Date.now() - requestStartTime);
         return buildLoggedClaudeError(502, msg);
     }
-    const earliestRecovery = orderedAccounts.reduce((min, account) => {
-        const until = getAccountCooldownUntil(getOrCreateRuntimeState(account.key));
-        return until !== null ? Math.min(min, until) : min;
-    }, Infinity);
-    // If no active cooldown remains (expired while retries ran), use 1s
-    // instead of fabricating a long retry-after.
-    const retryAfterSec = Number.isFinite(earliestRecovery)
-        ? Math.max(1, Math.ceil((earliestRecovery - Date.now()) / 1000))
-        : 1;
-    const errorMessage = `All accounts rate-limited. Earliest recovery in ${retryAfterSec}s.`;
+    // All accounts returned 429 after exhausting per-account retries.
+    // Return 1s retry-after — the proxy already waited for each upstream retry-after inline.
+    const retryAfterSec = 1;
+    const errorMessage = `All ${orderedAccounts.length} accounts rate-limited after ${MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES + 1} attempts each (1 initial + ${MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES} retries).`;
     logger.always(`[proxy] all accounts rate-limited, retry in ${retryAfterSec}s`);
     const errorBody = buildClaudeError(429, errorMessage, "overloaded_error");
     tracer?.setError("rate_limit_error", errorMessage);
@@ -1552,7 +1545,6 @@ function buildClaudeAnthropicFailureResponse(args) {
 }
 async function handleAnthropicSuccessfulResponse(args) {
     const { ctx, body, account, accountState, response, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
-    clearAccountCooldown(accountState);
     accountState.consecutiveRefreshFailures = 0;
     logger.always(`[proxy] ← ${response.status} account=${account.label}`);
     const quota = parseQuotaHeaders(response.headers);
@@ -1599,7 +1591,7 @@ async function handleAnthropicSuccessfulResponse(args) {
     });
 }
 async function handleAnthropicStreamingSuccessResponse(args) {
-    const { ctx, body, account, accountState, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
+    const { ctx, body, account, accountState: _accountState, response, responseHeaders, tracer, requestStartTime, fetchStartMs, attemptNumber, finalBodyStr, upstreamSpan, logProxyBody, logFinalRequest, } = args;
     if (!response.body) {
         upstreamSpan?.end();
         tracer?.setError("stream_error", "No response body from upstream");
@@ -1626,8 +1618,6 @@ async function handleAnthropicStreamingSuccessResponse(args) {
     const firstChunk = await reader.read();
     if (firstChunk.done || !firstChunk.value || firstChunk.value.length === 0) {
         reader.cancel();
-        accountState.coolingUntil = Date.now() + 10_000;
-        recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
         logger.always(`[proxy] ← empty stream from account=${account.label}, trying next`);
         tracer?.recordRetry(account.label, "empty_stream");
         upstreamSpan?.end();
@@ -2186,8 +2176,6 @@ async function handleAnthropicAuthRetry(args) {
             if (retryResp.ok) {
                 authRetrySucceeded = true;
                 accountState.consecutiveRefreshFailures = 0;
-                accountState.backoffLevel = 0;
-                accountState.coolingUntil = undefined;
                 logger.always(`[proxy] ← 200 account=${account.label} (after ${authRetry + 1} refresh(es))`);
                 const successResponse = await handleAnthropicSuccessfulRetryResponse({
                     ctx,
@@ -2222,18 +2210,7 @@ async function handleAnthropicAuthRetry(args) {
             recordAttemptError(account.label, account.type, retryStatus);
             if (retryStatus === 429) {
                 currentSawRateLimit = true;
-                const retryAfter = retryResp.headers.get("retry-after");
-                const parsedRetryAfter = parseInt(retryAfter ?? "", 10);
-                const cooldownMs = Number.isNaN(parsedRetryAfter)
-                    ? 60_000
-                    : Math.max(1, parsedRetryAfter) * 1000;
-                const cooldown = applyRateLimitCooldown({
-                    state: accountState,
-                    retryAfterMs: cooldownMs,
-                    capMs: RATE_LIMIT_BACKOFF_CAP_MS,
-                });
                 advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
-                recordCooldown(account.label, account.type, Date.now() + cooldown.backoffMs, accountState.backoffLevel);
                 break;
             }
             if (retryStatus === 401 || retryStatus === 402 || retryStatus === 403) {
@@ -2288,20 +2265,15 @@ async function handleAnthropicAuthRetry(args) {
         }
     }
     if (!authRetrySucceeded) {
-        if (!accountState.permanentlyDisabled) {
-            if (!accountState.coolingUntil ||
-                accountState.coolingUntil <= Date.now()) {
-                accountState.coolingUntil = Date.now() + AUTH_COOLDOWN_MS;
-            }
-            recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
-        }
+        // No persistent cooldown — just move to next account for this request.
         currentLastError = authRetryError;
-        logger.always(`[proxy] ⚠ account=${account.label} auth retries exhausted, cooldown=5min`);
+        logger.always(`[proxy] ⚠ account=${account.label} auth retries exhausted, rotating to next account`);
         logAttempt(401, "authentication_error", authRetryError);
         tracer?.setError("authentication_error", authRetryError);
         tracer?.recordRetry(account.label, "auth_exhausted");
         currentUpstreamSpan?.end();
         currentUpstreamSpan = undefined;
+        advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
     }
     return {
         continueLoop: true,
@@ -2354,7 +2326,7 @@ function buildAnthropicTerminalErrorResponse(args) {
     }
 }
 async function handleAnthropicNonOkResponse(args) {
-    const { response, account, accountState, tracer, requestStartTime, fetchStartMs, attemptNumber, logAttempt, logProxyBody, logFinalRequest, lastError, authFailureMessage, sawTransientFailure, invalidRequestFailure, maxConsecutiveRefreshFailures, } = args;
+    const { response, account, accountState, enabledAccounts, orderedAccounts, tracer, requestStartTime, fetchStartMs, attemptNumber, logAttempt, logProxyBody, logFinalRequest, lastError, authFailureMessage, sawTransientFailure, invalidRequestFailure, maxConsecutiveRefreshFailures, } = args;
     let currentLastError = lastError;
     let currentAuthFailureMessage = authFailureMessage;
     let currentSawTransientFailure = sawTransientFailure;
@@ -2404,17 +2376,16 @@ async function handleAnthropicNonOkResponse(args) {
         !account.refreshToken) {
         recordAttemptError(account.label, account.type, response.status);
         accountState.consecutiveRefreshFailures += 1;
-        accountState.coolingUntil = Date.now() + AUTH_COOLDOWN_MS;
-        recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
         if (accountState.consecutiveRefreshFailures >= maxConsecutiveRefreshFailures) {
             await disableAccountUntilReauth(account, accountState);
         }
         currentAuthFailureMessage = formatReauthMessage(account.label);
-        logger.always(`[proxy] ← ${response.status} account=${account.label} cooldown=5min`);
+        logger.always(`[proxy] ← ${response.status} account=${account.label} (auth failure, no refresh token)`);
         currentLastError = errBody;
         logAttempt(response.status, "authentication_error", summarizeErrorMessage(errBody));
         tracer?.setError("authentication_error", summarizeErrorMessage(errBody));
         tracer?.recordRetry(account.label, "auth_no_refresh");
+        advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
         return {
             continueLoop: true,
             lastError: currentLastError,
@@ -2431,13 +2402,12 @@ async function handleAnthropicNonOkResponse(args) {
         recordAttemptError(account.label, account.type, response.status);
         currentAuthFailureMessage =
             "Authentication failed for Anthropic API key credentials. Update ANTHROPIC_API_KEY or re-login with OAuth.";
-        accountState.coolingUntil = Date.now() + AUTH_COOLDOWN_MS;
-        recordCooldown(account.label, account.type, accountState.coolingUntil, accountState.backoffLevel);
-        logger.always(`[proxy] ← ${response.status} account=${account.label} cooldown=5min`);
+        logger.always(`[proxy] ← ${response.status} account=${account.label} (auth failure, api_key)`);
         currentLastError = errBody;
         logAttempt(response.status, "authentication_error", summarizeErrorMessage(errBody));
         tracer?.setError("authentication_error", summarizeErrorMessage(errBody));
         tracer?.recordRetry(account.label, "auth_api_key");
+        advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
         return {
             continueLoop: true,
             lastError: currentLastError,
@@ -2805,7 +2775,7 @@ async function prepareAnthropicAccountAttempt(args) {
     };
 }
 async function fetchAnthropicAccountResponse(args) {
-    const { url, headers, finalBodyStr, account, accountState, enabledAccounts, orderedAccounts, tracer, logAttempt, currentLastError, currentSawRateLimit, currentSawNetworkError, upstreamSpan, } = args;
+    const { url, headers, finalBodyStr, account, accountState: _accountState2, enabledAccounts: _enabledAccounts, orderedAccounts: _orderedAccounts, tracer, logAttempt, currentLastError, currentSawRateLimit, currentSawNetworkError, upstreamSpan, } = args;
     let lastError = currentLastError;
     let sawRateLimit = currentSawRateLimit;
     let sawNetworkError = currentSawNetworkError;
@@ -2844,36 +2814,18 @@ async function fetchAnthropicAccountResponse(args) {
     }
     if (response.status === 429) {
         sawRateLimit = true;
-        const retryAfter = response.headers.get("retry-after");
-        let cooldownMs = 0;
-        if (retryAfter) {
-            const seconds = parseInt(retryAfter, 10);
-            if (!Number.isNaN(seconds)) {
-                cooldownMs = seconds * 1000;
-            }
-            else {
-                const date = new Date(retryAfter);
-                if (!Number.isNaN(date.getTime())) {
-                    cooldownMs = Math.max(date.getTime() - Date.now(), 1000);
-                }
-            }
-        }
-        const cooldown = applyRateLimitCooldown({
-            state: accountState,
-            retryAfterMs: cooldownMs > 0 ? cooldownMs : undefined,
-            capMs: RATE_LIMIT_BACKOFF_CAP_MS,
-        });
-        advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
+        const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
         recordAttemptError(account.label, account.type, 429);
-        recordCooldown(account.label, account.type, Date.now() + cooldown.backoffMs, accountState.backoffLevel);
         lastError = await response.text();
-        logger.always(`[proxy] ← 429 account=${account.label} backoff-level=${accountState.backoffLevel} cooldown=${Math.round(cooldown.backoffMs / 1000)}s`);
+        logger.always(`[proxy] ← 429 account=${account.label} retry-after=${retryAfterMs}ms (upstream)`);
         logAttempt(429, "rate_limit_error", String(lastError));
         tracer?.setError("rate_limit_error", String(lastError).slice(0, 500));
         tracer?.recordRetry(account.label, "rate_limit");
         currentUpstreamSpan?.end();
         return {
             continueLoop: true,
+            retrySameAccount: true,
+            retryAfterMs,
             lastError,
             sawRateLimit,
             sawNetworkError,
@@ -2914,20 +2866,12 @@ async function handleAnthropicRoutedClaudeRequest(args) {
         attemptNumber: 0,
     };
     const acctSelectionSpan = tracer?.startAccountSelection();
-    const accountPartition = partitionAccountsByCooldown(orderedAccounts, (account) => getOrCreateRuntimeState(account.key));
-    for (const skippedAccount of accountPartition.skipped) {
-        logger.always(`[proxy] skipping account=${skippedAccount.account.label} cooldown remaining=${Math.max(1, Math.ceil((skippedAccount.cooldown.until - Date.now()) / 1000))}s`);
-    }
-    // Only flag rate-limit when ALL accounts are cooling — if some are eligible,
-    // let the actual attempt results determine sawRateLimit via real 429 responses.
-    if (accountPartition.skipped.length > 0 &&
-        accountPartition.eligible.length === 0) {
-        loopState.sawRateLimit = true;
-        loopState.lastError = `All ${accountPartition.skipped.length} accounts are cooling down`;
-    }
-    accountLoop: for (const account of accountPartition.eligible) {
+    // No partition / cooldown gating — every account is always eligible.
+    // Retries are handled inline per-account using upstream retry-after.
+    accountLoop: for (const account of orderedAccounts) {
         const accountState = getOrCreateRuntimeState(account.key);
         let transientSameAccountRetries = 0;
+        let rateLimitSameAccountRetries = 0;
         while (true) {
             loopState.attemptNumber += 1;
             if (tracer && loopState.attemptNumber === 1 && acctSelectionSpan) {
@@ -2991,6 +2935,24 @@ async function handleAnthropicRoutedClaudeRequest(args) {
             loopState.sawRateLimit = fetchResult.sawRateLimit;
             loopState.sawNetworkError = fetchResult.sawNetworkError;
             if (fetchResult.continueLoop || !fetchResult.response) {
+                // 429 with retry-after: wait and retry same account up to 5 times
+                if (fetchResult.retrySameAccount &&
+                    fetchResult.retryAfterMs !== undefined &&
+                    rateLimitSameAccountRetries < MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES) {
+                    rateLimitSameAccountRetries += 1;
+                    const delayMs = Math.min(fetchResult.retryAfterMs || 1_000, MAX_RATE_LIMIT_RETRY_DELAY_MS);
+                    logger.always(`[proxy] retrying same account=${account.label} after upstream 429 (${rateLimitSameAccountRetries}/${MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES}) in ${delayMs}ms`);
+                    await sleep(delayMs);
+                    continue;
+                }
+                // Rate-limit retries exhausted for this account — rotate
+                if (fetchResult.retrySameAccount &&
+                    fetchResult.retryAfterMs !== undefined) {
+                    advancePrimaryIfCurrent(account.key, enabledAccounts.length, orderedAccounts[0]?.key);
+                    logger.always(`[proxy] exhausted ${MAX_RATE_LIMIT_SAME_ACCOUNT_RETRIES} rate-limit retries for account=${account.label}; rotating`);
+                    continue accountLoop;
+                }
+                // Transient error retry (network errors, 529 overloaded)
                 if (fetchResult.retrySameAccount &&
                     transientSameAccountRetries < MAX_TRANSIENT_SAME_ACCOUNT_RETRIES) {
                     transientSameAccountRetries += 1;
@@ -3052,6 +3014,8 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                     response,
                     account,
                     accountState,
+                    enabledAccounts,
+                    orderedAccounts,
                     tracer,
                     requestStartTime,
                     fetchStartMs: preparedAttempt.fetchStartMs,
@@ -3366,8 +3330,6 @@ function getOrCreateRuntimeState(accountKey) {
         return existing;
     }
     const initial = {
-        coolingUntil: undefined,
-        backoffLevel: 0,
         consecutiveRefreshFailures: 0,
         permanentlyDisabled: false,
     };
@@ -3376,8 +3338,6 @@ function getOrCreateRuntimeState(accountKey) {
 }
 async function disableAccountUntilReauth(account, state) {
     state.permanentlyDisabled = true;
-    state.coolingUntil = undefined;
-    state.backoffLevel = 0;
     // Decision 7 (usage): Persist disabled state to disk so it survives restarts
     try {
         const { tokenStore } = await import("../../auth/tokenStore.js");

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

@@ -574,6 +574,8 @@ export type PreparedAnthropicAccountAttempt = {
 export type AnthropicUpstreamFetchResult = {
     continueLoop: boolean;
     retrySameAccount?: boolean;
+    /** When set, the caller should wait this many ms before retrying (from upstream retry-after). */
+    retryAfterMs?: number;
     response?: Response;
     lastError: unknown;
     sawRateLimit: boolean;
@@ -589,8 +591,6 @@ export type AccountStats = {
     rateLimitCount: number;
     lastAttemptAt: number;
     lastErrorAt?: number;
-    currentBackoffLevel: number;
-    coolingUntil?: number;
 };
 export type ProxyStats = {
     startedAt: number;
@@ -639,8 +639,6 @@ export type AccountQuota = {
 };
 /** Runtime state for a proxy account. */
 export type RuntimeAccountState = {
-    coolingUntil?: number;
-    backoffLevel: number;
     consecutiveRefreshFailures: number;
     permanentlyDisabled: boolean;
     lastToken?: string;
@@ -708,14 +706,6 @@ export type ProxyTranslationPlan = {
     attempts: ProxyTranslationAttempt[];
     skipped: never[];
 };
-/** An account skipped during partitioning, with its cooldown info. */
-export type CooldownSkippedAccount<T> = {
-    account: T;
-    cooldown: {
-        until: number;
-        backoffLevel: number;
-    };
-};
 /** Mutable readiness state tracked by the proxy process. */
 export type ProxyReadinessState = {
     startTimeMs: number;

package/dist/lib/utils/sanitizers/filename.d.ts

@@ -10,7 +10,6 @@
  * @see https://cheatsheetseries.owasp.org/cheatsheets/Input_Validation_Cheat_Sheet.html
  */
 import type { SanitizeFileNameOptions, SanitizeDisplayNameOptions } from "../../types/index.js";
-export type { SanitizeFileNameOptions, SanitizeDisplayNameOptions };
 /**
  * Sanitize a filename for safe filesystem storage.
  * Removes characters that are invalid on various operating systems.

package/dist/memory/hippocampusInitializer.d.ts

@@ -1,3 +1,2 @@
-import { Hippocampus, type HippocampusConfig, type StorageConfig } from "@juspay/hippocampus";
-export type { HippocampusConfig, StorageConfig };
+import { Hippocampus, type HippocampusConfig } from "@juspay/hippocampus";
 export declare function initializeHippocampus(config: HippocampusConfig): Hippocampus | null;

package/dist/memory/hippocampusInitializer.js

@@ -1,4 +1,4 @@
-import { Hippocampus, } from "@juspay/hippocampus";
+import { Hippocampus } from "@juspay/hippocampus";
 import { logger } from "../utils/logger.js";
 export function initializeHippocampus(config) {
     try {

package/dist/models/anthropicModels.d.ts

@@ -6,7 +6,6 @@
  */
 import type { ClaudeSubscriptionTier, AnthropicModelMetadata } from "../types/index.js";
 import { ModelAccessError } from "../types/index.js";
-export type { ClaudeSubscriptionTier, AnthropicModelMetadata };
 export { ModelAccessError };
 /**
  * Anthropic Claude model identifiers

package/dist/models/anthropicModels.js

@@ -5,6 +5,7 @@
  * model capabilities, and provides helper functions for tier-based access control.
  */
 import { ModelAccessError } from "../types/index.js";
+// Re-export runtime value for convenience
 export { ModelAccessError };
 // ============================================================================
 // ANTHROPIC MODEL ENUM

package/dist/neurolink.js

@@ -47,7 +47,7 @@ import { ToolRouter } from "./mcp/routing/index.js";
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
 import { inferAnnotations, isSafeToRetry } from "./mcp/toolAnnotations.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
-import { initializeHippocampus, } from "./memory/hippocampusInitializer.js";
+import { initializeHippocampus } from "./memory/hippocampusInitializer.js";
 import { createMemoryRetrievalTools } from "./memory/memoryRetrievalTools.js";
 import { getMetricsAggregator, MetricsAggregator, } from "./observability/metricsAggregator.js";
 import { SpanStatus, SpanType, CircuitBreakerOpenError, ConversationMemoryError, AuthenticationError, AuthorizationError, InvalidModelError, } from "./types/index.js";

package/dist/observability/exporterRegistry.d.ts

@@ -3,8 +3,7 @@
  * Manages multiple observability exporters with circuit breaker protection
  */
 import type { BaseExporter } from "./exporters/baseExporter.js";
-import type { Sampler } from "./sampling/samplers.js";
-import type { ExporterHealthStatus, ExportResult, SpanData } from "../types/index.js";
+import type { ExporterHealthStatus, ExportResult, Sampler, SpanData } from "../types/index.js";
 /**
  * Circuit breaker state for an exporter
  */

package/dist/observability/retryPolicy.d.ts

@@ -3,7 +3,6 @@
  * Configurable retry strategies for observability exporters
  */
 import type { RetryPolicy, RetryContext, RetryDecision } from "../types/index.js";
-export type { RetryPolicy };
 /**
  * Base retry policy with common configuration
  */

package/dist/observability/sampling/samplers.d.ts

@@ -3,7 +3,6 @@
  * Control which spans are exported for production optimization
  */
 import type { SamplerConfig, SamplingRule, SpanData, Sampler } from "../../types/index.js";
-export type { Sampler };
 /**
  * Always sample all spans
  */

package/dist/observability/spanProcessor.d.ts

@@ -4,7 +4,6 @@
  * Fills the 9% gap in pattern compliance
  */
 import type { SpanAttributes, SpanData, SpanProcessor } from "../types/index.js";
-export type { SpanProcessor };
 /**
  * No-op processor that passes spans through unchanged
  */