@oai404iao/pi-codex-core 0.1.0-alpha.1

package/src/adapter/compaction/collect.ts

@@ -0,0 +1,51 @@
+import { NonRetryableProviderError } from "../../providers/openai-codex/errors.js";
+import { mapCodexEvents } from "../../providers/openai-codex/events.js";
+import { parseSSE } from "../../providers/openai-codex/sse.js";
+import { type StreamEventShape } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { isNativeCompactionItem } from "./checkpoint.js";
+
+interface CodexCompactionStreamResult {
+	item: unknown;
+	responseId?: string;
+	responseItems: unknown[];
+}
+
+export async function collectCodexCompactionStream(
+	events: AsyncIterable<StreamEventShape>,
+): Promise<CodexCompactionStreamResult> {
+	let outputItemCount = 0;
+	const compacted: unknown[] = [];
+	const responseItems: unknown[] = [];
+	let responseId: string | undefined;
+	for await (const event of events) {
+		if (event.type === "response.created" && event.response?.id) {
+			responseId = event.response.id;
+		}
+		if (event.type === "response.output_item.done" && event.item) {
+			outputItemCount++;
+			responseItems.push(event.item);
+			if (isNativeCompactionItem(event.item)) compacted.push(event.item);
+		}
+		if (
+			(event.type === "response.completed" || event.type === "response.incomplete")
+			&& event.response?.id
+		) {
+			responseId = event.response.id;
+		}
+	}
+	if (compacted.length !== 1) {
+		throw new NonRetryableProviderError(
+			`OpenAI compaction trigger expected exactly one compaction item, received ${compacted.length} from ${outputItemCount} output items`,
+		);
+	}
+	return {
+		item: compacted[0],
+		...(responseId ? { responseId } : {}),
+		responseItems,
+	};
+}
+
+export async function collectCodexCompactionOutput(response: Response, sessionKey?: string): Promise<unknown> {
+	const result = await collectCodexCompactionStream(mapCodexEvents(parseSSE(response), sessionKey));
+	return result.item;
+}

package/src/adapter/compaction/http.ts

@@ -0,0 +1,101 @@
+import { BASE_DELAY_MS, CODEX_REMOTE_COMPACTION_STREAM_RETRIES, MAX_RETRIES, SSE_RESPONSE_HEADER_TIMEOUT_MS } from "../../providers/openai-codex/constants.js";
+import { NonRetryableProviderError, isRetryableError, parseErrorResponse, withHttpStatusPrefix } from "../../providers/openai-codex/errors.js";
+import { proxyDispatcherForUrl } from "../../providers/openai-codex/proxy.js";
+import { sleep } from "../../providers/openai-codex/retry.js";
+import { fetchWithResponseHeaderTimeout } from "../../providers/openai-codex/sse.js";
+import { type ResponsesBody } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { collectCodexCompactionOutput } from "./collect.js";
+
+export async function postJsonWithRetries(
+	url: string,
+	headers: Headers,
+	body: unknown,
+	signal: AbortSignal | undefined,
+	timeoutMs = SSE_RESPONSE_HEADER_TIMEOUT_MS,
+): Promise<Record<string, unknown>> {
+	const bodyJson = JSON.stringify(body);
+	const dispatcher = await proxyDispatcherForUrl(url);
+	let lastError: Error | undefined;
+	for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+		try {
+			const response = await fetchWithResponseHeaderTimeout(url, {
+				method: "POST",
+				headers,
+				body: bodyJson,
+				...(dispatcher ? { dispatcher } : {}),
+			} as RequestInit, signal, timeoutMs);
+			if (response.ok) {
+				const parsed = await response.json();
+				if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+					throw new NonRetryableProviderError("OpenAI native compaction returned a non-object response");
+				}
+				return parsed as Record<string, unknown>;
+			}
+			const errorText = await response.text();
+			if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
+				await sleep(BASE_DELAY_MS * 2 ** attempt, signal);
+				continue;
+			}
+			const info = await parseErrorResponse(new Response(errorText, {
+				status: response.status,
+				statusText: response.statusText,
+			}));
+			throw new NonRetryableProviderError(withHttpStatusPrefix(response.status, info.friendlyMessage || info.message));
+		} catch (error) {
+			if (error instanceof NonRetryableProviderError) throw error;
+			if (signal?.aborted) throw new Error("Request was aborted");
+			lastError = error instanceof Error ? error : new Error(String(error));
+			if (attempt < MAX_RETRIES) {
+				await sleep(BASE_DELAY_MS * 2 ** attempt, signal);
+				continue;
+			}
+			throw lastError;
+		}
+	}
+	throw lastError ?? new Error("OpenAI native compaction failed");
+}
+
+export async function requestCodexCompactionTrigger(
+	url: string,
+	headers: Headers,
+	body: ResponsesBody,
+	signal: AbortSignal | undefined,
+	sessionKey?: string,
+): Promise<unknown> {
+	const bodyJson = JSON.stringify(body);
+	const dispatcher = await proxyDispatcherForUrl(url);
+	let lastError: Error | undefined;
+	const maxRetries = Math.min(MAX_RETRIES, CODEX_REMOTE_COMPACTION_STREAM_RETRIES);
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		try {
+			const response = await fetchWithResponseHeaderTimeout(url, {
+				method: "POST",
+				headers,
+				body: bodyJson,
+				...(dispatcher ? { dispatcher } : {}),
+			} as RequestInit, signal);
+			if (response.ok) return await collectCodexCompactionOutput(response, sessionKey);
+
+			const errorText = await response.text();
+			if (attempt < maxRetries && isRetryableError(response.status, errorText)) {
+				await sleep(BASE_DELAY_MS * 2 ** attempt, signal);
+				continue;
+			}
+			const info = await parseErrorResponse(new Response(errorText, {
+				status: response.status,
+				statusText: response.statusText,
+			}));
+			throw new NonRetryableProviderError(withHttpStatusPrefix(response.status, info.friendlyMessage || info.message));
+		} catch (error) {
+			if (error instanceof NonRetryableProviderError) throw error;
+			if (signal?.aborted) throw new Error("Request was aborted");
+			lastError = error instanceof Error ? error : new Error(String(error));
+			if (attempt < maxRetries) {
+				await sleep(BASE_DELAY_MS * 2 ** attempt, signal);
+				continue;
+			}
+			throw lastError;
+		}
+	}
+	throw lastError ?? new Error("OpenAI compaction trigger failed");
+}

package/src/adapter/compaction/request.ts

@@ -0,0 +1,159 @@
+import { type ProviderHeaders } from "@earendil-works/pi-ai";
+import { type Api, type Context, type Model, type SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { hasCodexRequestAuth, resolveCodexRequestAccountId } from "@oai404iao/pi-codex-runtime/internal/codex-http";
+import { resolveCodexRequestProfile } from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";
+import { resolveCodexRequestIdentity } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { applyFastModeServiceTier } from "../../fast-mode.js";
+import { loadModelSettings, type ResolvedCodexModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import { setProviderGeneratedHeader } from "@oai404iao/pi-codex-runtime/internal/provider-headers";
+import { rewriteNativeOpenAiTools } from "../../provider-native-tools.js";
+import { CODEX_COMPACTION_TRIGGER_TYPE, X_OPENAI_INTERNAL_CODEX_RESPONSES_LITE } from "../../providers/openai-codex/constants.js";
+import { applyConfiguredResponsesFeatureHeaders, buildJsonHeaders, buildSSEHeaders, buildWebSocketHeaders } from "../../providers/openai-codex/headers.js";
+import { buildRequestBody, ensureWebSearchDetailsIncluded } from "../../providers/openai-codex/request-body.js";
+import { createCodexRequestId } from "../../providers/openai-codex/request-metadata.js";
+import { compactUrl } from "../../providers/openai-codex/urls.js";
+import { buildCodexCompactionCheckpoint, compactionItems, sanitizeNativeCompactionOutput } from "./checkpoint.js";
+import { postJsonWithRetries } from "./http.js";
+import { requestCodexCompactionTriggerWithTransport } from "./transport.js";
+import type { NativeToolOwnership } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+export async function requestOpenAINativeCompaction(
+	model: Model<Api>,
+	context: Context,
+	options: {
+		ownsNativeTool?: NativeToolOwnership;
+		mode: "responses" | "responses-compact";
+		apiKey: string;
+		headers?: ProviderHeaders;
+		signal?: AbortSignal;
+		reasoning?: SimpleStreamOptions["reasoning"];
+		sessionId?: string;
+		turnId?: string;
+		maxRetries?: number;
+		maxRetryDelayMs?: number;
+		settings: ResolvedCodexModelSettings;
+	},
+): Promise<unknown[]> {
+	const settings = options.settings.modelProfile
+		? options.settings
+		: loadModelSettings(model, undefined, options.settings);
+	const auth = { apiKey: options.apiKey || undefined, headers: options.headers };
+	if (!hasCodexRequestAuth({ modelHeaders: model.headers, auth })) {
+		throw new Error(`No request authentication for provider: ${model.provider}`);
+	}
+	if (settings.compactionMode === "pi") {
+		throw new Error("native compaction is disabled by the current model profile");
+	}
+	const profile = resolveCodexRequestProfile(settings.requestProfile);
+	const accountId = resolveCodexRequestAccountId({
+		modelHeaders: model.headers,
+		auth,
+		apiKeyMode: settings.apiKeyMode,
+	});
+	const requestIdentity = resolveCodexRequestIdentity(
+		options.sessionId,
+		options.turnId ? { turn_id: options.turnId } : undefined,
+		"compaction",
+	);
+	let body = applyFastModeServiceTier(buildRequestBody(model, context, profile, {
+		ownsNativeTool: options.ownsNativeTool,
+		apiKey: options.apiKey,
+		headers: options.headers,
+		signal: options.signal,
+		reasoning: options.reasoning,
+		sessionId: options.sessionId,
+	}), settings, model);
+	if (settings.nativeProviderTools) {
+		const webSearch = settings.modelProfile?.effective.tools.webSearch;
+		body = rewriteNativeOpenAiTools(body, {
+			ownsNativeTool: options.ownsNativeTool,
+			imageModel: settings.imageModel,
+			imageGeneration: settings.imageGenerationImplementation ?? false,
+			webSearch: settings.webSearchEnabled
+				&& webSearch
+				? {
+						implementation: webSearch.implementation,
+						contentTypes: webSearch.contentTypes,
+					}
+				: false,
+		}).payload;
+	}
+	ensureWebSearchDetailsIncluded(body);
+
+	if (options.mode === "responses") {
+		const retainedInput = [...body.input];
+		body.input = [...retainedInput, { type: CODEX_COMPACTION_TRIGGER_TYPE }];
+		const sseHeaders = applyConfiguredResponsesFeatureHeaders(buildSSEHeaders(
+			model.headers,
+			options.headers,
+			accountId,
+			options.apiKey,
+			options.sessionId,
+			profile,
+			requestIdentity?.threadId,
+			requestIdentity,
+		), settings, model);
+		const requestId = requestIdentity?.threadId
+			?? options.sessionId
+			?? createCodexRequestId();
+		const websocketHeaders = applyConfiguredResponsesFeatureHeaders(buildWebSocketHeaders(
+			model.headers,
+			options.headers,
+			accountId,
+			options.apiKey,
+			requestId,
+			requestId,
+			requestIdentity,
+		), settings, model);
+		const item = await requestCodexCompactionTriggerWithTransport(
+			model,
+			{ sse: sseHeaders, websocket: websocketHeaders },
+			body,
+			{
+				sessionId: options.sessionId,
+				turnId: options.turnId,
+				requestIdentity,
+				signal: options.signal,
+				settings,
+				maxRetries: options.maxRetries,
+				maxRetryDelayMs: options.maxRetryDelayMs,
+			},
+		);
+		return buildCodexCompactionCheckpoint(retainedInput, item);
+	}
+
+	const headers = buildJsonHeaders(
+		model.headers,
+		options.headers,
+		accountId,
+		options.apiKey,
+		options.sessionId,
+		requestIdentity,
+	);
+	if (profile.responsesMode === "lite") {
+		setProviderGeneratedHeader(headers, X_OPENAI_INTERNAL_CODEX_RESPONSES_LITE, "true");
+	}
+	const compactBody: Record<string, unknown> = {
+		model: body.model,
+		input: body.input,
+		parallel_tool_calls: body.parallel_tool_calls,
+	};
+	for (const key of ["instructions", "tools", "reasoning", "service_tier", "prompt_cache_key", "text"] as const) {
+		if (body[key] !== undefined) compactBody[key] = body[key];
+	}
+	const response = await postJsonWithRetries(
+		compactUrl(model.baseUrl, settings.apiKeyMode),
+		headers,
+		compactBody,
+		options.signal,
+	);
+	const output = response.output;
+	if (!Array.isArray(output) || output.length === 0) {
+		throw new Error("OpenAI /responses/compact returned no replacement output");
+	}
+	const sanitizedOutput = sanitizeNativeCompactionOutput(output);
+	if (compactionItems(sanitizedOutput).length === 0) {
+		throw new Error("OpenAI /responses/compact output did not contain a compaction item");
+	}
+	return sanitizedOutput;
+}

package/src/adapter/compaction/transport.ts

@@ -0,0 +1,125 @@
+import { type Api, type Model, type SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
+import { resolveCodexRequestProfile } from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";
+import { type CodexRequestIdentity } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { type ResolvedCodexModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import { webSocketFallbackKey } from "../../providers/openai-codex/cache-key.js";
+import { CODEX_REMOTE_COMPACTION_STREAM_RETRIES } from "../../providers/openai-codex/constants.js";
+import { withResponsesLiteWebSocketMetadata } from "../../providers/openai-codex/lite.js";
+import { createPiTurnId, withSseRequestMetadata } from "../../providers/openai-codex/request-metadata.js";
+import { isRetryableWebSocketError, isWebSocketConnectionLimitReachedError, isWebSocketUpgradeRejectedError, sleep, webSocketCompactionRetryDelayMs, webSocketStreamMaxRetries } from "../../providers/openai-codex/retry.js";
+import { type ResponsesBody, type WebSocketRequestMetadata } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { resolveCodexUrl, resolveResponsesWebSocketUrl } from "../../providers/openai-codex/urls.js";
+import { websocketHttpFallbackSessions } from "../../providers/openai-codex/websocket-session.js";
+import { requestCodexCompactionTrigger } from "./http.js";
+import { requestCodexCompactionTriggerWebSocket } from "./websocket.js";
+
+export async function requestCodexCompactionTriggerWithTransport(
+	model: Model<Api>,
+	headers: {
+		sse: Headers;
+		websocket: Headers;
+	},
+	body: ResponsesBody,
+	options: {
+		sessionId?: string;
+		turnId?: string;
+		requestIdentity?: CodexRequestIdentity;
+		signal?: AbortSignal;
+		settings: ResolvedCodexModelSettings;
+		maxRetries?: number;
+		maxRetryDelayMs?: number;
+	},
+): Promise<unknown> {
+	const transport = options.settings.openaiTransport;
+	const responsesMode = resolveCodexRequestProfile(options.settings.requestProfile).responsesMode;
+	const sseUrl = resolveCodexUrl(model.baseUrl, { apiKeyMode: options.settings.apiKeyMode });
+	const requestMetadata: WebSocketRequestMetadata = {
+		...(options.sessionId ? { sessionId: options.sessionId } : {}),
+		...(options.requestIdentity?.threadId
+			? { threadId: options.requestIdentity.threadId }
+			: {}),
+		turnId: options.requestIdentity?.turnId
+			|| options.turnId
+			|| createPiTurnId(),
+		requestKind: "compaction",
+		...(options.requestIdentity
+			? { identity: options.requestIdentity }
+			: {}),
+	};
+	if (transport === "sse") {
+		return requestCodexCompactionTrigger(
+			sseUrl,
+			headers.sse,
+			withSseRequestMetadata(body, requestMetadata),
+			options.signal,
+			options.sessionId,
+		);
+	}
+
+	const websocketUrl = resolveResponsesWebSocketUrl(model.baseUrl, { apiKeyMode: options.settings.apiKeyMode });
+	const fallbackKey = webSocketFallbackKey(
+		options.sessionId,
+		model,
+		websocketUrl,
+		options.settings.modelProfileHash,
+	);
+	if (
+		transport === "auto"
+		&& fallbackKey
+		&& websocketHttpFallbackSessions.has(fallbackKey)
+	) {
+		return requestCodexCompactionTrigger(
+			sseUrl,
+			headers.sse,
+			withSseRequestMetadata(body, requestMetadata),
+			options.signal,
+			options.sessionId,
+		);
+	}
+
+	const maxRetries = Math.min(
+		CODEX_REMOTE_COMPACTION_STREAM_RETRIES,
+		webSocketStreamMaxRetries({
+			maxRetries: options.maxRetries,
+		} as SimpleStreamOptions),
+	);
+	const retryOptions = {
+		...(options.maxRetryDelayMs !== undefined ? { maxRetryDelayMs: options.maxRetryDelayMs } : {}),
+	} as SimpleStreamOptions;
+	let retries = 0;
+	while (true) {
+		try {
+			return await requestCodexCompactionTriggerWebSocket(
+				websocketUrl,
+				headers.websocket,
+				withResponsesLiteWebSocketMetadata(body, responsesMode),
+				model,
+				requestMetadata,
+				options.signal,
+				options.settings.modelProfileHash,
+			);
+		} catch (error) {
+			if (options.signal?.aborted) throw new Error("Request was aborted");
+			const upgradeRejected = isWebSocketUpgradeRejectedError(error);
+			if (transport === "auto" && upgradeRejected) {
+				if (fallbackKey) websocketHttpFallbackSessions.add(fallbackKey);
+				break;
+			}
+			const retryable = isWebSocketConnectionLimitReachedError(error) || isRetryableWebSocketError(error);
+			if (retryable && retries < maxRetries) {
+				retries++;
+				await sleep(webSocketCompactionRetryDelayMs(error, retries, retryOptions), options.signal);
+				continue;
+			}
+			throw error;
+		}
+	}
+
+	return requestCodexCompactionTrigger(
+		sseUrl,
+		headers.sse,
+		withSseRequestMetadata(body, requestMetadata),
+		options.signal,
+		options.sessionId,
+	);
+}

package/src/adapter/compaction/websocket.ts

@@ -0,0 +1,119 @@
+import { type Api, type Model } from "@earendil-works/pi-ai/compat";
+import { webSocketCacheKey } from "../../providers/openai-codex/cache-key.js";
+import { WEBSOCKET_CONNECT_TIMEOUT_MS, WEBSOCKET_SEND_TIMEOUT_MS } from "../../providers/openai-codex/constants.js";
+import { buildCachedWebSocketRequestBody, prepareWebSocketRequestBodyForWire } from "../../providers/openai-codex/continuation.js";
+import { mapCodexEvents } from "../../providers/openai-codex/events.js";
+import { withWebSocketRequestMetadata } from "../../providers/openai-codex/request-metadata.js";
+import { isPreviousResponseNotFoundError, isRetryableEarlyWebSocketError } from "../../providers/openai-codex/retry.js";
+import { type ResponsesBody, type WebSocketRequestMetadata } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { countWebSocketEvents, parseWebSocket, sendWebSocketRequest } from "../../providers/openai-codex/websocket-events.js";
+import { acquireWebSocket } from "../../providers/openai-codex/websocket-session.js";
+import { collectCodexCompactionStream } from "./collect.js";
+
+export async function requestCodexCompactionTriggerWebSocket(
+	url: string,
+	headers: Headers,
+	body: ResponsesBody,
+	model: Model<Api>,
+	requestMetadata: WebSocketRequestMetadata,
+	signal: AbortSignal | undefined,
+	profileHash?: string,
+): Promise<unknown> {
+	let disableCachedContext = false;
+	let staleSocketRetried = false;
+	let missingPreviousResponseRetried = false;
+
+	while (true) {
+		const cacheKey = webSocketCacheKey(
+			requestMetadata.sessionId,
+			model,
+			url,
+			headers,
+			profileHash,
+		);
+		const { socket, entry, release, reused } = await acquireWebSocket(
+			url,
+			headers,
+			cacheKey,
+			requestMetadata.sessionId,
+			signal,
+			WEBSOCKET_CONNECT_TIMEOUT_MS,
+		);
+		let keepConnection = true;
+		let released = false;
+		let eventCount = 0;
+		// All reusable WebSocket transports opportunistically continue an exact
+		// logical request prefix. `websocket` still sends a full request whenever
+		// the stable fields or input prefix do not match.
+		const useCachedContext = true;
+		const fullBody = withWebSocketRequestMetadata(body, requestMetadata);
+		const requestBody = useCachedContext && !disableCachedContext && entry
+			? buildCachedWebSocketRequestBody(entry, fullBody)
+			: fullBody;
+		const wireRequestBody = prepareWebSocketRequestBodyForWire(requestBody);
+		const releaseOnce = (releaseOptions?: { keep?: boolean }) => {
+			if (released) return;
+			released = true;
+			release(releaseOptions);
+		};
+
+		try {
+			await sendWebSocketRequest(
+				socket,
+				JSON.stringify({ type: "response.create", ...wireRequestBody }),
+				signal,
+				WEBSOCKET_SEND_TIMEOUT_MS,
+			);
+			const result = await collectCodexCompactionStream(
+				mapCodexEvents(
+					countWebSocketEvents(parseWebSocket(socket, signal), () => {
+						eventCount++;
+					}),
+					requestMetadata.sessionId,
+				),
+			);
+			if (signal?.aborted) {
+				keepConnection = false;
+				throw new Error("Request was aborted");
+			}
+			if (entry && result.responseId) {
+				entry.continuation = {
+					lastRequestBody: fullBody,
+					lastResponseId: result.responseId,
+					lastResponseItems: result.responseItems,
+				};
+			} else if (entry) {
+				entry.continuation = undefined;
+			}
+			releaseOnce({ keep: true });
+			return result.item;
+		} catch (error) {
+			if (entry) entry.continuation = undefined;
+			keepConnection = false;
+			releaseOnce({ keep: false });
+			if (
+				!staleSocketRetried
+				&& reused
+				&& eventCount === 0
+				&& !signal?.aborted
+				&& isRetryableEarlyWebSocketError(error)
+			) {
+				staleSocketRetried = true;
+				continue;
+			}
+			if (
+				!missingPreviousResponseRetried
+				&& requestBody.previous_response_id
+				&& !signal?.aborted
+				&& isPreviousResponseNotFoundError(error)
+			) {
+				missingPreviousResponseRetried = true;
+				disableCachedContext = true;
+				continue;
+			}
+			throw error;
+		} finally {
+			releaseOnce({ keep: keepConnection });
+		}
+	}
+}

package/src/extension/prewarm-snapshot.ts

@@ -0,0 +1,27 @@
+import { type Context, type ThinkingLevel } from "@earendil-works/pi-ai/compat";
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { thinkingLevelFromUnknown } from "../providers/openai-codex/reasoning.js";
+
+export interface StartupPrewarmSnapshot {
+	systemPrompt: string;
+	tools: Context["tools"];
+	reasoning?: ThinkingLevel;
+}
+
+export function startupPrewarmSnapshot(pi: ExtensionAPI, ctx: any): StartupPrewarmSnapshot {
+	const activeToolNames = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+	return {
+		systemPrompt: ctx.getSystemPrompt?.() ?? "",
+		tools: (typeof pi.getAllTools === "function" ? pi.getAllTools() : [])
+			.filter((tool) => activeToolNames.includes(tool.name))
+			.map((tool) => ({
+				name: tool.name,
+				description: tool.description,
+				parameters: tool.parameters,
+			})),
+		reasoning: thinkingLevelFromUnknown(
+			(ctx as { thinkingLevel?: unknown }).thinkingLevel
+			?? (typeof pi.getThinkingLevel === "function" ? pi.getThinkingLevel() : undefined),
+		),
+	};
+}

package/src/extension/provider-runtime.ts

@@ -0,0 +1,101 @@
+import {
+	streamSimpleOpenAICodexResponses, streamSimpleOpenAIResponses,
+	type Api, type Context, type Model, type SimpleStreamOptions,
+} from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { installCodexIdentityLifecycle } from "@oai404iao/pi-codex-runtime/internal/codex-identity-extension";
+import { currentCodexTurn, resolveCodexRequestIdentity } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { loadModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import { createCodexStream } from "../providers/openai-codex/stream.js";
+import type { OpenAIResponsesProviderController } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+import { closeProviderWebSocketSessions } from "../providers/openai-codex/websocket-session.js";
+import type { ProviderPresentation } from "@oai404iao/pi-codex-runtime/internal/extension/provider-presentation";
+import { createStartupPrewarmLifecycle } from "./startup-prewarm.js";
+
+export function registerResponsesProviderRuntime(
+	pi: ExtensionAPI,
+	options: { getCurrentCwd: () => string; ownsNativeTool?: OpenAIResponsesProviderController["ownsNativeTool"] },
+	presentation?: ProviderPresentation,
+): OpenAIResponsesProviderController {
+	installCodexIdentityLifecycle(pi);
+	const prewarm = createStartupPrewarmLifecycle(pi, options.ownsNativeTool);
+	const streamSimple = <TApi extends Api>(model: Model<TApi>, context: Context, streamOptions?: SimpleStreamOptions) => {
+		const settings = loadModelSettings(model, options.getCurrentCwd());
+		if (
+			!settings.enabled
+			|| !settings.modelProfile?.effective.enabled
+			|| !settings.providerShimActive
+		) {
+			return model.api === "openai-codex-responses"
+				? streamSimpleOpenAICodexResponses(model as Model<"openai-codex-responses">, context, streamOptions)
+				: streamSimpleOpenAIResponses(model as Model<"openai-responses">, context, streamOptions);
+		}
+		return createCodexStream(model, context, streamOptions, {
+			ownsNativeTool: options.ownsNativeTool,
+			...presentation?.streamEffects(),
+			getCurrentCwd: options.getCurrentCwd,
+			getCurrentTurnId: (sessionId) => currentCodexTurn(sessionId)?.turnId,
+			getStartupPrewarm: prewarm.get,
+		});
+	};
+
+	type CodexResponsesApi = "openai-responses" | "openai-codex-responses";
+	const registeredProviderApis = new Map<string, CodexResponsesApi>();
+	const registerProviderShim = (provider: string, api: CodexResponsesApi): void => {
+		if (!provider || registeredProviderApis.get(provider) === api) return;
+		pi.registerProvider(provider, { api, streamSimple });
+		registeredProviderApis.set(provider, api);
+	};
+	const ensureProviderShimForModel = (model: Model<Api> | undefined, cwd?: string): void => {
+		if (!model) return;
+		const settings = loadModelSettings(model, cwd);
+		if (
+			!settings.enabled
+			|| !settings.modelProfile?.effective.enabled
+			|| !settings.providerShimActive
+		) {
+			return;
+		}
+		if (model.api === "openai-responses" || model.api === "openai-codex-responses") {
+			registerProviderShim(model.provider, model.api as CodexResponsesApi);
+		}
+	};
+
+	// Register built-ins first; custom providers require an actual selected
+	// model so their URL, auth and model list are never created or overwritten.
+	registerProviderShim("openai-codex", "openai-codex-responses");
+	registerProviderShim("openai", "openai-responses");
+
+	pi.on("session_start", async (_event, ctx) => {
+		prewarm.reset();
+		ensureProviderShimForModel(ctx?.model as Model<Api> | undefined, ctx?.cwd);
+		presentation?.clear();
+		prewarm.start(ctx);
+	});
+	pi.on("model_select", async (_event, ctx) => {
+		ensureProviderShimForModel(ctx?.model as Model<Api> | undefined, ctx?.cwd);
+	});
+	pi.on("session_shutdown", async (_event, ctx) => {
+		prewarm.reset();
+		presentation?.flush();
+		closeProviderWebSocketSessions(ctx?.sessionManager?.getSessionId?.());
+		presentation?.clear();
+	});
+	pi.on("before_agent_start", async (_event, ctx) => {
+		ensureProviderShimForModel(ctx.model as Model<Api> | undefined, ctx.cwd);
+	});
+	pi.on("agent_end", async () => {
+		presentation?.scheduleFlush();
+	});
+	presentation?.registerRenderers();
+
+	return {
+		ownsNativeTool: options.ownsNativeTool,
+		getCurrentTurnId(sessionId) {
+			return currentCodexTurn(sessionId)?.turnId;
+		},
+		getRequestIdentity(sessionId, requestKind = "turn") {
+			return resolveCodexRequestIdentity(sessionId, undefined, requestKind);
+		},
+	};
+}