@juspay/neurolink 10.8.5 → 10.8.7

package/dist/core/baseProvider.js

@@ -166,7 +166,11 @@ export class BaseProvider {
             timestamp: Date.now(),
         });
         // ===== EARLY MULTIMODAL DETECTION =====
-        const hasFileInput = !!options.input?.files?.length || !!options.input?.videoFiles?.length;
+        // #1259: audioFiles was missing here while videoFiles was present, so an
+        // audio-only stream skipped this branch entirely.
+        const hasFileInput = !!options.input?.files?.length ||
+            !!options.input?.videoFiles?.length ||
+            !!options.input?.audioFiles?.length;
         if (hasFileInput) {
             // ===== VIDEO ANALYSIS DETECTION =====
             // Check if video frames are present and handle with fake streaming

package/dist/lib/core/baseProvider.js

@@ -166,7 +166,11 @@ export class BaseProvider {
             timestamp: Date.now(),
         });
         // ===== EARLY MULTIMODAL DETECTION =====
-        const hasFileInput = !!options.input?.files?.length || !!options.input?.videoFiles?.length;
+        // #1259: audioFiles was missing here while videoFiles was present, so an
+        // audio-only stream skipped this branch entirely.
+        const hasFileInput = !!options.input?.files?.length ||
+            !!options.input?.videoFiles?.length ||
+            !!options.input?.audioFiles?.length;
         if (hasFileInput) {
             // ===== VIDEO ANALYSIS DETECTION =====
             // Check if video frames are present and handle with fake streaming

package/dist/lib/providers/googleVertex/client.d.ts

@@ -141,6 +141,26 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Validate stream options
      */
     private validateStreamOptionsOnly;
+    /**
+     * Preprocess file input before routing to the native SDKs.
+     *
+     * BaseProvider runs this via `buildMultimodalMessagesArray`, but Vertex
+     * overrides both `generate()` and `executeStream()` to reach the native
+     * @google/genai / @anthropic-ai/vertex-sdk clients directly, so neither
+     * inherits it. Without this the file content never reaches the model and
+     * the reply is an entirely plausible "no document is attached" — a silent
+     * wrong answer rather than an error.
+     *
+     * #1258: only `generate()` used to call this, so the same document that
+     * `generate()` read back correctly came back as "no documents attached"
+     * through `stream()`. Sharing one method is what keeps the two paths from
+     * drifting apart again.
+     *
+     * #1259: the alias fold has to happen *before* the `files` check, or
+     * requests carrying only `audioFiles`/`videoFiles` look empty here and skip
+     * preprocessing entirely.
+     */
+    private preprocessNativeFileInput;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodType<unknown> | Schema<unknown>): Promise<StreamResult>;
     /**
      * Emit `stream:end` so the Pipeline B observability listener creates a

package/dist/lib/providers/googleVertex/client.js

@@ -14,7 +14,7 @@ import { AuthenticationError, InvalidModelError, NetworkError, ProviderError, Ra
 import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
 import { applyVertexAnthropicCacheBreakpoints } from "../../utils/anthropicCacheBreakpoints.js";
 import { FileDetector } from "../../utils/fileDetector.js";
-import { processUnifiedFilesArray } from "../../utils/messageBuilder.js";
+import { mergeMediaFileAliases, processUnifiedFilesArray, } from "../../utils/messageBuilder.js";
 import { logger } from "../../utils/logger.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, toVertexAnthropicModelId, } from "../../utils/modelDetection.js";
 import { detectImageMimeType } from "../../utils/imageDetection.js";
@@ -868,6 +868,40 @@ export class GoogleVertexProvider extends BaseProvider {
     validateStreamOptionsOnly(options) {
         this.validateStreamOptions(options);
     }
+    /**
+     * Preprocess file input before routing to the native SDKs.
+     *
+     * BaseProvider runs this via `buildMultimodalMessagesArray`, but Vertex
+     * overrides both `generate()` and `executeStream()` to reach the native
+     * @google/genai / @anthropic-ai/vertex-sdk clients directly, so neither
+     * inherits it. Without this the file content never reaches the model and
+     * the reply is an entirely plausible "no document is attached" — a silent
+     * wrong answer rather than an error.
+     *
+     * #1258: only `generate()` used to call this, so the same document that
+     * `generate()` read back correctly came back as "no documents attached"
+     * through `stream()`. Sharing one method is what keeps the two paths from
+     * drifting apart again.
+     *
+     * #1259: the alias fold has to happen *before* the `files` check, or
+     * requests carrying only `audioFiles`/`videoFiles` look empty here and skip
+     * preprocessing entirely.
+     */
+    async preprocessNativeFileInput(options) {
+        if (options.input) {
+            mergeMediaFileAliases(options.input);
+        }
+        if (!options.input?.files?.length) {
+            return;
+        }
+        try {
+            // Mutates options.input.text / .images / .pdfFiles in place.
+            await processUnifiedFilesArray(options, 100 * 1024 * 1024, this.providerName);
+        }
+        catch (fileError) {
+            logger.warn(`[GoogleVertex] processUnifiedFilesArray threw, continuing without file content: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+        }
+    }
     async executeStream(options, _analysisSchema) {
         // ALL models now use native SDKs - no more @ai-sdk/google-vertex dependency
         const modelName = options.model || this.modelName || getDefaultVertexModel();
@@ -889,6 +923,9 @@ export class GoogleVertexProvider extends BaseProvider {
             // Tool filter (a0269210): trust options.tools — caller (BaseProvider.stream)
             // already merged MCP/built-in tools and applied any enabledToolNames filter.
             const optionTools = options.tools || {};
+            // #1258: stream() must run the same file preprocessing generate()
+            // does, or attached files are dropped on this path alone.
+            await this.preprocessNativeFileInput(options);
             // Emit a `neurolink.message.build` span for the native stream path
             // so observability tooling sees the same hierarchy it sees on
             // Pipeline A. Without this, test:tracing's "Message Build Span"
@@ -5742,20 +5779,7 @@ export class GoogleVertexProvider extends BaseProvider {
             const baseTools = !options.disableTools
                 ? await this.getToolsForStream(options)
                 : {};
-            // Process the unified `input.files` array before routing to the
-            // native SDK. BaseProvider.generate() runs this preprocessing via
-            // buildMultimodalMessagesArray, but Vertex's override skips it,
-            // which would otherwise drop text-file content (and the
-            // mimetype-hint contract) on the floor. Mutates options.input.text /
-            // options.input.images / options.input.pdfFiles in place.
-            if (options.input?.files && options.input.files.length > 0) {
-                try {
-                    await processUnifiedFilesArray(options, 100 * 1024 * 1024, this.providerName);
-                }
-                catch (fileError) {
-                    logger.warn(`[GoogleVertex] processUnifiedFilesArray threw, continuing without file content: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
-                }
-            }
+            await this.preprocessNativeFileInput(options);
             // Emit a `neurolink.message.build` span so observability tooling
             // sees the message-construction phase even on the native (Pipeline B)
             // Vertex path. Pipeline A normally produces this via MessageBuilder;

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

@@ -1,12 +1,22 @@
 import type { FallbackEntry, ModelMapping, ProxyRoutingConfig, RouteResult } from "../types/index.js";
+/** Default and accepted range for concurrent upstream requests per OAuth account. */
+export declare const MIN_MAX_INFLIGHT_PER_ACCOUNT = 1;
+export declare const MAX_MAX_INFLIGHT_PER_ACCOUNT = 20;
+export declare const DEFAULT_MAX_INFLIGHT_PER_ACCOUNT = 2;
 export declare class ModelRouter {
     private readonly mappings;
     private readonly passthrough;
     private readonly fallback;
+    private readonly autoFallback;
+    private readonly maxInflightPerAccount;
     constructor(config: ProxyRoutingConfig);
     resolve(requestedModel: string): RouteResult;
     isClaudeTarget(requestedModel: string): boolean;
     getFallbackChain(): FallbackEntry[];
+    /** Whether translation-layer auto-provider fallback is explicitly enabled. */
+    isAutoFallbackEnabled(): boolean;
+    /** Maximum concurrent upstream requests admitted for each OAuth account. */
+    getMaxInflightPerAccount(): number;
     /** Return the raw model mapping entries (used by /v1/models). */
     getModelMappings(): ModelMapping[];
     /** Return models configured for passthrough (used by /v1/models). */

package/dist/lib/proxy/modelRouter.js

@@ -1,11 +1,20 @@
+/** Default and accepted range for concurrent upstream requests per OAuth account. */
+export const MIN_MAX_INFLIGHT_PER_ACCOUNT = 1;
+export const MAX_MAX_INFLIGHT_PER_ACCOUNT = 20;
+export const DEFAULT_MAX_INFLIGHT_PER_ACCOUNT = 2;
 export class ModelRouter {
     mappings;
     passthrough;
     fallback;
+    autoFallback;
+    maxInflightPerAccount;
     constructor(config) {
         this.mappings = new Map(config.modelMappings.map((m) => [m.from, m]));
         this.passthrough = new Set(config.passthroughModels ?? []);
         this.fallback = config.fallbackChain;
+        this.autoFallback = config.autoFallback === true;
+        this.maxInflightPerAccount =
+            config.maxInflightPerAccount ?? DEFAULT_MAX_INFLIGHT_PER_ACCOUNT;
     }
     resolve(requestedModel) {
         const mapping = this.mappings.get(requestedModel);
@@ -29,6 +38,14 @@ export class ModelRouter {
     getFallbackChain() {
         return this.fallback;
     }
+    /** Whether translation-layer auto-provider fallback is explicitly enabled. */
+    isAutoFallbackEnabled() {
+        return this.autoFallback;
+    }
+    /** Maximum concurrent upstream requests admitted for each OAuth account. */
+    getMaxInflightPerAccount() {
+        return this.maxInflightPerAccount;
+    }
     /** Return the raw model mapping entries (used by /v1/models). */
     getModelMappings() {
         return Array.from(this.mappings.values());

package/dist/lib/proxy/proxyConfig.js

@@ -12,6 +12,7 @@
  */
 import { readFile } from "node:fs/promises";
 import { extname } from "node:path";
+import { MAX_MAX_INFLIGHT_PER_ACCOUNT, MIN_MAX_INFLIGHT_PER_ACCOUNT, } from "./modelRouter.js";
 import { logger } from "../utils/logger.js";
 // ---------------------------------------------------------------------------
 // Environment variable resolution
@@ -237,6 +238,24 @@ export function validateProxyConfig(config) {
             normalizedQuotaRouting !== "false") {
             errors.push("routing.quota-routing must be a boolean");
         }
+        const rawAutoFallback = routing["auto-fallback"] ?? routing.autoFallback;
+        const normalizedAutoFallback = typeof rawAutoFallback === "string"
+            ? rawAutoFallback.trim().toLowerCase()
+            : undefined;
+        if (rawAutoFallback !== undefined &&
+            typeof rawAutoFallback !== "boolean" &&
+            normalizedAutoFallback !== "true" &&
+            normalizedAutoFallback !== "false") {
+            errors.push("routing.auto-fallback must be a boolean");
+        }
+        const rawMaxInflight = routing["max-inflight-per-account"] ?? routing.maxInflightPerAccount;
+        if (rawMaxInflight !== undefined &&
+            (typeof rawMaxInflight !== "number" ||
+                !Number.isInteger(rawMaxInflight) ||
+                rawMaxInflight < MIN_MAX_INFLIGHT_PER_ACCOUNT ||
+                rawMaxInflight > MAX_MAX_INFLIGHT_PER_ACCOUNT)) {
+            errors.push("routing.max-inflight-per-account must be an integer between 1 and 20");
+        }
         const rawSessionSoftLimit = routing["session-soft-limit"] ?? routing.sessionSoftLimit;
         if (rawSessionSoftLimit !== undefined) {
             const sessionSoftLimit = Number(rawSessionSoftLimit);
@@ -322,6 +341,8 @@ function warnPlaintextApiKeys(accounts) {
  * - `strategy` ("round-robin" | "fill-first")
  * - `model-mappings` / `modelMappings` — array of {from, to, provider}
  * - `fallback-chain` / `fallbackChain` — array of {provider, model}
+ * - `auto-fallback` / `autoFallback` — opt in to an unspecified provider
+ * - `max-inflight-per-account` / `maxInflightPerAccount` — concurrency cap
  * - `passthroughModels` / `passthrough-models` — array of model IDs
  * - `quota-routing` / `quotaRouting` — quota-aware fill-first ordering
  * - `session-soft-limit` / `sessionSoftLimit` — proactive handoff threshold
@@ -396,6 +417,31 @@ function parseRoutingConfig(raw) {
             logger.warn(`[proxy-config] Ignoring routing.quotaRouting: expected boolean, got ${typeof rawQuotaRouting}`);
         }
     }
+    const rawAutoFallback = raw["auto-fallback"] ?? raw.autoFallback;
+    if (rawAutoFallback !== undefined) {
+        if (typeof rawAutoFallback === "boolean") {
+            result.autoFallback = rawAutoFallback;
+        }
+        else if (typeof rawAutoFallback === "string" &&
+            ["true", "false"].includes(rawAutoFallback.trim().toLowerCase())) {
+            result.autoFallback = rawAutoFallback.trim().toLowerCase() === "true";
+        }
+        else {
+            logger.warn(`[proxy-config] Ignoring routing.autoFallback: expected boolean, got ${typeof rawAutoFallback}`);
+        }
+    }
+    const rawMaxInflight = raw["max-inflight-per-account"] ?? raw.maxInflightPerAccount;
+    if (rawMaxInflight !== undefined) {
+        if (typeof rawMaxInflight === "number" &&
+            Number.isInteger(rawMaxInflight) &&
+            rawMaxInflight >= MIN_MAX_INFLIGHT_PER_ACCOUNT &&
+            rawMaxInflight <= MAX_MAX_INFLIGHT_PER_ACCOUNT) {
+            result.maxInflightPerAccount = rawMaxInflight;
+        }
+        else {
+            logger.warn(`[proxy-config] Ignoring routing.maxInflightPerAccount: expected integer between 1 and 20, got ${String(rawMaxInflight)}`);
+        }
+    }
     const rawSessionSoftLimit = raw["session-soft-limit"] ?? raw.sessionSoftLimit;
     if (rawSessionSoftLimit !== undefined) {
         const sessionSoftLimit = Number(rawSessionSoftLimit);

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

@@ -32,6 +32,7 @@ export declare class RollingWorkerSupervisor {
     private spawnCandidate;
     private flushQueuedSockets;
     private transferSocket;
+    private maybeDrainWorker;
     private handleTransferFailure;
     private rejectSocket;
     private describeTransferError;

package/dist/lib/proxy/rollingWorkerSupervisor.js

@@ -287,21 +287,19 @@ export class RollingWorkerSupervisor {
                     generation,
                     version: expectedVersion,
                     dispose,
+                    pendingTransfers: 0,
+                    drainRequested: false,
                 };
                 this.active = activated;
                 this.candidate = null;
                 this.flushQueuedSockets();
                 if (previous) {
                     this.draining.set(previous.generation, previous);
-                    try {
-                        previous.handle.sendControl({
-                            type: "proxy-worker:drain",
-                            generation: previous.generation,
-                        });
-                    }
-                    catch {
-                        previous.handle.terminate("SIGTERM");
-                    }
+                    // A worker can still own socket transfers accepted before this
+                    // activation. Draining it before their IPC commits makes those
+                    // clients fail even though the replacement is healthy.
+                    previous.drainRequested = true;
+                    this.maybeDrainWorker(previous);
                 }
                 this.options.log?.(`[proxy-supervisor] activated generation=${generation} pid=${handle.pid} version=${expectedVersion}`);
                 this.publishState();
@@ -340,6 +338,8 @@ export class RollingWorkerSupervisor {
                 handle,
                 generation,
                 version: expectedVersion,
+                pendingTransfers: 0,
+                drainRequested: false,
                 expectedVersion,
                 activationRequested: false,
                 dispose,
@@ -362,15 +362,41 @@ export class RollingWorkerSupervisor {
         }
     }
     transferSocket(worker, socket) {
+        worker.pendingTransfers += 1;
+        let settled = false;
+        const complete = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            worker.pendingTransfers = Math.max(0, worker.pendingTransfers - 1);
+            if (error) {
+                this.handleTransferFailure(worker, socket, error);
+            }
+            this.maybeDrainWorker(worker);
+        };
         try {
-            worker.handle.sendSocket(worker.generation, socket, (error) => {
-                if (error) {
-                    this.handleTransferFailure(worker, socket, error);
-                }
-            });
+            worker.handle.sendSocket(worker.generation, socket, complete);
         }
         catch (error) {
-            this.handleTransferFailure(worker, socket, error);
+            complete(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    maybeDrainWorker(worker) {
+        if (!worker.drainRequested ||
+            worker.pendingTransfers > 0 ||
+            !this.draining.has(worker.generation)) {
+            return;
+        }
+        worker.drainRequested = false;
+        try {
+            worker.handle.sendControl({
+                type: "proxy-worker:drain",
+                generation: worker.generation,
+            });
+        }
+        catch {
+            worker.handle.terminate("SIGTERM");
         }
     }
     handleTransferFailure(worker, socket, error) {

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

@@ -4,12 +4,14 @@ export declare function inferClaudeProxyModelTier(modelName: string): ClaudeProx
  * Build a translation plan for a Claude-compatible proxy request.
  * The plan lists the primary provider followed by eligible fallback targets.
  * All configured fallback entries are always eligible — no contract-based gating.
- * When no fallback chain is configured, an "auto-provider" entry is appended.
+ * An "auto-provider" entry is appended only when explicitly enabled by the
+ * caller. This keeps an empty fallback chain from silently escaping to an
+ * unrelated provider.
  */
 export declare function buildProxyTranslationPlan(primary: {
     provider: string;
     model?: string;
-}, fallbackChain: FallbackEntry[], requestedModel: string, _parsed: ParsedClaudeRequest): ProxyTranslationPlan;
+}, fallbackChain: FallbackEntry[], requestedModel: string, _parsed: ParsedClaudeRequest, allowAutoFallback?: boolean): ProxyTranslationPlan;
 /**
  * Parse the retry-after header from an upstream 429 response.
  * Returns milliseconds to wait, or 0 if no valid header present.

package/dist/lib/proxy/routingPolicy.js

@@ -15,9 +15,11 @@ export function inferClaudeProxyModelTier(modelName) {
  * Build a translation plan for a Claude-compatible proxy request.
  * The plan lists the primary provider followed by eligible fallback targets.
  * All configured fallback entries are always eligible — no contract-based gating.
- * When no fallback chain is configured, an "auto-provider" entry is appended.
+ * An "auto-provider" entry is appended only when explicitly enabled by the
+ * caller. This keeps an empty fallback chain from silently escaping to an
+ * unrelated provider.
  */
-export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel, _parsed) {
+export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel, _parsed, allowAutoFallback = false) {
     const attempts = [
         {
             provider: primary.provider,
@@ -36,9 +38,10 @@ export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel
             label: `${fallback.provider}/${fallback.model}`,
         });
     }
-    // Append auto-provider when no configured fallback chain exists,
-    // or when all configured entries were deduped (same as primary).
-    if (fallbackChain.length === 0 || attempts.length === 1) {
+    // A provider chosen by the translation layer is an explicit opt-in. It is
+    // intentionally not a default when configured entries are absent or deduped.
+    if (allowAutoFallback &&
+        (fallbackChain.length === 0 || attempts.length === 1)) {
         attempts.push({ label: "auto-provider" });
     }
     return {

package/dist/lib/proxy/runtimeConfig.js

@@ -212,6 +212,8 @@ async function buildCandidate(options, generation, allowMissingConfig, allowMiss
             strategy,
             modelMappings: routing.modelMappings ?? [],
             fallbackChain: routing.fallbackChain ?? [],
+            autoFallback: routing.autoFallback,
+            maxInflightPerAccount: routing.maxInflightPerAccount,
             passthroughModels: routing.passthroughModels,
             quotaRouting: routing.quotaRouting,
             sessionSoftLimit: routing.sessionSoftLimit,

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

@@ -12,7 +12,13 @@
 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, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountAdmissionLease, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicNonOkResult, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, ClaudeRequest, ClaudeProxyRouteRuntimeOptions, ModelRouterInterface, ParsedClaudeError, ProxyAccountRoutingDecision, ProxyAccountSortMetrics, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+declare function tryAcquireAccountAdmission(accountKey: string, capacity: number): AccountAdmissionLease | undefined;
+declare function acquireAccountAdmission(accountKey: string, capacity: number, abortSignal?: AbortSignal, timeoutMs?: number): Promise<AccountAdmissionLease | undefined>;
+declare function acquireFirstAvailableAccountAdmission(accountKeys: string[], capacity: number, abortSignal?: AbortSignal, timeoutMs?: number): Promise<{
+    accountKey: string;
+    lease: AccountAdmissionLease;
+} | undefined>;
 /** 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/
@@ -158,6 +164,7 @@ declare function handleAnthropicStreamingSuccessResponse(args: {
     upstreamSpan?: import("@opentelemetry/api").Span;
     logAttempt: AnthropicAttemptLogger;
     logProxyBody: ProxyBodyCaptureLogger;
+    onStreamTerminal?: () => void;
     logFinalRequest: (status: number, accountLabel: string, accountType: string, errorType?: string, errorMessage?: string, extra?: {
         inputTokens?: number;
         outputTokens?: number;
@@ -189,6 +196,7 @@ declare function handleAnthropicAuthRetry(args: {
     upstreamSpan?: import("@opentelemetry/api").Span;
     logAttempt: AnthropicAttemptLogger;
     logProxyBody: ProxyBodyCaptureLogger;
+    onStreamTerminal?: () => void;
     logFinalRequest: (status: number, accountLabel: string, accountType: string, errorType?: string, errorMessage?: string, extra?: {
         inputTokens?: number;
         outputTokens?: number;
@@ -210,6 +218,33 @@ declare function finalizeAnthropicTerminalFetchError(args: {
     logProxyBody: ProxyBodyCaptureLogger;
     logFinalRequest: ClaudeFinalRequestLogger;
 }): Response | unknown;
+declare function handleAnthropicNonOkResponse(args: {
+    response: Response;
+    account: ProxyPassthroughAccount;
+    accountState: RuntimeAccountState;
+    enabledAccounts: ProxyPassthroughAccount[];
+    orderedAccounts: ProxyPassthroughAccount[];
+    tracer?: ProxyTracer;
+    requestStartTime: number;
+    fetchStartMs: number;
+    attemptNumber: number;
+    logAttempt: AnthropicAttemptLogger;
+    logProxyBody: ProxyBodyCaptureLogger;
+    logFinalRequest: (status: number, accountLabel: string, accountType: string, errorType?: string, errorMessage?: string, extra?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheCreationTokens?: number;
+        cacheReadTokens?: number;
+    }) => void;
+    lastError: unknown;
+    authFailureMessage: string | null;
+    sawTransientFailure: boolean;
+    invalidRequestFailure: {
+        status: number;
+        body: string;
+        contentType?: string;
+    } | null;
+}): Promise<AnthropicNonOkResult>;
 /**
  * Detect Anthropic's anti-abuse / request-construction 429.
  *
@@ -284,6 +319,12 @@ export declare const buildProxyFallbackOptions: typeof buildTranslationOptions;
  * carry transient HTML responses (e.g. 520 pages) inside `error.message`.
  */
 export declare function isTransientHttpFailure(status: number, errBody: string): boolean;
+/**
+ * An upstream overload is already a capacity signal. Retrying it on the same
+ * OAuth account only consumes its remaining concurrency and delays rotation.
+ */
+export declare function isUpstreamOverload(status: number, errBody: string): boolean;
+export declare function redactProviderErrorMessage(message: string): string;
 export declare const __testHooks: {
     resolveHomeIndex: typeof resolveHomeIndex;
     maybeResetPrimaryToHome: typeof maybeResetPrimaryToHome;
@@ -309,12 +350,22 @@ export declare const __testHooks: {
     isAntiAbuseConstruction429: typeof isAntiAbuseConstruction429;
     fetchAnthropicAccountResponse: typeof fetchAnthropicAccountResponse;
     finalizeAnthropicTerminalFetchError: typeof finalizeAnthropicTerminalFetchError;
+    handleAnthropicNonOkResponse: typeof handleAnthropicNonOkResponse;
     handleAnthropicAuthRetry: typeof handleAnthropicAuthRetry;
     handleAnthropicStreamingSuccessResponse: typeof handleAnthropicStreamingSuccessResponse;
     claimTransientRateLimitRetry: typeof claimTransientRateLimitRetry;
     claimTransientCooldownAdmission: typeof claimTransientCooldownAdmission;
     waitForTransientAccountAvailability: typeof waitForTransientAccountAvailability;
+    acquireAccountAdmission: typeof acquireAccountAdmission;
+    acquireFirstAvailableAccountAdmission: typeof acquireFirstAvailableAccountAdmission;
+    tryAcquireAccountAdmission: typeof tryAcquireAccountAdmission;
+    getAccountAdmissionSnapshot: (accountKey: string) => {
+        active: number;
+        waiting: number;
+    };
     describeTransportError: typeof describeTransportError;
+    redactProviderErrorMessage: typeof redactProviderErrorMessage;
+    isUpstreamOverload: typeof isUpstreamOverload;
     shouldAttemptClaudeFallback: typeof shouldAttemptClaudeFallback;
     executeClaudeFallbackWithRetry: typeof executeClaudeFallbackWithRetry;
     buildClaudeAnthropicFailureResponse: typeof buildClaudeAnthropicFailureResponse;