@juspay/neurolink 12.12.4 → 12.12.6

package/dist/providers/openaiChatCompletionsBase.js

@@ -66,6 +66,73 @@ const yieldsSchemaValidObject = (text, schema) => {
     const coerced = coerceJsonToSchema(text, schema);
     return coerced !== null && schemaAccepts(schema, coerced.structuredData);
 };
+// Pull one native chunk at a time and forward cancellation to its iterator.
+const chunksToV3Stream = (source, completion, cancel) => {
+    const iterator = source[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    controller.enqueue(await completion);
+                    controller.close();
+                }
+                else if (next.value.reasoning) {
+                    controller.enqueue({
+                        type: "reasoning-delta",
+                        delta: next.value.reasoning,
+                    });
+                }
+                else {
+                    controller.enqueue({ type: "text-delta", delta: next.value.content });
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel() {
+            cancel();
+            await iterator.return?.();
+        },
+    });
+};
+async function* v3StreamToChunks(stream, onFinish) {
+    const reader = stream.getReader();
+    let done = false;
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done) {
+                done = true;
+                return;
+            }
+            const part = next.value;
+            if (part.type === "text-delta") {
+                yield { content: part.delta };
+            }
+            else if (part.type === "reasoning-delta") {
+                yield { content: "", reasoning: part.delta };
+            }
+            else if (part.type === "finish") {
+                onFinish(part);
+            }
+            else if (part.type === "error") {
+                throw part.error;
+            }
+        }
+    }
+    finally {
+        try {
+            if (!done) {
+                await reader.cancel();
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
 export class OpenAIChatCompletionsProvider extends BaseProvider {
     config;
     resolvedModel;
@@ -946,7 +1013,10 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         let wireNameMaps;
         let openAITools;
         let openAIToolChoice;
-        let conversation;
+        // The prompt is kept in its pre-wire shape. Model middleware transforms
+        // `params.prompt`, and the conversion to the chat-completions wire format
+        // has to happen AFTER that or the transform would be discarded.
+        let promptMessages;
         try {
             modelId = await this.resolveModelName();
             const shouldUseTools = !options.disableTools && this.supportsTools();
@@ -962,8 +1032,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 ? buildToolsForOpenAI(toolsRecord, wireNameMaps?.toWire)
                 : undefined;
             openAIToolChoice = mapNeuroLinkToolChoice(resolveToolChoice(options, toolsRecord, shouldUseTools), wireNameMaps?.toWire);
-            const initialMessages = await this.buildMessagesForStream(options);
-            conversation = messageBuilderToOpenAI(initialMessages, wireNameMaps?.toWire);
+            promptMessages = (await this.buildMessagesForStream(options));
         }
         catch (setupErr) {
             timeoutController?.cleanup();
@@ -979,26 +1048,136 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const channel = createStreamChannel();
         // Per-provider lifecycle hook (e.g. OTel span wrap for LiteLLM).
         const lifecycle = this.onStreamStart(modelId);
-        const loopPromise = this.runStreamLoop({
-            maxSteps,
+        // Model middleware on the streaming path.
+        //
+        // The base model below is not `buildDelegatingModel()`'s — that one's
+        // `doGenerate` is a single wire call and its `doStream` is a stub. This
+        // one's `doStream` starts the real multi-step stream loop, which is what
+        // "produce the stream for this request" means here. Wrapping it gives the
+        // streaming path the contract the generate path has always had:
+        // `transformParams` can rewrite the prompt before a byte is sent, and
+        // `wrapStream` can observe, filter, or replace the stream outright.
+        //
+        // Honoured on the way back in: `prompt`, `maxOutputTokens`, `temperature`
+        // and `topP`. `tools` is offered read-only — a middleware that rewrites it
+        // gets a WARN rather than a silent drop, because re-deriving the wire tool
+        // list here would diverge from `buildToolsForOpenAI`.
+        const v3Tools = openAITools?.map((t) => ({
+            type: "function",
+            name: t.function.name,
+            description: t.function.description,
+            inputSchema: t.function.parameters,
+        }));
+        const v3Params = {
+            prompt: promptMessages,
+            ...(v3Tools ? { tools: v3Tools } : {}),
+            ...(options.maxTokens !== undefined
+                ? { maxOutputTokens: options.maxTokens }
+                : {}),
+            ...(options.temperature !== undefined
+                ? { temperature: options.temperature }
+                : {}),
+            ...(options.topP !== undefined ? { topP: options.topP } : {}),
+        };
+        let loopPromise;
+        const providerNameForLoop = this.providerName;
+        const streamBaseModel = {
+            specificationVersion: "v3",
+            provider: providerNameForLoop,
             modelId,
-            url,
-            fetchImpl,
-            abortSignal,
-            options,
-            conversation,
-            openAITools,
-            openAIToolChoice,
-            toolsRecord,
-            toolNameFromWire: wireNameMaps?.fromWire,
-            emitter,
-            toolsUsed,
-            toolExecutionSummaries,
-            pushChunk: channel.push,
-            closeChannel: channel.close,
-            resolveUsage,
-            resolveFinish,
-        });
+            supportedUrls: {},
+            doGenerate: async (params) => {
+                const model = await this.getAISDKModel();
+                if (typeof model === "string") {
+                    throw new Error("Native model handle required");
+                }
+                return model.doGenerate(params);
+            },
+            doStream: async (params) => {
+                if (params?.tools !== undefined && params.tools !== v3Tools) {
+                    logger.warn(`${providerNameForLoop}: middleware rewrote 'tools' on the streaming path; tool rewrites are not applied to the wire request yet — the original tool list was sent.`);
+                }
+                const transformedPrompt = Array.isArray(params?.prompt)
+                    ? params.prompt
+                    : promptMessages;
+                const conversation = messageBuilderToOpenAI(transformedPrompt, wireNameMaps?.toWire);
+                const sampled = {
+                    ...options,
+                    ...(typeof params?.maxOutputTokens === "number"
+                        ? { maxTokens: params.maxOutputTokens }
+                        : {}),
+                    ...(typeof params?.temperature === "number"
+                        ? { temperature: params.temperature }
+                        : {}),
+                    ...(typeof params?.topP === "number" ? { topP: params.topP } : {}),
+                };
+                loopPromise = this.runStreamLoop({
+                    maxSteps,
+                    modelId,
+                    url,
+                    fetchImpl,
+                    abortSignal,
+                    options: sampled,
+                    conversation,
+                    openAITools,
+                    openAIToolChoice,
+                    toolsRecord,
+                    toolNameFromWire: wireNameMaps?.fromWire,
+                    emitter,
+                    toolsUsed,
+                    toolExecutionSummaries,
+                    pushChunk: channel.push,
+                    closeChannel: channel.close,
+                    resolveUsage,
+                    resolveFinish,
+                });
+                const completion = loopPromise.then(() => Promise.all([usagePromise, finishPromise]).then(([usage, reason]) => ({
+                    type: "finish",
+                    finishReason: { unified: reason },
+                    usage: {
+                        inputTokens: {
+                            total: usage.promptTokens,
+                            cacheRead: usage.cacheReadTokens,
+                        },
+                        outputTokens: { total: usage.completionTokens },
+                    },
+                })));
+                // The producer can reject before the consumer pulls its terminal event.
+                void completion.catch(() => undefined);
+                return {
+                    stream: chunksToV3Stream(channel.iterable, completion, () => consumerAbortController.abort()),
+                };
+            },
+        };
+        // A middleware chain that blocks (guardrails' precall path) returns its own
+        // stream without calling `doStream`, so the loop may never start. Every
+        // later reader of `loopPromise` has to tolerate that.
+        let chunkSource;
+        try {
+            const wrappedStreamModel = await this.applyMiddlewareToModel(streamBaseModel, options);
+            if (typeof wrappedStreamModel === "string") {
+                throw new Error("Native stream model handle required");
+            }
+            const { stream } = await wrappedStreamModel.doStream(v3Params);
+            chunkSource = v3StreamToChunks(stream, (part) => {
+                if (!loopPromise) {
+                    const input = part.usage.inputTokens.total ?? 0;
+                    const output = part.usage.outputTokens.total ?? 0;
+                    resolveUsage({
+                        promptTokens: input,
+                        completionTokens: output,
+                        totalTokens: input + output,
+                    });
+                    resolveFinish(part.finishReason.unified);
+                }
+            });
+        }
+        catch (error) {
+            consumerAbortController.abort();
+            channel.close();
+            timeoutController?.cleanup();
+            throw error;
+        }
         // Closure-scoped capture: the runStreamLoop's catch block stashes the
         // underlying provider error here so we can pass it through to
         // buildNoOutputSentinel for richer telemetry (matches the pattern in
@@ -1025,7 +1204,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const transformedStream = async function* () {
             let contentYielded = 0;
             try {
-                for await (const chunk of channel.iterable) {
+                for await (const chunk of chunkSource) {
                     if ("content" in chunk &&
                         typeof chunk.content === "string" &&
                         chunk.content.length > 0) {
@@ -1034,6 +1213,8 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                     yield chunk;
                 }
                 // Surface any error that the loop threw after we drained the channel.
+                // `loopPromise` is undefined when a middleware blocked the request
+                // before `doStream` ran, in which case there is no loop to surface.
                 await loopPromise;
                 // No-output path: stream completed normally but yielded zero text.
                 // Build an enriched sentinel + stamp the active OTel span so
@@ -1062,6 +1243,15 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
                 throw streamError;
             }
             finally {
+                if (!loopPromise) {
+                    resolveUsage({
+                        promptTokens: 0,
+                        completionTokens: 0,
+                        totalTokens: 0,
+                    });
+                    resolveFinish("stop");
+                }
+                timeoutController?.cleanup();
                 if (!consumerAbortController.signal.aborted) {
                     consumerAbortController.abort();
                 }
@@ -1101,7 +1291,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             }))),
         });
         loopPromise
-            .finally(() => timeoutController?.cleanup())
+            ?.finally(() => timeoutController?.cleanup())
             .catch((error) => {
             captureProviderError(error);
         });

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,7 +6,7 @@
  * in the native Codex proxy handler so fallback traffic follows the same pool
  * rules as a native Codex request.
  */
-import type { ClaudeRequest, CodexFallbackResult, CodexReasoningEffort, 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;
@@ -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;
@@ -372,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/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, {

package/dist/proxy/rollingWorkerProtocol.d.ts

@@ -1,5 +1,7 @@
 import type { ProxyWorkerControlMessage, ProxyWorkerStatusMessage } from "../types/index.js";
 export declare const PROXY_SOCKET_WORKER_ENV = "NEUROLINK_PROXY_SOCKET_WORKER";
+/** The worker has not been sent a commit and cannot have served this socket. */
+export declare const PROXY_SOCKET_OFFER_TIMEOUT = "PROXY_SOCKET_OFFER_TIMEOUT";
 export declare const PROXY_ROLLING_SUPERVISOR_ENV = "NEUROLINK_PROXY_ROLLING_SUPERVISOR";
 export declare function isProxyWorkerControlMessage(value: unknown): value is ProxyWorkerControlMessage;
 export declare function isProxyWorkerStatusMessage(value: unknown): value is ProxyWorkerStatusMessage;

package/dist/proxy/rollingWorkerProtocol.js

@@ -1,4 +1,6 @@
 export const PROXY_SOCKET_WORKER_ENV = "NEUROLINK_PROXY_SOCKET_WORKER";
+/** The worker has not been sent a commit and cannot have served this socket. */
+export const PROXY_SOCKET_OFFER_TIMEOUT = "PROXY_SOCKET_OFFER_TIMEOUT";
 export const PROXY_ROLLING_SUPERVISOR_ENV = "NEUROLINK_PROXY_ROLLING_SUPERVISOR";
 export function isProxyWorkerControlMessage(value) {
     if (!value || typeof value !== "object") {

package/dist/proxy/rollingWorkerSupervisor.d.ts

@@ -11,6 +11,10 @@ export declare class RollingWorkerSupervisor {
     private candidate;
     private readonly draining;
     private readonly queuedSockets;
+    private flushingSockets;
+    private consecutiveOfferTimeouts;
+    private lastStallReplacementAt;
+    private transferStateTimer;
     private replacement;
     private rejectedSockets;
     private failedTransfers;
@@ -40,5 +44,6 @@ export declare class RollingWorkerSupervisor {
     private extractLifecycleFailureDetails;
     private recordFailure;
     private recordEvent;
+    private scheduleTransferState;
     private publishState;
 }