@oh-my-pi/pi-coding-agent 15.12.3 → 15.13.0

package/src/extensibility/custom-commands/loader.ts

@@ -7,7 +7,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, getProjectDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import * as zod from "zod/v4";
+import { z as zod } from "zod/v4";
 import { getConfigDirs } from "../../config";
 import { execCommand } from "../../exec/exec";
 // Runtime self-reference: dereference this namespace only inside loader functions to keep the index.ts cycle safe.

package/src/extensibility/custom-commands/types.ts

@@ -5,7 +5,7 @@
  * Unlike markdown commands which expand to prompts, custom commands can execute
  * arbitrary logic with full access to the hook context.
  */
-import type * as Zod from "zod/v4";
+import type { z } from "zod/v4";
 import type { ExecOptions, ExecResult, HookCommandContext } from "../../extensibility/hooks/types";
 import type * as PiCodingAgent from "../../index";
 import type * as TypeBox from "../typebox";
@@ -25,7 +25,7 @@ export interface CustomCommandAPI {
 	/** Injected zod-backed typebox shim (legacy/compat). */
 	typebox: typeof TypeBox;
 	/** Injected zod module for Zod-authored custom commands. */
-	zod: typeof Zod;
+	zod: typeof z;
 	/** Injected pi-coding-agent exports */
 	pi: typeof PiCodingAgent;
 }

package/src/extensibility/custom-tools/loader.ts

@@ -7,7 +7,7 @@
 import * as path from "node:path";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { toolCapability } from "../../capability/tool";
 import { type CustomTool, loadCapability } from "../../discovery";
 import type { ExecOptions } from "../../exec/exec";

package/src/extensibility/custom-tools/types.ts

@@ -15,7 +15,7 @@ import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { FetchImpl, Model, Static, TSchema } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type * as Zod from "zod/v4";
+import type { z } from "zod/v4";
 import type { Rule } from "../../capability/rule";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { Settings } from "../../config/settings";
@@ -64,7 +64,7 @@ export interface CustomToolAPI {
 	/** Injected zod-backed typebox shim (legacy/compat — Zod-authored tools are preferred). */
 	typebox: typeof TypeBox;
 	/** Injected zod module for Zod-authored custom tools. */
-	zod: typeof Zod;
+	zod: typeof z;
 	/** Injected pi-coding-agent exports */
 	pi: typeof PiCodingAgent;
 	/** Push a preview action that can later be resolved with the hidden resolve tool */

package/src/extensibility/extensions/loader.ts

@@ -8,7 +8,7 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Model, TextContent, TSchema } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import * as Zod from "zod/v4";
+import { z } from "zod/v4";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
 import { loadCapability } from "../../discovery";
 import { getExtensionNameFromPath } from "../../discovery/helpers";
@@ -122,7 +122,7 @@ export class ExtensionRuntime implements IExtensionRuntime {
 class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	readonly logger = logger;
 	readonly typebox = TypeBox;
-	readonly zod = Zod;
+	readonly zod = z;
 	readonly flagValues = new Map<string, boolean | string>();
 	readonly pendingProviderRegistrations: Array<{
 		name: string;

package/src/extensibility/extensions/model-api.ts

@@ -0,0 +1,41 @@
+/**
+ * Model query facade exposed to extensions as `ctx.models`.
+ *
+ * Read-only: lets an extension select a model the same way core does — list
+ * authenticated models, read the session model, resolve a model string or role
+ * alias, and compare model families — without touching the mutable registry or
+ * duplicating resolution/family heuristics.
+ */
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { modelFamilyToken } from "@oh-my-pi/pi-catalog/identity";
+import type { ModelRegistry } from "../../config/model-registry";
+import { getModelMatchPreferences, resolveModelRoleValue } from "../../config/model-resolver";
+import type { Settings } from "../../config/settings";
+import type { ExtensionModelQuery } from "./types";
+
+/**
+ * Build the `ctx.models` facade. `getModel` is read lazily so `current()` always
+ * reflects the live session model (it can change mid-session via `/model`).
+ */
+export function createExtensionModelQuery(
+	modelRegistry: ModelRegistry,
+	settings: Settings | undefined,
+	getModel: () => Model | undefined,
+): ExtensionModelQuery {
+	return {
+		list: () => modelRegistry.getAvailable(),
+		current: () => getModel(),
+		// resolveModelRoleValue expands a role alias (`pi/slow`) to its full configured
+		// priority list and tries each pattern — the same path core selection uses — so a
+		// fallback model lower in the list still resolves. Plain model strings pass through
+		// as a single pattern.
+		resolve: (spec: string): Model<Api> | undefined =>
+			resolveModelRoleValue(spec, modelRegistry.getAvailable(), {
+				settings,
+				matchPreferences: getModelMatchPreferences(settings),
+				modelRegistry,
+			}).model,
+		family: (model: Model<Api>): string =>
+			modelFamilyToken(modelRegistry.getCanonicalId(model) ?? model.id) || model.provider.toLowerCase(),
+	};
+}

package/src/extensibility/extensions/runner.ts

@@ -6,9 +6,11 @@ import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMeta
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
 import type { MemoryRuntimeContext } from "../../memory-backend";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { SessionManager } from "../../session/session-manager";
+import { createExtensionModelQuery } from "./model-api";
 import type {
 	AfterProviderResponseEvent,
 	AssistantThinkingRenderer,
@@ -207,6 +209,7 @@ export class ExtensionRunner {
 		private readonly sessionManager: SessionManager,
 		private readonly modelRegistry: ModelRegistry,
 		getMemory?: () => MemoryRuntimeContext | undefined,
+		private readonly settings?: Settings,
 	) {
 		this.#uiContext = noOpUIContext;
 		this.#getMemoryFn = getMemory;
@@ -479,6 +482,7 @@ export class ExtensionRunner {
 			get model() {
 				return getModel();
 			},
+			models: createExtensionModelQuery(this.modelRegistry, this.settings, getModel),
 			isIdle: () => this.#isIdleFn(),
 			abort: () => this.#abortFn(),
 			hasPendingMessages: () => this.#hasPendingMessagesFn(),

package/src/extensibility/extensions/types.ts

@@ -32,7 +32,7 @@ import type {
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type * as Zod from "zod/v4";
+import type { z } from "zod/v4";
 import type { KeybindingsManager } from "../../config/keybindings";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { EditToolDetails } from "../../edit";
@@ -56,6 +56,7 @@ import type {
 	SearchToolInput,
 	WriteToolInput,
 } from "../../tools";
+import type { ApprovalMode } from "../../tools/approval";
 import type { EventBus } from "../../utils/event-bus";
 import type {
 	AgentEndEvent,
@@ -293,6 +294,32 @@ export interface CompactOptions {
 // surface (model registry, system prompt, shutdown, full session manager
 // access). Field overlap is incidental; merging into a base would require
 // hooks to widen their public contract.
+/**
+ * Read-only model query facade exposed at `ctx.models`. Lets an extension select a
+ * model the same way core does — list authenticated models, read the session model,
+ * resolve a model string or role alias, and compare model families — without reaching
+ * into the mutable registry or re-implementing matching/family heuristics.
+ */
+export interface ExtensionModelQuery {
+	/** Authenticated models available this session (the same set `--model` selection sees). */
+	list(): Model[];
+	/** The current session model, if one is set. */
+	current(): Model | undefined;
+	/**
+	 * Resolve a model string (`provider/id`, bare id) or role alias (`pi/slow`, a
+	 * configured role) to a Model, using the same settings-backed aliases and match
+	 * preferences as core selection. Thinking/routing suffixes are accepted and resolved
+	 * to the base model (pass effort separately). Returns undefined when nothing matches.
+	 */
+	resolve(spec: string): Model | undefined;
+	/**
+	 * Opaque lineage token for "are these the same family?" comparisons — every Claude
+	 * point release shares a token, Claude and GPT differ. Backed by catalog canonical
+	 * identity. Compare it; do not persist it (the vocabulary tracks new releases).
+	 */
+	family(model: Model): string;
+}
+
 export interface ExtensionContext {
 	/** UI methods for user interaction */
 	ui: ExtensionUIContext;
@@ -310,6 +337,8 @@ export interface ExtensionContext {
 	modelRegistry: ModelRegistry;
 	/** Current model (may be undefined) */
 	model: Model | undefined;
+	/** Read-only model query facade: list / current / resolve / family. */
+	models: ExtensionModelQuery;
 	/** Whether the agent is idle (not streaming) */
 	isIdle(): boolean;
 	/** Abort the current agent operation */
@@ -608,6 +637,24 @@ export interface InputEvent {
 // Tool Events
 // ============================================================================
 
+export interface ToolApprovalRequestedEvent {
+	type: "tool_approval_requested";
+	sessionId: string;
+	toolCallId: string;
+	toolName: string;
+	reason?: string;
+	approvalMode: ApprovalMode;
+}
+
+export interface ToolApprovalResolvedEvent {
+	type: "tool_approval_resolved";
+	sessionId: string;
+	toolCallId: string;
+	toolName: string;
+	approved: boolean;
+	reason?: string;
+}
+
 interface ToolCallEventBase {
 	type: "tool_call";
 	toolCallId: string;
@@ -775,7 +822,9 @@ export type ExtensionEvent =
 	| UserPythonEvent
 	| InputEvent
 	| ToolCallEvent
-	| ToolResultEvent;
+	| ToolResultEvent
+	| ToolApprovalRequestedEvent
+	| ToolApprovalResolvedEvent;
 
 // ============================================================================
 // Event Results
@@ -890,7 +939,7 @@ export interface ExtensionAPI {
 	typebox: typeof TypeBox;
 
 	/** Injected zod module for Zod-authored extension tools (canonical going forward). */
-	zod: typeof Zod;
+	zod: typeof z;
 
 	/** Injected pi-coding-agent exports for accessing SDK utilities */
 	pi: typeof PiCodingAgent;
@@ -946,6 +995,8 @@ export interface ExtensionAPI {
 	on(event: "goal_updated", handler: ExtensionHandler<GoalUpdatedEvent>): void;
 	on(event: "credential_disabled", handler: ExtensionHandler<CredentialDisabledEvent>): void;
 	on(event: "input", handler: ExtensionHandler<InputEvent, InputEventResult>): void;
+	on(event: "tool_approval_requested", handler: ExtensionHandler<ToolApprovalRequestedEvent>): void;
+	on(event: "tool_approval_resolved", handler: ExtensionHandler<ToolApprovalResolvedEvent>): void;
 	on(event: "tool_call", handler: ExtensionHandler<ToolCallEvent, ToolCallEventResult>): void;
 	on(event: "tool_result", handler: ExtensionHandler<ToolResultEvent, ToolResultEventResult>): void;
 	on(event: "user_bash", handler: ExtensionHandler<UserBashEvent, UserBashEventResult>): void;

package/src/extensibility/extensions/wrapper.ts

@@ -121,8 +121,36 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		const approvalCheck = requiresApproval(this.tool, params, approvalMode, userPolicies);
 
 		if (approvalCheck.required) {
+			const hasApprovalHandlers =
+				this.runner.hasHandlers("tool_approval_requested") || this.runner.hasHandlers("tool_approval_resolved");
+			const sessionId = context?.sessionManager?.getSessionId() ?? "";
+			if (hasApprovalHandlers) {
+				await this.runner.emit({
+					type: "tool_approval_requested",
+					sessionId,
+					toolName: this.tool.name,
+					toolCallId,
+					...(approvalCheck.reason ? { reason: approvalCheck.reason } : {}),
+					approvalMode,
+				});
+			}
+
+			const resolveApproval = async (approved: boolean, reason?: string) => {
+				if (!hasApprovalHandlers) return;
+				await this.runner.emit({
+					type: "tool_approval_resolved",
+					sessionId,
+					toolName: this.tool.name,
+					toolCallId,
+					approved,
+					...(reason ? { reason } : {}),
+				});
+			};
+
 			// Check if UI is available
 			if (!this.runner.hasUI()) {
+				const reason = "no interactive UI available";
+				await resolveApproval(false, reason);
 				throw new Error(
 					`Tool "${this.tool.name}" requires approval but no interactive UI available.\n` +
 						`Options:\n` +
@@ -133,11 +161,19 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 			}
 
 			const uiContext = this.runner.getUIContext();
-			const choice = await uiContext.select(formatApprovalPrompt(this.tool, params, approvalCheck.reason), [
-				"Approve",
-				"Deny",
-			]);
-			if (choice !== "Approve") {
+			let choice: string | undefined;
+			try {
+				choice = await uiContext.select(formatApprovalPrompt(this.tool, params, approvalCheck.reason), [
+					"Approve",
+					"Deny",
+				]);
+			} catch (err) {
+				await resolveApproval(false, err instanceof Error ? err.message : "approval aborted");
+				throw err;
+			}
+			const approved = choice === "Approve";
+			await resolveApproval(approved, approved ? undefined : "denied by user");
+			if (!approved) {
 				throw new Error(`Tool call denied by user: ${this.tool.name}`);
 			}
 		}

package/src/extensibility/hooks/index.ts

@@ -1,4 +1,5 @@
-export type { ReadonlySessionManager, UsageStatistics } from "../../session/session-manager";
+export type { UsageStatistics } from "../../session/session-entries";
+export type { ReadonlySessionManager } from "../../session/session-manager";
 export * from "./loader";
 export * from "./runner";
 export * from "./tool-wrapper";

package/src/extensibility/hooks/loader.ts

@@ -3,7 +3,7 @@
  */
 import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
-import * as zod from "zod/v4";
+import { z as zod } from "zod/v4";
 import { hookCapability } from "../../capability/hook";
 import type { Hook } from "../../discovery";
 import { loadCapability } from "../../discovery";

package/src/extensibility/hooks/types.ts

@@ -1,7 +1,7 @@
 import type { ImageContent, Message, Model, TextContent } from "@oh-my-pi/pi-ai";
 import type { Component, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
-import type * as Zod from "zod/v4";
+import type { z } from "zod/v4";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { EditToolDetails } from "../../edit";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
@@ -585,7 +585,7 @@ export interface HookAPI {
 	/** Injected zod-backed typebox shim (legacy/compat — prefer `zod`). */
 	typebox: typeof TypeBox;
 	/** Injected zod module for Zod-authored hooks. */
-	zod: typeof Zod;
+	zod: typeof z;
 	/** Injected pi-coding-agent exports */
 	pi: typeof PiCodingAgent;
 }

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -30,16 +30,28 @@ const PI_PACKAGE_ALTERNATION = PI_PACKAGE_NAMES.join("|");
 // root that we relocated under a different folder. Each entry rewrites
 // `<pkg>/<from>` → `<pkg>/<to>` after the scope has been canonicalised, so
 // plugins importing the upstream layout still resolve to a real file in our
-// bundled copy. Add new entries as `pkg/from -> pkg/to` whenever a plugin
-// surfaces another upstream-only subpath that breaks resolution.
+// bundled copy. Entries ending in `/` rewrite the whole subtree; add new
+// `pkg/from -> pkg/to` pairs whenever an upstream-only subpath breaks resolution.
 const PI_SUBPATH_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
-	// (currently empty) Upstream `@mariozechner/pi-ai/oauth` re-exported
-	// `./utils/oauth/index.js`. Our pi-ai now exposes the same surface at the
-	// real `@oh-my-pi/pi-ai/oauth` export, so the legacy subpath canonicalizes
-	// straight to it with no rewrite. Add `from -> to` entries here whenever a
-	// future upstream-only subpath surfaces that breaks resolution.
+	["pi-ai/utils/oauth", "pi-ai/oauth"],
+	["pi-ai/utils/oauth/", "pi-ai/oauth/"],
 ]);
 
+function remapLegacyPiSubpath(rest: string): string {
+	const exact = PI_SUBPATH_REMAPS.get(rest);
+	if (exact) {
+		return exact;
+	}
+
+	for (const [from, to] of PI_SUBPATH_REMAPS) {
+		if (from.endsWith("/") && rest.startsWith(from)) {
+			return `${to}${rest.slice(from.length)}`;
+		}
+	}
+
+	return rest;
+}
+
 const LEGACY_PI_SPECIFIER_FILTER = new RegExp(`^@(?:${PI_SCOPE_ALTERNATION})/(?:${PI_PACKAGE_ALTERNATION})(?:/.*)?$`);
 const LEGACY_PI_IMPORT_SPECIFIER_REGEX = new RegExp(
 	`((?:from\\s+|import\\s+|import\\s*\\(\\s*)["'])(@(?:${PI_SCOPE_ALTERNATION})/(?:${PI_PACKAGE_ALTERNATION})(?:/[^"'()\\s]+)?)(["'])`,
@@ -101,6 +113,28 @@ export function __computeBunfsPackageRoot(metaDir: string, pathImpl: typeof path
 	return pathImpl.join(metaDir, "packages");
 }
 
+/**
+ * Compute the package root for the npm prebuilt `dist/cli.js` bundle.
+ *
+ * `bundle-dist.ts` defines `process.env.PI_BUNDLED="true"`; after bundling,
+ * `import.meta.dir` points at `<package>/dist`. Do not resolve the package via
+ * bare `@oh-my-pi/pi-coding-agent` here: from a global install Bun can pick an
+ * older cache entry, recreating mixed-runtime plugin loading.
+ */
+export function __computeBundledSelfPackageRoot(metaDir: string, pathImpl: typeof path = path): string {
+	const normalizedMetaDir = pathImpl.normalize(metaDir);
+	if (pathImpl.basename(normalizedMetaDir) === "dist") {
+		return pathImpl.resolve(metaDir, "..");
+	}
+
+	const pluginsDirSuffix = pathImpl.join("src", "extensibility", "plugins");
+	if (normalizedMetaDir.endsWith(pluginsDirSuffix)) {
+		return pathImpl.resolve(metaDir, "..", "..", "..");
+	}
+
+	return pathImpl.resolve(metaDir);
+}
+
 const BUNFS_PACKAGE_ROOT = IS_COMPILED_BINARY ? __computeBunfsPackageRoot(import.meta.dir) : null;
 
 function bunfsPath(...segments: string[]): string {
@@ -112,11 +146,7 @@ function bunfsPath(...segments: string[]): string {
 
 function resolveBundledSelfPackageRoot(): string | undefined {
 	if (!process.env.PI_BUNDLED) return undefined;
-	try {
-		return path.dirname(Bun.resolveSync("@oh-my-pi/pi-coding-agent/package.json", import.meta.dir));
-	} catch {
-		return undefined;
-	}
+	return __computeBundledSelfPackageRoot(import.meta.dir);
 }
 
 const BUNDLED_SELF_PACKAGE_ROOT = resolveBundledSelfPackageRoot();
@@ -208,7 +238,7 @@ function remapLegacyPiSpecifier(specifier: string): string | null {
 		return null;
 	}
 	const rest = specifier.slice(slashIdx + 1);
-	const remappedSubpath = PI_SUBPATH_REMAPS.get(rest) ?? rest;
+	const remappedSubpath = remapLegacyPiSubpath(rest);
 	return `${CANONICAL_PI_SCOPE}/${remappedSubpath}`;
 }
 

package/src/extensibility/plugins/loader.ts

@@ -172,34 +172,49 @@ function resolveManifestEntryFile(joined: string): string | null {
  * Handles both single-string and string[] base entries, plus feature-specific entries.
  */
 function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "commands" | "extensions"): string[] {
-	const paths: string[] = [];
+	const resolved: string[] = [];
+	for (const entry of resolvePluginManifestEntries(plugin, key)) {
+		if (entry.resolvedPath) {
+			resolved.push(entry.resolvedPath);
+		}
+	}
+	return resolved;
+}
+
+/**
+ * Declared manifest entries paired with their resolved file path. Returns one
+ * record per declared entry — base entries first, then enabled-feature entries
+ * — so callers (e.g. install-time validation) can detect manifest entries that
+ * point at missing files instead of silently skipping them like
+ * {@link resolvePluginPaths} does.
+ */
+export function resolvePluginManifestEntries(
+	plugin: InstalledPlugin,
+	key: "tools" | "hooks" | "commands" | "extensions",
+): Array<{ entry: string; resolvedPath: string | null }> {
+	const declared: Array<{ entry: string; resolvedPath: string | null }> = [];
 	const manifest = plugin.manifest;
 
-	// Base entry (always included if exists)
+	const resolveEntry = (entry: string): { entry: string; resolvedPath: string | null } => ({
+		entry,
+		resolvedPath: resolveManifestEntryFile(path.join(plugin.path, entry)),
+	});
+
 	const base = manifest[key];
 	if (base) {
 		const entries = Array.isArray(base) ? base : [base];
 		for (const entry of entries) {
-			const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
-			if (resolved) {
-				paths.push(resolved);
-			}
+			declared.push(resolveEntry(entry));
 		}
 	}
 
-	// Feature-specific entries
 	if (manifest.features && plugin.enabledFeatures) {
 		const enabledSet = new Set(plugin.enabledFeatures);
-
 		for (const [featName, feat] of Object.entries(manifest.features)) {
 			if (!enabledSet.has(featName)) continue;
-
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
-					if (resolved) {
-						paths.push(resolved);
-					}
+					declared.push(resolveEntry(entry));
 				}
 			}
 		}
@@ -207,19 +222,15 @@ function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "c
 		// null means use defaults - enable features with default: true
 		for (const [_featName, feat] of Object.entries(manifest.features)) {
 			if (!feat.default) continue;
-
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
-					if (resolved) {
-						paths.push(resolved);
-					}
+					declared.push(resolveEntry(entry));
 				}
 			}
 		}
 	}
 
-	return paths;
+	return declared;
 }
 
 export function resolvePluginToolPaths(plugin: InstalledPlugin): string[] {