@howaboua/pi-codex-conversion 1.0.28 → 1.0.30

package/README.md

@@ -9,7 +9,7 @@ This package replaces Pi's default Codex/GPT experience with a narrower Codex-li
 - preserves Pi's composed system prompt and applies a narrow Codex-oriented delta on top
 - renders exec activity with Codex-style command and background-terminal labels
 - renders `apply_patch` calls with Codex-style `Added` / `Edited` / `Deleted` diff blocks and Pi-style colored diff lines
-- targets modern Pi tool/rendering APIs and is aligned with Pi `0.70.x`
+- targets modern Pi tool/rendering APIs and is aligned with Pi `0.72.x`
 
 ![Available tools](./available-tools.png)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -51,15 +51,15 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "^0.70.0",
-    "@mariozechner/pi-coding-agent": "^0.70.0",
-    "@mariozechner/pi-tui": "^0.70.0",
+    "@mariozechner/pi-ai": "^0.73.0",
+    "@mariozechner/pi-coding-agent": "^0.73.0",
+    "@mariozechner/pi-tui": "^0.73.0",
     "typebox": "^1.1.24"
   },
   "devDependencies": {
-    "@mariozechner/pi-ai": "^0.70.5",
-    "@mariozechner/pi-coding-agent": "^0.70.5",
-    "@mariozechner/pi-tui": "^0.70.5",
+    "@mariozechner/pi-ai": "^0.73.0",
+    "@mariozechner/pi-coding-agent": "^0.73.0",
+    "@mariozechner/pi-tui": "^0.73.0",
     "tsx": "^4.20.5",
     "typebox": "^1.1.24",
     "typescript": "^5.9.3"

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

@@ -2,8 +2,10 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Box, Image, Spacer, Text } from "@mariozechner/pi-tui";
 import {
 	createAssistantMessageEventStream,
+	appendAssistantMessageDiagnostic,
+	clampThinkingLevel,
+	createAssistantMessageDiagnostic,
 	getEnvApiKey,
-	supportsXhigh,
 	type Api,
 	type AssistantMessage,
 	type AssistantMessageEventStream,
@@ -103,14 +105,22 @@ interface SessionWebSocketCacheEntry {
 	socket: WebSocketLike;
 	busy: boolean;
 	idleTimer?: ReturnType<typeof setTimeout>;
+	continuation?: CachedWebSocketContinuationState;
 }
 
 interface AcquiredWebSocket {
 	socket: WebSocketLike;
+	entry?: SessionWebSocketCacheEntry;
 	reused: boolean;
 	release: (options?: { keep?: boolean }) => void;
 }
 
+interface CachedWebSocketContinuationState {
+	lastRequestBody: ResponsesBody;
+	lastResponseId: string;
+	lastResponseItems: unknown[];
+}
+
 let fsPromisesPromise: Promise<typeof import("node:fs/promises")> | undefined;
 const workspaceRootCache = new Map<string, Promise<string>>();
 
@@ -121,7 +131,8 @@ interface ResponsesBody {
 	store: boolean;
 	stream: boolean;
 	instructions?: string;
-	input: unknown;
+	previous_response_id?: string;
+	input: unknown[];
 	text: { verbosity: string };
 	include: string[];
 	prompt_cache_key?: string;
@@ -403,16 +414,6 @@ function headersToRecord(headers: Headers): Record<string, string> {
 	return Object.fromEntries(headers.entries());
 }
 
-function buildWebSocketCacheKey(url: string, headers: Headers, sessionId: string | undefined): string | undefined {
-	if (!sessionId) return undefined;
-	const headerFingerprint = Object.entries(headersToRecord(headers))
-		.map(([key, value]) => [key.toLowerCase(), value] as const)
-		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([key, value]) => `${key}:${value}`)
-		.join("\n");
-	return `${sessionId}:${shortHash(`${url}\n${headerFingerprint}`)}`;
-}
-
 function createCodexRequestId(): string {
 	if (typeof globalThis.crypto?.randomUUID === "function") {
 		return globalThis.crypto.randomUUID();
@@ -554,10 +555,13 @@ function buildRequestBody<TApi extends Api>(model: Model<TApi>, context: Context
 		}
 	}
 
-	if (options?.reasoning !== undefined) {
-		const requested = supportsXhigh(model) ? options.reasoning : options.reasoning === "xhigh" ? "high" : options.reasoning;
+	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+	const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
+	if (reasoningEffort !== undefined) {
+		const effort = model.thinkingLevelMap?.[reasoningEffort] ?? reasoningEffort;
+		if (effort === null) return body;
 		body.reasoning = {
-			effort: clampReasoningEffort(model.id, requested),
+			effort: clampReasoningEffort(model.id, effort),
 			summary: ((options as { reasoningSummary?: string } | undefined)?.reasoningSummary ?? "auto") as string,
 		};
 	}
@@ -662,6 +666,7 @@ function closeWebSocketSilently(socket: WebSocketLike, code = 1000, reason = "do
 	}
 }
 
+
 function scheduleSessionWebSocketExpiry(cacheKey: string, entry: SessionWebSocketCacheEntry): void {
 	if (entry.idleTimer) {
 		clearTimeout(entry.idleTimer);
@@ -760,8 +765,7 @@ async function acquireWebSocket(
 	sessionId: string | undefined,
 	signal: AbortSignal | undefined,
 ): Promise<AcquiredWebSocket> {
-	const cacheKey = buildWebSocketCacheKey(url, headers, sessionId);
-	if (!cacheKey) {
+	if (!sessionId) {
 		const socket = await connectWebSocket(url, headers, signal);
 		return {
 			socket,
@@ -776,7 +780,7 @@ async function acquireWebSocket(
 		};
 	}
 
-	const cached = websocketSessionCache.get(cacheKey);
+	const cached = websocketSessionCache.get(sessionId);
 	if (cached) {
 		if (cached.idleTimer) {
 			clearTimeout(cached.idleTimer);
@@ -787,15 +791,16 @@ async function acquireWebSocket(
 			cached.busy = true;
 			return {
 				socket: cached.socket,
+				entry: cached,
 				reused: true,
 				release: ({ keep } = {}) => {
 					if (!keep || !isWebSocketReusable(cached.socket)) {
 						closeWebSocketSilently(cached.socket);
-						websocketSessionCache.delete(cacheKey);
+						websocketSessionCache.delete(sessionId);
 						return;
 					}
 					cached.busy = false;
-					scheduleSessionWebSocketExpiry(cacheKey, cached);
+					scheduleSessionWebSocketExpiry(sessionId, cached);
 				},
 			};
 		}
@@ -813,27 +818,28 @@ async function acquireWebSocket(
 
 		if (!isWebSocketReusable(cached.socket)) {
 			closeWebSocketSilently(cached.socket);
-			websocketSessionCache.delete(cacheKey);
+			websocketSessionCache.delete(sessionId);
 		}
 	}
 
 	const socket = await connectWebSocket(url, headers, signal);
 	const entry: SessionWebSocketCacheEntry = { socket, busy: true };
-	websocketSessionCache.set(cacheKey, entry);
+	websocketSessionCache.set(sessionId, entry);
 	return {
 		socket,
+		entry,
 		reused: false,
 		release: ({ keep } = {}) => {
 			if (!keep || !isWebSocketReusable(entry.socket)) {
 				closeWebSocketSilently(entry.socket);
 				if (entry.idleTimer) clearTimeout(entry.idleTimer);
-				if (websocketSessionCache.get(cacheKey) === entry) {
-					websocketSessionCache.delete(cacheKey);
+				if (websocketSessionCache.get(sessionId) === entry) {
+					websocketSessionCache.delete(sessionId);
 				}
 				return;
 			}
 			entry.busy = false;
-			scheduleSessionWebSocketExpiry(cacheKey, entry);
+			scheduleSessionWebSocketExpiry(sessionId, entry);
 		},
 	};
 }
@@ -853,6 +859,57 @@ async function decodeWebSocketData(data: unknown): Promise<string | null> {
 	return null;
 }
 
+function requestBodyWithoutInput(body: ResponsesBody): ResponsesBody {
+	const { input: _input, previous_response_id: _previousResponseId, ...rest } = body;
+	return rest as ResponsesBody;
+}
+
+function responseInputsEqual(a: unknown[] | undefined, b: unknown[] | undefined): boolean {
+	return JSON.stringify(a ?? []) === JSON.stringify(b ?? []);
+}
+
+function requestBodiesMatchExceptInput(a: ResponsesBody, b: ResponsesBody): boolean {
+	return JSON.stringify(requestBodyWithoutInput(a)) === JSON.stringify(requestBodyWithoutInput(b));
+}
+
+function getCachedWebSocketInputDelta(body: ResponsesBody, continuation: CachedWebSocketContinuationState): unknown[] | undefined {
+	if (!requestBodiesMatchExceptInput(body, continuation.lastRequestBody)) {
+		return undefined;
+	}
+
+	const currentInput = body.input ?? [];
+	const baseline = [...(continuation.lastRequestBody.input ?? []), ...continuation.lastResponseItems];
+	if (currentInput.length < baseline.length) {
+		return undefined;
+	}
+
+	const prefix = currentInput.slice(0, baseline.length);
+	if (!responseInputsEqual(prefix, baseline)) {
+		return undefined;
+	}
+
+	return currentInput.slice(baseline.length);
+}
+
+function buildCachedWebSocketRequestBody(entry: SessionWebSocketCacheEntry, body: ResponsesBody): ResponsesBody {
+	const continuation = entry.continuation;
+	if (!continuation) {
+		return body;
+	}
+
+	const delta = getCachedWebSocketInputDelta(body, continuation);
+	if (!delta || !continuation.lastResponseId) {
+		entry.continuation = undefined;
+		return body;
+	}
+
+	return {
+		...body,
+		previous_response_id: continuation.lastResponseId,
+		input: delta,
+	};
+}
+
 async function* parseWebSocket(socket: WebSocketLike, signal: AbortSignal | undefined): AsyncIterable<StreamEventShape> {
 	const queue: StreamEventShape[] = [];
 	let pending: (() => void) | null = null;
@@ -1128,10 +1185,16 @@ async function processWebSocketStream<TApi extends Api>(
 	let streamStarted = false;
 
 	for (let attempt = 0; attempt < 2; attempt++) {
-		const { socket, release, reused } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
+		const { socket, entry, release, reused } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
 		let keepConnection = true;
 		let released = false;
 		let eventCount = 0;
+		const transport = (options as { transport?: string } | undefined)?.transport ?? "auto";
+		const useCachedContext = transport === "websocket-cached" || transport === "auto";
+		// ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").
+		// WebSocket continuation still works via connection-scoped previous_response_id state.
+		const fullBody = body;
+		const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
 
 		const releaseOnce = (releaseOptions?: { keep?: boolean }) => {
 			if (released) return;
@@ -1140,7 +1203,7 @@ async function processWebSocketStream<TApi extends Api>(
 		};
 
 		try {
-			socket.send(JSON.stringify({ type: "response.create", ...body }));
+			socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
 			if (!streamStarted) {
 				onStart();
 				stream.push({ type: "start", partial: output });
@@ -1160,10 +1223,22 @@ async function processWebSocketStream<TApi extends Api>(
 			);
 			if (options?.signal?.aborted) {
 				keepConnection = false;
+			} else if (useCachedContext && entry && output.responseId) {
+				const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
+					includeSystemPrompt: false,
+				}).filter((item) => typeof item === "object" && item !== null && (item as { type?: unknown }).type !== "function_call_output");
+				entry.continuation = {
+					lastRequestBody: fullBody,
+					lastResponseId: output.responseId,
+					lastResponseItems: responseItems,
+				};
 			}
 			releaseOnce({ keep: keepConnection });
 			return;
 		} catch (error) {
+			if (entry) {
+				entry.continuation = undefined;
+			}
 			keepConnection = false;
 			releaseOnce({ keep: false });
 			// Pi's stock provider reuses session WebSockets. In practice the Codex
@@ -1378,7 +1453,7 @@ function createCodexStream<TApi extends Api>(
 			const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, options?.sessionId);
 			const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
 			const bodyJson = JSON.stringify(body);
-			const transport = options?.transport || "sse";
+			const transport = options?.transport || "auto";
 
 			if (transport !== "sse") {
 				let websocketStarted = false;
@@ -1406,7 +1481,17 @@ function createCodexStream<TApi extends Api>(
 					stream.end();
 					return;
 				} catch (error) {
-					if (transport === "websocket" || websocketStarted) {
+					appendAssistantMessageDiagnostic(
+						output,
+						createAssistantMessageDiagnostic("provider_transport_failure", error, {
+							configuredTransport: transport,
+							fallbackTransport: websocketStarted ? undefined : "sse",
+							eventsEmitted: websocketStarted,
+							phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
+							requestBytes: new TextEncoder().encode(bodyJson).byteLength,
+						}),
+					);
+					if (transport === "websocket" || transport === "websocket-cached" || websocketStarted) {
 						throw error;
 					}
 				}