@juspay/neurolink 12.40.2 → 12.41.0

package/dist/server/routes/codexProxyRoutes.d.ts

@@ -17,7 +17,7 @@
  * never collides with anthropic entries) and does pre-commit rotation only, not
  * the full transient-budget / admission machinery.
  */
-import type { AccountQuota, CodexRefreshTokenStore, CodexRuntimeAccount, CodexTokenRefresher, RateLimitCoolingReason, RouteGroup, ServerContext } from "../../types/index.js";
+import type { AccountQuota, CodexRefreshTokenStore, CodexResponseEnvelope, CodexResponseStream, CodexRuntimeAccount, CodexTokenRefresher, RateLimitCoolingReason, RouteGroup, ServerContext, ProxyRuntimeConfigProvider } from "../../types/index.js";
 declare function refreshCodexTokenOnceWithDependencies(key: string, refreshToken: string, store: CodexRefreshTokenStore, refresh: CodexTokenRefresher): Promise<{
     accessToken: string;
     refreshToken: string;
@@ -47,15 +47,49 @@ declare function planCodexCooldown(quota: AccountQuota | null, retryAfterMs: num
     coolingUntil: number;
     reason: RateLimitCoolingReason;
 };
+/**
+ * Drive a `CodexResponseStream`'s `frames` generator into a `Response` body,
+ * calling `onSettled` exactly once with the outcome: the terminal envelope on
+ * a normal finish, the thrown error on the (never expected, still handled)
+ * post-commit failure, or `cancelled` when the consumer cancels the
+ * `ReadableStream` first (client disconnect, or an upstream timeout/abort).
+ *
+ * `createAnthropicFallbackStream`'s generator never throws once past its own
+ * internal preflight (codexToAnthropicFallback.ts:220-517) — every
+ * post-commit failure is instead serialized as a `response.failed` frame and
+ * the generator completes normally — so the `catch` branch here is a
+ * defensive backstop, not the documented failure path.
+ */
+declare function wrapCodexOutboundResponseStream(codecStream: CodexResponseStream, headers: Record<string, string>, onSettled: (result: {
+    kind: "completed";
+    envelope: CodexResponseEnvelope;
+} | {
+    kind: "error";
+    error: unknown;
+} | {
+    kind: "cancelled";
+}) => void): Response;
 /** Core pooled handler for POST /backend-api/codex/responses. */
-export declare function handleCodexResponsesRequest(ctx: ServerContext): Promise<Response>;
+export declare function handleCodexResponsesRequest(ctx: ServerContext, runtimeConfigProvider?: ProxyRuntimeConfigProvider, loopbackPort?: number, internalDispatch?: (request: Request) => Response | Promise<Response>): Promise<Response>;
 /**
  * Create Codex proxy routes.
  *
  * @param basePath - Base path prefix (default "").
+ * @param runtimeConfigProvider - Optional runtime config snapshot reader.
+ *   Gates the Codex-outbound fallback dispatcher at all four insertion
+ *   points in `dispatch()`: omitting it (or a snapshot with the feature
+ *   disabled / no targets configured) reproduces today's behavior exactly.
+ * @param loopbackPort - The in-process HTTP port the outbound-fallback leg's
+ *   Anthropic-pool loopback request targets (mirrors `createOpenAIProxyRoutes`'s
+ *   bridge). Required only for an `anthropic` target; the `vertex` target
+ *   dispatches via `executeVertexAnthropicFallback` and never reads it.
+ * @param internalDispatch - Optional in-process fetch (`(request) =>
+ *   app.fetch(request)`), so the outbound-fallback loopback never re-enters
+ *   the public listener. Falls back to a real `fetch` against
+ *   `loopbackPort` when omitted.
  * @returns RouteGroup with the Codex backend Responses endpoint.
  */
-export declare function createCodexProxyRoutes(basePath?: string): RouteGroup;
+export declare function createCodexProxyRoutes(basePath?: string, runtimeConfigProvider?: ProxyRuntimeConfigProvider, loopbackPort?: number, internalDispatch?: (request: Request) => Response | Promise<Response>): RouteGroup;
 export declare const __testHooks: {
     loadCodexProxyAccounts: typeof loadCodexProxyAccounts;
     orderCodexAccounts: typeof orderCodexAccounts;
@@ -64,5 +98,7 @@ export declare const __testHooks: {
     refreshCodexTokenOnce: typeof refreshCodexTokenOnce;
     refreshCodexTokenOnceWithDependencies: typeof refreshCodexTokenOnceWithDependencies;
     codexRefreshInFlightSize: () => number;
+    setOutboundFallbackTimeoutMsForTests: (ms: number | null) => void;
+    wrapCodexOutboundResponseStream: typeof wrapCodexOutboundResponseStream;
 };
 export {};