@juspay/neurolink 10.12.5 → 10.12.7

package/dist/cli/commands/proxy.js

@@ -22,6 +22,7 @@ import { withTimeout } from "../../lib/utils/async/withTimeout.js";
 import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serverUtils.js";
 import { configureProxyKeepAliveDispatcher } from "../../lib/proxy/proxyDispatcher.js";
 import { ProxyRuntimeConfigStore } from "../../lib/proxy/runtimeConfig.js";
+import { startProxyLogCleanupScheduler } from "../../lib/proxy/logCleanupScheduler.js";
 import { anthropicAccountKeysEqual, createAccountAllowlist, ENV_ANTHROPIC_ACCOUNT_KEY, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../lib/proxy/accountSelection.js";
 import { beginProxyRequest, getProxyActivitySnapshot, trackProxyResponse, } from "../../lib/proxy/proxyActivity.js";
 import { flushProxyLifecycleEvents, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../lib/proxy/proxyLifecycle.js";
@@ -1208,10 +1209,12 @@ async function createProxyNeurolinkRuntime(logsDir) {
     process.env.NEUROLINK_SKIP_MCP = "true";
     const { NeuroLink } = await import("../../lib/neurolink.js");
     const neurolink = new NeuroLink();
-    const { initRequestLogger, cleanupLogs } = await import("../../lib/proxy/requestLogger.js");
+    const { initRequestLogger } = await import("../../lib/proxy/requestLogger.js");
     initRequestLogger(true, logsDir);
-    cleanupLogs(7, 500);
-    return { neurolink, cleanupLogs };
+    return {
+        neurolink,
+        logsDir: logsDir ?? join(homedir(), ".neurolink", "logs"),
+    };
 }
 function registerProxyRequestTracking(app, requestMetadata, readiness) {
     app.use("/v1/*", async (c, next) => {
@@ -2158,7 +2161,7 @@ async function refreshProxyTokensInBackground(accountAllowlist) {
         // non-fatal
     }
 }
-function startProxyBackgroundMaintenance(cleanupLogs, getAccountAllowlist) {
+function startProxyBackgroundMaintenance(logsDir, getAccountAllowlist) {
     const refreshInterval = setInterval(() => {
         if (backgroundRefreshInProgress) {
             return;
@@ -2172,15 +2175,8 @@ function startProxyBackgroundMaintenance(cleanupLogs, getAccountAllowlist) {
             backgroundRefreshInProgress = false;
         });
     }, 30_000);
-    const logCleanupInterval = setInterval(() => {
-        try {
-            cleanupLogs(7, 500);
-        }
-        catch (error) {
-            logger.debug(`[proxy] background log cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }, 60 * 60 * 1000);
-    return { refreshInterval, logCleanupInterval };
+    const logCleanupScheduler = startProxyLogCleanupScheduler({ logsDir });
+    return { refreshInterval, logCleanupScheduler };
 }
 function registerProxyShutdownHandlers(params) {
     let shutdownStarted = false;
@@ -2220,7 +2216,7 @@ function registerProxyShutdownHandlers(params) {
         }
         shutdownStarted = true;
         clearInterval(params.refreshInterval);
-        clearInterval(params.logCleanupInterval);
+        await params.logCleanupScheduler.stop();
         params.updaterSupervisor?.stop();
         params.stopRuntimeConfig?.();
         logger.always(`\nShutting down proxy (${signal})...`);
@@ -2524,7 +2520,7 @@ async function startProxyRuntime(params) {
     else {
         logger.always(chalk.dim("  ⊘ Dev mode: skipping client auto-configuration"));
     }
-    const maintenance = startProxyBackgroundMaintenance(params.cleanupLogs, () => params.runtimeConfigStore
+    const maintenance = startProxyBackgroundMaintenance(params.logsDir, () => params.runtimeConfigStore
         ? params.runtimeConfigStore.getSnapshot().accountAllowlist
         : params.accountAllowlist);
     const shutdown = registerProxyShutdownHandlers({
@@ -2719,7 +2715,7 @@ async function startProxyCommandHandler(argv) {
         // of opening a new flow per request — cuts outbound flow churn through host
         // content-filters. Runs once, after env load so it can be tuned via env.
         configureProxyKeepAliveDispatcher();
-        const { neurolink, cleanupLogs } = await createProxyNeurolinkRuntime(devPaths?.logsDir);
+        const { neurolink, logsDir } = await createProxyNeurolinkRuntime(devPaths?.logsDir);
         const configPath = argv.config
             ? resolve(argv.config)
             : join(homedir(), ".neurolink", "proxy-config.yaml");
@@ -2770,7 +2766,7 @@ async function startProxyCommandHandler(argv) {
             accountAllowlist,
             loadedEnvFile,
             passthrough,
-            cleanupLogs,
+            logsDir,
             runtimeConfigStore,
         });
     }

package/dist/cli/commands/proxyAnalyze.js

@@ -18,9 +18,11 @@ function printAnalysis(report) {
     logger.always(report.coverage.finalRequests
         ? `    Completed: ${report.requests.completed} (${chalk.green(`${report.requests.success} success`)}, ${chalk.red(`${report.requests.errors} errors`)})`
         : chalk.yellow("    Completed: unavailable (no final request logs)"));
-    logger.always(report.coverage.attempts && report.coverage.finalRequests
+    logger.always(report.coverage.attempts &&
+        report.coverage.finalRequests &&
+        report.coverage.comparableRequestAttempts
         ? `    Recovered after retry: ${report.requests.recoveredAfterRetry}`
-        : chalk.yellow("    Recovered after retry: unavailable"));
+        : chalk.yellow("    Recovered after retry: unavailable (request/attempt windows are incomplete or non-comparable)"));
     if (report.requests.errors > 0) {
         logger.always(`    Final error types: ${JSON.stringify(report.requests.errorTypes)}`);
     }
@@ -79,11 +81,14 @@ function printAnalysis(report) {
     }
     logger.always("");
     logger.always(chalk.bold("  Data Quality"));
+    if (!report.coverage.comparableRequestAttempts) {
+        logger.always(chalk.yellow("    WARNING: request and attempt totals do not cover a comparable full window; do not reconcile them as one cohort"));
+    }
     logger.always(`    ${report.dataQuality.linesRead} lines scanned, ${report.dataQuality.malformedLines} malformed, ${report.dataQuality.unsupportedLifecycleLines} unsupported lifecycle, ${report.dataQuality.lifecycleSequenceGaps} sequence gaps, ${report.dataQuality.lifecycleSequenceDuplicates} duplicates`);
     logger.always(`    Routing decisions: ${report.dataQuality.routingDecisions.valid} valid, ${report.dataQuality.routingDecisions.invalid} invalid, ${report.dataQuality.routingDecisions.absent} absent`);
     for (const [stream, range] of Object.entries(report.dataQuality.streams)) {
         if (range.observedFrom) {
-            logger.always(`    ${stream}: ${range.observedFrom} to ${range.observedTo}${range.startsAtOrBeforeRequestedWindow ? "" : chalk.yellow(" (starts after requested window)")}`);
+            logger.always(`    ${stream}: ${range.observedFrom} to ${range.observedTo}${range.completeWindow ? "" : chalk.yellow(" (partial: starts after requested window)")}`);
         }
     }
     const artifacts = report.dataQuality.bodyArtifacts;

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

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

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

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

package/dist/lib/proxy/logCleanupWorkerEntry.js

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

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

@@ -700,61 +700,71 @@ 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`);
     }
 }
 //# sourceMappingURL=requestLogger.js.map

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