@oai404iao/pi-codex-core 0.1.0-alpha.1

package/src/extension/startup-prewarm.ts

@@ -0,0 +1,264 @@
+import type { Api, Model } from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { hasCodexRequestAuth, resolveCodexRequestAccountId } from "@oai404iao/pi-codex-runtime/internal/codex-http";
+import { resolveCodexRequestProfile } from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";
+import { resolveCodexRequestIdentity } from "@oai404iao/pi-codex-runtime/internal/codex-wire-identity";
+import { applyFastModeServiceTier } from "../fast-mode.js";
+import { loadModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import { rewriteNativeOpenAiTools } from "../provider-native-tools.js";
+import { webSocketCacheKey, webSocketFallbackKey } from "../providers/openai-codex/cache-key.js";
+import { WEBSOCKET_PREWARM_TIMEOUT_MS } from "../providers/openai-codex/constants.js";
+import { applyConfiguredResponsesFeatureHeaders, buildWebSocketHeaders } from "../providers/openai-codex/headers.js";
+import { withResponsesLiteWebSocketMetadata } from "../providers/openai-codex/lite.js";
+import { prewarmWebSocket } from "../providers/openai-codex/prewarm.js";
+import { buildRequestBody, ensureWebSearchDetailsIncluded } from "../providers/openai-codex/request-body.js";
+import { isWebSocketUpgradeRejectedError } from "../providers/openai-codex/retry.js";
+import { resolveResponsesWebSocketUrl } from "../providers/openai-codex/urls.js";
+import { websocketHttpFallbackSessions, websocketSessionCache } from "../providers/openai-codex/websocket-session.js";
+import { startupPrewarmSnapshot, type StartupPrewarmSnapshot } from "./prewarm-snapshot.js";
+import type { NativeToolOwnership } from "@oai404iao/pi-codex-runtime/internal/providers/openai-codex/types";
+
+interface StartupPrewarmState {
+	status: "pending" | "ready" | "failed";
+	promise: Promise<void>;
+	abortController: AbortController;
+}
+
+interface SessionStartupPrewarmTask {
+	generation: number;
+	modelIdentity: string;
+	promise: Promise<void>;
+	abortController: AbortController;
+}
+
+function settleSpeculativeTask(task: Promise<void>, signal: AbortSignal): Promise<void> {
+	return new Promise(resolve => {
+		const finish = () => {
+			signal.removeEventListener("abort", finish);
+			resolve();
+		};
+		signal.addEventListener("abort", finish, { once: true });
+		// The auth API may not cooperate with cancellation. Release callers now
+		// but keep both handlers attached to consume a late resolution/rejection.
+		void task.then(finish, finish);
+		if (signal.aborted) finish();
+	});
+}
+
+export function createStartupPrewarmLifecycle(pi: ExtensionAPI, ownsNativeTool?: NativeToolOwnership) {
+	const startupPrewarms = new Map<string, StartupPrewarmState>();
+	const sessionStartupPrewarmTasks = new Map<string, SessionStartupPrewarmTask>();
+	let sessionGeneration = 0;
+
+	const reset = () => {
+		sessionGeneration++;
+		for (const state of startupPrewarms.values()) state.abortController.abort();
+		for (const task of sessionStartupPrewarmTasks.values()) task.abortController.abort();
+		startupPrewarms.clear();
+		sessionStartupPrewarmTasks.clear();
+	};
+
+	const modelIdentity = (model: Model<Api>): string =>
+		`${model.provider}\n${model.api}\n${model.id}\n${model.baseUrl}`;
+
+	const scheduleStartupPrewarm = (
+		ctx: ExtensionContext,
+		generation: number,
+		startupSignal: AbortSignal,
+		snapshot: StartupPrewarmSnapshot,
+	): Promise<void> => (async () => {
+		if (startupSignal.aborted) return;
+		const model = ctx.model as Model<Api> | undefined;
+		const sessionId = ctx?.sessionManager?.getSessionId?.();
+		if (!model || !sessionId || generation !== sessionGeneration) return;
+		const settings = loadModelSettings(model, ctx.cwd);
+		if (
+			!settings.enabled
+			|| !settings.modelProfile?.effective.enabled
+			|| !settings.providerShimActive
+			|| !settings.openaiWebSocketPrewarm
+			|| settings.openaiTransport === "sse"
+		) {
+			return;
+		}
+
+		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+		if (
+			startupSignal.aborted
+			|| generation !== sessionGeneration
+			|| !auth.ok
+			|| !hasCodexRequestAuth({
+				modelHeaders: model.headers,
+				auth: { apiKey: auth.apiKey, headers: auth.headers },
+			})
+		) {
+			return;
+		}
+
+		const profile = resolveCodexRequestProfile(settings.requestProfile);
+		const requestIdentity = resolveCodexRequestIdentity(
+			sessionId,
+			undefined,
+			"prewarm",
+		);
+		// Match Codex startup prewarm: snapshot only stable request context.
+		// Conversation history and the first user message are sent by the first
+		// real request as an incremental continuation from this response.
+		let body = applyFastModeServiceTier(
+			buildRequestBody(model, {
+				systemPrompt: snapshot.systemPrompt,
+				messages: [],
+				tools: snapshot.tools,
+			}, profile, {
+				ownsNativeTool,
+				apiKey: auth.apiKey,
+				headers: auth.headers,
+				sessionId,
+				reasoning: snapshot.reasoning ?? (model.reasoning ? "medium" : undefined),
+			}),
+			settings,
+			model,
+		);
+		if (settings.nativeProviderTools) {
+			const webSearch = settings.modelProfile.effective.tools.webSearch;
+			body = rewriteNativeOpenAiTools(body, {
+				ownsNativeTool,
+				imageModel: settings.imageModel,
+				imageGeneration: settings.imageGenerationImplementation ?? false,
+				webSearch: settings.webSearchEnabled && webSearch
+					? {
+							implementation: webSearch.implementation,
+							contentTypes: webSearch.contentTypes,
+						}
+					: false,
+			}).payload;
+		}
+		ensureWebSearchDetailsIncluded(body);
+		body = withResponsesLiteWebSocketMetadata(body, profile.responsesMode);
+
+		const websocketUrl = resolveResponsesWebSocketUrl(model.baseUrl, { apiKeyMode: settings.apiKeyMode });
+		const fallbackKey = webSocketFallbackKey(
+			sessionId,
+			model,
+			websocketUrl,
+			settings.modelProfileHash,
+		);
+		if (settings.openaiTransport === "auto" && fallbackKey && websocketHttpFallbackSessions.has(fallbackKey)) {
+			return;
+		}
+		if (startupSignal.aborted || generation !== sessionGeneration) return;
+		const headers = applyConfiguredResponsesFeatureHeaders(buildWebSocketHeaders(
+			model.headers,
+			auth.headers,
+			resolveCodexRequestAccountId({
+				modelHeaders: model.headers,
+				auth: { apiKey: auth.apiKey, headers: auth.headers },
+				apiKeyMode: settings.apiKeyMode,
+			}),
+			auth.apiKey ?? "",
+			sessionId,
+			requestIdentity?.threadId ?? sessionId,
+			requestIdentity,
+		), settings, model);
+		const cacheKey = webSocketCacheKey(
+			sessionId,
+			model,
+			websocketUrl,
+			headers,
+			settings.modelProfileHash,
+		);
+		if (
+			!cacheKey
+			|| startupSignal.aborted
+			|| generation !== sessionGeneration
+			|| startupPrewarms.has(cacheKey)
+		) {
+			return;
+		}
+		if (websocketSessionCache.get(cacheKey)?.continuation) return;
+
+		const abortController = new AbortController();
+		const abortFromSession = () => abortController.abort();
+		startupSignal.addEventListener("abort", abortFromSession, { once: true });
+		const state: StartupPrewarmState = {
+			status: "pending",
+			abortController,
+			promise: Promise.resolve(),
+		};
+		startupPrewarms.set(cacheKey, state);
+		const timeout = setTimeout(() => abortController.abort(), WEBSOCKET_PREWARM_TIMEOUT_MS);
+		state.promise = prewarmWebSocket({
+			url: websocketUrl,
+			headers,
+			cacheKey,
+			body,
+			requestMetadata: {
+				sessionId,
+				threadId: requestIdentity?.threadId ?? sessionId,
+				turnId: requestIdentity?.turnId ?? "",
+				requestKind: "prewarm",
+				...(requestIdentity ? { identity: requestIdentity } : {}),
+			},
+			signal: abortController.signal,
+			connectTimeoutMs: WEBSOCKET_PREWARM_TIMEOUT_MS,
+		})
+			.then(() => {
+				state.status = "ready";
+			})
+			.catch((error) => {
+				state.status = "failed";
+				if (
+					!startupSignal.aborted
+					&& generation === sessionGeneration
+					&& settings.openaiTransport === "auto"
+					&& fallbackKey
+					&& isWebSocketUpgradeRejectedError(error)
+				) {
+					websocketHttpFallbackSessions.add(fallbackKey);
+				}
+			})
+			.finally(() => {
+				clearTimeout(timeout);
+				startupSignal.removeEventListener("abort", abortFromSession);
+			});
+		await state.promise;
+	})();
+
+	const start = (ctx: ExtensionContext) => {
+		const generation = sessionGeneration;
+		// Do not block session startup. The first provider request naturally
+		// serializes behind this socket operation if it is still pending.
+		const model = ctx?.model as Model<Api> | undefined;
+		const sessionId = ctx?.sessionManager?.getSessionId?.();
+		if (model && sessionId) {
+			const abortController = new AbortController();
+			const snapshot = startupPrewarmSnapshot(pi, ctx);
+			// Prewarm is speculative. Auth/request preparation failures must not
+			// escape as unhandled promises or prevent the real request from running.
+			const promise = settleSpeculativeTask(
+				scheduleStartupPrewarm(ctx, generation, abortController.signal, snapshot),
+				abortController.signal,
+			);
+			sessionStartupPrewarmTasks.set(sessionId, {
+				generation,
+				modelIdentity: modelIdentity(model),
+				promise,
+				abortController,
+			});
+			void promise;
+		}
+	};
+
+	return {
+		reset,
+		start,
+		get(sessionId: string, requestModel: Model<Api>): Promise<void> | undefined {
+			const task = sessionStartupPrewarmTasks.get(sessionId);
+			return task
+				&& task.generation === sessionGeneration
+				&& task.modelIdentity === modelIdentity(requestModel)
+				? task.promise
+				: undefined;
+		},
+	};
+}

package/src/fast-mode.ts

@@ -0,0 +1,124 @@
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+	modelKey,
+	type ModelLike,
+} from "@oai404iao/pi-codex-runtime/internal/capabilities";
+import { loadModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import type { ResolvedCodexModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import {
+	configPath,
+	loadSettings,
+	updateConfig,
+	type CodexMinimalToolsSettings,
+} from "@oai404iao/pi-codex-runtime/internal/settings";
+
+export const FAST_MODE_STATUS_KEY = "codex-fast-mode";
+export const FAST_MODE_SERVICE_TIER = "priority" as const;
+
+export function isFastModeModel(model: ModelLike | undefined): boolean {
+	return Boolean(loadModelSettings(model).fastServiceTier);
+}
+
+export function resolveFastModeServiceTier(
+	settings: Pick<CodexMinimalToolsSettings, "enabled" | "fastMode"> & Partial<ResolvedCodexModelSettings>,
+	model: ModelLike | undefined,
+): string | undefined {
+	if (!settings.enabled || !settings.fastMode) return undefined;
+	if (settings.modelProfile) return settings.fastServiceTier;
+	return loadModelSettings(model, undefined, settings as CodexMinimalToolsSettings).fastServiceTier;
+}
+
+export function applyFastModeServiceTier<T extends Record<string, unknown>>(
+	body: T,
+	settings: Pick<CodexMinimalToolsSettings, "enabled" | "fastMode"> & Partial<ResolvedCodexModelSettings>,
+	model: ModelLike | undefined,
+): T {
+	const serviceTier = resolveFastModeServiceTier(settings, model);
+	if (!serviceTier || body.service_tier !== undefined) return body;
+	return { ...body, service_tier: serviceTier };
+}
+
+function fastModeLines(ctx: ExtensionContext): string[] {
+	const settings = loadSettings(ctx.cwd);
+	const model = ctx.model as ModelLike | undefined;
+	const modelSettings = loadModelSettings(model, ctx.cwd, settings);
+	const activeTier = resolveFastModeServiceTier(modelSettings, model);
+	return [
+		"Codex Fast mode",
+		`enabled: ${settings.fastMode}`,
+		`service tier: ${modelSettings.fastServiceTier ?? "(unsupported)"}`,
+		`model: ${modelKey(model)}`,
+		`active for current model: ${Boolean(activeTier)}`,
+		`config: ${configPath()}`,
+	];
+}
+
+export function syncFastModeStatus(ctx: ExtensionContext): void {
+	const settings = loadSettings(ctx.cwd);
+	const model = ctx.model as ModelLike | undefined;
+	const tier = resolveFastModeServiceTier(loadModelSettings(model, ctx.cwd, settings), model);
+	const ui = ctx.ui as ExtensionContext["ui"] | undefined;
+	ui?.setStatus?.(
+		FAST_MODE_STATUS_KEY,
+		tier,
+	);
+}
+
+function showFastModeStatus(ctx: ExtensionCommandContext): void {
+	syncFastModeStatus(ctx as ExtensionContext);
+	ctx.ui.notify(fastModeLines(ctx as ExtensionContext).join("\n"), "info");
+}
+
+export function registerFastMode(pi: ExtensionAPI): void {
+	pi.registerCommand("fast", {
+		description: "Toggle model-profile Fast mode. Usage: /fast [on|off|status]",
+		handler: async (args: string, ctx) => {
+			const command = args.trim().toLowerCase().split(/\s+/, 1)[0] ?? "";
+			const settings = loadSettings(ctx.cwd);
+			let patch: Partial<CodexMinimalToolsSettings> | undefined;
+
+			switch (command) {
+				case "":
+					patch = { fastMode: !settings.fastMode };
+					break;
+				case "on":
+					patch = { fastMode: true };
+					break;
+				case "off":
+					patch = { fastMode: false };
+					break;
+				case "status":
+					showFastModeStatus(ctx);
+					return;
+				default:
+					ctx.ui.notify("Usage: /fast [on|off|status]", "warning");
+					return;
+			}
+
+			try {
+				updateConfig(patch);
+				showFastModeStatus(ctx);
+			} catch (error) {
+				ctx.ui.notify(
+					`Failed to update Fast mode: ${error instanceof Error ? error.message : String(error)}`,
+					"error",
+				);
+			}
+		},
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		syncFastModeStatus(ctx);
+	});
+	pi.on("model_select", async (_event, ctx) => {
+		syncFastModeStatus(ctx);
+	});
+	pi.on("session_shutdown", async (_event, ctx) => {
+		const ui = ctx.ui as ExtensionContext["ui"] | undefined;
+		ui?.setStatus?.(FAST_MODE_STATUS_KEY, undefined);
+	});
+}

package/src/index.ts

@@ -0,0 +1,257 @@
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { getCapabilities, Image, Text, type Component } from "@earendil-works/pi-tui";
+
+import { hasConfiguredModelsLoaded } from "@oai404iao/pi-codex-runtime/internal/activation";
+
+import {
+	computeToolCapabilities,
+	modelKey,
+	type ModelLike,
+} from "@oai404iao/pi-codex-runtime/internal/capabilities";
+
+import { resolveCodexRequestProfile } from "@oai404iao/pi-codex-runtime/internal/codex-request-profile";
+
+import { registerFastMode, resolveFastModeServiceTier } from "./fast-mode.js";
+
+import { glyphs } from "@oai404iao/pi-codex-runtime/internal/glyphs";
+
+import {
+	modelCatalogDiagnostics,
+	modelsPath,
+	resolveModelProfile,
+} from "@oai404iao/pi-codex-runtime/internal/model-catalog/catalog";
+
+import { loadModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+
+import { registerNativeCompaction } from "./native-compaction.js";
+
+import { rewriteNativeOpenAiTools } from "./provider-native-tools.js";
+
+import { configPath, loadSettings, settingsDiagnostics } from "@oai404iao/pi-codex-runtime/internal/settings";
+
+import { createApplyPatchToolDefinition } from "./tools/apply-patch.js";
+
+import { viewImage, viewImageToolSchema, type ValidatedImage, type ViewImageInput } from "./tools/view-image.js";
+
+import { addPackageTool, ensureCodexServices } from "@oai404iao/pi-codex-runtime";
+
+import { registerResponsesProviderRuntime } from "./extension/provider-runtime.js";
+
+
+
+function terminalImageProtocol(): "kitty" | "iterm2" | null {
+	return getCapabilities().images ?? null;
+}
+
+function formatBytes(bytes: number): string {
+	if (!Number.isFinite(bytes) || bytes < 0) return "unknown size";
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${Math.round(bytes / 102.4) / 10}K`;
+	return `${Math.round(bytes / (1024 * 102.4)) / 10}M`;
+}
+
+function viewImageCallText(args: ViewImageInput | undefined, theme: any): string {
+	const path = typeof args?.path === "string" ? args.path : "image";
+	const detail = args?.detail && args.detail !== "auto" ? ` ${theme.fg("dim", `${glyphs().dot.trim()} ${args.detail}`)}` : "";
+	return `${theme.fg("accent", glyphs().bullet)}${theme.fg("text", theme.bold("View Image "))}${theme.fg("accent", path)}${detail}`;
+}
+
+function viewImageResultText(details: ValidatedImage | undefined, theme: any): string {
+	if (!details) return `${theme.fg("accent", glyphs().bullet)}${theme.fg("text", theme.bold("View Image"))}${theme.fg("dim", `${glyphs().dot}image loaded`)}`;
+	const type = details.mimeType.replace(/^image\//, "").toUpperCase();
+	const protocol = terminalImageProtocol();
+	const preview = protocol ? theme.fg("success", `inline ${protocol}`) : theme.fg("warning", "fallback");
+	return `${theme.fg("accent", glyphs().bullet)}${theme.fg("text", theme.bold("View Image "))}${theme.fg("accent", details.displayPath)}${theme.fg("dim", glyphs().dot)}${theme.fg("success", type)}${theme.fg("dim", `${glyphs().dot}${formatBytes(details.sizeBytes)}${glyphs().dot}`)}${preview}`;
+}
+
+function emptyComponent(): Component {
+	return { invalidate() {}, render: () => [] };
+}
+
+function textComponent(text: string): Component {
+	return new Text(text, 0, 0);
+}
+
+function viewImageResultComponent(result: any, options: any, theme: any, context: any): Component {
+	if (options?.isPartial) return emptyComponent();
+	const details = result?.details as ValidatedImage | undefined;
+	const imagePart = result?.content?.find?.((part: any) => part?.type === "image" && typeof part.data === "string" && typeof part.mimeType === "string");
+	const header = textComponent(viewImageResultText(details, theme));
+	if (!imagePart) return header;
+	const imageTheme = { fallbackColor: (text: string) => theme.fg("dim", text) };
+	const maxHeightCells = options?.expanded ? 28 : 18;
+	const image = new Image(imagePart.data, imagePart.mimeType, imageTheme, { maxWidthCells: 80, maxHeightCells, filename: details?.displayPath });
+	return {
+		invalidate() {
+			header.invalidate();
+			image.invalidate();
+		},
+		render(width: number): string[] {
+			return [...header.render(width), ...image.render(width)];
+		},
+	};
+}
+
+function contextModel(ctx: ExtensionContext): ModelLike | undefined {
+	return ctx.model as ModelLike | undefined;
+}
+
+function statusLines(pi: ExtensionAPI, ctx: ExtensionContext): string[] {
+	const settings = loadSettings(ctx.cwd);
+	const model = contextModel(ctx);
+	const modelSettings = loadModelSettings(model, ctx.cwd, settings);
+	const capabilities = computeToolCapabilities(model, settings);
+	const requestProfile = resolveCodexRequestProfile(modelSettings.requestProfile);
+	const modelProfile = modelSettings.modelProfile;
+	const active = new Set(pi.getActiveTools?.() ?? []);
+	const fastModeTier = resolveFastModeServiceTier(modelSettings, model);
+	return [
+		"Codex Minimal Tools",
+		`model: ${modelKey(model)}`,
+		`config: ${configPath()}`,
+		`models: ${modelsPath()}`,
+		`model profile: ${modelProfile ? `${modelProfile.sources.join("+")} #${modelProfile.profileHash}` : "(none)"}`,
+		`configured models loaded: ${hasConfiguredModelsLoaded(ctx, settings)}`,
+		`enabled: ${settings.enabled}`,
+		`autoEnable: ${settings.autoEnable}`,
+		`provider shim: ${modelSettings.providerShimActive ? "active" : "inactive"}`,
+		`responses endpoint: ${modelSettings.apiKeyMode ? "openai" : "codex"}`,
+		`responses transport: ${modelSettings.openaiTransport}`,
+		`Responses WebSocket prewarm: ${modelSettings.openaiWebSocketPrewarm}`,
+		`fast mode: ${settings.fastMode ? modelSettings.fastServiceTier ?? "on (unsupported)" : "off"}${fastModeTier ? ", active" : ""}`,
+		`compaction: ${modelSettings.compactionMode}`,
+		`request profile: ${requestProfile.responsesMode}/${requestProfile.patchTransport}, summary=${requestProfile.reasoningSummary}, system=${requestProfile.systemPromptPlacement}, hosted=${requestProfile.supportsHostedTools}, parallel=${requestProfile.supportsParallelTools}`,
+		`web search: ${modelSettings.webSearchImplementation ?? "off"}`,
+		`image generation: ${modelSettings.imageGenerationImplementation ?? "off"}`,
+		`legacy additionalModelIds: ${settings.additionalModelIds.length > 0 ? settings.additionalModelIds.join(", ") : "(none)"}`,
+		`apiKeyMode: ${modelSettings.apiKeyMode}`,
+		`native provider shim: ${settings.enabled ? "registered" : "disabled"}`,
+		"tools:",
+		...Object.entries(capabilities).map(([name, capability]) => `- ${name}: ${capability.enabled ? "supported" : "disabled"}${active.has(name) ? ", active" : ""} — ${capability.reason}`),
+	];
+}
+
+function registerDiagnosticCommand(pi: ExtensionAPI): void {
+	const showDoctor = (ctx: ExtensionCommandContext) => {
+		const settings = loadSettings(ctx.cwd);
+		const lines = statusLines(pi, ctx as ExtensionContext);
+		lines.push(`image output dir: ${settings.imageOutputDir}`);
+		lines.push(`OPENAI_API_KEY: ${process.env.OPENAI_API_KEY ? "present" : "not set"}`);
+		const diagnostics = settingsDiagnostics();
+		if (diagnostics.length > 0) lines.push("settings diagnostics:", ...diagnostics.map((line) => `- ${line}`));
+		const catalogDiagnostics = modelCatalogDiagnostics();
+		if (catalogDiagnostics.length > 0) lines.push("model catalog diagnostics:", ...catalogDiagnostics.map((line) => `- ${line}`));
+		const profileDiagnostics = loadModelSettings(contextModel(ctx), ctx.cwd, settings)
+			.modelProfile?.diagnostics
+			.filter((line) => !catalogDiagnostics.includes(line)) ?? [];
+		if (profileDiagnostics.length > 0) {
+			lines.push("active model profile diagnostics:", ...profileDiagnostics.map((line) => `- ${line}`));
+		}
+		ctx.ui.notify(lines.join("\n"), "info");
+	};
+	pi.registerCommand("codex-minimal-tools", {
+		description: "Show Codex Minimal Tools status. Usage: /codex-minimal-tools | /codex-minimal-tools:doctor",
+		handler: async (args: string, ctx) => {
+			const subcommand = args.trim().split(/\s+/, 1)[0]?.toLowerCase();
+			if (subcommand === "doctor") {
+				showDoctor(ctx);
+				return;
+			}
+			if (!subcommand) {
+				ctx.ui.notify(statusLines(pi, ctx as ExtensionContext).join("\n"), "info");
+				return;
+			}
+			ctx.ui.notify(statusLines(pi, ctx as ExtensionContext).join("\n"), "info");
+		},
+	});
+	pi.registerCommand("codex-minimal-tools:doctor", {
+		description: "Run lightweight self-checks",
+		handler: async (_args: string, ctx) => showDoctor(ctx),
+	});
+}
+
+function registerCoreTools(pi: ExtensionAPI): void {
+	pi.registerTool({
+		renderShell: "self",
+		name: "view_image",
+		label: "View Image",
+		description: "Inspect a local image file by returning image content to the model. Relative paths resolve against ctx.cwd; a leading @ is accepted.",
+		promptSnippet: "Inspect local image files by path.",
+		promptGuidelines: ["Use view_image when you need to inspect a local image file; pass the path in the path argument."],
+		parameters: viewImageToolSchema,
+		async execute(_toolCallId: string, params: ViewImageInput, _signal: AbortSignal | undefined, _onUpdate: unknown, ctx: ExtensionContext) {
+			const settings = loadSettings(ctx.cwd);
+			return viewImage(params, ctx.cwd, { workspaceOnly: settings.viewImageWorkspaceOnly }) as never;
+		},
+		renderCall(args: ViewImageInput, theme: any, context: any) {
+			if (context?.executionStarted && !context?.isPartial) return emptyComponent();
+			return textComponent(viewImageCallText(args, theme));
+		},
+		renderResult(result: any, options: any, theme: any, context: any) {
+			return viewImageResultComponent(result, options, theme, context);
+		},
+	} as never);
+	pi.registerTool(createApplyPatchToolDefinition({
+		deferRendering: loadSettings().deferApplyPatchRendering,
+	}) as never);
+}
+
+
+export default function codexCore(pi: ExtensionAPI): void {
+	const broker = ensureCodexServices(pi);
+	if (!broker.claim("package:core")) return;
+	const ownsNativeTool = (name: "web_search" | "image_generation") => broker.tools.has(name);
+	let currentCwd = process.cwd();
+	pi.on("session_start", (_event, ctx) => { currentCwd = ctx.cwd; });
+	pi.on("model_select", (_event, ctx) => { currentCwd = ctx.cwd; });
+	if (loadSettings(currentCwd).enabled) {
+		const controller = registerResponsesProviderRuntime(pi, { getCurrentCwd: () => currentCwd, ownsNativeTool }, {
+			// Shared services own presentation hooks even when core is absent.
+			clear() {}, flush() {}, scheduleFlush() {}, registerRenderers() {},
+			streamEffects: () => broker.presentation.streamEffects(),
+		});
+		broker.coreEnabled = true;
+		registerNativeCompaction(pi, controller);
+	}
+	let registered = false;
+	const register = () => {
+		if (registered) return;
+		registerCoreTools(pi);
+		registered = true;
+	};
+	addPackageTool(broker, "view_image", register);
+	addPackageTool(broker, "apply_patch", register);
+	registerDiagnosticCommand(pi);
+	registerFastMode(pi);
+
+
+	pi.on("before_provider_request", (event, ctx) => {
+		currentCwd = ctx.cwd;
+		const settings = loadSettings(ctx.cwd);
+		const model = contextModel(ctx);
+		const modelSettings = loadModelSettings(model, ctx.cwd, settings);
+		const profile = resolveModelProfile(model, { settings });
+		if (
+			!settings.enabled
+			|| !profile?.effective.enabled
+			|| !modelSettings.providerShimActive
+			|| !modelSettings.nativeProviderTools
+		) return undefined;
+		const capabilities = computeToolCapabilities(contextModel(ctx), settings);
+		const webSearch = profile.effective.tools.webSearch;
+		const result = rewriteNativeOpenAiTools(event.payload, {
+			ownsNativeTool,
+			imageModel: settings.imageModel,
+			imageGeneration: modelSettings.imageGenerationImplementation ?? false,
+			webSearch: capabilities.web_search.enabled
+				&& webSearch
+				? {
+						implementation: webSearch.implementation,
+						contentTypes: webSearch.contentTypes,
+					}
+				: false,
+		});
+		return result.rewritten.length > 0 ? result.payload : undefined;
+	});
+}