@f5-sales-demo/pi-ai 22.7.0 → 22.7.2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/pi-ai",
-	"version": "22.7.0",
+	"version": "22.7.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Can Boluk",
@@ -46,7 +46,7 @@
 		"@anthropic-ai/sdk": "0.124.0",
 		"@aws-sdk/client-bedrock-runtime": "3.1127.0",
 		"@bufbuild/protobuf": "2.14.1",
-		"@f5-sales-demo/pi-utils": "22.7.0",
+		"@f5-sales-demo/pi-utils": "22.7.2",
 		"@google/genai": "2.21.0",
 		"@sinclair/typebox": "0.34.52",
 		"@smithy/node-http-handler": "4.12.1",

package/src/providers/anthropic.ts

@@ -192,7 +192,7 @@ function getCacheControl(
 }
 
 // Stealth mode: Mimic Claude Code headers and tool prefixing.
-export const claudeCodeVersion = "2.1.286";
+export const claudeCodeVersion = "2.1.287";
 export const claudeToolPrefix: string = "proxy_";
 export const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 

package/src/providers/openai-codex-responses.ts

@@ -26,6 +26,7 @@ import { getEnvApiKey } from "../stream";
 import {
 	type Api,
 	type AssistantMessage,
+	type AssistantMessageEvent,
 	type Context,
 	isSpecialServiceTier,
 	type Model,
@@ -47,7 +48,7 @@ import {
 } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
-import { getOpenAIStreamIdleTimeoutMs, iterateWithIdleTimeout } from "../utils/idle-iterator";
+import { getOpenAIStreamIdleTimeoutMs } from "../utils/idle-iterator";
 import { parseStreamingJson } from "../utils/json-parse";
 import { isTransportClosureError } from "../utils/retry";
 import { adaptSchemaForStrict, NO_STRICT } from "../utils/schema";
@@ -185,7 +186,6 @@ interface CodexRequestContext {
 
 interface CodexRequestSetup {
 	requestSignal: AbortSignal;
-	wrapCodexSseStream: (source: AsyncGenerator<Record<string, unknown>>) => AsyncGenerator<Record<string, unknown>>;
 	requestAbortController: AbortController;
 }
 
@@ -195,6 +195,8 @@ interface CodexWebSocketRequestState {
 }
 
 interface CodexStreamRuntime {
+	stagedEvents: AssistantMessageEvent[];
+	firstTransportFailure?: unknown;
 	websocketRequestState?: CodexWebSocketRequestState;
 	continuationRecoveryAttempt: number;
 	sawResponseAccepted: boolean;
@@ -208,6 +210,7 @@ interface CodexStreamRuntime {
 	outputSlots: Map<number, { item: CodexEventItem | null; block: CodexOutputBlock | null; index: number }>;
 	currentIndex: number;
 	completedItemIds: Set<string>;
+	completedContentIndices: Set<number>;
 	currentBlock: CodexOutputBlock | null;
 	nativeOutputItems: Array<Record<string, unknown>>;
 	websocketStreamRetries: number;
@@ -219,6 +222,7 @@ interface CodexStreamRuntime {
 }
 
 interface CodexStreamProcessingContext {
+	runtime?: CodexStreamRuntime;
 	model: Model<"openai-codex-responses">;
 	output: AssistantMessage;
 	stream: AssistantMessageEventStream;
@@ -298,7 +302,13 @@ function getCodexProviderSessionState(
 }
 
 function createCodexWebSocketTransportError(message: string): Error {
-	return new Error(`${CODEX_WEBSOCKET_TRANSPORT_ERROR_PREFIX}: ${message}`);
+	return Object.assign(new Error(`${CODEX_WEBSOCKET_TRANSPORT_ERROR_PREFIX}: ${message}`), {
+		codexTransportInterruption: message.startsWith("websocket closed")
+			? "socket_closed"
+			: message === "idle timeout waiting for websocket" || message === "timeout waiting for first websocket event"
+				? "idle_timeout"
+				: undefined,
+	});
 }
 
 function isCodexWebSocketFatalError(error: Error): boolean {
@@ -453,15 +463,7 @@ function createRequestSetup(options: OpenAICodexResponsesOptions | undefined): C
 	const requestSignal = options?.signal
 		? AbortSignal.any([options.signal, requestAbortController.signal])
 		: requestAbortController.signal;
-	const wrapCodexSseStream = (
-		source: AsyncGenerator<Record<string, unknown>>,
-	): AsyncGenerator<Record<string, unknown>> =>
-		iterateWithIdleTimeout(source, {
-			idleTimeoutMs: getOpenAIStreamIdleTimeoutMs(),
-			errorMessage: "OpenAI Codex SSE stream stalled while waiting for the next event",
-			onIdle: () => requestAbortController.abort(),
-		});
-	return { requestAbortController, requestSignal, wrapCodexSseStream };
+	return { requestAbortController, requestSignal };
 }
 
 async function buildCodexRequestContext(
@@ -766,6 +768,60 @@ async function openCodexWebSocketTransport(
 	return { eventStream, requestBodyForState, transport: "websocket", websocketRequestState };
 }
 
+class CodexSseIdleTimeoutError extends Error {
+	constructor() {
+		super("OpenAI Codex SSE stream stalled while waiting for the next event");
+		this.name = "CodexSseIdleTimeoutError";
+	}
+}
+
+async function* iterateCodexSseAttempt(
+	source: AsyncGenerator<Record<string, unknown>>,
+	attempt: AbortController,
+	cleanup: () => void,
+): AsyncGenerator<Record<string, unknown>> {
+	const timeoutMs = getOpenAIStreamIdleTimeoutMs();
+	try {
+		while (true) {
+			attempt.signal.throwIfAborted();
+			let timer: NodeJS.Timeout | undefined;
+			try {
+				const next = source.next();
+				const result =
+					timeoutMs === undefined
+						? await next
+						: await Promise.race([
+								next,
+								new Promise<never>((_resolve, reject) => {
+									timer = setTimeout(() => {
+										const error = new CodexSseIdleTimeoutError();
+										reject(error);
+										attempt.abort(error);
+									}, timeoutMs);
+								}),
+							]);
+				if (timer !== undefined) {
+					clearTimeout(timer);
+					timer = undefined;
+				}
+				attempt.signal.throwIfAborted();
+				if (result.done) return;
+				yield result.value;
+			} finally {
+				if (timer !== undefined) clearTimeout(timer);
+			}
+		}
+	} finally {
+		attempt.abort();
+		cleanup();
+		try {
+			await source.return(undefined);
+		} catch {
+			/* Preserve the original stream failure. */
+		}
+	}
+}
+
 async function openCodexSseTransport(
 	requestContext: CodexRequestContext,
 	requestSetup: CodexRequestSetup,
@@ -779,8 +835,16 @@ async function openCodexSseTransport(
 	transport: CodexTransport;
 	websocketRequestState?: CodexWebSocketRequestState;
 }> {
-	const eventStream = requestSetup.wrapCodexSseStream(
-		await openCodexSseEventStream(
+	const attempt = new AbortController();
+	const signal = requestSetup.requestSignal;
+	const onAbort = () => attempt.abort(signal.reason);
+	const cleanup = () => signal.removeEventListener("abort", onAbort);
+	signal.addEventListener("abort", onAbort, { once: true });
+	if (signal.aborted) onAbort();
+	let source: AsyncGenerator<Record<string, unknown>>;
+	try {
+		attempt.signal.throwIfAborted();
+		source = await openCodexSseEventStream(
 			requestContext.url,
 			requestContext.requestHeaders,
 			requestContext.accountId,
@@ -788,10 +852,16 @@ async function openCodexSseTransport(
 			options?.sessionId,
 			body,
 			state,
-			requestSetup.requestSignal,
+			attempt.signal,
 			retryFetch,
-		),
-	);
+		);
+	} catch (error) {
+		attempt.abort();
+		cleanup();
+		throw error;
+	}
+	const eventStream = iterateCodexSseAttempt(source, attempt, cleanup);
+
 	return { eventStream, requestBodyForState: structuredCloneJSON(body), transport: "sse" };
 }
 
@@ -837,6 +907,7 @@ function createCodexStreamRuntime(initial: {
 	websocketRequestState?: CodexWebSocketRequestState;
 }): CodexStreamRuntime {
 	return {
+		stagedEvents: [],
 		websocketRequestState: initial.websocketRequestState,
 		continuationRecoveryAttempt: 0,
 		sawResponseAccepted: false,
@@ -850,6 +921,7 @@ function createCodexStreamRuntime(initial: {
 		outputSlots: new Map(),
 		currentIndex: -1,
 		completedItemIds: new Set(),
+		completedContentIndices: new Set(),
 		nativeOutputItems: [],
 		websocketStreamRetries: 0,
 		providerRetryAttempt: 0,
@@ -860,6 +932,30 @@ function createCodexStreamRuntime(initial: {
 	};
 }
 
+// Empty normalized blocks belong to the attempt until replay becomes unsafe.
+class CodexAttemptEventStream extends AssistantMessageEventStream {
+	constructor(
+		private readonly target: AssistantMessageEventStream,
+		private readonly runtime: CodexStreamRuntime,
+	) {
+		super();
+	}
+
+	override push(event: AssistantMessageEvent): void {
+		if (this.runtime.sawReplayUnsafeActivity || this.runtime.sawTerminalEvent) {
+			this.flush();
+			this.target.push(event);
+		} else {
+			this.runtime.stagedEvents.push(structuredCloneJSON(event));
+		}
+	}
+
+	flush(): void {
+		for (const event of this.runtime.stagedEvents) this.target.push(event);
+		this.runtime.stagedEvents.length = 0;
+	}
+}
+
 async function processCodexResponseStream(
 	context: CodexStreamProcessingContext,
 	runtime: CodexStreamRuntime,
@@ -867,6 +963,7 @@ async function processCodexResponseStream(
 	const { output, stream } = context;
 	runtime.grammarToolInputProperties = context.requestContext.grammarToolInputProperties;
 	stream.push({ type: "start", partial: output });
+	const attemptStream = new CodexAttemptEventStream(stream, runtime);
 
 	while (true) {
 		try {
@@ -875,10 +972,12 @@ async function processCodexResponseStream(
 				await context.options?.onProviderStreamEvent?.(rawEvent, context.model);
 				firstTokenTime = handleCodexStreamEvent({
 					...context,
+					stream: attemptStream,
 					runtime,
 					rawEvent,
 					firstTokenTime,
 				});
+				if (runtime.sawReplayUnsafeActivity || runtime.sawTerminalEvent) attemptStream.flush();
 			}
 			if (!runtime.sawTerminalEvent) {
 				throw Object.assign(new Error("Codex stream ended before terminal completion event"), {
@@ -1047,6 +1146,7 @@ function handleCodexStreamEvent(args: {
 		if (itemId && runtime.completedItemIds.has(itemId)) return firstTokenTime;
 		if (itemId) runtime.completedItemIds.add(itemId);
 		handleOutputItemDone(model, output, stream, runtime, rawEvent, blockIndex);
+		if (runtime.currentIndex >= 0) runtime.completedContentIndices.add(runtime.currentIndex);
 		runtime.outputSlots.delete(
 			typeof rawEvent.output_index === "number" ? rawEvent.output_index : runtime.currentIndex,
 		);
@@ -1215,6 +1315,7 @@ function handleOutputItemDone(
 ): void {
 	const item = structuredCloneJSON(rawEvent.item) as CodexEventItem;
 	runtime.nativeOutputItems.push(item as unknown as Record<string, unknown>);
+	output.providerPayload = createOpenAIResponsesHistoryPayload(model.provider, runtime.nativeOutputItems);
 	if (item.type === "custom_tool_call" && runtime.currentBlock?.type === "toolCall") {
 		const property = runtime.grammarToolInputProperties?.get(item.name) ?? "input";
 		Object.assign(runtime.currentBlock, {
@@ -1270,7 +1371,7 @@ function handleOutputItemDone(
 			type: "toolCall",
 			id: `${item.call_id}|${item.id}`,
 			name: item.name,
-			arguments: parseStreamingJson(item.arguments || "{}"),
+			arguments: JSON.parse(item.arguments || "{}"),
 		};
 		if (runtime.currentBlock?.type === "toolCall") {
 			Object.assign(runtime.currentBlock, toolCall);
@@ -1409,7 +1510,7 @@ async function recoverCodexStreamError(
 	runtime: CodexStreamRuntime,
 	error: unknown,
 ): Promise<boolean> {
-	if (runtime.transport === "sse" && isTransportClosureError(error)) {
+	if (runtime.transport === "sse" && (error instanceof CodexSseIdleTimeoutError || isTransportClosureError(error))) {
 		return tryRestartCodexSseTransport(context, runtime, error);
 	}
 	if (isCodexRejectedContinuation(error)) {
@@ -1427,11 +1528,27 @@ async function recoverCodexStreamError(
 	return false;
 }
 
+async function sleepBeforeCodexSseRestart(delayMs: number, signal: AbortSignal): Promise<void> {
+	signal.throwIfAborted();
+	const { promise, resolve, reject } = Promise.withResolvers<void>();
+	const timer = setTimeout(resolve, delayMs);
+	const onAbort = () => reject(signal.reason);
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		await promise;
+		signal.throwIfAborted();
+	} finally {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+
 async function tryRestartCodexSseTransport(
 	context: CodexStreamProcessingContext,
 	runtime: CodexStreamRuntime,
 	originalError: unknown,
 ): Promise<boolean> {
+	runtime.firstTransportFailure ??= originalError;
 	let error = originalError;
 	while (true) {
 		const replayEligible =
@@ -1451,22 +1568,29 @@ async function tryRestartCodexSseTransport(
 			terminalEventSeen: runtime.sawTerminalEvent,
 			replayEligible,
 		});
-		if (!replayEligible || !isTransportClosureError(error)) {
+		if (!replayEligible || !(error instanceof CodexSseIdleTimeoutError || isTransportClosureError(error))) {
 			if (error !== originalError) throw error;
 			return false;
 		}
-		if (runtime.transportRestartAttempt >= 2) throw originalError;
+		if (runtime.transportRestartAttempt >= Math.max(0, context.options?.maxRetries ?? 2))
+			throw runtime.firstTransportFailure;
 		runtime.transportRestartAttempt += 1;
-		await runtime.eventStream.return(undefined);
+		try {
+			await runtime.eventStream.return(undefined);
+		} catch {
+			/* Preserve the recovery failure. */
+		}
 		runtime.currentItem = null;
 		runtime.currentBlock = null;
 		runtime.currentIndex = -1;
 		runtime.outputSlots.clear();
 		runtime.completedItemIds.clear();
+		runtime.completedContentIndices.clear();
 		runtime.nativeOutputItems.length = 0;
 		runtime.sawResponseAccepted = false;
 		runtime.sawOutputEvent = false;
 		runtime.sawTerminalEvent = false;
+		runtime.stagedEvents.length = 0;
 		resetOutputState(context.output);
 		delete context.output.responseId;
 		delete context.output.providerPayload;
@@ -1480,7 +1604,10 @@ async function tryRestartCodexSseTransport(
 			resetCodexWebSocketAppendState(state);
 			resetCodexSessionMetadata(state);
 		}
-		await abortableSleep(500 * runtime.transportRestartAttempt, context.requestSetup.requestSignal);
+		await sleepBeforeCodexSseRestart(
+			500 * (runtime.transportRestartAttempt + Math.max(0, 2 - (context.options?.maxRetries ?? 2))),
+			context.requestSetup.requestSignal,
+		);
 		try {
 			const next = await openCodexSseTransport(
 				context.requestContext,
@@ -1529,6 +1656,14 @@ async function tryRecoverCodexContinuation(
 	resetCodexWebSocketAppendState(state);
 	resetCodexSessionMetadata(state);
 	if (!eligible) return false;
+	if (context.options?.maxRetries !== undefined) {
+		if (runtime.transportRestartAttempt >= context.options.maxRetries) return false;
+		runtime.transportRestartAttempt += 1;
+		await sleepBeforeCodexSseRestart(
+			500 * (runtime.transportRestartAttempt + Math.max(0, 2 - (context.options?.maxRetries ?? 2))),
+			context.requestSetup.requestSignal,
+		);
+	}
 	runtime.continuationRecoveryAttempt += 1;
 	logCodexDebug("codex continuation recovery", {
 		reason: "previous_response_unavailable",
@@ -1570,6 +1705,14 @@ async function tryReconnectCodexWebSocketOnConnectionLimit(
 	}
 
 	// Close the stale connection so getOrCreateCodexWebSocketConnection creates a fresh one.
+	if (context.options?.maxRetries !== undefined) {
+		if (runtime.transportRestartAttempt >= context.options.maxRetries) return false;
+		runtime.transportRestartAttempt += 1;
+		await sleepBeforeCodexSseRestart(
+			500 * (runtime.transportRestartAttempt + Math.max(0, 2 - (context.options?.maxRetries ?? 2))),
+			context.requestSetup.requestSignal,
+		);
+	}
 	websocketState.connection?.close("connection_limit");
 	websocketState.connection = undefined;
 	resetCodexWebSocketAppendState(websocketState);
@@ -1588,7 +1731,9 @@ async function tryReconnectCodexWebSocketOnConnectionLimit(
 		runtime.currentBlock = null;
 		runtime.outputSlots.clear();
 		runtime.completedItemIds.clear();
+		runtime.completedContentIndices.clear();
 		runtime.nativeOutputItems.length = 0;
+		runtime.stagedEvents.length = 0;
 		resetOutputState(context.output);
 		context.firstTokenTime = undefined;
 		recordCodexWebSocketFailure(websocketState, true);
@@ -1616,6 +1761,14 @@ async function tryReplayWebsocketFailureOverSse(
 		!runtime.sawTerminalEvent &&
 		!context.options?.signal?.aborted;
 	if (!canReplay) return false;
+	if (context.options?.maxRetries !== undefined) {
+		if (runtime.transportRestartAttempt >= context.options.maxRetries) return false;
+		runtime.transportRestartAttempt += 1;
+		await sleepBeforeCodexSseRestart(
+			500 * (runtime.transportRestartAttempt + Math.max(0, 2 - (context.options?.maxRetries ?? 2))),
+			context.requestSetup.requestSignal,
+		);
+	}
 
 	const state = websocketState;
 	const streamError = error instanceof Error ? error : new Error(String(error));
@@ -1649,7 +1802,9 @@ async function tryReplayWebsocketFailureOverSse(
 		runtime.currentBlock = null;
 		runtime.outputSlots.clear();
 		runtime.completedItemIds.clear();
+		runtime.completedContentIndices.clear();
 		runtime.nativeOutputItems.length = 0;
+		runtime.stagedEvents.length = 0;
 		resetOutputState(context.output);
 		context.firstTokenTime = undefined;
 	}
@@ -1690,7 +1845,9 @@ async function tryRetryCodexProviderError(
 	runtime.currentBlock = null;
 	runtime.outputSlots.clear();
 	runtime.completedItemIds.clear();
+	runtime.completedContentIndices.clear();
 	runtime.sawTerminalEvent = false;
+	runtime.stagedEvents.length = 0;
 	resetOutputState(context.output);
 	context.firstTokenTime = undefined;
 	await abortableSleep(CODEX_RETRY_DELAY_MS * runtime.providerRetryAttempt, context.requestSetup.requestSignal);
@@ -1752,6 +1909,37 @@ async function handleCodexStreamFailure(
 		resetCodexWebSocketAppendState(context.requestContext.websocketState);
 		resetCodexSessionMetadata(context.requestContext.websocketState);
 	}
+	const runtime = context.runtime;
+	const interrupted =
+		!context.requestSetup.requestSignal.aborted &&
+		runtime &&
+		!runtime.sawTerminalEvent &&
+		!(error instanceof CodexProviderStreamError) &&
+		(error instanceof CodexSseIdleTimeoutError ||
+			isTransportClosureError(error) ||
+			(error as { codexTransportInterruption?: string })?.codexTransportInterruption);
+	if (interrupted) {
+		output.interruption = {
+			transport: runtime.transport,
+			classification:
+				error instanceof CodexSseIdleTimeoutError ||
+				(error as { codexTransportInterruption?: string }).codexTransportInterruption === "idle_timeout"
+					? "idle_timeout"
+					: (error as { code?: string }).code === "ERR_STREAM_PREMATURE_CLOSE"
+						? "premature_eof"
+						: "socket_closed",
+			providerRetriesConsumed: runtime.transportRestartAttempt,
+			completedContentIndices: [...runtime.completedContentIndices].sort((a, b) => a - b),
+		};
+		output.providerPayload = createOpenAIResponsesHistoryPayload(context.model.provider, runtime.nativeOutputItems);
+	}
+	if (runtime) {
+		try {
+			await runtime.eventStream.return(undefined);
+		} catch {
+			/* Preserve the original failure. */
+		}
+	}
 	output.stopReason = context.options?.signal?.aborted ? "aborted" : "error";
 	output.errorMessage = await finalizeErrorMessage(error, context.requestContext.rawRequestDump);
 	output.providerFailureCode = sanitizeProviderFailureCode(
@@ -1791,6 +1979,7 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 			}
 
 			processingContext = {
+				runtime,
 				model,
 				output,
 				stream,
@@ -2465,7 +2654,39 @@ async function openCodexSseEventStream(
 	if (!response.body) {
 		throw new Error("No response body");
 	}
-	return readSseJson<Record<string, unknown>>(response.body, signal);
+	signal?.throwIfAborted();
+	const reader = response.body.getReader();
+	let closed = false;
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		// Cancel settles pending reads synchronously; do not await an upstream cancel hook.
+		void reader.cancel().catch(() => {});
+		reader.releaseLock();
+	};
+	const onAbort = () => close();
+	signal?.addEventListener("abort", onAbort, { once: true });
+	const owned = new ReadableStream<Uint8Array>({
+		async pull(controller) {
+			try {
+				const result = await reader.read();
+				if (result.done) controller.close();
+				else controller.enqueue(result.value);
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		cancel: close,
+	});
+	async function* events(): AsyncGenerator<Record<string, unknown>> {
+		try {
+			yield* readSseJson<Record<string, unknown>>(owned);
+		} finally {
+			close();
+			signal?.removeEventListener("abort", onAbort);
+		}
+	}
+	return events();
 }
 
 function createCodexHeaders(
@@ -2554,6 +2775,7 @@ async function fetchWithRetry(url: string, init: RequestInit, signal?: AbortSign
 	let rateLimitTimeSpent = 0;
 	while (true) {
 		try {
+			signal?.throwIfAborted();
 			const response = await fetch(url, { ...init, signal: signal ?? init.signal });
 			if (!retry || !CODEX_RETRYABLE_STATUS.has(response.status)) {
 				return response;
@@ -2681,7 +2903,7 @@ function convertMessages(model: Model<"openai-codex-responses">, context: Contex
 
 			const outputItems: ResponseInput = [];
 			for (const block of msg.content) {
-				if (block.type === "thinking" && msg.stopReason !== "error") {
+				if (block.type === "thinking" && (msg.stopReason !== "error" || !!assistantMsg.interruption)) {
 					if (block.thinkingSignature) {
 						outputItems.push(JSON.parse(block.thinkingSignature) as ResponseReasoningItem);
 					}

package/src/providers/openai-responses-shared.ts

@@ -135,7 +135,7 @@ export function convertResponsesAssistantMessage<TApi extends Api>(
 		assistantMsg.model !== model.id && assistantMsg.provider === model.provider && assistantMsg.api === model.api;
 
 	for (const block of assistantMsg.content) {
-		if (block.type === "thinking" && assistantMsg.stopReason !== "error") {
+		if (block.type === "thinking" && (assistantMsg.stopReason !== "error" || !!assistantMsg.interruption)) {
 			if (!includeThinkingSignatures) {
 				continue;
 			}

package/src/providers/transform-messages.ts

@@ -69,7 +69,9 @@ export function transformMessages<TApi extends Api>(
 			// Aborted/errored messages may have partially-streamed thinking signatures.
 			// A partial signature is invalid and will be rejected by the API, so we must
 			// strip signatures from thinking blocks in these messages.
-			const hasInvalidSignatures = assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error";
+			const hasInvalidSignatures =
+				assistantMsg.stopReason === "aborted" ||
+				(assistantMsg.stopReason === "error" && !assistantMsg.interruption);
 
 			const transformedContent = assistantMsg.content.flatMap(block => {
 				if (block.type === "thinking") {
@@ -205,7 +207,10 @@ export function transformMessages<TApi extends Api>(
 			const assistantMsg = msg as AssistantMessage;
 			const toolCalls = assistantMsg.content.filter(b => b.type === "toolCall") as ToolCall[];
 
-			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+			if (
+				(assistantMsg.stopReason === "error" && !assistantMsg.interruption) ||
+				assistantMsg.stopReason === "aborted"
+			) {
 				// Keep the assistant message with tool calls intact. If real tool results follow, preserve them;
 				// otherwise synthesize aborted results before the next turn boundary.
 				result.push(msg);

package/src/types.ts

@@ -442,6 +442,14 @@ export interface DeveloperMessage {
 }
 
 export interface AssistantMessage {
+	/** Completed content retained after a typed transport interruption. */
+	interruption?: {
+		transport: "sse" | "websocket";
+		classification: "socket_closed" | "premature_eof" | "idle_timeout";
+		providerRetriesConsumed: number;
+		toolChoiceServed?: boolean;
+		completedContentIndices: number[];
+	};
 	/** A queued background request; poll using the same provider route. */
 	deferred?: DeferredHandle;
 	providerRewrite?: {