@gajae-code/coding-agent 0.10.2 → 0.11.1

package/src/modes/shared/agent-wire/handshake.ts

@@ -1,157 +0,0 @@
-import type { RpcUnattendedDeclaration } from "../../rpc/rpc-types";
-import { BRIDGE_PROTOCOL_VERSION, type BridgeFrameType } from "./protocol";
-import type { BridgeCommandScope } from "./scopes";
-
-export type BridgeCapability =
-	| "events"
-	| "prompt"
-	| "permission"
-	| "elicitation"
-	| "ui.declarative"
-	| "ui.editor"
-	| "ui.terminal_input"
-	| "host_tools"
-	| "host_uri"
-	| "client_bridge.read_text_file"
-	| "client_bridge.write_text_file"
-	| "client_bridge.create_terminal"
-	| "workflow_gate";
-
-export interface BridgeProtocolRange {
-	min: number;
-	max: number;
-}
-
-export interface BridgeHandshakeRequest {
-	protocol_version_range: BridgeProtocolRange;
-	capabilities: BridgeCapability[];
-	requested_scopes: BridgeCommandScope[];
-	last_seq?: number;
-	/** Optional unattended declaration (budget + scope + action allowlist) for #318/#319. */
-	unattended?: RpcUnattendedDeclaration;
-}
-
-export interface BridgeEndpointDescriptor {
-	events: string;
-	commands: string;
-	uiResponses: string;
-	claimControl: string;
-	disconnectControl: string;
-	hostToolResults: string;
-	hostUriResults: string;
-}
-
-export interface BridgeHandshakeAccepted {
-	status: "accepted";
-	protocol_version: typeof BRIDGE_PROTOCOL_VERSION;
-	session_id: string;
-	accepted_capabilities: BridgeCapability[];
-	accepted_scopes: BridgeCommandScope[];
-	unsupported: BridgeCapability[];
-	endpoints: BridgeEndpointDescriptor;
-	frame_types: BridgeFrameType[];
-	/** Echoed unattended declaration when one was supplied and accepted (#321). */
-	accepted_unattended?: RpcUnattendedDeclaration;
-	/** Server-side accepted unattended mode after live negotiation, not just declaration echo. */
-	unattended_active?: boolean;
-}
-
-export interface BridgeHandshakeRejected {
-	status: "rejected";
-	reason: "incompatible_version" | "unauthorized" | "invalid_request";
-	message: string;
-}
-
-export type BridgeHandshakeResponse = BridgeHandshakeAccepted | BridgeHandshakeRejected;
-
-/** Shape-validate an optional unattended declaration carried on the handshake. */
-export function isUnattendedDeclarationShape(value: unknown): value is RpcUnattendedDeclaration {
-	if (!value || typeof value !== "object") return false;
-	const d = value as Record<string, unknown>;
-	const b = d.budget as Record<string, unknown> | undefined;
-	const budgetOk =
-		!!b &&
-		typeof b === "object" &&
-		// Match UnattendedRunController fail-closed validation: positive finite budgets.
-		["max_tokens", "max_tool_calls", "max_wall_time_ms", "max_cost_usd"].every(
-			k => typeof b[k] === "number" && Number.isFinite(b[k] as number) && (b[k] as number) > 0,
-		);
-	return (
-		typeof d.actor === "string" &&
-		d.actor.trim() !== "" &&
-		budgetOk &&
-		Array.isArray(d.scopes) &&
-		d.scopes.every(s => typeof s === "string") &&
-		Array.isArray(d.action_allowlist) &&
-		d.action_allowlist.every(s => typeof s === "string")
-	);
-}
-export function isBridgeHandshakeRequest(value: unknown): value is BridgeHandshakeRequest {
-	if (!value || typeof value !== "object") return false;
-	const request = value as {
-		protocol_version_range?: unknown;
-		capabilities?: unknown;
-		requested_scopes?: unknown;
-		last_seq?: unknown;
-		unattended?: unknown;
-	};
-	const range = request.protocol_version_range as { min?: unknown; max?: unknown } | undefined;
-	return (
-		!!range &&
-		typeof range.min === "number" &&
-		Number.isInteger(range.min) &&
-		typeof range.max === "number" &&
-		Number.isInteger(range.max) &&
-		Array.isArray(request.capabilities) &&
-		request.capabilities.every(capability => typeof capability === "string") &&
-		Array.isArray(request.requested_scopes) &&
-		request.requested_scopes.every(scope => typeof scope === "string") &&
-		(request.last_seq === undefined ||
-			(typeof request.last_seq === "number" && Number.isInteger(request.last_seq))) &&
-		(request.unattended === undefined || isUnattendedDeclarationShape(request.unattended))
-	);
-}
-
-export function negotiateBridgeHandshake(
-	request: BridgeHandshakeRequest,
-	server: {
-		sessionId: string;
-		capabilities: readonly BridgeCapability[];
-		scopes: readonly BridgeCommandScope[];
-		endpoints: BridgeEndpointDescriptor;
-		frameTypes: readonly BridgeFrameType[];
-		acceptedUnattended?: RpcUnattendedDeclaration;
-	},
-): BridgeHandshakeResponse {
-	if (
-		request.protocol_version_range.min > BRIDGE_PROTOCOL_VERSION ||
-		request.protocol_version_range.max < BRIDGE_PROTOCOL_VERSION
-	) {
-		return {
-			status: "rejected",
-			reason: "incompatible_version",
-			message: `Bridge protocol v${BRIDGE_PROTOCOL_VERSION} is outside client range ${request.protocol_version_range.min}..${request.protocol_version_range.max}`,
-		};
-	}
-	const serverCapabilities = new Set(server.capabilities);
-	const acceptedCapabilities = request.capabilities.filter(capability => serverCapabilities.has(capability));
-	const acceptedSet = new Set(acceptedCapabilities);
-	const unsupported = request.capabilities.filter(capability => !acceptedSet.has(capability));
-	const serverScopes = new Set(server.scopes);
-	const acceptedScopes = request.requested_scopes.filter(scope => serverScopes.has(scope));
-	const accepted: BridgeHandshakeAccepted = {
-		status: "accepted",
-		protocol_version: BRIDGE_PROTOCOL_VERSION,
-		session_id: server.sessionId,
-		accepted_capabilities: acceptedCapabilities,
-		accepted_scopes: acceptedScopes,
-		unsupported,
-		endpoints: server.endpoints,
-		frame_types: [...server.frameTypes],
-	};
-	if (server.acceptedUnattended !== undefined && acceptedSet.has("workflow_gate")) {
-		accepted.accepted_unattended = server.acceptedUnattended;
-		accepted.unattended_active = true;
-	}
-	return accepted;
-}

package/src/modes/shared/agent-wire/host-tool-bridge.ts

@@ -1,197 +0,0 @@
-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 {
-	RpcHostToolCallRequest,
-	RpcHostToolCancelRequest,
-	RpcHostToolDefinition,
-	RpcHostToolResult,
-	RpcHostToolUpdate,
-} from "../../rpc/rpc-types";
-import type { Theme } from "../../theme/theme";
-
-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) &&
-		content.every(item => !!item && typeof item === "object" && typeof (item as { type?: unknown }).type === "string")
-	);
-}
-
-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; isError?: unknown };
-	return (
-		frame.type === "host_tool_result" &&
-		typeof frame.id === "string" &&
-		isAgentToolResult(frame.result) &&
-		(frame.isError === undefined || typeof frame.isError === "boolean")
-	);
-}
-
-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[] {
-		if (tools.some(tool => tool.name === "ask")) {
-			throw new Error('RPC host tool "ask" is reserved and cannot be supplied by the host');
-		}
-		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/shared/agent-wire/host-uri-bridge.ts

@@ -1,236 +0,0 @@
-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/rpc-types";
-
-const RESERVED_INTERNAL_URI_SCHEMES = new Set(["gjc", "agent", "artifact", "memory", "local", "rule", "issue", "pr"]);
-
-type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
-
-type PendingUriRequest = {
-	operation: "read" | "write";
-	url: string;
-	resolve: (frame: RpcHostUriResult) => void;
-	reject: (error: Error) => void;
-};
-
-export function isRpcHostUriResult(value: unknown): value is RpcHostUriResult {
-	if (!value || typeof value !== "object") return false;
-	const frame = value as {
-		type?: unknown;
-		id?: unknown;
-		content?: unknown;
-		contentType?: unknown;
-		notes?: unknown;
-		immutable?: unknown;
-		isError?: unknown;
-		error?: unknown;
-	};
-	return (
-		frame.type === "host_uri_result" &&
-		typeof frame.id === "string" &&
-		(frame.content === undefined || typeof frame.content === "string") &&
-		(frame.contentType === undefined ||
-			frame.contentType === "text/markdown" ||
-			frame.contentType === "application/json" ||
-			frame.contentType === "text/plain") &&
-		(frame.notes === undefined ||
-			(Array.isArray(frame.notes) && frame.notes.every(note => typeof note === "string"))) &&
-		(frame.immutable === undefined || typeof frame.immutable === "boolean") &&
-		(frame.isError === undefined || typeof frame.isError === "boolean") &&
-		(frame.error === undefined || typeof frame.error === "string")
-	);
-}
-
-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);
-	}
-}
-
-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());
-	}
-
-	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}`);
-			}
-			if (RESERVED_INTERNAL_URI_SCHEMES.has(scheme)) {
-				throw new Error(`Host URI scheme is reserved: ${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());
-	}
-
-	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);
-	}
-
-	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/shared/agent-wire/protocol.ts

@@ -1,46 +0,0 @@
-/**
- * Shared agent-wire protocol primitives for GJC bridge surfaces.
- *
- * The canonical event/frame contract now lives in `event-contract.ts`. This
- * module re-exports it under the historical `Bridge*` names so existing RPC and
- * Bridge code keeps compiling while the adapters migrate to the canonical
- * `AgentWire*` names. See `.gjc/specs/deep-interview-reconcile-rpc-adapters.md`.
- */
-import type {
-	AgentWireEventFrame,
-	AgentWireEventPayload,
-	AgentWireEventType,
-	AgentWireFrameEnvelope,
-	AgentWireFrameType,
-} from "./event-contract";
-import { AGENT_WIRE_EVENT_TYPES, AGENT_WIRE_PROTOCOL_VERSION } from "./event-contract";
-
-/** Wire protocol version. Bump on breaking envelope/semantic changes. */
-export const BRIDGE_PROTOCOL_VERSION = AGENT_WIRE_PROTOCOL_VERSION;
-
-/** The discriminant of every `AgentSessionEvent` the agent can emit. */
-export type AgentSessionEventType = AgentWireEventType;
-
-/** Every agent-session event type, derived from the exhaustive registry. */
-export const AGENT_SESSION_EVENT_TYPES: readonly AgentSessionEventType[] = AGENT_WIRE_EVENT_TYPES;
-
-/** Top-level frame categories carried over any bridge transport. */
-export type BridgeFrameType = AgentWireFrameType;
-
-/** Universal frame envelope. See {@link AgentWireFrameEnvelope}. */
-export type BridgeFrameEnvelope<
-	TType extends BridgeFrameType = BridgeFrameType,
-	TPayload = unknown,
-> = AgentWireFrameEnvelope<TType, TPayload>;
-
-/** Payload carried by an `event` frame. See {@link AgentWireEventPayload}. */
-export type BridgeEventPayload = AgentWireEventPayload;
-
-/** An `AgentSessionEvent` serialized into a versioned wire frame. */
-export type BridgeEventFrame = AgentWireEventFrame;
-
-/** A `workflow_gate` event serialized into a versioned wire frame (#321). */
-export type BridgeWorkflowGateFrame = BridgeFrameEnvelope<
-	"workflow_gate",
-	import("../../rpc/rpc-types").RpcWorkflowGate
->;

package/src/modes/shared/agent-wire/responses.ts

@@ -1,17 +0,0 @@
-/** Shared RPC-compatible response helpers for agent-wire consumers. */
-import type { RpcCommand, RpcResponse } from "../../rpc/rpc-types";
-
-export function rpcSuccess<T extends RpcCommand["type"]>(
-	id: string | undefined,
-	command: T,
-	data?: object | null,
-): RpcResponse {
-	if (data === undefined) {
-		return { id, type: "response", command, success: true } as RpcResponse;
-	}
-	return { id, type: "response", command, success: true, data } as RpcResponse;
-}
-
-export function rpcError(id: string | undefined, command: string, error: string | object): RpcResponse {
-	return { id, type: "response", command, success: false, error } as RpcResponse;
-}