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

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-dev.25.f80a775",
+  "version": "1.5.5-dev.27.aa95f55",
   "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,19 @@ 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 } : {}),
 	};
@@ -98,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] : []),
 	];
@@ -109,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/config.ts

@@ -10,6 +10,7 @@ export const COMPACTION_MODELS: readonly CompactionModel[] = ["gpt-5.5", "gpt-5.
 export const COMPACTION_REASONING_LEVELS: readonly CompactionReasoning[] = ["current", "minimal", "low", "medium", "high", "xhigh"];
 
 export interface CodexConversionConfig {
+	applyPatchOnly: boolean;
 	fast: boolean;
 	imageGeneration: boolean;
 	compactionModel: CompactionModel;
@@ -23,6 +24,7 @@ export interface CodexConversionConfig {
 
 export const CODEX_CONVERSION_CONFIG_BASENAME = "pi-codex-conversion.json";
 export const DEFAULT_CODEX_CONVERSION_CONFIG: CodexConversionConfig = {
+	applyPatchOnly: false,
 	fast: false,
 	imageGeneration: true,
 	compactionModel: "gpt-5.5",
@@ -68,6 +70,7 @@ export function readCodexConversionConfig(configPath: string = getCodexConversio
 		const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as unknown;
 		if (!isObject(parsed)) return { ...DEFAULT_CODEX_CONVERSION_CONFIG };
 		return {
+			applyPatchOnly: typeof parsed.applyPatchOnly === "boolean" ? parsed.applyPatchOnly : DEFAULT_CODEX_CONVERSION_CONFIG.applyPatchOnly,
 			fast: typeof parsed.fast === "boolean" ? parsed.fast : DEFAULT_CODEX_CONVERSION_CONFIG.fast,
 			imageGeneration: typeof parsed.imageGeneration === "boolean" ? parsed.imageGeneration : DEFAULT_CODEX_CONVERSION_CONFIG.imageGeneration,
 			compactionModel: normalizeCompactionModel(parsed.compactionModel) ?? DEFAULT_CODEX_CONVERSION_CONFIG.compactionModel,

package/src/adapter/skills.ts

@@ -15,3 +15,11 @@ export function getCodexSkillPaths(cwd: string, home: string = homedir()): strin
 	}
 	return skillPaths.filter((path) => existsSync(path));
 }
+
+export function hasNoSkillsFlag(argv: readonly string[] = process.argv): boolean {
+	for (const arg of argv) {
+		if (arg === "--") return false;
+		if (arg === "--no-skills" || arg === "-ns") return true;
+	}
+	return false;
+}

package/src/adapter/tool-set.ts

@@ -1,5 +1,6 @@
 export const STATUS_KEY = "codex-adapter";
 export const STATUS_TEXT = "\u001b[38;2;0;76;255mCodex adapter\u001b[0m";
+export const APPLY_PATCH_ONLY_STATUS_TEXT = `${STATUS_TEXT} • apply patch only`;
 
 export function buildStatusText(options: { verbosity?: string; webSearch: boolean; imageGeneration: boolean; fast: boolean; useOnAllModels: boolean; compaction?: { enabled: boolean; model: string; reasoning: string } }): string {
 	const extras = [
@@ -17,7 +18,9 @@ export function buildStatusText(options: { verbosity?: string; webSearch: boolea
 
 export const DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write"];
 
-export const CORE_ADAPTER_TOOL_NAMES = ["exec_command", "write_stdin", "apply_patch"];
+export const SHELL_ADAPTER_TOOL_NAMES = ["exec_command", "write_stdin"];
+export const APPLY_PATCH_TOOL_NAME = "apply_patch";
+export const CORE_ADAPTER_TOOL_NAMES = [...SHELL_ADAPTER_TOOL_NAMES, APPLY_PATCH_TOOL_NAME];
 export const IMAGE_GENERATION_TOOL_NAME = "image_generation";
 export const VIEW_IMAGE_TOOL_NAME = "view_image";
-export const WEB_SEARCH_TOOL_NAME = "web_search";
+export const WEB_SEARCH_TOOL_NAME = "web.run";

package/src/codex-settings/ui.ts

@@ -17,9 +17,9 @@ export interface CodexSettingsScreenOptions {
 	initialTab?: SettingsTab;
 }
 
-type SettingsTab = "general" | "compaction";
+type SettingsTab = "general" | "compaction" | "overrides";
 
-const TAB_ORDER: readonly SettingsTab[] = ["general", "compaction"];
+const TAB_ORDER: readonly SettingsTab[] = ["general", "compaction", "overrides"];
 
 export async function openCodexSettingsScreen(ctx: ExtensionContext, options: CodexSettingsScreenOptions): Promise<void> {
 	let draft = { ...options.initialConfig };
@@ -46,6 +46,7 @@ export async function openCodexSettingsScreen(ctx: ExtensionContext, options: Co
 					formatTabs(activeTab, theme),
 					rule(width, theme, "borderMuted"),
 					...(activeTab === "compaction" ? formatCompactionNotes(theme) : []),
+					...(activeTab === "overrides" ? formatOverridesNotes(theme) : []),
 					"",
 					...settingsList.render(width),
 					rule(width, theme, "borderMuted"),
@@ -74,6 +75,12 @@ function formatCompactionNotes(theme: Theme): string[] {
 	];
 }
 
+function formatOverridesNotes(theme: Theme): string[] {
+	return [
+		theme.fg("dim", "  Advanced tool-surface overrides."),
+	];
+}
+
 function rule(width: number, theme: Theme, color: "accent" | "borderMuted"): string {
 	return theme.fg(color, "─".repeat(Math.max(0, width)));
 }
@@ -110,6 +117,12 @@ function buildItems(tab: SettingsTab, draft: CodexConversionConfig): SettingItem
 		];
 	}
 
+	if (tab === "overrides") {
+		return [
+			{ id: "applyPatchOnly", label: "Apply patch only", currentValue: draft.applyPatchOnly ? "on" : "off", values: ["off", "on"] },
+		];
+	}
+
 	return [
 		{ id: "useOnAllModels", label: "Use on all models", currentValue: draft.useOnAllModels ? "on" : "off", values: ["off", "on"] },
 		{ id: "statusLine", label: "Statusline", currentValue: draft.statusLine ? "on" : "off", values: ["off", "on"] },
@@ -122,6 +135,7 @@ function buildItems(tab: SettingsTab, draft: CodexConversionConfig): SettingItem
 
 function applySettingChange(id: string, value: string, draft: CodexConversionConfig): CodexConversionConfig {
 	const nextDraft = { ...draft };
+	if (id === "applyPatchOnly") nextDraft.applyPatchOnly = value === "on";
 	if (id === "useOnAllModels") nextDraft.useOnAllModels = value === "on";
 	if (id === "statusLine") nextDraft.statusLine = value === "on";
 	if (id === "fast") nextDraft.fast = value === "on";
@@ -136,7 +150,7 @@ function applySettingChange(id: string, value: string, draft: CodexConversionCon
 
 function formatTabs(activeTab: SettingsTab, theme: Theme): string {
 	const renderTab = (tab: SettingsTab, label: string) => activeTab === tab ? theme.bold(label) : theme.fg("dim", label);
-	return `  ${renderTab("general", "General")}  ${theme.fg("dim", "/")}  ${renderTab("compaction", "Compaction")}`;
+	return `  ${renderTab("general", "General")}  ${theme.fg("dim", "/")}  ${renderTab("compaction", "Compaction")}  ${theme.fg("dim", "/")}  ${renderTab("overrides", "Overrides")}`;
 }
 
 function formatLinks(theme: Theme): string[] {

package/src/index.ts

@@ -18,9 +18,10 @@ import { rewriteCodexProviderRequest } from "./adapter/provider-request.ts";
 import { handleCodexSessionBeforeCompact } from "./adapter/compaction.ts";
 import { isNativeCompactionDetails, NATIVE_COMPACTION_DISPLAY_MESSAGE_TYPE, NATIVE_COMPACTION_DISPLAY_TEXT } from "./adapter/types.ts";
 import { isAdapterContextExcludedCustomMessage } from "./adapter/context-filter.ts";
-import { getCodexSkillPaths } from "./adapter/skills.ts";
+import { getCodexSkillPaths, hasNoSkillsFlag } from "./adapter/skills.ts";
 import type { AdapterState } from "./adapter/state.ts";
 import { registerCodexCommand } from "./codex-settings/command.ts";
+import { WEB_SEARCH_TOOL_NAME } from "./adapter/tool-set.ts";
 
 function getCommandArg(args: unknown): string | undefined {
 	if (!args || typeof args !== "object" || !("cmd" in args) || typeof args.cmd !== "string") {
@@ -44,13 +45,16 @@ export default function codexConversion(pi: ExtensionAPI) {
 	const tracker = createExecCommandTracker();
 	const state: AdapterState = { enabled: false, cwd: process.cwd(), promptSkills: [], config: readCodexConversionConfig() };
 	const sessions = createExecSessionManager();
-	let nativeWebSearchRegistered = false;
+	const registeredNativeWebSearchTools = new Set<string>();
 	let nativeImageGenerationRegistered = false;
 
 	function ensureOptionalNativeToolsRegistered(config = state.config): void {
-		if (config.webSearch && !nativeWebSearchRegistered) {
-			registerWebSearchTool(pi);
-			nativeWebSearchRegistered = true;
+		if (config.webSearch) {
+			const webSearchToolName = WEB_SEARCH_TOOL_NAME;
+			if (!registeredNativeWebSearchTools.has(webSearchToolName)) {
+				registerWebSearchTool(pi, webSearchToolName);
+				registeredNativeWebSearchTools.add(webSearchToolName);
+			}
 		}
 		if (config.imageGeneration && !nativeImageGenerationRegistered) {
 			registerImageGenerationTool(pi);
@@ -93,6 +97,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 	});
 
 	pi.on("resources_discover", async (event) => {
+		if (hasNoSkillsFlag()) return undefined;
 		const skillPaths = getCodexSkillPaths(event.cwd);
 		return skillPaths.length > 0 ? { skillPaths } : undefined;
 	});
@@ -134,7 +139,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 		if (!shouldUseCodexAdapter(ctx, state.config)) {
 			return undefined;
 		}
-		const skills = resolvePromptSkills(event.systemPromptOptions?.skills, state.promptSkills);
+		const skills = hasNoSkillsFlag() ? [] : resolvePromptSkills(event.systemPromptOptions?.skills, state.promptSkills);
 		return {
 			systemPrompt: buildCodexSystemPrompt(event.systemPrompt, {
 				skills,

package/src/providers/openai-codex-custom-provider.ts

@@ -20,6 +20,7 @@ import {
 	CODEX_TOOL_CALL_PROVIDERS,
 	processResponsesStream,
 } from "./openai-responses-shared.ts";
+import { WEB_SEARCH_TOOL_NAME } from "../adapter/tool-set.ts";
 
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const JWT_CLAIM_PATH = "https://api.openai.com/auth";
@@ -109,6 +110,19 @@ interface SessionWebSocketCacheEntry {
 	continuation?: CachedWebSocketContinuationState;
 }
 
+export interface OpenAICodexWebSocketDebugStats {
+	requests: number;
+	connectionsCreated: number;
+	connectionsReused: number;
+	cachedContextRequests: number;
+	storeTrueRequests: number;
+	fullContextRequests: number;
+	deltaRequests: number;
+	lastInputItems: number;
+	lastDeltaInputItems?: number;
+	lastPreviousResponseId?: string;
+}
+
 interface AcquiredWebSocket {
 	socket: WebSocketLike;
 	entry?: SessionWebSocketCacheEntry;
@@ -166,6 +180,38 @@ interface ResponseEnvelope {
 type ServiceTier = ResponseCreateParamsStreaming["service_tier"];
 
 const websocketSessionCache = new Map<string, SessionWebSocketCacheEntry>();
+const websocketDebugStats = new Map<string, OpenAICodexWebSocketDebugStats>();
+
+function getOrCreateWebSocketDebugStats(sessionId: string): OpenAICodexWebSocketDebugStats {
+	let stats = websocketDebugStats.get(sessionId);
+	if (!stats) {
+		stats = {
+			requests: 0,
+			connectionsCreated: 0,
+			connectionsReused: 0,
+			cachedContextRequests: 0,
+			storeTrueRequests: 0,
+			fullContextRequests: 0,
+			deltaRequests: 0,
+			lastInputItems: 0,
+		};
+		websocketDebugStats.set(sessionId, stats);
+	}
+	return stats;
+}
+
+export function getOpenAICodexWebSocketDebugStats(sessionId: string): OpenAICodexWebSocketDebugStats | undefined {
+	const stats = websocketDebugStats.get(sessionId);
+	return stats ? { ...stats } : undefined;
+}
+
+export function resetOpenAICodexWebSocketDebugStats(sessionId?: string): void {
+	if (sessionId) {
+		websocketDebugStats.delete(sessionId);
+		return;
+	}
+	websocketDebugStats.clear();
+}
 
 class NonRetryableProviderError extends Error {}
 
@@ -550,7 +596,7 @@ export function buildRequestBody<TApi extends Api>(model: Model<TApi>, context:
 
 	if (context.tools && context.tools.length > 0) {
 		body.tools = convertResponsesTools(context.tools, { strict: null });
-		const hasWebSearchTool = context.tools.some((tool) => tool.name === "web_search");
+		const hasWebSearchTool = context.tools.some((tool) => tool.name === WEB_SEARCH_TOOL_NAME);
 		if (hasWebSearchTool) {
 			body.include.push("web_search_call.action.sources", "web_search_call.results");
 		}
@@ -680,6 +726,7 @@ export function closeOpenAICodexWebSocketSessions(sessionId?: string): void {
 		const entry = websocketSessionCache.get(sessionId);
 		if (entry) closeEntry(entry);
 		websocketSessionCache.delete(sessionId);
+		websocketDebugStats.delete(sessionId);
 		return;
 	}
 
@@ -687,6 +734,7 @@ export function closeOpenAICodexWebSocketSessions(sessionId?: string): void {
 		closeEntry(entry);
 	}
 	websocketSessionCache.clear();
+	websocketDebugStats.clear();
 }
 
 
@@ -1230,7 +1278,7 @@ async function processWebSocketStream<TApi extends Api>(
 	let streamStarted = false;
 
 	for (let attempt = 0; attempt < 2; attempt++) {
-		const { socket, entry, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
+		const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
 		let keepConnection = true;
 		let released = false;
 		let eventCount = 0;
@@ -1240,6 +1288,24 @@ async function processWebSocketStream<TApi extends Api>(
 		// WebSocket continuation still works via connection-scoped previous_response_id state.
 		const fullBody = body;
 		const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
+		const stats = options?.sessionId ? getOrCreateWebSocketDebugStats(options.sessionId) : undefined;
+		if (stats) {
+			stats.requests++;
+			if (reused) stats.connectionsReused++;
+			else stats.connectionsCreated++;
+			if (useCachedContext) stats.cachedContextRequests++;
+			if (requestBody.store === true) stats.storeTrueRequests++;
+			stats.lastInputItems = requestBody.input?.length ?? 0;
+			if (requestBody.previous_response_id) {
+				stats.deltaRequests++;
+				stats.lastDeltaInputItems = requestBody.input?.length ?? 0;
+				stats.lastPreviousResponseId = requestBody.previous_response_id;
+			} else {
+				stats.fullContextRequests++;
+				stats.lastDeltaInputItems = undefined;
+				stats.lastPreviousResponseId = undefined;
+			}
+		}
 
 		const releaseOnce = (releaseOptions?: { keep?: boolean }) => {
 			if (released) return;

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

@@ -2,10 +2,11 @@ import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-w
 import { Type } from "typebox";
 import { Container, Text } from "@earendil-works/pi-tui";
 import { isOpenAICodexModel } from "../adapter/codex-model.ts";
+import { WEB_SEARCH_TOOL_NAME } from "../adapter/tool-set.ts";
 
-export const WEB_SEARCH_UNSUPPORTED_MESSAGE = "web_search is only available with the openai-codex provider";
+export const WEB_SEARCH_UNSUPPORTED_MESSAGE = "web.run 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";
+	"web.run is a native openai-codex provider tool and should not execute locally";
 export const WEB_SEARCH_SESSION_NOTE_TYPE = "codex-web-search-session-note";
 const WEB_SEARCH_MULTIMODAL_CONTENT_TYPES = ["text", "image"] as const;
 
@@ -20,6 +21,7 @@ interface FunctionToolPayload {
 }
 
 interface ResponsesPayload {
+	include?: unknown;
 	tools?: unknown[];
 	[key: string]: unknown;
 }
@@ -43,7 +45,7 @@ export function supportsMultimodalNativeWebSearch(model: ExtensionContext["model
 }
 
 function isWebSearchFunctionTool(tool: unknown): tool is FunctionToolPayload {
-	return !!tool && typeof tool === "object" && (tool as FunctionToolPayload).type === "function" && (tool as FunctionToolPayload).name === "web_search";
+	return !!tool && typeof tool === "object" && (tool as FunctionToolPayload).type === "function" && (tool as FunctionToolPayload).name === WEB_SEARCH_TOOL_NAME;
 }
 
 function createEmptyResultComponent(): Container {
@@ -80,17 +82,28 @@ export function rewriteNativeWebSearchTool(payload: unknown, model: ExtensionCon
 	if (!rewritten) {
 		return payload;
 	}
+	const existingInclude: unknown[] = Array.isArray((payload as ResponsesPayload).include)
+		? [...((payload as ResponsesPayload).include as unknown[])]
+		: [];
+	const include = [
+		...existingInclude,
+		...[
+			"web_search_call.action.sources",
+			"web_search_call.results",
+		].filter((item) => !existingInclude.includes(item)),
+	];
 
 	return {
 		...(payload as ResponsesPayload),
+		include,
 		tools: nextTools,
 	};
 }
 
-export function createWebSearchTool(): ToolDefinition<typeof WEB_SEARCH_PARAMETERS> {
+export function createWebSearchTool(name: string = WEB_SEARCH_TOOL_NAME): ToolDefinition<typeof WEB_SEARCH_PARAMETERS> {
 	return {
-		name: "web_search",
-		label: "web_search",
+		name,
+		label: name,
 		description:
 			"Search the web for sources relevant to the current task. Use it when you need up-to-date information, external references, or broader context beyond the workspace.",
 		promptSnippet:
@@ -104,7 +117,7 @@ export function createWebSearchTool(): ToolDefinition<typeof WEB_SEARCH_PARAMETE
 			throw new Error(WEB_SEARCH_LOCAL_EXECUTION_MESSAGE);
 		},
 		renderCall(_args, theme) {
-			return new Text(`${theme.fg("toolTitle", theme.bold("web_search"))}`, 0, 0);
+			return new Text(`${theme.fg("toolTitle", theme.bold(name))}`, 0, 0);
 		},
 		renderResult(result, { expanded }, theme) {
 			if (!expanded) {
@@ -117,6 +130,6 @@ export function createWebSearchTool(): ToolDefinition<typeof WEB_SEARCH_PARAMETE
 	};
 }
 
-export function registerWebSearchTool(pi: ExtensionAPI): void {
-	pi.registerTool(createWebSearchTool());
+export function registerWebSearchTool(pi: ExtensionAPI, name: string = WEB_SEARCH_TOOL_NAME): void {
+	pi.registerTool(createWebSearchTool(name));
 }