@howaboua/pi-codex-conversion 1.0.28 → 1.0.29

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.29",
   "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.72.0",
+    "@mariozechner/pi-coding-agent": "^0.72.0",
+    "@mariozechner/pi-tui": "^0.72.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.72.0",
+    "@mariozechner/pi-coding-agent": "^0.72.0",
+    "@mariozechner/pi-tui": "^0.72.0",
     "tsx": "^4.20.5",
     "typebox": "^1.1.24",
     "typescript": "^5.9.3"

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

@@ -2,8 +2,8 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Box, Image, Spacer, Text } from "@mariozechner/pi-tui";
 import {
 	createAssistantMessageEventStream,
+	clampThinkingLevel,
 	getEnvApiKey,
-	supportsXhigh,
 	type Api,
 	type AssistantMessage,
 	type AssistantMessageEventStream,
@@ -103,14 +103,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 +129,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;
@@ -554,10 +563,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,
 		};
 	}
@@ -787,6 +799,7 @@ async function acquireWebSocket(
 			cached.busy = true;
 			return {
 				socket: cached.socket,
+				entry: cached,
 				reused: true,
 				release: ({ keep } = {}) => {
 					if (!keep || !isWebSocketReusable(cached.socket)) {
@@ -822,6 +835,7 @@ async function acquireWebSocket(
 	websocketSessionCache.set(cacheKey, entry);
 	return {
 		socket,
+		entry,
 		reused: false,
 		release: ({ keep } = {}) => {
 			if (!keep || !isWebSocketReusable(entry.socket)) {
@@ -853,6 +867,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 +1193,15 @@ 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 useCachedContext = (options as { transport?: string } | undefined)?.transport === "websocket-cached";
+		// 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 +1210,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 +1230,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
@@ -1406,7 +1488,7 @@ function createCodexStream<TApi extends Api>(
 					stream.end();
 					return;
 				} catch (error) {
-					if (transport === "websocket" || websocketStarted) {
+					if (transport === "websocket" || transport === "websocket-cached" || websocketStarted) {
 						throw error;
 					}
 				}