@oh-my-pi/pi-coding-agent 13.19.0 → 14.0.2

package/src/modes/rpc/host-tools.ts

@@ -0,0 +1,186 @@
+import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { Snowflake } from "@oh-my-pi/pi-utils";
+import type { Static, TSchema } from "@sinclair/typebox";
+import { applyToolProxy } from "../../extensibility/tool-proxy";
+import type { Theme } from "../../modes/theme/theme";
+import type {
+	RpcHostToolCallRequest,
+	RpcHostToolCancelRequest,
+	RpcHostToolDefinition,
+	RpcHostToolResult,
+	RpcHostToolUpdate,
+} from "./rpc-types";
+
+type RpcHostToolOutput = (frame: RpcHostToolCallRequest | RpcHostToolCancelRequest) => void;
+
+type PendingHostToolCall = {
+	resolve: (result: AgentToolResult<unknown>) => void;
+	reject: (error: Error) => void;
+	onUpdate?: AgentToolUpdateCallback<unknown>;
+};
+
+function isAgentToolResult(value: unknown): value is AgentToolResult<unknown> {
+	if (!value || typeof value !== "object") return false;
+	const content = (value as { content?: unknown }).content;
+	return Array.isArray(content);
+}
+
+export function isRpcHostToolResult(value: unknown): value is RpcHostToolResult {
+	if (!value || typeof value !== "object") return false;
+	const frame = value as { type?: unknown; id?: unknown; result?: unknown };
+	return frame.type === "host_tool_result" && typeof frame.id === "string" && isAgentToolResult(frame.result);
+}
+
+export function isRpcHostToolUpdate(value: unknown): value is RpcHostToolUpdate {
+	if (!value || typeof value !== "object") return false;
+	const frame = value as { type?: unknown; id?: unknown; partialResult?: unknown };
+	return frame.type === "host_tool_update" && typeof frame.id === "string" && isAgentToolResult(frame.partialResult);
+}
+
+class RpcHostToolAdapter<TParams extends TSchema = TSchema, TTheme extends Theme = Theme>
+	implements AgentTool<TParams, unknown, TTheme>
+{
+	declare name: string;
+	declare label: string;
+	declare description: string;
+	declare parameters: TParams;
+	readonly strict = true;
+	concurrency: "shared" | "exclusive" = "shared";
+	#bridge: RpcHostToolBridge;
+	#definition: RpcHostToolDefinition;
+
+	constructor(definition: RpcHostToolDefinition, bridge: RpcHostToolBridge) {
+		this.#definition = definition;
+		this.#bridge = bridge;
+		applyToolProxy(definition, this);
+	}
+
+	execute(
+		toolCallId: string,
+		params: Static<TParams>,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<unknown>,
+	): Promise<AgentToolResult<unknown>> {
+		return this.#bridge.requestExecution(
+			this.#definition,
+			toolCallId,
+			params as Record<string, unknown>,
+			signal,
+			onUpdate,
+		);
+	}
+}
+
+export class RpcHostToolBridge {
+	#output: RpcHostToolOutput;
+	#definitions = new Map<string, RpcHostToolDefinition>();
+	#pendingCalls = new Map<string, PendingHostToolCall>();
+
+	constructor(output: RpcHostToolOutput) {
+		this.#output = output;
+	}
+
+	getToolNames(): string[] {
+		return Array.from(this.#definitions.keys());
+	}
+
+	setTools(tools: RpcHostToolDefinition[]): AgentTool[] {
+		this.#definitions = new Map(tools.map(tool => [tool.name, tool]));
+		return tools.map(tool => new RpcHostToolAdapter(tool, this));
+	}
+
+	handleResult(frame: RpcHostToolResult): boolean {
+		const pending = this.#pendingCalls.get(frame.id);
+		if (!pending) return false;
+		this.#pendingCalls.delete(frame.id);
+		if (frame.isError) {
+			const text = frame.result.content
+				.filter(
+					(item): item is { type: "text"; text: string } => item.type === "text" && typeof item.text === "string",
+				)
+				.map(item => item.text)
+				.join("\n")
+				.trim();
+			pending.reject(new Error(text || "Host tool execution failed"));
+			return true;
+		}
+		pending.resolve(frame.result);
+		return true;
+	}
+
+	handleUpdate(frame: RpcHostToolUpdate): boolean {
+		const pending = this.#pendingCalls.get(frame.id);
+		if (!pending) return false;
+		pending.onUpdate?.(frame.partialResult);
+		return true;
+	}
+
+	requestExecution(
+		definition: RpcHostToolDefinition,
+		toolCallId: string,
+		args: Record<string, unknown>,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<unknown>,
+	): Promise<AgentToolResult<unknown>> {
+		if (signal?.aborted) {
+			return Promise.reject(new Error(`Host tool "${definition.name}" was aborted`));
+		}
+
+		const id = Snowflake.next() as string;
+		const { promise, resolve, reject } = Promise.withResolvers<AgentToolResult<unknown>>();
+		let settled = false;
+
+		const cleanup = () => {
+			signal?.removeEventListener("abort", onAbort);
+			this.#pendingCalls.delete(id);
+		};
+
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			this.#output({
+				type: "host_tool_cancel",
+				id: Snowflake.next() as string,
+				targetId: id,
+			});
+			reject(new Error(`Host tool "${definition.name}" was aborted`));
+		};
+
+		signal?.addEventListener("abort", onAbort, { once: true });
+		this.#pendingCalls.set(id, {
+			resolve: result => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				resolve(result);
+			},
+			reject: error => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(error);
+			},
+			onUpdate,
+		});
+
+		this.#output({
+			type: "host_tool_call",
+			id,
+			toolCallId,
+			toolName: definition.name,
+			arguments: args,
+		});
+
+		return promise;
+	}
+
+	rejectAllPending(message: string): void {
+		const error = new Error(message);
+		const pendingCalls = Array.from(this.#pendingCalls.values());
+		this.#pendingCalls.clear();
+		for (const pending of pendingCalls) {
+			pending.reject(error);
+		}
+	}
+}

package/src/modes/rpc/rpc-client.ts

@@ -3,13 +3,22 @@
  *
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
-import type { AgentEvent, AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import { isRecord, ptree, readJsonl } from "@oh-my-pi/pi-utils";
 import type { BashResult } from "../../exec/bash-executor";
 import type { SessionStats } from "../../session/agent-session";
 import type { CompactionResult } from "../../session/compaction";
-import type { RpcCommand, RpcResponse, RpcSessionState } from "./rpc-types";
+import type {
+	RpcCommand,
+	RpcHostToolCallRequest,
+	RpcHostToolCancelRequest,
+	RpcHostToolDefinition,
+	RpcHostToolResult,
+	RpcHostToolUpdate,
+	RpcResponse,
+	RpcSessionState,
+} from "./rpc-types";
 
 /** Distributive Omit that works with union types */
 type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
@@ -32,12 +41,40 @@ export interface RpcClientOptions {
 	sessionDir?: string;
 	/** Additional CLI arguments */
 	args?: string[];
+	/** Custom tools owned by the embedding host and exposed over the RPC transport */
+	customTools?: RpcClientCustomTool[];
 }
 
 export type ModelInfo = Pick<Model, "provider" | "id" | "contextWindow" | "reasoning" | "thinking">;
 
 export type RpcEventListener = (event: AgentEvent) => void;
 
+export interface RpcClientToolContext<TDetails = unknown> {
+	toolCallId: string;
+	signal: AbortSignal;
+	sendUpdate(partialResult: RpcClientToolResult<TDetails>): void;
+}
+
+export type RpcClientToolResult<TDetails = unknown> = AgentToolResult<TDetails> | string;
+
+export interface RpcClientCustomTool<
+	TParams extends Record<string, unknown> = Record<string, unknown>,
+	TDetails = unknown,
+> extends Omit<RpcHostToolDefinition, "parameters"> {
+	parameters: Record<string, unknown>;
+	execute(
+		params: TParams,
+		context: RpcClientToolContext<TDetails>,
+	): Promise<RpcClientToolResult<TDetails>> | RpcClientToolResult<TDetails>;
+}
+
+export function defineRpcClientTool<
+	TParams extends Record<string, unknown> = Record<string, unknown>,
+	TDetails = unknown,
+>(tool: RpcClientCustomTool<TParams, TDetails>): RpcClientCustomTool<TParams, TDetails> {
+	return tool;
+}
+
 const agentEventTypes = new Set<AgentEvent["type"]>([
 	"agent_start",
 	"agent_end",
@@ -70,6 +107,31 @@ function isAgentEvent(value: unknown): value is AgentEvent {
 	return agentEventTypes.has(type as AgentEvent["type"]);
 }
 
+function isRpcHostToolCallRequest(value: unknown): value is RpcHostToolCallRequest {
+	if (!isRecord(value)) return false;
+	return (
+		value.type === "host_tool_call" &&
+		typeof value.id === "string" &&
+		typeof value.toolCallId === "string" &&
+		typeof value.toolName === "string" &&
+		isRecord(value.arguments)
+	);
+}
+
+function isRpcHostToolCancelRequest(value: unknown): value is RpcHostToolCancelRequest {
+	if (!isRecord(value)) return false;
+	return value.type === "host_tool_cancel" && typeof value.id === "string" && typeof value.targetId === "string";
+}
+
+function normalizeToolResult<TDetails>(result: RpcClientToolResult<TDetails>): AgentToolResult<TDetails> {
+	if (typeof result === "string") {
+		return {
+			content: [{ type: "text", text: result }],
+		};
+	}
+	return result;
+}
+
 // ============================================================================
 // RPC Client
 // ============================================================================
@@ -79,10 +141,14 @@ export class RpcClient {
 	#eventListeners: RpcEventListener[] = [];
 	#pendingRequests: Map<string, { resolve: (response: RpcResponse) => void; reject: (error: Error) => void }> =
 		new Map();
+	#customTools: RpcClientCustomTool[] = [];
+	#pendingHostToolCalls = new Map<string, { controller: AbortController }>();
 	#requestId = 0;
 	#abortController = new AbortController();
 
-	constructor(private options: RpcClientOptions = {}) {}
+	constructor(private options: RpcClientOptions = {}) {
+		this.#customTools = [...(options.customTools ?? [])];
+	}
 
 	/**
 	 * Start the RPC agent process.
@@ -162,6 +228,9 @@ export class RpcClient {
 
 		try {
 			await readyPromise;
+			if (this.#customTools.length > 0) {
+				await this.setCustomTools(this.#customTools);
+			}
 		} finally {
 			clearTimeout(readyTimeout);
 		}
@@ -177,6 +246,10 @@ export class RpcClient {
 		this.#abortController.abort();
 		this.#process = null;
 		this.#pendingRequests.clear();
+		for (const pendingCall of this.#pendingHostToolCalls.values()) {
+			pendingCall.controller.abort();
+		}
+		this.#pendingHostToolCalls.clear();
 	}
 
 	/**
@@ -434,6 +507,26 @@ export class RpcClient {
 		return this.#getData<{ messages: AgentMessage[] }>(response).messages;
 	}
 
+	/**
+	 * Replace the host-owned custom tools exposed to the RPC session.
+	 * Changes take effect before the next model call.
+	 */
+	async setCustomTools(tools: RpcClientCustomTool[]): Promise<string[]> {
+		this.#customTools = [...tools];
+		if (!this.#process) {
+			return this.#customTools.map(tool => tool.name);
+		}
+		const definitions: RpcHostToolDefinition[] = this.#customTools.map(tool => ({
+			name: tool.name,
+			label: tool.label,
+			description: tool.description,
+			parameters: tool.parameters,
+			hidden: tool.hidden,
+		}));
+		const response = await this.#send({ type: "set_host_tools", tools: definitions });
+		return this.#getData<{ toolNames: string[] }>(response).toolNames;
+	}
+
 	// =========================================================================
 	// Helpers
 	// =========================================================================
@@ -514,6 +607,16 @@ export class RpcClient {
 			}
 		}
 
+		if (isRpcHostToolCallRequest(data)) {
+			void this.#handleHostToolCall(data);
+			return;
+		}
+
+		if (isRpcHostToolCancelRequest(data)) {
+			this.#pendingHostToolCalls.get(data.targetId)?.controller.abort();
+			return;
+		}
+
 		if (!isAgentEvent(data)) return;
 
 		// Otherwise it's an event
@@ -555,21 +658,83 @@ export class RpcClient {
 			},
 		});
 
-		// Write to stdin after registering the handler
-		const stdin = this.#process!.stdin as import("bun").FileSink;
-		stdin.write(`${JSON.stringify(fullCommand)}\n`);
-		// flush() returns number | Promise<number> - handle both cases
+		this.#writeFrame(fullCommand, err => {
+			this.#pendingRequests.delete(id);
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeoutId);
+			reject(err);
+		});
+		return promise;
+	}
+
+	async #handleHostToolCall(request: RpcHostToolCallRequest): Promise<void> {
+		const tool = this.#customTools.find(candidate => candidate.name === request.toolName);
+		if (!tool) {
+			this.#writeFrame({
+				type: "host_tool_result",
+				id: request.id,
+				result: {
+					content: [{ type: "text", text: `Host tool "${request.toolName}" is not registered` }],
+					details: {},
+				},
+				isError: true,
+			} satisfies RpcHostToolResult);
+			return;
+		}
+
+		const controller = new AbortController();
+		this.#pendingHostToolCalls.set(request.id, { controller });
+
+		const sendUpdate = (partialResult: RpcClientToolResult<unknown>): void => {
+			if (controller.signal.aborted) return;
+			this.#writeFrame({
+				type: "host_tool_update",
+				id: request.id,
+				partialResult: normalizeToolResult(partialResult),
+			} satisfies RpcHostToolUpdate);
+		};
+
+		try {
+			const result = await tool.execute(request.arguments, {
+				toolCallId: request.toolCallId,
+				signal: controller.signal,
+				sendUpdate,
+			});
+			if (controller.signal.aborted) return;
+			this.#writeFrame({
+				type: "host_tool_result",
+				id: request.id,
+				result: normalizeToolResult(result),
+			} satisfies RpcHostToolResult);
+		} catch (error) {
+			if (controller.signal.aborted) return;
+			this.#writeFrame({
+				type: "host_tool_result",
+				id: request.id,
+				result: {
+					content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+					details: {},
+				},
+				isError: true,
+			} satisfies RpcHostToolResult);
+		} finally {
+			this.#pendingHostToolCalls.delete(request.id);
+		}
+	}
+
+	#writeFrame(frame: RpcCommand | RpcHostToolResult | RpcHostToolUpdate, onError?: (error: Error) => void): void {
+		if (!this.#process?.stdin) {
+			throw new Error("Client not started");
+		}
+		const stdin = this.#process.stdin as import("bun").FileSink;
+		stdin.write(`${JSON.stringify(frame)}\n`);
 		const flushResult = stdin.flush();
 		if (flushResult instanceof Promise) {
 			flushResult.catch((err: Error) => {
-				this.#pendingRequests.delete(id);
-				if (settled) return;
-				settled = true;
-				clearTimeout(timeoutId);
-				reject(err);
+				onError?.(err);
 			});
 		}
-		return promise;
 	}
 
 	#getData<T>(response: RpcResponse): T {

package/src/modes/rpc/rpc-mode.ts

@@ -10,7 +10,7 @@
  * - Events: AgentSessionEvent objects streamed as they occur
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
-import { readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
+import { $env, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
 import type {
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
@@ -18,10 +18,14 @@ import type {
 } from "../../extensibility/extensions";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
+import { isRpcHostToolResult, isRpcHostToolUpdate, RpcHostToolBridge } from "./host-tools";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
 	RpcExtensionUIResponse,
+	RpcHostToolCallRequest,
+	RpcHostToolCancelRequest,
+	RpcHostToolDefinition,
 	RpcResponse,
 	RpcSessionState,
 } from "./rpc-types";
@@ -34,7 +38,40 @@ export type PendingExtensionRequest = {
 	reject: (error: Error) => void;
 };
 
-type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | object) => void;
+type RpcOutput = (
+	obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | object,
+) => void;
+
+function normalizeHostToolDefinitions(tools: RpcHostToolDefinition[]): RpcHostToolDefinition[] {
+	return tools.map((tool, index) => {
+		const name = typeof tool.name === "string" ? tool.name.trim() : "";
+		if (!name) {
+			throw new Error(`Host tool at index ${index} must provide a non-empty name`);
+		}
+		const description = typeof tool.description === "string" ? tool.description.trim() : "";
+		if (!description) {
+			throw new Error(`Host tool "${name}" must provide a non-empty description`);
+		}
+		if (!tool.parameters || typeof tool.parameters !== "object" || Array.isArray(tool.parameters)) {
+			throw new Error(`Host tool "${name}" must provide a JSON Schema object`);
+		}
+		const label = typeof tool.label === "string" && tool.label.trim() ? tool.label.trim() : name;
+		return {
+			name,
+			label,
+			description,
+			parameters: tool.parameters,
+			hidden: tool.hidden === true,
+		};
+	});
+}
+
+function shouldEmitRpcTitles(): boolean {
+	const raw = $env.PI_RPC_EMIT_TITLE;
+	if (!raw) return false;
+	const normalized = raw.trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
 
 export function requestRpcEditor(
 	pendingRequests: Map<string, PendingExtensionRequest>,
@@ -110,6 +147,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 	const output = (obj: RpcResponse | RpcExtensionUIRequest | object) => {
 		process.stdout.write(`${JSON.stringify(obj)}\n`);
 	};
+	const emitRpcTitles = shouldEmitRpcTitles();
 
 	const success = <T extends RpcCommand["type"]>(
 		id: string | undefined,
@@ -127,6 +165,7 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 	};
 
 	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
+	const hostToolBridge = new RpcHostToolBridge(output);
 
 	// Shutdown request flag (wrapped in object to allow mutation with const)
 	const shutdownState = { requested: false };
@@ -291,7 +330,8 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		}
 
 		setTitle(title: string): void {
-			// Fire and forget - host can implement terminal title control
+			// Title updates are low-value noise for most RPC hosts; opt in via PI_RPC_EMIT_TITLE=1.
+			if (!emitRpcTitles) return;
 			this.output({
 				type: "extension_ui_request",
 				id: Snowflake.next() as string,
@@ -544,10 +584,29 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 					autoCompactionEnabled: session.autoCompactionEnabled,
 					messageCount: session.messages.length,
 					queuedMessageCount: session.queuedMessageCount,
+					todoPhases: session.getTodoPhases(),
+					systemPrompt: session.systemPrompt,
+					dumpTools: session.agent.state.tools.map(tool => ({
+						name: tool.name,
+						description: tool.description,
+						parameters: tool.parameters,
+					})),
 				};
 				return success(id, "get_state", state);
 			}
 
+			case "set_todos": {
+				session.setTodoPhases(command.phases);
+				return success(id, "set_todos", { todoPhases: session.getTodoPhases() });
+			}
+
+			case "set_host_tools": {
+				const tools = normalizeHostToolDefinitions(command.tools);
+				const rpcTools = hostToolBridge.setTools(tools);
+				await session.refreshRpcHostTools(rpcTools);
+				return success(id, "set_host_tools", { toolNames: tools.map(tool => tool.name) });
+			}
+
 			// =================================================================
 			// Model
 			// =================================================================
@@ -738,6 +797,16 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 				continue;
 			}
 
+			if (isRpcHostToolResult(parsed)) {
+				hostToolBridge.handleResult(parsed);
+				continue;
+			}
+
+			if (isRpcHostToolUpdate(parsed)) {
+				hostToolBridge.handleUpdate(parsed);
+				continue;
+			}
+
 			// Handle regular commands
 			const command = parsed as RpcCommand;
 			const response = await handleCommand(command);
@@ -751,5 +820,6 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 	}
 
 	// stdin closed — RPC client is gone, exit cleanly
+	hostToolBridge.rejectAllPending("RPC client disconnected before host tool execution completed");
 	process.exit(0);
 }

package/src/modes/rpc/rpc-types.ts

@@ -4,11 +4,12 @@
  * Commands are sent as JSON lines on stdin.
  * Responses and events are emitted as JSON lines on stdout.
  */
-import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AgentMessage, AgentToolResult, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Effort, ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { SessionStats } from "../../session/agent-session";
 import type { CompactionResult } from "../../session/compaction";
+import type { TodoPhase } from "../../tools/todo-write";
 
 // ============================================================================
 // RPC Commands (stdin)
@@ -25,6 +26,8 @@ export type RpcCommand =
 
 	// State
 	| { id?: string; type: "get_state" }
+	| { id?: string; type: "set_todos"; phases: TodoPhase[] }
+	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
 
 	// Model
 	| { id?: string; type: "set_model"; provider: string; modelId: string }
@@ -82,6 +85,10 @@ export interface RpcSessionState {
 	autoCompactionEnabled: boolean;
 	messageCount: number;
 	queuedMessageCount: number;
+	todoPhases: TodoPhase[];
+	/** For session dump / export (plain-text parity with /dump). */
+	systemPrompt?: string;
+	dumpTools?: Array<{ name: string; description: string; parameters: unknown }>;
 }
 
 // ============================================================================
@@ -100,6 +107,8 @@ export type RpcResponse =
 
 	// State
 	| { id?: string; type: "response"; command: "get_state"; success: true; data: RpcSessionState }
+	| { id?: string; type: "response"; command: "set_todos"; success: true; data: { todoPhases: TodoPhase[] } }
+	| { id?: string; type: "response"; command: "set_host_tools"; success: true; data: { toolNames: string[] } }
 
 	// Model
 	| {
@@ -228,6 +237,49 @@ export type RpcExtensionUIRequest =
 	| { type: "extension_ui_request"; id: string; method: "setTitle"; title: string }
 	| { type: "extension_ui_request"; id: string; method: "set_editor_text"; text: string };
 
+// ============================================================================
+// Host Tool Frames (bidirectional)
+// ============================================================================
+
+export interface RpcHostToolDefinition {
+	name: string;
+	label?: string;
+	description: string;
+	parameters: Record<string, unknown>;
+	hidden?: boolean;
+}
+
+/** Emitted by the RPC server when it needs the host to execute a registered tool. */
+export interface RpcHostToolCallRequest {
+	type: "host_tool_call";
+	id: string;
+	toolCallId: string;
+	toolName: string;
+	arguments: Record<string, unknown>;
+}
+
+/** Emitted by the RPC server when a pending host tool call should be aborted. */
+export interface RpcHostToolCancelRequest {
+	type: "host_tool_cancel";
+	id: string;
+	targetId: string;
+}
+
+/** Sent by the host to stream partial tool updates back to the RPC server. */
+export interface RpcHostToolUpdate {
+	type: "host_tool_update";
+	id: string;
+	partialResult: AgentToolResult<unknown>;
+}
+
+/** Sent by the host to complete a pending tool call. */
+export interface RpcHostToolResult {
+	type: "host_tool_result";
+	id: string;
+	result: AgentToolResult<unknown>;
+	isError?: boolean;
+}
+
 // ============================================================================
 // Extension UI Commands (stdin)
 // ============================================================================