@agentorg/cli 0.0.4 → 0.0.6

package/dist/node_modules/@agentorg/mcp/dist/src/provider.js

@@ -0,0 +1,167 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { hubActors, mcpProvider } from "@agentorg/interfaces";
+import { Refused } from "@agentorg/sdk";
+import { connect } from "@agentorg/sdk/client";
+import { z } from "zod";
+import { Connection } from "./connection.js";
+import { KINDS, parseConnection, targetOf } from "./kinds.js";
+/** What is kept of a connection between runs, in the provider's private file. */
+const Stored = z.object({
+    credential: z.string(),
+    kind: z.string(),
+    params: z.record(z.string(), z.unknown()),
+    secrets: z.record(z.string(), z.string()),
+});
+const FILE = "connections.json";
+const quiet = { info() { }, warn() { }, error() { } };
+/**
+ * Run the built-in MCP provider as an Actor exporting `mcp.provider@1` as `provider`. It offers two
+ * kinds, `url` and `command`; a server it starts runs with this process's rights. Connections made earlier are joined again at the start.
+ */
+export async function startMcpProvider(options) {
+    const log = options.log ?? quiet;
+    const { hubUrl, dir } = options;
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    const path = join(dir, FILE);
+    /** The file, entry by entry; one that can't be read is set aside and the rest still run. */
+    const read = () => {
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return {};
+            throw error;
+        }
+        const entries = z.record(z.string(), z.unknown()).safeParse((() => {
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                return undefined;
+            }
+        })());
+        if (!entries.success) {
+            renameSync(path, `${path}.unreadable-${Date.now()}`);
+            log.error("The connections file can't be read: it is set aside and starts empty.");
+            return {};
+        }
+        const kept = {};
+        for (const [id, entry] of Object.entries(entries.data)) {
+            const parsed = Stored.safeParse(entry);
+            if (parsed.success)
+                kept[id] = parsed.data;
+            else
+                log.error(`Connection ${id} can't be read, and is left out.`);
+        }
+        return kept;
+    };
+    const stored = read();
+    const save = () => {
+        writeFileSync(`${path}.tmp`, JSON.stringify(stored), { mode: 0o600, flush: true });
+        renameSync(`${path}.tmp`, path);
+    };
+    const connections = new Map();
+    const open = async (actorId, credential, spec, secrets) => {
+        const connection = new Connection(spec, secrets, log, options.timing);
+        await connection.join({ hubUrl, actorId, credential });
+        connections.set(actorId, connection);
+        return connection;
+    };
+    let closing = false;
+    const endAll = () => Promise.all([...connections.values()].map((c) => c.end()));
+    const held = (id) => {
+        const connection = connections.get(id);
+        if (!connection)
+            throw new Refused("unknown", `This provider holds no connection ${id}.`);
+        return connection;
+    };
+    for (const [actorId, { credential, kind, params, secrets }] of Object.entries(stored)) {
+        const { spec, secrets: hidden, why } = parseConnection(kind, params, secrets);
+        if (!spec) {
+            log.error(`Connection ${actorId} can't be read: ${why}`);
+            continue;
+        }
+        try {
+            (await open(actorId, credential, spec, hidden)).run();
+        }
+        catch (error) {
+            log.error(`Connection ${actorId} didn't rejoin the Hub: ${String(error)}`);
+            // The Hub no longer knows it: its Actor was closed while the provider was away.
+            if (error instanceof Refused && error.code === "forbidden") {
+                delete stored[actorId];
+                save();
+            }
+        }
+    }
+    const provider = await connect({
+        hubUrl,
+        actorId: options.actorId,
+        credential: options.credential,
+        slots: { actors: hubActors },
+        exports: { provider: mcpProvider },
+        log,
+        start(ctx) {
+            ctx.exports.provider.implement({
+                kinds: () => ({
+                    kinds: KINDS.map(({ kind, title, params, secrets }) => ({
+                        kind,
+                        title,
+                        params: JSON.parse(JSON.stringify(z.toJSONSchema(params))),
+                        secrets: JSON.parse(JSON.stringify(z.toJSONSchema(secrets))),
+                    })),
+                }),
+                async create({ kind, params, secrets, name }) {
+                    const { spec, secrets: hidden, why } = parseConnection(kind, params, secrets);
+                    if (!spec)
+                        throw new Refused("invalid", why);
+                    const { actorId, credential } = await ctx.slots.actors.call.create({ name });
+                    let connection;
+                    try {
+                        connection = await open(actorId, credential, spec, hidden);
+                        if (closing)
+                            throw new Refused("unavailable", "This provider is stopping.");
+                        stored[actorId] = { credential: credential, kind, params, secrets: hidden };
+                        save();
+                        connection.run();
+                    }
+                    catch (error) {
+                        connections.delete(actorId);
+                        delete stored[actorId];
+                        await connection?.end();
+                        await ctx.slots.actors.call.close({ actorId }).catch(() => { });
+                        throw error;
+                    }
+                    return { connection: actorId, target: targetOf(spec) };
+                },
+                status: ({ connection }) => held(connection).status(),
+                async remove({ connection }) {
+                    const found = held(connection);
+                    await ctx.slots.actors.call.close({ actorId: connection });
+                    connections.delete(connection);
+                    delete stored[connection];
+                    try {
+                        save();
+                    }
+                    finally {
+                        await found.end();
+                    }
+                    return {};
+                },
+            });
+        },
+    }).catch(async (error) => {
+        await endAll();
+        throw error;
+    });
+    return {
+        async close() {
+            closing = true;
+            await endAll();
+            provider.close();
+        },
+    };
+}

package/dist/node_modules/@agentorg/mcp/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@agentorg/mcp",
+  "version": "0.0.0",
+  "private": true,
+  "description": "The built-in MCP provider: each connection to an MCP server is an Actor offering tools@1",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "test": "node --test \"dist/test/**/*.test.js\""
+  },
+  "dependencies": {
+    "@agentorg/interfaces": "0.0.0",
+    "@agentorg/sdk": "0.0.0",
+    "@modelcontextprotocol/client": "2.4.0",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@agentorg/hub": "0.0.0",
+    "@modelcontextprotocol/server": "2.4.0"
+  }
+}

package/dist/node_modules/@agentorg/sdk/dist/src/cli.js

@@ -8,22 +8,19 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { openChannel } from "./client.js";
 import { NotConnected, OutcomeUnknown, Refused } from "./errors.js";
-import { BuildError, buildPackage } from "./package.js";
 import { hubHome, personCall, UsageError } from "./person-commands.js";
 const USAGE = `Usage: agentorg <command> [--home DIR]
 
-  build [package-dir]                       build a package into a .agentorg archive
   hub [--port N]                            run a Hub, serving on loopback
-  add <file.agentorg>                       hub.packages.add
   actors | bindings | exports | audit       each one's list
   bind <consumer.slot> <provider.export>    hub.grants.bind
   call <slot> <method> [json]               call one of the person's slots
 
-Commands other than build and hub act as the person, with the Hub home's person-credential.
+Commands other than hub act as the person, with the Hub home's person-credential.
 The home is --home, else $AGENTORG_HUB_HOME, else
 $XDG_DATA_HOME/agentorg, else ~/.local/share/agentorg.
 `;
@@ -56,21 +53,6 @@ if (values.help) {
     process.exit(0);
 }
 const home = hubHome(values.home);
-async function build() {
-    try {
-        const built = await buildPackage(rest[0] ?? ".");
-        write(process.stdout, `${built.manifest.name}@${built.manifest.version} ${built.hash}\n${relative(process.cwd(), built.file)}`);
-    }
-    catch (error) {
-        // A BuildError says what to fix; anything else is a bug, so its stack is shown.
-        write(process.stderr, error instanceof BuildError
-            ? error.message
-            : error instanceof Error
-                ? (error.stack ?? error.message)
-                : String(error));
-        process.exit(1);
-    }
-}
 /** Run a Hub in the home, and leave its address in `<home>/url` for the other commands. */
 async function hub() {
     if (values.port !== undefined && !/^\d{1,5}$/.test(values.port))
@@ -178,9 +160,7 @@ catch (error) {
         throw error;
     usage(error.message);
 }
-if (command === "build")
-    await build();
-else if (command === "hub")
+if (command === "hub")
     await hub();
 else if (call)
     await asPerson(call.slot, call.method, call.input);

package/dist/node_modules/@agentorg/sdk/dist/src/client.d.ts

@@ -1,6 +1,6 @@
 import { type Header, type WireError } from "@agentorg/wire";
 import { type DescribedInterface, type Interface } from "./interface.js";
-import { type Context, type Duplex, type ExportMap, type InterfaceMap, type Log } from "./module.js";
+import { type Context, type ExportMap, type InterfaceMap, type Log } from "./module.js";
 /** A stream the Hub opens toward this Actor's exports, naming the export and who is calling. */
 export type Serve = Extract<Header, {
     op: "serve";
@@ -10,25 +10,11 @@ export interface ServeHandlers {
     call(serve: Serve, input: unknown): Promise<unknown>;
     /** Start sending an export's events; `end` stops them from this side. Returns how to stop. */
     subscribe(serve: Serve, send: (payload: unknown) => void, end: (error?: unknown) => void): () => void;
-    /** Check that the export takes the stream (throwing a refusal if not), then return what runs it. */
-    accept(serve: Serve): (stream: Duplex) => Promise<void>;
-    /** The same for an `http` export: the stream carries HTTP/1.1 once accepted. */
-    serveHttp(serve: Serve): (stream: Duplex) => Promise<void>;
 }
-/**
- * Where the channel goes: the Hub's WebSocket address with the Actor's credential, or a pipe the
- * Hub made for this Actor's process, whose hello needs no credential.
- */
-export type ChannelOptions = ChannelBase & ({
+export interface ChannelOptions {
+    /** The Hub's WebSocket address. */
     hubUrl: string;
     credential: string;
-    channel?: never;
-} | {
-    channel: Duplex;
-    hubUrl?: never;
-    credential?: never;
-});
-interface ChannelBase {
     actorId: string;
     /**
      * Whether this channel may replace one the Actor already has (the default). With `false`, a
@@ -76,12 +62,6 @@ export interface Channel {
     call(slot: string, method: string, value: unknown): Promise<unknown>;
     /** Events from a slot's provider until it ends (`onEnd`) or is stopped; returns how to stop. */
     subscribe(slot: string, event: string, onEvent: (payload: unknown) => void, onEnd?: (error?: Error) => void): () => void;
-    open(slot: string, params: unknown): Promise<Duplex>;
-    /** A stream to an `http` slot's provider, carrying HTTP/1.1 once it accepts. */
-    http(slot: string): Promise<Duplex>;
-    /** Offer and withdraw run-time exports; they reach the Hub in the order they were made. */
-    offer(name: string, iface: DescribedInterface): Promise<void>;
-    withdraw(name: string): Promise<void>;
     close(): void;
     /** Settles when the channel ends. */
     readonly closed: Promise<void>;
@@ -128,8 +108,7 @@ type None = Record<never, Interface>;
  * `start`, and use slots from `onBind`. `start` runs before the channel opens, so the Hub never
  * reaches an export before it is implemented. A slot is bound when the Hub says so; `onBind` runs
  * when it becomes usable (bound, or its provider back), and `on` handlers subscribe while it is
- * usable. `exports.add` and `withdraw()` offer and withdraw over the channel. `http` slots and
- * exports speak HTTP/1.1 over the Hub's stream, one request per stream, with `node:http`.
+ * usable.
  */
 export declare function connect<const S extends InterfaceMap = None, const X extends ExportMap = None>(options: ConnectOptions<S, X>): Promise<Client<S, X>>;
 export {};

package/dist/node_modules/@agentorg/sdk/dist/src/client.js

@@ -57,9 +57,7 @@ export async function openChannel(options) {
         ready = resolve;
     });
     try {
-        const bytes = options.channel !== undefined
-            ? options.channel
-            : await webSocketChannel(new WebSocket(options.hubUrl));
+        const bytes = await webSocketChannel(new WebSocket(options.hubUrl));
         session = new Session(bytes, {
             client: true,
             onStream(stream) {
@@ -73,7 +71,7 @@ export async function openChannel(options) {
         });
     }
     catch {
-        throw new NotConnected(`the Hub at ${options.hubUrl ?? "its pipe"}`);
+        throw new NotConnected(`the Hub at ${options.hubUrl}`);
     }
     async function serveStream(header, stream, reader) {
         if (header.op === "slot") {
@@ -119,14 +117,6 @@ export async function openChannel(options) {
             }
             if (header.kind === "subscribe")
                 return subscribeStream(handlers, header, stream);
-            if (header.kind === "open" || header.kind === "http") {
-                const run = header.kind === "open" ? handlers.accept(header) : handlers.serveHttp(header);
-                const writer = stream.writable.getWriter();
-                await writer.write(encodeFrame(result({})));
-                writer.releaseLock();
-                // Accepted: from here the stream is raw bytes, so a failing handler can only reset it.
-                return await run({ readable: reader.rest(), writable: stream.writable }).catch(() => stream.reset());
-            }
             return stream.reset();
         }
         catch (error) {
@@ -195,7 +185,7 @@ export async function openChannel(options) {
     const hello = await exchange({
         op: "hello",
         actorId: options.actorId,
-        ...(options.credential === undefined ? {} : { credential: options.credential }),
+        credential: options.credential,
         ...(options.declares ? { declares: options.declares } : {}),
         ...(options.replace === false ? { replace: false } : {}),
     }, "the Hub");
@@ -213,13 +203,6 @@ export async function openChannel(options) {
             throw new Refused("bad_output", "The Hub's answer isn't a result.");
         return body.result;
     };
-    // Offers and withdrawals go one at a time, so the Hub sees them in the order they were made.
-    let changes = Promise.resolve();
-    const inOrder = (work) => {
-        const next = changes.then(work, work);
-        changes = next.catch(() => { });
-        return next;
-    };
     const closed = session.closed.then(() => {
         ended = true;
         bound.clear();
@@ -274,41 +257,9 @@ export async function openChannel(options) {
                 stream.reset();
             };
         },
-        open: (slot, params) => splice({ op: "open", slot, params }, slot),
-        http: (slot) => splice({ op: "http", slot }, slot),
-        offer: (name, iface) => inOrder(async () => {
-            answered(await exchange({ op: "offer", name, interface: iface }, name), name);
-        }),
-        withdraw: (name) => inOrder(async () => {
-            answered(await exchange({ op: "withdraw", name }, name), name);
-        }),
         close: () => session.close(),
         closed,
     };
-    /** Open a raw stream: send its header, read the one body that answers, then hand over the bytes. */
-    async function splice(header, slot) {
-        let stream;
-        try {
-            stream = session.open();
-            const writer = stream.writable.getWriter();
-            await writer.write(encodeFrame(header));
-            writer.releaseLock();
-            const reader = new FrameReader(stream.readable);
-            const first = await reader.next();
-            if (first === undefined)
-                throw new NotConnected(slot);
-            answered(parseBody(first), slot);
-            return { readable: reader.rest(), writable: stream.writable };
-        }
-        catch (error) {
-            stream?.reset();
-            if (error instanceof Refused ||
-                error instanceof NotConnected ||
-                error instanceof OutcomeUnknown)
-                throw error;
-            throw new NotConnected(slot);
-        }
-    }
 }
 const quiet = { info() { }, warn() { }, error() { } };
 /**
@@ -317,8 +268,7 @@ const quiet = { info() { }, warn() { }, error() { } };
  * `start`, and use slots from `onBind`. `start` runs before the channel opens, so the Hub never
  * reaches an export before it is implemented. A slot is bound when the Hub says so; `onBind` runs
  * when it becomes usable (bound, or its provider back), and `on` handlers subscribe while it is
- * usable. `exports.add` and `withdraw()` offer and withdraw over the channel. `http` slots and
- * exports speak HTTP/1.1 over the Hub's stream, one request per stream, with `node:http`.
+ * usable.
  */
 export async function connect(options) {
     const slots = (options.slots ?? {});
@@ -326,7 +276,7 @@ export async function connect(options) {
     const log = options.log ?? quiet;
     // defineActor checks the names, as it does for a module.
     const definition = defineActor({ slots, exports, start: options.start ?? (() => { }) });
-    const host = new ModuleHost("", slots, log);
+    const host = new ModuleHost(slots, log);
     const runtime = createRuntime(definition, {
         self: { actorId: options.actorId, module: "client" },
         log,

package/dist/node_modules/@agentorg/sdk/dist/src/errors.d.ts

@@ -1,4 +1,4 @@
-/** A call on a slot that no export is bound to, or on an export that was withdrawn. */
+/** A call on a slot that no export is bound to. */
 export declare class NotConnected extends Error {
     static [Symbol.hasInstance](value: unknown): boolean;
     readonly name = "NotConnected";

package/dist/node_modules/@agentorg/sdk/dist/src/errors.js

@@ -1,6 +1,6 @@
 /**
- * Marks an SDK error class's prototype with its name. A package's bundles and the runner each carry
- * their own copy of the SDK, so `instanceof` on these three classes checks this mark rather than
+ * Marks an SDK error class's prototype with its name. Programs may carry their own copy of the SDK,
+ * so `instanceof` on these three classes checks this mark rather than
  * the class, and an error made by one copy is the same error to the other. A subclass is checked
  * as usual.
  */
@@ -12,7 +12,7 @@ const instanceOf = (asked, base, name, value) =>
 asked === base
     ? isBranded(value, name)
     : Function.prototype[Symbol.hasInstance].call(asked, value);
-/** A call on a slot that no export is bound to, or on an export that was withdrawn. */
+/** A call on a slot that no export is bound to. */
 export class NotConnected extends Error {
     static [Symbol.hasInstance](value) {
         // biome-ignore lint/complexity/noThisInStatic: `this` is the class instanceof was asked about, a subclass included.

package/dist/node_modules/@agentorg/sdk/dist/src/index.d.ts

@@ -1,4 +1,4 @@
 export { canonicalJson, hashOf, sha256 } from "./canonical.js";
 export { NotConnected, OutcomeUnknown, Refused, type RefusedCode } from "./errors.js";
-export { compareInterfaces, type DescribedInterface, defineInterface, describeInterface, type EventSpec, type Events, event, type HttpInterface, hashInterface, type Interface, type InterfaceSchemas, interfaceId, type JsonSchema, type MethodSpec, type Methods, method, normalizeSchema, type RpcInterface, type StreamInterface, } from "./interface.js";
-export { type CallInfo, type Context, type Duplex, defineActor, defineWidget, type EmitOptions, type Export, type ExportMap, type ExposedSlot, type FrameRoot, type Handlers, type HttpExport, type HttpSlot, type InterfaceMap, isFrameInterface, isModuleDefinition, type Log, MODULE, type ModuleDefinition, type ModuleSpec, type Placement, type RpcExport, type RpcSlot, type Slot, type StreamExport, type StreamSlot, type ViewExport, } from "./module.js";
+export { compareInterfaces, type DescribedInterface, defineInterface, describeInterface, type EventSpec, type Events, event, hashInterface, type Interface, type InterfaceSchemas, interfaceId, type JsonSchema, type MethodSpec, type Methods, method, normalizeSchema, type RpcInterface, } from "./interface.js";
+export { type CallInfo, type Context, defineActor, type EmitOptions, type Export, type ExportMap, type ExposedSlot, type Handlers, type InterfaceMap, type Log, type ModuleDefinition, type ModuleSpec, type RpcExport, type RpcSlot, type Slot, } from "./module.js";

package/dist/node_modules/@agentorg/sdk/dist/src/index.js

@@ -1,4 +1,4 @@
 export { canonicalJson, hashOf, sha256 } from "./canonical.js";
 export { NotConnected, OutcomeUnknown, Refused } from "./errors.js";
 export { compareInterfaces, defineInterface, describeInterface, event, hashInterface, interfaceId, method, normalizeSchema, } from "./interface.js";
-export { defineActor, defineWidget, isFrameInterface, isModuleDefinition, MODULE, } from "./module.js";
+export { defineActor, } from "./module.js";

package/dist/node_modules/@agentorg/sdk/dist/src/interface.d.ts

@@ -26,17 +26,7 @@ export interface RpcInterface<N extends string = string, M extends Methods = Met
     readonly methods: M;
     readonly events: E;
 }
-/** Raw bytes in a named protocol, the L4 shape; opening a stream takes parameters. */
-export interface StreamInterface<N extends string = string, O extends z.ZodType = z.ZodType> extends Named<N> {
-    readonly kind: "stream";
-    readonly protocol: string;
-    readonly open: O;
-}
-/** HTTP/1.1 requests and responses on streams, the L7 shape. */
-export interface HttpInterface<N extends string = string> extends Named<N> {
-    readonly kind: "http";
-}
-export type Interface = RpcInterface | StreamInterface | HttpInterface;
+export type Interface = RpcInterface;
 /**
  * A named, versioned contract, identified by `name@major`. A slot binds only to an export of the
  * same `name@major` whose schemas hash the same.
@@ -48,36 +38,18 @@ export declare function defineInterface<const N extends string, M extends Method
     methods: M;
     events?: E;
 }): RpcInterface<N, M, E, V>;
-export declare function defineInterface<const N extends string, O extends z.ZodType>(spec: {
-    name: N;
-    major: number;
-    kind: "stream";
-    protocol: string;
-    open: O;
-}): StreamInterface<N, O>;
-export declare function defineInterface<const N extends string>(spec: {
-    name: N;
-    major: number;
-    kind: "http";
-}): HttpInterface<N>;
 export type JsonSchema = Record<string, unknown>;
-/** An interface's identity and JSON Schemas, as the manifest records them. */
+/** An interface's identity and JSON Schemas. */
 export type InterfaceSchemas = {
     id: string;
-} & ({
+} & {
     kind: "rpc";
     methods: Record<string, {
         input: JsonSchema;
         output: JsonSchema;
     }>;
     events: Record<string, JsonSchema>;
-} | {
-    kind: "stream";
-    protocol: string;
-    open: JsonSchema;
-} | {
-    kind: "http";
-});
+};
 /** An interface's identity, JSON Schemas and hash. */
 export type DescribedInterface = InterfaceSchemas & {
     hash: string;
@@ -94,10 +66,10 @@ export declare function normalizeSchema(schema: JsonSchema): JsonSchema;
 /**
  * The hash of an interface: SHA-256 over the canonical JSON of its identity and normalized JSON
  * Schemas. Everything in those schemas is contract, `.describe()` text included, so a reader can
- * recompute the hash from the manifest alone.
+ * recompute the hash from them alone.
  */
 export declare function hashInterface(schemas: InterfaceSchemas): string;
-/** The interface as the manifest records it: identity, JSON Schemas and hash. */
+/** The interface as it crosses the wire: identity, JSON Schemas and hash. */
 export declare function describeInterface(iface: Interface): DescribedInterface;
 /**
  * Whether a slot's interface and an export's can be bound: `same` is the same `name@major` with

package/dist/node_modules/@agentorg/sdk/dist/src/interface.js

@@ -26,20 +26,8 @@ export function defineInterface(spec) {
                     throw new TypeError(`${id}: ${name} is both a method and an event.`);
             return { name: spec.name, major: spec.major, kind: "rpc", methods, events };
         }
-        case "stream":
-            if (!spec.protocol || !spec.open)
-                throw new TypeError(`${id}: a stream interface names its protocol and its open schema.`);
-            return {
-                name: spec.name,
-                major: spec.major,
-                kind: "stream",
-                protocol: spec.protocol,
-                open: spec.open,
-            };
-        case "http":
-            return { name: spec.name, major: spec.major, kind: "http" };
         default:
-            throw new TypeError(`${id}: kind must be rpc, stream or http.`);
+            throw new TypeError(`${id}: kind must be rpc.`);
     }
 }
 /** `name@major`, the identity a slot and an export must share. */
@@ -135,26 +123,17 @@ function interfaceSchemas(iface) {
                     jsonSchema(id, `event ${name}`, e.payload, "output"),
                 ])),
             };
-        case "stream":
-            return {
-                id,
-                kind: "stream",
-                protocol: iface.protocol,
-                open: jsonSchema(id, "open", iface.open, "input"),
-            };
-        case "http":
-            return { id, kind: "http" };
     }
 }
 /**
  * The hash of an interface: SHA-256 over the canonical JSON of its identity and normalized JSON
  * Schemas. Everything in those schemas is contract, `.describe()` text included, so a reader can
- * recompute the hash from the manifest alone.
+ * recompute the hash from them alone.
  */
 export function hashInterface(schemas) {
     return hashOf(schemas);
 }
-/** The interface as the manifest records it: identity, JSON Schemas and hash. */
+/** The interface as it crosses the wire: identity, JSON Schemas and hash. */
 export function describeInterface(iface) {
     const schemas = interfaceSchemas(iface);
     return { ...schemas, hash: hashInterface(schemas) };

package/dist/node_modules/@agentorg/sdk/dist/src/module-host.d.ts

@@ -1,40 +1,31 @@
-import type { Channel, ChannelExposure, Serve, ServeHandlers } from "./client.js";
-import { Refused } from "./errors.js";
+import type { Channel, ChannelExposure, ServeHandlers } from "./client.js";
 import type { InterfaceMap, Log } from "./module.js";
 import type { ModuleRuntime, RuntimeOptions } from "./runtime.js";
 /**
- * One module's runtime, joined to a channel. Its slots and exports are named on the wire with a
- * prefix: none for a program that connects itself, `<module>.` for a module in a package Actor's
- * process, where several share one channel. It binds slots as the Hub's notices say, subscribes
- * `on` handlers while a slot is usable, serves the Hub's streams to its exports, and offers and
- * withdraws run-time exports.
+ * A program's runtime, joined to its channel. It binds slots as the Hub's notices say, subscribes
+ * `on` handlers while a slot is usable, and serves the Hub's streams to its exports.
  */
 export declare class ModuleHost {
     #private;
-    constructor(prefix: string, slots: InterfaceMap, log: Log);
+    constructor(slots: InterfaceMap, log: Log);
     get runtime(): ModuleRuntime<InterfaceMap, InterfaceMap>;
     set runtime(runtime: ModuleRuntime<InterfaceMap, InterfaceMap>);
     /** The runtime's hooks for this host: pass them to `createRuntime`. */
-    hooks(): Pick<RuntimeOptions, "onEmit" | "onListen" | "onAdd" | "onWithdraw">;
+    hooks(): Pick<RuntimeOptions, "onEmit" | "onListen">;
     /**
      * A slot notice for one of this module's slots, by its local name: unbound, bound, or (for a
      * slot already bound) usable again because its provider came back.
      */
     onSlot(slot: string, isBound: boolean): void;
     /**
-     * A notice for a slot made at run time: bound (or usable again) with its exposure, or gone. Its
-     * name is the Actor's, with no module prefix: every module of the Actor has it.
+     * A notice for a slot made at run time: bound (or usable again) with its exposure, or gone.
      */
     onExposed(slot: string, exposure: ChannelExposure | undefined): void;
     /** How this module serves the Hub's streams, by its local export names. */
     readonly serve: ServeHandlers;
     /**
-     * Join the opened channel: offer what was added during start, bind the slots the Hub's hello
-     * said are bound, and leave nothing usable once the channel goes.
+     * Join the opened channel: bind the slots the Hub's hello said are bound, and leave nothing
+     * usable once the channel goes.
      */
     attach(channel: Channel): void;
 }
-/** A `serve` stream renamed to a module's local export name. */
-export declare const localServe: (serve: Serve, local: string) => Serve;
-/** A refusal for a name that names no module here. */
-export declare const noModule: (name: string) => Refused;