@juspay/neurolink 9.87.2 → 9.87.3

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

@@ -11,8 +11,9 @@
  */
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import type { ModelRouter } from "../../proxy/modelRouter.js";
+import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
-import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, ParsedClaudeError, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeRequest, ParsedClaudeError, 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/
@@ -24,6 +25,9 @@ declare function resolveHomeIndex(enabledAccounts: ProxyPassthroughAccount[]): n
  *  account once its rate limit window expires. Called at the start of each
  *  request. Home is resolved fresh per call via resolveHomeIndex. */
 declare function maybeResetPrimaryToHome(enabledAccounts: ProxyPassthroughAccount[]): void;
+declare function claimTransientRateLimitRetry(accountKey: string, coolingUntil: number, now?: number): number | undefined;
+declare function claimTransientCooldownAdmission(accountKey: string, coolingUntil: number, now?: number): number | undefined;
+declare function waitForTransientAccountAvailability(orderedAccounts: ProxyPassthroughAccount[]): Promise<ProxyPassthroughAccount[]>;
 /** Convert an Anthropic unified-window reset (Unix epoch SECONDS, per the
  *  `anthropic-ratelimit-unified-*-reset` headers) into epoch-ms. Tolerates a
  *  value already expressed in ms (some intermediaries normalise it). Returns
@@ -77,11 +81,109 @@ declare function trackUpstreamReadableStream(source: ReadableStream<Uint8Array>)
     stream: ReadableStream<Uint8Array>;
     outcome: Promise<StreamTerminalOutcome>;
 };
+declare function handleAnthropicStreamingSuccessResponse(args: {
+    ctx: ServerContext;
+    body: ClaudeRequest;
+    account: ProxyPassthroughAccount;
+    accountState: RuntimeAccountState;
+    response: Response;
+    responseHeaders: Record<string, string>;
+    tracer?: ProxyTracer;
+    requestStartTime: number;
+    fetchStartMs: number;
+    attemptNumber: number;
+    finalBodyStr: string;
+    upstreamSpan?: import("@opentelemetry/api").Span;
+    logProxyBody: ProxyBodyCaptureLogger;
+    logFinalRequest: (status: number, accountLabel: string, accountType: string, errorType?: string, errorMessage?: string, extra?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheCreationTokens?: number;
+        cacheReadTokens?: number;
+    }) => void;
+}): Promise<AnthropicSuccessResult>;
 declare function getStreamFailureDetails(outcome: StreamTerminalOutcome): {
     status: number;
     errorType: string;
     message: string;
 } | undefined;
+declare function handleAnthropicAuthRetry(args: {
+    ctx: ServerContext;
+    body: ClaudeRequest;
+    account: ProxyPassthroughAccount;
+    accountState: RuntimeAccountState;
+    headers: Record<string, string>;
+    buildUpstreamBody: (token: string) => {
+        bodyStr: string;
+        sessionId?: string;
+    };
+    enabledAccounts: ProxyPassthroughAccount[];
+    orderedAccounts: ProxyPassthroughAccount[];
+    response: Response;
+    tracer?: ProxyTracer;
+    requestStartTime: number;
+    fetchStartMs: number;
+    attemptNumber: number;
+    finalBodyStr: string;
+    upstreamSpan?: import("@opentelemetry/api").Span;
+    logAttempt: (status: number, errorType?: string, errorMessage?: string, extra?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheCreationTokens?: number;
+        cacheReadTokens?: number;
+    }) => void;
+    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;
+    sawRateLimit: boolean;
+    sawTransientFailure: boolean;
+    sawNetworkError: boolean;
+}): Promise<AnthropicAuthRetryResult>;
+declare function finalizeAnthropicTerminalFetchError(args: {
+    terminalError: NonNullable<AnthropicUpstreamFetchResult["terminalError"]>;
+    account: ProxyPassthroughAccount;
+    tracer?: ProxyTracer;
+    requestStartTime: number;
+    attemptNumber: number;
+    logProxyBody: ProxyBodyCaptureLogger;
+    logFinalRequest: ClaudeFinalRequestLogger;
+}): Response | unknown;
+/**
+ * Detect Anthropic's anti-abuse / request-construction 429.
+ *
+ * The subscription/OAuth path rejects requests it does not recognise as genuine
+ * Claude Code traffic with a 429 `rate_limit_error` whose message is literally
+ * "Error" and which carries NONE of the real rate-limit headers (no retry-after,
+ * no anthropic-ratelimit-*). This is NOT a capacity limit — retrying or rotating
+ * accounts cannot fix it and only burns quota, so the caller must fail fast and
+ * return a non-retryable request error instead of "all accounts rate-limited".
+ */
+declare function isAntiAbuseConstruction429(headers: Record<string, string>, body: string): boolean;
+declare function fetchAnthropicAccountResponse(args: {
+    url: string;
+    headers: Record<string, string>;
+    finalBodyStr: string;
+    account: ProxyPassthroughAccount;
+    accountState: RuntimeAccountState;
+    enabledAccounts: ProxyPassthroughAccount[];
+    orderedAccounts: ProxyPassthroughAccount[];
+    tracer?: ProxyTracer;
+    logAttempt: AnthropicAttemptLogger;
+    logProxyBody: ProxyBodyCaptureLogger;
+    fetchStartMs: number;
+    attemptNumber: number;
+    currentLastError: unknown;
+    currentSawRateLimit: boolean;
+    currentSawNetworkError: boolean;
+    upstreamSpan?: import("@opentelemetry/api").Span;
+}): Promise<AnthropicUpstreamFetchResult>;
+declare function shouldAttemptClaudeFallback(loopState: AnthropicLoopState): boolean;
 /**
  * Create Claude-compatible proxy routes.
  *
@@ -94,6 +196,7 @@ declare function getStreamFailureDetails(outcome: StreamTerminalOutcome): {
  */
 export declare function createClaudeProxyRoutes(modelRouter?: ModelRouter, basePath?: string, accountStrategy?: "round-robin" | "fill-first", passthroughMode?: boolean, primaryAccountKey?: string, accountAllowlist?: AccountAllowlist): RouteGroup;
 export declare function getTransientSameAccountRetryDelayMs(retryNumber: number): number;
+declare function describeTransportError(error: unknown): string;
 /**
  * Parse a Claude error payload when available.
  */
@@ -132,5 +235,19 @@ export declare const __testHooks: {
     getPrimaryAccountIndex: () => number;
     setAccountRuntimeState: (key: string, state: Partial<RuntimeAccountState>) => void;
     resetAllRuntimeState: () => void;
+    polyfillOAuthBody: (bodyStr: string, isClaudeClientRequest: boolean) => {
+        bodyStr: string;
+        sessionId?: string;
+    };
+    isAntiAbuseConstruction429: typeof isAntiAbuseConstruction429;
+    fetchAnthropicAccountResponse: typeof fetchAnthropicAccountResponse;
+    finalizeAnthropicTerminalFetchError: typeof finalizeAnthropicTerminalFetchError;
+    handleAnthropicAuthRetry: typeof handleAnthropicAuthRetry;
+    handleAnthropicStreamingSuccessResponse: typeof handleAnthropicStreamingSuccessResponse;
+    claimTransientRateLimitRetry: typeof claimTransientRateLimitRetry;
+    claimTransientCooldownAdmission: typeof claimTransientCooldownAdmission;
+    waitForTransientAccountAvailability: typeof waitForTransientAccountAvailability;
+    describeTransportError: typeof describeTransportError;
+    shouldAttemptClaudeFallback: typeof shouldAttemptClaudeFallback;
 };
 export {};