@howaboua/pi-codex-conversion 1.5.5 → 1.5.6-dev.28.300a94c

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.5.6
+
+- Added Compaction and Overrides tabs to `/codex`.
+- Added optional native Responses compaction for Codex sessions, with settings for compaction model and reasoning.
+- Added an `apply_patch`-only override mode for GPT/Codex models. This mode bypasses most of this extension, but still gives you the `apply_patch` tool.
+- Renamed the native Codex web search tool from `web_search` to responses-native `web.run`, allowing compatibility with other extensions.
+- Synced the custom OpenAI Codex provider and Pi development dependencies with Pi `0.75.3`.
+
 ## 1.5.5
 
 - Avoid registering disabled native `web_search` and `image_generation` tools so other extensions can own those names.

package/README.md

@@ -26,7 +26,7 @@ When the adapter is active, the LLM sees these tools:
 - `exec_command` — shell execution with Codex-style `cmd` parameters and resumable sessions
 - `write_stdin` — continue or poll a running exec session
 - `apply_patch` — patch tool
-- `web_search` — native OpenAI Codex Responses web search, enabled only on the `openai-codex` provider
+- `web.run` — native OpenAI Codex Responses web search, enabled only on the `openai-codex` provider
 - `image_generation` — native OpenAI Codex Responses image generation, enabled only on image-capable `openai-codex` models
 - `view_image` — image-only wrapper around Pi's native image reading, enabled only for image-capable models
 
@@ -50,6 +50,10 @@ Use `/codex` to change adapter settings.
 
 Settings are saved globally in `~/.pi/agent/pi-codex-conversion.json`.
 
+The settings UI also has an **Overrides** tab. These options intentionally do not have `/codex ...` command shortcuts:
+
+- add only the Pi `apply_patch` tool for GPT/Codex models while keeping Pi's default toolkit, prompt, provider behavior, and compaction flow
+
 When `all` is on, non-Codex providers get the shell, patch, skill, and prompt-adapter behavior, but keep their normal Pi provider path. Native web search, native image generation, and priority service tier stay limited to the OpenAI Codex provider. Verbosity is applied to Responses API providers.
 
 The footer shows the active state, for example:
@@ -83,7 +87,7 @@ Raw command output is still available by expanding the tool result.
 - `exec_command` and `write_stdin` use a PTY-backed session manager for interactive commands and long-running processes.
 - `apply_patch` accepts absolute paths as-is and resolves relative paths against the current working directory.
 - Shell `apply_patch` is also available inside `exec_command`, but the dedicated `apply_patch` tool is preferred unless you are chaining edits with other shell steps.
-- Native `web_search` and `image_generation` are forwarded to OpenAI Codex Responses tools rather than executed as local function tools.
+- Native `web.run` and `image_generation` are forwarded to OpenAI Codex Responses tools rather than executed as local function tools.
 
 ## Development checkout
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.5.5",
+  "version": "1.5.6-dev.28.300a94c",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -60,9 +60,9 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.74.1",
-    "@earendil-works/pi-coding-agent": "^0.74.1",
-    "@earendil-works/pi-tui": "^0.74.1",
+    "@earendil-works/pi-ai": "^0.75.3",
+    "@earendil-works/pi-coding-agent": "^0.75.3",
+    "@earendil-works/pi-tui": "^0.75.3",
     "tsx": "^4.20.5",
     "typebox": "^1.1.24",
     "typescript": "^5.9.3"

package/src/adapter/activation.ts

@@ -3,21 +3,27 @@ import { isCodexLikeContext, isOpenAICodexContext, isResponsesContext } from "./
 import type { CodexConversionConfig } from "./config.ts";
 import type { AdapterState } from "./state.ts";
 import {
+	APPLY_PATCH_TOOL_NAME,
 	CORE_ADAPTER_TOOL_NAMES,
 	DEFAULT_TOOL_NAMES,
 	IMAGE_GENERATION_TOOL_NAME,
+	APPLY_PATCH_ONLY_STATUS_TEXT,
 	STATUS_KEY,
 	VIEW_IMAGE_TOOL_NAME,
 	WEB_SEARCH_TOOL_NAME,
+	SHELL_ADAPTER_TOOL_NAMES,
 	buildStatusText,
 } from "./tool-set.ts";
 import { supportsNativeImageGeneration } from "../tools/image-generation-tool.ts";
 import { supportsNativeWebSearch } from "../tools/web-search-tool.ts";
 
 const ADAPTER_TOOL_NAMES = [...CORE_ADAPTER_TOOL_NAMES, WEB_SEARCH_TOOL_NAME, IMAGE_GENERATION_TOOL_NAME, VIEW_IMAGE_TOOL_NAME];
-const ALWAYS_OWNED_ADAPTER_TOOL_NAMES = [...CORE_ADAPTER_TOOL_NAMES, VIEW_IMAGE_TOOL_NAME];
 
 export function syncAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
+	if (shouldUseApplyPatchOnly(ctx, state.config)) {
+		enableApplyPatchOnly(pi, ctx, state);
+		return;
+	}
 	if (shouldUseCodexAdapter(ctx, state.config)) {
 		enableAdapter(pi, ctx, state);
 	} else {
@@ -26,9 +32,28 @@ export function syncAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: Adap
 }
 
 export function shouldUseCodexAdapter(ctx: ExtensionContext, config: CodexConversionConfig): boolean {
+	if (config.applyPatchOnly) return false;
 	return config.useOnAllModels || isCodexLikeContext(ctx);
 }
 
+export function shouldUseApplyPatchOnly(ctx: ExtensionContext, config: CodexConversionConfig): boolean {
+	return config.applyPatchOnly && isCodexLikeContext(ctx);
+}
+
+function enableApplyPatchOnly(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
+	const adapterOwnedTools = [APPLY_PATCH_TOOL_NAME];
+	if (!state.enabled || state.adapterOwnedToolNames?.some((toolName) => toolName !== APPLY_PATCH_TOOL_NAME)) {
+		const restoredBase = state.enabled
+			? restoreTools(state.previousToolNames && state.previousToolNames.length > 0 ? state.previousToolNames : DEFAULT_TOOL_NAMES, pi.getActiveTools(), state.adapterOwnedToolNames ?? ADAPTER_TOOL_NAMES)
+			: stripAdapterTools(pi.getActiveTools(), ADAPTER_TOOL_NAMES);
+		state.previousToolNames = restoredBase;
+		state.enabled = true;
+	}
+	state.adapterOwnedToolNames = adapterOwnedTools;
+	pi.setActiveTools(mergeToolNames(state.previousToolNames ?? DEFAULT_TOOL_NAMES, adapterOwnedTools));
+	setApplyPatchOnlyStatus(ctx, state.config);
+}
+
 function enableAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
 	const currentAdapterOwnedTools = getAdapterOwnedToolNames(state.config);
 	const adapterOwnedTools = state.enabled ? mergeToolNames(state.adapterOwnedToolNames ?? currentAdapterOwnedTools, currentAdapterOwnedTools) : currentAdapterOwnedTools;
@@ -69,14 +94,20 @@ function setStatus(ctx: ExtensionContext, enabled: boolean, config: CodexConvers
 	ctx.ui.setStatus(STATUS_KEY, enabled ? buildStatusText(statusConfig) : undefined);
 }
 
+function setApplyPatchOnlyStatus(ctx: ExtensionContext, config: CodexConversionConfig): void {
+	if (!ctx.hasUI) return;
+	ctx.ui.setStatus(STATUS_KEY, config.statusLine ? APPLY_PATCH_ONLY_STATUS_TEXT : undefined);
+}
+
 function getStatusConfig(ctx: ExtensionContext, config: CodexConversionConfig): Parameters<typeof buildStatusText>[0] {
 	const showOpenAICodexFlags = isOpenAICodexContext(ctx);
 	const showResponsesVerbosity = isResponsesContext(ctx);
 	return {
 		useOnAllModels: config.useOnAllModels,
 		fast: showOpenAICodexFlags && config.fast,
-		webSearch: showOpenAICodexFlags && config.webSearch && supportsNativeWebSearch(ctx.model),
-		imageGeneration: showOpenAICodexFlags && config.imageGeneration && supportsNativeImageGeneration(ctx.model),
+		webSearch: showOpenAICodexFlags && !config.applyPatchOnly && config.webSearch && supportsNativeWebSearch(ctx.model),
+		imageGeneration: showOpenAICodexFlags && !config.applyPatchOnly && config.imageGeneration && supportsNativeImageGeneration(ctx.model),
+		compaction: { enabled: Boolean(config.responsesCompaction), model: config.compactionModel, reasoning: config.compactionReasoning },
 		...(showResponsesVerbosity ? { verbosity: config.verbosity } : {}),
 	};
 }
@@ -97,7 +128,9 @@ function getAdapterToolNames(ctx: ExtensionContext, config: CodexConversionConfi
 
 function getAdapterOwnedToolNames(config: CodexConversionConfig): string[] {
 	return [
-		...ALWAYS_OWNED_ADAPTER_TOOL_NAMES,
+		...SHELL_ADAPTER_TOOL_NAMES,
+		APPLY_PATCH_TOOL_NAME,
+		VIEW_IMAGE_TOOL_NAME,
 		...(config.webSearch ? [WEB_SEARCH_TOOL_NAME] : []),
 		...(config.imageGeneration ? [IMAGE_GENERATION_TOOL_NAME] : []),
 	];
@@ -108,7 +141,7 @@ function mergeToolNames(...toolNameGroups: string[][]): string[] {
 }
 
 export function mergeAdapterTools(activeTools: string[], adapterTools: string[], adapterOwnedTools: string[] = adapterTools): string[] {
-	const ownedTools = new Set([...ALWAYS_OWNED_ADAPTER_TOOL_NAMES, ...adapterTools, ...adapterOwnedTools]);
+	const ownedTools = new Set([...CORE_ADAPTER_TOOL_NAMES, ...adapterTools, ...adapterOwnedTools]);
 	const preservedTools = activeTools.filter((toolName) => !DEFAULT_TOOL_NAMES.includes(toolName) && !ownedTools.has(toolName));
 	return [...adapterTools, ...preservedTools];
 }

package/src/adapter/compact-client.ts

@@ -0,0 +1,257 @@
+import type { NativeCompactionRuntime } from "./compaction-runtime.ts";
+import type { NativeCompactionRequestBody } from "./serializer.ts";
+
+const JSON_CONTENT_TYPE = "application/json";
+
+type CompactResponseEnvelope = {
+	id?: string;
+	created_at?: number | string;
+	output: unknown[];
+	[key: string]: unknown;
+};
+
+export type NativeCompactionClientFailureReason =
+	| "aborted"
+	| "network-error"
+	| "non-2xx"
+	| "empty-body"
+	| "invalid-json"
+	| "malformed-response"
+	| "empty-output";
+
+export type NativeCompactionClientSuccess = {
+	ok: true;
+	status: number;
+	compactedWindow: unknown[];
+	compactResponseId?: string;
+	createdAt?: string;
+	response: CompactResponseEnvelope;
+};
+
+export type NativeCompactionClientFailure = {
+	ok: false;
+	reason: NativeCompactionClientFailureReason;
+	status?: number;
+	errorMessage?: string;
+	responseText?: string;
+	responseJson?: unknown;
+};
+
+export type NativeCompactionClientResult = NativeCompactionClientSuccess | NativeCompactionClientFailure;
+
+export type ExecuteNativeCompactionOptions = {
+	runtime: NativeCompactionRuntime;
+	request: NativeCompactionRequestBody;
+	signal?: AbortSignal;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isAbortError(error: unknown): boolean {
+	return (
+		(error instanceof DOMException && error.name === "AbortError") ||
+		(error instanceof Error && (error.name === "AbortError" || error.name === "ABORT_ERR"))
+	);
+}
+
+function normalizeResponseTimestamp(value: unknown): string | undefined {
+	if (typeof value === "number" && Number.isFinite(value)) {
+		const milliseconds = value > 1_000_000_000_000 ? value : value * 1000;
+		return new Date(milliseconds).toISOString();
+	}
+
+	if (typeof value !== "string") {
+		return undefined;
+	}
+
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+
+	const parsed = Date.parse(trimmed);
+	return Number.isNaN(parsed) ? trimmed : new Date(parsed).toISOString();
+}
+
+function isCompactOutputItem(value: unknown): value is Record<string, unknown> {
+	return isRecord(value);
+}
+
+function isCompactResponseEnvelope(value: unknown): value is CompactResponseEnvelope {
+	return isRecord(value) && Array.isArray(value.output) && value.output.every(isCompactOutputItem);
+}
+
+function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
+	const parts = token.split(".");
+	if (parts.length !== 3) {
+		return undefined;
+	}
+
+	try {
+		const payloadText = Buffer.from(parts[1]!, "base64url").toString("utf8");
+		const payload = JSON.parse(payloadText);
+		return isRecord(payload) ? payload : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function extractCodexAccountId(token: string): string | undefined {
+	const payload = decodeJwtPayload(token);
+	const authClaims = payload?.["https://api.openai.com/auth"];
+	if (!isRecord(authClaims)) {
+		return undefined;
+	}
+
+	const accountId = authClaims.chatgpt_account_id;
+	return typeof accountId === "string" && accountId.trim().length > 0 ? accountId.trim() : undefined;
+}
+
+function buildCodexUserAgent(): string {
+	const platform = typeof process !== "undefined" ? process.platform : "browser";
+	const arch = typeof process !== "undefined" ? process.arch : "unknown";
+	return `pi (${platform}; ${arch})`;
+}
+
+function extractBearerToken(headers: Headers): string | undefined {
+	const authorization = headers.get("authorization")?.trim();
+	const match = authorization?.match(/^Bearer\s+(.+)$/i);
+	return match?.[1]?.trim() || undefined;
+}
+
+function toHeaders(runtime: NativeCompactionRuntime): Record<string, string> {
+	const headers = new Headers(runtime.currentModel.headers ?? {});
+	for (const [key, value] of Object.entries(runtime.headers ?? {})) {
+		headers.set(key, value);
+	}
+	headers.set("accept", JSON_CONTENT_TYPE);
+	headers.set("content-type", JSON_CONTENT_TYPE);
+	if (runtime.apiKey) {
+		headers.set("authorization", `Bearer ${runtime.apiKey}`);
+	}
+
+	if (runtime.provider === "openai-codex") {
+		const accountId = extractCodexAccountId(runtime.apiKey ?? extractBearerToken(headers) ?? "");
+		if (accountId) {
+			headers.set("chatgpt-account-id", accountId);
+		}
+		headers.set("originator", "pi");
+		headers.set("user-agent", buildCodexUserAgent());
+		headers.set("openai-beta", "responses=experimental");
+	}
+
+	return Object.fromEntries(headers.entries());
+}
+
+export async function executeNativeCompaction(
+	options: ExecuteNativeCompactionOptions,
+): Promise<NativeCompactionClientResult> {
+	const { runtime, request, signal } = options;
+	const headers = toHeaders(runtime);
+
+	if (signal?.aborted) {
+		const aborted: NativeCompactionClientFailure = {
+			ok: false,
+			reason: "aborted",
+		};
+		return aborted;
+	}
+
+	try {
+		const response = await fetch(runtime.compactUrl, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(request),
+			signal,
+		});
+		const responseText = await response.text();
+
+		if (!response.ok) {
+			let responseJson: unknown;
+			if (responseText.trim().length > 0) {
+				try {
+					responseJson = JSON.parse(responseText);
+				} catch {
+					responseJson = undefined;
+				}
+			}
+
+			const failure: NativeCompactionClientFailure = {
+				ok: false,
+				reason: "non-2xx",
+				status: response.status,
+				responseText: responseText || undefined,
+				responseJson,
+			};
+			return failure;
+		}
+
+		if (!responseText.trim()) {
+			const failure: NativeCompactionClientFailure = {
+				ok: false,
+				reason: "empty-body",
+				status: response.status,
+			};
+			return failure;
+		}
+
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(responseText);
+		} catch (error) {
+			const failure: NativeCompactionClientFailure = {
+				ok: false,
+				reason: "invalid-json",
+				status: response.status,
+				errorMessage: error instanceof Error ? error.message : String(error),
+				responseText,
+			};
+			return failure;
+		}
+
+		if (!isCompactResponseEnvelope(parsed)) {
+			const failure: NativeCompactionClientFailure = {
+				ok: false,
+				reason: "malformed-response",
+				status: response.status,
+				responseJson: parsed,
+			};
+			return failure;
+		}
+
+		if (parsed.output.length === 0) {
+			const failure: NativeCompactionClientFailure = {
+				ok: false,
+				reason: "empty-output",
+				status: response.status,
+				responseJson: parsed,
+			};
+			return failure;
+		}
+
+		const success: NativeCompactionClientSuccess = {
+			ok: true,
+			status: response.status,
+			compactedWindow: [...parsed.output],
+			compactResponseId: typeof parsed.id === "string" && parsed.id.trim() ? parsed.id.trim() : undefined,
+			createdAt: normalizeResponseTimestamp(parsed.created_at),
+			response: parsed,
+		};
+		return success;
+	} catch (error) {
+		const failure: NativeCompactionClientFailure = isAbortError(error)
+			? {
+				ok: false,
+				reason: "aborted",
+			}
+			: {
+				ok: false,
+				reason: "network-error",
+				errorMessage: error instanceof Error ? error.message : String(error),
+			};
+
+		return failure;
+	}
+}

package/src/adapter/compaction-output.ts

@@ -0,0 +1,80 @@
+const COMPACTION_ITEM_TYPES = new Set(["compaction", "compaction_summary"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function cloneStructuredValue(value: unknown): unknown {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map(cloneStructuredValue);
+	}
+	if (isRecord(value)) {
+		const clone: Record<string, unknown> = {};
+		for (const [key, nested] of Object.entries(value)) {
+			clone[key] = cloneStructuredValue(nested);
+		}
+		return clone;
+	}
+	throw new Error(`Unsupported structured compact output value: ${typeof value}`);
+}
+
+function cloneCompactedOutputItem(item: Record<string, unknown>): Record<string, unknown> | undefined {
+	try {
+		return cloneStructuredValue(item) as Record<string, unknown>;
+	} catch {
+		return undefined;
+	}
+}
+
+export function shouldKeepCompactedOutputItem(item: unknown): item is Record<string, unknown> {
+	return isRecord(item) && typeof item.type === "string";
+}
+
+export function sanitizeCompactedWindow(output: readonly unknown[]): Record<string, unknown>[] {
+	const sanitized: Record<string, unknown>[] = [];
+	for (const item of output) {
+		if (!shouldKeepCompactedOutputItem(item)) continue;
+		const cloned = cloneCompactedOutputItem(item);
+		if (cloned) sanitized.push(cloned);
+	}
+	return sanitized;
+}
+
+export function extractCompactionSummaryText(compactedWindow: readonly unknown[]): string | undefined {
+	for (const item of compactedWindow) {
+		if (!isRecord(item) || typeof item.type !== "string" || !COMPACTION_ITEM_TYPES.has(item.type)) continue;
+		if (typeof item.encrypted_content === "string" && item.encrypted_content.trim().length > 0) return item.encrypted_content.trim();
+	}
+	return undefined;
+}
+
+export function hasCompactionOutputItem(compactedWindow: readonly unknown[]): boolean {
+	return compactedWindow.some((item) => isRecord(item) && typeof item.type === "string" && COMPACTION_ITEM_TYPES.has(item.type));
+}
+
+function describeOutputItem(item: unknown): string {
+	if (!isRecord(item)) return typeof item;
+	const type = typeof item.type === "string" ? item.type : "<missing-type>";
+	const role = typeof item.role === "string" ? `/${item.role}` : "";
+	const content = Array.isArray(item.content) ? ` content=${item.content.length}` : "";
+	const keys = Object.keys(item).sort().slice(0, 8).join(",");
+	return `${type}${role}${content} keys=[${keys}]`;
+}
+
+export function summarizeCompactionOutputForDiagnostics(rawOutput: readonly unknown[], sanitizedOutput: readonly unknown[]): string {
+	const rawTypes = rawOutput.map((item) => isRecord(item) && typeof item.type === "string" ? item.type : typeof item);
+	const sanitizedTypes = sanitizedOutput.map((item) => isRecord(item) && typeof item.type === "string" ? item.type : typeof item);
+	const rawCounts = countValues(rawTypes);
+	const sanitizedCounts = countValues(sanitizedTypes);
+	const sample = rawOutput.slice(0, 8).map((item, index) => `${index}: ${describeOutputItem(item)}`).join("; ");
+	return `raw=${rawOutput.length} {${rawCounts}}; sanitized=${sanitizedOutput.length} {${sanitizedCounts}}; sample=${sample || "<empty>"}`;
+}
+
+function countValues(values: readonly string[]): string {
+	const counts = new Map<string, number>();
+	for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
+	return Array.from(counts.entries()).map(([value, count]) => `${value}:${count}`).join(", ");
+}