@juspay/neurolink 10.8.4 → 10.8.6

package/dist/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/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/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/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/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/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;