@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.2

package/src/modes/print-mode.ts

@@ -7,8 +7,9 @@
  */
 import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
 import { sanitizeText } from "@oh-my-pi/pi-natives";
-import { runExtensionCompact, runExtensionSetModel } from "../extensibility/extensions/compact-handler";
 import type { AgentSession } from "../session/agent-session";
+import { isSilentAbort } from "../session/messages";
+import { initializeExtensions } from "./runtime-init";
 
 /**
  * Options for print mode.
@@ -39,90 +40,16 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 		}
 	}
 	// Set up extensions for print mode (no UI, no command context)
-	const extensionRunner = session.extensionRunner;
-	if (extensionRunner) {
-		extensionRunner.initialize(
-			// ExtensionActions
-			{
-				sendMessage: (message, options) => {
-					session.sendCustomMessage(message, options).catch(e => {
-						process.stderr.write(`Extension sendMessage failed: ${e instanceof Error ? e.message : String(e)}\n`);
-					});
-				},
-				sendUserMessage: (content, options) => {
-					session.sendUserMessage(content, options).catch(e => {
-						process.stderr.write(
-							`Extension sendUserMessage failed: ${e instanceof Error ? e.message : String(e)}\n`,
-						);
-					});
-				},
-				appendEntry: (customType, data) => {
-					session.sessionManager.appendCustomEntry(customType, data);
-				},
-				setLabel: (targetId, label) => {
-					session.sessionManager.appendLabelChange(targetId, label);
-				},
-				getActiveTools: () => session.getActiveToolNames(),
-				getAllTools: () => session.getAllToolNames(),
-				setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
-				getCommands: () => [],
-				setModel: model => runExtensionSetModel(session, model),
-				getThinkingLevel: () => session.thinkingLevel,
-				setThinkingLevel: level => session.setThinkingLevel(level),
-				getSessionName: () => session.sessionManager.getSessionName(),
-				setSessionName: async name => {
-					await session.sessionManager.setSessionName(name, "user");
-				},
-			},
-			// ExtensionContextActions
-			{
-				getModel: () => session.model,
-				isIdle: () => !session.isStreaming,
-				abort: () => session.abort(),
-				hasPendingMessages: () => session.queuedMessageCount > 0,
-				shutdown: () => {},
-				getContextUsage: () => session.getContextUsage(),
-				getSystemPrompt: () => session.systemPrompt,
-				compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
-			},
-			// ExtensionCommandContextActions - commands invokable via prompt("/command")
-			{
-				getContextUsage: () => session.getContextUsage(),
-				waitForIdle: () => session.agent.waitForIdle(),
-				newSession: async options => {
-					const success = await session.newSession({ parentSession: options?.parentSession });
-					if (success && options?.setup) {
-						await options.setup(session.sessionManager);
-					}
-					return { cancelled: !success };
-				},
-				branch: async entryId => {
-					const result = await session.branch(entryId);
-					return { cancelled: result.cancelled };
-				},
-				navigateTree: async (targetId, options) => {
-					const result = await session.navigateTree(targetId, { summarize: options?.summarize });
-					return { cancelled: result.cancelled };
-				},
-				switchSession: async sessionPath => {
-					const success = await session.switchSession(sessionPath);
-					return { cancelled: !success };
-				},
-				reload: async () => {
-					await session.reload();
-				},
-				compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
-			},
-			// No UI context
-		);
-		extensionRunner.onError(err => {
+	await initializeExtensions(session, {
+		reportSendError: (action, err) => {
+			process.stderr.write(
+				`Extension ${action === "extension_send" ? "sendMessage" : "sendUserMessage"} failed: ${err.message}\n`,
+			);
+		},
+		reportRuntimeError: err => {
 			process.stderr.write(`Extension error (${err.extensionPath}): ${err.error}\n`);
-		});
-		// Emit session_start event
-		await extensionRunner.emit({
-			type: "session_start",
-		});
-	}
+		},
+	});
 
 	// Always subscribe to enable session persistence via _handleAgentEvent
 	session.subscribe(event => {
@@ -150,8 +77,11 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 		if (lastMessage?.role === "assistant") {
 			const assistantMsg = lastMessage as AssistantMessage;
 
-			// Check for error/aborted
-			if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+			// Check for error/aborted — skip silent-abort (plan-mode compaction transition)
+			if (
+				(assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") &&
+				!isSilentAbort(assistantMsg.errorMessage)
+			) {
 				const errorLine = sanitizeText(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`);
 				const flushed = process.stderr.write(`${errorLine}\n`);
 				if (flushed) {

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

@@ -0,0 +1,235 @@
+import { Snowflake } from "@oh-my-pi/pi-utils";
+import { InternalUrlRouter } from "../../internal-urls";
+import type {
+	InternalResource,
+	InternalUrl,
+	ProtocolHandler,
+	ResolveContext,
+	WriteContext,
+} from "../../internal-urls/types";
+import type {
+	RpcHostUriCancelRequest,
+	RpcHostUriRequest,
+	RpcHostUriResult,
+	RpcHostUriSchemeDefinition,
+} from "./rpc-types";
+
+type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
+
+type PendingUriRequest = {
+	operation: "read" | "write";
+	url: string;
+	resolve: (frame: RpcHostUriResult) => void;
+	reject: (error: Error) => void;
+};
+
+/** Type guard for inbound `host_uri_result` frames coming from the host. */
+export function isRpcHostUriResult(value: unknown): value is RpcHostUriResult {
+	if (!value || typeof value !== "object") return false;
+	const frame = value as { type?: unknown; id?: unknown };
+	return frame.type === "host_uri_result" && typeof frame.id === "string";
+}
+
+/**
+ * One handler instance per host-registered scheme. Delegates reads and (when
+ * the scheme was registered as writable) writes to the bridge, which serializes
+ * them over the RPC transport.
+ */
+class RpcHostUriProtocolHandler implements ProtocolHandler {
+	readonly scheme: string;
+	readonly immutable: boolean;
+	readonly write?: (url: InternalUrl, content: string, context?: WriteContext) => Promise<void>;
+	readonly #bridge: RpcHostUriBridge;
+
+	constructor(definition: RpcHostUriSchemeDefinition, bridge: RpcHostUriBridge) {
+		this.scheme = definition.scheme;
+		this.immutable = definition.immutable === true;
+		this.#bridge = bridge;
+		if (definition.writable === true) {
+			this.write = (url, content, context) => this.#bridge.requestWrite(this.scheme, url, content, context);
+		}
+	}
+
+	resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		return this.#bridge.requestRead(this.scheme, url, context);
+	}
+}
+
+/**
+ * Bidirectional bridge that lets the RPC host own a set of URI schemes.
+ *
+ * The host registers schemes via `set_host_uri_schemes`; the bridge installs
+ * a `RpcHostUriProtocolHandler` per scheme into the process-global
+ * {@link InternalUrlRouter}. Reads land on the read tool through the existing
+ * router; writes are intercepted by the write tool and dispatched through
+ * `requestWrite`.
+ */
+export class RpcHostUriBridge {
+	#output: RpcHostUriOutput;
+	#router: InternalUrlRouter;
+	#definitions = new Map<string, RpcHostUriSchemeDefinition>();
+	#pending = new Map<string, PendingUriRequest>();
+
+	constructor(output: RpcHostUriOutput, router: InternalUrlRouter = InternalUrlRouter.instance()) {
+		this.#output = output;
+		this.#router = router;
+	}
+
+	getSchemes(): string[] {
+		return Array.from(this.#definitions.keys());
+	}
+
+	/**
+	 * Replace the registered set of host URI schemes. Previously registered
+	 * schemes that no longer appear in the new set are unregistered from the
+	 * router; surviving and new schemes get fresh handler instances.
+	 */
+	setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[] {
+		const normalized = new Map<string, RpcHostUriSchemeDefinition>();
+		for (const raw of schemes) {
+			const scheme = typeof raw?.scheme === "string" ? raw.scheme.trim().toLowerCase() : "";
+			if (!scheme) {
+				throw new Error("Host URI scheme must be a non-empty string");
+			}
+			if (!/^[a-z][a-z0-9+.-]*$/.test(scheme)) {
+				throw new Error(`Host URI scheme contains invalid characters: ${raw.scheme}`);
+			}
+			normalized.set(scheme, {
+				scheme,
+				description: typeof raw.description === "string" ? raw.description : undefined,
+				writable: raw.writable === true,
+				immutable: raw.immutable === true,
+			});
+		}
+
+		for (const previous of this.#definitions.keys()) {
+			if (!normalized.has(previous)) {
+				this.#router.unregister(previous);
+			}
+		}
+		for (const definition of normalized.values()) {
+			this.#router.register(new RpcHostUriProtocolHandler(definition, this));
+		}
+		this.#definitions = normalized;
+		return Array.from(normalized.keys());
+	}
+
+	/**
+	 * Unregister every host scheme from the router and reject any in-flight
+	 * requests. Called on RPC shutdown to keep the global router clean for
+	 * subsequent sessions in the same process (used by tests).
+	 */
+	clear(message: string = "Host URI bridge shut down"): void {
+		for (const scheme of this.#definitions.keys()) {
+			this.#router.unregister(scheme);
+		}
+		this.#definitions.clear();
+		this.rejectAllPending(message);
+	}
+
+	/** Resolve a pending request by id; called by `rpc-mode` on inbound results. */
+	handleResult(frame: RpcHostUriResult): boolean {
+		const pending = this.#pending.get(frame.id);
+		if (!pending) return false;
+		this.#pending.delete(frame.id);
+		pending.resolve(frame);
+		return true;
+	}
+
+	rejectAllPending(message: string): void {
+		const error = new Error(message);
+		const pending = Array.from(this.#pending.values());
+		this.#pending.clear();
+		for (const entry of pending) {
+			entry.reject(error);
+		}
+	}
+
+	async requestRead(scheme: string, url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		const result = await this.#dispatch("read", url.href, undefined, context?.signal);
+		if (result.isError) {
+			throw new Error(result.error || result.content || `Host URI read failed for ${url.href}`);
+		}
+		const content = result.content ?? "";
+		const contentType = result.contentType ?? "text/plain";
+		const definition = this.#definitions.get(scheme);
+		return {
+			url: url.href,
+			content,
+			contentType,
+			size: Buffer.byteLength(content, "utf-8"),
+			notes: result.notes && result.notes.length > 0 ? [...result.notes] : undefined,
+			immutable: result.immutable ?? definition?.immutable === true,
+		};
+	}
+
+	async requestWrite(_scheme: string, url: InternalUrl, content: string, context?: WriteContext): Promise<void> {
+		const result = await this.#dispatch("write", url.href, content, context?.signal);
+		if (result.isError) {
+			throw new Error(result.error || result.content || `Host URI write failed for ${url.href}`);
+		}
+	}
+
+	#dispatch(
+		operation: "read" | "write",
+		url: string,
+		content: string | undefined,
+		signal: AbortSignal | undefined,
+	): Promise<RpcHostUriResult> {
+		if (signal?.aborted) {
+			return Promise.reject(new Error(`Host URI ${operation} for ${url} was aborted`));
+		}
+
+		const id = Snowflake.next() as string;
+		const { promise, resolve, reject } = Promise.withResolvers<RpcHostUriResult>();
+		let settled = false;
+
+		const cleanup = () => {
+			signal?.removeEventListener("abort", onAbort);
+			this.#pending.delete(id);
+		};
+
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			this.#output({
+				type: "host_uri_cancel",
+				id: Snowflake.next() as string,
+				targetId: id,
+			});
+			reject(new Error(`Host URI ${operation} for ${url} was aborted`));
+		};
+
+		signal?.addEventListener("abort", onAbort, { once: true });
+		this.#pending.set(id, {
+			operation,
+			url,
+			resolve: frame => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				resolve(frame);
+			},
+			reject: err => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(err);
+			},
+		});
+
+		const frame: RpcHostUriRequest = {
+			type: "host_uri_request",
+			id,
+			operation,
+			url,
+		};
+		if (operation === "write") {
+			frame.content = content ?? "";
+		}
+		this.#output(frame);
+
+		return promise;
+	}
+}

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

@@ -17,10 +17,11 @@ import type {
 	ExtensionUIDialogOptions,
 	ExtensionWidgetOptions,
 } from "../../extensibility/extensions";
-import { runExtensionCompact, runExtensionSetModel } from "../../extensibility/extensions/compact-handler";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
+import { initializeExtensions } from "../runtime-init";
 import { isRpcHostToolResult, isRpcHostToolUpdate, RpcHostToolBridge } from "./host-tools";
+import { isRpcHostUriResult, RpcHostUriBridge } from "./host-uris";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
@@ -28,6 +29,8 @@ import type {
 	RpcHostToolCallRequest,
 	RpcHostToolCancelRequest,
 	RpcHostToolDefinition,
+	RpcHostUriCancelRequest,
+	RpcHostUriRequest,
 	RpcResponse,
 	RpcSessionState,
 } from "./rpc-types";
@@ -41,7 +44,14 @@ export type PendingExtensionRequest = {
 };
 
 type RpcOutput = (
-	obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | object,
+	obj:
+		| RpcResponse
+		| RpcExtensionUIRequest
+		| RpcHostToolCallRequest
+		| RpcHostToolCancelRequest
+		| RpcHostUriRequest
+		| RpcHostUriCancelRequest
+		| object,
 ) => void;
 
 function normalizeHostToolDefinitions(tools: RpcHostToolDefinition[]): RpcHostToolDefinition[] {
@@ -188,6 +198,7 @@ export async function runRpcMode(
 
 	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
 	const hostToolBridge = new RpcHostToolBridge(output);
+	const hostUriBridge = new RpcHostUriBridge(output);
 
 	// Shutdown request flag (wrapped in object to allow mutation with const)
 	const shutdownState = { requested: false };
@@ -421,91 +432,18 @@ export async function runRpcMode(
 	setToolUIContext?.(rpcUiContext, true);
 
 	// Set up extensions with RPC-based UI context
-	const extensionRunner = session.extensionRunner;
-	if (extensionRunner) {
-		extensionRunner.initialize(
-			// ExtensionActions
-			{
-				sendMessage: (message, options) => {
-					session.sendCustomMessage(message, options).catch(e => {
-						output(error(undefined, "extension_send", e.message));
-					});
-				},
-				sendUserMessage: (content, options) => {
-					session.sendUserMessage(content, options).catch(e => {
-						output(error(undefined, "extension_send_user", e.message));
-					});
-				},
-				appendEntry: (customType, data) => {
-					session.sessionManager.appendCustomEntry(customType, data);
-				},
-				setLabel: (targetId, label) => {
-					session.sessionManager.appendLabelChange(targetId, label);
-				},
-				getActiveTools: () => session.getActiveToolNames(),
-				getAllTools: () => session.getAllToolNames(),
-				setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
-				getCommands: () => [],
-				setModel: model => runExtensionSetModel(session, model),
-				getThinkingLevel: () => session.thinkingLevel,
-				setThinkingLevel: level => session.setThinkingLevel(level),
-				getSessionName: () => session.sessionManager.getSessionName(),
-				setSessionName: async name => {
-					await session.sessionManager.setSessionName(name, "user");
-				},
-			},
-			// ExtensionContextActions
-			{
-				getModel: () => session.agent.state.model,
-				isIdle: () => !session.isStreaming,
-				abort: () => session.abort(),
-				hasPendingMessages: () => session.queuedMessageCount > 0,
-				shutdown: () => {
-					shutdownState.requested = true;
-				},
-				getContextUsage: () => session.getContextUsage(),
-				getSystemPrompt: () => session.systemPrompt,
-				compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
-			},
-			// ExtensionCommandContextActions - commands invokable via prompt("/command")
-			{
-				getContextUsage: () => session.getContextUsage(),
-				waitForIdle: () => session.agent.waitForIdle(),
-				newSession: async options => {
-					const success = await session.newSession({ parentSession: options?.parentSession });
-					// Note: setup callback runs but no UI feedback in RPC mode
-					if (success && options?.setup) {
-						await options.setup(session.sessionManager);
-					}
-					return { cancelled: !success };
-				},
-				branch: async entryId => {
-					const result = await session.branch(entryId);
-					return { cancelled: result.cancelled };
-				},
-				navigateTree: async (targetId, options) => {
-					const result = await session.navigateTree(targetId, { summarize: options?.summarize });
-					return { cancelled: result.cancelled };
-				},
-				switchSession: async sessionPath => {
-					const success = await session.switchSession(sessionPath);
-					return { cancelled: !success };
-				},
-				reload: async () => {
-					await session.reload();
-				},
-				compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
-			},
-			rpcUiContext,
-		);
-		extensionRunner.onError(err => {
+	await initializeExtensions(session, {
+		reportSendError: (action, err) => {
+			output(error(undefined, action, err.message));
+		},
+		reportRuntimeError: err => {
 			output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
-		});
-		// Emit session_start event
-		await extensionRunner.emit({
-			type: "session_start",
-		});
-	}
+		},
+		onShutdown: () => {
+			shutdownState.requested = true;
+		},
+		uiContext: rpcUiContext,
+	});
 
 	// Output all agent events as JSON
 	session.subscribe(event => {
@@ -606,6 +544,15 @@ export async function runRpcMode(
 				return success(id, "set_host_tools", { toolNames: tools.map(tool => tool.name) });
 			}
 
+			case "set_host_uri_schemes": {
+				try {
+					const schemes = hostUriBridge.setSchemes(command.schemes);
+					return success(id, "set_host_uri_schemes", { schemes });
+				} catch (err) {
+					return error(id, "set_host_uri_schemes", err instanceof Error ? err.message : String(err));
+				}
+			}
+
 			// =================================================================
 			// Model
 			// =================================================================
@@ -850,8 +797,8 @@ export async function runRpcMode(
 	async function checkShutdownRequested(): Promise<void> {
 		if (!shutdownState.requested) return;
 
-		if (extensionRunner?.hasHandlers("session_shutdown")) {
-			await extensionRunner.emit({ type: "session_shutdown" });
+		if (session.extensionRunner?.hasHandlers("session_shutdown")) {
+			await session.extensionRunner.emit({ type: "session_shutdown" });
 		}
 
 		process.exit(0);
@@ -880,6 +827,11 @@ export async function runRpcMode(
 				continue;
 			}
 
+			if (isRpcHostUriResult(parsed)) {
+				hostUriBridge.handleResult(parsed);
+				continue;
+			}
+
 			// Handle regular commands
 			const command = parsed as RpcCommand;
 			const response = await handleCommand(command);
@@ -894,5 +846,6 @@ export async function runRpcMode(
 
 	// stdin closed — RPC client is gone, exit cleanly
 	hostToolBridge.rejectAllPending("RPC client disconnected before host tool execution completed");
+	hostUriBridge.clear("RPC client disconnected before host URI request completed");
 	process.exit(0);
 }

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

@@ -29,6 +29,7 @@ export type RpcCommand =
 	| { id?: string; type: "get_state" }
 	| { id?: string; type: "set_todos"; phases: TodoPhase[] }
 	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
+	| { id?: string; type: "set_host_uri_schemes"; schemes: RpcHostUriSchemeDefinition[] }
 
 	// Model
 	| { id?: string; type: "set_model"; provider: string; modelId: string }
@@ -121,6 +122,7 @@ export type RpcResponse =
 	| { 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[] } }
+	| { id?: string; type: "response"; command: "set_host_uri_schemes"; success: true; data: { schemes: string[] } }
 
 	// Model
 	| {
@@ -304,6 +306,61 @@ export interface RpcHostToolResult {
 	isError?: boolean;
 }
 
+// ============================================================================
+// Host URI Frames (bidirectional)
+// ============================================================================
+
+export interface RpcHostUriSchemeDefinition {
+	/** URL scheme without trailing `://` (e.g. `db`, `notion`). */
+	scheme: string;
+	/** Optional human-readable description for logs/diagnostics. */
+	description?: string;
+	/** When true, the write tool is allowed to dispatch writes to this scheme. */
+	writable?: boolean;
+	/** When true, downstream callers suppress hashline anchors for resolved content. */
+	immutable?: boolean;
+}
+
+export type RpcHostUriOperation = "read" | "write";
+
+/** Emitted by the RPC server when it needs the host to satisfy a URI operation. */
+export interface RpcHostUriRequest {
+	type: "host_uri_request";
+	id: string;
+	operation: RpcHostUriOperation;
+	url: string;
+	/** Present for write operations. */
+	content?: string;
+}
+
+/** Emitted by the RPC server when a pending URI request should be aborted. */
+export interface RpcHostUriCancelRequest {
+	type: "host_uri_cancel";
+	id: string;
+	targetId: string;
+}
+
+/** Sent by the host to complete a pending URI request. */
+export interface RpcHostUriResult {
+	type: "host_uri_result";
+	id: string;
+	/**
+	 * Required for successful `read` results. Ignored for `write` success.
+	 * Set on errors when a textual explanation accompanies `isError`.
+	 */
+	content?: string;
+	/** Defaults to `text/plain` when omitted. */
+	contentType?: "text/markdown" | "application/json" | "text/plain";
+	/** Optional resolution notes propagated to the read tool. */
+	notes?: string[];
+	/** Overrides the scheme-level `immutable` flag for this single resolution. */
+	immutable?: boolean;
+	/** When true, surface the result content as an error to the caller. */
+	isError?: boolean;
+	/** Optional error message; preferred over `content` for error surfacing. */
+	error?: string;
+}
+
 // ============================================================================
 // Extension UI Commands (stdin)
 // ============================================================================