@juspay/neurolink 9.54.3 → 9.54.5

package/dist/server/middleware/validation.d.ts

@@ -2,12 +2,12 @@
  * Request Validation Middleware
  * Provides schema-based request validation for server adapters
  */
-import type { MiddlewareDefinition, ServerContext } from "../types.js";
+import type { MiddlewareDefinition, ServerContext } from "../../types/index.js";
 import { ValidationError as ServerValidationError } from "../errors.js";
 /**
  * Validation configuration
  */
-export type ValidationConfig = {
+type ValidationConfig = {
     /** Schema for validating request body */
     bodySchema?: ValidationSchema;
     /** Schema for validating query parameters */
@@ -30,7 +30,7 @@ export type ValidationConfig = {
  * Simple validation schema
  * Can be extended with JSON Schema or Zod integration
  */
-export type ValidationSchema = {
+type ValidationSchema = {
     /** Required fields */
     required?: string[];
     /** Field type definitions */
@@ -41,7 +41,7 @@ export type ValidationSchema = {
 /**
  * Property schema definition
  */
-export type PropertySchema = {
+type PropertySchema = {
     /** Property type */
     type: "string" | "number" | "boolean" | "object" | "array";
     /** Minimum value (for numbers) or length (for strings/arrays) */
@@ -128,13 +128,13 @@ export declare const createValidationMiddleware: typeof createRequestValidationM
 /**
  * Extended property schema for common schemas
  */
-export type ExtendedPropertySchema = PropertySchema & {
+type ExtendedPropertySchema = PropertySchema & {
     format?: string;
 };
 /**
  * Extended validation schema for common schemas
  */
-export type ExtendedValidationSchema = {
+type ExtendedValidationSchema = {
     type?: string;
     format?: string;
     required?: string[];

package/dist/server/openapi/generator.d.ts

@@ -2,12 +2,11 @@
  * OpenAPI 3.1 Specification Generator
  * Generates OpenAPI documentation from NeuroLink server routes
  */
-import type { JsonObject } from "../../types/common.js";
-import type { RouteDefinition, ServerAdapterConfig } from "../types.js";
+import type { JsonObject, RouteDefinition, ServerAdapterConfig } from "../../types/index.js";
 /**
  * OpenAPI generator configuration
  */
-export type OpenAPIGeneratorConfig = {
+type OpenAPIGeneratorConfig = {
     /** API info override */
     info?: {
         title?: string;
@@ -36,7 +35,7 @@ export type OpenAPIGeneratorConfig = {
 /**
  * Generated OpenAPI specification
  */
-export type OpenAPISpec = {
+type OpenAPISpec = {
     openapi: "3.1.0";
     info: JsonObject;
     servers: JsonObject[];
@@ -105,3 +104,4 @@ export declare function generateOpenAPISpec(routes: RouteDefinition[], config?:
  * Generate OpenAPI spec from server adapter configuration
  */
 export declare function generateOpenAPIFromConfig(serverConfig: ServerAdapterConfig, routes?: RouteDefinition[]): OpenAPISpec;
+export {};

package/dist/server/openapi/index.d.ts

@@ -2,6 +2,6 @@
  * OpenAPI Module
  * Exports for OpenAPI 3.1 specification generation
  */
-export { OpenAPIGenerator, createOpenAPIGenerator, generateOpenAPISpec, generateOpenAPIFromConfig, type OpenAPIGeneratorConfig, type OpenAPISpec, } from "./generator.js";
+export { OpenAPIGenerator, createOpenAPIGenerator, generateOpenAPISpec, generateOpenAPIFromConfig, } from "./generator.js";
 export { ErrorResponseSchema, TokenUsageSchema, AgentInputSchema, AgentExecuteRequestSchema, AgentExecuteResponseSchema, ToolCallSchema, ProviderInfoSchema, ToolParameterSchema, ToolDefinitionSchema, ToolListResponseSchema, ToolExecuteRequestSchema, ToolExecuteResponseSchema, MCPServerToolSchema, MCPServerStatusSchema, MCPServersListResponseSchema, ConversationMessageSchema, SessionSchema, SessionsListResponseSchema, HealthResponseSchema, ReadyResponseSchema, MetricsResponseSchema, OpenAPISchemas, } from "./schemas.js";
 export { createSuccessResponse, createErrorResponse, createStreamingResponse, StandardErrorResponses, createPathParameter, createQueryParameter, createHeaderParameter, CommonParameters, createGetOperation, createPostOperation, createStreamingPostOperation, createDeleteOperation, BearerSecurityScheme, ApiKeySecurityScheme, BasicSecurityScheme, StandardTags, createServer, DefaultServers, createApiInfo, NeuroLinkApiInfo, } from "./templates.js";

package/dist/server/openapi/schemas.d.ts

@@ -3,7 +3,7 @@
  * JSON Schema definitions for all NeuroLink server API types
  * Compliant with OpenAPI 3.1 / JSON Schema 2020-12
  */
-import type { JsonObject } from "../../types/common.js";
+import type { JsonObject } from "../../types/index.js";
 /**
  * Error response schema
  */

package/dist/server/openapi/templates.d.ts

@@ -2,7 +2,7 @@
  * OpenAPI Templates
  * Reusable OpenAPI path and operation templates
  */
-import type { JsonObject } from "../../types/common.js";
+import type { JsonObject } from "../../types/index.js";
 /**
  * Create a success response template
  */

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

@@ -2,7 +2,7 @@
  * Agent Routes
  * Endpoints for agent execution and streaming
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create agent routes
  */

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

@@ -10,8 +10,7 @@
  * Without a router, models are passed through to the Anthropic provider.
  */
 import type { ModelRouter } from "../../proxy/modelRouter.js";
-import type { ParsedClaudeRequest } from "../../types/index.js";
-import type { RouteGroup } from "../types.js";
+import type { ParsedClaudeRequest, RouteGroup } from "../../types/index.js";
 /**
  * Create Claude-compatible proxy routes.
  *

package/dist/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/server/routes/healthRoutes.d.ts

@@ -2,7 +2,7 @@
  * Health Routes
  * Endpoints for health checks and system status
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create health check routes
  */

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

@@ -2,7 +2,7 @@
  * Route Builders
  * Pre-built route definitions for common NeuroLink endpoints
  */
-import type { RouteDefinition, RouteGroup } from "../types.js";
+import type { RouteDefinition, RouteGroup } from "../../types/index.js";
 export { createAgentRoutes } from "./agentRoutes.js";
 export { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
 export { createHealthRoutes } from "./healthRoutes.js";
@@ -13,7 +13,7 @@ export { createToolRoutes } from "./toolRoutes.js";
 /**
  * Options for creating routes
  */
-export type CreateRoutesOptions = {
+type CreateRoutesOptions = {
     /** Enable OpenAPI/Swagger documentation endpoints (default: false) */
     enableSwagger?: boolean;
     /**

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

@@ -2,7 +2,7 @@
  * MCP Routes
  * Endpoints for MCP server management
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create MCP server management routes
  */

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

@@ -2,7 +2,7 @@
  * Memory Routes
  * Endpoints for conversation memory management
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create memory management routes
  * Note: These routes provide a simplified interface to conversation memory.

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

@@ -2,7 +2,7 @@
  * OpenAPI Routes
  * Endpoints for OpenAPI specification and documentation
  */
-import type { RouteDefinition, RouteGroup } from "../types.js";
+import type { RouteDefinition, RouteGroup } from "../../types/index.js";
 /**
  * Create OpenAPI documentation routes
  *

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

@@ -2,7 +2,7 @@
  * Tool Routes
  * Endpoints for tool listing, discovery, and execution
  */
-import type { RouteGroup } from "../types.js";
+import type { RouteGroup } from "../../types/index.js";
 /**
  * Create tool routes
  */