@juspay/neurolink 12.12.3 → 12.12.5

package/dist/cli/commands/proxy.js

@@ -66,7 +66,6 @@ const gatedShareRequests = new WeakSet();
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
 /** How long shutdown waits on the share listener before moving on. */
 const SHARE_LISTENER_CLOSE_TIMEOUT_MS = 10_000;
-const PROXY_STATUS_TOKEN_READ_TIMEOUT_MS = 2_000;
 const PROXY_STATUS_RECONCILE_TIMEOUT_MS = 750;
 const PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS = 750;
 // Allowed drift between a pid's OS-reported start time and the persisted
@@ -1164,6 +1163,10 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
                     });
                 },
                 onTerminal: ({ outcome, observedBodyBytes, responseChunks }) => {
+                    if (outcome === "completed" &&
+                        metadata.terminalErrorType === "stream_error") {
+                        outcome = "stream_error";
+                    }
                     logProxyLifecycleEvent({
                         event: "request_terminal",
                         requestId: metadata.requestId,
@@ -1500,6 +1503,7 @@ export async function createProxyStartApp(params) {
                     shareOutcome.release();
                 }
             }
+            const requestAbortController = new AbortController();
             const ctx = {
                 requestId: metadata?.requestId ?? crypto.randomUUID(),
                 method: c.req.method,
@@ -1509,6 +1513,10 @@ export async function createProxyStartApp(params) {
                 params: c.req.param(),
                 body,
                 rawBody,
+                abortSignal: AbortSignal.any([
+                    c.req.raw.signal,
+                    requestAbortController.signal,
+                ]),
                 // The proxy runtime exposes only the structural slice of NeuroLink the
                 // routes use; narrow (overlap-checked) to the full class for ServerContext.
                 neurolink: params.neurolink,
@@ -1555,39 +1563,42 @@ export async function createProxyStartApp(params) {
                 Symbol.asyncIterator in Object(result)) {
                 const iterator = result[Symbol.asyncIterator]();
                 let cancelled = false;
+                const encoder = new TextEncoder();
                 const responseStream = new ReadableStream({
-                    async start(controller) {
+                    async pull(controller) {
+                        if (cancelled) {
+                            return;
+                        }
                         try {
-                            while (!cancelled) {
-                                const { value, done } = await iterator.next();
-                                if (done) {
-                                    break;
-                                }
-                                controller.enqueue(new TextEncoder().encode(value));
+                            const next = await iterator.next();
+                            if (cancelled) {
+                                return;
+                            }
+                            if (next.done) {
+                                controller.close();
+                            }
+                            else {
+                                controller.enqueue(encoder.encode(next.value));
                             }
-                            controller.close();
                         }
                         catch (streamErr) {
                             if (cancelled) {
-                                controller.close();
                                 return;
                             }
-                            const errMsg = streamErr instanceof Error
-                                ? streamErr.message
-                                : String(streamErr);
-                            const errorEvent = `event: error\ndata: ${JSON.stringify({ type: "error", error: { type: "api_error", message: `Stream interrupted: ${errMsg}` } })}\n\n`;
-                            try {
-                                controller.enqueue(new TextEncoder().encode(errorEvent));
-                            }
-                            catch {
-                                // Controller already errored — ignore
+                            if (metadata) {
+                                metadata.terminalErrorType = "stream_error";
                             }
+                            logger.debug("[proxy] response stream interrupted", {
+                                error: streamErr,
+                            });
+                            controller.enqueue(encoder.encode(`event: error\ndata: ${JSON.stringify({ type: "error", error: { type: "api_error", message: "Stream interrupted" } })}\n\n`));
                             controller.close();
                         }
                     },
-                    async cancel() {
+                    async cancel(reason) {
                         cancelled = true;
-                        await iterator.return?.();
+                        requestAbortController.abort(reason);
+                        await withTimeout(Promise.resolve(iterator.return?.()), 1000, "[proxy] response cancellation timed out").catch(() => undefined);
                     },
                 });
                 return new Response(responseStream, {
@@ -1697,48 +1708,24 @@ export async function createProxyStartApp(params) {
         let accountInventoryLoaded = false;
         try {
             const { tokenStore } = await import("../../auth/tokenStore.js");
-            const [anthropicKeys, codexKeys] = await withTimeout(Promise.all([
-                tokenStore.listByPrefix("anthropic:"),
-                tokenStore.listByPrefix("codex:"),
-            ]), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account enumeration timed out");
-            for (const key of anthropicKeys) {
-                storedAnthropicAccountKeys.add(normalizeAnthropicAccountKey(key));
-            }
-            for (const key of codexKeys) {
-                storedCodexAccountKeys.add(key);
-            }
-            // Once account names are known, preserve them even when optional token
-            // metadata is slow. That keeps the status table useful and avoids
-            // incorrectly presenting known accounts as removed.
-            accountInventoryLoaded = true;
-            const storedKeys = [...anthropicKeys, ...codexKeys];
-            const inventory = await withTimeout((async () => {
-                const tokenExpirations = await Promise.all(storedKeys.map(async (key) => {
-                    try {
-                        const tokens = await withTimeout(tokenStore.peekTokens(key), PROXY_STATUS_TOKEN_READ_TIMEOUT_MS, "[proxy] /status token inspection timed out");
-                        return tokens ? [key, tokens.expiresAt] : undefined;
-                    }
-                    catch (error) {
-                        logger.debug(`[proxy] /status: failed to inspect token metadata for ${normalizeAnthropicAccountKey(key)}: ${error instanceof Error ? error.message : String(error)}`);
-                        return undefined;
-                    }
-                }));
-                const disabledKeys = await tokenStore.listDisabled();
-                return { tokenExpirations, disabledKeys };
-            })(), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account metadata timed out");
-            for (const expiration of inventory.tokenExpirations) {
-                if (expiration) {
-                    const key = expiration[0].startsWith("anthropic:")
-                        ? normalizeAnthropicAccountKey(expiration[0])
-                        : expiration[0];
-                    storedAccountExpirations.set(key, expiration[1]);
+            const inventory = await withTimeout(tokenStore.getProviderSnapshot(), PROXY_STATUS_ACCOUNT_INVENTORY_TIMEOUT_MS, "[proxy] /status account inspection timed out");
+            for (const [storedKey, entry] of Object.entries(inventory)) {
+                if (!storedKey.startsWith("anthropic:") &&
+                    !storedKey.startsWith("codex:")) {
+                    continue;
+                }
+                const key = storedKey.startsWith("anthropic:")
+                    ? normalizeAnthropicAccountKey(storedKey)
+                    : storedKey;
+                (key.startsWith("anthropic:")
+                    ? storedAnthropicAccountKeys
+                    : storedCodexAccountKeys).add(key);
+                storedAccountExpirations.set(key, entry.tokens.expiresAt);
+                if (entry.disabled) {
+                    disabledProviderAccountKeys.add(key);
                 }
             }
-            for (const key of inventory.disabledKeys) {
-                disabledProviderAccountKeys.add(key.startsWith("anthropic:")
-                    ? normalizeAnthropicAccountKey(key)
-                    : key);
-            }
+            accountInventoryLoaded = true;
         }
         catch (err) {
             logger.debug(`[proxy] /status: failed to resolve account cooldown labels: ${err instanceof Error ? err.message : String(err)}`);
@@ -3090,7 +3077,15 @@ function printStatusStats(stats) {
             }
         }
     }
-    if (stats.accounts?.length) {
+    const historical = (stats.accounts ?? []).filter((account) => account.status === "unattributed");
+    const accounts = (stats.accounts ?? []).filter((account) => account.status !== "unattributed");
+    if (historical.length > 0) {
+        const sum = (field) => historical.reduce((total, account) => total + (account[field] ?? 0), 0);
+        console.info(`\n  Historical usage (provider unknown; included in totals):`);
+        console.info(`    ${historical.length} legacy records: ${sum("attempts")} attempts, ${sum("success")} success, ${sum("errors")} errors, ${sum("rateLimits")} rate-limited attempts`);
+        console.info("    Per-record history remains available with --format json.");
+    }
+    if (accounts.length > 0) {
         console.info(`\n  Accounts:`);
         const headers = [
             "ACCOUNT",
@@ -3101,8 +3096,8 @@ function printStatusStats(stats) {
             "RL",
             "STATUS",
         ];
-        const rows = stats.accounts.map((account) => [
-            account.label,
+        const rows = accounts.map((account) => [
+            account.key ?? account.label,
             account.type,
             String(account.attempts ?? account.requests ?? 0),
             String(account.success ?? 0),
@@ -3267,7 +3262,7 @@ export const proxyStatusCommand = {
                     });
                     if (statusResp.ok) {
                         const statusData = (await statusResp.json());
-                        liveStats = statusData.stats;
+                        liveStats = statusData.stats ?? null;
                         liveConfig = statusData.config;
                         status.workerVersion =
                             typeof statusData.version === "string"
@@ -3342,6 +3337,9 @@ export const proxyStatusCommand = {
                 else if (status.rolling?.draining.length) {
                     logger.always(`  ${chalk.bold("Handoff:")}    ${chalk.cyan(`${status.rolling.draining.length} previous worker(s) draining`)}`);
                 }
+                if (status.rolling) {
+                    logger.always(`  ${chalk.bold("Socket handoff:")} ${status.rolling.pendingTransfers ?? "unknown"} pending, ${status.rolling.queuedSockets} queued; ${status.rolling.rejectedSockets} rejected, ${status.rolling.failedTransfers} failed transfers since supervisor start`);
+                }
                 if (status.deferredUpdate) {
                     const active = status.deferredUpdate.activeRequests === null
                         ? "unknown activity"
@@ -3398,21 +3396,8 @@ export const proxyStatusCommand = {
                     logger.always("");
                     logger.always(chalk.gray("  (Could not reach proxy for live status)"));
                 }
-                // Try to get detailed stats
-                try {
-                    const liveUrl = status.url;
-                    const statusResp = await fetch(`${liveUrl}/status`, {
-                        signal: AbortSignal.timeout(2_000),
-                    });
-                    if (statusResp.ok) {
-                        const statusData = (await statusResp.json());
-                        if (statusData.stats) {
-                            printStatusStats(statusData.stats);
-                        }
-                    }
-                }
-                catch {
-                    /* non-fatal */
+                if (liveStats) {
+                    printStatusStats(liveStats);
                 }
             }
             else {

package/dist/proxy/claudeFormat.d.ts

@@ -1,4 +1,4 @@
-import type { ClaudeErrorResponse, ClaudeRequest, ClaudeResponse, ContentBlockType, InternalResult, ParsedClaudeRequest, StreamLifecycleState } from "../types/index.js";
+import type { ClaudeErrorResponse, ClaudeRequest, ClaudeResponse, ContentBlockType, InternalResult, ParsedClaudeRequest, SSEMessageDelta, StreamLifecycleState } from "../types/index.js";
 /** Generate a unique message id in the Claude format. */
 export declare function generateMessageId(): string;
 /** Generate a Claude-format tool use ID (`toolu_` + 24 random chars). */
@@ -121,7 +121,7 @@ export declare class ClaudeStreamSerializer {
     /**
      * Finalize the stream: content_block_stop, message_delta, message_stop.
      */
-    finish(outputTokens?: number, finishReason?: string): Generator<string>;
+    finish(outputTokens?: number, finishReason?: string, finalUsage?: Partial<SSEMessageDelta["usage"]>): Generator<string>;
     /**
      * Emit an error event.  Transitions to terminal ERROR state.
      */

package/dist/proxy/claudeFormat.js

@@ -582,7 +582,7 @@ export class ClaudeStreamSerializer {
     /**
      * Finalize the stream: content_block_stop, message_delta, message_stop.
      */
-    *finish(outputTokens, finishReason) {
+    *finish(outputTokens, finishReason, finalUsage) {
         // If we never started (empty response), start first
         if (this.state === "idle") {
             yield* this.ensureMessageStarted();
@@ -603,7 +603,7 @@ export class ClaudeStreamSerializer {
                 stop_reason: mapStopReason(resolvedFinishReason),
                 stop_sequence: null,
             },
-            usage: { output_tokens: this.outputTokens },
+            usage: { ...finalUsage, output_tokens: this.outputTokens },
         };
         yield formatSSE("message_delta", messageDelta);
         // message_stop

package/dist/proxy/codexFallback.d.ts

@@ -6,14 +6,14 @@
  * in the native Codex proxy handler so fallback traffic follows the same pool
  * rules as a native Codex request.
  */
-import type { ClaudeRequest, CodexFallbackResult, CodexResponsesRequest } from "../types/index.js";
+import type { ClaudeRequest, CodexFallbackResult, CodexFallbackStream, CodexReasoningEffort, CodexResponsesRequest } from "../types/index.js";
 export declare class CodexFallbackResponseError extends Error {
     readonly status: number;
     readonly responseBody: string;
     constructor(status: number, responseBody: string);
 }
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
-export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model: string): CodexResponsesRequest;
+export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model: string, reasoningEffort?: CodexReasoningEffort): CodexResponsesRequest;
 /**
  * Parse a complete Codex Responses SSE stream before emitting Claude output.
  *
@@ -24,3 +24,9 @@ export declare function convertClaudeRequestToCodex(body: ClaudeRequest, model:
 export declare function parseCodexFallbackSSE(sse: string): CodexFallbackResult;
 /** Consume and validate a native Codex response before producing Claude output. */
 export declare function consumeCodexFallbackResponse(response: Response): Promise<CodexFallbackResult>;
+/**
+ * Translate a Codex stream as events arrive. A completed tool call is emitted
+ * once its arguments validate; text does not wait for response.completed.
+ * The caller owns error framing and must never retry after emitting output.
+ */
+export declare function createCodexFallbackStream(response: Response, model: string): Promise<CodexFallbackStream>;

package/dist/proxy/codexFallback.js

@@ -6,6 +6,7 @@
  * in the native Codex proxy handler so fallback traffic follows the same pool
  * rules as a native Codex request.
  */
+import { ClaudeStreamSerializer, generateToolUseId } from "./claudeFormat.js";
 import { extractCodexUsage } from "./codexUsage.js";
 export class CodexFallbackResponseError extends Error {
     status;
@@ -131,7 +132,7 @@ function convertClaudeMessage(role, content) {
     return input;
 }
 /** Convert a Claude Messages request into the ChatGPT Codex Responses shape. */
-export function convertClaudeRequestToCodex(body, model) {
+export function convertClaudeRequestToCodex(body, model, reasoningEffort) {
     const input = body.messages.flatMap((message) => convertClaudeMessage(message.role, message.content));
     const request = {
         model,
@@ -139,6 +140,9 @@ export function convertClaudeRequestToCodex(body, model) {
         stream: true,
         // ChatGPT's backend rejects requests unless this is explicitly false.
         store: false,
+        ...(reasoningEffort !== undefined
+            ? { reasoning: { effort: reasoningEffort } }
+            : {}),
     };
     const instructions = buildSystemInstructions(body);
     if (instructions) {
@@ -369,3 +373,183 @@ export async function consumeCodexFallbackResponse(response) {
     }
     return parseCodexFallbackSSE(await response.text());
 }
+/**
+ * Translate a Codex stream as events arrive. A completed tool call is emitted
+ * once its arguments validate; text does not wait for response.completed.
+ * The caller owns error framing and must never retry after emitting output.
+ */
+export async function createCodexFallbackStream(response, model) {
+    if (!response.ok) {
+        throw new CodexFallbackResponseError(response.status, await response.text().catch(() => ""));
+    }
+    if (!response.body ||
+        !(response.headers.get("content-type") ?? "")
+            .toLowerCase()
+            .includes("text/event-stream")) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new Error("Codex fallback returned a non-SSE or empty response");
+    }
+    const reader = response.body.getReader();
+    let cancellation;
+    const cancel = (reason) => {
+        cancellation ??= reader
+            .cancel(reason)
+            .catch(() => undefined)
+            .finally(() => reader.releaseLock());
+        return cancellation;
+    };
+    async function* frames() {
+        const serializer = new ClaudeStreamSerializer(model);
+        const decoder = new TextDecoder();
+        const toolCalls = new Map();
+        const emittedTools = new Set();
+        const emittedTextItems = new Set();
+        const textParts = [];
+        let textLength = 0;
+        let toolChars = 0;
+        let carry = "";
+        let searchFrom = 0;
+        let completed = false;
+        let usage;
+        const maxChars = 16 * 1024 * 1024;
+        function* text(value, index) {
+            if (!value) {
+                return;
+            }
+            textLength += value.length;
+            if (textLength > maxChars) {
+                throw new Error("Codex fallback output exceeded the stream limit");
+            }
+            textParts.push(value);
+            emittedTextItems.add(index);
+            yield* serializer.pushDelta(value);
+        }
+        function* item(value, index) {
+            if (!isRecord(value)) {
+                throw new Error("Codex fallback output item is malformed");
+            }
+            if (value.type === "function_call") {
+                const id = asNonEmptyString(value.call_id);
+                if (!id || !emittedTools.has(id)) {
+                    toolChars += JSON.stringify(value).length;
+                    if (toolChars > maxChars || toolCalls.size >= 4096) {
+                        throw new Error("Codex fallback tools exceeded the stream limit");
+                    }
+                    addFunctionCall(value, toolCalls);
+                    const call = id ? toolCalls.get(id) : undefined;
+                    if (id && call) {
+                        emittedTools.add(id);
+                        yield* serializer.pushToolUse(generateToolUseId(), call.toolName, call.args);
+                    }
+                }
+            }
+            if (!emittedTextItems.has(index)) {
+                yield* text(outputTextFromItem(value), index);
+            }
+        }
+        function* event(frame) {
+            for (const { event: eventName, payload } of parseSSEPayloads(frame)) {
+                const type = asNonEmptyString(payload.type) ?? eventName;
+                if (!type) {
+                    throw new Error("Codex fallback stream event is missing a type");
+                }
+                if (completed) {
+                    throw new Error("Codex fallback stream emitted events after completion");
+                }
+                if (type === "error" ||
+                    type === "response.failed" ||
+                    type === "response.incomplete") {
+                    throw new Error(`Codex fallback stream terminated with ${type}`);
+                }
+                const index = typeof payload.output_index === "number" ? payload.output_index : 0;
+                if (type === "response.output_text.delta") {
+                    if (typeof payload.delta !== "string") {
+                        throw new Error("Codex fallback text delta is malformed");
+                    }
+                    yield* text(payload.delta, index);
+                }
+                else if (type === "response.output_item.done") {
+                    if (!isRecord(payload.item)) {
+                        throw new Error("Codex fallback output item is malformed");
+                    }
+                    yield* item(payload.item, index);
+                }
+                else if (type === "response.completed") {
+                    if (responseStatus(payload) !== "completed") {
+                        throw new Error("Codex fallback response did not complete");
+                    }
+                    completed = true;
+                    const parsedUsage = extractCodexUsage(payload);
+                    if (parsedUsage) {
+                        usage = {
+                            input: parsedUsage.inputTokens,
+                            output: parsedUsage.outputTokens,
+                            total: parsedUsage.inputTokens + parsedUsage.outputTokens,
+                            cacheReadTokens: parsedUsage.cacheReadTokens,
+                            cacheCreationTokens: parsedUsage.cacheCreationTokens,
+                        };
+                    }
+                    const responseBody = payload.response;
+                    if (isRecord(responseBody) && Array.isArray(responseBody.output)) {
+                        for (const [i, output] of responseBody.output.entries()) {
+                            yield* item(output, i);
+                        }
+                    }
+                }
+            }
+        }
+        try {
+            yield* serializer.start();
+            while (true) {
+                const chunk = await reader.read();
+                carry += decoder.decode(chunk.value, { stream: !chunk.done });
+                // Search only new bytes plus the boundary overlap. Long tool payloads
+                // split over many chunks must not rescan their accumulated prefix.
+                const boundary = /\r?\n\r?\n/g;
+                boundary.lastIndex = searchFrom;
+                let match;
+                while ((match = boundary.exec(carry)) !== null) {
+                    if (match.index > maxChars) {
+                        throw new Error("Codex fallback event exceeded the stream limit");
+                    }
+                    yield* event(carry.slice(0, match.index));
+                    carry = carry.slice(match.index + match[0].length);
+                    boundary.lastIndex = 0;
+                }
+                if (carry.length > maxChars) {
+                    throw new Error("Codex fallback event exceeded the stream limit");
+                }
+                searchFrom = Math.max(0, carry.length - 3);
+                if (chunk.done) {
+                    break;
+                }
+            }
+            if (carry.trim()) {
+                yield* event(carry);
+            }
+            if (!completed) {
+                throw new Error("Codex fallback stream ended before response.completed");
+            }
+            if (textLength === 0 && toolCalls.size === 0) {
+                throw new Error("Codex fallback returned no content or tool calls");
+            }
+            const finishReason = toolCalls.size > 0 ? "tool_use" : "end_turn";
+            yield* serializer.finish(usage?.output, finishReason, {
+                input_tokens: usage?.input,
+                cache_read_input_tokens: usage?.cacheReadTokens,
+                cache_creation_input_tokens: usage?.cacheCreationTokens,
+            });
+            return {
+                text: textParts.join(""),
+                toolCalls: [...toolCalls.values()],
+                finishReason,
+                ...(usage ? { usage } : {}),
+            };
+        }
+        finally {
+            await cancel();
+            reader.releaseLock();
+        }
+    }
+    return { frames: frames(), cancel };
+}

package/dist/proxy/proxyConfig.js

@@ -189,6 +189,18 @@ function applyAccountDefaults(account) {
         metadata: account.metadata,
     };
 }
+const CODEX_REASONING_EFFORTS = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+function isCodexReasoningEffort(value) {
+    return CODEX_REASONING_EFFORTS.some((effort) => effort === value);
+}
 /**
  * Validate the shape of a parsed proxy config.
  * Returns an array of human-readable error strings (empty = valid).
@@ -215,6 +227,28 @@ export function validateProxyConfig(config) {
     }
     if (hasRouting) {
         const routing = cfg.routing;
+        const rawFallback = routing["fallback-chain"] ?? routing.fallbackChain;
+        if (Array.isArray(rawFallback)) {
+            rawFallback.forEach((entry, index) => {
+                if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+                    return;
+                }
+                const fallback = entry;
+                const effort = fallback["reasoning-effort"] !== undefined
+                    ? fallback["reasoning-effort"]
+                    : fallback.reasoningEffort;
+                if (effort === undefined) {
+                    return;
+                }
+                const field = `routing.fallback-chain[${index}].reasoning-effort`;
+                if (!isCodexReasoningEffort(effort)) {
+                    errors.push(`${field} must be one of: ${CODEX_REASONING_EFFORTS.join(", ")}`);
+                }
+                if (String(fallback.provider ?? "").trim() !== "codex") {
+                    errors.push(`${field} is only supported for provider codex`);
+                }
+            });
+        }
         const rawAccountAllowlist = routing["account-allowlist"] ?? routing.accountAllowlist;
         if (rawAccountAllowlist !== undefined) {
             if (!Array.isArray(rawAccountAllowlist)) {
@@ -350,7 +384,7 @@ function warnPlaintextApiKeys(accounts) {
  * Extracts:
  * - `strategy` ("round-robin" | "fill-first")
  * - `model-mappings` / `modelMappings` — array of {from, to, provider}
- * - `fallback-chain` / `fallbackChain` — array of {provider, model}
+ * - `fallback-chain` / `fallbackChain` — array of {provider, model, reasoningEffort?}
  * - `auto-fallback` / `autoFallback` — opt in to an unspecified provider
  * - `max-inflight-per-account` / `maxInflightPerAccount` — concurrency cap
  * - `passthroughModels` / `passthrough-models` — array of model IDs
@@ -404,7 +438,16 @@ function parseRoutingConfig(raw) {
                 logger.warn(`[proxy-config] Skipping fallback entry with empty "provider" or "model": ${JSON.stringify(e)}`);
                 return null;
             }
-            return { provider, model };
+            const effort = e["reasoning-effort"] !== undefined
+                ? e["reasoning-effort"]
+                : e.reasoningEffort;
+            return {
+                provider,
+                model,
+                ...(isCodexReasoningEffort(effort)
+                    ? { reasoningEffort: effort }
+                    : {}),
+            };
         })
             .filter((e) => e !== null);
     }

package/dist/proxy/rollingProxyServer.js

@@ -13,6 +13,7 @@ export async function startRollingProxyServer(options) {
     let requestedReplacementTimer;
     let requestedReplacementSchedule = 0;
     let requestedReplacementPending = false;
+    let requestedReplacementReason = "environment";
     let replacementQueueTail = null;
     const recoveryDelayMs = Math.max(1, options.recoveryDelayMs ?? DEFAULT_RECOVERY_DELAY_MS);
     const maxRecoveryDelayMs = Math.max(recoveryDelayMs, options.maxRecoveryDelayMs ?? DEFAULT_MAX_RECOVERY_DELAY_MS);
@@ -70,11 +71,14 @@ export async function startRollingProxyServer(options) {
             scheduleRecovery();
         }
     };
-    function scheduleRequestedReplacement() {
+    function scheduleRequestedReplacement(request) {
         if (closing) {
             return;
         }
         requestedReplacementPending = true;
+        if (request) {
+            requestedReplacementReason = request.reason;
+        }
         if (requestedReplacementTimer || replacementQueueTail) {
             return;
         }
@@ -89,15 +93,16 @@ export async function startRollingProxyServer(options) {
             }
             requestedReplacementPending = false;
             const replacementVersion = desiredVersion;
+            const replacementReason = requestedReplacementReason;
             void queueReplacement(async () => {
                 if (closing || !supervisor.snapshot().active) {
                     return;
                 }
-                options.log?.(`[proxy-supervisor] preparing same-version worker replacement version=${replacementVersion} reason=environment`);
+                options.log?.(`[proxy-supervisor] preparing same-version worker replacement version=${replacementVersion} reason=${replacementReason}`);
                 await supervisor.replace(replacementVersion);
-                options.log?.(`[proxy-supervisor] same-version worker replacement complete version=${replacementVersion} reason=environment`);
+                options.log?.(`[proxy-supervisor] same-version worker replacement complete version=${replacementVersion} reason=${replacementReason}`);
             }).catch((error) => {
-                options.log?.(`[proxy-supervisor] same-version worker replacement failed version=${replacementVersion} reason=environment: ${error instanceof Error ? error.message : String(error)}`);
+                options.log?.(`[proxy-supervisor] same-version worker replacement failed version=${replacementVersion} reason=${replacementReason}: ${error instanceof Error ? error.message : String(error)}`);
             });
         }, 50);
         requestedReplacementTimer.unref?.();
@@ -106,6 +111,7 @@ export async function startRollingProxyServer(options) {
         spawnWorker: options.spawnWorker,
         readyTimeoutMs: options.readyTimeoutMs,
         socketQueueLimit: options.socketQueueLimit,
+        maxPendingTransfers: options.maxPendingTransfers,
         socketQueueTimeoutMs: options.socketQueueTimeoutMs,
         shutdownTimeoutMs: options.shutdownTimeoutMs,
         onStateChange: stateChanged,

package/dist/proxy/rollingWorkerProcess.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { ErrorFactory } from "../utils/errorHandling.js";
-import { isProxyWorkerStatusMessage, PROXY_SOCKET_WORKER_ENV, } from "./rollingWorkerProtocol.js";
+import { isProxyWorkerStatusMessage, PROXY_SOCKET_WORKER_ENV, PROXY_SOCKET_OFFER_TIMEOUT, } from "./rollingWorkerProtocol.js";
 export function spawnProxySocketWorker(options) {
     const socketAckTimeoutMs = Math.max(1, options.socketAckTimeoutMs ?? 30_000);
     let nextSocketId = 0;
@@ -134,7 +134,13 @@ export function spawnProxySocketWorker(options) {
             }
             const socketId = `${generation}:${++nextSocketId}`;
             const timeout = setTimeout(() => {
-                settleSocket(socketId, new Error(`proxy worker ${childPid} did not accept socket within ${socketAckTimeoutMs}ms`));
+                const error = new Error(`proxy worker ${childPid} did not accept socket within ${socketAckTimeoutMs}ms`);
+                if (!pendingSockets.get(socketId)?.accepted) {
+                    // No commit was sent. The cancel message settles this offer without
+                    // terminating unrelated requests already owned by the worker.
+                    error.code = PROXY_SOCKET_OFFER_TIMEOUT;
+                }
+                settleSocket(socketId, error);
             }, socketAckTimeoutMs);
             timeout.unref?.();
             pendingSockets.set(socketId, {