@agentorg/cli 0.0.6 → 0.0.8

package/dist/src/gateway.js

@@ -4,11 +4,13 @@ import { createRequire } from "node:module";
 import { dirname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Hub, listen, PERSON } from "@agentorg/hub";
-import { accountLogin, agents, connections, hubActors, hubAudit, hubBindings, hubExports, hubGrants, skills, } from "@agentorg/interfaces";
-import { Refused } from "@agentorg/sdk";
+import { accountLogin, agents, connections, hubActors, hubAudit, hubBindings, hubExports, hubGrants, llmSession, skills, } from "@agentorg/interfaces";
+import { describeInterface, Refused } from "@agentorg/sdk";
 import { connect } from "@agentorg/sdk/client";
 import { WebSocketServer } from "ws";
 import { serveSocket } from "./api.js";
+import { callFolders } from "./folders.js";
+import { LIVE_MAX, pipeLive } from "./live.js";
 import { Notes } from "./notes.js";
 import { oauthRoute } from "./oauth.js";
 import { closePackageActors, startPrograms, } from "./programs.js";
@@ -39,6 +41,21 @@ const MAX_MESSAGE = 1024 * 1024;
 const HELLO_TIMEOUT_MS = 10_000;
 /** The close code for a socket with no live session: the tab signs in again. */
 const SIGN_IN_AGAIN = 4401;
+/** A model's reply can take minutes; every other interface keeps the Hub's own limit. */
+export const HUB_OPTIONS = {
+    answerTimeoutsMs: { [describeInterface(llmSession).id]: 10 * 60_000 },
+};
+/** The port the kept sessions were given at, if any are kept. */
+function keptPort(sessions) {
+    try {
+        const { at } = JSON.parse(readFileSync(sessions, "utf8"));
+        const port = /^http:\/\/127\.0\.0\.1:(\d+)$/.exec(String(at))?.[1];
+        return port === undefined ? undefined : Number(port);
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Write a file only its owner reads, all at once. */
 function writePrivate(file, text) {
     writeFileSync(`${file}.tmp`, text, { mode: 0o600 });
@@ -55,13 +72,38 @@ export async function startApp(options) {
     const home = resolve(options.home);
     mkdirSync(home, { recursive: true, mode: 0o700 });
     closePackageActors(home);
-    const hub = Hub.open(home);
+    const hub = Hub.open(home, HUB_OPTIONS);
     const listener = await listen(hub, {}).catch((error) => {
         hub.close();
         throw error;
     });
     writePrivate(join(home, "url"), `${listener.url}\n`);
-    const signIn = new SignIn();
+    // A tab signed in before the app last stopped is still signed in, if the app is at the address
+    // it was then: what is kept is each session's hash, in a file only its owner reads. At another
+    // address they are dropped. A tab keeps its session by address, so it couldn't say one here, and
+    // a tab left open on the old address goes on saying its session to whatever answers there.
+    const sessions = join(home, "sessions.json");
+    const signIn = new SignIn({
+        kept: {
+            read() {
+                try {
+                    return JSON.parse(readFileSync(sessions, "utf8")).hashes;
+                }
+                catch {
+                    // None kept, or none that reads back.
+                    return undefined;
+                }
+            },
+            write(hashes) {
+                try {
+                    writePrivate(sessions, `${JSON.stringify({ at: origin, hashes })}\n`);
+                }
+                catch {
+                    // A home that can't be written still signs the tab in: only the next start forgets it.
+                }
+            },
+        },
+    });
     const credential = readFileSync(join(home, "person-credential"), "utf8").trim();
     /** The app's own notes: what the shell remembers. */
     const notes = new Notes(join(home, "app-notes.json"));
@@ -81,6 +123,8 @@ export async function startApp(options) {
         async call(slot, method, input) {
             if (slot === "store")
                 return notes.call(method, input);
+            if (slot === "folders")
+                return callFolders(method, input);
             const exposed = Object.hasOwn(SLOTS, slot) ? undefined : exposedSlot(slot);
             if (!exposed && !Object.hasOwn(SLOTS, slot))
                 throw new Refused("invalid", `The person has no slot ${slot}.`);
@@ -197,18 +241,32 @@ export async function startApp(options) {
         response.end(request.method === "HEAD" ? undefined : body);
     };
     const sockets = new WebSocketServer({ noServer: true, maxPayload: MAX_MESSAGE });
+    const lives = new WebSocketServer({ noServer: true, maxPayload: LIVE_MAX });
     server.on("upgrade", (request, socket, head) => {
         // An upgraded socket has no error handler of its own: a client that resets would crash the app.
         socket.on("error", () => socket.destroy());
         const url = new URL(request.url ?? "/", origin);
         const cli = signIn.isCli(request.headers.authorization);
         const allowed = request.headers.host === host() &&
-            url.pathname === "/api" &&
+            (url.pathname === "/api" || url.pathname === "/live") &&
             (cli || request.headers.origin === origin);
         if (!allowed) {
             socket.end("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
             return;
         }
+        if (url.pathname === "/live") {
+            const query = url.searchParams;
+            return lives.handleUpgrade(request, socket, head, (ws) => pipeLive(ws, {
+                cli,
+                isSession: (session) => signIn.isSession(session),
+                ticket: async () => (await personSide.call("agents", "live", {
+                    agent: query.get("agent"),
+                    instance: query.get("instance"),
+                    surface: query.get("surface"),
+                    mode: query.get("mode") ?? "watch",
+                })),
+            }));
+        }
         sockets.handleUpgrade(request, socket, head, (ws) => {
             let served;
             const serve = () => {
@@ -244,16 +302,25 @@ export async function startApp(options) {
             });
         });
     });
-    await new Promise((done, failed) => {
+    const listenOn = (port) => new Promise((done, failed) => {
         server.once("error", failed);
-        server.listen(options.port ?? 0, "127.0.0.1", () => done());
-    }).catch(async (error) => {
+        server.listen(port, "127.0.0.1", () => done());
+    });
+    // With no port asked for, the one the kept sessions were given at, so a tab left open is still
+    // signed in. If that one can't be had, any free one, as on a first start.
+    await (options.port === undefined
+        ? listenOn(keptPort(sessions) ?? 0).catch(() => listenOn(0))
+        : listenOn(options.port)).catch(async (error) => {
         person.close();
         await listener.close();
         hub.close();
         throw error;
     });
-    origin = `http://127.0.0.1:${server.address().port}`;
+    const { port } = server.address();
+    // At another address the kept sessions are dropped, before anything is answered.
+    if (keptPort(sessions) !== port)
+        rmSync(sessions, { force: true });
+    origin = `http://127.0.0.1:${port}`;
     writePrivate(join(home, "cli-token"), `${signIn.cliToken}\n`);
     writePrivate(join(home, "app.json"), `${JSON.stringify({ url: origin, pid: process.pid })}\n`);
     let closing;
@@ -294,9 +361,11 @@ export async function startApp(options) {
                 catch {
                     // Already gone.
                 }
-            for (const client of sockets.clients)
-                client.terminate();
-            sockets.close();
+            for (const server of [sockets, lives]) {
+                for (const client of server.clients)
+                    client.terminate();
+                server.close();
+            }
             // server.close waits for every open connection; a tab still connected (a keep-alive request,
             // a socket reconnecting) would hold the app open, so they are all closed now.
             const serverClosed = new Promise((done) => server.close(() => done()));

package/dist/src/live.d.ts

@@ -0,0 +1,17 @@
+import WebSocket from "ws";
+/** What one live frame can be, either way. */
+export declare const LIVE_MAX: number;
+export interface Ticket {
+    url: string;
+    protocol: string;
+}
+/**
+ * Pipe a page's socket to a surface. A tab says its session first, as on `/api`, and is then
+ * answered `{"op":"live","protocol"}`; after that every frame is the surface's own. The CLI is in
+ * by its token.
+ */
+export declare function pipeLive(page: WebSocket, options: {
+    cli: boolean;
+    isSession(session: unknown): boolean;
+    ticket(): Promise<Ticket>;
+}): void;

package/dist/src/live.js

@@ -0,0 +1,109 @@
+// A live surface of an agent's unit, for a page: the page opens a socket here, same-origin, and
+// this asks management for a one-time ticket, dials it, and pipes the bytes both ways. The ticket
+// and every token stay out of the page.
+import WebSocket from "ws";
+/** What one live frame can be, either way. */
+export const LIVE_MAX = 4 * 1024 * 1024;
+/** The page didn't say its session, or the session is gone. */
+const SIGN_IN_AGAIN = 4401;
+/** The surface couldn't be opened; the reason says why. */
+const NOT_OPENED = 4404;
+const HELLO_TIMEOUT_MS = 10_000;
+/** What a page may send before the surface opens; past it, the socket closes rather than drop. */
+const WAITING_MAX = 1024 * 1024;
+/** Past this much unsent to the page, the surface waits; it goes on below the lower mark. */
+const BEHIND = 8 * 1024 * 1024;
+const CAUGHT_UP = 1024 * 1024;
+/** A close code a page may be given: the peer's when it's an ordinary one. */
+const codeOf = (code) => code === 1000 || code === 1001 || (code >= 3000 && code <= 4999) ? code : 1011;
+/** A close reason fits in 123 bytes. */
+const reasonOf = (text) => {
+    let reason = text;
+    while (Buffer.byteLength(reason) > 123)
+        reason = reason.slice(0, -1);
+    return reason;
+};
+/**
+ * Pipe a page's socket to a surface. A tab says its session first, as on `/api`, and is then
+ * answered `{"op":"live","protocol"}`; after that every frame is the surface's own. The CLI is in
+ * by its token.
+ */
+export function pipeLive(page, options) {
+    let upstream;
+    let opening = false;
+    const waiting = [];
+    let waitingBytes = 0;
+    const sizeOf = (data) => Array.isArray(data)
+        ? data.reduce((sum, one) => sum + one.length, 0)
+        : data.byteLength;
+    const open = async () => {
+        opening = true;
+        let ticket;
+        try {
+            ticket = await options.ticket();
+        }
+        catch (error) {
+            return page.close(NOT_OPENED, reasonOf(error instanceof Error ? error.message : "Not opened."));
+        }
+        if (page.readyState !== WebSocket.OPEN)
+            return;
+        let socket;
+        try {
+            // A server's socket, dialled from here: no browser Origin goes with it.
+            socket = new WebSocket(ticket.url, { maxPayload: LIVE_MAX });
+        }
+        catch {
+            // Its message would hold the ticket.
+            return page.close(NOT_OPENED, "The surface didn't open.");
+        }
+        upstream = socket;
+        socket.on("open", () => {
+            page.send(JSON.stringify({ op: "live", protocol: ticket.protocol }));
+            for (const [data, binary] of waiting.splice(0))
+                socket.send(data, { binary });
+        });
+        socket.on("message", (data, binary) => {
+            page.send(data, { binary }, () => {
+                if (page.bufferedAmount < CAUGHT_UP)
+                    socket.resume();
+            });
+            // A page that can't keep up isn't sent more until it has.
+            if (page.bufferedAmount > BEHIND)
+                socket.pause();
+        });
+        socket.on("close", (code, reason) => page.close(codeOf(code), reasonOf(String(reason))));
+        socket.on("error", () => page.close(NOT_OPENED, "The surface didn't open."));
+    };
+    const timer = options.cli
+        ? undefined
+        : setTimeout(() => page.close(SIGN_IN_AGAIN, "No session"), HELLO_TIMEOUT_MS);
+    const opened = () => open().catch(() => page.close(NOT_OPENED, "The surface didn't open."));
+    if (options.cli)
+        void opened();
+    page.on("message", (data, binary) => {
+        if (!opening) {
+            clearTimeout(timer);
+            let hello;
+            try {
+                hello = binary ? undefined : JSON.parse(String(data));
+            }
+            catch {
+                // Not a hello.
+            }
+            if (hello?.op !== "hello" || !options.isSession(hello.session))
+                return page.close(SIGN_IN_AGAIN, "Sign in again");
+            return void opened();
+        }
+        if (upstream?.readyState === WebSocket.OPEN)
+            return upstream.send(data, { binary });
+        waitingBytes += sizeOf(data);
+        if (waitingBytes > WAITING_MAX)
+            return page.close(1009, "Too much before the surface opened.");
+        waiting.push([data, binary]);
+    });
+    page.on("close", () => {
+        clearTimeout(timer);
+        upstream?.close();
+    });
+    page.on("error", () => page.terminate());
+}

package/dist/src/programs.d.ts

@@ -6,12 +6,19 @@ export interface ProgramsOptions {
     log?: (message: string) => void;
     /** How ChatGPT's requests leave, instead of the network. For tests. */
     fetch?: (request: Request, init: RequestInit) => Promise<Response>;
+    /** Where the computer connector looks for a local service, the web unit's server, and agents' folders. For tests. */
+    computer?: {
+        dataFolder?: string;
+        webUrl?: string;
+        agentsFolder?: string;
+    };
 }
 export interface Programs {
     /** The Actors running now, by program. */
     chatgpt?: string;
     agents?: string;
     mcp?: string;
+    computer?: string;
     management?: string;
     /** Leave the Hub, in the order that lets each finish. What each keeps stays. */
     close(): Promise<void>;

package/dist/src/programs.js

@@ -1,8 +1,9 @@
-// The app's programs: ChatGPT, the agent provider, the MCP provider and management, each an Actor
+// The app's programs: ChatGPT, the agent provider, the MCP provider, the computer connector and management, each an Actor
 // of its own that this process runs on its own channel, with its own private folder under the home.
 // Every step reads what is there before it acts, so each start converges on the same system.
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { startComputerProvider } from "@agentorg/computer-connector";
 import { HubState, PERSON } from "@agentorg/hub";
 import { startManager } from "@agentorg/manager";
 import { startMcpProvider } from "@agentorg/mcp";
@@ -25,6 +26,17 @@ export function closePackageActors(home) {
         state.close();
     }
 }
+/** The bundled Assistant: the base, a computer on a service the person chooses, and the web. */
+const ASSISTANT_TEMPLATE = {
+    id: "assistant",
+    title: "Assistant",
+    description: "An agent with a computer of its own and the web.",
+    base: { provider: "AgentOrg", creatable: "assistant" },
+    units: [
+        { provider: "Computers", unit: "computer", values: { access: "terminal", browser: true } },
+        { provider: "Computers", unit: "web", values: { service: "exa" } },
+    ],
+};
 /** The Hub's exports each program holds. */
 const hubBinding = (name) => ({ slot: name, provider: "hub", export: name });
 /**
@@ -131,6 +143,19 @@ export async function startPrograms(person, options) {
         closers.unshift(() => running.close());
         return actorId;
     });
+    const computer = await attempt("the computer connector", async () => {
+        const { actorId, credential } = await identity("computer", "Computers", [hubBinding("actors")]);
+        const running = await startComputerProvider({
+            hubUrl,
+            actorId,
+            credential,
+            dir: dirOf("computer"),
+            log: programLog,
+            ...options.computer,
+        });
+        closers.unshift(() => running.close());
+        return actorId;
+    });
     const management = await attempt("management", async () => {
         const { actorId, credential } = await identity("management", "Management", [
             hubBinding("actors"),
@@ -144,6 +169,7 @@ export async function startPrograms(person, options) {
             credential,
             dir: dirOf("management"),
             log: programLog,
+            templates: [ASSISTANT_TEMPLATE],
         });
         closers.push(() => running.close());
         for (const [slot, exported] of [
@@ -155,13 +181,14 @@ export async function startPrograms(person, options) {
         return actorId;
     });
     if (management)
-        for (const provider of [agents, mcp])
+        for (const provider of [agents, mcp, computer])
             if (provider)
                 await attempt("connecting a provider to management", () => call("grants", "expose", { provider, export: "provider", to: management }));
     return {
         ...(chatgpt ? { chatgpt } : {}),
         ...(agents ? { agents } : {}),
         ...(mcp ? { mcp } : {}),
+        ...(computer ? { computer } : {}),
         ...(management ? { management } : {}),
         async close() {
             for (const close of closers)

package/dist/src/signin.d.ts

@@ -1,15 +1,24 @@
+/** Where the sessions' hashes outlast the app: read once, when first needed, and written at each sign-in. */
+export interface KeptSessions {
+    /** What was written last; anything that isn't a list is read as none. */
+    read(): unknown;
+    write(hashes: string[]): void;
+}
 /**
  * Who may use the gateway: browser tabs with a session, made from a one-time code, and the CLI
  * with the token in the home. A code works once, within 60 s, and travels only in a URL's
- * fragment, which no request carries. A session is a random id the gateway holds in memory, so a
- * restart signs every tab out. It is no cookie, which every port on 127.0.0.1 would receive: the
- * shell keeps it in its origin's own storage and says it in its socket's first message.
+ * fragment, which no request carries. A session is a random id of which the gateway holds only a
+ * hash. With `kept`, the hashes outlast the app, so a tab is still signed in when the app starts
+ * again; a session ends only when `SESSIONS_MAX` newer ones have been given.
+ * It is no cookie, which every port on 127.0.0.1 would receive: the shell keeps it in its origin's
+ * own storage and says it in its socket's first message.
  */
 export declare class SignIn {
     #private;
     readonly cliToken: string;
     constructor(options?: {
         now?: () => number;
+        kept?: KeptSessions;
     });
     /** A new one-time code, for `/signin#<code>`. */
     code(): string;

package/dist/src/signin.js

@@ -1,10 +1,12 @@
-import { randomBytes, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 /** How long a sign-in code works. */
 const CODE_TTL_MS = 60_000;
 /** Codes not yet used; past it, the oldest go, so nothing grows without bound. */
 const MAX_CODES = 16;
 const SESSIONS_MAX = 256;
 const token = () => randomBytes(32).toString("base64url");
+/** What is kept of a session: enough to know it again, and nothing that signs anyone in. */
+const hashOf = (session) => createHash("sha256").update(session).digest("base64url");
 const same = (a, b) => {
     const left = Buffer.from(a);
     const right = Buffer.from(b);
@@ -13,17 +15,34 @@ const same = (a, b) => {
 /**
  * Who may use the gateway: browser tabs with a session, made from a one-time code, and the CLI
  * with the token in the home. A code works once, within 60 s, and travels only in a URL's
- * fragment, which no request carries. A session is a random id the gateway holds in memory, so a
- * restart signs every tab out. It is no cookie, which every port on 127.0.0.1 would receive: the
- * shell keeps it in its origin's own storage and says it in its socket's first message.
+ * fragment, which no request carries. A session is a random id of which the gateway holds only a
+ * hash. With `kept`, the hashes outlast the app, so a tab is still signed in when the app starts
+ * again; a session ends only when `SESSIONS_MAX` newer ones have been given.
+ * It is no cookie, which every port on 127.0.0.1 would receive: the shell keeps it in its origin's
+ * own storage and says it in its socket's first message.
  */
 export class SignIn {
     cliToken = token();
     #codes = new Map();
+    /** The hash of each session, the oldest first. */
     #sessions = new Set();
     #now;
+    #kept;
+    #restored = false;
     constructor(options = {}) {
         this.#now = options.now ?? Date.now;
+        this.#kept = options.kept;
+    }
+    /** Take back what was kept, the first time a session is given or asked about. */
+    #restore() {
+        if (this.#restored)
+            return;
+        this.#restored = true;
+        const read = this.#kept?.read();
+        const hashes = Array.isArray(read) ? read : [];
+        for (const hash of hashes.slice(-SESSIONS_MAX))
+            if (typeof hash === "string")
+                this.#sessions.add(hash);
     }
     /** A new one-time code, for `/signin#<code>`. */
     code() {
@@ -48,17 +67,22 @@ export class SignIn {
         if (this.#now() > expires)
             return undefined;
         const session = token();
-        this.#sessions.add(session);
+        this.#restore();
+        this.#sessions.add(hashOf(session));
         while (this.#sessions.size > SESSIONS_MAX)
             this.#sessions.delete(this.#sessions.values().next().value);
+        // Kept before it is given: a session the tab holds is one a restart still knows.
+        this.#kept?.write([...this.#sessions]);
         return session;
     }
     /** Whether a session is live. */
     isSession(session) {
         if (typeof session !== "string")
             return false;
+        this.#restore();
+        const hash = hashOf(session);
         for (const known of this.#sessions)
-            if (same(known, session))
+            if (same(known, hash))
                 return true;
         return false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/cli",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "AgentOrg as one app: the Hub, the person's gateway and the shell, on loopback.",
   "license": "MIT",
   "repository": {
@@ -29,6 +29,7 @@
   "dependencies": {
     "@modelcontextprotocol/client": "2.4.0",
     "ajv": "^8.20.0",
+    "react-diff-view": "3.3.3",
     "ws": "^8.22.1",
     "yaml": "2.9.1",
     "zod": "^4.6.7"

package/dist/node_modules/@agentorg/interfaces/dist/src/mcp-provider.d.ts

@@ -1,88 +0,0 @@
-import { z } from "zod";
-/** A way a provider makes connections, such as `url` or `command`. */
-export declare const ConnectionKind: z.ZodString;
-/** `connecting` before its first success, `connected`, or `down` and being tried again. */
-export declare const ConnectionState: z.ZodEnum<{
-    connected: "connected";
-    connecting: "connecting";
-    down: "down";
-}>;
-/** A connection's tools, for people to read; a provider cuts a long description to fit. */
-export declare const ConnectionTool: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/** How a connection stands now: `detail` says why it is down, and never holds a secret. */
-export declare const ConnectionStatus: z.ZodObject<{
-    state: z.ZodEnum<{
-        connected: "connected";
-        connecting: "connecting";
-        down: "down";
-    }>;
-    detail: z.ZodOptional<z.ZodString>;
-    tools: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/** The parameters of a connection, fitting its kind's `params` schema. */
-export declare const ConnectionParams: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-/**
- * What a server needs and shouldn't be seen, by name, such as a bearer token. Write-only: the values
- * cross once, in `create`, and go only to the provider's own private file.
- */
-export declare const ConnectionSecrets: z.ZodRecord<z.ZodString, z.ZodString>;
-/** What a connection attaches to or runs, for people to read: never a secret. */
-export declare const ConnectionTarget: z.ZodString;
-/**
- * `mcp.provider@1`: a program that makes connections to MCP servers. Each connection joins the
- * Hub as its own Actor, whose id is `connection`, exporting `tools@1` as `tools`. MCP itself stays
- * behind this interface.
- *
- * A secret a server needs is given once, in `create`'s `secrets`, and stays with the provider: its
- * value is never in `params`, `target`, `detail`, or anything else read back. `status` and `remove` are refused `unknown` for a connection the
- * provider doesn't hold.
- */
-export declare const mcpProvider: import("@agentorg/sdk").RpcInterface<"mcp.provider", {
-    /** The kinds it offers; `params` and `secrets` are the JSON Schemas of what each one takes. */
-    kinds: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        kinds: z.ZodArray<z.ZodObject<{
-            kind: z.ZodString;
-            title: z.ZodString;
-            params: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-            secrets: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    /**
-     * Make a connection and its Actor, named `name`. It returns once the Actor has joined the Hub,
-     * whether or not the server has answered yet; `status` says how it stands. Refused `invalid`
-     * when `kind` isn't offered or `params` or `secrets` don't fit it.
-     */
-    create: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        kind: z.ZodString;
-        params: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-        secrets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        connection: z.ZodString;
-        target: z.ZodString;
-    }, z.core.$strip>>;
-    status: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        connection: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        state: z.ZodEnum<{
-            connected: "connected";
-            connecting: "connecting";
-            down: "down";
-        }>;
-        detail: z.ZodOptional<z.ZodString>;
-        tools: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    /** End the connection and close its Actor, which removes what was bound to it. */
-    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        connection: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-}, {}, 1>;