@acpjs/client 0.1.0

package/README.md

@@ -0,0 +1,128 @@
+# @acpjs/client
+
+Typed facade and reducer-driven client-side store for acpjs. Environment-neutral (no Node built-ins) and connected to any host purely through the Transport contract (in-process, Electron renderer, …). It replays the normalized event stream on the client side with the pure reducer from `@acpjs/protocol` into `SessionState`, exposed through a snapshot + subscribe surface. The only runtime dependency is `@acpjs/protocol`; `@acpjs/core` is consumed only through transport contract types.
+
+## Installation
+
+```sh
+pnpm add @acpjs/client
+```
+
+ESM-only, requires `node >= 24` (also usable in browser / renderer environments).
+
+## Minimal usage (in-process Node)
+
+```ts
+import {
+  AcpClientError,
+  createAcpClient,
+  createInProcessTransport,
+} from '@acpjs/client'
+import { createAcpHost, createHostEndpoint } from '@acpjs/core'
+
+const host = createAcpHost()
+const transport = createInProcessTransport(createHostEndpoint(host))
+const client = createAcpClient({ transport })
+
+const agent = await client.agents.spawn({
+  id: 'my-agent',
+  command: 'npx',
+  args: ['some-acp-agent'],
+})
+
+const session = await agent.sessions.create({ cwd: process.cwd() })
+session.subscribe(() => render(session.getSnapshot()))
+
+client.permissions.subscribe((requests) => {
+  for (const request of requests) {
+    // Under multi-client races, a respond rejected with acpjs/already-answered
+    // is the normal path (the pending list has already converged) — ignore it.
+    request
+      .respond({
+        outcome: 'selected',
+        optionId: request.options[0]?.optionId ?? '',
+      })
+      .catch((error) => {
+        if (
+          error instanceof AcpClientError &&
+          error.code === 'acpjs/already-answered'
+        )
+          return
+        throw error
+      })
+  }
+})
+
+await session.prompt([{ type: 'text', text: 'hello' }])
+session.getSnapshot() // cached immutable SessionState reference
+
+// In-process: the host lifecycle is independent of the client. client.dispose()
+// only closes the transport; you must separately await host.dispose() or the
+// agent child processes will leak.
+await client.dispose()
+await host.dispose()
+```
+
+## Public API (closed surface, SPEC §6.4)
+
+The export surface is exactly three values: `createAcpClient`, `createInProcessTransport`, and `AcpClientError` (pinned by an API snapshot test). There is no raw RPC send, no raw protocol notification subscription, and no store selector parameter.
+
+- `createAcpClient({ transport })` → `AcpClient`
+  - `client.agents.spawn(definition)` → `Promise<AcpAgent>`. `definition` is an `AgentDefinition` (`id`, `command`, `args?`, `env?`, `cwd?`, `meta?`). The returned handle carries `agentId` plus `capabilities?` / `authMethods?` passed through from initialize.
+  - `client.agents.get(agentId)` → `AcpAgent | undefined`: look up a known handle by id (same reference returned by spawn / attach).
+  - `client.agents.getSnapshot()` → `readonly AcpAgent[]`: cached immutable snapshot of the handle set — a new reference is produced only when the set changes (`useSyncExternalStore` compatible).
+  - `client.agents.subscribe(() => ...)`: notification when the agent handle set changes (no immediate callback; read the initial value via `getSnapshot`).
+  - `client.agents.list()` → `Promise<readonly AgentSnapshot[]>`: a one-shot RPC query of every agent known to the host (`agentId` / `status` / `restartCount` / `reason?` / `exit?` / `capabilities?` / `authMethods?` / `authRequired?`), non-reactive.
+  - `client.agents.attach(agentId)` → `Promise<AcpAgent>`: hydrate an agent that already exists on the host into a handle (internally calls `list()` to verify existence). An unknown id rejects with `acpjs/agent-exited`; an existing handle is reused.
+  - `client.sessions.get(sessionId)` → `AcpSession | undefined`: look up a known session handle by id. create / load / resume / attach for the same sessionId share one frozen handle.
+  - `client.sessions.getSnapshot()` → `readonly AcpSession[]`: cached immutable snapshot of the session handle set.
+  - `client.sessions.subscribe(() => ...)`: notification when the session handle set changes.
+  - `client.sessions.list()` → `Promise<readonly SessionSnapshot[]>`: a one-shot RPC query of every session known to the host (`sessionId` / `status` / `agentId?` / `cwd?` / `agentDefinitionId?`), non-reactive.
+  - `client.sessions.attach(sessionId)` → `Promise<AcpSession>`: re-attach to an existing session **without an agent handle** (internally calls `list()`; if present it subscribes and rebuilds state via replay from `fromSeq: 0`). An unknown id rejects with `acpjs/session-closed`.
+  - `client.sessions.restore()` → `Promise<readonly SessionSnapshot[]>`: after a host restart, rebuild `disconnected` sessions from storage and return their snapshots.
+  - `client.permissions.getSnapshot()` → `readonly PermissionRequest[]`: cached immutable reference of the pending permission-request list — a new reference is produced only when the set changes.
+  - `client.permissions.subscribe((requests) => ...)`: notification with the latest snapshot on any add/remove of the pending set (new request, respond, other-client answer / superseded); no immediate callback (read the initial value via `getSnapshot`). Each `request` carries `requestId` / `sessionId` / `toolCall` / `options` (protocol pass-through) and `respond(outcome)`.
+  - `client.status.getSnapshot()` → `ConnectionStatusSnapshot` (`{ status: 'connecting' | 'connected' | 'closed', error? }`): cached immutable snapshot of the connection status.
+  - `client.status.subscribe(() => ...)`: notification when the connection status changes (no immediate callback; read the initial value via `getSnapshot`).
+  - `client.dispose()`: close the transport; afterwards every call rejects with `acpjs/transport-closed`.
+- `AcpAgent`
+  - `agent.agentId`, `agent.capabilities?`, `agent.authMethods?`: readonly handle properties.
+  - `agent.getSnapshot()` → `AgentSnapshot`: cached immutable snapshot of this agent's runtime state (`status` / `restartCount` / `reason?` / `exit?` / `capabilities?` / `authMethods?` / `authRequired?`). `restartCount` is driven by live `agent-status-change` events; `authRequired` / `authMethods` reflect the waiting-for-auth dimension driven by host-level `auth-required` events (SPEC §4.11, §8.2).
+  - `agent.subscribe(() => ...)`: notification when the runtime state changes (no immediate callback; read the initial value via `getSnapshot`).
+  - `agent.sessions.create({ cwd, mcpServers? })` / `load(sessionId, { cwd, mcpServers? })` / `list({ cursor?, cwd? })` / `resume(sessionId)` / `delete(sessionId)`.
+  - `agent.authenticate(methodId)` / `agent.logout()`.
+- `AcpSession`
+  - `session.sessionId`: readonly id.
+  - `session.getSnapshot()` → `SessionState`: cached immutable reference — a new reference is produced only when a new event arrives (`useSyncExternalStore` compatible).
+  - `session.subscribe((state) => ...)`: notification when state changes (the current value is not replayed; read the initial value via `getSnapshot`).
+  - `session.prompt(ContentBlock[])` → `Promise<PromptFinishedPayload>`: protocol content blocks passed through with no rewriting (SPEC §12). Also `cancel()`, `close()`, `setMode(modeId)`, `setConfigOption(configId, value)`.
+- Slash commands are not a separate API: `SessionState.availableCommands` only enumerates available commands for autocompletion UI. To invoke a command, write a `/`-prefixed text block in the prompt, which may be mixed with other blocks — `session.prompt([{ type: 'text', text: '/web query' }])`. There is no `invokeCommand`-style method.
+- Every error is an `AcpClientError` (an `ErrorObject` shape: `code` (acpjs/\*), `message`, `data?`, `retryable`). A capability-gated method whose capability was not declared rejects with `acpjs/capability-unsupported` (core semantics passed through); a second answer to a permission rejects with `acpjs/already-answered`.
+
+## State construction (SPEC §9.2)
+
+The only client-side state-construction path: the transport receives an `AcpEvent` → the `reduce` function from `@acpjs/protocol` replays it in `seq` order. Subscriptions carry `fromSeq`; a late subscriber / reconnection is backfilled by replay and ends up deeply equal to a full-duration subscriber (INV-2). A duplicate event whose `seq` was already applied is ignored.
+
+## Transport
+
+The client consumes the Transport contract from `@acpjs/protocol` (`connect` / `request` / `subscribe` / `respondInbound` / `close`, with lifecycle `connecting → connected → closed` plus an error termination path). The built-in `createInProcessTransport(endpoint)` connects to `@acpjs/core`'s `createHostEndpoint(host)` (the client only sees contract types and has zero dependency on core; SPEC §6.2). Reconnection is not a transport obligation; a new connection backfills via `fromSeq`.
+
+## Implementation-defined decisions (SPEC §15)
+
+- **RPC id format**: `rpc-<n>` (monotonic counter within a client instance).
+- **RPC method names**: sourced from `@acpjs/protocol`'s `ACP_RPC_METHODS` (`agents/spawn|authenticate|logout|list`, `sessions/create|load|list|resume|delete|prompt|cancel|close|setMode|setConfigOption|getAll|restore`), the same constant table consumed by core's `createHostEndpoint` (pinned by protocol and end-to-end tests).
+- **auth-required facade shape (create-time)**: `sessions.create` does not return a union type; instead it rejects with an `AcpClientError` (`code: 'acpjs/auth-required'`, `retryable: true`, `data.authMethods` is the protocol original). After `authenticate`, the consumer retries create. In parallel the agent's runtime snapshot becomes observable as waiting-for-auth (`authRequired: true` + `authMethods`), driven by the host-level `auth-required` event.
+- **store subscription timing**: one store per sessionId; on first acquiring a session handle (create / load / resume / attach) it subscribes from `fromSeq: 0`. Within one client the same sessionId reuses the same store, the same frozen handle, and the same subscription.
+- **subscribe does not call back immediately**: consistent with external-store conventions (session state, agent/session registries, connection status, and the permission list all behave this way); read the initial value via `getSnapshot` / `get`.
+- **connection status store**: `client.status` maintains a single `ConnectionStatusSnapshot`, advancing `connecting → connected → closed` with the transport lifecycle (termination may carry an `error`); entering `closed` also clears the pending permission snapshot. No duplicate notification when neither status nor error changes.
+- **sessions.attach semantics**: does not go through an agent handle — it uses `sessions.list()` to verify the sessionId is still known to the host; if present it creates a store and rebuilds state by replaying from `fromSeq: 0`; an unknown id rejects with `acpjs/session-closed`. Suitable for re-attaching to an existing session across windows / after a page reload.
+- **agents/sessions list/restore are one-shot RPC queries**: `agents.list()` / `sessions.list()` / `sessions.restore()` are non-reactive request/response snapshots (for enumeration and hydration), returning wire-level `AgentSnapshot` / `SessionSnapshot` without subscribing to subsequent changes; for reactive observation use the corresponding `getSnapshot` / `subscribe`.
+- **permission-request exit**: a request leaves the pending set (and subscribers are notified with a new snapshot) when respond succeeds, when respond is rejected with `acpjs/already-answered` (someone else already answered), or when the owning session's event stream emits `permission-request-resolved` (other-client answer / superseded). A late consumer reading `getSnapshot` only sees still-pending requests. Under multi-client races, a respond rejected with `acpjs/already-answered` is the normal path — the pending list has converged and consumers should ignore that code rather than treat it as an error. Inbound requests whose kind is not `permission` are ignored (forward compatibility).
+- **dispose semantics**: mark closed → unsubscribe all store subscriptions → clear permission subscribers and the pending permission set → `transport.close()`; idempotent.
+- **in-process direct-call mechanism** (named in the §15 checklist): `createInProcessTransport(endpoint)` implements the Transport contract via direct function calls — `request` / `subscribe` / `respondInbound` forward straight to `@acpjs/core`'s `EnvelopeEndpoint` (provided by `createHostEndpoint(host)`), with no JSON serialization and no transport boundary. `connect` wires up inbound requests via `endpoint.onInboundRequest` and advances the lifecycle to `connected`; inbound requests (such as permissions) are handed to the client as-is. Payloads remain structured-clone safe (INV-3, asserted by end-to-end tests). After close, `request` responds with an `acpjs/transport-closed` error, `respondInbound` rejects, and `subscribe` throws an `AcpClientError` (surfacing misuse early); a repeated `connect` throws `acpjs/config-invalid`; `close` is idempotent and unsubscribes all active subscriptions. Reconnection is not part of the contract obligation; a new connection backfills state via `fromSeq`.
+- **listener-callback exceptions**: session-state listeners and permission listeners that throw are isolated (swallowed, without interrupting dispatch to the rest of the batch; there is no client-side diagnostic channel).
+- **connect failure**: every facade call rejects with the lifecycle error (or `acpjs/transport-closed`).
+
+```
+
+```

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+import { AcpErrorCode, AgentCapabilities, AgentDefinition, AgentSnapshotWire, AuthMethod, ContentBlock, EnvelopeEndpoint, ErrorObject, ListSessionsResponse, McpServer, PermissionRequestCreatedPayload, PromptFinishedPayload, RequestPermissionOutcome, SessionConfigOption, SessionConfigValue, SessionSnapshotWire, SessionState, Transport, TransportConnectionStatus } from "@acpjs/protocol";
+
+//#region src/types.d.ts
+type AgentSnapshot = AgentSnapshotWire;
+type SessionSnapshot = SessionSnapshotWire;
+interface AcpSession {
+  readonly sessionId: string;
+  getSnapshot: () => SessionState;
+  subscribe: (listener: (state: SessionState) => void) => () => void;
+  prompt: (blocks: ContentBlock[]) => Promise<PromptFinishedPayload>;
+  cancel: () => Promise<void>;
+  close: () => Promise<void>;
+  setMode: (modeId: string) => Promise<void>;
+  setConfigOption: (configId: string, value: SessionConfigValue) => Promise<SessionConfigOption[]>;
+}
+interface SessionCreateParams {
+  cwd: string;
+  mcpServers?: McpServer[];
+}
+interface SessionListParams {
+  cursor?: string;
+  cwd?: string;
+}
+interface AcpAgentSessions {
+  create: (params: SessionCreateParams) => Promise<AcpSession>;
+  load: (sessionId: string, params: SessionCreateParams) => Promise<AcpSession>;
+  list: (params?: SessionListParams) => Promise<ListSessionsResponse>;
+  resume: (sessionId: string) => Promise<AcpSession>;
+  delete: (sessionId: string) => Promise<void>;
+}
+interface AcpAgent {
+  readonly agentId: string;
+  readonly capabilities?: AgentCapabilities;
+  readonly authMethods?: AuthMethod[];
+  getSnapshot: () => AgentSnapshot;
+  subscribe: (listener: ChangeListener) => () => void;
+  readonly sessions: AcpAgentSessions;
+  authenticate: (methodId: string) => Promise<void>;
+  logout: () => Promise<void>;
+}
+interface PermissionRequest {
+  readonly requestId: string;
+  readonly sessionId: string;
+  readonly toolCall: PermissionRequestCreatedPayload['toolCall'];
+  readonly options: PermissionRequestCreatedPayload['options'];
+  respond: (outcome: RequestPermissionOutcome) => Promise<void>;
+}
+type PermissionListener = (requests: readonly PermissionRequest[]) => void;
+type ChangeListener = () => void;
+interface ConnectionStatusSnapshot {
+  status: TransportConnectionStatus;
+  error?: ErrorObject;
+}
+interface AcpClient {
+  readonly agents: {
+    spawn: (definition: AgentDefinition) => Promise<AcpAgent>;
+    get: (agentId: string) => AcpAgent | undefined;
+    getSnapshot: () => readonly AcpAgent[];
+    subscribe: (listener: ChangeListener) => () => void;
+    list: () => Promise<readonly AgentSnapshot[]>;
+    attach: (agentId: string) => Promise<AcpAgent>;
+  };
+  readonly sessions: {
+    get: (sessionId: string) => AcpSession | undefined;
+    getSnapshot: () => readonly AcpSession[];
+    subscribe: (listener: ChangeListener) => () => void;
+    list: () => Promise<readonly SessionSnapshot[]>;
+    attach: (sessionId: string) => Promise<AcpSession>;
+    restore: () => Promise<readonly SessionSnapshot[]>;
+  };
+  readonly permissions: {
+    getSnapshot: () => readonly PermissionRequest[];
+    subscribe: (listener: PermissionListener) => () => void;
+  };
+  readonly status: {
+    getSnapshot: () => ConnectionStatusSnapshot;
+    subscribe: (listener: ChangeListener) => () => void;
+  };
+  dispose: () => Promise<void>;
+}
+interface CreateAcpClientOptions {
+  transport: Transport;
+}
+//#endregion
+//#region src/client.d.ts
+declare function createAcpClient(options: CreateAcpClientOptions): AcpClient;
+//#endregion
+//#region src/errors.d.ts
+declare class AcpClientError extends Error {
+  code: AcpErrorCode;
+  data: unknown;
+  retryable: boolean;
+  constructor(error: ErrorObject);
+}
+//#endregion
+//#region src/in-process.d.ts
+declare function createInProcessTransport(endpoint: EnvelopeEndpoint): Transport;
+//#endregion
+export { type AcpAgent, type AcpAgentSessions, type AcpClient, AcpClientError, type AcpSession, type AgentDefinition, type AgentSnapshot, type ChangeListener, type ConnectionStatusSnapshot, type CreateAcpClientOptions, type PermissionListener, type PermissionRequest, type SessionConfigValue, type SessionCreateParams, type SessionListParams, type SessionSnapshot, createAcpClient, createInProcessTransport };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/client.ts","../src/errors.ts","../src/in-process.ts"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,511 @@
+import { ACP_ERROR_CODES, ACP_RPC_METHODS, createInitialSessionState, isAcpErrorCode, reduce } from "@acpjs/protocol";
+//#region src/errors.ts
+var AcpClientError = class extends Error {
+	code;
+	data;
+	retryable;
+	constructor(error) {
+		super(error.message);
+		this.name = "AcpClientError";
+		this.code = error.code;
+		this.data = error.data;
+		this.retryable = error.retryable;
+	}
+};
+function transportClosedError() {
+	return {
+		code: ACP_ERROR_CODES.transportClosed,
+		message: "transport is closed",
+		retryable: true
+	};
+}
+function asErrorObject(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const candidate = value;
+	if (typeof candidate.code !== "string" || !isAcpErrorCode(candidate.code)) return;
+	return {
+		code: candidate.code,
+		message: typeof candidate.message === "string" ? candidate.message : "",
+		...candidate.data === void 0 ? {} : { data: candidate.data },
+		retryable: candidate.retryable === true
+	};
+}
+function toClientError(value) {
+	if (value instanceof AcpClientError) return value;
+	const errorObject = asErrorObject(value);
+	if (errorObject) return new AcpClientError(errorObject);
+	const message = value instanceof Error ? value.message : typeof value === "string" ? value : "unknown error";
+	return new AcpClientError({
+		code: ACP_ERROR_CODES.agentError,
+		message,
+		retryable: false
+	});
+}
+//#endregion
+//#region src/internal.ts
+function notifyChange(listeners) {
+	for (const listener of listeners) try {
+		listener();
+	} catch {}
+}
+//#endregion
+//#region src/agent-handle.ts
+function sameAuthMethods(current, next) {
+	if (current === void 0) return next.length === 0;
+	if (current.length !== next.length) return false;
+	return current.every((method, index) => method.id === next[index]?.id);
+}
+function sameRuntimeState(current, payload) {
+	return current.status === payload.status && current.restartCount === payload.restartCount && current.reason === payload.reason && current.exit?.code === payload.exit?.code && current.exit?.signal === payload.exit?.signal;
+}
+function createAgentHandle(call, openSession, onStatusChanged, snapshot) {
+	const agentId = snapshot.agentId;
+	let current = snapshot;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		agent: Object.freeze({
+			agentId,
+			...snapshot.capabilities === void 0 ? {} : { capabilities: snapshot.capabilities },
+			...snapshot.authMethods === void 0 ? {} : { authMethods: snapshot.authMethods },
+			getSnapshot: () => current,
+			subscribe(listener) {
+				listeners.add(listener);
+				return () => listeners.delete(listener);
+			},
+			sessions: Object.freeze({
+				async create(params) {
+					const result = await call(ACP_RPC_METHODS.createSession, {
+						agentId,
+						cwd: params.cwd,
+						...params.mcpServers === void 0 ? {} : { mcpServers: params.mcpServers }
+					});
+					if (result.status === "auth-required") throw new AcpClientError({
+						code: "acpjs/auth-required",
+						message: "agent requires authentication",
+						data: { authMethods: result.authMethods },
+						retryable: true
+					});
+					return openSession(result.sessionId);
+				},
+				async load(sessionId, params) {
+					await call(ACP_RPC_METHODS.loadSession, {
+						agentId,
+						sessionId,
+						cwd: params.cwd,
+						...params.mcpServers === void 0 ? {} : { mcpServers: params.mcpServers }
+					});
+					return openSession(sessionId);
+				},
+				async list(params = {}) {
+					return await call(ACP_RPC_METHODS.listSessions, {
+						agentId,
+						...params.cursor === void 0 ? {} : { cursor: params.cursor },
+						...params.cwd === void 0 ? {} : { cwd: params.cwd }
+					});
+				},
+				async resume(sessionId) {
+					await call(ACP_RPC_METHODS.resumeSession, { sessionId });
+					return openSession(sessionId);
+				},
+				async delete(sessionId) {
+					await call(ACP_RPC_METHODS.deleteSession, { sessionId });
+				}
+			}),
+			async authenticate(methodId) {
+				await call(ACP_RPC_METHODS.authenticate, {
+					agentId,
+					methodId
+				});
+			},
+			async logout() {
+				await call(ACP_RPC_METHODS.logout, { agentId });
+			}
+		}),
+		applyStatus(payload) {
+			if (sameRuntimeState(current, payload)) return;
+			current = {
+				agentId,
+				status: payload.status,
+				restartCount: payload.restartCount,
+				...payload.reason === void 0 ? {} : { reason: payload.reason },
+				...payload.exit === void 0 ? {} : { exit: payload.exit },
+				...current.capabilities === void 0 ? {} : { capabilities: current.capabilities },
+				...current.authMethods === void 0 ? {} : { authMethods: current.authMethods },
+				...current.authRequired === void 0 ? {} : { authRequired: current.authRequired }
+			};
+			notifyChange(listeners);
+			onStatusChanged();
+		},
+		applyAuthRequired(payload) {
+			if (current.authRequired === true && sameAuthMethods(current.authMethods, payload.authMethods)) return;
+			current = {
+				...current,
+				authRequired: true,
+				authMethods: payload.authMethods
+			};
+			notifyChange(listeners);
+			onStatusChanged();
+		}
+	};
+}
+//#endregion
+//#region src/permission-registry.ts
+function createPermissionRegistry() {
+	const pending = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let snapshot = Object.freeze([]);
+	function publish() {
+		snapshot = Object.freeze([...pending.values()]);
+		for (const listener of listeners) try {
+			listener(snapshot);
+		} catch {}
+	}
+	return {
+		getSnapshot: () => snapshot,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		add(request) {
+			pending.set(request.requestId, request);
+			publish();
+		},
+		prune(requestId) {
+			if (pending.delete(requestId)) publish();
+		},
+		reset() {
+			if (pending.size === 0) return;
+			pending.clear();
+			publish();
+		},
+		clear() {
+			pending.clear();
+			publish();
+			listeners.clear();
+		}
+	};
+}
+//#endregion
+//#region src/session-handle.ts
+function createSessionHandle(call, store) {
+	const sessionId = store.sessionId;
+	return Object.freeze({
+		sessionId,
+		getSnapshot: () => store.getSnapshot(),
+		subscribe: (listener) => store.subscribe(listener),
+		async prompt(blocks) {
+			return await call(ACP_RPC_METHODS.prompt, {
+				sessionId,
+				prompt: blocks
+			});
+		},
+		async cancel() {
+			await call(ACP_RPC_METHODS.cancel, { sessionId });
+		},
+		async close() {
+			await call(ACP_RPC_METHODS.closeSession, { sessionId });
+		},
+		async setMode(modeId) {
+			await call(ACP_RPC_METHODS.setMode, {
+				sessionId,
+				modeId
+			});
+		},
+		async setConfigOption(configId, value) {
+			return await call(ACP_RPC_METHODS.setConfigOption, {
+				sessionId,
+				configId,
+				value
+			});
+		}
+	});
+}
+//#endregion
+//#region src/store.ts
+function createSessionStore(sessionId) {
+	let state = createInitialSessionState(sessionId);
+	let lastSeq = 0;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		sessionId,
+		getSnapshot: () => state,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		apply(event) {
+			if (!("sessionId" in event) || event.sessionId !== sessionId) return;
+			if (event.seq <= lastSeq) return;
+			lastSeq = event.seq;
+			const next = reduce(state, event);
+			if (next === state) return;
+			state = next;
+			for (const listener of listeners) try {
+				listener(state);
+			} catch {}
+		},
+		lastSeq: () => lastSeq
+	};
+}
+//#endregion
+//#region src/client.ts
+function createAcpClient(options) {
+	const transport = options.transport;
+	let closedError;
+	const stores = /* @__PURE__ */ new Map();
+	const storeUnsubscribers = /* @__PURE__ */ new Set();
+	const agents = /* @__PURE__ */ new Map();
+	const agentListeners = /* @__PURE__ */ new Set();
+	const agentUpdaters = /* @__PURE__ */ new Map();
+	let agentsSnapshot = Object.freeze([]);
+	function publishAgents() {
+		agentsSnapshot = Object.freeze([...agents.values()]);
+		notifyChange(agentListeners);
+	}
+	const sessions = /* @__PURE__ */ new Map();
+	const sessionListeners = /* @__PURE__ */ new Set();
+	let sessionsSnapshot = Object.freeze([]);
+	function publishSessions() {
+		sessionsSnapshot = Object.freeze([...sessions.values()]);
+		notifyChange(sessionListeners);
+	}
+	const permissions = createPermissionRegistry();
+	let statusSnapshot = Object.freeze({ status: "connecting" });
+	const statusListeners = /* @__PURE__ */ new Set();
+	function ensureOpen() {
+		if (closedError) throw new AcpClientError(closedError);
+	}
+	const handlers = {
+		onInboundRequest(request) {
+			if (request.kind !== "permission") return;
+			const payload = request.payload;
+			const permission = Object.freeze({
+				requestId: payload.requestId,
+				sessionId: payload.sessionId,
+				toolCall: payload.toolCall,
+				options: payload.options,
+				respond: (outcome) => respondPermission(request.id, payload.requestId, outcome)
+			});
+			permissions.add(permission);
+		},
+		onLifecycle(event) {
+			if (event.status === "closed") {
+				closedError = event.error ?? transportClosedError();
+				permissions.reset();
+			}
+			if (statusSnapshot.status === event.status && statusSnapshot.error === event.error) return;
+			statusSnapshot = Object.freeze({
+				status: event.status,
+				...event.error === void 0 ? {} : { error: event.error }
+			});
+			notifyChange(statusListeners);
+		}
+	};
+	function onHostEvent(event) {
+		if (event.type === "agent-status-change") agentUpdaters.get(event.agentId)?.applyStatus(event.payload);
+		else if (event.type === "auth-required") agentUpdaters.get(event.agentId)?.applyAuthRequired(event.payload);
+		else if (event.type === "session-created" || event.type === "session-closed") notifyChange(sessionListeners);
+	}
+	const connected = transport.connect(handlers);
+	connected.then(() => {
+		if (closedError) return;
+		storeUnsubscribers.add(transport.subscribe({ fromSeq: 0 }, onHostEvent));
+	}).catch(() => {});
+	async function respondPermission(inboundId, requestId, outcome) {
+		ensureOpen();
+		try {
+			await connected;
+			await transport.respondInbound({
+				id: inboundId,
+				result: outcome
+			});
+		} catch (error) {
+			const clientError = toClientError(error);
+			if (clientError.code === ACP_ERROR_CODES.alreadyAnswered) permissions.prune(requestId);
+			throw clientError;
+		}
+		permissions.prune(requestId);
+	}
+	let rpcCounter = 0;
+	async function call(method, params) {
+		ensureOpen();
+		try {
+			await connected;
+		} catch (error) {
+			throw toClientError(error);
+		}
+		ensureOpen();
+		rpcCounter += 1;
+		let response;
+		try {
+			response = await transport.request({
+				id: `rpc-${rpcCounter}`,
+				method,
+				params
+			});
+		} catch (error) {
+			throw toClientError(error);
+		}
+		if (!response.ok) throw new AcpClientError(response.error);
+		return response.result;
+	}
+	function attachStore(sessionId) {
+		const existing = stores.get(sessionId);
+		if (existing) return existing;
+		const store = createSessionStore(sessionId);
+		stores.set(sessionId, store);
+		const unsubscribe = transport.subscribe({
+			sessionId,
+			fromSeq: store.lastSeq()
+		}, (event) => {
+			if (event.type === "permission-request-resolved") permissions.prune(event.payload.requestId);
+			store.apply(event);
+		});
+		storeUnsubscribers.add(unsubscribe);
+		return store;
+	}
+	function openSession(sessionId) {
+		const existing = sessions.get(sessionId);
+		if (existing) return existing;
+		const session = createSessionHandle(call, attachStore(sessionId));
+		sessions.set(sessionId, session);
+		publishSessions();
+		return session;
+	}
+	async function listAgents() {
+		return await call(ACP_RPC_METHODS.listAgents, {});
+	}
+	async function listAllSessions() {
+		return await call(ACP_RPC_METHODS.getAllSessions, {});
+	}
+	function registerAgent(snapshot) {
+		const { agent, applyStatus, applyAuthRequired } = createAgentHandle(call, openSession, publishAgents, snapshot);
+		agentUpdaters.set(agent.agentId, {
+			applyStatus,
+			applyAuthRequired
+		});
+		agents.set(agent.agentId, agent);
+		publishAgents();
+		return agent;
+	}
+	return Object.freeze({
+		agents: Object.freeze({
+			async spawn(definition) {
+				return registerAgent(await call(ACP_RPC_METHODS.spawnAgent, { definition }));
+			},
+			get: (agentId) => agents.get(agentId),
+			getSnapshot: () => agentsSnapshot,
+			subscribe(listener) {
+				agentListeners.add(listener);
+				return () => agentListeners.delete(listener);
+			},
+			list: listAgents,
+			async attach(agentId) {
+				const snapshot = (await listAgents()).find((candidate) => candidate.agentId === agentId);
+				if (!snapshot) throw new AcpClientError({
+					code: ACP_ERROR_CODES.agentExited,
+					message: `agent ${agentId} is not known to the host`,
+					retryable: false
+				});
+				return agents.get(agentId) ?? registerAgent(snapshot);
+			}
+		}),
+		sessions: Object.freeze({
+			get: (sessionId) => sessions.get(sessionId),
+			getSnapshot: () => sessionsSnapshot,
+			subscribe(listener) {
+				sessionListeners.add(listener);
+				return () => sessionListeners.delete(listener);
+			},
+			list: listAllSessions,
+			async attach(sessionId) {
+				if (!(await listAllSessions()).some((candidate) => candidate.sessionId === sessionId)) throw new AcpClientError({
+					code: ACP_ERROR_CODES.sessionClosed,
+					message: `session ${sessionId} is not known to the host`,
+					retryable: false
+				});
+				return openSession(sessionId);
+			},
+			async restore() {
+				return await call(ACP_RPC_METHODS.restoreSessions, {});
+			}
+		}),
+		permissions: Object.freeze({
+			getSnapshot: permissions.getSnapshot,
+			subscribe: permissions.subscribe
+		}),
+		status: Object.freeze({
+			getSnapshot: () => statusSnapshot,
+			subscribe(listener) {
+				statusListeners.add(listener);
+				return () => statusListeners.delete(listener);
+			}
+		}),
+		async dispose() {
+			if (closedError) return;
+			closedError = transportClosedError();
+			for (const unsubscribe of storeUnsubscribers) unsubscribe();
+			storeUnsubscribers.clear();
+			permissions.clear();
+			await transport.close();
+		}
+	});
+}
+//#endregion
+//#region src/in-process.ts
+function createInProcessTransport(endpoint) {
+	let status = "connecting";
+	let handlers;
+	const unsubscribers = /* @__PURE__ */ new Set();
+	let detachInbound;
+	return {
+		async connect(next) {
+			if (status === "closed") throw new AcpClientError(transportClosedError());
+			if (handlers) throw new AcpClientError({
+				code: ACP_ERROR_CODES.configInvalid,
+				message: "transport already connected",
+				retryable: false
+			});
+			handlers = next;
+			next.onLifecycle({ status: "connecting" });
+			detachInbound = endpoint.onInboundRequest((request) => {
+				next.onInboundRequest(request);
+			});
+			status = "connected";
+			next.onLifecycle({ status: "connected" });
+		},
+		async request(request) {
+			if (status !== "connected") return {
+				id: request.id,
+				ok: false,
+				error: transportClosedError()
+			};
+			return endpoint.request(request);
+		},
+		subscribe(params, onEvent) {
+			if (status !== "connected") throw new AcpClientError(transportClosedError());
+			const unsubscribe = endpoint.subscribe(params, onEvent);
+			unsubscribers.add(unsubscribe);
+			return () => {
+				unsubscribers.delete(unsubscribe);
+				unsubscribe();
+			};
+		},
+		async respondInbound(response) {
+			if (status !== "connected") throw new AcpClientError(transportClosedError());
+			await endpoint.respondInbound(response);
+		},
+		async close() {
+			if (status === "closed") return;
+			status = "closed";
+			detachInbound?.();
+			for (const unsubscribe of unsubscribers) unsubscribe();
+			unsubscribers.clear();
+			handlers?.onLifecycle({ status: "closed" });
+		}
+	};
+}
+//#endregion
+export { AcpClientError, createAcpClient, createInProcessTransport };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/errors.ts","../src/internal.ts","../src/agent-handle.ts","../src/permission-registry.ts","../src/session-handle.ts","../src/store.ts","../src/client.ts","../src/in-process.ts"],"sourcesContent":["import {\n  ACP_ERROR_CODES,\n  isAcpErrorCode,\n  type AcpErrorCode,\n  type ErrorObject,\n} from '@acpjs/protocol'\n\nexport class AcpClientError extends Error {\n  code: AcpErrorCode\n  data: unknown\n  retryable: boolean\n\n  constructor(error: ErrorObject) {\n    super(error.message)\n    this.name = 'AcpClientError'\n    this.code = error.code\n    this.data = error.data\n    this.retryable = error.retryable\n  }\n}\n\nexport function transportClosedError(): ErrorObject {\n  return {\n    code: ACP_ERROR_CODES.transportClosed,\n    message: 'transport is closed',\n    retryable: true,\n  }\n}\n\nfunction asErrorObject(value: unknown): ErrorObject | undefined {\n  if (typeof value !== 'object' || value === null) return undefined\n  const candidate = value as {\n    code?: unknown\n    message?: unknown\n    data?: unknown\n    retryable?: unknown\n  }\n  if (typeof candidate.code !== 'string' || !isAcpErrorCode(candidate.code)) {\n    return undefined\n  }\n  return {\n    code: candidate.code,\n    message: typeof candidate.message === 'string' ? candidate.message : '',\n    ...(candidate.data === undefined ? {} : { data: candidate.data }),\n    retryable: candidate.retryable === true,\n  }\n}\n\nexport function toClientError(value: unknown): AcpClientError {\n  if (value instanceof AcpClientError) return value\n  const errorObject = asErrorObject(value)\n  if (errorObject) return new AcpClientError(errorObject)\n  const message =\n    value instanceof Error\n      ? value.message\n      : typeof value === 'string'\n        ? value\n        : 'unknown error'\n  return new AcpClientError({\n    code: ACP_ERROR_CODES.agentError,\n    message,\n    retryable: false,\n  })\n}\n","import type { ChangeListener } from './types.ts'\n\nexport type RpcCall = (\n  method: string,\n  params: Record<string, unknown>,\n) => Promise<unknown>\n\nexport function notifyChange(listeners: ReadonlySet<ChangeListener>): void {\n  for (const listener of listeners) {\n    try {\n      listener()\n    } catch {}\n  }\n}\n","import {\n  ACP_RPC_METHODS,\n  type AgentSnapshotWire,\n  type AgentStatusChangePayload,\n  type AuthRequiredPayload,\n  type CreateSessionResult,\n  type ListSessionsResponse,\n} from '@acpjs/protocol'\n\nimport { AcpClientError } from './errors.ts'\nimport { notifyChange, type RpcCall } from './internal.ts'\n\nimport type {\n  AcpAgent,\n  AcpSession,\n  ChangeListener,\n  SessionCreateParams,\n  SessionListParams,\n} from './types.ts'\n\nexport interface AgentHandle {\n  agent: AcpAgent\n  applyStatus: (payload: AgentStatusChangePayload) => void\n  applyAuthRequired: (payload: AuthRequiredPayload) => void\n}\n\nfunction sameAuthMethods(\n  current: AgentSnapshotWire['authMethods'],\n  next: AuthRequiredPayload['authMethods'],\n): boolean {\n  if (current === undefined) return next.length === 0\n  if (current.length !== next.length) return false\n  return current.every((method, index) => method.id === next[index]?.id)\n}\n\nfunction sameRuntimeState(\n  current: AgentSnapshotWire,\n  payload: AgentStatusChangePayload,\n): boolean {\n  return (\n    current.status === payload.status &&\n    current.restartCount === payload.restartCount &&\n    current.reason === payload.reason &&\n    current.exit?.code === payload.exit?.code &&\n    current.exit?.signal === payload.exit?.signal\n  )\n}\n\nexport function createAgentHandle(\n  call: RpcCall,\n  openSession: (sessionId: string) => AcpSession,\n  onStatusChanged: () => void,\n  snapshot: AgentSnapshotWire,\n): AgentHandle {\n  const agentId = snapshot.agentId\n  let current = snapshot\n  const listeners = new Set<ChangeListener>()\n  const agent: AcpAgent = Object.freeze({\n    agentId,\n    ...(snapshot.capabilities === undefined\n      ? {}\n      : { capabilities: snapshot.capabilities }),\n    ...(snapshot.authMethods === undefined\n      ? {}\n      : { authMethods: snapshot.authMethods }),\n    getSnapshot: () => current,\n    subscribe(listener: ChangeListener): () => void {\n      listeners.add(listener)\n      return () => listeners.delete(listener)\n    },\n    sessions: Object.freeze({\n      async create(params: SessionCreateParams): Promise<AcpSession> {\n        const result = (await call(ACP_RPC_METHODS.createSession, {\n          agentId,\n          cwd: params.cwd,\n          ...(params.mcpServers === undefined\n            ? {}\n            : { mcpServers: params.mcpServers }),\n        })) as CreateSessionResult\n        if (result.status === 'auth-required') {\n          throw new AcpClientError({\n            code: 'acpjs/auth-required',\n            message: 'agent requires authentication',\n            data: { authMethods: result.authMethods },\n            retryable: true,\n          })\n        }\n        return openSession(result.sessionId)\n      },\n      async load(\n        sessionId: string,\n        params: SessionCreateParams,\n      ): Promise<AcpSession> {\n        await call(ACP_RPC_METHODS.loadSession, {\n          agentId,\n          sessionId,\n          cwd: params.cwd,\n          ...(params.mcpServers === undefined\n            ? {}\n            : { mcpServers: params.mcpServers }),\n        })\n        return openSession(sessionId)\n      },\n      async list(\n        params: SessionListParams = {},\n      ): Promise<ListSessionsResponse> {\n        return (await call(ACP_RPC_METHODS.listSessions, {\n          agentId,\n          ...(params.cursor === undefined ? {} : { cursor: params.cursor }),\n          ...(params.cwd === undefined ? {} : { cwd: params.cwd }),\n        })) as ListSessionsResponse\n      },\n      async resume(sessionId: string): Promise<AcpSession> {\n        await call(ACP_RPC_METHODS.resumeSession, { sessionId })\n        return openSession(sessionId)\n      },\n      async delete(sessionId: string): Promise<void> {\n        await call(ACP_RPC_METHODS.deleteSession, { sessionId })\n      },\n    }),\n    async authenticate(methodId: string): Promise<void> {\n      await call(ACP_RPC_METHODS.authenticate, { agentId, methodId })\n    },\n    async logout(): Promise<void> {\n      await call(ACP_RPC_METHODS.logout, { agentId })\n    },\n  })\n  return {\n    agent,\n    applyStatus(payload: AgentStatusChangePayload): void {\n      if (sameRuntimeState(current, payload)) return\n      current = {\n        agentId,\n        status: payload.status,\n        restartCount: payload.restartCount,\n        ...(payload.reason === undefined ? {} : { reason: payload.reason }),\n        ...(payload.exit === undefined ? {} : { exit: payload.exit }),\n        ...(current.capabilities === undefined\n          ? {}\n          : { capabilities: current.capabilities }),\n        ...(current.authMethods === undefined\n          ? {}\n          : { authMethods: current.authMethods }),\n        ...(current.authRequired === undefined\n          ? {}\n          : { authRequired: current.authRequired }),\n      }\n      notifyChange(listeners)\n      onStatusChanged()\n    },\n    applyAuthRequired(payload: AuthRequiredPayload): void {\n      if (\n        current.authRequired === true &&\n        sameAuthMethods(current.authMethods, payload.authMethods)\n      ) {\n        return\n      }\n      current = {\n        ...current,\n        authRequired: true,\n        authMethods: payload.authMethods,\n      }\n      notifyChange(listeners)\n      onStatusChanged()\n    },\n  }\n}\n","import type { PermissionListener, PermissionRequest } from './types.ts'\n\nexport interface PermissionRegistry {\n  getSnapshot: () => readonly PermissionRequest[]\n  subscribe: (listener: PermissionListener) => () => void\n  add: (request: PermissionRequest) => void\n  prune: (requestId: string) => void\n  reset: () => void\n  clear: () => void\n}\n\nexport function createPermissionRegistry(): PermissionRegistry {\n  const pending = new Map<string, PermissionRequest>()\n  const listeners = new Set<PermissionListener>()\n  let snapshot: readonly PermissionRequest[] = Object.freeze([])\n\n  function publish(): void {\n    snapshot = Object.freeze([...pending.values()])\n    for (const listener of listeners) {\n      try {\n        listener(snapshot)\n      } catch {}\n    }\n  }\n\n  return {\n    getSnapshot: () => snapshot,\n    subscribe(listener) {\n      listeners.add(listener)\n      return () => listeners.delete(listener)\n    },\n    add(request) {\n      pending.set(request.requestId, request)\n      publish()\n    },\n    prune(requestId) {\n      if (pending.delete(requestId)) publish()\n    },\n    reset() {\n      if (pending.size === 0) return\n      pending.clear()\n      publish()\n    },\n    clear() {\n      pending.clear()\n      publish()\n      listeners.clear()\n    },\n  }\n}\n","import {\n  ACP_RPC_METHODS,\n  type ContentBlock,\n  type PromptFinishedPayload,\n  type SessionConfigOption,\n} from '@acpjs/protocol'\n\nimport type { RpcCall } from './internal.ts'\nimport type { SessionStore, StateListener } from './store.ts'\nimport type { AcpSession, SessionConfigValue } from './types.ts'\n\nexport function createSessionHandle(\n  call: RpcCall,\n  store: SessionStore,\n): AcpSession {\n  const sessionId = store.sessionId\n  return Object.freeze({\n    sessionId,\n    getSnapshot: () => store.getSnapshot(),\n    subscribe: (listener: StateListener) => store.subscribe(listener),\n    async prompt(blocks: ContentBlock[]): Promise<PromptFinishedPayload> {\n      return (await call(ACP_RPC_METHODS.prompt, {\n        sessionId,\n        prompt: blocks,\n      })) as PromptFinishedPayload\n    },\n    async cancel(): Promise<void> {\n      await call(ACP_RPC_METHODS.cancel, { sessionId })\n    },\n    async close(): Promise<void> {\n      await call(ACP_RPC_METHODS.closeSession, { sessionId })\n    },\n    async setMode(modeId: string): Promise<void> {\n      await call(ACP_RPC_METHODS.setMode, { sessionId, modeId })\n    },\n    async setConfigOption(\n      configId: string,\n      value: SessionConfigValue,\n    ): Promise<SessionConfigOption[]> {\n      return (await call(ACP_RPC_METHODS.setConfigOption, {\n        sessionId,\n        configId,\n        value,\n      })) as SessionConfigOption[]\n    },\n  })\n}\n","import {\n  createInitialSessionState,\n  reduce,\n  type AcpEvent,\n  type SessionState,\n} from '@acpjs/protocol'\n\nexport type StateListener = (state: SessionState) => void\n\nexport interface SessionStore {\n  readonly sessionId: string\n  getSnapshot: () => SessionState\n  subscribe: (listener: StateListener) => () => void\n  apply: (event: AcpEvent) => void\n  lastSeq: () => number\n}\n\nexport function createSessionStore(sessionId: string): SessionStore {\n  let state = createInitialSessionState(sessionId)\n  let lastSeq = 0\n  const listeners = new Set<StateListener>()\n  return {\n    sessionId,\n    getSnapshot: () => state,\n    subscribe(listener) {\n      listeners.add(listener)\n      return () => listeners.delete(listener)\n    },\n    apply(event) {\n      if (!('sessionId' in event) || event.sessionId !== sessionId) return\n      if (event.seq <= lastSeq) return\n      lastSeq = event.seq\n      const next = reduce(state, event)\n      if (next === state) return\n      state = next\n      for (const listener of listeners) {\n        try {\n          listener(state)\n        } catch {}\n      }\n    },\n    lastSeq: () => lastSeq,\n  }\n}\n","import {\n  ACP_ERROR_CODES,\n  ACP_RPC_METHODS,\n  type AcpEvent,\n  type AgentSnapshotWire,\n  type AgentStatusChangePayload,\n  type AuthRequiredPayload,\n  type ErrorObject,\n  type PermissionRequestCreatedPayload,\n  type RequestPermissionOutcome,\n  type SessionSnapshotWire,\n  type TransportHandlers,\n} from '@acpjs/protocol'\n\nimport { createAgentHandle } from './agent-handle.ts'\nimport {\n  AcpClientError,\n  toClientError,\n  transportClosedError,\n} from './errors.ts'\nimport { notifyChange } from './internal.ts'\nimport { createPermissionRegistry } from './permission-registry.ts'\nimport { createSessionHandle } from './session-handle.ts'\nimport { createSessionStore, type SessionStore } from './store.ts'\n\nimport type {\n  AcpAgent,\n  AcpClient,\n  AcpSession,\n  AgentDefinition,\n  ChangeListener,\n  ConnectionStatusSnapshot,\n  CreateAcpClientOptions,\n  PermissionRequest,\n} from './types.ts'\n\nexport function createAcpClient(options: CreateAcpClientOptions): AcpClient {\n  const transport = options.transport\n  let closedError: ErrorObject | undefined\n  const stores = new Map<string, SessionStore>()\n  const storeUnsubscribers = new Set<() => void>()\n  const agents = new Map<string, AcpAgent>()\n  const agentListeners = new Set<ChangeListener>()\n  const agentUpdaters = new Map<\n    string,\n    {\n      applyStatus: (payload: AgentStatusChangePayload) => void\n      applyAuthRequired: (payload: AuthRequiredPayload) => void\n    }\n  >()\n  let agentsSnapshot: readonly AcpAgent[] = Object.freeze([])\n\n  function publishAgents(): void {\n    agentsSnapshot = Object.freeze([...agents.values()])\n    notifyChange(agentListeners)\n  }\n\n  const sessions = new Map<string, AcpSession>()\n  const sessionListeners = new Set<ChangeListener>()\n  let sessionsSnapshot: readonly AcpSession[] = Object.freeze([])\n\n  function publishSessions(): void {\n    sessionsSnapshot = Object.freeze([...sessions.values()])\n    notifyChange(sessionListeners)\n  }\n\n  const permissions = createPermissionRegistry()\n\n  let statusSnapshot: ConnectionStatusSnapshot = Object.freeze({\n    status: 'connecting' as const,\n  })\n  const statusListeners = new Set<ChangeListener>()\n\n  function ensureOpen(): void {\n    if (closedError) throw new AcpClientError(closedError)\n  }\n\n  const handlers: TransportHandlers = {\n    onInboundRequest(request) {\n      if (request.kind !== 'permission') return\n      const payload = request.payload as PermissionRequestCreatedPayload & {\n        sessionId: string\n      }\n      const permission: PermissionRequest = Object.freeze({\n        requestId: payload.requestId,\n        sessionId: payload.sessionId,\n        toolCall: payload.toolCall,\n        options: payload.options,\n        respond: (outcome: RequestPermissionOutcome) =>\n          respondPermission(request.id, payload.requestId, outcome),\n      })\n      permissions.add(permission)\n    },\n    onLifecycle(event) {\n      if (event.status === 'closed') {\n        closedError = event.error ?? transportClosedError()\n        permissions.reset()\n      }\n      if (\n        statusSnapshot.status === event.status &&\n        statusSnapshot.error === event.error\n      ) {\n        return\n      }\n      statusSnapshot = Object.freeze({\n        status: event.status,\n        ...(event.error === undefined ? {} : { error: event.error }),\n      })\n      notifyChange(statusListeners)\n    },\n  }\n\n  function onHostEvent(event: AcpEvent): void {\n    if (event.type === 'agent-status-change') {\n      agentUpdaters.get(event.agentId)?.applyStatus(event.payload)\n    } else if (event.type === 'auth-required') {\n      agentUpdaters.get(event.agentId)?.applyAuthRequired(event.payload)\n    } else if (\n      event.type === 'session-created' ||\n      event.type === 'session-closed'\n    ) {\n      notifyChange(sessionListeners)\n    }\n  }\n\n  const connected = transport.connect(handlers)\n  connected\n    .then(() => {\n      if (closedError) return\n      storeUnsubscribers.add(transport.subscribe({ fromSeq: 0 }, onHostEvent))\n    })\n    .catch(() => {})\n\n  async function respondPermission(\n    inboundId: string,\n    requestId: string,\n    outcome: RequestPermissionOutcome,\n  ): Promise<void> {\n    ensureOpen()\n    try {\n      await connected\n      await transport.respondInbound({ id: inboundId, result: outcome })\n    } catch (error) {\n      const clientError = toClientError(error)\n      if (clientError.code === ACP_ERROR_CODES.alreadyAnswered) {\n        permissions.prune(requestId)\n      }\n      throw clientError\n    }\n    permissions.prune(requestId)\n  }\n\n  let rpcCounter = 0\n  async function call(\n    method: string,\n    params: Record<string, unknown>,\n  ): Promise<unknown> {\n    ensureOpen()\n    try {\n      await connected\n    } catch (error) {\n      throw toClientError(error)\n    }\n    ensureOpen()\n    rpcCounter += 1\n    let response\n    try {\n      response = await transport.request({\n        id: `rpc-${rpcCounter}`,\n        method,\n        params,\n      })\n    } catch (error) {\n      throw toClientError(error)\n    }\n    if (!response.ok) throw new AcpClientError(response.error)\n    return response.result\n  }\n\n  function attachStore(sessionId: string): SessionStore {\n    const existing = stores.get(sessionId)\n    if (existing) return existing\n    const store = createSessionStore(sessionId)\n    stores.set(sessionId, store)\n    const unsubscribe = transport.subscribe(\n      { sessionId, fromSeq: store.lastSeq() },\n      (event) => {\n        if (event.type === 'permission-request-resolved') {\n          permissions.prune(event.payload.requestId)\n        }\n        store.apply(event)\n      },\n    )\n    storeUnsubscribers.add(unsubscribe)\n    return store\n  }\n\n  function openSession(sessionId: string): AcpSession {\n    const existing = sessions.get(sessionId)\n    if (existing) return existing\n    const session = createSessionHandle(call, attachStore(sessionId))\n    sessions.set(sessionId, session)\n    publishSessions()\n    return session\n  }\n\n  async function listAgents(): Promise<readonly AgentSnapshotWire[]> {\n    return (await call(ACP_RPC_METHODS.listAgents, {})) as AgentSnapshotWire[]\n  }\n\n  async function listAllSessions(): Promise<readonly SessionSnapshotWire[]> {\n    return (await call(\n      ACP_RPC_METHODS.getAllSessions,\n      {},\n    )) as SessionSnapshotWire[]\n  }\n\n  function registerAgent(snapshot: AgentSnapshotWire): AcpAgent {\n    const { agent, applyStatus, applyAuthRequired } = createAgentHandle(\n      call,\n      openSession,\n      publishAgents,\n      snapshot,\n    )\n    agentUpdaters.set(agent.agentId, { applyStatus, applyAuthRequired })\n    agents.set(agent.agentId, agent)\n    publishAgents()\n    return agent\n  }\n\n  return Object.freeze({\n    agents: Object.freeze({\n      async spawn(definition: AgentDefinition): Promise<AcpAgent> {\n        const snapshot = (await call(ACP_RPC_METHODS.spawnAgent, {\n          definition,\n        })) as AgentSnapshotWire\n        return registerAgent(snapshot)\n      },\n      get: (agentId: string) => agents.get(agentId),\n      getSnapshot: () => agentsSnapshot,\n      subscribe(listener: ChangeListener): () => void {\n        agentListeners.add(listener)\n        return () => agentListeners.delete(listener)\n      },\n      list: listAgents,\n      async attach(agentId: string): Promise<AcpAgent> {\n        const snapshots = await listAgents()\n        const snapshot = snapshots.find(\n          (candidate) => candidate.agentId === agentId,\n        )\n        if (!snapshot) {\n          throw new AcpClientError({\n            code: ACP_ERROR_CODES.agentExited,\n            message: `agent ${agentId} is not known to the host`,\n            retryable: false,\n          })\n        }\n        return agents.get(agentId) ?? registerAgent(snapshot)\n      },\n    }),\n    sessions: Object.freeze({\n      get: (sessionId: string) => sessions.get(sessionId),\n      getSnapshot: () => sessionsSnapshot,\n      subscribe(listener: ChangeListener): () => void {\n        sessionListeners.add(listener)\n        return () => sessionListeners.delete(listener)\n      },\n      list: listAllSessions,\n      async attach(sessionId: string): Promise<AcpSession> {\n        const snapshots = await listAllSessions()\n        const known = snapshots.some(\n          (candidate) => candidate.sessionId === sessionId,\n        )\n        if (!known) {\n          throw new AcpClientError({\n            code: ACP_ERROR_CODES.sessionClosed,\n            message: `session ${sessionId} is not known to the host`,\n            retryable: false,\n          })\n        }\n        return openSession(sessionId)\n      },\n      async restore(): Promise<readonly SessionSnapshotWire[]> {\n        return (await call(\n          ACP_RPC_METHODS.restoreSessions,\n          {},\n        )) as SessionSnapshotWire[]\n      },\n    }),\n    permissions: Object.freeze({\n      getSnapshot: permissions.getSnapshot,\n      subscribe: permissions.subscribe,\n    }),\n    status: Object.freeze({\n      getSnapshot: () => statusSnapshot,\n      subscribe(listener: ChangeListener): () => void {\n        statusListeners.add(listener)\n        return () => statusListeners.delete(listener)\n      },\n    }),\n    async dispose(): Promise<void> {\n      if (closedError) return\n      closedError = transportClosedError()\n      for (const unsubscribe of storeUnsubscribers) unsubscribe()\n      storeUnsubscribers.clear()\n      permissions.clear()\n      await transport.close()\n    },\n  })\n}\n","import {\n  ACP_ERROR_CODES,\n  type EnvelopeEndpoint,\n  type Transport,\n  type TransportConnectionStatus,\n  type TransportHandlers,\n} from '@acpjs/protocol'\n\nimport { AcpClientError, transportClosedError } from './errors.ts'\n\nexport function createInProcessTransport(\n  endpoint: EnvelopeEndpoint,\n): Transport {\n  let status: TransportConnectionStatus = 'connecting'\n  let handlers: TransportHandlers | undefined\n  const unsubscribers = new Set<() => void>()\n  let detachInbound: (() => void) | undefined\n\n  return {\n    async connect(next: TransportHandlers): Promise<void> {\n      if (status === 'closed') {\n        throw new AcpClientError(transportClosedError())\n      }\n      if (handlers) {\n        throw new AcpClientError({\n          code: ACP_ERROR_CODES.configInvalid,\n          message: 'transport already connected',\n          retryable: false,\n        })\n      }\n      handlers = next\n      next.onLifecycle({ status: 'connecting' })\n      detachInbound = endpoint.onInboundRequest((request) => {\n        next.onInboundRequest(request)\n      })\n      status = 'connected'\n      next.onLifecycle({ status: 'connected' })\n    },\n    async request(request) {\n      if (status !== 'connected') {\n        return { id: request.id, ok: false, error: transportClosedError() }\n      }\n      return endpoint.request(request)\n    },\n    subscribe(params, onEvent) {\n      if (status !== 'connected') {\n        throw new AcpClientError(transportClosedError())\n      }\n      const unsubscribe = endpoint.subscribe(params, onEvent)\n      unsubscribers.add(unsubscribe)\n      return () => {\n        unsubscribers.delete(unsubscribe)\n        unsubscribe()\n      }\n    },\n    async respondInbound(response) {\n      if (status !== 'connected') {\n        throw new AcpClientError(transportClosedError())\n      }\n      await endpoint.respondInbound(response)\n    },\n    async close() {\n      if (status === 'closed') return\n      status = 'closed'\n      detachInbound?.()\n      for (const unsubscribe of unsubscribers) unsubscribe()\n      unsubscribers.clear()\n      handlers?.onLifecycle({ status: 'closed' })\n    },\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@acpjs/client",
+  "version": "0.1.0",
+  "description": "acpjs typed facade, reducer-driven snapshot+subscribe store, and in-process transport.",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@acpjs/protocol": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.2",
+    "@acpjs/core": "0.1.0",
+    "@acpjs/fixture-agent": "0.0.0"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  }
+}