@gajae-code/coding-agent 0.2.5 → 0.3.1

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

@@ -1,186 +1 @@
-import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
-import type { Static, TSchema } from "@gajae-code/ai";
-import { Snowflake } from "@gajae-code/utils";
-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);
-		}
-	}
-}
+export * from "../shared/agent-wire/host-tool-bridge";

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

@@ -1,235 +1 @@
-import { Snowflake } from "@gajae-code/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;
-	}
-}
+export * from "../shared/agent-wire/host-uri-bridge";

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

@@ -186,7 +186,12 @@ export class RpcClient {
 			cwd: this.options.cwd,
 			env: { ...Bun.env, ...this.options.env },
 			stdin: "pipe",
+			stderr: "full",
 		});
+		const startupStderrPromise = this.#process.stderr
+			? new Response(this.#process.stderr).text().catch(() => "")
+			: Promise.resolve("");
+		const getStartupStderr = async () => this.#process?.peekStderr() || (await startupStderrPromise);
 
 		// Wait for the "ready" signal or process exit
 		const { promise: readyPromise, resolve: readyResolve, reject: readyReject } = Promise.withResolvers<void>();
@@ -203,10 +208,20 @@ export class RpcClient {
 				}
 				this.#handleLine(line);
 			}
-			// Stream ended without ready signal — process exited
+			// Stream ended without ready signal — process exited. Wait for the
+			// managed process wrapper so stderr is fully drained before reporting.
 			if (!readySettled) {
-				readySettled = true;
-				readyReject(new Error(`Agent process exited before ready. Stderr: ${this.#process?.peekStderr() ?? ""}`));
+				const proc = this.#process;
+				const exitCode = proc ? await proc.exited.catch(() => proc.exitCode ?? -1) : undefined;
+				if (!readySettled) {
+					const stderr = await getStartupStderr();
+					readySettled = true;
+					readyReject(
+						new Error(
+							`Agent process exited${exitCode === undefined ? "" : ` with code ${exitCode}`} before ready. Stderr: ${stderr}`,
+						),
+					);
+				}
 			}
 		})().catch((err: Error) => {
 			if (!readySettled) {
@@ -216,12 +231,12 @@ export class RpcClient {
 		});
 
 		// Also race against process exit (in case stdout closes before we read it)
-		void this.#process.exited.then((exitCode: number) => {
+		void this.#process.exited.then(async (exitCode: number) => {
 			if (!readySettled) {
+				const stderr = await getStartupStderr();
+				if (readySettled) return;
 				readySettled = true;
-				readyReject(
-					new Error(`Agent process exited with code ${exitCode}. Stderr: ${this.#process?.peekStderr() ?? ""}`),
-				);
+				readyReject(new Error(`Agent process exited with code ${exitCode}. Stderr: ${stderr}`));
 			}
 		});
 
@@ -229,9 +244,9 @@ export class RpcClient {
 		const readyTimeout = this.#startTimeout(30000, () => {
 			if (readySettled) return;
 			readySettled = true;
-			readyReject(
-				new Error(`Timeout waiting for agent to become ready. Stderr: ${this.#process?.peekStderr() ?? ""}`),
-			);
+			void getStartupStderr().then(stderr => {
+				readyReject(new Error(`Timeout waiting for agent to become ready. Stderr: ${stderr}`));
+			});
 		});
 
 		try {