@oh-my-pi/pi-utils 17.2.9 → 17.2.10

package/dist/types/turndown/gfm.d.ts

@@ -0,0 +1,11 @@
+import type { TurndownPlugin } from "./types.js";
+/** Install GitHub fenced code blocks selected by `highlight-source-*` wrappers. */
+export declare const highlightedCodeBlock: TurndownPlugin;
+/** Install GFM strikethrough conversion. */
+export declare const strikethrough: TurndownPlugin;
+/** Install GFM task-list checkbox conversion. */
+export declare const taskListItems: TurndownPlugin;
+/** Install GFM table conversion for tables with a heading row. */
+export declare const tables: TurndownPlugin;
+/** Install every GFM rule used by the coding agent. */
+export declare const gfm: TurndownPlugin;

package/dist/types/turndown/html.d.ts

@@ -0,0 +1,5 @@
+import type { TurndownNode } from "./types.js";
+/** Parse an HTML fragment into the small DOM subset needed by Turndown. */
+export declare function parseHtmlFragment(html: string): TurndownNode;
+/** Serialize a standards-shaped or internal HTML node. */
+export declare function serializeNode(node: TurndownNode): string;

package/dist/types/turndown/service.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedTurndownOptions, RuleFilter, TurndownNode, TurndownOptions, TurndownPlugin, TurndownRule } from "./types.js";
+/** Convert HTML fragments to Markdown with extensible Turndown-compatible rules. */
+export default class TurndownService {
+    #private;
+    readonly options: ResolvedTurndownOptions;
+    constructor(options?: TurndownOptions);
+    /** Install a highest-priority named conversion rule. */
+    addRule(key: string, rule: TurndownRule): this;
+    /** Preserve matching elements as HTML when no custom rule handles them. */
+    keep(filter: RuleFilter): this;
+    /** Drop matching elements and all of their converted content. */
+    remove(filter: RuleFilter): this;
+    /** Install one plugin or an ordered list of plugins. */
+    use(plugin: TurndownPlugin | readonly TurndownPlugin[]): this;
+    /** Escape Markdown punctuation using Turndown's public escaping rules. */
+    escape(text: string): string;
+    /** Convert an HTML string or standards-shaped DOM node to Markdown. */
+    turndown(input: string | TurndownNode): string;
+    /** Convert only a node's children within the active conversion. */
+    convertChildren(node: TurndownNode): string;
+}

package/dist/types/turndown/types.d.ts

@@ -0,0 +1,70 @@
+/** Behavior-compatible reimplementation of turndown's used surface. */
+/** A DOM-shaped node accepted by conversion rules. */
+export interface TurndownNode {
+    readonly nodeType: number;
+    readonly nodeName: string;
+    readonly parentNode: TurndownNode | null;
+    readonly childNodes: ArrayLike<TurndownNode>;
+    readonly children: ArrayLike<TurndownNode>;
+    readonly firstChild: TurndownNode | null;
+    readonly lastChild: TurndownNode | null;
+    readonly nextSibling: TurndownNode | null;
+    readonly previousSibling: TurndownNode | null;
+    readonly textContent: string | null;
+    readonly outerHTML?: string;
+    getAttribute(name: string): string | null;
+    hasAttribute(name: string): boolean;
+}
+/** Options supported by the HTML-to-Markdown converter. */
+export interface TurndownOptions {
+    headingStyle?: "setext" | "atx";
+    hr?: string;
+    bulletListMarker?: "*" | "-" | "+";
+    codeBlockStyle?: "indented" | "fenced";
+    fence?: string;
+    emDelimiter?: "_" | "*";
+    strongDelimiter?: "**" | "__";
+    linkStyle?: "inlined" | "referenced";
+    linkReferenceStyle?: "full" | "collapsed" | "shortcut";
+    preformattedCode?: boolean;
+    blankReplacement?: ReplacementFunction;
+    keepReplacement?: ReplacementFunction;
+    defaultReplacement?: ReplacementFunction;
+}
+/** Fully resolved options passed to replacement callbacks. */
+export interface ResolvedTurndownOptions {
+    headingStyle: "setext" | "atx";
+    hr: string;
+    bulletListMarker: "*" | "-" | "+";
+    codeBlockStyle: "indented" | "fenced";
+    fence: string;
+    emDelimiter: "_" | "*";
+    strongDelimiter: "**" | "__";
+    linkStyle: "inlined" | "referenced";
+    linkReferenceStyle: "full" | "collapsed" | "shortcut";
+    preformattedCode: boolean;
+    blankReplacement?: ReplacementFunction;
+    keepReplacement?: ReplacementFunction;
+    defaultReplacement?: ReplacementFunction;
+}
+/** A tag name, list of tag names, or predicate selecting nodes for a rule. */
+export type RuleFilter = string | readonly string[] | ((node: TurndownNode, options: ResolvedTurndownOptions) => boolean);
+/** Produces Markdown for a matched node and its already-converted children. */
+export type ReplacementFunction = (content: string, node: TurndownNode, options: ResolvedTurndownOptions) => string;
+/** A named conversion rule accepted by `addRule`. */
+export interface TurndownRule {
+    filter: RuleFilter;
+    replacement: ReplacementFunction;
+}
+/** A plugin that installs one or more conversion rules. */
+export type TurndownPlugin = (service: TurndownServiceLike) => void;
+/** Structural service surface available to plugins. */
+export interface TurndownServiceLike {
+    readonly options: ResolvedTurndownOptions;
+    addRule(key: string, rule: TurndownRule): this;
+    convertChildren(node: TurndownNode): string;
+    keep(filter: RuleFilter): this;
+    remove(filter: RuleFilter): this;
+    turndown(input: string | TurndownNode): string;
+    escape(text: string): string;
+}

package/dist/types/turndown.d.ts

@@ -0,0 +1,4 @@
+/** Behavior-compatible reimplementation of turndown's used surface. */
+export * from "./turndown/gfm.js";
+export { default, default as TurndownService } from "./turndown/service.js";
+export * from "./turndown/types.js";

package/dist/types/vterm/buffer.d.ts

@@ -0,0 +1,99 @@
+/** Cell rendition tracked by the virtual terminal. */
+export interface CellAttributes {
+    bold: boolean;
+    dim: boolean;
+    italic: boolean;
+    underline: boolean;
+    inverse: boolean;
+    strikethrough: boolean;
+    overline: boolean;
+    fgMode: 0 | 1 | 2;
+    fg: number;
+    bgMode: 0 | 1 | 2;
+    bg: number;
+}
+/** A mutable terminal grid cell. */
+export interface CellData {
+    chars: string;
+    width: number;
+    attrs: CellAttributes;
+}
+/** Creates the default rendition. */
+export declare function defaultAttributes(): CellAttributes;
+/** Creates an empty cell with the supplied rendition. */
+export declare function blankCell(attrs?: CellAttributes): CellData;
+/** Proposed xterm-compatible cell readback object. */
+export declare class BufferCell {
+    #private;
+    /** Reuses this object for another grid cell. */
+    setFrom(cell: CellData): this;
+    /** Returns the grapheme stored in this cell. */
+    getChars(): string;
+    /** Returns the cell width, with zero denoting a wide-cell continuation. */
+    getWidth(): number;
+    /** Returns the packed foreground palette index or RGB value. */
+    getFgColor(): number;
+    /** Returns the packed background palette index or RGB value. */
+    getBgColor(): number;
+    /** Reports bold rendition. */
+    isBold(): number;
+    /** Reports dim rendition. */
+    isDim(): number;
+    /** Reports italic rendition. */
+    isItalic(): number;
+    /** Reports underline rendition. */
+    isUnderline(): number;
+    /** Reports inverse rendition. */
+    isInverse(): number;
+    /** Reports strikethrough rendition. */
+    isStrikethrough(): number;
+    /** Reports overline rendition. */
+    isOverline(): number;
+    /** Reports a true-color foreground. */
+    isFgRGB(): boolean;
+    /** Reports a true-color background. */
+    isBgRGB(): boolean;
+    /** Reports a palette foreground. */
+    isFgPalette(): boolean;
+    /** Reports a palette background. */
+    isBgPalette(): boolean;
+}
+/** One physical row in a terminal buffer. */
+export declare class BufferLine {
+    cells: CellData[];
+    isWrapped: boolean;
+    constructor(columns: number, attrs?: CellAttributes);
+    /** Number of grid columns in the line. */
+    get length(): number;
+    /** Reads a cell, optionally reusing the caller's object. */
+    getCell(column: number, cell?: BufferCell): BufferCell | undefined;
+    /** Converts a column range to text. */
+    translateToString(trimRight?: boolean, startColumn?: number, endColumn?: number): string;
+}
+/** Storage backing one terminal screen and its history. */
+export interface BufferState {
+    lines: BufferLine[];
+    baseY: number;
+    viewportY: number;
+    cursorX: number;
+    cursorY: number;
+}
+/** Public xterm-compatible view over a buffer state. */
+export declare class BufferView {
+    private readonly state;
+    constructor(state: () => BufferState);
+    /** Number of physical lines, including scrollback. */
+    get length(): number;
+    /** First row of the live screen in the full buffer. */
+    get baseY(): number;
+    /** First row currently exposed by the viewport. */
+    get viewportY(): number;
+    /** Cursor column in the live screen. */
+    get cursorX(): number;
+    /** Cursor row in the live screen. */
+    get cursorY(): number;
+    /** Reads a physical buffer line. */
+    getLine(row: number): BufferLine | undefined;
+    /** Creates a reusable empty cell readback object. */
+    getNullCell(): BufferCell;
+}

package/dist/types/vterm/terminal.d.ts

@@ -0,0 +1,44 @@
+import { BufferView } from "./buffer.js";
+/** Construction options supported by the headless virtual terminal. */
+export interface TerminalOptions {
+    cols?: number;
+    rows?: number;
+    scrollback?: number;
+    allowProposedApi?: boolean;
+    disableStdin?: boolean;
+}
+/** Disposable event subscription. */
+export interface Disposable {
+    dispose(): void;
+}
+/** Observable terminal modes used by interactive input normalization. */
+export interface TerminalModes {
+    applicationCursorKeysMode: boolean;
+}
+/** Buffer collection exposed by the virtual terminal. */
+export interface TerminalBuffers {
+    readonly active: BufferView;
+    readonly normal: BufferView;
+    readonly alternate: BufferView;
+}
+/** Behavior-compatible reimplementation of @xterm/headless's used surface. */
+export declare class Terminal {
+    #private;
+    /** Current terminal column count. */
+    cols: number;
+    /** Current terminal row count. */
+    rows: number;
+    /** Normal, alternate, and active buffer views. */
+    readonly buffer: TerminalBuffers;
+    /** Currently active input modes. */
+    readonly modes: TerminalModes;
+    constructor(options?: TerminalOptions);
+    /** Parses terminal output and invokes the callback after the write is committed. */
+    write(data: string | Uint8Array, callback?: () => void): void;
+    /** Changes the terminal grid and reflows wrapped normal-buffer lines. */
+    resize(columns: number, rows: number): void;
+    /** Subscribes to terminal-generated input replies. */
+    onData(listener: (data: string) => void): Disposable;
+    /** Releases parser state and event listeners. */
+    dispose(): void;
+}

package/dist/types/vterm.d.ts

@@ -0,0 +1,8 @@
+/** Behavior-compatible reimplementation of @xterm/headless's used surface. */
+export * from "./vterm/buffer.js";
+export * from "./vterm/terminal.js";
+import { Terminal } from "./vterm/terminal.js";
+declare const vterm: {
+    Terminal: typeof Terminal;
+};
+export default vterm;

package/dist/types/xml.d.ts

@@ -0,0 +1,31 @@
+/** Behavior-compatible reimplementation of fast-xml-parser's used surface. */
+/** Context supplied to an array-selection callback. */
+export type XMLArraySelector = (tagName: string, jPath: string, isLeafNode: boolean, isAttribute: boolean | null) => boolean;
+/** Options supported by {@link XMLParser}. */
+export interface XMLParserOptions {
+    /** Omits attributes when true (default). */
+    ignoreAttributes?: boolean;
+    /** Prefix applied to attribute property names. */
+    attributeNamePrefix?: string;
+    /** Property used for text alongside children or attributes. */
+    textNodeName?: string;
+    /** Trims ordinary text and attribute values. */
+    trimValues?: boolean;
+    /** Coerces numeric and boolean element text. */
+    parseTagValue?: boolean;
+    /** Coerces numeric and boolean attribute values. */
+    parseAttributeValue?: boolean;
+    /** Controls entity processing and its expansion ceiling. */
+    processEntities?: boolean | {
+        maxTotalExpansions?: number;
+    };
+    /** Selects element or attribute properties that must always be arrays. */
+    isArray?: XMLArraySelector;
+}
+/** Parses XML into the object shape used by the document converters. */
+export declare class XMLParser {
+    #private;
+    constructor(options?: XMLParserOptions);
+    /** Parses one XML document. */
+    parse(xml: string): unknown;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-utils",
-	"version": "17.2.9",
+	"version": "17.2.10",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -31,10 +31,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "17.2.9",
-		"handlebars": "^4.7.9",
-		"winston": "^3.19.0",
-		"winston-daily-rotate-file": "5.0.0"
+		"@oh-my-pi/pi-natives": "17.2.10"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/acp/connection.ts

@@ -0,0 +1,344 @@
+import type {
+	Agent,
+	AuthenticateRequest,
+	AuthenticateResponse,
+	CloseSessionRequest,
+	CloseSessionResponse,
+	CompleteElicitationNotification,
+	CreateElicitationRequest,
+	CreateElicitationResponse,
+	CreateTerminalRequest,
+	ForkSessionRequest,
+	ForkSessionResponse,
+	InitializeRequest,
+	InitializeResponse,
+	ListSessionsRequest,
+	ListSessionsResponse,
+	LoadSessionRequest,
+	LoadSessionResponse,
+	MaybePromise,
+	NewSessionRequest,
+	NewSessionResponse,
+	PromptRequest,
+	PromptResponse,
+	ReadTextFileRequest,
+	ReadTextFileResponse,
+	RequestPermissionRequest,
+	RequestPermissionResponse,
+	ResumeSessionRequest,
+	ResumeSessionResponse,
+	SessionNotification,
+	SetSessionConfigOptionRequest,
+	SetSessionConfigOptionResponse,
+	SetSessionModeRequest,
+	SetSessionModeResponse,
+	TerminalActionResponse,
+	TerminalOutputResponse,
+	WaitForTerminalExitResponse,
+	WriteTextFileRequest,
+	WriteTextFileResponse,
+} from "./protocol";
+import type { Stream } from "./stream";
+import { RequestError, RpcConnection } from "./transport";
+
+/** Terminal creation response returned by a client. */
+export interface CreateTerminalResponse {
+	terminalId: string;
+}
+/** Client callbacks handled by a client-side connection. */
+export interface Client {
+	requestPermission(params: RequestPermissionRequest): MaybePromise<RequestPermissionResponse>;
+	sessionUpdate(params: SessionNotification): MaybePromise<void>;
+	readTextFile?(params: ReadTextFileRequest): MaybePromise<ReadTextFileResponse>;
+	writeTextFile?(params: WriteTextFileRequest): MaybePromise<WriteTextFileResponse | void>;
+	createTerminal?(params: CreateTerminalRequest): MaybePromise<CreateTerminalResponse>;
+	terminalOutput?(params: { sessionId: string; terminalId: string }): MaybePromise<TerminalOutputResponse>;
+	waitForTerminalExit?(params: { sessionId: string; terminalId: string }): MaybePromise<WaitForTerminalExitResponse>;
+	killTerminal?(params: { sessionId: string; terminalId: string }): MaybePromise<TerminalActionResponse | void>;
+	releaseTerminal?(params: { sessionId: string; terminalId: string }): MaybePromise<TerminalActionResponse | void>;
+	unstable_createElicitation?(params: CreateElicitationRequest): MaybePromise<CreateElicitationResponse>;
+	unstable_completeElicitation?(params: CompleteElicitationNotification): MaybePromise<void>;
+	extMethod?(method: string, params: Record<string, unknown>): MaybePromise<Record<string, unknown>>;
+	extNotification?(method: string, params: Record<string, unknown>): MaybePromise<void>;
+}
+
+/** Agent-side ACP connection. */
+export class AgentSideConnection {
+	#connection: RpcConnection;
+
+	constructor(toAgent: (connection: AgentSideConnection) => Agent, stream: Stream) {
+		let agent: Agent | undefined;
+		this.#connection = new RpcConnection(stream, async (method, params, notification) => {
+			const target = agent;
+			if (!target) throw RequestError.internalError(undefined, "Agent is not initialized");
+			return dispatchAgent(target, method, params, notification);
+		});
+		agent = toAgent(this);
+	}
+
+	/** Signal aborted when the transport closes. */
+	get signal(): AbortSignal {
+		return this.#connection.signal;
+	}
+	/** Promise resolved when the transport closes. */
+	get closed(): Promise<void> {
+		return this.#connection.closed;
+	}
+	/** Sends a session update notification. */
+	sessionUpdate(params: SessionNotification): Promise<void> {
+		return this.#connection.notify("session/update", params);
+	}
+	/** Requests permission from the client. */
+	requestPermission(params: RequestPermissionRequest): Promise<RequestPermissionResponse> {
+		return this.#connection.request("session/request_permission", params);
+	}
+	/** Reads a client-side text file. */
+	readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse> {
+		return this.#connection.request("fs/read_text_file", params);
+	}
+	/** Writes a client-side text file. */
+	writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse> {
+		return this.#connection.request("fs/write_text_file", params);
+	}
+	/** Creates a client terminal and returns its control handle. */
+	async createTerminal(params: CreateTerminalRequest): Promise<TerminalHandle> {
+		const response = await this.#connection.request<CreateTerminalResponse>("terminal/create", params);
+		return new TerminalHandle(response.terminalId, params.sessionId, this.#connection);
+	}
+	/** Creates an interactive elicitation on the client. */
+	unstable_createElicitation(params: CreateElicitationRequest): Promise<CreateElicitationResponse> {
+		return this.#connection.request("elicitation/create", params);
+	}
+	/** Notifies a client that URL elicitation completed. */
+	unstable_completeElicitation(params: CompleteElicitationNotification): Promise<void> {
+		return this.#connection.notify("elicitation/complete", params);
+	}
+	/** Sends a custom request. */
+	request<Response = unknown, Params = unknown>(method: string, params?: Params): Promise<Response> {
+		return this.#connection.request(method, params);
+	}
+	/** Sends a custom notification. */
+	notify<Params = unknown>(method: string, params?: Params): Promise<void> {
+		return this.#connection.notify(method, params);
+	}
+	/** Sends a legacy extension request. */
+	extMethod(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>> {
+		return this.request(method, params);
+	}
+	/** Sends a legacy extension notification. */
+	extNotification(method: string, params: Record<string, unknown>): Promise<void> {
+		return this.notify(method, params);
+	}
+}
+
+/** Handle for controlling a client-owned terminal. */
+export class TerminalHandle {
+	/** Client terminal identifier. */
+	readonly id: string;
+	#sessionId: string;
+	#connection: RpcConnection;
+
+	constructor(id: string, sessionId: string, connection: RpcConnection) {
+		this.id = id;
+		this.#sessionId = sessionId;
+		this.#connection = connection;
+	}
+	/** Gets current terminal output. */
+	currentOutput(): Promise<TerminalOutputResponse> {
+		return this.#connection.request("terminal/output", { sessionId: this.#sessionId, terminalId: this.id });
+	}
+	/** Waits for terminal exit. */
+	waitForExit(): Promise<WaitForTerminalExitResponse> {
+		return this.#connection.request("terminal/wait_for_exit", { sessionId: this.#sessionId, terminalId: this.id });
+	}
+	/** Kills the terminal. */
+	kill(): Promise<TerminalActionResponse> {
+		return this.#connection.request("terminal/kill", { sessionId: this.#sessionId, terminalId: this.id });
+	}
+	/** Releases the terminal. */
+	release(): Promise<TerminalActionResponse | void> {
+		return this.#connection.request("terminal/release", { sessionId: this.#sessionId, terminalId: this.id });
+	}
+	/** Releases the terminal during async disposal. */
+	async [Symbol.asyncDispose](): Promise<void> {
+		await this.release();
+	}
+}
+
+/** Client-side ACP connection used to call an agent. */
+export class ClientSideConnection {
+	#connection: RpcConnection;
+
+	constructor(toClient: (connection: ClientSideConnection) => Client, stream: Stream) {
+		let client: Client | undefined;
+		this.#connection = new RpcConnection(stream, async (method, params, notification) => {
+			const target = client;
+			if (!target) throw RequestError.internalError(undefined, "Client is not initialized");
+			return dispatchClient(target, method, params, notification);
+		});
+		client = toClient(this);
+	}
+	/** Signal aborted when the transport closes. */
+	get signal(): AbortSignal {
+		return this.#connection.signal;
+	}
+	/** Promise resolved when the transport closes. */
+	get closed(): Promise<void> {
+		return this.#connection.closed;
+	}
+	/** Initializes protocol capabilities. */
+	initialize(params: InitializeRequest): Promise<InitializeResponse> {
+		return this.#connection.request("initialize", params);
+	}
+	/** Authenticates with an agent. */
+	authenticate(params: AuthenticateRequest): Promise<AuthenticateResponse> {
+		return this.#connection.request("authenticate", params);
+	}
+	/** Creates a session. */
+	newSession(params: NewSessionRequest): Promise<NewSessionResponse> {
+		return this.#connection.request("session/new", params);
+	}
+	/** Loads a session. */
+	loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse> {
+		return this.#connection.request("session/load", params);
+	}
+	/** Lists sessions. */
+	listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse> {
+		return this.#connection.request("session/list", params);
+	}
+	/** Resumes a session. */
+	resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse> {
+		return this.#connection.request("session/resume", params);
+	}
+	/** Forks a session. */
+	unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse> {
+		return this.#connection.request("session/fork", params);
+	}
+	/** Closes a session. */
+	closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse> {
+		return this.#connection.request("session/close", params);
+	}
+	/** Sets a session mode. */
+	setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse> {
+		return this.#connection.request("session/set_mode", params);
+	}
+	/** Sets a session config option. */
+	setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse> {
+		return this.#connection.request("session/set_config_option", params);
+	}
+	/** Sends a prompt. */
+	prompt(params: PromptRequest): Promise<PromptResponse> {
+		return this.#connection.request("session/prompt", params);
+	}
+	/** Cancels an active prompt. */
+	cancel(params: { sessionId: string }): Promise<void> {
+		return this.#connection.notify("session/cancel", params);
+	}
+}
+
+async function dispatchAgent(agent: Agent, method: string, params: unknown, notification: boolean): Promise<unknown> {
+	switch (method) {
+		case "initialize":
+			return agent.initialize(params as InitializeRequest);
+		case "authenticate":
+			return invokeRequired(agent, agent.authenticate, method, params as AuthenticateRequest);
+		case "session/new":
+			return agent.newSession(params as NewSessionRequest);
+		case "session/load":
+			return invokeRequired(agent, agent.loadSession, method, params as LoadSessionRequest);
+		case "session/list":
+			return invokeRequired(agent, agent.listSessions, method, params as ListSessionsRequest);
+		case "session/resume":
+			return invokeRequired(agent, agent.resumeSession, method, params as ResumeSessionRequest);
+		case "session/fork":
+			return invokeRequired(agent, agent.unstable_forkSession, method, params as ForkSessionRequest);
+		case "session/close":
+			return invokeRequired(agent, agent.closeSession, method, params as CloseSessionRequest);
+		case "session/set_mode":
+			return invokeRequired(agent, agent.setSessionMode, method, params as SetSessionModeRequest);
+		case "session/set_config_option":
+			return invokeRequired(agent, agent.setSessionConfigOption, method, params as SetSessionConfigOptionRequest);
+		case "session/prompt":
+			return agent.prompt(params as PromptRequest);
+		case "session/cancel":
+			return agent.cancel(params as { sessionId: string });
+		default:
+			if (method === "$/cancel_request") return;
+			if (notification && agent.extNotification)
+				return agent.extNotification(method, params as Record<string, unknown>);
+			if (!notification && agent.extMethod) return agent.extMethod(method, params as Record<string, unknown>);
+			throw RequestError.methodNotFound(method);
+	}
+}
+
+async function dispatchClient(
+	client: Client,
+	method: string,
+	params: unknown,
+	notification: boolean,
+): Promise<unknown> {
+	switch (method) {
+		case "session/request_permission":
+			return client.requestPermission(params as RequestPermissionRequest);
+		case "session/update":
+			return client.sessionUpdate(params as SessionNotification);
+		case "fs/read_text_file":
+			return invokeRequired(client, client.readTextFile, method, params as ReadTextFileRequest);
+		case "fs/write_text_file":
+			return invokeRequired(client, client.writeTextFile, method, params as WriteTextFileRequest);
+		case "terminal/create":
+			return invokeRequired(client, client.createTerminal, method, params as CreateTerminalRequest);
+		case "terminal/output":
+			return invokeRequired(
+				client,
+				client.terminalOutput,
+				method,
+				params as { sessionId: string; terminalId: string },
+			);
+		case "terminal/wait_for_exit":
+			return invokeRequired(
+				client,
+				client.waitForTerminalExit,
+				method,
+				params as { sessionId: string; terminalId: string },
+			);
+		case "terminal/kill":
+			return invokeRequired(
+				client,
+				client.killTerminal,
+				method,
+				params as { sessionId: string; terminalId: string },
+			);
+		case "terminal/release":
+			return invokeRequired(
+				client,
+				client.releaseTerminal,
+				method,
+				params as { sessionId: string; terminalId: string },
+			);
+		case "elicitation/create":
+			return invokeRequired(client, client.unstable_createElicitation, method, params as CreateElicitationRequest);
+		case "elicitation/complete":
+			return invokeRequired(
+				client,
+				client.unstable_completeElicitation,
+				method,
+				params as CompleteElicitationNotification,
+			);
+		default:
+			if (notification && client.extNotification)
+				return client.extNotification(method, params as Record<string, unknown>);
+			if (!notification && client.extMethod) return client.extMethod(method, params as Record<string, unknown>);
+			throw RequestError.methodNotFound(method);
+	}
+}
+
+function invokeRequired<Params, Response>(
+	receiver: Agent | Client,
+	handler: ((params: Params) => MaybePromise<Response>) | undefined,
+	method: string,
+	params: Params,
+): MaybePromise<Response> {
+	if (!handler) throw RequestError.methodNotFound(method);
+	return handler.call(receiver, params);
+}