@prometheus-ai/agent 0.5.4 → 0.5.8

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

@@ -12,16 +12,20 @@ import type {
 	ToolTier,
 } from "@prometheus-ai/agent-core";
 import type { CompactionResult } from "@prometheus-ai/agent-core/compaction";
-import type { Model, Static, TSchema } from "@prometheus-ai/ai";
+import type { FetchImpl, Model, Static, TSchema } from "@prometheus-ai/ai";
 import type { Component } from "@prometheus-ai/tui";
+import type { logger as PiLogger } from "@prometheus-ai/utils";
+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";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { HookUIContext } from "../../extensibility/hooks/types";
+import type * as PiCodingAgent from "../../index";
 import type { Theme } from "../../modes/theme/theme";
 import type { ReadonlySessionManager } from "../../session/session-manager";
 import type { TodoItem } from "../../tools/todo";
+import type * as TypeBox from "../typebox";
 
 /** Alias for clarity */
 export type CustomToolUIContext = HookUIContext;
@@ -56,13 +60,15 @@ export interface CustomToolAPI {
 	/** Whether UI is available (false in print/RPC mode) */
 	hasUI: boolean;
 	/** File logger for error/warning/debug messages */
-	logger: typeof import("@prometheus-ai/utils").logger;
+	logger: typeof PiLogger;
 	/** Injected zod-backed typebox shim (legacy/compat — Zod-authored tools are preferred). */
-	typebox: typeof import("../typebox");
+	typebox: typeof TypeBox;
 	/** Injected zod module for Zod-authored custom tools. */
-	zod: typeof import("zod/v4");
-	/** Injected coding-agent exports */
-	pi: typeof import("../..");
+	zod: typeof z;
+	/** Injected Prometheus coding agent exports */
+	prometheus: typeof PiCodingAgent;
+	/** Legacy alias for injected Prometheus coding agent exports */
+	pi: typeof PiCodingAgent;
 	/** Push a preview action that can later be resolved with the hidden resolve tool */
 	pushPendingAction(action: CustomToolPendingAction): void;
 }
@@ -86,6 +92,8 @@ export interface CustomToolContext {
 	abort(): void;
 	/** Settings instance for the current session. Prefer over the global singleton. */
 	settings?: Settings;
+	/** Fetch implementation for outbound HTTP; defaults to global fetch when omitted. */
+	fetch?: FetchImpl;
 	/** Whether to auto-approve all destructive tool operations (--auto-approve CLI flag) */
 	autoApprove?: boolean;
 }
@@ -101,11 +109,11 @@ export type CustomToolSessionEvent =
 	| {
 			reason: "auto_compaction_start";
 			trigger: "threshold" | "overflow" | "idle" | "incomplete";
-			action: "context-full" | "handoff" | "shake";
+			action: "context-full" | "handoff" | "shake" | "snapcompact";
 	  }
 	| {
 			reason: "auto_compaction_end";
-			action: "context-full" | "handoff" | "shake";
+			action: "context-full" | "handoff" | "shake" | "snapcompact";
 			result: CompactionResult | undefined;
 			aborted: boolean;
 			willRetry: boolean;

package/src/extensibility/extensions/get-commands-handler.ts

@@ -15,6 +15,7 @@
  * themselves. Each frontend (interactive-mode, ACP) prepends its own builtins.
  */
 import type { SkillsSettings } from "../../config/settings";
+import { BUILTIN_SLASH_COMMAND_RESERVED_NAMES } from "../../slash-commands/builtin-registry";
 import type { CustomCommandSource, LoadedCustomCommand } from "../custom-commands";
 import { getSkillSlashCommandName, type Skill } from "../skills";
 import type { SlashCommandInfo, SlashCommandLocation } from "../slash-commands";
@@ -32,7 +33,7 @@ export function getSessionSlashCommands(session: CommandsCapableSession): SlashC
 
 	const runner = session.extensionRunner;
 	if (runner) {
-		for (const cmd of runner.getRegisteredCommands()) {
+		for (const cmd of runner.getRegisteredCommands(BUILTIN_SLASH_COMMAND_RESERVED_NAMES)) {
 			out.push({
 				name: cmd.name,
 				description: cmd.description,

package/src/extensibility/extensions/index.ts

@@ -5,6 +5,7 @@
 export type { SlashCommandInfo, SlashCommandLocation, SlashCommandSource } from "../slash-commands";
 export {
 	discoverAndLoadExtensions,
+	discoverExtensionPaths,
 	ExtensionRuntimeNotInitializedError,
 	loadExtensionFromFactory,
 	loadExtensions,

package/src/extensibility/extensions/loader.ts

@@ -1,23 +1,25 @@
 /**
  * Extension loader - loads TypeScript extension modules using native Bun import.
  */
+
 import type * as fs1 from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import * as PiCodingAgent from "@prometheus-ai/agent";
 import type { ThinkingLevel } from "@prometheus-ai/agent-core";
 import type { ImageContent, Model, TextContent, TSchema } from "@prometheus-ai/ai";
 import type { KeyId } from "@prometheus-ai/tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@prometheus-ai/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";
 import type { ExecOptions } from "../../exec/exec";
 import { execCommand } from "../../exec/exec";
+// Runtime self-reference: dereference this namespace only inside loader functions to keep the index.ts cycle safe.
+import * as PiCodingAgent from "../../index";
 import type { CustomMessage } from "../../session/messages";
 import { EventBus } from "../../utils/event-bus";
-import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "../plugins/legacy-pi-compat";
+import { installLegacyPackageSpecifierShim, loadLegacyPackageModule } from "../plugins/legacy-package-compat";
 import { getAllPluginExtensionPaths } from "../plugins/loader";
 import * as TypeBox from "../typebox";
 
@@ -36,7 +38,7 @@ import type {
 	ToolDefinition,
 } from "./types";
 
-installLegacyPiSpecifierShim();
+installLegacyPackageSpecifierShim();
 
 type HandlerFn = (...args: unknown[]) => Promise<unknown>;
 type LoadedExtensionModule = ExtensionFactory | { default?: ExtensionFactory };
@@ -121,7 +123,8 @@ export class ExtensionRuntime implements IExtensionRuntime {
 class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 	readonly logger = logger;
 	readonly typebox = TypeBox;
-	readonly zod = Zod;
+	readonly zod = z;
+	readonly prometheus = PiCodingAgent;
 	readonly flagValues = new Map<string, boolean | string>();
 	readonly pendingProviderRegistrations: Array<{
 		name: string;
@@ -286,7 +289,7 @@ async function loadExtension(
 ): Promise<{ extension: Extension | null; error: string | null }> {
 	const resolvedPath = resolvePath(extensionPath, cwd);
 	try {
-		const module = (await loadLegacyPiModule(resolvedPath)) as LoadedExtensionModule;
+		const module = (await loadLegacyPackageModule(resolvedPath)) as LoadedExtensionModule;
 		const factory = getExtensionFactory(module);
 
 		if (typeof factory !== "function") {
@@ -382,6 +385,35 @@ function isExtensionFile(name: string): boolean {
 	return name.endsWith(".ts") || name.endsWith(".js");
 }
 
+const MANIFEST_ENTRY_INDEX_NAMES = ["index.ts", "index.js", "index.mjs", "index.cjs"] as const;
+
+async function resolveExtensionEntryFile(entryPath: string): Promise<string | null> {
+	try {
+		const stat = await fs.stat(entryPath);
+		if (!stat.isDirectory()) {
+			return entryPath;
+		}
+		for (const indexName of MANIFEST_ENTRY_INDEX_NAMES) {
+			const candidate = path.join(entryPath, indexName);
+			try {
+				const indexStat = await fs.stat(candidate);
+				if (!indexStat.isDirectory()) {
+					return candidate;
+				}
+			} catch (err) {
+				if (isEnoent(err) || isEacces(err) || hasFsCode(err, "EPERM")) continue;
+				throw err;
+			}
+		}
+		return null;
+	} catch (err) {
+		if (isEnoent(err) || isEacces(err) || hasFsCode(err, "EPERM")) {
+			return null;
+		}
+		throw err;
+	}
+}
+
 /**
  * Resolve extension entry points from a directory.
  */
@@ -392,13 +424,8 @@ async function resolveExtensionEntries(dir: string): Promise<string[] | null> {
 		const entries: string[] = [];
 		for (const extPath of manifest.extensions) {
 			const resolvedExtPath = path.resolve(dir, extPath);
-			try {
-				await fs.stat(resolvedExtPath);
-				entries.push(resolvedExtPath);
-			} catch (err) {
-				if (isEnoent(err) || isEacces(err) || hasFsCode(err, "EPERM")) continue;
-				throw err;
-			}
+			const entry = await resolveExtensionEntryFile(resolvedExtPath);
+			if (entry) entries.push(entry);
 		}
 		if (entries.length > 0) {
 			return entries;
@@ -478,16 +505,24 @@ async function discoverExtensionsInDir(dir: string): Promise<string[]> {
 
 	return discovered;
 }
-
 /**
- * Discover and load extensions from standard locations.
+ * Discover absolute paths of extensions to load, without importing or
+ * binding factories. Hot path on session startup — the scan walks native
+ * `.prometheus`/`.prometheus` extension capabilities, the installed-plugin tree, and any
+ * configured paths.
+ *
+ * Subagents reuse the parent's collected paths via the SDK's
+ * `preloadedExtensionPaths` option, then call {@link loadExtensions} themselves
+ * so each session rebuilds Extension instances bound to its OWN
+ * `ExtensionAPI` (cwd, eventBus, runtime). Forwarding the parent's
+ * `LoadExtensionsResult` directly would reuse handlers/tools/commands that
+ * closed over the parent's `cwd` and event bus.
  */
-export async function discoverAndLoadExtensions(
+export async function discoverExtensionPaths(
 	configuredPaths: string[],
 	cwd: string,
-	eventBus?: EventBus,
 	disabledExtensionIds: string[] = [],
-): Promise<LoadExtensionsResult> {
+): Promise<string[]> {
 	const allPaths: string[] = [];
 	const seen = new Set<string>();
 	const disabled = new Set(disabledExtensionIds);
@@ -509,7 +544,7 @@ export async function discoverAndLoadExtensions(
 		}
 	};
 
-	// 1. Discover extension modules via capability API (native .prometheus and compatibility roots)
+	// 1. Discover extension modules via capability API (native .prometheus/.prometheus only)
 	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, { cwd });
 	for (const ext of discovered.items) {
 		if (ext._source.provider !== "native") continue;
@@ -548,5 +583,20 @@ export async function discoverAndLoadExtensions(
 		addPath(resolved);
 	}
 
-	return loadExtensions(allPaths, cwd, eventBus);
+	return allPaths;
+}
+
+/**
+ * Discover and load extensions from standard locations. Composed of
+ * {@link discoverExtensionPaths} (FS scan) + {@link loadExtensions}
+ * (per-session binding).
+ */
+export async function discoverAndLoadExtensions(
+	configuredPaths: string[],
+	cwd: string,
+	eventBus?: EventBus,
+	disabledExtensionIds: string[] = [],
+): Promise<LoadExtensionsResult> {
+	const paths = await discoverExtensionPaths(configuredPaths, cwd, disabledExtensionIds);
+	return loadExtensions(paths, cwd, eventBus);
 }

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 "@prometheus-ai/ai";
+import { modelFamilyToken } from "@prometheus-ai/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,8 +6,11 @@ import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMeta
 import type { KeyId } from "@prometheus-ai/tui";
 import { logger } from "@prometheus-ai/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,
@@ -187,6 +190,7 @@ export class ExtensionRunner {
 	#switchSessionHandler: SwitchSessionHandler = async () => ({ cancelled: false });
 	#reloadHandler: () => Promise<void> = async () => {};
 	#shutdownHandler: ShutdownHandler = () => {};
+	#getMemoryFn?: () => MemoryRuntimeContext | undefined;
 	#commandDiagnostics: Array<{ type: string; message: string; path: string }> = [];
 	#initialized = false;
 	/**
@@ -204,8 +208,11 @@ export class ExtensionRunner {
 		private readonly cwd: string,
 		private readonly sessionManager: SessionManager,
 		private readonly modelRegistry: ModelRegistry,
+		getMemory?: () => MemoryRuntimeContext | undefined,
+		private readonly settings?: Settings,
 	) {
 		this.#uiContext = noOpUIContext;
+		this.#getMemoryFn = getMemory;
 	}
 
 	initialize(
@@ -427,7 +434,7 @@ export class ExtensionRunner {
 		return this.extensions.flatMap(ext => ext.assistantThinkingRenderers);
 	}
 
-	getRegisteredCommands(reserved?: Set<string>): RegisteredCommand[] {
+	getRegisteredCommands(reserved?: ReadonlySet<string>): RegisteredCommand[] {
 		this.#commandDiagnostics = [];
 
 		const commands = new Map<string, RegisteredCommand>();
@@ -475,11 +482,13 @@ export class ExtensionRunner {
 			get model() {
 				return getModel();
 			},
+			models: createExtensionModelQuery(this.modelRegistry, this.settings, getModel),
 			isIdle: () => this.#isIdleFn(),
 			abort: () => this.#abortFn(),
 			hasPendingMessages: () => this.#hasPendingMessagesFn(),
 			shutdown: () => this.#shutdownHandler(),
 			getSystemPrompt: () => this.#getSystemPromptFn(),
+			memory: this.#getMemoryFn?.(),
 		};
 	}
 
@@ -898,7 +907,8 @@ export class ExtensionRunner {
 						messages.push(result.message);
 					}
 					if (result.systemPrompt !== undefined) {
-						currentSystemPrompt = result.systemPrompt;
+						currentSystemPrompt =
+							typeof result.systemPrompt === "string" ? [result.systemPrompt] : result.systemPrompt;
 						systemPromptModified = true;
 					}
 				}

package/src/extensibility/extensions/types.ts

@@ -7,9 +7,13 @@
  * - Register commands, keyboard shortcuts, and CLI flags
  * - Interact with the user via UI primitives
  */
-
-import type * as piCodingAgent from "@prometheus-ai/agent";
-import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@prometheus-ai/agent-core";
+import type {
+	AgentMessage,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	ThinkingLevel,
+	ToolApproval,
+} from "@prometheus-ai/agent-core";
 import type { CompactionResult } from "@prometheus-ai/agent-core/compaction";
 import type {
 	Api,
@@ -18,22 +22,25 @@ import type {
 	Context,
 	ImageContent,
 	Model,
+	ModelSpec,
 	ProviderResponseMetadata,
 	SimpleStreamOptions,
 	Static,
 	TextContent,
 	TSchema,
 } from "@prometheus-ai/ai";
-import type { OAuthCredentials, OAuthLoginCallbacks } from "@prometheus-ai/ai/utils/oauth/types";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@prometheus-ai/ai/oauth/types";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@prometheus-ai/tui";
 import type { logger as PiLogger } from "@prometheus-ai/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";
 import type { PythonResult } from "../../eval/py/executor";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
+import type * as PiCodingAgent from "../../index";
+import type { MemoryRuntimeContext } from "../../memory-backend";
 import type { CustomEditor } from "../../modes/components/custom-editor";
 import type { Theme } from "../../modes/theme/theme";
 import type { CustomMessage } from "../../session/messages";
@@ -49,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,
@@ -286,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;
@@ -303,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 */
@@ -313,6 +349,8 @@ export interface ExtensionContext {
 	shutdown(): void;
 	/** Get the current effective system prompt. */
 	getSystemPrompt(): string[];
+	/** Structured memory runtime for status/search/save across the configured backend. */
+	memory?: MemoryRuntimeContext;
 }
 
 /**
@@ -393,6 +431,9 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
 	defaultInactive?: boolean;
 	/** If true, tool may stage deferred changes that require explicit resolve/discard. */
 	deferrable?: boolean;
+	/** Tool approval tier. Defaults to `"exec"` when omitted.
+	 *  `"read"`: read-only operations. `"write"`: mutations. `"exec"`: code execution. */
+	approval?: ToolApproval;
 	/** MCP server name for discovery/search metadata when this tool fronts an MCP server. */
 	mcpServerName?: string;
 	/** Original MCP tool name for discovery/search metadata. */
@@ -596,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;
@@ -763,7 +822,9 @@ export type ExtensionEvent =
 	| UserPythonEvent
 	| InputEvent
 	| ToolCallEvent
-	| ToolResultEvent;
+	| ToolResultEvent
+	| ToolApprovalRequestedEvent
+	| ToolApprovalResolvedEvent;
 
 // ============================================================================
 // Event Results
@@ -878,10 +939,12 @@ export interface ExtensionAPI {
 	typebox: typeof TypeBox;
 
 	/** Injected zod module for Zod-authored extension tools (canonical going forward). */
-	zod: typeof Zod;
+	zod: typeof z;
 
-	/** Injected coding-agent exports for accessing SDK utilities */
-	pi: typeof piCodingAgent;
+	/** Injected Prometheus coding agent exports for accessing SDK utilities */
+	prometheus: typeof PiCodingAgent;
+	/** Legacy alias for injected Prometheus coding agent exports */
+	pi: typeof PiCodingAgent;
 
 	// =========================================================================
 	// Event Subscription
@@ -934,6 +997,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;
@@ -1073,7 +1138,7 @@ export interface ExtensionAPI {
 	 *       id: "claude-sonnet-4@20250514",
 	 *       name: "Claude Sonnet 4 (Vertex)",
 	 *       reasoning: true,
-	 *       thinking: { mode: "anthropic-adaptive", minLevel: "minimal", maxLevel: "high" },
+	 *       thinking: { mode: "anthropic-adaptive", efforts: ["minimal", "low", "medium", "high"] },
 	 *       input: ["text", "image"],
 	 *       cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
 	 *       contextWindow: 200000,
@@ -1126,6 +1191,13 @@ export interface ProviderConfig {
 		/** Optional model rewrite hook for credential-aware routing (e.g., enterprise URLs). */
 		modifyModels?(models: Model<Api>[], credentials: OAuthCredentials): Model<Api>[];
 	};
+	/**
+	 * Async factory that fetches the live model list from the provider endpoint.
+	 * Runs through the same SQLite model-cache as built-in providers (keyed by
+	 * provider name, default 24 h TTL). Receives the resolved API key (undefined
+	 * when unauthenticated). Mutually exclusive with `models`.
+	 */
+	fetchDynamicModels?: (apiKey: string | undefined) => Promise<readonly ProviderModelConfig[]>;
 }
 
 /** Configuration for a model within a provider. */
@@ -1153,7 +1225,7 @@ export interface ProviderModelConfig {
 	/** Custom headers for this model. */
 	headers?: Record<string, string>;
 	/** OpenAI compatibility settings. */
-	compat?: Model<Api>["compat"];
+	compat?: ModelSpec<Api>["compat"];
 }
 
 /** Extension factory function type. Supports both sync and async initialization. */

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,10 +3,12 @@
  */
 import * as path from "node:path";
 import { logger } from "@prometheus-ai/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";
+// Runtime self-reference: dereference this namespace only inside loader functions to keep the index.ts cycle safe.
+import * as PiCodingAgent from "../../index";
 import type { HookMessage } from "../../session/messages";
 import type { SessionManager } from "../../session/session-manager";
 import * as typebox from "../typebox";
@@ -138,7 +140,8 @@ async function createHookAPI(
 		logger,
 		typebox,
 		zod,
-		pi: await import("@prometheus-ai/agent"),
+		prometheus: PiCodingAgent,
+		pi: PiCodingAgent,
 	} as HookAPI;
 
 	return {
@@ -225,7 +228,7 @@ export async function loadHooks(paths: string[], cwd: string): Promise<LoadHooks
 /**
  * Discover and load hooks from all registered providers.
  * Uses the capability API to discover hook paths from:
- * 1. Prometheus native configs and compatibility hook roots
+ * 1. Prometheus native configs (.prometheus/.prometheus hooks/)
  * 2. Installed plugins
  * 3. Other editor/IDE configurations
  *