gsd-pi 2.39.0 → 2.40.0-dev.4a93031

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "2.39.0",
+  "version": "2.40.0",
   "description": "Coding agent CLI (vendored from pi-mono)",
   "type": "module",
   "piConfig": {

package/packages/pi-coding-agent/src/core/agent-session.ts

@@ -25,6 +25,7 @@ import type {
 } from "@gsd/pi-agent-core";
 import type { AssistantMessage, ImageContent, Message, Model, TextContent } from "@gsd/pi-ai";
 import { modelsAreEqual, resetApiProviders, supportsXhigh } from "@gsd/pi-ai";
+import { Type } from "@sinclair/typebox";
 import { getDocsPath } from "../config.js";
 import { getErrorMessage } from "../utils/error.js";
 import { theme } from "../modes/interactive/theme/theme.js";
@@ -732,9 +733,10 @@ export class AgentSession {
 	 * Changes take effect on the next agent turn.
 	 */
 	setActiveToolsByName(toolNames: string[]): void {
+		const requestedToolNames = [...new Set([...toolNames, ...this._getBuiltinToolNames()])];
 		const tools: AgentTool[] = [];
 		const validToolNames: string[] = [];
-		for (const name of toolNames) {
+		for (const name of requestedToolNames) {
 			const tool = this._toolRegistry.get(name);
 			if (tool) {
 				tools.push(tool);
@@ -743,6 +745,7 @@ export class AgentSession {
 		}
 		this.agent.setTools(tools);
 
+
 		// Rebuild base system prompt with new tool set
 		this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
 		this.agent.setSystemPrompt(this._baseSystemPrompt);
@@ -858,6 +861,48 @@ export class AgentSession {
 		return Array.from(unique);
 	}
 
+	private _findSkillByName(skillName: string) {
+		return this.resourceLoader.getSkills().skills.find((skill) => skill.name === skillName);
+	}
+
+	private _formatMissingSkillMessage(skillName: string): string {
+		const availableSkills = this.resourceLoader.getSkills().skills.map((skill) => skill.name).join(", ") || "(none)";
+		return `Skill "${skillName}" not found. Available skills: ${availableSkills}`;
+	}
+
+	private _emitSkillExpansionError(skillFilePath: string, err: unknown): void {
+		this._extensionRunner?.emitError({
+			extensionPath: skillFilePath,
+			event: "skill_expansion",
+			error: getErrorMessage(err),
+		});
+	}
+
+	private _renderSkillInvocation(skill: { name: string; filePath: string; baseDir: string }, args?: string): string {
+		const content = readFileSync(skill.filePath, "utf-8");
+		const body = stripFrontmatter(content).trim();
+		const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${body}\n</skill>`;
+		return args && args.trim() ? `${skillBlock}\n\n${args.trim()}` : skillBlock;
+	}
+
+	private _expandSkillByName(skillName: string, args?: string): string {
+		const skill = this._findSkillByName(skillName);
+		if (!skill) {
+			throw new Error(this._formatMissingSkillMessage(skillName));
+		}
+
+		try {
+			return this._renderSkillInvocation(skill, args);
+		} catch (err) {
+			this._emitSkillExpansionError(skill.filePath, err);
+			throw err;
+		}
+	}
+
+	private _formatSkillInvocation(skillName: string, args?: string): string {
+		return this._expandSkillByName(skillName, args);
+	}
+
 	private _rebuildSystemPrompt(toolNames: string[]): string {
 		const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
 		const toolSnippets: Record<string, string> = {};
@@ -1103,25 +1148,78 @@ export class AgentSession {
 		const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
 		const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
 
-		const skill = this.resourceLoader.getSkills().skills.find((s) => s.name === skillName);
-		if (!skill) return text; // Unknown skill, pass through
+		if (!this._findSkillByName(skillName)) return text;
 
 		try {
-			const content = readFileSync(skill.filePath, "utf-8");
-			const body = stripFrontmatter(content).trim();
-			const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${body}\n</skill>`;
-			return args ? `${skillBlock}\n\n${args}` : skillBlock;
-		} catch (err) {
-			// Emit error like extension commands do
-			this._extensionRunner?.emitError({
-				extensionPath: skill.filePath,
-				event: "skill_expansion",
-				error: getErrorMessage(err),
-			});
-			return text; // Return original on error
+			return this._formatSkillInvocation(skillName, args);
+		} catch {
+			return text;
 		}
 	}
 
+	private _createBuiltInSkillTool(): AgentTool {
+		const skillSchema = Type.Object({
+			skill: Type.String({ description: "The skill name. E.g., 'commit', 'review-pr', or 'pdf'" }),
+			args: Type.Optional(Type.String({ description: "Optional arguments for the skill" })),
+		});
+
+		return {
+			name: "Skill",
+			label: "Skill",
+			description:
+				"Execute a skill within the main conversation. Use this tool when users ask for a slash command or reference a skill by name. Returns the expanded skill block and appends args after it.",
+			parameters: skillSchema,
+			execute: async (_toolCallId, params: unknown) => {
+				const input = params as { skill: string; args?: string };
+				try {
+					return {
+						content: [
+							{
+								type: "text",
+								text: this._expandSkillByName(input.skill, input.args),
+							},
+						],
+						details: undefined,
+					};
+				} catch (err) {
+					return {
+						content: [{ type: "text", text: getErrorMessage(err) }],
+						details: undefined,
+					};
+				}
+			},
+		};
+	}
+
+	private _getBuiltinToolNames(): string[] {
+		return this._getBuiltinTools().map((tool) => tool.name);
+	}
+
+	private _getBuiltinTools(): AgentTool[] {
+		return [this._createBuiltInSkillTool()];
+	}
+
+	private _getRegisteredToolDefinitions(): ToolDefinition[] {
+		const registeredTools = this._extensionRunner?.getAllRegisteredTools() ?? [];
+		return registeredTools.map((tool) => tool.definition);
+	}
+
+	private _getBuiltinToolDefinitions(): ToolDefinition[] {
+		return this._getBuiltinTools().map((tool) => ({
+			name: tool.name,
+			label: tool.label,
+			description: tool.description,
+			parameters: tool.parameters,
+			execute: async () => ({ content: [], details: undefined }),
+		}));
+	}
+
+	getRenderableToolDefinition(toolName: string): ToolDefinition | undefined {
+		return [...this._getBuiltinToolDefinitions(), ...this._getRegisteredToolDefinitions()].find(
+			(tool) => tool.name === toolName,
+		);
+	}
+
 	/**
 	 * Queue a steering message to interrupt the agent mid-run.
 	 * Delivered after current tool execution, skips remaining tools.
@@ -1967,8 +2065,12 @@ export class AgentSession {
 		const wrappedExtensionTools = this._extensionRunner
 			? wrapRegisteredTools(allCustomTools, this._extensionRunner)
 			: [];
+		const builtinTools = this._getBuiltinTools();
 
 		const toolRegistry = new Map(this._baseToolRegistry);
+		for (const tool of builtinTools) {
+			toolRegistry.set(tool.name, tool);
+		}
 		for (const tool of wrappedExtensionTools as AgentTool[]) {
 			toolRegistry.set(tool.name, tool);
 		}
@@ -2694,14 +2796,11 @@ export class AgentSession {
 	async exportToHtml(outputPath?: string): Promise<string> {
 		const themeName = this.settingsManager.getTheme();
 
-		// Create tool renderer if we have an extension runner (for custom tool HTML rendering)
-		let toolRenderer: ToolHtmlRenderer | undefined;
-		if (this._extensionRunner) {
-			toolRenderer = createToolHtmlRenderer({
-				getToolDefinition: (name) => this._extensionRunner!.getToolDefinition(name),
-				theme,
-			});
-		}
+		// Create tool renderer for extension and built-in tool HTML rendering
+		const toolRenderer = createToolHtmlRenderer({
+			getToolDefinition: (name) => this.getRenderableToolDefinition(name),
+			theme,
+		});
 
 		return await exportSessionToHtml(this.sessionManager, this.state, {
 			outputPath,

package/packages/pi-coding-agent/src/core/skill-tool.test.ts

@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+
+import { Agent } from "@gsd/pi-agent-core";
+import { AuthStorage } from "./auth-storage.js";
+import { AgentSession } from "./agent-session.js";
+import { ModelRegistry } from "./model-registry.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SessionManager } from "./session-manager.js";
+import { SettingsManager } from "./settings-manager.js";
+
+let testDir: string;
+
+function writeSkill(cwd: string, name: string, description: string, body = `# ${name}\n`): string {
+	const skillDir = join(cwd, ".pi", "skills", name);
+	mkdirSync(skillDir, { recursive: true });
+	const skillPath = join(skillDir, "SKILL.md");
+	writeFileSync(skillPath, `---\nname: ${name}\ndescription: ${description}\n---\n\n${body}`);
+	return skillPath;
+}
+
+describe("Skill tool", () => {
+	beforeEach(() => {
+		testDir = mkdtempSync(join(tmpdir(), "skill-tool-test-"));
+	});
+
+	afterEach(() => {
+		rmSync(testDir, { recursive: true, force: true });
+	});
+
+	async function createSession() {
+		const agentDir = join(testDir, "agent-home");
+		const authStorage = AuthStorage.inMemory({});
+		const modelRegistry = new ModelRegistry(authStorage, join(agentDir, "models.json"));
+		const settingsManager = SettingsManager.inMemory();
+		const resourceLoader = new DefaultResourceLoader({
+			cwd: testDir,
+			agentDir,
+			settingsManager,
+			noExtensions: true,
+			noPromptTemplates: true,
+			noThemes: true,
+		});
+		await resourceLoader.reload();
+
+		return new AgentSession({
+			agent: new Agent(),
+			sessionManager: SessionManager.inMemory(testDir),
+			settingsManager,
+			cwd: testDir,
+			resourceLoader,
+			modelRegistry,
+		});
+	}
+
+	it("resolves a project-level skill to the exact skill block format", async () => {
+		const skillPath = writeSkill(
+			testDir,
+			"swift-testing",
+			"Use for Swift Testing assertions and verification patterns.",
+			"# Swift Testing\nUse this skill.\n",
+		);
+		const session = await createSession();
+
+		const tool = session.state.tools.find((entry) => entry.name === "Skill");
+		assert.ok(tool, "Skill tool should be registered");
+
+		const result = await tool.execute("call-1", { skill: "swift-testing" });
+		assert.equal(
+			result.content[0]?.type === "text" ? result.content[0].text : "",
+			`<skill name="swift-testing" location="${skillPath}">\nReferences are relative to ${join(testDir, ".pi", "skills", "swift-testing")}.\n\n# Swift Testing\nUse this skill.\n</skill>`,
+		);
+	});
+
+	it("returns a helpful error for unknown skills", async () => {
+		writeSkill(testDir, "swift-testing", "Use for Swift Testing assertions and verification patterns.");
+		const session = await createSession();
+		const tool = session.state.tools.find((entry) => entry.name === "Skill");
+		assert.ok(tool, "Skill tool should be registered");
+
+		const result = await tool.execute("call-2", { skill: "nonexistent" });
+		const message = result.content[0]?.type === "text" ? result.content[0].text : "";
+		assert.match(message, /^Skill "nonexistent" not found\. Available skills: /);
+		assert.match(message, /swift-testing/);
+	});
+});

package/packages/pi-coding-agent/src/core/skills.ts

@@ -299,7 +299,8 @@ export function formatSkillsForPrompt(skills: Skill[]): string {
 
 	const lines = [
 		"\n\nThe following skills provide specialized instructions for specific tasks.",
-		"Use the read tool to load a skill's file when the task matches its description.",
+		"Use the Skill tool with the exact skill name from <available_skills> when the task matches its description.",
+		"If the Skill tool reports an unknown skill, do not guess: use an exact name from <available_skills> or tell the user the skill is unavailable.",
 		"When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
 		"",
 		"<available_skills>",

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts

@@ -0,0 +1,302 @@
+import { Loader, Spacer, Text } from "@gsd/pi-tui";
+
+import type { InteractiveModeEvent, InteractiveModeStateHost } from "../interactive-mode-state.js";
+import { theme } from "../theme/theme.js";
+import { AssistantMessageComponent } from "../components/assistant-message.js";
+import { ToolExecutionComponent } from "../components/tool-execution.js";
+import { appKey } from "../components/keybinding-hints.js";
+
+export async function handleAgentEvent(host: InteractiveModeStateHost & {
+	init: () => Promise<void>;
+	getMarkdownThemeWithSettings: () => any;
+	addMessageToChat: (message: any, options?: any) => void;
+	formatWebSearchResult: (content: unknown) => string;
+	getRegisteredToolDefinition: (toolName: string) => any;
+	checkShutdownRequested: () => Promise<void>;
+	rebuildChatFromMessages: () => void;
+	flushCompactionQueue: (options?: { willRetry?: boolean }) => Promise<void>;
+	showStatus: (message: string) => void;
+	showError: (message: string) => void;
+	updatePendingMessagesDisplay: () => void;
+}, event: InteractiveModeEvent): Promise<void> {
+	if (!host.isInitialized) {
+		await host.init();
+	}
+
+	host.footer.invalidate();
+
+	switch (event.type) {
+		case "agent_start":
+			if (host.retryEscapeHandler) {
+				host.defaultEditor.onEscape = host.retryEscapeHandler;
+				host.retryEscapeHandler = undefined;
+			}
+			if (host.retryLoader) {
+				host.retryLoader.stop();
+				host.retryLoader = undefined;
+			}
+			if (host.loadingAnimation) {
+				host.loadingAnimation.stop();
+			}
+			host.statusContainer.clear();
+			host.loadingAnimation = new Loader(
+				host.ui,
+				(spinner) => theme.fg("accent", spinner),
+				(text) => theme.fg("muted", text),
+				host.defaultWorkingMessage,
+			);
+			host.statusContainer.addChild(host.loadingAnimation);
+			if (host.pendingWorkingMessage !== undefined) {
+				if (host.pendingWorkingMessage) {
+					host.loadingAnimation.setMessage(host.pendingWorkingMessage);
+				}
+				host.pendingWorkingMessage = undefined;
+			}
+			host.ui.requestRender();
+			break;
+
+		case "message_start":
+			if (event.message.role === "custom") {
+				host.addMessageToChat(event.message);
+				host.ui.requestRender();
+			} else if (event.message.role === "user") {
+				host.addMessageToChat(event.message);
+				host.updatePendingMessagesDisplay();
+				host.ui.requestRender();
+			} else if (event.message.role === "assistant") {
+				host.streamingComponent = new AssistantMessageComponent(
+					undefined,
+					host.hideThinkingBlock,
+					host.getMarkdownThemeWithSettings(),
+				);
+				host.streamingMessage = event.message;
+				host.chatContainer.addChild(host.streamingComponent);
+				host.streamingComponent.updateContent(host.streamingMessage);
+				host.ui.requestRender();
+			}
+			break;
+
+		case "message_update":
+			if (host.streamingComponent && event.message.role === "assistant") {
+				host.streamingMessage = event.message;
+				host.streamingComponent.updateContent(host.streamingMessage);
+				for (const content of host.streamingMessage.content) {
+					if (content.type === "toolCall") {
+						if (!host.pendingTools.has(content.id)) {
+							const component = new ToolExecutionComponent(
+								content.name,
+								content.arguments,
+								{ showImages: host.settingsManager.getShowImages() },
+								host.getRegisteredToolDefinition(content.name),
+								host.ui,
+							);
+							component.setExpanded(host.toolOutputExpanded);
+							host.chatContainer.addChild(component);
+							host.pendingTools.set(content.id, component);
+						} else {
+							host.pendingTools.get(content.id)?.updateArgs(content.arguments);
+						}
+					} else if (content.type === "serverToolUse") {
+						if (!host.pendingTools.has(content.id)) {
+							const component = new ToolExecutionComponent(
+								content.name,
+								content.input ?? {},
+								{ showImages: host.settingsManager.getShowImages() },
+								undefined,
+								host.ui,
+							);
+							component.setExpanded(host.toolOutputExpanded);
+							host.chatContainer.addChild(component);
+							host.pendingTools.set(content.id, component);
+						}
+					} else if (content.type === "webSearchResult") {
+						const component = host.pendingTools.get(content.toolUseId);
+						if (component) {
+							const searchContent = content.content;
+							const isError = searchContent && typeof searchContent === "object" && "type" in (searchContent as any) && (searchContent as any).type === "web_search_tool_result_error";
+							component.updateResult({
+								content: [{ type: "text", text: host.formatWebSearchResult(searchContent) }],
+								isError: !!isError,
+							});
+							host.pendingTools.delete(content.toolUseId);
+						}
+					}
+				}
+				host.ui.requestRender();
+			}
+			break;
+
+		case "message_end":
+			if (event.message.role === "user") break;
+			if (host.streamingComponent && event.message.role === "assistant") {
+				host.streamingMessage = event.message;
+				let errorMessage: string | undefined;
+				if (host.streamingMessage.stopReason === "aborted") {
+					const retryAttempt = host.session.retryAttempt;
+					errorMessage = retryAttempt > 0
+						? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+						: "Operation aborted";
+					host.streamingMessage.errorMessage = errorMessage;
+				}
+				host.streamingComponent.updateContent(host.streamingMessage);
+				if (host.streamingMessage.stopReason === "aborted" || host.streamingMessage.stopReason === "error") {
+					if (!errorMessage) {
+						errorMessage = host.streamingMessage.errorMessage || "Error";
+					}
+					for (const [, component] of host.pendingTools.entries()) {
+						component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
+					}
+					host.pendingTools.clear();
+				} else {
+					for (const [, component] of host.pendingTools.entries()) {
+						component.setArgsComplete();
+					}
+				}
+				host.streamingComponent = undefined;
+				host.streamingMessage = undefined;
+				host.footer.invalidate();
+			}
+			host.ui.requestRender();
+			break;
+
+		case "tool_execution_start":
+			if (!host.pendingTools.has(event.toolCallId)) {
+				const component = new ToolExecutionComponent(
+					event.toolName,
+					event.args,
+					{ showImages: host.settingsManager.getShowImages() },
+					host.getRegisteredToolDefinition(event.toolName),
+					host.ui,
+				);
+				component.setExpanded(host.toolOutputExpanded);
+				host.chatContainer.addChild(component);
+				host.pendingTools.set(event.toolCallId, component);
+				host.ui.requestRender();
+			}
+			break;
+
+		case "tool_execution_update": {
+			const component = host.pendingTools.get(event.toolCallId);
+			if (component) {
+				component.updateResult({ ...event.partialResult, isError: false }, true);
+				host.ui.requestRender();
+			}
+			break;
+		}
+
+		case "tool_execution_end": {
+			const component = host.pendingTools.get(event.toolCallId);
+			if (component) {
+				component.updateResult({ ...event.result, isError: event.isError });
+				host.pendingTools.delete(event.toolCallId);
+				host.ui.requestRender();
+			}
+			break;
+		}
+
+		case "agent_end":
+			if (host.loadingAnimation) {
+				host.loadingAnimation.stop();
+				host.loadingAnimation = undefined;
+				host.statusContainer.clear();
+			}
+			if (host.streamingComponent) {
+				host.chatContainer.removeChild(host.streamingComponent);
+				host.streamingComponent = undefined;
+				host.streamingMessage = undefined;
+			}
+			host.pendingTools.clear();
+			await host.checkShutdownRequested();
+			host.ui.requestRender();
+			break;
+
+		case "auto_compaction_start":
+			host.autoCompactionEscapeHandler = host.defaultEditor.onEscape;
+			host.defaultEditor.onEscape = () => host.session.abortCompaction();
+			host.statusContainer.clear();
+			host.autoCompactionLoader = new Loader(
+				host.ui,
+				(spinner) => theme.fg("accent", spinner),
+				(text) => theme.fg("muted", text),
+				`${event.reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... (${appKey(host.keybindings, "interrupt")} to cancel)`,
+			);
+			host.statusContainer.addChild(host.autoCompactionLoader);
+			host.ui.requestRender();
+			break;
+
+		case "auto_compaction_end":
+			if (host.autoCompactionEscapeHandler) {
+				host.defaultEditor.onEscape = host.autoCompactionEscapeHandler;
+				host.autoCompactionEscapeHandler = undefined;
+			}
+			if (host.autoCompactionLoader) {
+				host.autoCompactionLoader.stop();
+				host.autoCompactionLoader = undefined;
+				host.statusContainer.clear();
+			}
+			if (event.aborted) {
+				host.showStatus("Auto-compaction cancelled");
+			} else if (event.result) {
+				host.chatContainer.clear();
+				host.rebuildChatFromMessages();
+				host.addMessageToChat({
+					role: "compactionSummary",
+					tokensBefore: event.result.tokensBefore,
+					summary: event.result.summary,
+					timestamp: Date.now(),
+				});
+				host.footer.invalidate();
+			} else if (event.errorMessage) {
+				host.chatContainer.addChild(new Spacer(1));
+				host.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
+			}
+			void host.flushCompactionQueue({ willRetry: event.willRetry });
+			host.ui.requestRender();
+			break;
+
+		case "auto_retry_start":
+			host.retryEscapeHandler = host.defaultEditor.onEscape;
+			host.defaultEditor.onEscape = () => host.session.abortRetry();
+			host.statusContainer.clear();
+			host.retryLoader = new Loader(
+				host.ui,
+				(spinner) => theme.fg("warning", spinner),
+				(text) => theme.fg("muted", text),
+				`Retrying (${event.attempt}/${event.maxAttempts}) in ${Math.round(event.delayMs / 1000)}s... (${appKey(host.keybindings, "interrupt")} to cancel)`,
+			);
+			host.statusContainer.addChild(host.retryLoader);
+			host.ui.requestRender();
+			break;
+
+		case "auto_retry_end":
+			if (host.retryEscapeHandler) {
+				host.defaultEditor.onEscape = host.retryEscapeHandler;
+				host.retryEscapeHandler = undefined;
+			}
+			if (host.retryLoader) {
+				host.retryLoader.stop();
+				host.retryLoader = undefined;
+				host.statusContainer.clear();
+			}
+			if (!event.success) {
+				host.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
+			}
+			host.ui.requestRender();
+			break;
+
+		case "fallback_provider_switch":
+			host.showStatus(`Switched from ${event.from} → ${event.to} (${event.reason})`);
+			host.ui.requestRender();
+			break;
+
+		case "fallback_provider_restored":
+			host.showStatus(`Restored to ${event.provider}`);
+			host.ui.requestRender();
+			break;
+
+		case "fallback_chain_exhausted":
+			host.showError(event.reason);
+			host.ui.requestRender();
+			break;
+	}
+}

package/packages/pi-coding-agent/src/modes/interactive/controllers/extension-ui-controller.ts

@@ -0,0 +1,59 @@
+import type { ExtensionUIContext } from "../../../core/extensions/index.js";
+
+import { Theme, getAvailableThemesWithPaths, getThemeByName, setTheme, setThemeInstance, theme } from "../theme/theme.js";
+import { appKey } from "../components/keybinding-hints.js";
+
+export function createExtensionUIContext(host: any): ExtensionUIContext {
+	return {
+		select: (title, options, opts) => host.showExtensionSelector(title, options, opts),
+		confirm: (title, message, opts) => host.showExtensionConfirm(title, message, opts),
+		input: (title, placeholder, opts) => host.showExtensionInput(title, placeholder, opts),
+		notify: (message, type) => host.showExtensionNotify(message, type),
+		onTerminalInput: (handler) => host.addExtensionTerminalInputListener(handler),
+		setStatus: (key, text) => host.setExtensionStatus(key, text),
+		setWorkingMessage: (message) => {
+			if (host.loadingAnimation) {
+				if (message) {
+					host.loadingAnimation.setMessage(message);
+				} else {
+					host.loadingAnimation.setMessage(`${host.defaultWorkingMessage} (${appKey(host.keybindings, "interrupt")} to interrupt)`);
+				}
+			} else {
+				host.pendingWorkingMessage = message;
+			}
+		},
+		setWidget: (key, content, options) => host.setExtensionWidget(key, content, options),
+		setFooter: (factory) => host.setExtensionFooter(factory),
+		setHeader: (factory) => host.setExtensionHeader(factory),
+		setTitle: (title) => host.ui.terminal.setTitle(title),
+		custom: (factory, options) => host.showExtensionCustom(factory, options),
+		pasteToEditor: (text) => host.editor.handleInput(`\x1b[200~${text}\x1b[201~`),
+		setEditorText: (text) => host.editor.setText(text),
+		getEditorText: () => host.editor.getText(),
+		editor: (title, prefill) => host.showExtensionEditor(title, prefill),
+		setEditorComponent: (factory) => host.setCustomEditorComponent(factory),
+		get theme() {
+			return theme;
+		},
+		getAllThemes: () => getAvailableThemesWithPaths(),
+		getTheme: (name) => getThemeByName(name),
+		setTheme: (themeOrName) => {
+			if (themeOrName instanceof Theme) {
+				setThemeInstance(themeOrName);
+				host.ui.requestRender();
+				return { success: true };
+			}
+			const result = setTheme(themeOrName, true);
+			if (result.success) {
+				if (host.settingsManager.getTheme() !== themeOrName) {
+					host.settingsManager.setTheme(themeOrName);
+				}
+				host.ui.requestRender();
+			}
+			return result;
+		},
+		getToolsExpanded: () => host.toolOutputExpanded,
+		setToolsExpanded: (expanded) => host.setToolsExpanded(expanded),
+	};
+}
+