@howaboua/pi-codex-conversion 1.0.24 → 1.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {

package/src/providers/openai-codex-custom-provider.ts

@@ -105,6 +105,12 @@ interface SessionWebSocketCacheEntry {
 	idleTimer?: ReturnType<typeof setTimeout>;
 }
 
+interface AcquiredWebSocket {
+	socket: WebSocketLike;
+	reused: boolean;
+	release: (options?: { keep?: boolean }) => void;
+}
+
 let fsPromisesPromise: Promise<typeof import("node:fs/promises")> | undefined;
 const workspaceRootCache = new Map<string, Promise<string>>();
 
@@ -753,12 +759,13 @@ async function acquireWebSocket(
 	headers: Headers,
 	sessionId: string | undefined,
 	signal: AbortSignal | undefined,
-): Promise<{ socket: WebSocketLike; release: (options?: { keep?: boolean }) => void }> {
+): Promise<AcquiredWebSocket> {
 	const cacheKey = buildWebSocketCacheKey(url, headers, sessionId);
 	if (!cacheKey) {
 		const socket = await connectWebSocket(url, headers, signal);
 		return {
 			socket,
+			reused: false,
 			release: ({ keep } = {}) => {
 				if (keep === false) {
 					closeWebSocketSilently(socket);
@@ -780,6 +787,7 @@ async function acquireWebSocket(
 			cached.busy = true;
 			return {
 				socket: cached.socket,
+				reused: true,
 				release: ({ keep } = {}) => {
 					if (!keep || !isWebSocketReusable(cached.socket)) {
 						closeWebSocketSilently(cached.socket);
@@ -796,6 +804,7 @@ async function acquireWebSocket(
 			const socket = await connectWebSocket(url, headers, signal);
 			return {
 				socket,
+				reused: false,
 				release: () => {
 					closeWebSocketSilently(socket);
 				},
@@ -813,6 +822,7 @@ async function acquireWebSocket(
 	websocketSessionCache.set(cacheKey, entry);
 	return {
 		socket,
+		reused: false,
 		release: ({ keep } = {}) => {
 			if (!keep || !isWebSocketReusable(entry.socket)) {
 				closeWebSocketSilently(entry.socket);
@@ -948,6 +958,21 @@ async function* parseWebSocket(socket: WebSocketLike, signal: AbortSignal | unde
 	}
 }
 
+async function* countWebSocketEvents(
+	events: AsyncIterable<StreamEventShape>,
+	onEvent: () => void,
+): AsyncIterable<StreamEventShape> {
+	for await (const event of events) {
+		onEvent();
+		yield event;
+	}
+}
+
+function isRetryableEarlyWebSocketError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return /^WebSocket (error|closed)(?:\s|$)/.test(message);
+}
+
 async function* mapCodexEvents(events: AsyncIterable<StreamEventShape>): AsyncIterable<StreamEventShape> {
 	let sawTerminalResponse = false;
 	for await (const event of events) {
@@ -1100,22 +1125,58 @@ async function processWebSocketStream<TApi extends Api>(
 	cwd: string,
 	requestPrompt: string | undefined,
 ): Promise<void> {
-	const { socket, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
-	let keepConnection = true;
+	let streamStarted = false;
+
+	for (let attempt = 0; attempt < 2; attempt++) {
+		const { socket, release, reused } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
+		let keepConnection = true;
+		let released = false;
+		let eventCount = 0;
+
+		const releaseOnce = (releaseOptions?: { keep?: boolean }) => {
+			if (released) return;
+			released = true;
+			release(releaseOptions);
+		};
 
-	try {
-		socket.send(JSON.stringify({ type: "response.create", ...body }));
-		onStart();
-		stream.push({ type: "start", partial: output });
-		await processCapturedResponsesStream(parseWebSocket(socket, options?.signal), output, stream, model, options, deps, cwd, requestPrompt);
-		if (options?.signal?.aborted) {
+		try {
+			socket.send(JSON.stringify({ type: "response.create", ...body }));
+			if (!streamStarted) {
+				onStart();
+				stream.push({ type: "start", partial: output });
+				streamStarted = true;
+			}
+			await processCapturedResponsesStream(
+				countWebSocketEvents(parseWebSocket(socket, options?.signal), () => {
+					eventCount++;
+				}),
+				output,
+				stream,
+				model,
+				options,
+				deps,
+				cwd,
+				requestPrompt,
+			);
+			if (options?.signal?.aborted) {
+				keepConnection = false;
+			}
+			releaseOnce({ keep: keepConnection });
+			return;
+		} catch (error) {
 			keepConnection = false;
+			releaseOnce({ keep: false });
+			// Pi's stock provider reuses session WebSockets. In practice the Codex
+			// backend sometimes cleanly closes an idle cached socket between turns;
+			// if that stale socket fails before any response event, retry once on a
+			// fresh WebSocket without changing request shape or falling back transports.
+			if (attempt === 0 && reused && eventCount === 0 && !options?.signal?.aborted && isRetryableEarlyWebSocketError(error)) {
+				continue;
+			}
+			throw error;
+		} finally {
+			releaseOnce({ keep: keepConnection });
 		}
-	} catch (error) {
-		keepConnection = false;
-		throw error;
-	} finally {
-		release({ keep: keepConnection });
 	}
 }
 

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

@@ -8,12 +8,10 @@ type Message = Context["messages"][number];
 
 interface ImageGenerationCallItem {
 	type: "image_generation_call";
-	id?: string;
-	status?: string;
-	result?: string | null;
-	output_format?: string;
+	id: string;
+	status: string;
+	result: string | null;
 	revised_prompt?: string;
-	[key: string]: unknown;
 }
 
 interface ImageGenerationCallBlock {
@@ -76,6 +74,23 @@ function isImageGenerationCallBlock(block: InternalAssistantContent): block is I
 	return block.type === "image_generation_call" && block.item?.type === "image_generation_call";
 }
 
+function sanitizeImageGenerationCallItem(item: unknown): ImageGenerationCallItem | undefined {
+	if (!item || typeof item !== "object") return undefined;
+	const candidate = item as Record<string, unknown>;
+	if (candidate.type !== "image_generation_call") return undefined;
+	if (typeof candidate.id !== "string" || candidate.id === "") return undefined;
+	if (typeof candidate.status !== "string" || candidate.status === "") return undefined;
+	if (!(typeof candidate.result === "string" || candidate.result === null)) return undefined;
+
+	return {
+		type: "image_generation_call",
+		id: candidate.id,
+		status: candidate.status,
+		result: candidate.result,
+		...(typeof candidate.revised_prompt === "string" ? { revised_prompt: candidate.revised_prompt } : {}),
+	};
+}
+
 const NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
 const NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
 
@@ -287,7 +302,8 @@ export function convertResponsesMessages<TApi extends Api>(
 			let assistantBlockIndex = 0;
 			for (const block of msg.content as InternalAssistantContent[]) {
 				if (isImageGenerationCallBlock(block)) {
-					output.push(block.item as ResponseInput[number]);
+					const imageGenerationCall = sanitizeImageGenerationCallItem(block.item);
+					if (imageGenerationCall) output.push(imageGenerationCall as ResponseInput[number]);
 				} else if (block.type === "thinking") {
 					if (block.thinkingSignature) output.push(JSON.parse(block.thinkingSignature));
 				} else if (block.type === "text") {
@@ -581,10 +597,13 @@ export async function processResponsesStream<TApi extends Api>(
 				stream.push({ type: "toolcall_end", contentIndex: toolCallIndex, toolCall, partial: output });
 				outputStates.delete(event.output_index);
 			} else if (item.type === "image_generation_call") {
-				(output.content as InternalAssistantContent[]).push({
-					type: "image_generation_call",
-					item: item as ImageGenerationCallItem,
-				});
+				const imageGenerationCall = sanitizeImageGenerationCallItem(item);
+				if (imageGenerationCall) {
+					(output.content as InternalAssistantContent[]).push({
+						type: "image_generation_call",
+						item: imageGenerationCall,
+					});
+				}
 				outputStates.delete(event.output_index);
 			}
 		} else if (event.type === "response.completed") {