@juspay/neurolink 10.7.0 → 10.8.0

package/dist/lib/proxy/proxyAnalysis.js

@@ -20,6 +20,8 @@ const ROUTING_MODES = new Set(PROXY_ACCOUNT_ROUTING_MODES);
 const ROUTING_REASONS = new Set(PROXY_ACCOUNT_ROUTING_REASONS);
 const ROUTING_ACCOUNT_TYPES = new Set(PROXY_ACCOUNT_TYPES);
 const COOLING_REASONS = new Set(ACCOUNT_COOLING_REASONS);
+const MAX_RETAINED_ROUTING_RECORDS = 200;
+const MAX_ROUTING_RECORDS_BEFORE_COMPACTION = MAX_RETAINED_ROUTING_RECORDS * 2;
 function isContainedPath(root, candidate) {
     const candidateRelative = relative(root, candidate);
     return (candidateRelative.length > 0 &&
@@ -338,7 +340,8 @@ function summarizeRouting(finalRequests) {
     const modes = {};
     const selectionReasons = {};
     const initialAccounts = {};
-    const records = [];
+    const retainedRecords = [];
+    let totalRecords = 0;
     let finalAccountChanges = 0;
     let finalOutsideCandidateSet = 0;
     for (const [requestId, request] of finalRequests) {
@@ -357,21 +360,36 @@ function summarizeRouting(finalRequests) {
         else if (decision.initialAccount !== request.account) {
             finalAccountChanges += 1;
         }
-        records.push({
-            requestId,
-            timestamp: request.timestamp,
-            responseStatus: request.status,
-            finalAccount: request.account,
-            finalAccountType: request.accountType,
-            decision,
+        totalRecords += 1;
+        retainedRecords.push({
+            record: {
+                requestId,
+                timestamp: request.timestamp,
+                responseStatus: request.status,
+                finalAccount: request.account,
+                finalAccountType: request.accountType,
+                decision,
+            },
+            timestampMs: Date.parse(request.timestamp),
+            sequence: totalRecords,
         });
+        if (retainedRecords.length > MAX_ROUTING_RECORDS_BEFORE_COMPACTION) {
+            retainedRecords.sort((left, right) => left.timestampMs - right.timestampMs ||
+                left.sequence - right.sequence);
+            retainedRecords.splice(0, retainedRecords.length - MAX_RETAINED_ROUTING_RECORDS);
+        }
     }
+    retainedRecords.sort((left, right) => left.timestampMs - right.timestampMs || left.sequence - right.sequence);
+    const records = retainedRecords
+        .slice(-MAX_RETAINED_ROUTING_RECORDS)
+        .map(({ record }) => record);
     return {
         modes,
         selectionReasons,
         initialAccounts,
         finalAccountChanges,
         finalOutsideCandidateSet,
+        totalRecords,
         records,
     };
 }
@@ -704,7 +722,7 @@ export async function analyzeProxyLogs(options) {
             attempts: totalAttempts > 0,
             attemptLatency: attemptLatency.length > 0,
             cacheUsage: finalSummary.cache.requestsWithUsage > 0,
-            routingDecisions: routingSummary.records.length > 0,
+            routingDecisions: routingSummary.totalRecords > 0,
         },
         dataQuality: {
             linesRead,

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

@@ -12,7 +12,7 @@
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
-import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
 /** Resolve the configured primary's stable key to its current index in the
  *  request's enabledAccounts list. Returns 0 (insertion-order fallback) when
  *  no key is configured or the key cannot be matched (account disabled/
@@ -85,6 +85,19 @@ declare function seedRuntimeQuotasFromDisk(accounts: ProxyPassthroughAccount[]):
  * last resort.
  */
 declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number): ProxyPassthroughAccount[];
+declare function buildRoutingDecision(args: {
+    accounts: ProxyPassthroughAccount[];
+    orderedAccounts: ProxyPassthroughAccount[];
+    metricsByKey: ReadonlyMap<string, ProxyAccountSortMetrics>;
+    evaluatedAt: number;
+    strategy: "round-robin" | "fill-first";
+    primaryKey: string | undefined;
+    quotaRoutingEnabled: boolean;
+    quotaOrdered: boolean;
+    sessionSoftLimit: number;
+    sessionResetToleranceMs: number;
+    rotationOffset: number;
+}): ProxyAccountRoutingDecision | undefined;
 declare function trackUpstreamReadableStream(source: ReadableStream<Uint8Array>): {
     stream: ReadableStream<Uint8Array>;
     outcome: Promise<StreamTerminalOutcome>;
@@ -279,7 +292,8 @@ export declare const __testHooks: {
     getStreamFailureDetails: typeof getStreamFailureDetails;
     trackUpstreamReadableStream: typeof trackUpstreamReadableStream;
     orderAccountsByQuota: typeof orderAccountsByQuota;
-    buildQuotaRoutingDecision: (accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number) => ProxyAccountRoutingDecision;
+    buildQuotaRoutingDecision: (accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number) => ProxyAccountRoutingDecision | undefined;
+    buildRoutingDecision: typeof buildRoutingDecision;
     resetEpochToMs: typeof resetEpochToMs;
     seedRuntimeQuotasFromDisk: typeof seedRuntimeQuotasFromDisk;
     reconcileEligibleAccountRuntimeState: typeof reconcileEligibleAccountRuntimeState;

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

@@ -562,16 +562,18 @@ function buildRoutingDecision(args) {
     const { accounts, orderedAccounts, metricsByKey, evaluatedAt, strategy, primaryKey, quotaRoutingEnabled, quotaOrdered, sessionSoftLimit, sessionResetToleranceMs, rotationOffset, } = args;
     const sourceIndexes = new Map(accounts.map((account, index) => [account.key, index]));
     const configuredPrimaryMatched = !!primaryKey && accounts.some((account) => account.key === primaryKey);
-    const candidates = orderedAccounts.map((account, rank) => {
+    const candidates = [];
+    for (const account of orderedAccounts) {
         const metrics = metricsByKey.get(account.key);
         if (!metrics) {
-            throw new Error(`Missing precomputed routing metrics for account ${account.label}`);
+            logger.warn(`[proxy] routing evidence omitted because metrics are missing for account=${account.label}`);
+            return undefined;
         }
-        return {
+        candidates.push({
             account: account.label,
             accountType: account.type,
-            sourceIndex: sourceIndexes.get(account.key) ?? rank,
-            rank,
+            sourceIndex: sourceIndexes.get(account.key) ?? candidates.length,
+            rank: candidates.length,
             configuredPrimary: !!primaryKey && account.key === primaryKey,
             usable: metrics.usable,
             saturated: metrics.saturated,
@@ -598,8 +600,8 @@ function buildRoutingDecision(args) {
             weeklyResetAt: Number.isFinite(metrics.weeklyReset)
                 ? metrics.weeklyReset
                 : null,
-        };
-    });
+        });
+    }
     const initialAccount = orderedAccounts[0];
     let mode;
     let selectionReason;
@@ -684,7 +686,7 @@ function selectClaudeProxyAccountOrder(args) {
             accountSortMetrics(account.key, evaluatedAt, sessionSoftLimit, sessionResetToleranceMs),
         ]));
     }
-    setRoutingDecision(buildRoutingDecision({
+    const routingDecision = buildRoutingDecision({
         accounts: enabledAccounts,
         orderedAccounts,
         metricsByKey,
@@ -696,7 +698,10 @@ function selectClaudeProxyAccountOrder(args) {
         sessionSoftLimit,
         sessionResetToleranceMs,
         rotationOffset,
-    }));
+    });
+    if (routingDecision) {
+        setRoutingDecision(routingDecision);
+    }
     return orderedAccounts;
 }
 // ---------------------------------------------------------------------------
@@ -4896,6 +4901,7 @@ export const __testHooks = {
             rotationOffset: 0,
         });
     },
+    buildRoutingDecision,
     resetEpochToMs,
     seedRuntimeQuotasFromDisk,
     reconcileEligibleAccountRuntimeState,

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

@@ -1418,9 +1418,25 @@ export type TextGenerationResult = {
 /**
  * Enhanced result type with optional analytics/evaluation
  */
+export type TTSMetadata = {
+    /** Whether TTS synthesis was invoked. False indicates TTS was skipped. */
+    attempted: boolean;
+    /** Whether TTS synthesis completed successfully. */
+    success: boolean;
+    /** Structured synthesis error details, present only when synthesis failed. */
+    error?: {
+        code: string;
+        message: string;
+        retriable?: boolean;
+    };
+    /** TTS synthesis time in milliseconds. */
+    latency?: number;
+};
 export type EnhancedGenerateResult = GenerateResult & {
     analytics?: AnalyticsData;
     evaluation?: EvaluationData;
+    /** Outcome metadata when TTS was enabled for this generation. */
+    ttsMetadata?: TTSMetadata;
 };
 /**
  * NL-004: Model alias/deprecation configuration.

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

@@ -1341,6 +1341,9 @@ export type ProxyAnalysisReport = {
         initialAccounts: Record<string, number>;
         finalAccountChanges: number;
         finalOutsideCandidateSet: number;
+        /** Number of routing decisions aggregated before sampling records. */
+        totalRecords: number;
+        /** Most recent bounded sample retained for offline inspection. */
         records: ProxyAnalysisRoutingRecord[];
     };
     accounts: ProxyAnalysisAccount[];

package/dist/lib/utils/errorHandling.d.ts

@@ -70,6 +70,7 @@ export declare class NeuroLinkError extends Error {
     readonly category: ErrorCategory;
     readonly severity: ErrorSeverity;
     readonly retriable: boolean;
+    readonly retryAfterMs?: number;
     readonly context: Record<string, unknown>;
     readonly timestamp: Date;
     readonly toolName?: string;
@@ -80,6 +81,7 @@ export declare class NeuroLinkError extends Error {
         category: ErrorCategory;
         severity: ErrorSeverity;
         retriable: boolean;
+        retryAfterMs?: number;
         context?: Record<string, unknown>;
         originalError?: Error;
         toolName?: string;

package/dist/lib/utils/errorHandling.js

@@ -87,6 +87,7 @@ export class NeuroLinkError extends Error {
     category;
     severity;
     retriable;
+    retryAfterMs;
     context;
     timestamp;
     toolName;
@@ -98,6 +99,7 @@ export class NeuroLinkError extends Error {
         this.category = options.category;
         this.severity = options.severity;
         this.retriable = options.retriable;
+        this.retryAfterMs = options.retryAfterMs;
         this.context = options.context || {};
         this.timestamp = new Date();
         this.toolName = options.toolName;

package/dist/lib/utils/pdfProcessor.js

@@ -91,14 +91,14 @@ const PDF_PROVIDER_CONFIGS = {
     litellm: {
         maxSizeMB: 10,
         maxPages: 100,
-        supportsNative: true,
+        supportsNative: false, // LiteLLM is a proxy — underlying model may not support native PDF; default to safe text extraction
         requiresCitations: false,
         apiType: "files-api",
     },
     "openai-compatible": {
         maxSizeMB: 10,
         maxPages: 100,
-        supportsNative: false, // LiteLLM is a proxy — underlying model may not support native PDF; default to safe text extraction
+        supportsNative: false,
         requiresCitations: false,
         apiType: "files-api",
     },

package/dist/lib/utils/providerRetry.d.ts

@@ -18,6 +18,10 @@ import { type Span } from "@opentelemetry/api";
 export declare const MAX_PROVIDER_RETRIES = 2;
 /** Base delay in ms for exponential backoff between retries. */
 export declare const BASE_RETRY_DELAY_MS = 1000;
+/** Minimum delay in ms when a retryable response provides no retry timing. */
+export declare const NO_HINT_FLOOR_MS = 10000;
+/** Maximum server-requested retry delay honored by provider retries. */
+export declare const MAX_RETRY_AFTER_MS = 120000;
 /**
  * Check whether an error thrown by the AI SDK is retryable.
  *
@@ -38,4 +42,4 @@ export declare function getErrorStatusCode(error: unknown): number | undefined;
  * @param label      - A human-readable label for log messages (e.g. "generateText", "streamText")
  * @returns The result of the operation
  */
-export declare function withProviderRetry<T>(operation: () => Promise<T>, span: Span, label: string): Promise<T>;
+export declare function withProviderRetry<T>(operation: () => Promise<T>, span: Span | undefined, label: string, sleep?: (delayMs: number) => Promise<void>): Promise<T>;

package/dist/lib/utils/providerRetry.js

@@ -14,12 +14,19 @@
  * @module utils/providerRetry
  */
 import {} from "@opentelemetry/api";
+import { NeuroLinkError } from "./errorHandling.js";
 import { logger } from "./logger.js";
 import { APICallError } from "./generationErrors.js";
+import { parseRetryAfterMs } from "./retryAfter.js";
 /** Maximum number of retry attempts after the initial call (total = 1 + MAX_PROVIDER_RETRIES). */
 export const MAX_PROVIDER_RETRIES = 2;
 /** Base delay in ms for exponential backoff between retries. */
 export const BASE_RETRY_DELAY_MS = 1000;
+/** Minimum delay in ms when a retryable response provides no retry timing. */
+export const NO_HINT_FLOOR_MS = 10_000;
+/** Maximum server-requested retry delay honored by provider retries. */
+export const MAX_RETRY_AFTER_MS = 120_000;
+const sleepWithTimeout = (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs));
 /**
  * Check whether an error thrown by the AI SDK is retryable.
  *
@@ -32,6 +39,9 @@ export function isRetryableProviderError(error) {
     if (APICallError.isInstance(error)) {
         return error.isRetryable;
     }
+    if (error instanceof NeuroLinkError) {
+        return error.retriable;
+    }
     // Fallback: duck-type for status codes on errors that aren't APICallError
     if (error && typeof error === "object" && "statusCode" in error) {
         const statusCode = error.statusCode;
@@ -51,6 +61,18 @@ export function getErrorStatusCode(error) {
     }
     return undefined;
 }
+function getRetryAfterMs(error) {
+    if (APICallError.isInstance(error) && error.responseHeaders) {
+        const parsedDelay = parseRetryAfterMs(error.responseHeaders);
+        if (parsedDelay !== undefined) {
+            return parsedDelay;
+        }
+    }
+    if (error instanceof NeuroLinkError && error.retryAfterMs !== undefined) {
+        return error.retryAfterMs;
+    }
+    return undefined;
+}
 /**
  * Execute a provider call with instrumented retry logic.
  *
@@ -59,12 +81,12 @@ export function getErrorStatusCode(error) {
  * @param label      - A human-readable label for log messages (e.g. "generateText", "streamText")
  * @returns The result of the operation
  */
-export async function withProviderRetry(operation, span, label) {
+export async function withProviderRetry(operation, span, label, sleep = sleepWithTimeout) {
     for (let attempt = 0; attempt <= MAX_PROVIDER_RETRIES; attempt++) {
         try {
             const result = await operation();
             // Record how many attempts it took on the span
-            span.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+            span?.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
             if (attempt > 0) {
                 logger.info(`[providerRetry] ${label} succeeded after ${attempt + 1} attempts`);
             }
@@ -76,9 +98,9 @@ export async function withProviderRetry(operation, span, label) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             if (!retryable || attempt === MAX_PROVIDER_RETRIES) {
                 // Record failure details before re-throwing
-                span.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+                span?.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
                 if (attempt > 0) {
-                    span.setAttribute("gen_ai.provider.retries_exhausted", true);
+                    span?.setAttribute("gen_ai.provider.retries_exhausted", true);
                 }
                 logger.warn(`[providerRetry] ${label} failed (non-retryable or retries exhausted)`, {
                     attempt: attempt + 1,
@@ -88,10 +110,14 @@ export async function withProviderRetry(operation, span, label) {
                 });
                 throw error;
             }
-            // Calculate exponential backoff delay
-            const delay = BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
+            const retryAfterMs = getRetryAfterMs(error);
+            const boundedRetryAfterMs = retryAfterMs === undefined
+                ? undefined
+                : Math.min(MAX_RETRY_AFTER_MS, Math.max(0, retryAfterMs));
+            const delay = boundedRetryAfterMs ??
+                Math.max(BASE_RETRY_DELAY_MS * Math.pow(2, attempt), NO_HINT_FLOOR_MS);
             // Record retry event on the OTel span
-            span.addEvent("gen_ai.provider.retry", {
+            span?.addEvent("gen_ai.provider.retry", {
                 "retry.attempt": attempt + 1,
                 "retry.delay_ms": delay,
                 ...(statusCode !== undefined && { "retry.status_code": statusCode }),
@@ -104,7 +130,7 @@ export async function withProviderRetry(operation, span, label) {
                 statusCode,
                 error: errorMessage,
             });
-            await new Promise((r) => setTimeout(r, delay));
+            await sleep(delay);
         }
     }
     // This should never be reached due to the throw inside the loop,

package/dist/lib/utils/retryAfter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parse standard and commonly used rate-limit response headers.
+ *
+ * @returns The requested delay in milliseconds, or undefined when the
+ * response does not provide a usable rate-limit delay.
+ */
+export declare function parseRetryAfterMs(headers: Pick<Headers, "get"> | Readonly<Record<string, string>>): number | undefined;

package/dist/lib/utils/retryAfter.js

@@ -0,0 +1,44 @@
+function getHeader(headers, headerName) {
+    if ("get" in headers && typeof headers.get === "function") {
+        return headers.get(headerName);
+    }
+    const normalizedHeaderName = headerName.toLowerCase();
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === normalizedHeaderName) {
+            return value;
+        }
+    }
+    return null;
+}
+/**
+ * Parse standard and commonly used rate-limit response headers.
+ *
+ * @returns The requested delay in milliseconds, or undefined when the
+ * response does not provide a usable rate-limit delay.
+ */
+export function parseRetryAfterMs(headers) {
+    const retryAfter = getHeader(headers, "Retry-After");
+    if (retryAfter) {
+        const seconds = parseInt(retryAfter, 10);
+        if (!Number.isNaN(seconds)) {
+            return Math.max(0, seconds * 1000);
+        }
+        const retryDate = new Date(retryAfter);
+        if (!Number.isNaN(retryDate.getTime())) {
+            return Math.max(0, retryDate.getTime() - Date.now());
+        }
+    }
+    const rateLimitReset = getHeader(headers, "X-RateLimit-Reset");
+    if (rateLimitReset) {
+        const resetTimestamp = parseInt(rateLimitReset, 10);
+        if (!Number.isNaN(resetTimestamp)) {
+            const resetTime = resetTimestamp > 1e12 ? resetTimestamp : resetTimestamp * 1000;
+            return Math.max(0, resetTime - Date.now());
+        }
+    }
+    if (getHeader(headers, "X-RateLimit-Remaining") === "0") {
+        return 1000;
+    }
+    return undefined;
+}
+//# sourceMappingURL=retryAfter.js.map

package/dist/mcp/httpRateLimiter.js

@@ -4,6 +4,7 @@
  * Provides fault tolerance and prevents server overload
  */
 import { mcpLogger } from "../utils/logger.js";
+import { parseRetryAfterMs } from "../utils/retryAfter.js";
 import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
 import { getActiveTraceContext } from "../telemetry/traceContext.js";
 /**
@@ -176,48 +177,40 @@ export class HTTPRateLimiter {
      * @returns Wait time in milliseconds, or 0 if no rate limit headers found
      */
     handleRateLimitResponse(headers) {
-        // Check for Retry-After header (standard HTTP 429 response)
+        const parsedWaitTimeMs = parseRetryAfterMs(headers);
+        // Keep the existing source-specific logs while delegating delay parsing.
         const retryAfter = headers.get("Retry-After");
-        if (retryAfter) {
-            // Retry-After can be either a number of seconds or an HTTP-date
+        if (retryAfter && parsedWaitTimeMs !== undefined) {
             const seconds = parseInt(retryAfter, 10);
             if (!isNaN(seconds)) {
-                // It's a number of seconds
-                const waitTimeMs = seconds * 1000;
                 mcpLogger.info(`[HTTPRateLimiter] Server requested retry after ${seconds} seconds`);
-                return waitTimeMs;
+                return parsedWaitTimeMs;
             }
             else {
-                // Try to parse as HTTP-date
                 const retryDate = new Date(retryAfter);
                 if (!isNaN(retryDate.getTime())) {
-                    const waitTimeMs = Math.max(0, retryDate.getTime() - Date.now());
-                    mcpLogger.info(`[HTTPRateLimiter] Server requested retry at ${retryDate.toISOString()} (${waitTimeMs}ms)`);
-                    return waitTimeMs;
+                    mcpLogger.info(`[HTTPRateLimiter] Server requested retry at ${retryDate.toISOString()} (${parsedWaitTimeMs}ms)`);
+                    return parsedWaitTimeMs;
                 }
             }
         }
         // Check for X-RateLimit-Reset header (common non-standard header)
         const rateLimitReset = headers.get("X-RateLimit-Reset");
-        if (rateLimitReset) {
+        if (rateLimitReset && parsedWaitTimeMs !== undefined) {
             const resetTimestamp = parseInt(rateLimitReset, 10);
             if (!isNaN(resetTimestamp)) {
-                // Could be Unix timestamp (seconds) or milliseconds
                 const resetTime = resetTimestamp > 1e12 ? resetTimestamp : resetTimestamp * 1000;
-                const waitTimeMs = Math.max(0, resetTime - Date.now());
-                mcpLogger.info(`[HTTPRateLimiter] Rate limit resets at ${new Date(resetTime).toISOString()} (${waitTimeMs}ms)`);
-                return waitTimeMs;
+                mcpLogger.info(`[HTTPRateLimiter] Rate limit resets at ${new Date(resetTime).toISOString()} (${parsedWaitTimeMs}ms)`);
+                return parsedWaitTimeMs;
             }
         }
         // Check for X-RateLimit-Remaining header
         const remaining = headers.get("X-RateLimit-Remaining");
-        if (remaining === "0") {
-            // No remaining requests, use default backoff
-            const defaultBackoffMs = 1000;
-            mcpLogger.info(`[HTTPRateLimiter] Rate limit exhausted, using default backoff: ${defaultBackoffMs}ms`);
-            return defaultBackoffMs;
+        if (remaining === "0" && parsedWaitTimeMs !== undefined) {
+            mcpLogger.info(`[HTTPRateLimiter] Rate limit exhausted, using default backoff: ${parsedWaitTimeMs}ms`);
+            return parsedWaitTimeMs;
         }
-        return 0;
+        return parsedWaitTimeMs ?? 0;
     }
     /**
      * Get the number of remaining tokens

package/dist/proxy/proxyAnalysis.js

@@ -20,6 +20,8 @@ const ROUTING_MODES = new Set(PROXY_ACCOUNT_ROUTING_MODES);
 const ROUTING_REASONS = new Set(PROXY_ACCOUNT_ROUTING_REASONS);
 const ROUTING_ACCOUNT_TYPES = new Set(PROXY_ACCOUNT_TYPES);
 const COOLING_REASONS = new Set(ACCOUNT_COOLING_REASONS);
+const MAX_RETAINED_ROUTING_RECORDS = 200;
+const MAX_ROUTING_RECORDS_BEFORE_COMPACTION = MAX_RETAINED_ROUTING_RECORDS * 2;
 function isContainedPath(root, candidate) {
     const candidateRelative = relative(root, candidate);
     return (candidateRelative.length > 0 &&
@@ -338,7 +340,8 @@ function summarizeRouting(finalRequests) {
     const modes = {};
     const selectionReasons = {};
     const initialAccounts = {};
-    const records = [];
+    const retainedRecords = [];
+    let totalRecords = 0;
     let finalAccountChanges = 0;
     let finalOutsideCandidateSet = 0;
     for (const [requestId, request] of finalRequests) {
@@ -357,21 +360,36 @@ function summarizeRouting(finalRequests) {
         else if (decision.initialAccount !== request.account) {
             finalAccountChanges += 1;
         }
-        records.push({
-            requestId,
-            timestamp: request.timestamp,
-            responseStatus: request.status,
-            finalAccount: request.account,
-            finalAccountType: request.accountType,
-            decision,
+        totalRecords += 1;
+        retainedRecords.push({
+            record: {
+                requestId,
+                timestamp: request.timestamp,
+                responseStatus: request.status,
+                finalAccount: request.account,
+                finalAccountType: request.accountType,
+                decision,
+            },
+            timestampMs: Date.parse(request.timestamp),
+            sequence: totalRecords,
         });
+        if (retainedRecords.length > MAX_ROUTING_RECORDS_BEFORE_COMPACTION) {
+            retainedRecords.sort((left, right) => left.timestampMs - right.timestampMs ||
+                left.sequence - right.sequence);
+            retainedRecords.splice(0, retainedRecords.length - MAX_RETAINED_ROUTING_RECORDS);
+        }
     }
+    retainedRecords.sort((left, right) => left.timestampMs - right.timestampMs || left.sequence - right.sequence);
+    const records = retainedRecords
+        .slice(-MAX_RETAINED_ROUTING_RECORDS)
+        .map(({ record }) => record);
     return {
         modes,
         selectionReasons,
         initialAccounts,
         finalAccountChanges,
         finalOutsideCandidateSet,
+        totalRecords,
         records,
     };
 }
@@ -704,7 +722,7 @@ export async function analyzeProxyLogs(options) {
             attempts: totalAttempts > 0,
             attemptLatency: attemptLatency.length > 0,
             cacheUsage: finalSummary.cache.requestsWithUsage > 0,
-            routingDecisions: routingSummary.records.length > 0,
+            routingDecisions: routingSummary.totalRecords > 0,
         },
         dataQuality: {
             linesRead,

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

@@ -12,7 +12,7 @@
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
-import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
 /** Resolve the configured primary's stable key to its current index in the
  *  request's enabledAccounts list. Returns 0 (insertion-order fallback) when
  *  no key is configured or the key cannot be matched (account disabled/
@@ -85,6 +85,19 @@ declare function seedRuntimeQuotasFromDisk(accounts: ProxyPassthroughAccount[]):
  * last resort.
  */
 declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number): ProxyPassthroughAccount[];
+declare function buildRoutingDecision(args: {
+    accounts: ProxyPassthroughAccount[];
+    orderedAccounts: ProxyPassthroughAccount[];
+    metricsByKey: ReadonlyMap<string, ProxyAccountSortMetrics>;
+    evaluatedAt: number;
+    strategy: "round-robin" | "fill-first";
+    primaryKey: string | undefined;
+    quotaRoutingEnabled: boolean;
+    quotaOrdered: boolean;
+    sessionSoftLimit: number;
+    sessionResetToleranceMs: number;
+    rotationOffset: number;
+}): ProxyAccountRoutingDecision | undefined;
 declare function trackUpstreamReadableStream(source: ReadableStream<Uint8Array>): {
     stream: ReadableStream<Uint8Array>;
     outcome: Promise<StreamTerminalOutcome>;
@@ -279,7 +292,8 @@ export declare const __testHooks: {
     getStreamFailureDetails: typeof getStreamFailureDetails;
     trackUpstreamReadableStream: typeof trackUpstreamReadableStream;
     orderAccountsByQuota: typeof orderAccountsByQuota;
-    buildQuotaRoutingDecision: (accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number) => ProxyAccountRoutingDecision;
+    buildQuotaRoutingDecision: (accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number) => ProxyAccountRoutingDecision | undefined;
+    buildRoutingDecision: typeof buildRoutingDecision;
     resetEpochToMs: typeof resetEpochToMs;
     seedRuntimeQuotasFromDisk: typeof seedRuntimeQuotasFromDisk;
     reconcileEligibleAccountRuntimeState: typeof reconcileEligibleAccountRuntimeState;