@juspay/neurolink 9.87.3 → 9.88.0

package/dist/lib/proxy/openaiFormat.js

@@ -651,7 +651,7 @@ export function convertClaudeToOpenAIResponse(claude, requestModel) {
  *  - message_delta       -> captures stop_reason and output token usage
  *  - message_stop        -> emits the final `finish_reason` chunk + `[DONE]`
  */
-export function createClaudeToOpenAIStreamTransform(requestModel) {
+export function createClaudeToOpenAIStreamTransform(requestModel, options = {}) {
     const serializer = new OpenAIStreamSerializer(requestModel);
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -677,6 +677,9 @@ export function createClaudeToOpenAIStreamTransform(requestModel) {
         catch {
             return;
         }
+        if (finished) {
+            return;
+        }
         switch (eventName) {
             case "message_start": {
                 const message = (data.message ?? {});
@@ -749,8 +752,18 @@ export function createClaudeToOpenAIStreamTransform(requestModel) {
                 }
                 return;
             }
+            case "error": {
+                const error = (data.error ?? {});
+                const message = typeof error.message === "string"
+                    ? error.message
+                    : "Anthropic stream failed";
+                finished = true;
+                options.onError?.(message);
+                emit(controller, serializer.emitError(message));
+                return;
+            }
             default:
-                // ping, error, and unknown events are ignored.
+                // ping and unknown events are ignored.
                 return;
         }
     };
@@ -790,10 +803,12 @@ export function createClaudeToOpenAIStreamTransform(requestModel) {
             // closing `\n\n` is not silently lost.
             buffer += decoder.decode();
             drainBufferedEvents(controller);
-            // If the upstream closed without a message_stop, still finalize.
+            // Closing without message_stop is an interrupted stream, not success.
             if (!finished) {
                 finished = true;
-                emit(controller, serializer.finish(stopReason, usage));
+                const message = "Anthropic stream ended before message_stop";
+                options.onError?.(message);
+                emit(controller, serializer.emitError(message));
             }
         },
     });

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

@@ -0,0 +1,8 @@
+import type { ProxyActivitySnapshot } from "../types/index.js";
+/** Track one client-facing proxy request until its response body settles. */
+export declare function beginProxyRequest(): () => void;
+export declare function getProxyActivitySnapshot(): ProxyActivitySnapshot;
+export declare function isProxyActivityQuiet(snapshot: ProxyActivitySnapshot, quietThresholdMs: number, nowMs?: number): boolean;
+/** Keep activity open until the response body completes, errors, or is cancelled. */
+export declare function trackProxyResponse(response: Response, finishRequest: () => void): Response;
+export declare function resetProxyActivityForTests(): void;

package/dist/lib/proxy/proxyActivity.js

@@ -0,0 +1,77 @@
+let activeRequests = 0;
+let lastActivityAtMs = null;
+function touchActivity() {
+    lastActivityAtMs = Date.now();
+}
+/** Track one client-facing proxy request until its response body settles. */
+export function beginProxyRequest() {
+    activeRequests += 1;
+    touchActivity();
+    let finished = false;
+    return () => {
+        if (finished) {
+            return;
+        }
+        finished = true;
+        activeRequests = Math.max(0, activeRequests - 1);
+        touchActivity();
+    };
+}
+export function getProxyActivitySnapshot() {
+    return {
+        activeRequests,
+        lastActivityAt: lastActivityAtMs === null ? null : new Date(lastActivityAtMs),
+    };
+}
+export function isProxyActivityQuiet(snapshot, quietThresholdMs, nowMs = Date.now()) {
+    if (snapshot.activeRequests > 0) {
+        return false;
+    }
+    if (snapshot.lastActivityAt === null) {
+        return true;
+    }
+    return nowMs - snapshot.lastActivityAt.getTime() >= quietThresholdMs;
+}
+/** Keep activity open until the response body completes, errors, or is cancelled. */
+export function trackProxyResponse(response, finishRequest) {
+    if (!response.body) {
+        finishRequest();
+        return response;
+    }
+    const reader = response.body.getReader();
+    const trackedBody = new ReadableStream({
+        async pull(controller) {
+            try {
+                const { value, done } = await reader.read();
+                if (done) {
+                    finishRequest();
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+            catch (error) {
+                finishRequest();
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            try {
+                await reader.cancel(reason);
+            }
+            finally {
+                finishRequest();
+            }
+        },
+    });
+    return new Response(trackedBody, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+export function resetProxyActivityForTests() {
+    activeRequests = 0;
+    lastActivityAtMs = null;
+}
+//# sourceMappingURL=proxyActivity.js.map

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

@@ -13,7 +13,7 @@ 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, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeRequest, ParsedClaudeError, ProxyBodyCaptureLogger, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, ServerContext, StreamTerminalOutcome } from "../../types/index.js";
+import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAttemptLogger, AnthropicAuthRetryResult, AnthropicLoopState, AnthropicSuccessResult, AnthropicUpstreamFetchResult, ClaudeFinalRequestLogger, ClaudeLoggedErrorBuilder, 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/
@@ -62,17 +62,24 @@ declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: nu
 declare function seedRuntimeQuotasFromDisk(accounts: ProxyPassthroughAccount[]): Promise<void>;
 /**
  * Order accounts to MAXIMIZE quota utilization (fill-first, smart order):
- * spend the account whose window refreshes SOONEST first, so its about-to-reset
+ * spend the window that expires SOONEST first, so its about-to-reset
  * allowance isn't wasted, then move to accounts with longer-dated resets.
  *
  * Priority among usable accounts:
  *   1. no quota data yet — probe first: one request reveals its windows and
  *      self-corrects the ordering. (Ranking unknowns last would starve them
  *      forever: never picked → never observed → never comparable.)
- *   2. soonest WEEKLY (7d) reset  — the scarce, use-it-or-lose-it ceiling
- *   3. soonest SESSION (5h) reset
- *   4. highest weekly utilization — finish off the one closest to done
- *   5. configured primary account, then insertion order
+ *   2. session headroom before session-saturated (>= soft limit or
+ *      "throttled") — saturated accounts then follow the same bucketed
+ *      session ordering below: soonest back in service first, weekly
+ *      deciding same-bucket ties.
+ *   3. soonest SESSION (5h) reset — the capacity expiring soonest; compared
+ *      in tolerance buckets so near-simultaneous resets count as equal.
+ *   4. soonest WEEKLY (7d) reset — decides between same-bucket sessions.
+ *   5. highest weekly utilization — finish off the one closest to done
+ *   6. configured primary account, then insertion order
+ * An account with NO ticking session window (fresh, not yet started) has
+ * nothing expiring and sorts after ticking windows in step 3.
  * Cooling/rejected accounts sort last, soonest-back-to-service first, as
  * last resort.
  */
@@ -81,6 +88,47 @@ declare function trackUpstreamReadableStream(source: ReadableStream<Uint8Array>)
     stream: ReadableStream<Uint8Array>;
     outcome: Promise<StreamTerminalOutcome>;
 };
+declare function executeClaudeFallbackTranslation(args: {
+    ctx: ServerContext;
+    body: ClaudeRequest;
+    tracer?: ProxyTracer;
+    requestStartTime: number;
+    logProxyBody: ProxyBodyCaptureLogger;
+    logFinalRequest: (status: number, accountLabel: string, accountType: string, errorType?: string, errorMessage?: string, extra?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheCreationTokens?: number;
+        cacheReadTokens?: number;
+    }) => void;
+    options: Parameters<ServerContext["neurolink"]["stream"]>[0];
+    providerLabel: string;
+}): Promise<unknown>;
+declare function executeClaudeFallbackWithRetry(args: Parameters<typeof executeClaudeFallbackTranslation>[0]): Promise<unknown>;
+declare function buildClaudeAnthropicFailureResponse(args: {
+    tracer?: ProxyTracer;
+    requestStartTime: number;
+    authFailureMessage: string | null;
+    authCooldownMessage: string | null;
+    invalidRequestFailure: {
+        status: number;
+        body: string;
+        contentType?: string;
+    } | null;
+    sawNetworkError: boolean;
+    sawTransientFailure: boolean;
+    sawRateLimit: boolean;
+    lastError: unknown;
+    fallbackFailureMessage?: string;
+    orderedAccounts: ProxyPassthroughAccount[];
+    buildLoggedClaudeError: ClaudeLoggedErrorBuilder;
+    logProxyBody: ProxyBodyCaptureLogger;
+    logFinalRequest: (status: number, accountLabel: string, accountType: string, errorType?: string, errorMessage?: string, extra?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheCreationTokens?: number;
+        cacheReadTokens?: number;
+    }) => void;
+}): unknown;
 declare function handleAnthropicStreamingSuccessResponse(args: {
     ctx: ServerContext;
     body: ClaudeRequest;
@@ -249,5 +297,7 @@ export declare const __testHooks: {
     waitForTransientAccountAvailability: typeof waitForTransientAccountAvailability;
     describeTransportError: typeof describeTransportError;
     shouldAttemptClaudeFallback: typeof shouldAttemptClaudeFallback;
+    executeClaudeFallbackWithRetry: typeof executeClaudeFallbackWithRetry;
+    buildClaudeAnthropicFailureResponse: typeof buildClaudeAnthropicFailureResponse;
 };
 export {};