@arcanemachine/inter-agent-opencode 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+- Establish the OpenCode extension package and split TUI/server targets.

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 arcanemachine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# Inter-agent for OpenCode
+
+Connect OpenCode sessions to a local inter-agent server.
+
+The extension adds:
+
+- TUI commands to connect a session, send direct or broadcast messages, inspect peers, check status, and read the inbox.
+- Server tools for direct messages, broadcasts, peer listing, session status, and inbox reads.
+- Automatic delivery of inbound messages after the OpenCode session becomes idle.
+
+The Core server must already be running. This extension never starts, stops, or owns that server.
+
+## Transport and plugin targets
+
+- Connections stay on loopback addresses. Non-loopback endpoints fail closed.
+- Plaintext WebSockets are the default. Enable WSS when the Core server uses TLS. The client verifies the configured Core certificate and never falls back to plaintext.
+- The package has separate `./tui` and `./server` targets. Put the package in both `tui.json` and `opencode.json`; OpenCode loads the right target for each host.
+
+## Installation
+
+Build and pack from this checkout:
+
+```sh
+npm ci
+npm run build
+npm pack
+```
+
+Install and configure both plugin targets with OpenCode's installer:
+
+```sh
+opencode plugin /path/to/inter-agent-opencode.tgz
+```
+
+For local development, point the same command at the checkout:
+
+```sh
+opencode plugin /workspace/projects/inter-agent-opencode
+```
+
+The command installs the package and adds the server target to `opencode.json` and the TUI target to `tui.json`. Restart OpenCode after installation. If the TUI config lives at a custom path, set `OPENCODE_TUI_CONFIG` before starting OpenCode. Keep configuration files and plugin caches private.
+
+## Configuration
+
+The extension reads the same Core-compatible settings from environment variables or a JSON config file. Environment variables take precedence. The supported variables are:
+
+| Variable               | Meaning                                                                  |
+| ---------------------- | ------------------------------------------------------------------------ |
+| `INTER_AGENT_HOST`     | Server host; defaults to `127.0.0.1`. Must resolve to loopback.          |
+| `INTER_AGENT_PORT`     | Server port; defaults to `16837`.                                        |
+| `INTER_AGENT_SECRET`   | Shared authentication secret.                                            |
+| `INTER_AGENT_CONFIG`   | JSON config path; default is the platform config location.               |
+| `INTER_AGENT_DATA_DIR` | Private state directory; default is the platform state location.         |
+| `INTER_AGENT_TLS`      | Enable authenticated WSS on a loopback endpoint.                         |
+| `INTER_AGENT_TLS_CERT` | PEM certificate to trust for WSS; defaults to `<data-dir>/tls-cert.pem`. |
+
+The JSON config accepts `host`, `port`, `secret`, `dataDir`, `tls`, and `tlsCert` with the same meanings. When TLS is enabled, certificate trust resolves from `INTER_AGENT_TLS_CERT`, then `tlsCert`, then `<data-dir>/tls-cert.pem`; the extension never disables certificate verification or falls back to plaintext. Secret resolution is environment, then config, then a generated private `token` file under the data directory. Do not put secrets, authentication proofs, or private state contents in prompts, logs, or source control.
+
+### Configuration and private state paths
+
+`INTER_AGENT_CONFIG` overrides the JSON config path. Without that override, the default is platform-specific: macOS uses `~/Library/Application Support/inter-agent/config.json`; Windows uses `%APPDATA%/inter-agent/config.json` when `APPDATA` is set; otherwise `$XDG_CONFIG_HOME/inter-agent/config.json` is used when set, falling back to `~/.config/inter-agent/config.json`. These are location policies, not machine-specific paths.
+
+`INTER_AGENT_DATA_DIR` overrides the private state root, followed by `dataDir` in the JSON config. With neither override, macOS uses `~/Library/Application Support/inter-agent`; Windows uses `%LOCALAPPDATA%/inter-agent` (or `%APPDATA%/inter-agent`); otherwise `$XDG_STATE_HOME/inter-agent` is used when set, falling back to `~/.local/state/inter-agent`. The path resolver expands `~`, `$NAME`, and `${NAME}` forms.
+
+Workspace and session records are kept below `<data-dir>/opencode/workspaces/<workspace-hash>/sessions/<session-hash>/`. That private, session-scoped directory contains the connection lease, preferences, durable inbox, and lock/recovery state. When generated as the authentication fallback, a token is stored as `<data-dir>/token`; directories and token files use private permissions where the platform supports them. Keep the config file, data directory, and any configured certificate path private.
+
+For an isolated loopback setup, set a fresh port and state directory and provide the same secret to the separately started Core server and OpenCode host:
+
+```sh
+export INTER_AGENT_HOST=127.0.0.1
+export INTER_AGENT_PORT=19001
+export INTER_AGENT_DATA_DIR=/path/to/private/inter-agent-state
+export INTER_AGENT_SECRET='set-this-out-of-band'
+# Optional authenticated WSS on loopback:
+export INTER_AGENT_TLS=true
+export INTER_AGENT_TLS_CERT="$INTER_AGENT_DATA_DIR/tls-cert.pem"
+```
+
+The extension does not provide a Core-server start command. Start and stop that server using the Core installation's own documented procedure.
+
+## TUI commands
+
+Commands apply to the current OpenCode session. Each session has its own connection lease, routing name, pending delivery batch, and durable inbox.
+
+- `/inter-agent-connect <name> [--label <label>] [--auto-connect]`
+- `/inter-agent-disconnect`
+- `/inter-agent-send <to> <text>`
+- `/inter-agent-broadcast <text>`
+- `/inter-agent-list`
+- `/inter-agent-status`
+- `/inter-agent-inbox [count]`
+
+Connect, send, broadcast, and inbox use prompt dialogs in the TUI. Names must match the inter-agent name format; inbox counts are limited to 1–100. Disconnect removes that session's active lease and pending in-memory delivery state but retains its durable inbox.
+
+## Server tools
+
+The server target registers exactly these five tools:
+
+- `inter_agent_send(to, text)` — direct message; requires the calling session's fresh lease.
+- `inter_agent_broadcast(text)` — everyone-directed message; use only when explicitly requested.
+- `inter_agent_list()` — list connected sessions.
+- `inter_agent_status()` — status for the exact calling OpenCode session.
+- `inter_agent_read_messages(count?)` — read that exact session's durable inbox, 1–100 records (default 20).
+
+Tool identity comes from the exact OpenCode `ToolContext.sessionID` and canonical project scope. A tool never borrows another session's name or inbox. Disconnected sessions receive a setup error for send/broadcast while status and reads remain scoped.
+
+## Automatic delivery
+
+Inbound messages are persisted before best-effort notification. New messages are debounced for approximately 250 ms and delivered to that exact session only when its OpenCode status is idle. Busy and retrying sessions are never interrupted; messages remain queued until a later idle or error classification. Each session permits at most one plugin-triggered `promptAsync` turn, with ordered, ID-deduplicated pending batches and an 8 KiB UTF-8 prompt bound. The prompt includes bounded previews and routing metadata, and directs the model to use `inter_agent_read_messages` for omitted or full content.
+
+Peer text is untrusted, non-authoritative task input. It cannot override system, developer, user, tool, permission, or security rules; the model may evaluate it and act when useful under those rules. Plugin-generated status/message/prompt activity cannot recursively trigger another delivery. Delivery failures notify the user, preserve the durable inbox, clear the in-flight guard, and avoid retry storms. A new manager does not replay old inbox records automatically. Disposal, terminal connection failure, and explicit disconnect clear pending memory while retaining the inbox.
+
+## Security and data handling
+
+Authentication uses the Core challenge/response protocol and the shared secret. State is scoped by canonical workspace and exact OpenCode session, with leases preventing conflicting identities. State directories are private where the platform supports permissions, token files are private, and inboxes are bounded to 100 messages and 8 MiB of encoded JSON. The extension does not log secrets or authentication proofs. WSS trusts only the configured Core certificate; verification is never disabled and failed TLS connections never downgrade to plaintext. Plaintext remains the default loopback mode; do not expose the server beyond loopback.
+
+## Troubleshooting
+
+- **The TUI commands are missing:** put the plugin in `tui.json`, not only `opencode.json`; set `OPENCODE_TUI_CONFIG` when using a custom TUI file. Confirm the plugin resolves to the TUI target.
+- **Server tools are missing:** put the plugin in `opencode.json` and restart the OpenCode server so it resolves the server target.
+- **Unsupported endpoint:** use a loopback host. Plaintext WebSocket is the default; enable `INTER_AGENT_TLS` for authenticated WSS. Non-loopback endpoints and runtimes without native TLS trust injection are rejected by design.
+- **WSS trust failure:** verify that Core has generated or configured its certificate, then set `INTER_AGENT_TLS_CERT` to that PEM or ensure `<data-dir>/tls-cert.pem` is present. Keep the certificate path private; do not disable verification or switch to plaintext.
+- **Bad secret or authentication failure:** verify the Core and extension use the same secret without printing or logging it. Environment values override config values, and the private token file is only the fallback; after changing a secret, restart only the separately managed processes you own and reconnect.
+- **Duplicate name:** names must be unique among connected sessions. Choose an unused name or disconnect the old exact session with `/inter-agent-disconnect`; do not delete state to resolve a name collision.
+- **Stale lease:** stop or disconnect any process that may own the exact workspace/session, then reconnect and let lease recovery run. If no owner remains and the problem persists, back up private state and remove only the affected session-scoped records while all related clients are stopped; never delete the whole data directory or another session's records.
+- **Disconnected or unavailable:** start the separate Core server, verify the same endpoint/secret, then run `/inter-agent-status` and reconnect the exact OpenCode session.
+- **Messages are not visible:** run `/inter-agent-inbox`; durable records remain available after notification or delivery failure. Check that the recipient name and current session are exact.
+- **A model turn is still busy:** delivery waits rather than interrupting a busy/retrying session. Provider latency can delay the next idle turn.
+
+## Uninstall
+
+Remove the plugin entry from `opencode.json` and `tui.json`, remove the locally installed archive/package if applicable, and restart OpenCode. Stop the separately managed Core server yourself. If no longer needed, remove the private data directory only after preserving anything required from its inbox; the extension does not remove it automatically.
+
+## Development and verification
+
+```sh
+npm ci
+npm run typecheck
+npm run build
+npm run format:check
+npm test
+npm run test:compiled
+npm run test:state:compiled
+```
+
+Use fresh loopback ports and private temporary state for live checks. Do not use the shared default port when testing.

package/dist/client.d.ts

@@ -0,0 +1,73 @@
+import { type EndpointResolution } from "./config.js";
+import { RemoteError } from "./errors.js";
+import { type ListOkFrame, type Welcome } from "./protocol.js";
+export declare const HANDSHAKE_TIMEOUT_MS = 5000;
+export declare const LIST_TIMEOUT_MS = 2000;
+export declare const SEND_ERROR_WINDOW_MS = 250;
+export type WebSocketMessageEvent = {
+    data: unknown;
+};
+export type WebSocketCloseEvent = {
+    code?: number;
+    reason?: string;
+};
+export interface WebSocketLike {
+    readonly readyState?: number;
+    onopen: (() => void) | null;
+    onmessage: ((event: WebSocketMessageEvent) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    onclose: ((event: WebSocketCloseEvent) => void) | null;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+}
+export type WebSocketFactory = (url: string, tlsCertPath?: string) => WebSocketLike;
+export type ClientOptions = {
+    endpoint?: EndpointResolution;
+    secret?: string;
+    websocketFactory?: WebSocketFactory;
+    connectTimeoutMs?: number;
+    operationTimeoutMs?: number;
+    sendErrorWindowMs?: number;
+    signal?: AbortSignal;
+};
+export type ControlClientOptions = ClientOptions & {
+    fromName?: string;
+};
+export type SendResult = {
+    welcome: Welcome;
+    error?: RemoteError;
+};
+export type AgentConnectionOptions = ClientOptions & {
+    name: string;
+    label?: string | null;
+};
+export declare function defaultWebSocketFactory(url: string, tlsCertPath?: string): WebSocketLike;
+export declare class AgentConnection {
+    private readonly session;
+    readonly welcome: Welcome;
+    private readonly secret;
+    private readonly signal?;
+    private constructor();
+    static open(options: AgentConnectionOptions): Promise<AgentConnection>;
+    receive(timeoutMs?: number): Promise<import("./protocol.js").Message>;
+    close(): Promise<void>;
+}
+export declare class ControlConnection {
+    private readonly session;
+    readonly welcome: Welcome;
+    private readonly secret;
+    private readonly operationTimeoutMs;
+    private readonly sendErrorWindowMs;
+    private readonly signal?;
+    private constructor();
+    static open(options?: ClientOptions): Promise<ControlConnection>;
+    sendDirect(to: string, text: string, fromName?: string): Promise<SendResult>;
+    broadcast(text: string, fromName?: string): Promise<SendResult>;
+    list(): Promise<ListOkFrame>;
+    close(): Promise<void>;
+    private sendAndObserve;
+}
+export declare function sendDirect(to: string, text: string, fromName?: string, options?: ClientOptions): Promise<SendResult>;
+export declare function broadcast(text: string, fromName?: string, options?: ClientOptions): Promise<SendResult>;
+export declare function listSessions(options?: ClientOptions): Promise<ListOkFrame>;
+export declare function websocketUrl(endpoint: EndpointResolution): string;

package/dist/client.js

@@ -0,0 +1,409 @@
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+import { endpointUri, assertSupportedEndpoint, resolveEndpoint, resolveSecret, } from "./config.js";
+import { AuthenticationError, ConnectionError, ProtocolError, RemoteError, TimeoutError, InterAgentError, } from "./errors.js";
+import { buildAuthResponse, buildHello, decodeFrame, parseAuthChallenge, parseError, parseFrame, parseListOk, parseMessage, parseWelcome, validateName, validateText, verifyServerProof, DEFAULT_BROADCAST_TEXT_MAX, DEFAULT_DIRECT_TEXT_MAX, } from "./protocol.js";
+export const HANDSHAKE_TIMEOUT_MS = 5_000;
+export const LIST_TIMEOUT_MS = 2_000;
+export const SEND_ERROR_WINDOW_MS = 250;
+export function defaultWebSocketFactory(url, tlsCertPath) {
+    const Constructor = globalThis.WebSocket;
+    if (typeof Constructor !== "function")
+        throw new ConnectionError("native WebSocket is unavailable");
+    if (!tlsCertPath)
+        return new Constructor(url);
+    const bun = globalThis.Bun;
+    if (!bun)
+        throw new ConnectionError("WSS requires native Bun WebSocket TLS trust support");
+    let certificate;
+    try {
+        certificate = readFileSync(tlsCertPath);
+    }
+    catch {
+        throw new ConnectionError("unable to read inter-agent TLS certificate");
+    }
+    try {
+        return new Constructor(url, { tls: { ca: certificate } });
+    }
+    catch {
+        throw new ConnectionError("unable to create inter-agent WSS WebSocket");
+    }
+}
+class SocketSession {
+    socket;
+    queue = [];
+    waiter;
+    failure;
+    closed = false;
+    constructor(socket) {
+        this.socket = socket;
+        socket.onmessage = (event) => {
+            try {
+                this.deliver(decodeFrame(event.data));
+            }
+            catch (error) {
+                this.fail(error instanceof Error
+                    ? error
+                    : new ProtocolError("invalid websocket frame"));
+            }
+        };
+        socket.onerror = () => this.fail(new ConnectionError("inter-agent WebSocket connection failed"));
+        socket.onclose = () => this.fail(new ConnectionError("inter-agent WebSocket connection closed"));
+    }
+    deliver(data) {
+        if (this.waiter) {
+            const waiter = this.waiter;
+            this.waiter = undefined;
+            waiter.resolve(data);
+        }
+        else {
+            this.queue.push(data);
+        }
+    }
+    fail(error) {
+        if (this.closed || this.failure)
+            return;
+        this.failure = error;
+        const waiter = this.waiter;
+        this.waiter = undefined;
+        waiter?.reject(error);
+    }
+    async waitOpen(timeoutMs, signal) {
+        if (this.socket.readyState === 1)
+            return;
+        await waitForEvent((resolve, reject) => {
+            const previousOpen = this.socket.onopen;
+            const previousClose = this.socket.onclose;
+            const previousError = this.socket.onerror;
+            this.socket.onopen = () => {
+                previousOpen?.();
+                resolve();
+            };
+            this.socket.onclose = (event) => {
+                previousClose?.(event);
+                reject(new ConnectionError("inter-agent WebSocket closed before authentication"));
+            };
+            this.socket.onerror = (event) => {
+                previousError?.(event);
+                reject(new ConnectionError("inter-agent WebSocket failed before authentication"));
+            };
+        }, timeoutMs, signal, "inter-agent WebSocket connection timed out");
+    }
+    send(data) {
+        try {
+            this.socket.send(data);
+        }
+        catch {
+            throw new ConnectionError("inter-agent WebSocket send failed");
+        }
+    }
+    async receive(timeoutMs, signal) {
+        if (this.failure)
+            throw this.failure;
+        const queued = this.queue.shift();
+        if (queued !== undefined)
+            return queued;
+        return waitForEvent((resolve, reject) => {
+            this.waiter = { resolve, reject };
+        }, timeoutMs, signal, "inter-agent operation timed out").catch((error) => {
+            this.waiter = undefined;
+            throw error;
+        });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const waiter = this.waiter;
+        this.waiter = undefined;
+        waiter?.reject(new ConnectionError("inter-agent WebSocket closed"));
+        this.socket.onmessage = null;
+        this.socket.onopen = null;
+        this.socket.onerror = null;
+        this.socket.onclose = null;
+        try {
+            this.socket.close();
+        }
+        catch {
+            // Closing an already closed socket is harmless.
+        }
+    }
+}
+function waitForEvent(install, timeoutMs, signal, timeoutMessage) {
+    if (signal?.aborted)
+        return Promise.reject(new InterAgentError("operation aborted", "AbortError", true));
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(new TimeoutError(timeoutMessage));
+        }, timeoutMs);
+        const abort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(new InterAgentError("operation aborted", "AbortError", true));
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+        install((value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        });
+    });
+}
+function safeRemoteError(frame, secret) {
+    const parsed = parseError(frame);
+    return new RemoteError(parsed.code, parsed.message, secret);
+}
+function parseOperationError(raw, secret) {
+    const frame = parseFrame(raw);
+    if (frame.op !== "error")
+        return undefined;
+    return safeRemoteError(frame, secret);
+}
+export class AgentConnection {
+    session;
+    welcome;
+    secret;
+    signal;
+    constructor(session, welcome, secret, signal) {
+        this.session = session;
+        this.welcome = welcome;
+        this.secret = secret;
+        this.signal = signal;
+    }
+    static async open(options) {
+        const endpoint = options.endpoint ?? (await resolveEndpoint());
+        assertSupportedEndpoint(endpoint);
+        const secret = options.secret ?? resolveSecret().secret;
+        const factory = options.websocketFactory ?? defaultWebSocketFactory;
+        const connectTimeoutMs = options.connectTimeoutMs ?? HANDSHAKE_TIMEOUT_MS;
+        const deadline = performance.now() + connectTimeoutMs;
+        const socket = createSocket(factory, endpoint);
+        const session = new SocketSession(socket);
+        try {
+            await session.waitOpen(remainingDeadline(deadline), options.signal);
+            const hello = buildHello({
+                role: "agent",
+                sessionId: randomUUID(),
+                name: options.name,
+                label: options.label ?? null,
+                capabilities: {},
+            });
+            const clientNonce = hello.auth.client_nonce;
+            session.send(JSON.stringify(hello));
+            const challengeFrame = parseFrame(await session.receive(remainingDeadline(deadline), options.signal));
+            if (challengeFrame.op === "error")
+                throw safeRemoteError(challengeFrame, secret);
+            const challenge = parseAuthChallenge(challengeFrame);
+            if (!verifyServerProof(challenge.server_proof, secret, {
+                clientNonce,
+                serverNonce: challenge.server_nonce,
+                hello,
+            }))
+                throw new AuthenticationError();
+            session.send(JSON.stringify(buildAuthResponse(secret, {
+                clientNonce,
+                serverNonce: challenge.server_nonce,
+                hello,
+            })));
+            const welcomeFrame = parseFrame(await session.receive(remainingDeadline(deadline), options.signal));
+            if (welcomeFrame.op === "error")
+                throw safeRemoteError(welcomeFrame, secret);
+            const welcome = parseWelcome(welcomeFrame);
+            return new AgentConnection(session, welcome, secret, options.signal);
+        }
+        catch (error) {
+            session.close();
+            if (error instanceof InterAgentError)
+                throw error;
+            throw new ConnectionError("inter-agent authentication failed");
+        }
+    }
+    async receive(timeoutMs = HANDSHAKE_TIMEOUT_MS * 12) {
+        const frame = parseFrame(await this.session.receive(timeoutMs, this.signal));
+        if (frame.op === "error")
+            throw safeRemoteError(frame, this.secret);
+        return parseMessage(frame);
+    }
+    async close() {
+        this.session.close();
+    }
+}
+export class ControlConnection {
+    session;
+    welcome;
+    secret;
+    operationTimeoutMs;
+    sendErrorWindowMs;
+    signal;
+    constructor(session, welcome, secret, operationTimeoutMs, sendErrorWindowMs, signal) {
+        this.session = session;
+        this.welcome = welcome;
+        this.secret = secret;
+        this.operationTimeoutMs = operationTimeoutMs;
+        this.sendErrorWindowMs = sendErrorWindowMs;
+        this.signal = signal;
+    }
+    static async open(options = {}) {
+        const endpoint = options.endpoint ?? (await resolveEndpoint());
+        assertSupportedEndpoint(endpoint);
+        const secret = options.secret ?? resolveSecret().secret;
+        const factory = options.websocketFactory ?? defaultWebSocketFactory;
+        const connectTimeoutMs = options.connectTimeoutMs ?? HANDSHAKE_TIMEOUT_MS;
+        const deadline = performance.now() + connectTimeoutMs;
+        const socket = createSocket(factory, endpoint);
+        const session = new SocketSession(socket);
+        try {
+            await session.waitOpen(remainingDeadline(deadline), options.signal);
+            const hello = buildHello({
+                role: "control",
+                sessionId: randomUUID(),
+                name: "control",
+                label: null,
+                capabilities: {},
+            });
+            const clientNonce = hello.auth.client_nonce;
+            session.send(JSON.stringify(hello));
+            const challengeFrame = parseFrame(await session.receive(remainingDeadline(deadline), options.signal));
+            if (challengeFrame.op === "error")
+                throw safeRemoteError(challengeFrame, secret);
+            const challenge = parseAuthChallenge(challengeFrame);
+            if (!verifyServerProof(challenge.server_proof, secret, {
+                clientNonce,
+                serverNonce: challenge.server_nonce,
+                hello,
+            })) {
+                throw new AuthenticationError();
+            }
+            session.send(JSON.stringify(buildAuthResponse(secret, {
+                clientNonce,
+                serverNonce: challenge.server_nonce,
+                hello,
+            })));
+            const welcomeFrame = parseFrame(await session.receive(remainingDeadline(deadline), options.signal));
+            if (welcomeFrame.op === "error")
+                throw safeRemoteError(welcomeFrame, secret);
+            const welcome = parseWelcome(welcomeFrame);
+            return new ControlConnection(session, welcome, secret, options.operationTimeoutMs ?? LIST_TIMEOUT_MS, options.sendErrorWindowMs ?? SEND_ERROR_WINDOW_MS, options.signal);
+        }
+        catch (error) {
+            session.close();
+            if (error instanceof InterAgentError)
+                throw error;
+            throw new ConnectionError("inter-agent authentication failed");
+        }
+    }
+    async sendDirect(to, text, fromName) {
+        if (!validateName(to))
+            throw new ProtocolError("invalid direct message target", "BAD_NAME");
+        if (!validateText(text, DEFAULT_DIRECT_TEXT_MAX))
+            throw new ProtocolError("direct message text is too large", "TEXT_TOO_LARGE");
+        if (fromName !== undefined && !validateName(fromName))
+            throw new ProtocolError("invalid from_name", "BAD_FROM_NAME");
+        const payload = { op: "send", to, text };
+        if (fromName !== undefined)
+            payload.from_name = fromName;
+        return this.sendAndObserve(payload);
+    }
+    async broadcast(text, fromName) {
+        if (!validateText(text, DEFAULT_BROADCAST_TEXT_MAX))
+            throw new ProtocolError("broadcast text is too large", "TEXT_TOO_LARGE");
+        if (fromName !== undefined && !validateName(fromName))
+            throw new ProtocolError("invalid from_name", "BAD_FROM_NAME");
+        const payload = { op: "broadcast", text };
+        if (fromName !== undefined)
+            payload.from_name = fromName;
+        return this.sendAndObserve(payload);
+    }
+    async list() {
+        this.session.send(JSON.stringify({ op: "list" }));
+        const frame = parseFrame(await this.session.receive(this.operationTimeoutMs, this.signal));
+        if (frame.op === "error")
+            throw safeRemoteError(frame, this.secret);
+        return parseListOk(frame);
+    }
+    async close() {
+        this.session.close();
+    }
+    async sendAndObserve(payload) {
+        this.session.send(JSON.stringify(payload));
+        try {
+            const raw = await this.session.receive(this.sendErrorWindowMs, this.signal);
+            const error = parseOperationError(raw, this.secret);
+            if (error)
+                throw error;
+            throw new ProtocolError("unexpected response after message send");
+        }
+        catch (error) {
+            if (error instanceof TimeoutError)
+                return { welcome: this.welcome };
+            throw error;
+        }
+    }
+}
+function remainingDeadline(deadline) {
+    const remaining = Math.ceil(deadline - performance.now());
+    if (remaining <= 0)
+        throw new TimeoutError("inter-agent WebSocket connection timed out");
+    return remaining;
+}
+function createSocket(factory, endpoint) {
+    try {
+        return factory(endpointUri(endpoint), endpoint.tls ? endpoint.tlsCertPath : undefined);
+    }
+    catch (error) {
+        if (error instanceof InterAgentError)
+            throw error;
+        throw new ConnectionError("unable to create inter-agent WebSocket");
+    }
+}
+export async function sendDirect(to, text, fromName, options = {}) {
+    const connection = await ControlConnection.open(options);
+    try {
+        return await connection.sendDirect(to, text, fromName);
+    }
+    finally {
+        await connection.close();
+    }
+}
+export async function broadcast(text, fromName, options = {}) {
+    const connection = await ControlConnection.open(options);
+    try {
+        return await connection.broadcast(text, fromName);
+    }
+    finally {
+        await connection.close();
+    }
+}
+export async function listSessions(options = {}) {
+    const connection = await ControlConnection.open(options);
+    try {
+        return await connection.list();
+    }
+    finally {
+        await connection.close();
+    }
+}
+export function websocketUrl(endpoint) {
+    return endpointUri(endpoint);
+}
+//# sourceMappingURL=client.js.map