@howaboua/pi-codex-conversion 1.5.4-dev.19.703be35 → 1.5.4-dev.20.3249745

package/CHANGELOG.md

@@ -0,0 +1,127 @@
+# Changelog
+
+## 1.5.4
+
+- Added `/codex` settings UI.
+- Added saved global config at `~/.pi/agent/pi-codex-conversion.json`.
+- Added toggles for fast mode, native web search, native image generation, and using the adapter on all models.
+- Added verbosity control for Responses API providers.
+- Added footer status details for active Codex settings.
+- Added quick links from the settings UI to GitHub, Discord, and issue filing.
+- Updated Pi development dependencies to 0.74.1.
+
+## 1.5.3
+
+- Improved exploration output for skill reads so `SKILL.md` activity is easier to understand.
+
+## 1.5.2
+
+- Streamed partial `exec_command` updates while commands are still running.
+- Improved background terminal responsiveness and display state.
+
+## 1.5.1
+
+- Cleaned up the Codex adapter prompt and tool surface.
+- Fixed skill prompt injection after reload.
+- Fixed adapter tool restore behavior when switching models.
+- Simplified tool descriptions and README wording.
+- Bundled `apply_patch` and moved publishing to GitHub Actions.
+
+## 1.5.0
+
+- Aligned the Codex provider with Pi 0.73 and Pi 0.74 package/API changes.
+- Updated package scope for the Earendil Pi packages.
+- Removed a noisy web search startup note.
+
+## 1.0.29
+
+- Aligned with Pi 0.72.
+- Fixed cached websocket transport behavior.
+- Fixed thinking-level mapping and runtime compatibility issues.
+
+## 1.0.28
+
+- Aligned with Pi 0.70.5 Codex provider changes.
+
+## 1.0.27
+
+- Marked Codex websocket failures as retryable connection errors.
+
+## 1.0.26
+
+- Retried stale Codex websocket reuse.
+
+## 1.0.25
+
+- Sanitized Codex image generation history before sending follow-up requests.
+
+## 1.0.24
+
+- Updated the adapter for Pi 0.70 compatibility.
+- Fixed Codex websocket close race handling.
+
+## 1.0.23
+
+- Hotfix to remove a stale Codex max token field.
+
+## 1.0.22
+
+- Hotfix to omit unsupported Codex max output tokens.
+
+## 1.0.21
+
+- Hardened Codex provider streaming and image handling.
+- Preserved Codex image generation calls in conversation history.
+- Aligned websocket client behavior with Pi's Codex provider.
+- Future-proofed GPT-5 reasoning effort clamping.
+
+## 1.0.20
+
+- Updated for Pi 0.69 typebox changes.
+- Replicated Pi Codex websocket transport handling.
+- Fixed Codex SSE parsing, websocket auth, stream indexing, and websocket caching.
+- Moved image path guidance into prompt/tool text.
+- Hardened runtime behavior and activity ordering.
+
+## 1.0.19
+
+- Added native Codex web search and image generation support.
+- Fixed Codex custom provider packaging and session handling.
+- Restored Pi's default shell renderer for `apply_patch`.
+
+## 1.0.18
+
+- Aligned the extension with Pi 0.67.3 APIs.
+- Fixed `prepareArguments` validation regressions.
+
+## 1.0.17
+
+- Improved `apply_patch` fuzzy matching safety.
+- Continued applying independent patch actions after file failures.
+- Blocked dependent patch actions after earlier failures.
+- Tightened delete matching and path canonicalization.
+- Improved section-anchor matching and partial move failure reporting.
+
+## 1.0.12
+
+- Added structured `apply_patch` recovery hints.
+- Improved `apply_patch` failure rendering.
+- Capped exec session buffers at 256 MiB.
+
+## 1.0.11
+
+- Hotfix to show `apply_patch` failures after arguments complete.
+- Hotfix to hide incomplete `apply_patch` previews.
+
+## 1.0.10
+
+- Rendered partial `apply_patch` failures inline.
+- Added PTY polling guardrails for `write_stdin`.
+- Clamped tiny `exec_command` waits for non-interactive runs.
+- Clarified `write_stdin` polling behavior in the README.
+
+## 1.0.9
+
+- Initial public release of the Codex-style Pi adapter.
+- Added Codex-style shell tools, resumable exec sessions, patch editing, and tool rendering.
+- Forced bash when Pi is launched under fish while preserving fish-derived `PATH`.

package/README.md

@@ -9,22 +9,14 @@ GPT/Codex models are strongest when the tool surface looks like the Codex CLI th
 
 The point is to give the model tools it already knows how to use well: shell-first inspection, resumable command sessions, and large one-shot patch edits instead of piecemeal read/edit/write steps.
 
+You can also opt into using the adapter on every provider/model. YMMV: Codex-tuned models are still the best fit, but the shell/patch workflow can help elsewhere too. The extension also has a small `/codex` settings UI for toggling adapter behavior, web search, image generation, fast mode, and verbosity. See [Settings](#settings).
+
 ## Install
 
 ```bash
 pi install npm:@howaboua/pi-codex-conversion
 ```
 
-## Development checkout
-
-The Git checkout is mostly for development and mirrors the maintainer workflow. If you run it directly, you may need to build the bundled `apply_patch` binary for your platform.
-
-Run the current checkout without installing globally:
-
-```bash
-pi --no-extensions --no-skills -e /path/to/pi-codex-conversion
-```
-
 ![Available tools](./available-tools.png)
 
 ## Active tools in adapter mode
@@ -45,6 +37,26 @@ Notably:
 - file creation and edits should default to `apply_patch`
 - Pi may still expose additional runtime tools such as `parallel`; the prompt is written to tolerate that instead of assuming a fixed four-tool universe
 
+## Settings
+
+Use `/codex` to change adapter settings.
+
+- `/codex all` — use the Codex tool and prompt adapter on every model
+- `/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
+- `/codex low`, `/codex medium`, `/codex high` — set Responses API verbosity
+
+Settings are saved globally in `~/.pi/agent/pi-codex-conversion.json`.
+
+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:
+
+```text
+Codex adapter V: low • web search • image gen
+```
+
 ## What changes in Pi
 
 - Adapter mode activates automatically for OpenAI `gpt*` and `codex*` models, then restores the previous tool set when you switch away.
@@ -72,6 +84,16 @@ Raw command output is still available by expanding the tool result.
 - 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.
 
+## Development checkout
+
+The Git checkout is mostly for development and mirrors the maintainer workflow. If you run it directly, you may need to build the bundled `apply_patch` binary for your platform.
+
+Run the current checkout without installing globally:
+
+```bash
+pi --no-extensions --no-skills -e /path/to/pi-codex-conversion
+```
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.5.4-dev.19.703be35",
+  "version": "1.5.4-dev.20.3249745",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -33,6 +33,7 @@
     "bin/apply_patch.cmd",
     "vendor/apply-patch/**",
     "available-tools.png",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],

package/src/adapter/activation.ts

@@ -0,0 +1,109 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isCodexLikeContext, isOpenAICodexContext, isResponsesContext } from "./codex-model.ts";
+import type { CodexConversionConfig } from "./config.ts";
+import type { AdapterState } from "./state.ts";
+import {
+	CORE_ADAPTER_TOOL_NAMES,
+	DEFAULT_TOOL_NAMES,
+	IMAGE_GENERATION_TOOL_NAME,
+	STATUS_KEY,
+	VIEW_IMAGE_TOOL_NAME,
+	WEB_SEARCH_TOOL_NAME,
+	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];
+
+export function syncAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
+	if (shouldUseCodexAdapter(ctx, state.config)) {
+		enableAdapter(pi, ctx, state);
+	} else {
+		disableAdapter(pi, ctx, state);
+	}
+}
+
+export function shouldUseCodexAdapter(ctx: ExtensionContext, config: CodexConversionConfig): boolean {
+	return config.useOnAllModels || isCodexLikeContext(ctx);
+}
+
+function enableAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
+	const toolNames = mergeAdapterTools(pi.getActiveTools(), getAdapterToolNames(ctx, state.config));
+	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.enabled = true;
+	}
+	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())) {
+		pi.setActiveTools(restoredTools);
+	}
+	if (state.enabled) {
+		state.enabled = false;
+	}
+	setStatus(ctx, false, state.config);
+}
+
+function setStatus(ctx: ExtensionContext, enabled: boolean, config: CodexConversionConfig): void {
+	if (!ctx.hasUI) return;
+	const statusConfig = getStatusConfig(ctx, config);
+	ctx.ui.setStatus(STATUS_KEY, enabled ? buildStatusText(statusConfig) : 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),
+		...(showResponsesVerbosity ? { verbosity: config.verbosity } : {}),
+	};
+}
+
+function getAdapterToolNames(ctx: ExtensionContext, config: CodexConversionConfig): string[] {
+	const toolNames = [...CORE_ADAPTER_TOOL_NAMES];
+	if (config.webSearch && supportsNativeWebSearch(ctx.model)) {
+		toolNames.push(WEB_SEARCH_TOOL_NAME);
+	}
+	if (config.imageGeneration && supportsNativeImageGeneration(ctx.model)) {
+		toolNames.push(IMAGE_GENERATION_TOOL_NAME);
+	}
+	if (Array.isArray(ctx.model?.input) && ctx.model.input.includes("image")) {
+		toolNames.push(VIEW_IMAGE_TOOL_NAME);
+	}
+	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));
+	return [...adapterTools, ...preservedTools];
+}
+
+export function restoreTools(previousTools: string[], activeTools: string[]): string[] {
+	const restored = stripAdapterTools(previousTools);
+	for (const toolName of activeTools) {
+		if (!ADAPTER_TOOL_NAMES.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));
+}
+
+function hasAdapterTools(activeTools: string[]): boolean {
+	return activeTools.some((toolName) => ADAPTER_TOOL_NAMES.includes(toolName));
+}

package/src/adapter/codex-model.ts

@@ -11,6 +11,11 @@ export function isOpenAICodexModel(model: Partial<CodexLikeModelDescriptor> | nu
 	return (model.provider ?? "").toLowerCase() === "openai-codex";
 }
 
+export function isResponsesModel(model: Partial<CodexLikeModelDescriptor> | null | undefined): boolean {
+	if (!model) return false;
+	return (model.api ?? "").toLowerCase().includes("responses");
+}
+
 // Keep model detection intentionally conservative. The adapter replaces the
 // system prompt and tool surface, so false positives are worse than misses.
 export function isCodexLikeModel(model: Partial<CodexLikeModelDescriptor> | null | undefined): boolean {
@@ -30,3 +35,7 @@ export function isCodexLikeContext(ctx: ExtensionContext): boolean {
 export function isOpenAICodexContext(ctx: ExtensionContext): boolean {
 	return isOpenAICodexModel(ctx.model);
 }
+
+export function isResponsesContext(ctx: ExtensionContext): boolean {
+	return isResponsesModel(ctx.model);
+}

package/src/adapter/config.ts

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export type CodexVerbosity = "low" | "medium" | "high";
+
+export interface CodexConversionConfig {
+	fast: boolean;
+	imageGeneration: boolean;
+	useOnAllModels: boolean;
+	webSearch: boolean;
+	verbosity: CodexVerbosity;
+}
+
+export const CODEX_CONVERSION_CONFIG_BASENAME = "pi-codex-conversion.json";
+export const DEFAULT_CODEX_CONVERSION_CONFIG: CodexConversionConfig = {
+	fast: false,
+	imageGeneration: true,
+	useOnAllModels: false,
+	webSearch: true,
+	verbosity: "low",
+};
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function normalizeCodexVerbosity(value: unknown): CodexVerbosity | undefined {
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim().toLowerCase();
+	return normalized === "low" || normalized === "medium" || normalized === "high" ? normalized : undefined;
+}
+
+export function getCodexConversionConfigPath(agentDir: string = getAgentDir()): string {
+	return join(agentDir, CODEX_CONVERSION_CONFIG_BASENAME);
+}
+
+export function readCodexConversionConfig(configPath: string = getCodexConversionConfigPath()): CodexConversionConfig {
+	if (!existsSync(configPath)) {
+		writeCodexConversionConfig(DEFAULT_CODEX_CONVERSION_CONFIG, configPath);
+		return { ...DEFAULT_CODEX_CONVERSION_CONFIG };
+	}
+
+	try {
+		const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as unknown;
+		if (!isObject(parsed)) return { ...DEFAULT_CODEX_CONVERSION_CONFIG };
+		return {
+			fast: typeof parsed.fast === "boolean" ? parsed.fast : DEFAULT_CODEX_CONVERSION_CONFIG.fast,
+			imageGeneration: typeof parsed.imageGeneration === "boolean" ? parsed.imageGeneration : DEFAULT_CODEX_CONVERSION_CONFIG.imageGeneration,
+			useOnAllModels: typeof parsed.useOnAllModels === "boolean" ? parsed.useOnAllModels : DEFAULT_CODEX_CONVERSION_CONFIG.useOnAllModels,
+			webSearch: typeof parsed.webSearch === "boolean" ? parsed.webSearch : DEFAULT_CODEX_CONVERSION_CONFIG.webSearch,
+			verbosity: normalizeCodexVerbosity(parsed.verbosity) ?? DEFAULT_CODEX_CONVERSION_CONFIG.verbosity,
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`[pi-codex-conversion] Failed to read ${configPath}: ${message}`);
+		return { ...DEFAULT_CODEX_CONVERSION_CONFIG };
+	}
+}
+
+export function writeCodexConversionConfig(
+	config: CodexConversionConfig,
+	configPath: string = getCodexConversionConfigPath(),
+): { ok: true } | { ok: false; error: string } {
+	try {
+		mkdirSync(dirname(configPath), { recursive: true });
+		writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+		return { ok: true };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`[pi-codex-conversion] Failed to write ${configPath}: ${message}`);
+		return { ok: false, error: message };
+	}
+}
+
+export function applyCodexRequestParams(
+	payload: unknown,
+	config: CodexConversionConfig,
+	options: { serviceTier?: boolean; verbosity?: boolean } = { serviceTier: true, verbosity: true },
+): unknown {
+	if (!isObject(payload)) return payload;
+	const text = isObject(payload.text) ? payload.text : {};
+	return {
+		...payload,
+		...(options.serviceTier && config.fast ? { service_tier: "priority" } : {}),
+		...(options.verbosity ? { text: { ...text, verbosity: config.verbosity } } : {}),
+	};
+}

package/src/adapter/provider-request.ts

@@ -0,0 +1,23 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isOpenAICodexContext, isResponsesContext } from "./codex-model.ts";
+import { applyCodexRequestParams } from "./config.ts";
+import type { AdapterState } from "./state.ts";
+import { rewriteNativeImageGenerationTool } from "../tools/image-generation-tool.ts";
+import { rewriteNativeWebSearchTool } from "../tools/web-search-tool.ts";
+import { shouldUseCodexAdapter } from "./activation.ts";
+
+export function rewriteCodexProviderRequest(payload: unknown, ctx: ExtensionContext, state: AdapterState): unknown | undefined {
+	if (!shouldUseCodexAdapter(ctx, state.config) || (!isOpenAICodexContext(ctx) && !isResponsesContext(ctx))) {
+		return undefined;
+	}
+
+	const isOpenAICodex = isOpenAICodexContext(ctx);
+	const webSearchPayload = isOpenAICodex && state.config.webSearch ? rewriteNativeWebSearchTool(payload, ctx.model) : payload;
+	const imageGenerationPayload = isOpenAICodex && state.config.imageGeneration
+		? rewriteNativeImageGenerationTool(webSearchPayload, ctx.model)
+		: webSearchPayload;
+	return applyCodexRequestParams(imageGenerationPayload, state.config, {
+		serviceTier: isOpenAICodex,
+		verbosity: true,
+	});
+}

package/src/adapter/skills.ts

@@ -0,0 +1,17 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export function getCodexSkillPaths(cwd: string, home: string = homedir()): string[] {
+	const skillPaths = [join(home, ".agents", "skills")];
+	let currentDir = resolve(cwd);
+	while (true) {
+		skillPaths.push(join(currentDir, ".agents", "skills"));
+		const parentDir = resolve(currentDir, "..");
+		if (parentDir === currentDir) {
+			break;
+		}
+		currentDir = parentDir;
+	}
+	return skillPaths.filter((path) => existsSync(path));
+}

package/src/adapter/state.ts

@@ -0,0 +1,10 @@
+import type { PromptSkill } from "../prompt/build-system-prompt.ts";
+import type { CodexConversionConfig } from "./config.ts";
+
+export interface AdapterState {
+	enabled: boolean;
+	cwd: string;
+	previousToolNames?: string[];
+	promptSkills: PromptSkill[];
+	config: CodexConversionConfig;
+}

package/src/adapter/tool-set.ts

@@ -1,6 +1,19 @@
 export const STATUS_KEY = "codex-adapter";
 export const STATUS_TEXT = "\u001b[38;2;0;76;255mCodex adapter\u001b[0m";
 
+export function buildStatusText(options: { verbosity?: string; webSearch: boolean; imageGeneration: boolean; fast: boolean; useOnAllModels: boolean }): string {
+	const extras = [
+		options.useOnAllModels ? "all models" : undefined,
+		options.webSearch ? "web search" : undefined,
+		options.imageGeneration ? "image gen" : undefined,
+		options.fast ? "fast" : undefined,
+	]
+		.filter(Boolean)
+		.join(" • ");
+	const verbosity = options.verbosity === "medium" ? "mid" : options.verbosity === "high" ? "hi" : options.verbosity;
+	return `${STATUS_TEXT}${verbosity ? ` V: ${verbosity}` : ""}${extras ? ` • ${extras}` : ""}`;
+}
+
 export const DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write"];
 
 export const CORE_ADAPTER_TOOL_NAMES = ["exec_command", "write_stdin", "apply_patch"];

package/src/codex-settings/command.ts

@@ -0,0 +1,68 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	normalizeCodexVerbosity,
+	readCodexConversionConfig,
+	writeCodexConversionConfig,
+	type CodexConversionConfig,
+} from "../adapter/config.ts";
+import { syncAdapter } from "../adapter/activation.ts";
+import type { AdapterState } from "../adapter/state.ts";
+import { openCodexSettingsScreen } from "./ui.ts";
+
+const CODEX_COMMAND_COMPLETIONS = ["all", "fast", "search", "image", "low", "medium", "high"] as const;
+
+export function registerCodexCommand(pi: ExtensionAPI, state: AdapterState): void {
+	function saveAndApply(ctx: ExtensionContext, nextConfig: CodexConversionConfig): boolean {
+		const writeResult = writeCodexConversionConfig(nextConfig);
+		if (!writeResult.ok) {
+			ctx.ui.notify(`Failed to save Codex settings: ${writeResult.error}`, "error");
+			return false;
+		}
+		state.config = nextConfig;
+		syncAdapter(pi, ctx, state);
+		return true;
+	}
+
+	pi.registerCommand("codex", {
+		description: "Configure Codex adapter settings",
+		getArgumentCompletions: (prefix) =>
+			CODEX_COMMAND_COMPLETIONS.filter((item) => item.startsWith(prefix.trim().toLowerCase())).map((value) => ({ label: value, value })),
+		handler: async (args, ctx) => {
+			state.config = readCodexConversionConfig();
+			const arg = args.trim().toLowerCase();
+			const nextConfig = getCommandConfigUpdate(arg, state.config);
+			if (nextConfig) {
+				saveAndApply(ctx, nextConfig);
+				return;
+			}
+
+			if (arg) {
+				ctx.ui.notify("Usage: /codex, /codex all, /codex fast, /codex search, /codex image, /codex low|medium|high", "warning");
+				return;
+			}
+
+			if (!ctx.hasUI) {
+				ctx.ui.notify(formatCodexSettings(state.config), "info");
+				return;
+			}
+
+			await openCodexSettingsScreen(ctx, {
+				initialConfig: state.config,
+				onChange: (config) => saveAndApply(ctx, config),
+			});
+		},
+	});
+}
+
+function getCommandConfigUpdate(arg: string, config: CodexConversionConfig): CodexConversionConfig | undefined {
+	if (arg === "fast") return { ...config, fast: !config.fast };
+	if (arg === "all") return { ...config, useOnAllModels: !config.useOnAllModels };
+	if (arg === "search") return { ...config, webSearch: !config.webSearch };
+	if (arg === "image") return { ...config, imageGeneration: !config.imageGeneration };
+	const verbosity = normalizeCodexVerbosity(arg);
+	return verbosity ? { ...config, verbosity } : undefined;
+}
+
+function formatCodexSettings(config: CodexConversionConfig): string {
+	return `Codex settings: all models ${config.useOnAllModels ? "on" : "off"}, fast ${config.fast ? "on" : "off"}, web search ${config.webSearch ? "on" : "off"}, image generation ${config.imageGeneration ? "on" : "off"}, verbosity ${config.verbosity}`;
+}

package/src/codex-settings/links.ts

@@ -0,0 +1,16 @@
+import { spawn } from "node:child_process";
+
+export const GITHUB_URL = "https://github.com/IgorWarzocha/pi-codex-conversion";
+export const CHANGELOG_URL = `${GITHUB_URL}/blob/master/CHANGELOG.md`;
+export const DISCORD_URL = "https://discord.com/channels/1456806362351669492/1482388023994748948";
+export const ISSUE_URL = `${GITHUB_URL}/issues/new`;
+
+export function openExternalUrl(url: string): void {
+	const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+	const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+	const child = spawn(command, args, { detached: true, stdio: "ignore" });
+	child.on("error", (error) => {
+		console.warn(`[pi-codex-conversion] Failed to open ${url}: ${error.message}`);
+	});
+	child.unref();
+}

package/src/codex-settings/ui.ts

@@ -0,0 +1,92 @@
+import { DynamicBorder, getSettingsListTheme, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Box, Container, SettingsList, Spacer, Text, type SettingItem } from "@earendil-works/pi-tui";
+import { DEFAULT_CODEX_CONVERSION_CONFIG, normalizeCodexVerbosity, type CodexConversionConfig } from "../adapter/config.ts";
+import { CHANGELOG_URL, DISCORD_URL, GITHUB_URL, ISSUE_URL, openExternalUrl } from "./links.ts";
+
+export interface CodexSettingsScreenOptions {
+	initialConfig: CodexConversionConfig;
+	onChange: (nextConfig: CodexConversionConfig) => boolean;
+}
+
+export async function openCodexSettingsScreen(ctx: ExtensionContext, options: CodexSettingsScreenOptions): Promise<void> {
+	let draft = { ...options.initialConfig };
+	await ctx.ui.custom<void>((tui, theme, _kb, done) => {
+		const buildItems = (): SettingItem[] => [
+			{ id: "useOnAllModels", label: "Use on all models", currentValue: draft.useOnAllModels ? "on" : "off", values: ["off", "on"] },
+			{ id: "fast", label: "Fast mode", currentValue: draft.fast ? "on" : "off", values: ["off", "on"] },
+			{ id: "webSearch", label: "Web search", currentValue: draft.webSearch ? "on" : "off", values: ["off", "on"] },
+			{ id: "imageGeneration", label: "Image generation", currentValue: draft.imageGeneration ? "on" : "off", values: ["off", "on"] },
+			{ id: "verbosity", label: "Verbosity", currentValue: draft.verbosity, values: ["low", "medium", "high"] },
+		];
+
+		const container = new Container();
+		const panel = new Box(1, 0);
+		panel.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+		let settingsList: SettingsList;
+		settingsList = new SettingsList(buildItems(), 6, getSettingsListTheme(), (id, value) => {
+			const nextDraft = { ...draft };
+			const previousValue = buildItems().find((item) => item.id === id)?.currentValue;
+			if (id === "useOnAllModels") nextDraft.useOnAllModels = value === "on";
+			if (id === "fast") nextDraft.fast = value === "on";
+			if (id === "webSearch") nextDraft.webSearch = value === "on";
+			if (id === "imageGeneration") nextDraft.imageGeneration = value === "on";
+			if (id === "verbosity") nextDraft.verbosity = normalizeCodexVerbosity(value) ?? DEFAULT_CODEX_CONVERSION_CONFIG.verbosity;
+			if (options.onChange(nextDraft)) {
+				draft = nextDraft;
+			} else if (previousValue !== undefined) {
+				settingsList.updateValue(id, previousValue);
+			}
+			tui.requestRender();
+		}, () => done(undefined));
+		panel.addChild(settingsList);
+		panel.addChild(new DynamicBorder((text) => theme.fg("dim", text)));
+		panel.addChild(
+			new Text(
+				[
+					`${theme.bold("g")} github  ${theme.fg("dim", GITHUB_URL)}`,
+					`${theme.bold("c")} changes ${theme.fg("dim", CHANGELOG_URL)}`,
+					`${theme.bold("d")} discord ${theme.fg("dim", DISCORD_URL)}`,
+					`${theme.bold("i")} issue   ${theme.fg("dim", ISSUE_URL)}`,
+				].join("\n"),
+				0,
+				0,
+			),
+		);
+		panel.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+		container.addChild(new Spacer(1));
+		container.addChild(panel);
+
+		return {
+			render: (width: number) => container.render(width),
+			invalidate: () => container.invalidate(),
+			handleInput: (data: string) => {
+				if (handleLinkKey(data, ctx)) return;
+				settingsList.handleInput?.(data);
+				tui.requestRender();
+			},
+		};
+	});
+}
+
+function handleLinkKey(data: string, ctx: ExtensionContext): boolean {
+	const target = getLinkTarget(data);
+	if (!target) return false;
+	openExternalUrl(target.url);
+	ctx.ui.notify(target.message, "info");
+	return true;
+}
+
+function getLinkTarget(data: string): { url: string; message: string } | undefined {
+	switch (data) {
+		case "g":
+			return { url: GITHUB_URL, message: "Opened GitHub" };
+		case "c":
+			return { url: CHANGELOG_URL, message: "Opened changelog" };
+		case "d":
+			return { url: DISCORD_URL, message: "Opened Discord" };
+		case "i":
+			return { url: ISSUE_URL, message: "Opened issue form" };
+		default:
+			return undefined;
+	}
+}

package/src/index.ts

@@ -1,19 +1,6 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getCodexRuntimeShell } from "./adapter/runtime-shell.ts";
-import {
-	CORE_ADAPTER_TOOL_NAMES,
-	DEFAULT_TOOL_NAMES,
-	IMAGE_GENERATION_TOOL_NAME,
-	STATUS_KEY,
-	STATUS_TEXT,
-	VIEW_IMAGE_TOOL_NAME,
-	WEB_SEARCH_TOOL_NAME,
-} from "./adapter/tool-set.ts";
 import { clearApplyPatchRenderState, registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
-import { isCodexLikeContext, isOpenAICodexContext } from "./adapter/codex-model.ts";
 import { createExecCommandTracker } from "./tools/exec-command-state.ts";
 import { registerExecCommandTool } from "./tools/exec-command-tool.ts";
 import { createExecSessionManager } from "./tools/exec-session-manager.ts";
@@ -22,26 +9,18 @@ import {
 	WEB_SEARCH_ACTIVITY_MESSAGE_TYPE,
 	registerOpenAICodexCustomProvider,
 } from "./providers/openai-codex-custom-provider.ts";
-import { registerImageGenerationTool, rewriteNativeImageGenerationTool, supportsNativeImageGeneration } from "./tools/image-generation-tool.ts";
-import { buildCodexSystemPrompt, extractPiPromptSkills, resolvePromptSkills, type PromptSkill } from "./prompt/build-system-prompt.ts";
+import { registerImageGenerationTool } from "./tools/image-generation-tool.ts";
+import { buildCodexSystemPrompt, extractPiPromptSkills, resolvePromptSkills } from "./prompt/build-system-prompt.ts";
 import { registerViewImageTool, supportsOriginalImageDetail } from "./tools/view-image-tool.ts";
-import {
-	registerWebSearchTool,
-	rewriteNativeWebSearchTool,
-	supportsNativeWebSearch,
-	WEB_SEARCH_SESSION_NOTE_TYPE,
-} from "./tools/web-search-tool.ts";
+import { registerWebSearchTool, WEB_SEARCH_SESSION_NOTE_TYPE } from "./tools/web-search-tool.ts";
 import { registerWriteStdinTool } from "./tools/write-stdin-tool.ts";
 import { ensureBundledApplyPatchOnPath } from "./tools/apply-patch-binary.ts";
-
-interface AdapterState {
-	enabled: boolean;
-	cwd: string;
-	previousToolNames?: string[];
-	promptSkills: PromptSkill[];
-}
-
-const ADAPTER_TOOL_NAMES = [...CORE_ADAPTER_TOOL_NAMES, WEB_SEARCH_TOOL_NAME, IMAGE_GENERATION_TOOL_NAME, VIEW_IMAGE_TOOL_NAME];
+import { readCodexConversionConfig } from "./adapter/config.ts";
+import { syncAdapter, mergeAdapterTools, restoreTools, stripAdapterTools, shouldUseCodexAdapter } from "./adapter/activation.ts";
+import { rewriteCodexProviderRequest } from "./adapter/provider-request.ts";
+import { getCodexSkillPaths } from "./adapter/skills.ts";
+import type { AdapterState } from "./adapter/state.ts";
+import { registerCodexCommand } from "./codex-settings/command.ts";
 
 function getCommandArg(args: unknown): string | undefined {
 	if (!args || typeof args !== "object" || !("cmd" in args) || typeof args.cmd !== "string") {
@@ -63,7 +42,7 @@ function isToolCallOnlyAssistantMessage(message: unknown): boolean {
 export default function codexConversion(pi: ExtensionAPI) {
 	ensureBundledApplyPatchOnPath();
 	const tracker = createExecCommandTracker();
-	const state: AdapterState = { enabled: false, cwd: process.cwd(), promptSkills: [] };
+	const state: AdapterState = { enabled: false, cwd: process.cwd(), promptSkills: [], config: readCodexConversionConfig() };
 	const sessions = createExecSessionManager();
 
 	registerOpenAICodexCustomProvider(pi, {
@@ -74,6 +53,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 	registerWriteStdinTool(pi, sessions);
 	registerImageGenerationTool(pi);
 	registerWebSearchTool(pi);
+	registerCodexCommand(pi, state);
 
 	sessions.onSessionExit((sessionId) => {
 		tracker.recordSessionFinished(sessionId);
@@ -81,6 +61,9 @@ export default function codexConversion(pi: ExtensionAPI) {
 
 	pi.on("session_start", async (_event, ctx) => {
 		state.cwd = ctx.cwd;
+		state.config = readCodexConversionConfig();
+		state.promptSkills = extractPiPromptSkills(ctx.getSystemPrompt());
+		registerViewImageTool(pi, { allowOriginalDetail: supportsOriginalImageDetail(ctx.model) });
 		clearApplyPatchRenderState();
 		tracker.clear();
 		syncAdapter(pi, ctx, state);
@@ -93,6 +76,8 @@ export default function codexConversion(pi: ExtensionAPI) {
 
 	pi.on("model_select", async (_event, ctx) => {
 		state.cwd = ctx.cwd;
+		state.promptSkills = extractPiPromptSkills(ctx.getSystemPrompt());
+		registerViewImageTool(pi, { allowOriginalDetail: supportsOriginalImageDetail(ctx.model) });
 		syncAdapter(pi, ctx, state);
 	});
 
@@ -123,7 +108,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 	});
 
 	pi.on("before_agent_start", async (event, ctx) => {
-		if (!isCodexLikeContext(ctx)) {
+		if (!shouldUseCodexAdapter(ctx, state.config)) {
 			return undefined;
 		}
 		const skills = resolvePromptSkills(event.systemPromptOptions?.skills, state.promptSkills);
@@ -137,10 +122,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 
 	pi.on("before_provider_request", async (event, ctx) => {
 		state.cwd = ctx.cwd;
-		if (!isOpenAICodexContext(ctx)) {
-			return undefined;
-		}
-		return rewriteNativeImageGenerationTool(rewriteNativeWebSearchTool(event.payload, ctx.model), ctx.model);
+		return rewriteCodexProviderRequest(event.payload, ctx, state);
 	});
 
 	pi.on("context", async (event) => {
@@ -158,95 +140,4 @@ export default function codexConversion(pi: ExtensionAPI) {
 	});
 }
 
-export function getCodexSkillPaths(cwd: string, home: string = homedir()): string[] {
-	const skillPaths = [join(home, ".agents", "skills")];
-	let currentDir = resolve(cwd);
-	while (true) {
-		skillPaths.push(join(currentDir, ".agents", "skills"));
-		const parentDir = resolve(currentDir, "..");
-		if (parentDir === currentDir) {
-			break;
-		}
-		currentDir = parentDir;
-	}
-	return skillPaths.filter((path) => existsSync(path));
-}
-
-function syncAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
-	state.promptSkills = extractPiPromptSkills(ctx.getSystemPrompt());
-
-	registerViewImageTool(pi, { allowOriginalDetail: supportsOriginalImageDetail(ctx.model) });
-
-	if (isCodexLikeContext(ctx)) {
-		enableAdapter(pi, ctx, state);
-	} else {
-		disableAdapter(pi, ctx, state);
-	}
-}
-
-function enableAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
-	const toolNames = mergeAdapterTools(pi.getActiveTools(), getAdapterToolNames(ctx));
-	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.enabled = true;
-	}
-	pi.setActiveTools(toolNames);
-	setStatus(ctx, true);
-}
-
-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())) {
-		pi.setActiveTools(restoredTools);
-	}
-	if (state.enabled) {
-		state.enabled = false;
-	}
-	setStatus(ctx, false);
-}
-
-function setStatus(ctx: ExtensionContext, enabled: boolean): void {
-	if (!ctx.hasUI) return;
-	ctx.ui.setStatus(STATUS_KEY, enabled ? STATUS_TEXT : undefined);
-}
-
-function getAdapterToolNames(ctx: ExtensionContext): string[] {
-	const toolNames = [...CORE_ADAPTER_TOOL_NAMES];
-	if (supportsNativeWebSearch(ctx.model)) {
-		toolNames.push(WEB_SEARCH_TOOL_NAME);
-	}
-	if (supportsNativeImageGeneration(ctx.model)) {
-		toolNames.push(IMAGE_GENERATION_TOOL_NAME);
-	}
-	if (Array.isArray(ctx.model?.input) && ctx.model.input.includes("image")) {
-		toolNames.push(VIEW_IMAGE_TOOL_NAME);
-	}
-	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));
-	return [...adapterTools, ...preservedTools];
-}
-
-export function restoreTools(previousTools: string[], activeTools: string[]): string[] {
-	const restored = stripAdapterTools(previousTools);
-	for (const toolName of activeTools) {
-		if (!ADAPTER_TOOL_NAMES.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));
-}
-
-function hasAdapterTools(activeTools: string[]): boolean {
-	return activeTools.some((toolName) => ADAPTER_TOOL_NAMES.includes(toolName));
-}
+export { getCodexSkillPaths, mergeAdapterTools, restoreTools, stripAdapterTools };