@howaboua/pi-codex-conversion 1.5.4 → 1.5.5-dev.25.f80a775

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.5.5
+
+- Avoid registering disabled native `web_search` and `image_generation` tools so other extensions can own those names.
+- Preserve other extensions' `web_search` and `image_generation` tools when the matching Codex feature is off.
+- Added a `/codex status` toggle and settings UI option for hiding the Codex footer/statusline.
+
 ## 1.5.4
 
 - Added `/codex` settings UI.

package/README.md

@@ -42,6 +42,7 @@ Notably:
 Use `/codex` to change adapter settings.
 
 - `/codex all` — use the Codex tool and prompt adapter on every model
+- `/codex status` — toggle the footer/statusline entry
 - `/codex fast` — toggle priority service tier for the OpenAI Codex provider
 - `/codex search` — toggle native Codex web search
 - `/codex image` — toggle native Codex image generation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.5.4",
+  "version": "1.5.5-dev.25.f80a775",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {

package/src/adapter/activation.ts

@@ -15,6 +15,7 @@ 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 (shouldUseCodexAdapter(ctx, state.config)) {
@@ -29,32 +30,41 @@ export function shouldUseCodexAdapter(ctx: ExtensionContext, config: CodexConver
 }
 
 function enableAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
-	const toolNames = mergeAdapterTools(pi.getActiveTools(), getAdapterToolNames(ctx, state.config));
+	const currentAdapterOwnedTools = getAdapterOwnedToolNames(state.config);
+	const adapterOwnedTools = state.enabled ? mergeToolNames(state.adapterOwnedToolNames ?? currentAdapterOwnedTools, currentAdapterOwnedTools) : currentAdapterOwnedTools;
+	const toolNames = mergeAdapterTools(pi.getActiveTools(), getAdapterToolNames(ctx, state.config), adapterOwnedTools);
 	if (!state.enabled) {
 		// Preserve the previous active set once so switching away from Codex-like
 		// models restores the user's existing Pi tool configuration. Strip adapter
 		// tools in case a fresh session starts from persisted/mixed active tools.
-		state.previousToolNames = stripAdapterTools(pi.getActiveTools());
+		state.previousToolNames = stripAdapterTools(pi.getActiveTools(), adapterOwnedTools);
 		state.enabled = true;
 	}
+	state.adapterOwnedToolNames = currentAdapterOwnedTools;
 	pi.setActiveTools(toolNames);
 	setStatus(ctx, true, state.config);
 }
 
 function disableAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
 	const previousToolNames = state.previousToolNames && state.previousToolNames.length > 0 ? state.previousToolNames : DEFAULT_TOOL_NAMES;
-	const restoredTools = restoreTools(previousToolNames, pi.getActiveTools());
-	if (state.enabled || hasAdapterTools(pi.getActiveTools())) {
+	const adapterOwnedTools = state.adapterOwnedToolNames ?? getAdapterOwnedToolNames(state.config);
+	const restoredTools = restoreTools(previousToolNames, pi.getActiveTools(), adapterOwnedTools);
+	if (state.enabled || hasAdapterTools(pi.getActiveTools(), adapterOwnedTools)) {
 		pi.setActiveTools(restoredTools);
 	}
 	if (state.enabled) {
 		state.enabled = false;
+		state.adapterOwnedToolNames = undefined;
 	}
 	setStatus(ctx, false, state.config);
 }
 
 function setStatus(ctx: ExtensionContext, enabled: boolean, config: CodexConversionConfig): void {
 	if (!ctx.hasUI) return;
+	if (!config.statusLine) {
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		return;
+	}
 	const statusConfig = getStatusConfig(ctx, config);
 	ctx.ui.setStatus(STATUS_KEY, enabled ? buildStatusText(statusConfig) : undefined);
 }
@@ -67,6 +77,7 @@ function getStatusConfig(ctx: ExtensionContext, config: CodexConversionConfig):
 		fast: showOpenAICodexFlags && config.fast,
 		webSearch: showOpenAICodexFlags && config.webSearch && supportsNativeWebSearch(ctx.model),
 		imageGeneration: showOpenAICodexFlags && config.imageGeneration && supportsNativeImageGeneration(ctx.model),
+		compaction: { enabled: Boolean(config.responsesCompaction), model: config.compactionModel, reasoning: config.compactionReasoning },
 		...(showResponsesVerbosity ? { verbosity: config.verbosity } : {}),
 	};
 }
@@ -85,25 +96,38 @@ function getAdapterToolNames(ctx: ExtensionContext, config: CodexConversionConfi
 	return toolNames;
 }
 
-export function mergeAdapterTools(activeTools: string[], adapterTools: string[]): string[] {
-	const preservedTools = activeTools.filter((toolName) => !DEFAULT_TOOL_NAMES.includes(toolName) && !ADAPTER_TOOL_NAMES.includes(toolName));
+function getAdapterOwnedToolNames(config: CodexConversionConfig): string[] {
+	return [
+		...ALWAYS_OWNED_ADAPTER_TOOL_NAMES,
+		...(config.webSearch ? [WEB_SEARCH_TOOL_NAME] : []),
+		...(config.imageGeneration ? [IMAGE_GENERATION_TOOL_NAME] : []),
+	];
+}
+
+function mergeToolNames(...toolNameGroups: string[][]): string[] {
+	return [...new Set(toolNameGroups.flat())];
+}
+
+export function mergeAdapterTools(activeTools: string[], adapterTools: string[], adapterOwnedTools: string[] = adapterTools): string[] {
+	const ownedTools = new Set([...ALWAYS_OWNED_ADAPTER_TOOL_NAMES, ...adapterTools, ...adapterOwnedTools]);
+	const preservedTools = activeTools.filter((toolName) => !DEFAULT_TOOL_NAMES.includes(toolName) && !ownedTools.has(toolName));
 	return [...adapterTools, ...preservedTools];
 }
 
-export function restoreTools(previousTools: string[], activeTools: string[]): string[] {
-	const restored = stripAdapterTools(previousTools);
+export function restoreTools(previousTools: string[], activeTools: string[], adapterOwnedTools: string[] = ADAPTER_TOOL_NAMES): string[] {
+	const restored = stripAdapterTools(previousTools, adapterOwnedTools);
 	for (const toolName of activeTools) {
-		if (!ADAPTER_TOOL_NAMES.includes(toolName) && !restored.includes(toolName)) {
+		if (!adapterOwnedTools.includes(toolName) && !restored.includes(toolName)) {
 			restored.push(toolName);
 		}
 	}
 	return restored;
 }
 
-export function stripAdapterTools(toolNames: string[]): string[] {
-	return toolNames.filter((toolName) => !ADAPTER_TOOL_NAMES.includes(toolName));
+export function stripAdapterTools(toolNames: string[], adapterOwnedTools: string[] = ADAPTER_TOOL_NAMES): string[] {
+	return toolNames.filter((toolName) => !adapterOwnedTools.includes(toolName));
 }
 
-function hasAdapterTools(activeTools: string[]): boolean {
-	return activeTools.some((toolName) => ADAPTER_TOOL_NAMES.includes(toolName));
+function hasAdapterTools(activeTools: string[], adapterOwnedTools: string[]): boolean {
+	return activeTools.some((toolName) => adapterOwnedTools.includes(toolName));
 }

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(", ");
+}