@howaboua/pi-codex-conversion 1.0.2 → 1.0.4

package/README.md

@@ -4,7 +4,7 @@ Codex-oriented adapter for [Pi](https://github.com/badlogic/pi-mono).
 
 This package replaces Pi's default Codex/GPT experience with a narrower Codex-like surface while staying close to Pi's own runtime and prompt construction:
 
-- swaps active tools to `exec_command`, `write_stdin`, `apply_patch`, and `view_image`
+- swaps active tools to `exec_command`, `write_stdin`, `apply_patch`, `view_image`, and native OpenAI Codex Responses `web_search` on `openai-codex`
 - preserves Pi's composed system prompt and applies a narrow Codex-oriented delta on top
 - renders exec activity with Codex-style command and background-terminal labels
 
@@ -18,6 +18,7 @@ When the adapter is active, the LLM sees these tools:
 - `write_stdin` — continue or poll a running exec session
 - `apply_patch` — patch tool
 - `view_image` — image-only wrapper around Pi's native image reading, enabled only for image-capable models
+- `web_search` — native OpenAI Codex Responses web search, enabled only on the `openai-codex` provider
 
 Notably:
 
@@ -53,6 +54,7 @@ npm run check
 - `write_stdin({ session_id, chars: "" })` renders like `Waited for background terminal`
 - `write_stdin({ session_id, chars: "y\\n" })` renders like `Interacted with background terminal`
 - `view_image({ path: "/absolute/path/to/screenshot.png" })` is available on image-capable models
+- `web_search` is surfaced only on `openai-codex`, and the adapter rewrites it into the native OpenAI Responses `type: "web_search"` payload instead of executing a local function tool
 
 Raw command output is still available by expanding the tool result.
 
@@ -90,6 +92,7 @@ That keeps the prompt much closer to `pi-mono` while still steering the model to
 - Adapter mode activates automatically for OpenAI `gpt*` and `codex*` models.
 - When you switch away from those models, Pi restores the previous active tool set.
 - `view_image` resolves paths against the active session cwd and only exposes `detail: "original"` for Codex-family image-capable models.
+- `web_search` is exposed only for the `openai-codex` provider and is forwarded as the native OpenAI Codex Responses web search tool.
 - `apply_patch` paths stay restricted to the current working directory.
 - `exec_command` / `write_stdin` use a custom PTY-backed session manager via `node-pty` for interactive sessions.
 - PTY output handling applies basic terminal rewrite semantics (`\r`, `\b`, erase-in-line, and common escape cleanup) so interactive redraws replay sensibly.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {

package/src/adapter/codex-model.ts

@@ -6,6 +6,11 @@ export interface CodexLikeModelDescriptor {
 	id: string;
 }
 
+export function isOpenAICodexModel(model: Partial<CodexLikeModelDescriptor> | null | undefined): boolean {
+	if (!model) return false;
+	return (model.provider ?? "").toLowerCase() === "openai-codex";
+}
+
 // 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 {
@@ -14,9 +19,14 @@ export function isCodexLikeModel(model: Partial<CodexLikeModelDescriptor> | null
 	const provider = (model.provider ?? "").toLowerCase();
 	const api = (model.api ?? "").toLowerCase();
 	const id = (model.id ?? "").toLowerCase();
-	return provider.includes("codex") || api.includes("codex") || id.includes("codex") || (provider.includes("openai") && id.includes("gpt"));
+	const isCopilotGpt = (provider.includes("copilot") || api.includes("copilot")) && id.includes("gpt");
+	return provider.includes("codex") || api.includes("codex") || id.includes("codex") || (provider.includes("openai") && id.includes("gpt")) || isCopilotGpt;
 }
 
 export function isCodexLikeContext(ctx: ExtensionContext): boolean {
 	return isCodexLikeModel(ctx.model);
 }
+
+export function isOpenAICodexContext(ctx: ExtensionContext): boolean {
+	return isOpenAICodexModel(ctx.model);
+}

package/src/adapter/tool-set.ts

@@ -5,3 +5,4 @@ export const DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write"];
 
 export const CORE_ADAPTER_TOOL_NAMES = ["exec_command", "write_stdin", "apply_patch"];
 export const VIEW_IMAGE_TOOL_NAME = "view_image";
+export const WEB_SEARCH_TOOL_NAME = "web_search";

package/src/index.ts

@@ -1,21 +1,30 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { CORE_ADAPTER_TOOL_NAMES, DEFAULT_TOOL_NAMES, STATUS_KEY, STATUS_TEXT, VIEW_IMAGE_TOOL_NAME } from "./adapter/tool-set.ts";
+import { CORE_ADAPTER_TOOL_NAMES, DEFAULT_TOOL_NAMES, STATUS_KEY, STATUS_TEXT, VIEW_IMAGE_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from "./adapter/tool-set.ts";
 import { registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
-import { isCodexLikeContext } from "./adapter/codex-model.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";
 import { buildCodexSystemPrompt, extractPiPromptSkills, type PromptSkill } from "./prompt/build-system-prompt.ts";
 import { registerViewImageTool, supportsOriginalImageDetail } from "./tools/view-image-tool.ts";
+import {
+	WEB_SEARCH_ACTIVITY_MESSAGE_TYPE,
+	payloadContainsWebSearchTool,
+	registerWebSearchMessageRenderer,
+	registerWebSearchTool,
+	rewriteNativeWebSearchTool,
+	supportsNativeWebSearch,
+} from "./tools/web-search-tool.ts";
 import { registerWriteStdinTool } from "./tools/write-stdin-tool.ts";
 
 interface AdapterState {
 	enabled: boolean;
 	previousToolNames?: string[];
 	promptSkills: PromptSkill[];
+	pendingWebSearchCount: number;
 }
 
-const ADAPTER_TOOL_NAMES = [...CORE_ADAPTER_TOOL_NAMES, VIEW_IMAGE_TOOL_NAME];
+const ADAPTER_TOOL_NAMES = [...CORE_ADAPTER_TOOL_NAMES, VIEW_IMAGE_TOOL_NAME, WEB_SEARCH_TOOL_NAME];
 
 function getCommandArg(args: unknown): string | undefined {
 	if (!args || typeof args !== "object" || !("cmd" in args) || typeof args.cmd !== "string") {
@@ -26,12 +35,14 @@ function getCommandArg(args: unknown): string | undefined {
 
 export default function codexConversion(pi: ExtensionAPI) {
 	const tracker = createExecCommandTracker();
-	const state: AdapterState = { enabled: false, promptSkills: [] };
+	const state: AdapterState = { enabled: false, promptSkills: [], pendingWebSearchCount: 0 };
 	const sessions = createExecSessionManager();
 
 	registerApplyPatchTool(pi);
 	registerExecCommandTool(pi, tracker, sessions);
 	registerWriteStdinTool(pi, sessions);
+	registerWebSearchTool(pi);
+	registerWebSearchMessageRenderer(pi);
 
 	sessions.onSessionExit((_sessionId, command) => {
 		tracker.recordCommandFinished(command);
@@ -72,6 +83,41 @@ export default function codexConversion(pi: ExtensionAPI) {
 			}),
 		};
 	});
+
+	pi.on("context", async (event) => {
+		return {
+			messages: event.messages.filter(
+				(message) => !(message.role === "custom" && message.customType === WEB_SEARCH_ACTIVITY_MESSAGE_TYPE),
+			),
+		};
+	});
+
+	pi.on("turn_start", async () => {
+		state.pendingWebSearchCount = 0;
+	});
+
+	pi.on("before_provider_request", async (event, ctx) => {
+		if (!isOpenAICodexContext(ctx)) {
+			return undefined;
+		}
+		if (payloadContainsWebSearchTool(event.payload)) {
+			state.pendingWebSearchCount += 1;
+		}
+		return rewriteNativeWebSearchTool(event.payload, ctx.model);
+	});
+
+	pi.on("agent_end", async () => {
+		if (state.pendingWebSearchCount <= 0) {
+			return;
+		}
+		pi.sendMessage({
+			customType: WEB_SEARCH_ACTIVITY_MESSAGE_TYPE,
+			content: "",
+			display: true,
+			details: { count: state.pendingWebSearchCount },
+		});
+		state.pendingWebSearchCount = 0;
+	});
 }
 
 function syncAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
@@ -99,9 +145,12 @@ function enableAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterSt
 }
 
 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) {
-		const previousToolNames = state.previousToolNames && state.previousToolNames.length > 0 ? state.previousToolNames : DEFAULT_TOOL_NAMES;
-		pi.setActiveTools(restoreTools(previousToolNames, pi.getActiveTools()));
 		state.enabled = false;
 	}
 	setStatus(ctx, false);
@@ -113,10 +162,14 @@ function setStatus(ctx: ExtensionContext, enabled: boolean): void {
 }
 
 function getAdapterToolNames(ctx: ExtensionContext): string[] {
+	const toolNames = [...CORE_ADAPTER_TOOL_NAMES];
 	if (Array.isArray(ctx.model?.input) && ctx.model.input.includes("image")) {
-		return [...CORE_ADAPTER_TOOL_NAMES, VIEW_IMAGE_TOOL_NAME];
+		toolNames.push(VIEW_IMAGE_TOOL_NAME);
+	}
+	if (supportsNativeWebSearch(ctx.model)) {
+		toolNames.push(WEB_SEARCH_TOOL_NAME);
 	}
-	return [...CORE_ADAPTER_TOOL_NAMES];
+	return toolNames;
 }
 
 export function mergeAdapterTools(activeTools: string[], adapterTools: string[]): string[] {
@@ -133,3 +186,7 @@ export function restoreTools(previousTools: string[], activeTools: string[]): st
 	}
 	return restored;
 }
+
+function hasAdapterTools(activeTools: string[]): boolean {
+	return activeTools.some((toolName) => ADAPTER_TOOL_NAMES.includes(toolName));
+}

package/src/tools/codex-rendering.ts

@@ -32,6 +32,14 @@ export function renderWriteStdinCall(
 	return text;
 }
 
+export function renderWebSearchActivity(count: number, theme: RenderTheme, expanded = false): string {
+	let text = `${theme.fg("dim", "•")} ${theme.bold("Searched the web")}`;
+	if (expanded && count > 1) {
+		text += `\n${theme.fg("dim", "  └ ")}${theme.fg("muted", `${count} web searches in this turn`)}`;
+	}
+	return text;
+}
+
 function renderExplorationText(actions: ShellAction[], state: ExecCommandStatus, theme: RenderTheme): string {
 	const header = state === "running" ? "Exploring" : "Explored";
 	let text = `${theme.fg("dim", "•")} ${theme.bold(header)}`;

package/src/tools/web-search-tool.ts

@@ -0,0 +1,123 @@
+import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { Box, Text } from "@mariozechner/pi-tui";
+import { isOpenAICodexModel } from "../adapter/codex-model.ts";
+import { renderWebSearchActivity } from "./codex-rendering.ts";
+
+export const WEB_SEARCH_UNSUPPORTED_MESSAGE = "web_search is only available with the openai-codex provider";
+const WEB_SEARCH_LOCAL_EXECUTION_MESSAGE =
+	"web_search is a native openai-codex provider tool and should not execute locally";
+export const WEB_SEARCH_ACTIVITY_MESSAGE_TYPE = "codex-web-search";
+
+const WEB_SEARCH_PARAMETERS = Type.Object({}, { additionalProperties: false });
+
+interface FunctionToolPayload {
+	type?: unknown;
+	name?: unknown;
+}
+
+interface ResponsesPayload {
+	tools?: unknown[];
+	[key: string]: unknown;
+}
+
+export interface WebSearchActivityDetails {
+	count: number;
+}
+
+export function supportsNativeWebSearch(model: ExtensionContext["model"]): boolean {
+	return isOpenAICodexModel(model);
+}
+
+function isWebSearchFunctionTool(tool: unknown): tool is FunctionToolPayload {
+	return !!tool && typeof tool === "object" && (tool as FunctionToolPayload).type === "function" && (tool as FunctionToolPayload).name === "web_search";
+}
+
+export function rewriteNativeWebSearchTool(payload: unknown, model: ExtensionContext["model"]): unknown {
+	if (!supportsNativeWebSearch(model) || !payload || typeof payload !== "object") {
+		return payload;
+	}
+
+	const tools = (payload as ResponsesPayload).tools;
+	if (!Array.isArray(tools)) {
+		return payload;
+	}
+
+	let rewritten = false;
+	const nextTools = tools.map((tool) => {
+		if (!isWebSearchFunctionTool(tool)) {
+			return tool;
+		}
+		rewritten = true;
+		// Match Codex's native tool shape rather than exposing a synthetic function tool.
+		return {
+			type: "web_search",
+			external_web_access: true,
+		};
+	});
+
+	if (!rewritten) {
+		return payload;
+	}
+
+	return {
+		...(payload as ResponsesPayload),
+		tools: nextTools,
+	};
+}
+
+export function payloadContainsWebSearchTool(payload: unknown): boolean {
+	if (!payload || typeof payload !== "object") {
+		return false;
+	}
+	const tools = (payload as ResponsesPayload).tools;
+	if (!Array.isArray(tools)) {
+		return false;
+	}
+	return tools.some(
+		(tool) =>
+			!!tool &&
+			typeof tool === "object" &&
+			(("type" in tool && (tool as { type?: unknown }).type === "web_search") || isWebSearchFunctionTool(tool)),
+	);
+}
+
+export function createWebSearchTool(): ToolDefinition<typeof WEB_SEARCH_PARAMETERS> {
+	return {
+		name: "web_search",
+		label: "web_search",
+		description: "Search the internet for sources related to the prompt.",
+		promptSnippet: "Search the internet for sources related to the prompt.",
+		parameters: WEB_SEARCH_PARAMETERS,
+		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+			if (!supportsNativeWebSearch(ctx.model)) {
+				throw new Error(WEB_SEARCH_UNSUPPORTED_MESSAGE);
+			}
+			throw new Error(WEB_SEARCH_LOCAL_EXECUTION_MESSAGE);
+		},
+		renderCall(_args, theme) {
+			return new Text(`${theme.fg("toolTitle", theme.bold("web_search"))}`, 0, 0);
+		},
+		renderResult(result, { expanded }, theme) {
+			if (!expanded) {
+				return undefined;
+			}
+			const textBlock = result.content.find((item) => item.type === "text");
+			const text = textBlock?.type === "text" ? textBlock.text : "(no output)";
+			return new Text(theme.fg("dim", text), 0, 0);
+		},
+	};
+}
+
+export function registerWebSearchTool(pi: ExtensionAPI): void {
+	pi.registerTool(createWebSearchTool());
+}
+
+export function registerWebSearchMessageRenderer(pi: ExtensionAPI): void {
+	pi.registerMessageRenderer<WebSearchActivityDetails>(WEB_SEARCH_ACTIVITY_MESSAGE_TYPE, (message, { expanded }, theme) => {
+		const count = typeof message.details?.count === "number" ? message.details.count : 1;
+		const box = new Box(1, 1, (text) => theme.bg("toolSuccessBg", text));
+		box.addChild(new Text(renderWebSearchActivity(count, theme, expanded), 0, 0));
+		return box;
+	});
+}