@trycua/cua 0.2.0

package/dist/spaces/thread.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Agent threads: an agent CLI running a task in a Space, with an explicit
+ * isolation choice, a closed status ladder, and derived events.
+ *
+ * The run itself is the SDK's (`Space.agentStart` / `agentStatus` /
+ * `agentMessage` / `agentStop`, the same implementation as the Spaces MCP
+ * `agent_*` tools): a detached, tagged cua-spacesd process whose status is
+ * read from process liveness and its recorded exit code. This module adds
+ * what an app needs on top: a placement you have to choose, per-Space turn
+ * serialization for shared Spaces, and `events()`.
+ */
+import type { SpaceLike, SpacesLike } from "../native/index.js";
+import { type AgentStatus, type ThreadEvent, type ThreadStatus } from "./events.js";
+/** Agent CLIs the Spaces runtime can start (the contract's `AGENT_IDS`). */
+export type AgentId = "claude-code" | "gemini-cli" | "google-antigravity" | "goose" | "hermes" | "openai-codex" | "openclaw" | "opencode" | "pi";
+export declare const AGENT_IDS: readonly AgentId[];
+/** Statuses after which `events()` stops polling. */
+export declare const SETTLED: ReadonlySet<AgentStatus>;
+/**
+ * Where a thread's agent runs. There is no default; choosing is the point.
+ */
+export type ThreadPlacement = {
+    type: "dedicated";
+    /** Image of the Space this thread creates (default: the canonical Linux image). */
+    image?: string;
+    /** Where: `local` or `cloud` (default: the user's default location). */
+    on?: string;
+    /** `auto` (default), `container` or `vm`. */
+    kind?: string;
+    /** `auto` (default) or an engine the location offers for the kind. */
+    runtime?: string;
+    /** Delete the Space when the thread closes. Default true. */
+    deleteOnClose?: boolean;
+} | {
+    type: "shared";
+    /** The Space (id or handle) to place this thread on. */
+    space: string | SpaceLike;
+    /**
+     * Required, and required to be literally `true`: this thread shares a
+     * filesystem, a browser profile, cookies and every app login with every
+     * other thread on the Space; nothing inside a Space is a security
+     * boundary.
+     */
+    acknowledgeNoIsolation: true;
+};
+/** Throws unless the caller genuinely chose a placement. */
+export declare function validatePlacement(placement: ThreadPlacement | undefined): ThreadPlacement;
+/** One delivered (or refused) message. */
+export interface Turn {
+    id: string;
+    text: string;
+    /** `delivered` means the process started, not that the work is done. */
+    state: "delivered" | "refused";
+    /** The turn this one waited behind on a shared Space, if any. */
+    queuedBehind?: string;
+    reason: string;
+}
+/**
+ * Serializes turns per Space, shared by every thread on that Space, so two
+ * bots on one Space take the Space in turn instead of fighting over it.
+ */
+export declare class SpaceTurnLock {
+    private tail;
+    private activeTurn;
+    /** The turn currently holding the Space, or null. */
+    get active(): string | null;
+    /** Queues `turnId` now (call order, not scheduling order). */
+    enqueue(turnId: string): {
+        waitingBehind: string | null;
+        acquired: Promise<() => void>;
+    };
+    private take;
+}
+/** One lock per Space id, so two handles to the same Space share it. */
+export declare function lockFor(spaceId: string): SpaceTurnLock;
+export interface StartThreadOptions {
+    agent: AgentId;
+    /** The first task. There is no empty thread. */
+    prompt: string;
+    placement: ThreadPlacement;
+    /** Your own label, echoed on the thread. */
+    label?: string;
+    /** Open a terminal on the Space desktop tailing the run (default false). */
+    show?: boolean;
+}
+/** Starts an agent thread. `placement` is required and has no default. */
+export declare function startThread(spaces: SpacesLike, options: StartThreadOptions): Promise<Thread>;
+/** Adopts a run that already exists (started by another process or the MCP). */
+export declare function adoptThread(spaces: SpacesLike, spaceId: string, runId: string): Promise<Thread>;
+export interface EventOptions {
+    /** Hard bound on status polls (default 600). */
+    maxPolls?: number;
+    /** Delay between polls (default 1000 ms). */
+    intervalMs?: number;
+    /** Lines of output per poll (default 200). */
+    tail?: number;
+    signal?: AbortSignal;
+}
+/** An agent run in a Space. */
+export declare class Thread {
+    readonly runId: string;
+    readonly agent: AgentId;
+    readonly space: SpaceLike;
+    /** `space` when the thread has its Space to itself, `none` when shared. */
+    readonly isolation: "space" | "none";
+    readonly label: string | undefined;
+    /** Preparation steps the runtime could not complete, named. */
+    readonly notes: string[];
+    private readonly spaces;
+    private readonly deleteOnClose;
+    private readonly adapter;
+    private turns;
+    constructor(init: {
+        runId: string;
+        agent: AgentId;
+        space: SpaceLike;
+        spaces: SpacesLike;
+        isolation: "space" | "none";
+        deleteOnClose: boolean;
+        label?: string | undefined;
+        notes?: string[];
+    });
+    get id(): string;
+    /** The run's status on the closed ladder, with the raw output tail. */
+    status(tail?: number): Promise<ThreadStatus>;
+    /**
+     * Sends a follow-up. Turns on one Space are serialized. A run whose
+     * published `acceptsMessage` is false (a turn is running, or it could not
+     * be read) refuses unless `force`, and the refusal is returned, not hidden.
+     */
+    send(text: string, options?: {
+        force?: boolean;
+    }): Promise<Turn>;
+    /**
+     * Polls the run and yields derived events: text, files, links, approval
+     * prompts, and a `state` event on every status change. Stops once the run
+     * settles or after `maxPolls` (bounded).
+     */
+    events(options?: EventOptions): AsyncGenerator<ThreadEvent>;
+    /** Stops the run; `stopped` says whether its death was witnessed. */
+    stop(): Promise<{
+        stopped: boolean;
+        reason: string;
+    }>;
+    /** Stops the run and deletes a dedicated Space created for it. */
+    close(): Promise<void>;
+}

package/dist/spaces/thread.js

@@ -0,0 +1,285 @@
+/**
+ * Agent threads: an agent CLI running a task in a Space, with an explicit
+ * isolation choice, a closed status ladder, and derived events.
+ *
+ * The run itself is the SDK's (`Space.agentStart` / `agentStatus` /
+ * `agentMessage` / `agentStop`, the same implementation as the Spaces MCP
+ * `agent_*` tools): a detached, tagged cua-spacesd process whose status is
+ * read from process liveness and its recorded exit code. This module adds
+ * what an app needs on top: a placement you have to choose, per-Space turn
+ * serialization for shared Spaces, and `events()`.
+ */
+import { SpacesError, wrapErrors } from "./errors.js";
+import { TranscriptAdapter } from "./events.js";
+export const AGENT_IDS = [
+    "claude-code",
+    "gemini-cli",
+    "google-antigravity",
+    "goose",
+    "hermes",
+    "openai-codex",
+    "openclaw",
+    "opencode",
+    "pi",
+];
+/** Statuses after which `events()` stops polling. */
+export const SETTLED = new Set([
+    "idle",
+    "awaiting_input",
+    "finished",
+    "failed",
+    "crashed",
+]);
+/** Throws unless the caller genuinely chose a placement. */
+export function validatePlacement(placement) {
+    if (!placement || typeof placement !== "object") {
+        throw SpacesError.usage("a thread needs an explicit placement: { type: 'dedicated' } for its own Space, or " +
+            "{ type: 'shared', space, acknowledgeNoIsolation: true } to share one. There is no " +
+            "default because the two have different security properties.");
+    }
+    if (placement.type === "dedicated")
+        return placement;
+    if (placement.type === "shared") {
+        if (placement.acknowledgeNoIsolation !== true) {
+            throw new SpacesError("isolation", "shared placement requires acknowledgeNoIsolation: true. Threads on one Space share " +
+                "a filesystem, a browser profile, cookies and every app login; a screen or a window " +
+                "inside a Space is not a security boundary. This is the shared-coworker shape and it is a " +
+                "fine choice — but the SDK will not make it for you.");
+        }
+        if (!placement.space)
+            throw SpacesError.usage("shared placement requires a space");
+        return placement;
+    }
+    throw SpacesError.usage(`unknown placement type ${JSON.stringify(placement.type)}`);
+}
+/**
+ * Serializes turns per Space, shared by every thread on that Space, so two
+ * bots on one Space take the Space in turn instead of fighting over it.
+ */
+export class SpaceTurnLock {
+    tail = Promise.resolve();
+    activeTurn = null;
+    /** The turn currently holding the Space, or null. */
+    get active() {
+        return this.activeTurn;
+    }
+    /** Queues `turnId` now (call order, not scheduling order). */
+    enqueue(turnId) {
+        const waitingBehind = this.activeTurn;
+        let open;
+        const gate = new Promise((resolve) => {
+            open = resolve;
+        });
+        const previous = this.tail;
+        // A failed turn must not wedge the Space forever.
+        this.tail = previous.then(() => gate, () => gate);
+        const acquired = previous.then(() => this.take(turnId, open), () => this.take(turnId, open));
+        return { waitingBehind, acquired };
+    }
+    take(turnId, open) {
+        this.activeTurn = turnId;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            if (this.activeTurn === turnId)
+                this.activeTurn = null;
+            open();
+        };
+    }
+}
+const locksById = new Map();
+/** One lock per Space id, so two handles to the same Space share it. */
+export function lockFor(spaceId) {
+    let lock = locksById.get(spaceId);
+    if (!lock) {
+        lock = new SpaceTurnLock();
+        locksById.set(spaceId, lock);
+    }
+    return lock;
+}
+/** Starts an agent thread. `placement` is required and has no default. */
+export async function startThread(spaces, options) {
+    const placement = validatePlacement(options.placement);
+    if (!options.prompt)
+        throw SpacesError.usage("startThread requires a prompt");
+    if (!AGENT_IDS.includes(options.agent)) {
+        throw SpacesError.usage(`unknown agent ${JSON.stringify(options.agent)}; known: ${AGENT_IDS.join(", ")}`);
+    }
+    return wrapErrors(async () => {
+        let space;
+        let deleteOnClose = false;
+        if (placement.type === "dedicated") {
+            const options = {
+                image: placement.image,
+                on: placement.on,
+                kind: placement.kind,
+                runtime: placement.runtime,
+                name: undefined,
+                wait: true,
+                reuse: false,
+            };
+            const created = await spaces.create(options);
+            if (!created.space)
+                throw SpacesError.protocol("the Space did not become ready");
+            space = await spaces.space(created.space.id);
+            deleteOnClose = placement.deleteOnClose !== false;
+        }
+        else {
+            space = typeof placement.space === "string" ? await spaces.space(placement.space) : placement.space;
+        }
+        const started = await space.agentStart(options.agent, options.prompt, options.show ?? false, undefined);
+        return new Thread({
+            runId: started.runId,
+            agent: options.agent,
+            space,
+            spaces,
+            isolation: placement.type === "dedicated" ? "space" : "none",
+            deleteOnClose,
+            label: options.label,
+            notes: started.notes,
+        });
+    });
+}
+/** Adopts a run that already exists (started by another process or the MCP). */
+export async function adoptThread(spaces, spaceId, runId) {
+    return wrapErrors(async () => {
+        const space = await spaces.space(spaceId);
+        const status = await space.agentStatus(runId, 0);
+        if (!status.agent) {
+            // No run record: say so, and say why when the Space was unreachable.
+            const unreachable = /could not reach/.test(status.reason);
+            throw new SpacesError(unreachable ? "transport" : "not_found", `${runId}: ${status.reason}`);
+        }
+        return new Thread({
+            runId,
+            agent: status.agent,
+            space,
+            spaces,
+            isolation: "space",
+            deleteOnClose: false,
+        });
+    });
+}
+/** An agent run in a Space. */
+export class Thread {
+    runId;
+    agent;
+    space;
+    /** `space` when the thread has its Space to itself, `none` when shared. */
+    isolation;
+    label;
+    /** Preparation steps the runtime could not complete, named. */
+    notes;
+    spaces;
+    deleteOnClose;
+    adapter = new TranscriptAdapter();
+    turns = 0;
+    constructor(init) {
+        this.runId = init.runId;
+        this.agent = init.agent;
+        this.space = init.space;
+        this.spaces = init.spaces;
+        this.isolation = init.isolation;
+        this.deleteOnClose = init.deleteOnClose;
+        this.label = init.label;
+        this.notes = init.notes ?? [];
+    }
+    get id() {
+        return `thread-${this.runId}`;
+    }
+    /** The run's status on the closed ladder, with the raw output tail. */
+    async status(tail = 200) {
+        const s = await wrapErrors(() => this.space.agentStatus(this.runId, tail));
+        return {
+            runId: s.runId || this.runId,
+            status: asStatus(s.status),
+            reason: s.reason,
+            acceptsMessage: s.acceptsMessage,
+            transcript: s.outputTail ?? "",
+            desktopWindow: null,
+        };
+    }
+    /**
+     * Sends a follow-up. Turns on one Space are serialized. A run whose
+     * published `acceptsMessage` is false (a turn is running, or it could not
+     * be read) refuses unless `force`, and the refusal is returned, not hidden.
+     */
+    async send(text, options = {}) {
+        if (!text)
+            throw SpacesError.usage("send requires text");
+        const turnId = `${this.runId}-turn-${++this.turns}`;
+        const lock = lockFor(this.space.id());
+        const { waitingBehind, acquired } = lock.enqueue(turnId);
+        const release = await acquired;
+        try {
+            if (!options.force) {
+                // The server's rule, never re-derived from the status word here.
+                const s = await wrapErrors(() => this.space.agentStatus(this.runId, 0));
+                if (!s.acceptsMessage) {
+                    const turn = { id: turnId, text, state: "refused", reason: `${s.status}: ${s.reason}` };
+                    if (waitingBehind)
+                        turn.queuedBehind = waitingBehind;
+                    return turn;
+                }
+            }
+            const r = await wrapErrors(() => this.space.agentMessage(this.runId, text, options.force ?? false));
+            const turn = { id: turnId, text, state: r.ok ? "delivered" : "refused", reason: r.reason };
+            if (waitingBehind)
+                turn.queuedBehind = waitingBehind;
+            return turn;
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * Polls the run and yields derived events: text, files, links, approval
+     * prompts, and a `state` event on every status change. Stops once the run
+     * settles or after `maxPolls` (bounded).
+     */
+    async *events(options = {}) {
+        const maxPolls = options.maxPolls ?? 600;
+        const interval = options.intervalMs ?? 1000;
+        let last;
+        let seq = 0;
+        for (let poll = 0; poll < maxPolls; poll++) {
+            if (options.signal?.aborted)
+                return;
+            const s = await this.status(options.tail ?? 200);
+            for (const event of this.adapter.ingest(s.transcript))
+                yield event;
+            if (s.status !== last) {
+                last = s.status;
+                const state = {
+                    kind: "state",
+                    state: s.status,
+                    reason: s.reason,
+                    seq: 1_000_000 + seq++,
+                    observedAt: new Date().toISOString(),
+                    derived: false,
+                };
+                yield state;
+            }
+            if (SETTLED.has(s.status))
+                return;
+            await new Promise((r) => setTimeout(r, interval));
+        }
+    }
+    /** Stops the run; `stopped` says whether its death was witnessed. */
+    async stop() {
+        const r = await wrapErrors(() => this.space.agentStop(this.runId));
+        return { stopped: r.ok, reason: r.reason };
+    }
+    /** Stops the run and deletes a dedicated Space created for it. */
+    async close() {
+        await this.stop().catch(() => undefined);
+        if (this.deleteOnClose)
+            await wrapErrors(() => this.spaces.delete_(this.space.id()));
+    }
+}
+function asStatus(value) {
+    const known = ["running", "awaiting_input", "idle", "finished", "failed", "crashed", "unknown"];
+    return known.includes(value) ? value : "unknown";
+}

package/dist/spaces/transport/http.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `McpHttpTransport`: the Spaces MCP server over streamable HTTP, as served
+ * by `cua daemon` at `<loopback>/mcp`.
+ *
+ * This is what a webview or browser uses when it can reach the daemon's
+ * loopback listener: `POST /mcp` with one JSON-RPC message, answered with
+ * `application/json`. The daemon mints an `Mcp-Session-Id` on `initialize`;
+ * every later request carries it, and a 404 means the session is gone (the
+ * daemon restarted), which this transport reports as a `TransportError` with
+ * code 404 so `McpSession` re-initializes on the next call.
+ *
+ * The bearer is the daemon's loopback token (`GetInfo.loopback_token`, or the
+ * `token` in `~/.cua/daemon.json`). Nothing here imports Node builtins.
+ */
+import { type RpcOutgoing, type RpcResponse, type SendOptions, type Transport } from "./types.js";
+/** The `fetch` shape this needs (the global one, or an injected fake). */
+export type FetchFn = (input: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}) => Promise<{
+    status: number;
+    ok: boolean;
+    headers: {
+        get(name: string): string | null;
+    };
+    text(): Promise<string>;
+}>;
+export interface McpHttpOptions {
+    /** Daemon loopback base URL (`http://127.0.0.1:<port>`) or the full `/mcp` URL. */
+    url: string;
+    /** The daemon's loopback bearer token. */
+    token?: string;
+    /** Inject a fetch (tests, a Tauri HTTP plugin). Defaults to `globalThis.fetch`. */
+    fetch?: FetchFn;
+}
+export declare const SESSION_HEADER = "mcp-session-id";
+export declare class McpHttpTransport implements Transport {
+    readonly kind = "http";
+    private readonly endpoint;
+    private readonly token;
+    private readonly doFetch;
+    private session;
+    constructor(options: McpHttpOptions);
+    /** The session id the daemon minted, once initialized. */
+    get sessionId(): string | undefined;
+    send(message: RpcOutgoing, options?: SendOptions): Promise<RpcResponse | null>;
+    /** Ends the MCP session (`DELETE /mcp`). Never throws. */
+    close(): Promise<void>;
+}

package/dist/spaces/transport/http.js

@@ -0,0 +1,113 @@
+/**
+ * `McpHttpTransport`: the Spaces MCP server over streamable HTTP, as served
+ * by `cua daemon` at `<loopback>/mcp`.
+ *
+ * This is what a webview or browser uses when it can reach the daemon's
+ * loopback listener: `POST /mcp` with one JSON-RPC message, answered with
+ * `application/json`. The daemon mints an `Mcp-Session-Id` on `initialize`;
+ * every later request carries it, and a 404 means the session is gone (the
+ * daemon restarted), which this transport reports as a `TransportError` with
+ * code 404 so `McpSession` re-initializes on the next call.
+ *
+ * The bearer is the daemon's loopback token (`GetInfo.loopback_token`, or the
+ * `token` in `~/.cua/daemon.json`). Nothing here imports Node builtins.
+ */
+import { TransportError, } from "./types.js";
+export const SESSION_HEADER = "mcp-session-id";
+export class McpHttpTransport {
+    kind = "http";
+    endpoint;
+    token;
+    doFetch;
+    session;
+    constructor(options) {
+        const base = options.url.replace(/\/+$/, "");
+        this.endpoint = base.endsWith("/mcp") ? base : `${base}/mcp`;
+        this.token = options.token;
+        const f = options.fetch ?? globalThis.fetch;
+        if (!f)
+            throw new TransportError("no fetch available; pass options.fetch");
+        this.doFetch = f;
+    }
+    /** The session id the daemon minted, once initialized. */
+    get sessionId() {
+        return this.session;
+    }
+    async send(message, options = {}) {
+        const headers = {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+        };
+        if (this.token)
+            headers.authorization = `Bearer ${this.token}`;
+        if (this.session && message.method !== "initialize")
+            headers[SESSION_HEADER] = this.session;
+        const controller = new AbortController();
+        const timer = options.timeoutSeconds === undefined
+            ? undefined
+            : setTimeout(() => controller.abort(), options.timeoutSeconds * 1000);
+        const onAbort = () => controller.abort();
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        let response;
+        try {
+            response = await this.doFetch(this.endpoint, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(message),
+                signal: controller.signal,
+            });
+        }
+        catch (cause) {
+            throw new TransportError(`${message.method}: the daemon at ${this.endpoint} did not answer (${String(cause)})`);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
+        }
+        const text = await response.text();
+        if (response.status === 404 && this.session) {
+            // The daemon forgot the session (it restarted): make the next call
+            // initialize again.
+            this.session = undefined;
+            throw new TransportError(`${message.method}: MCP session expired`, 404);
+        }
+        if (response.status === 401) {
+            throw new TransportError(`${message.method}: the daemon refused the bearer token`, 401);
+        }
+        if (!response.ok && response.status !== 202) {
+            throw new TransportError(`${message.method}: HTTP ${response.status} ${text.slice(0, 200)}`, response.status);
+        }
+        const minted = response.headers.get(SESSION_HEADER);
+        if (minted)
+            this.session = minted;
+        if (!("id" in message) || text.trim() === "")
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new TransportError(`${message.method}: the daemon returned non-JSON: ${text.slice(0, 200)}`);
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new TransportError(`${message.method}: the daemon returned a non-object reply`);
+        }
+        return parsed;
+    }
+    /** Ends the MCP session (`DELETE /mcp`). Never throws. */
+    async close() {
+        if (!this.session)
+            return;
+        const headers = { [SESSION_HEADER]: this.session };
+        if (this.token)
+            headers.authorization = `Bearer ${this.token}`;
+        this.session = undefined;
+        try {
+            await this.doFetch(this.endpoint, { method: "DELETE", headers });
+        }
+        catch {
+            /* the daemon is gone, which is the state we wanted */
+        }
+    }
+}

package/dist/spaces/transport/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@trycua/cua/spaces/transport`: the Spaces control plane for hosts that
+ * cannot load the native binding (a Tauri webview, a browser).
+ *
+ * Dependency-free TypeScript: `McpSession` speaks MCP to the Rust Spaces
+ * server over any `Transport`:
+ *
+ * - `McpHttpTransport`: the `cua daemon` loopback `/mcp` (streamable HTTP,
+ *   bearer = the daemon's loopback token);
+ * - `TauriTransport`: `invoke()` into the Tauri app's Rust side.
+ *
+ * Node code should use `@trycua/cua/spaces` (the typed SDK) instead. See
+ * `types.ts` for why the seam exchanges whole JSON-RPC messages rather than
+ * bytes.
+ */
+export { type Json, type RpcError, type RpcId, type RpcNotification, type RpcOutgoing, type RpcRequest, type RpcResponse, type SendOptions, type Transport, TransportError, } from "./types.js";
+export { type ClientInfo, type ContentPart, McpSession, PROTOCOL_VERSION, type ServerInfo, type SessionOptions, ToolError, type ToolDescriptor, type ToolResult, textOf, } from "./session.js";
+export { DEFAULT_REQUEST_COMMAND, DEFAULT_SHUTDOWN_COMMAND, type InvokeFn, TauriTransport, type TauriOptions, } from "./tauri.js";
+export { type FetchFn, McpHttpTransport, type McpHttpOptions, SESSION_HEADER } from "./http.js";

package/dist/spaces/transport/index.js

@@ -0,0 +1,19 @@
+/**
+ * `@trycua/cua/spaces/transport`: the Spaces control plane for hosts that
+ * cannot load the native binding (a Tauri webview, a browser).
+ *
+ * Dependency-free TypeScript: `McpSession` speaks MCP to the Rust Spaces
+ * server over any `Transport`:
+ *
+ * - `McpHttpTransport`: the `cua daemon` loopback `/mcp` (streamable HTTP,
+ *   bearer = the daemon's loopback token);
+ * - `TauriTransport`: `invoke()` into the Tauri app's Rust side.
+ *
+ * Node code should use `@trycua/cua/spaces` (the typed SDK) instead. See
+ * `types.ts` for why the seam exchanges whole JSON-RPC messages rather than
+ * bytes.
+ */
+export { TransportError, } from "./types.js";
+export { McpSession, PROTOCOL_VERSION, ToolError, textOf, } from "./session.js";
+export { DEFAULT_REQUEST_COMMAND, DEFAULT_SHUTDOWN_COMMAND, TauriTransport, } from "./tauri.js";
+export { McpHttpTransport, SESSION_HEADER } from "./http.js";