@juspay/neurolink 10.12.5 → 10.12.7

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

@@ -646,6 +646,7 @@ export type AnthropicSuccessResult = {
     failure?: {
         message: string;
         rateLimit: boolean;
+        retryDelayMs?: number;
     };
 } | {
     response: Response | unknown;
@@ -702,6 +703,8 @@ export type AnthropicAuthRetryResult = {
     response?: Response | unknown;
     holdsAccountAdmission?: boolean;
     continueLoop: boolean;
+    /** Failure-path pacing before rotating after provider-wide overload. */
+    retryDelayMs?: number;
     lastError: unknown;
     authFailureMessage: string | null;
     sawRateLimit: boolean;
@@ -713,6 +716,8 @@ export type AnthropicNonOkResult = {
     response?: Response | unknown;
     continueLoop: boolean;
     retrySameAccount?: boolean;
+    /** Failure-path pacing before rotating after provider-wide overload. */
+    retryDelayMs?: number;
     lastError: unknown;
     authFailureMessage: string | null;
     sawTransientFailure: boolean;
@@ -1457,6 +1462,9 @@ export type ProxyAnalysisReport = {
         attemptLatency: boolean;
         cacheUsage: boolean;
         routingDecisions: boolean;
+        /** True only when every stream needed for cross-stream request/attempt
+         * reconciliation begins at or before the requested analysis window. */
+        comparableRequestAttempts: boolean;
     };
     dataQuality: {
         linesRead: number;
@@ -1468,6 +1476,8 @@ export type ProxyAnalysisReport = {
             observedFrom: string | null;
             observedTo: string | null;
             startsAtOrBeforeRequestedWindow: boolean;
+            /** Whether this stream can support claims covering the full window. */
+            completeWindow: boolean;
         }>;
         bodyArtifacts: {
             capturesIndexed: number;
@@ -2073,6 +2083,14 @@ export type RollingWorkerFailureDetails = {
     workerExitSignal?: string | null;
     supervisorAction?: "none" | "sigkill_after_transfer_failure";
 };
+export type RollingWorkerSupervisorEvent = {
+    at: string;
+    type: "activated" | "failure" | "failed_transfer" | "rejected_socket";
+    generation: number | null;
+    version: string | null;
+    phase?: "startup" | "activation" | "runtime" | "transfer";
+    reason?: string;
+};
 export type RollingWorkerSupervisorSnapshot = {
     generation: number;
     active: {
@@ -2093,6 +2111,8 @@ export type RollingWorkerSupervisorSnapshot = {
     queuedSockets: number;
     rejectedSockets: number;
     failedTransfers: number;
+    /** Bounded generation-scoped evidence for attributing lifetime counters. */
+    recentEvents: RollingWorkerSupervisorEvent[];
     lastFailure: ({
         at: string;
         generation: number;
@@ -2305,7 +2325,18 @@ export type ProxyNeurolinkRuntime = {
     neurolink: {
         getToolRegistry(): MCPToolRegistry;
     };
-    cleanupLogs: (daysToKeep?: number, maxFiles?: number) => void;
+    logsDir: string;
+};
+/** Data passed to the isolated proxy log-retention worker. */
+export type ProxyLogCleanupWorkerData = {
+    logsDir: string;
+    maxAgeDays: number;
+    maxSizeMb: number;
+};
+/** Lifecycle handle for non-blocking proxy log retention. */
+export type ProxyLogCleanupScheduler = {
+    trigger: () => boolean;
+    stop: () => Promise<void>;
 };
 /** Hono app + readiness state created by the proxy start command. */
 export type ProxyStartApp = {

package/dist/lib/utils/messageBuilder.js

@@ -1073,6 +1073,18 @@ export async function processUnifiedFilesArray(options, maxSize, provider) {
             options.systemPrompt = existingSystem
                 ? `${existingSystem}${filePromptAugmentation}`
                 : filePromptAugmentation.trim();
+            // Keep options.prompt in sync with the enriched input.text.
+            // neurolink.ts snapshots `prompt: options.input?.text` at baseOptions
+            // creation — BEFORE this function appends file content — and some
+            // native paths (executeNativeAnthropicGenerate historically) read
+            // `options.prompt` first. Leaving the stale snapshot in place means
+            // every appended file is silently dropped on those paths and the model
+            // answers "no file attached". Same dual-write processCSVFilesForNativeSDK
+            // already documents for exactly this trap.
+            const promptCarrier = options;
+            if (typeof promptCarrier.prompt === "string") {
+                promptCarrier.prompt = inp2.text;
+            }
         }
     });
 }

package/dist/providers/googleVertex/client.js

@@ -4815,7 +4815,15 @@ export class GoogleVertexProvider extends BaseProvider {
         });
         // Build messages from input
         const messages = [];
-        const inputText = options.prompt || options.input?.text || "Please respond.";
+        // input.text FIRST — the file preprocessors (processUnifiedFilesArray,
+        // processCSVFilesForNativeSDK) append attached-file content to input.text,
+        // while options.prompt is snapshotted from the ORIGINAL input.text at
+        // baseOptions creation (neurolink.ts). With prompt-first precedence every
+        // attached file was silently dropped on the Claude generate path — the
+        // model answered "no file attached" to a request that carried one. The
+        // native Gemini path already reads input.text first for exactly this
+        // reason.
+        const inputText = options.input?.text || options.prompt || "Please respond.";
         // Replay conversationMessages (with tool turns), else the legacy text-only conversationHistory.
         if (options.conversationMessages &&
             options.conversationMessages.length > 0) {

package/dist/proxy/logCleanupScheduler.d.ts

@@ -0,0 +1,12 @@
+import type { ProxyLogCleanupScheduler } from "../types/index.js";
+/**
+ * Runs retention in a worker so large log trees cannot delay readiness or
+ * block active streams. Concurrent runs are coalesced into the active scan.
+ */
+export declare function startProxyLogCleanupScheduler(params: {
+    logsDir: string;
+    maxAgeDays?: number;
+    maxSizeMb?: number;
+    initialDelayMs?: number;
+    intervalMs?: number;
+}): ProxyLogCleanupScheduler;

package/dist/proxy/logCleanupScheduler.js

@@ -0,0 +1,73 @@
+import { Worker } from "node:worker_threads";
+import { withTimeout } from "../utils/async/withTimeout.js";
+import { logger } from "../utils/logger.js";
+const DEFAULT_INITIAL_DELAY_MS = 30_000;
+const DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
+const WORKER_TERMINATION_TIMEOUT_MS = 5_000;
+/**
+ * Runs retention in a worker so large log trees cannot delay readiness or
+ * block active streams. Concurrent runs are coalesced into the active scan.
+ */
+export function startProxyLogCleanupScheduler(params) {
+    const maxAgeDays = params.maxAgeDays ?? 7;
+    const maxSizeMb = params.maxSizeMb ?? 500;
+    let activeWorker;
+    let stopped = false;
+    const trigger = () => {
+        if (stopped || activeWorker) {
+            return false;
+        }
+        let worker;
+        try {
+            worker = new Worker(params.workerUrl ??
+                new URL("./logCleanupWorkerEntry.js", import.meta.url), {
+                execArgv: process.execArgv.filter((argument) => !argument.startsWith("--input-type")),
+                workerData: {
+                    logsDir: params.logsDir,
+                    maxAgeDays,
+                    maxSizeMb,
+                },
+            });
+        }
+        catch (error) {
+            logger.debug(`[proxy] could not start background log cleanup: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+        activeWorker = worker;
+        worker.unref();
+        worker.once("error", (error) => {
+            logger.debug(`[proxy] background log cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        worker.once("exit", (code) => {
+            if (activeWorker === worker) {
+                activeWorker = undefined;
+            }
+            if (code !== 0 && !stopped) {
+                logger.debug(`[proxy] background log cleanup exited with code ${code}`);
+            }
+        });
+        return true;
+    };
+    const initialTimer = setTimeout(trigger, params.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS);
+    initialTimer.unref();
+    const interval = setInterval(trigger, params.intervalMs ?? DEFAULT_INTERVAL_MS);
+    interval.unref();
+    return {
+        trigger,
+        stop: async () => {
+            stopped = true;
+            clearTimeout(initialTimer);
+            clearInterval(interval);
+            const worker = activeWorker;
+            activeWorker = undefined;
+            if (worker) {
+                try {
+                    await withTimeout(worker.terminate(), WORKER_TERMINATION_TIMEOUT_MS, "Timed out terminating the proxy log cleanup worker");
+                }
+                catch (error) {
+                    logger.debug(`[proxy] background log cleanup termination failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        },
+    };
+}

package/dist/proxy/logCleanupWorkerEntry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/proxy/logCleanupWorkerEntry.js

@@ -0,0 +1,14 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { cleanupLogsAt } from "./requestLogger.js";
+const data = workerData;
+try {
+    cleanupLogsAt(data.logsDir, data.maxAgeDays, data.maxSizeMb);
+    parentPort?.postMessage({ ok: true });
+}
+catch (error) {
+    parentPort?.postMessage({
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+    });
+    process.exitCode = 1;
+}

package/dist/proxy/proxyAnalysis.js

@@ -737,6 +737,10 @@ export async function analyzeProxyLogs(options) {
     const artifactsReferenced = artifactsPresent + artifactsMissing;
     const finalSummary = summarizeFinalRequests(finalRequests, terminalStreamErrors, attemptsByRequest, accounts);
     const routingSummary = summarizeRouting(finalRequests);
+    const streamComplete = (stream) => {
+        const range = observedRanges[stream];
+        return range.from !== null && range.from <= sinceMs;
+    };
     return {
         generatedAt: new Date(nowMs).toISOString(),
         since: new Date(sinceMs).toISOString(),
@@ -755,6 +759,7 @@ export async function analyzeProxyLogs(options) {
             attemptLatency: attemptLatency.length > 0,
             cacheUsage: finalSummary.cache.requestsWithUsage > 0,
             routingDecisions: routingSummary.totalRecords > 0,
+            comparableRequestAttempts: streamComplete("requests") && streamComplete("attempts"),
         },
         dataQuality: {
             linesRead,
@@ -768,6 +773,7 @@ export async function analyzeProxyLogs(options) {
                     observedFrom: range.from === null ? null : new Date(range.from).toISOString(),
                     observedTo: range.to === null ? null : new Date(range.to).toISOString(),
                     startsAtOrBeforeRequestedWindow: range.from !== null && range.from <= sinceMs,
+                    completeWindow: range.from !== null && range.from <= sinceMs,
                 },
             ])),
             bodyArtifacts: {

package/dist/proxy/requestLogger.d.ts

@@ -70,3 +70,9 @@ export declare function logStreamError(entry: {
  * Non-fatal — proxy keeps working even if cleanup fails.
  */
 export declare function cleanupLogs(maxAgeDays?: number, maxSizeMb?: number): void;
+/**
+ * Path-scoped retention implementation used by the proxy cleanup worker.
+ * This function is intentionally synchronous: callers must run it outside the
+ * request-serving process when the directory can contain many artifacts.
+ */
+export declare function cleanupLogsAt(activeLogDir: string, maxAgeDays?: number, maxSizeMb?: number): void;

package/dist/proxy/requestLogger.js

@@ -700,60 +700,70 @@ export async function logStreamError(entry) {
  * Non-fatal — proxy keeps working even if cleanup fails.
  */
 export function cleanupLogs(maxAgeDays = 7, maxSizeMb = 500) {
-    if (!logDir || !existsSync(logDir)) {
+    if (!logDir) {
         return;
     }
     try {
-        const activeLogDir = logDir;
-        const files = collectManagedLogFiles(activeLogDir).sort((a, b) => a.mtime - b.mtime); // oldest first
-        const currentDate = new Date().toISOString().split("T")[0];
-        const currentMetadataLogs = new Set(["proxy", "proxy-attempts", "proxy-debug", "proxy-lifecycle"].map((prefix) => join(activeLogDir, `${prefix}-${currentDate}.jsonl`)));
-        const canDelete = (file) => !currentMetadataLogs.has(file.path);
-        const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-        let deletedCount = 0;
-        let freedBytes = 0;
-        // Pass 1: delete files older than maxAgeDays
-        const remaining = [];
-        for (const file of files) {
-            if (file.mtime < cutoff && canDelete(file)) {
-                unlinkSync(file.path);
-                deletedCount++;
-                freedBytes += file.size;
-            }
-            else {
-                remaining.push(file);
-            }
-        }
-        const bodiesDir = join(logDir, "bodies");
-        if (existsSync(bodiesDir)) {
-            pruneEmptyDirectories(bodiesDir, bodiesDir);
-        }
-        // Pass 2: if total size exceeds maxSizeMb, delete oldest until under limit
-        const maxBytes = maxSizeMb * 1024 * 1024;
-        let totalSize = remaining.reduce((sum, f) => sum + f.size, 0);
-        const deletionCandidates = remaining.filter(canDelete);
-        // Current-day metadata is the only reliable source for final-request,
-        // attempt, lifecycle, and body-index reconciliation. Keep those indexes
-        // intact during size cleanup; body artifacts and older indexes remain
-        // eligible for eviction.
-        while (totalSize > maxBytes && deletionCandidates.length > 0) {
-            const oldest = deletionCandidates.shift();
-            if (!oldest) {
-                break;
-            }
-            unlinkSync(oldest.path);
-            totalSize -= oldest.size;
+        cleanupLogsAt(logDir, maxAgeDays, maxSizeMb);
+    }
+    catch {
+        // Non-fatal for legacy in-process callers.
+    }
+}
+/**
+ * Path-scoped retention implementation used by the proxy cleanup worker.
+ * This function is intentionally synchronous: callers must run it outside the
+ * request-serving process when the directory can contain many artifacts.
+ */
+export function cleanupLogsAt(activeLogDir, maxAgeDays = 7, maxSizeMb = 500) {
+    if (!existsSync(activeLogDir)) {
+        return;
+    }
+    const files = collectManagedLogFiles(activeLogDir).sort((a, b) => a.mtime - b.mtime); // oldest first
+    const currentDate = new Date().toISOString().split("T")[0];
+    const currentMetadataLogs = new Set(["proxy", "proxy-attempts", "proxy-debug", "proxy-lifecycle"].map((prefix) => join(activeLogDir, `${prefix}-${currentDate}.jsonl`)));
+    const canDelete = (file) => !currentMetadataLogs.has(file.path);
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    let deletedCount = 0;
+    let freedBytes = 0;
+    // Pass 1: delete files older than maxAgeDays
+    const remaining = [];
+    for (const file of files) {
+        if (file.mtime < cutoff && canDelete(file)) {
+            unlinkSync(file.path);
             deletedCount++;
-            freedBytes += oldest.size;
+            freedBytes += file.size;
         }
-        if (existsSync(bodiesDir)) {
-            pruneEmptyDirectories(bodiesDir, bodiesDir);
+        else {
+            remaining.push(file);
         }
-        if (deletedCount > 0) {
-            logger.info(`[proxy] log cleanup: deleted ${deletedCount} file(s), freed ${(freedBytes / 1024 / 1024).toFixed(1)} MB`);
+    }
+    const bodiesDir = join(activeLogDir, "bodies");
+    if (existsSync(bodiesDir)) {
+        pruneEmptyDirectories(bodiesDir, bodiesDir);
+    }
+    // Pass 2: if total size exceeds maxSizeMb, delete oldest until under limit
+    const maxBytes = maxSizeMb * 1024 * 1024;
+    let totalSize = remaining.reduce((sum, f) => sum + f.size, 0);
+    const deletionCandidates = remaining.filter(canDelete);
+    // Current-day metadata is the only reliable source for final-request,
+    // attempt, lifecycle, and body-index reconciliation. Keep those indexes
+    // intact during size cleanup; body artifacts and older indexes remain
+    // eligible for eviction.
+    while (totalSize > maxBytes && deletionCandidates.length > 0) {
+        const oldest = deletionCandidates.shift();
+        if (!oldest) {
+            break;
         }
+        unlinkSync(oldest.path);
+        totalSize -= oldest.size;
+        deletedCount++;
+        freedBytes += oldest.size;
     }
-    catch {
-        // Non-fatal
+    if (existsSync(bodiesDir)) {
+        pruneEmptyDirectories(bodiesDir, bodiesDir);
+    }
+    if (deletedCount > 0) {
+        logger.info(`[proxy] log cleanup: deleted ${deletedCount} file(s), freed ${(freedBytes / 1024 / 1024).toFixed(1)} MB`);
     }
 }

package/dist/proxy/rollingWorkerSupervisor.d.ts

@@ -14,6 +14,7 @@ export declare class RollingWorkerSupervisor {
     private replacement;
     private rejectedSockets;
     private failedTransfers;
+    private readonly recentEvents;
     private lastFailure;
     private closed;
     private shutdownPromise;
@@ -38,5 +39,6 @@ export declare class RollingWorkerSupervisor {
     private describeTransferError;
     private extractLifecycleFailureDetails;
     private recordFailure;
+    private recordEvent;
     private publishState;
 }

package/dist/proxy/rollingWorkerSupervisor.js

@@ -3,6 +3,7 @@ const DEFAULT_READY_TIMEOUT_MS = 30_000;
 const DEFAULT_SOCKET_QUEUE_LIMIT = 1_024;
 const DEFAULT_SOCKET_QUEUE_TIMEOUT_MS = 30_000;
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 30_000;
+const MAX_RECENT_SUPERVISOR_EVENTS = 100;
 /**
  * Owns worker generations while the caller owns the public listening socket.
  * Sockets are transferred once to the active worker, so response bytes never
@@ -18,6 +19,7 @@ export class RollingWorkerSupervisor {
     replacement = null;
     rejectedSockets = 0;
     failedTransfers = 0;
+    recentEvents = [];
     lastFailure = null;
     closed = false;
     shutdownPromise = null;
@@ -56,6 +58,7 @@ export class RollingWorkerSupervisor {
             queuedSockets: this.queuedSockets.length,
             rejectedSockets: this.rejectedSockets,
             failedTransfers: this.failedTransfers,
+            recentEvents: [...this.recentEvents],
             lastFailure: this.lastFailure,
         };
     }
@@ -302,6 +305,11 @@ export class RollingWorkerSupervisor {
                     this.maybeDrainWorker(previous);
                 }
                 this.options.log?.(`[proxy-supervisor] activated generation=${generation} pid=${handle.pid} version=${expectedVersion}`);
+                this.recordEvent({
+                    type: "activated",
+                    generation,
+                    version: expectedVersion,
+                });
                 this.publishState();
                 finish();
             });
@@ -410,6 +418,13 @@ export class RollingWorkerSupervisor {
     handleTransferFailure(worker, socket, error) {
         this.failedTransfers += 1;
         const detail = this.describeTransferError(error);
+        this.recordEvent({
+            type: "failed_transfer",
+            generation: worker.generation,
+            version: worker.version,
+            phase: "transfer",
+            reason: detail,
+        });
         const lifecycle = this.extractLifecycleFailureDetails(error, worker.handle.pid);
         this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} failed to accept a transferred socket: ${detail}`, {
             ...lifecycle.details,
@@ -432,10 +447,16 @@ export class RollingWorkerSupervisor {
             }
             this.publishState();
         }
-        this.rejectSocket(socket);
+        this.rejectSocket(socket, worker.generation, worker.version, "transfer_failure");
     }
-    rejectSocket(socket) {
+    rejectSocket(socket, generation = this.active?.generation ?? null, version = this.active?.version ?? null, reason = "unavailable") {
         this.rejectedSockets += 1;
+        this.recordEvent({
+            type: "rejected_socket",
+            generation,
+            version,
+            reason,
+        });
         socket.destroy();
         this.publishState();
     }
@@ -479,6 +500,23 @@ export class RollingWorkerSupervisor {
             message: message.slice(0, 1_000),
             ...details,
         };
+        this.recordEvent({
+            type: "failure",
+            generation,
+            version,
+            phase,
+            reason: message,
+        });
+    }
+    recordEvent(event) {
+        this.recentEvents.push({
+            at: new Date().toISOString(),
+            ...event,
+            ...(event.reason ? { reason: event.reason.slice(0, 1_000) } : {}),
+        });
+        if (this.recentEvents.length > MAX_RECENT_SUPERVISOR_EVENTS) {
+            this.recentEvents.splice(0, this.recentEvents.length - MAX_RECENT_SUPERVISOR_EVENTS);
+        }
     }
     publishState() {
         try {

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

@@ -310,6 +310,7 @@ declare function shouldAttemptClaudeFallback(loopState: AnthropicLoopState): boo
 export declare function createClaudeProxyRoutes(modelRouter?: ModelRouterInterface, basePath?: string, accountStrategy?: "round-robin" | "fill-first", passthroughMode?: boolean, primaryAccountKey?: string, accountAllowlistOrRuntimeOptions?: AccountAllowlist | ClaudeProxyRouteRuntimeOptions): RouteGroup;
 declare function reconcileEligibleAccountRuntimeState(account: ProxyPassthroughAccount): void;
 export declare function getTransientSameAccountRetryDelayMs(retryNumber: number): number;
+export declare function getOverloadRotationDelayMs(attemptNumber: number): number;
 declare function describeTransportError(error: unknown): string;
 /**
  * Determine whether a POST can be retried without risking duplicate provider
@@ -400,6 +401,7 @@ export declare const __testHooks: {
     describeTransportError: typeof describeTransportError;
     redactProviderErrorMessage: typeof redactProviderErrorMessage;
     isUpstreamOverload: typeof isUpstreamOverload;
+    getOverloadRotationDelayMs: typeof getOverloadRotationDelayMs;
     shouldAttemptClaudeFallback: typeof shouldAttemptClaudeFallback;
     executeClaudeFallbackWithRetry: typeof executeClaudeFallbackWithRetry;
     buildClaudeAnthropicFailureResponse: typeof buildClaudeAnthropicFailureResponse;

package/dist/server/routes/claudeProxyRoutes.js

@@ -63,6 +63,7 @@ let lastKnownAccountCount = 0;
 const MAX_AUTH_RETRIES = 5;
 const MAX_TRANSIENT_SAME_ACCOUNT_RETRIES = 2;
 const TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS = [250, 1_000];
+const OVERLOAD_ACCOUNT_ROTATION_DELAYS_MS = [250, 500, 1_000, 2_000];
 const MAX_FALLBACK_NETWORK_RETRIES = 1;
 const FALLBACK_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1000;
 /** Maximum upstream 429 attempts per account before rotating — for a TRANSIENT
@@ -2883,7 +2884,13 @@ async function handleAnthropicStreamingSuccessResponse(args) {
         });
         return {
             retryNextAccount: true,
-            failure: { message: preflight.message, rateLimit: isRateLimit },
+            failure: {
+                message: preflight.message,
+                rateLimit: isRateLimit,
+                ...(preflight.errorType === "overloaded_error"
+                    ? { retryDelayMs: getOverloadRotationDelayMs(attemptNumber) }
+                    : {}),
+            },
         };
     }
     logAttempt(response.status, undefined, undefined, {
@@ -3484,6 +3491,9 @@ async function handleAnthropicAuthRetry(args) {
                     const failure = successResult.failure;
                     return {
                         continueLoop: true,
+                        ...(failure?.retryDelayMs
+                            ? { retryDelayMs: failure.retryDelayMs }
+                            : {}),
                         lastError: failure?.message ?? currentLastError,
                         authFailureMessage: currentAuthFailureMessage,
                         sawRateLimit: currentSawRateLimit || Boolean(failure?.rateLimit),
@@ -3941,6 +3951,9 @@ async function handleAnthropicNonOkResponse(args) {
         return {
             continueLoop: true,
             retrySameAccount: !upstreamOverload,
+            ...(upstreamOverload
+                ? { retryDelayMs: getOverloadRotationDelayMs(attemptNumber) }
+                : {}),
             lastError: currentLastError,
             authFailureMessage: currentAuthFailureMessage,
             sawTransientFailure: currentSawTransientFailure,
@@ -4553,7 +4566,8 @@ async function handleAnthropicRoutedClaudeRequest(args) {
         effectiveAccounts.every((account) => !isAccountAdmissionAvailable(account.key, accountAdmissionCapacity))) {
         queuedAccountAdmission = await acquireFirstAvailableAccountAdmission(effectiveAccounts.map((account) => account.key), accountAdmissionCapacity, ctx.abortSignal);
     }
-    accountLoop: for (const account of effectiveAccounts) {
+    accountLoop: for (const [accountIndex, account,] of effectiveAccounts.entries()) {
+        const hasNextAccount = accountIndex < effectiveAccounts.length - 1;
         const accountState = getOrCreateRuntimeState(account.key);
         let transientSameAccountRetries = 0;
         let rateLimitSameAccountRetries = 0;
@@ -4763,6 +4777,10 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                         return authRetryResult.response;
                     }
                     if (authRetryResult.continueLoop) {
+                        if (hasNextAccount && authRetryResult.retryDelayMs) {
+                            logger.always(`[proxy] pacing cross-account SSE overload rotation for ${authRetryResult.retryDelayMs}ms after auth refresh`);
+                            await sleep(authRetryResult.retryDelayMs);
+                        }
                         continue accountLoop;
                     }
                 }
@@ -4804,6 +4822,10 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                         if (nonOkResult.retrySameAccount) {
                             logger.always(`[proxy] exhausted transient same-account retries for account=${account.label}; rotating`);
                         }
+                        if (hasNextAccount && nonOkResult.retryDelayMs) {
+                            logger.always(`[proxy] pacing cross-account overload rotation for ${nonOkResult.retryDelayMs}ms`);
+                            await sleep(nonOkResult.retryDelayMs);
+                        }
                         continue accountLoop;
                     }
                     break accountLoop;
@@ -4845,6 +4867,10 @@ async function handleAnthropicRoutedClaudeRequest(args) {
                         loopState.lastError = successResult.failure.message;
                         loopState.sawRateLimit ||= successResult.failure.rateLimit;
                         loopState.sawTransientFailure ||= !successResult.failure.rateLimit;
+                        if (hasNextAccount && successResult.failure.retryDelayMs) {
+                            logger.always(`[proxy] pacing cross-account SSE overload rotation for ${successResult.failure.retryDelayMs}ms`);
+                            await sleep(successResult.failure.retryDelayMs);
+                        }
                     }
                     continue accountLoop;
                 }
@@ -5315,6 +5341,10 @@ export function getTransientSameAccountRetryDelayMs(retryNumber) {
     const index = Math.min(Math.max(retryNumber - 1, 0), TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS.length - 1);
     return TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS[index] ?? 0;
 }
+export function getOverloadRotationDelayMs(attemptNumber) {
+    const index = Math.min(Math.max(attemptNumber - 1, 0), OVERLOAD_ACCOUNT_ROTATION_DELAYS_MS.length - 1);
+    return jitteredDelay(OVERLOAD_ACCOUNT_ROTATION_DELAYS_MS[index] ?? 250);
+}
 async function sleep(ms) {
     await new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -5586,6 +5616,7 @@ export const __testHooks = {
     describeTransportError,
     redactProviderErrorMessage,
     isUpstreamOverload,
+    getOverloadRotationDelayMs,
     shouldAttemptClaudeFallback,
     executeClaudeFallbackWithRetry,
     buildClaudeAnthropicFailureResponse,