@juspay/neurolink 10.12.4 → 10.12.6

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,

package/dist/types/processor.d.ts

@@ -774,6 +774,21 @@ export type ArchiveDecompressionResult = {
  * perfectly well-formed, and telling the user it is damaged would send them to
  * re-create a file that was never broken.
  */
+/**
+ * The slice of an adm-zip entry the bounded reader depends on.
+ *
+ * Structural rather than adm-zip's own `IZipEntry` so the reader states what it
+ * actually needs — the compressed bytes and the header fields it refuses to
+ * trust — instead of importing a library type it would then have to satisfy in
+ * full when building a test double.
+ */
+export type BoundedZipEntry = {
+    getCompressedData: () => Buffer;
+    header: {
+        method: number;
+        crc: number;
+    };
+};
 export type ArchiveEntryReadResult = {
     readonly status: "ok";
     readonly buffer: Buffer;

package/dist/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "10.12.4",
+  "version": "10.12.6",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -163,7 +163,7 @@
     "test:system-messages": "npx tsx test/continuous-test-suite-system-messages.ts",
     "test:test-stubs": "npx tsx test/continuous-test-suite-test-stubs.ts",
     "test:tool-routing-semantic": "npx tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:proxy-usage-refresh && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-structured && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding && pnpm run test:archive:security",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:file-detector-extension && pnpm run test:file-detector-magic-bytes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:litellm-context && pnpm run test:dedup-execute-map && pnpm run test:step-budget-guard && pnpm run test:agent-plumbing && pnpm run test:tool-execution-recorder && pnpm run test:proxy-terminal-errors && pnpm run test:proxy-usage-refresh && pnpm run test:system-messages && pnpm run test:tool-routing-semantic && pnpm run test:anthropic-tools-policy && pnpm run test:anthropic-structured && pnpm run test:sagemaker-tools && pnpm run test:anthropic-multimodal && pnpm run test:excel-interop && pnpm run test:model-capabilities && pnpm run test:agent-runtime:vitest && pnpm run test:agent-delegation && pnpm run test:retry-after:vitest && pnpm run test:sampling-params && pnpm run test:structured-recovery && pnpm run test:prompt-redaction && pnpm run test:mcp-result-cache && pnpm run test:test-stubs && pnpm run test:model-not-found-retryable && pnpm run test:websearch-grounding && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:proxy:vitest",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run": "",
@@ -234,6 +234,7 @@
     "test:proxy-terminal-errors": "npx tsx test/continuous-test-suite-proxy-terminal-errors.ts",
     "test:proxy-limit-headers": "npx tsx test/continuous-test-suite-proxy-limit-headers.ts",
     "test:proxy-usage-refresh": "npx tsx test/continuous-test-suite-proxy-usage-refresh.ts",
+    "test:proxy:vitest": "pnpm exec vitest run test/proxyAnalysis.test.ts test/proxyConfigHotReload.test.ts test/proxyObservabilityFoundation.test.ts test/proxyReliabilityHardening.test.ts test/proxyReplay.test.ts test/proxyRollingWorkerHandoff.test.ts test/proxyTestIsolation.test.ts test/proxyUpdaterFallback.test.ts test/proxyUsageStatsPersistence.test.ts",
     "test:anthropic-limit-capture": "npx tsx test/continuous-test-suite-anthropic-limit-capture.ts",
     "test:audio": "npx tsx test/continuous-test-suite-audio.ts",
     "test:file-formats": "npx tsx test/continuous-test-suite-file-formats.ts",
@@ -246,7 +247,8 @@
     "test:structured-recovery": "npx tsx test/continuous-test-suite-structured-recovery.ts",
     "test:prompt-redaction": "npx tsx test/continuous-test-suite-prompt-redaction.ts",
     "test:mcp-result-cache": "npx tsx test/continuous-test-suite-mcp-result-cache.ts",
-    "test:archive:security": "npx tsx test/continuous-test-suite-archive-security.ts"
+    "test:archive:security": "npx tsx test/continuous-test-suite-archive-security.ts",
+    "test:office:security": "npx tsx test/continuous-test-suite-office-security.ts"
   },
   "files": [
     "dist",