@howaboua/pi-codex-conversion 1.0.3 → 1.0.5

package/README.md

@@ -4,12 +4,15 @@ 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
 
 ![Available tools](./available-tools.png)
 
+> [!NOTE]
+> Native OpenAI Codex Responses web search runs silently. Pi does not expose native web-search usage events to extensions, so the adapter shows a one-time session notice instead of per-search tool-call history.
+
 ## Active tools in adapter mode
 
 When the adapter is active, the LLM sees these tools:
@@ -18,6 +21,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 +57,8 @@ 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
+- when native web search is available, the adapter shows a one-time session notice; individual searches are not surfaced because Pi does not expose native web-search execution events to extensions
 
 Raw command output is still available by expanding the tool result.
 
@@ -90,6 +96,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.3",
+  "version": "1.0.5",
   "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 {
@@ -21,3 +26,7 @@ export function isCodexLikeModel(model: Partial<CodexLikeModelDescriptor> | null
 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,31 @@
 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 {
+	registerWebSearchTool,
+	registerWebSearchSessionNoteRenderer,
+	rewriteNativeWebSearchTool,
+	shouldShowWebSearchSessionNote,
+	supportsNativeWebSearch,
+	WEB_SEARCH_SESSION_NOTE_TEXT,
+	WEB_SEARCH_SESSION_NOTE_TYPE,
+} from "./tools/web-search-tool.ts";
 import { registerWriteStdinTool } from "./tools/write-stdin-tool.ts";
 
 interface AdapterState {
 	enabled: boolean;
 	previousToolNames?: string[];
 	promptSkills: PromptSkill[];
+	webSearchNoticeShown: boolean;
 }
 
-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,18 +36,21 @@ 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: [], webSearchNoticeShown: false };
 	const sessions = createExecSessionManager();
 
 	registerApplyPatchTool(pi);
 	registerExecCommandTool(pi, tracker, sessions);
 	registerWriteStdinTool(pi, sessions);
+	registerWebSearchTool(pi);
+	registerWebSearchSessionNoteRenderer(pi);
 
 	sessions.onSessionExit((_sessionId, command) => {
 		tracker.recordCommandFinished(command);
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
+		state.webSearchNoticeShown = false;
 		syncAdapter(pi, ctx, state);
 	});
 
@@ -72,12 +85,28 @@ export default function codexConversion(pi: ExtensionAPI) {
 			}),
 		};
 	});
+
+	pi.on("before_provider_request", async (event, ctx) => {
+		if (!isOpenAICodexContext(ctx)) {
+			return undefined;
+		}
+		return rewriteNativeWebSearchTool(event.payload, ctx.model);
+	});
+
+	pi.on("context", async (event) => {
+		return {
+			messages: event.messages.filter(
+				(message) => !(message.role === "custom" && message.customType === WEB_SEARCH_SESSION_NOTE_TYPE),
+			),
+		};
+	});
 }
 
 function syncAdapter(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
 	state.promptSkills = extractPiPromptSkills(ctx.getSystemPrompt());
 
 	registerViewImageTool(pi, { allowOriginalDetail: supportsOriginalImageDetail(ctx.model) });
+	maybeShowWebSearchSessionNote(pi, ctx, state);
 
 	if (isCodexLikeContext(ctx)) {
 		enableAdapter(pi, ctx, state);
@@ -116,10 +145,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[] {
@@ -140,3 +173,15 @@ export function restoreTools(previousTools: string[], activeTools: string[]): st
 function hasAdapterTools(activeTools: string[]): boolean {
 	return activeTools.some((toolName) => ADAPTER_TOOL_NAMES.includes(toolName));
 }
+
+function maybeShowWebSearchSessionNote(pi: ExtensionAPI, ctx: ExtensionContext, state: AdapterState): void {
+	if (!shouldShowWebSearchSessionNote(ctx.model, ctx.hasUI, state.webSearchNoticeShown)) {
+		return;
+	}
+	pi.sendMessage({
+		customType: WEB_SEARCH_SESSION_NOTE_TYPE,
+		content: WEB_SEARCH_SESSION_NOTE_TEXT,
+		display: true,
+	});
+	state.webSearchNoticeShown = true;
+}

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

@@ -0,0 +1,112 @@
+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";
+
+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_SESSION_NOTE_TYPE = "codex-web-search-session-note";
+export const WEB_SEARCH_SESSION_NOTE_TEXT =
+	"Native OpenAI Codex web search is enabled for this session. Search runs silently and is not surfaced as a separate tool call.";
+
+const WEB_SEARCH_PARAMETERS = Type.Object({}, { additionalProperties: false });
+
+interface FunctionToolPayload {
+	type?: unknown;
+	name?: unknown;
+}
+
+interface ResponsesPayload {
+	tools?: unknown[];
+	[key: string]: unknown;
+}
+
+export function supportsNativeWebSearch(model: ExtensionContext["model"]): boolean {
+	return isOpenAICodexModel(model);
+}
+
+export function shouldShowWebSearchSessionNote(
+	model: ExtensionContext["model"],
+	hasUI: boolean,
+	alreadyShown: boolean,
+): boolean {
+	return hasUI && !alreadyShown && supportsNativeWebSearch(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 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 registerWebSearchSessionNoteRenderer(pi: ExtensionAPI): void {
+	pi.registerMessageRenderer(WEB_SEARCH_SESSION_NOTE_TYPE, (_message, _options, theme) => {
+		const box = new Box(1, 1, (text) => theme.bg("toolSuccessBg", text));
+		box.addChild(new Text(theme.bold("Web search enabled"), 0, 0));
+		box.addChild(new Text(`\n${theme.fg("dim", WEB_SEARCH_SESSION_NOTE_TEXT)}`, 0, 0));
+		return box;
+	});
+}