@agentorg/cli 0.0.5 → 0.0.7

package/dist/node_modules/@agentorg/interfaces/dist/src/chat.js

@@ -1,6 +1,11 @@
 import { defineInterface, event, method } from "@agentorg/sdk";
 import { z } from "zod";
 const MessageId = z.string().min(1).max(128);
+const ChatId = z.string().min(1).max(128);
+/** The longest title a chat has. */
+export const CHAT_TITLE_MAX = 200;
+/** One chat of an agent's, where a call names it. */
+const OnChat = z.object({ chat: ChatId });
 /**
  * A tool call a `tool` message stands for: its name, whether it is `running` or ended `done` or
  * `refused`, and its input (the call's JSON arguments) and output (its JSON result, or the
@@ -25,55 +30,99 @@ export const ChatMessage = z.object({
     at: z.string().max(64),
     tool: ChatTool.optional(),
 });
-export const ChatState = z.enum(["idle", "thinking", "tool", "error"]);
+/** What the agent is doing: `working` while it answers anything, in any chat. */
+export const ChatStatus = z.object({ state: z.enum(["idle", "working"]) });
 /**
- * What the agent is doing. On `error`, `detail.code` is the refusal's code, such as the model's
+ * Why a message in a chat got no answer. `code` is the refusal's code, such as the model's
  * `usage_limit` or `not_signed_in`, so a view can offer the right action.
  */
-export const ChatStatus = z.object({
-    state: ChatState,
-    detail: z.object({ code: z.string(), message: z.string() }).optional(),
+const ChatProblem = z.object({ code: z.string().max(128), message: z.string().max(2000) });
+/**
+ * One of an agent's chats, as a list shows it. Its `title` is its first message's first line until
+ * it is renamed. `latest` is its newest reply, so a view can tell what is new without reading the
+ * chat. `problem` is there while a message in it got no answer, until its next reply.
+ */
+export const ChatEntry = z.object({
+    id: ChatId,
+    title: z.string().max(CHAT_TITLE_MAX),
+    /** When it started: an ISO 8601 time. */
+    at: z.string().max(64),
+    latest: z.object({ id: MessageId, at: z.string().max(64) }).optional(),
+    problem: ChatProblem.optional(),
+    archived: z.boolean(),
 });
 /**
- * `chat@1`: a conversation with an agent. `send` starts a turn, whose messages, streaming text and
- * status arrive as events. Events are live only: `history` is the record, and `state` the status
- * now.
+ * `chat@1`: an agent's chats. A chat is the messages sent in it and nothing more: `send` with no
+ * `chat` starts one, and with one, goes on in it. Messages and streaming text arrive as events,
+ * each naming its chat. What works is the agent, not a chat: `status` says when it starts and
+ * when it is done. Events are live only: `history` is a chat's record, `state` the agent's status
+ * now, and `list` the chats. A provider that can't take
+ * a message now refuses it `busy`. A call naming a chat the agent doesn't have is refused
+ * `unknown`.
  */
 export const chat = defineInterface({
     name: "chat",
     major: 1,
     kind: "rpc",
     methods: {
+        /**
+         * Send this message in `chat`, or in a new chat; the result says which. The agent answers it
+         * in that chat. An archived chat takes a message like any other, and stays archived. Refused
+         * `busy` when the provider can't take it now.
+         */
         send: method({
-            input: z.object({ text: z.string().min(1).max(100_000).regex(/\S/) }),
-            output: z.object({ messageId: MessageId }),
+            input: z.object({
+                chat: ChatId.optional(),
+                text: z.string().min(1).max(100_000).regex(/\S/),
+            }),
+            output: z.object({ chat: ChatId, messageId: MessageId }),
         }),
         /**
-         * Messages before `before` (or the newest), oldest first; `more` when older ones remain. A
-         * provider returns fewer than `limit` when a page would not fit one frame.
+         * A chat's messages before `before` (or the newest), oldest first; `more` when older ones
+         * remain. A provider returns fewer than `limit` when a page would not fit one frame.
          */
         history: method({
-            input: z.object({
+            input: OnChat.extend({
                 before: MessageId.optional(),
                 limit: z.number().int().min(1).max(200).optional(),
             }),
             output: z.object({ messages: z.array(ChatMessage), more: z.boolean() }),
         }),
-        /** Stop the current turn, if any. */
-        cancel: method({ input: z.object({}), output: z.object({}) }),
-        /** The status now, as the latest `status` event said; for a view opened mid-turn. */
+        /** The agent's status now, as its latest `status` event said; for a view opened late. */
         state: method({ input: z.object({}), output: ChatStatus }),
         /**
-         * Run the last turn again from the record, without recording the person's message again;
-         * `messageId` is that message's. Refused `busy` during a turn, and `nothing_to_retry` when no
-         * message has been sent.
+         * The chats after `before` in the list (or from its start), newest first by their last
+         * message; `more` when others follow. Those not archived, or with `archived`, those that are.
+         * A message sent in a chat moves it to the front, so a later page may repeat a chat that
+         * moved, and never leaves out one that didn't: the `chat` event says each that did. A `before`
+         * the agent doesn't have gives an empty page.
          */
-        retry: method({ input: z.object({}), output: z.object({ messageId: MessageId }) }),
+        list: method({
+            input: z.object({
+                archived: z.boolean().optional(),
+                before: ChatId.optional(),
+                limit: z.number().int().min(1).max(200).optional(),
+            }),
+            output: z.object({ chats: z.array(ChatEntry), more: z.boolean() }),
+        }),
+        /** Give a chat another title: one line, so only the first line of `title` is kept. */
+        rename: method({
+            input: OnChat.extend({ title: z.string().min(1).max(CHAT_TITLE_MAX).regex(/\S/) }),
+            output: z.object({}),
+        }),
+        /** Put a chat among the archived ones, or back. It stays readable either way. */
+        archive: method({ input: OnChat.extend({ archived: z.boolean() }), output: z.object({}) }),
     },
     events: {
-        message: event(ChatMessage),
+        message: event(ChatMessage.extend({ chat: ChatId })),
         /** Text of the assistant message `id`, as it streams; its `message` event follows. */
-        delta: event(z.object({ id: MessageId, text: z.string() })),
+        delta: event(z.object({ chat: ChatId, id: MessageId, text: z.string() })),
+        /** The agent's status, when it changes. */
         status: event(ChatStatus),
+        /**
+         * A chat as it now is: it was started, renamed or archived, a message was sent in it, or one
+         * got no answer.
+         */
+        chat: event(ChatEntry),
     },
 });

package/dist/node_modules/@agentorg/interfaces/dist/src/connection.d.ts

@@ -0,0 +1,36 @@
+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;

package/dist/node_modules/@agentorg/interfaces/dist/src/connection.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+/** A way a provider makes connections, such as `url` or `command`. */
+export const ConnectionKind = z
+    .string()
+    .regex(/^[a-z][a-z0-9-]*$/)
+    .max(64);
+/** `connecting` before its first success, `connected`, or `down` and being tried again. */
+export const ConnectionState = z.enum(["connecting", "connected", "down"]);
+/** A connection's tools, for people to read; a provider cuts a long description to fit. */
+export const ConnectionTool = z.object({
+    name: z.string().min(1).max(128),
+    description: z.string().max(512).optional(),
+});
+/** How a connection stands now: `detail` says why it is down, and never holds a secret. */
+export const ConnectionStatus = z.object({
+    state: ConnectionState,
+    detail: z.string().max(2000).optional(),
+    tools: z.array(ConnectionTool),
+});
+/** The parameters of a connection, fitting its kind's `params` schema. */
+export const ConnectionParams = z.record(z.string(), z.json());
+/**
+ * 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 const ConnectionSecrets = z.record(z
+    .string()
+    .regex(/^[A-Za-z_][A-Za-z0-9_]*$/)
+    .max(256), z.string().min(1).max(16_384));
+/** What a connection attaches to or runs, for people to read: never a secret. */
+export const ConnectionTarget = z.string().min(1).max(4096);

package/dist/node_modules/@agentorg/interfaces/dist/src/folders.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+/** The most folders one answer names. */
+export declare const FOLDERS_MAX = 2000;
+/**
+ * `folders@1`: the folders on the machine the app runs on, for a person choosing one. It names
+ * folders and nothing else. `list` starts at the person's home folder; `parent` is absent at the
+ * top. Refused `unknown` when there's no such folder, `invalid` for a path that isn't absolute.
+ */
+export declare const folders: import("@agentorg/sdk").RpcInterface<"folders", {
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        parent: z.ZodOptional<z.ZodString>;
+        folders: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, {}, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/folders.js

@@ -0,0 +1,25 @@
+import { defineInterface, method } from "@agentorg/sdk";
+import { z } from "zod";
+/** The most folders one answer names. */
+export const FOLDERS_MAX = 2000;
+const Path = z.string().min(1).max(4096);
+/**
+ * `folders@1`: the folders on the machine the app runs on, for a person choosing one. It names
+ * folders and nothing else. `list` starts at the person's home folder; `parent` is absent at the
+ * top. Refused `unknown` when there's no such folder, `invalid` for a path that isn't absolute.
+ */
+export const folders = defineInterface({
+    name: "folders",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        list: method({
+            input: z.object({ path: Path.optional() }),
+            output: z.object({
+                path: Path,
+                parent: Path.optional(),
+                folders: z.array(z.object({ name: z.string().max(4096) })).max(FOLDERS_MAX),
+            }),
+        }),
+    },
+});

package/dist/node_modules/@agentorg/interfaces/dist/src/hub.d.ts

@@ -1,52 +1,7 @@
 import { z } from "zod";
 export declare const Id: z.ZodString;
-/** A slot or export: `name` for an external Actor, `module.name` for a package Actor. */
+/** A slot or export: `name`, or `module.name`. */
 export declare const Name: z.ZodString;
-export declare const Package: z.ZodObject<{
-    hash: z.ZodString;
-    name: z.ZodString;
-    version: z.ZodString;
-}, z.core.$strip>;
-/** `hub.packages@1`: the content-addressed package store. */
-export declare const hubPackages: import("@agentorg/sdk").RpcInterface<"hub.packages", {
-    /** Add a `.agentorg` archive from a path on the Hub's machine; it is verified first. */
-    add: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        hash: z.ZodString;
-        manifest: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-    }, z.core.$strip>>;
-    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        packages: z.ZodArray<z.ZodObject<{
-            hash: z.ZodString;
-            name: z.ZodString;
-            version: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        hash: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        hash: z.ZodString;
-        manifest: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-    }, z.core.$strip>>;
-    /** Refused while an Actor runs the package. */
-    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        hash: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /**
-     * Build a package from its source, given as data (`package.json` and files under `src/`, up to
-     * 768 KiB), and add it as `add` does. It's `agentorg build`'s build, reading no tsconfig; its
-     * files import only `@agentorg/sdk`, `@agentorg/interfaces`, `zod`, `react`, `react-dom` and
-     * `@agentorg/kit` by name, and nothing outside the package's folder, never by a pattern. A build that fails is
-     * `Refused("build")` with the build's message, so the source can be fixed and built again.
-     */
-    build: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        files: z.ZodRecord<z.ZodString, z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        hash: z.ZodString;
-        manifest: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-    }, z.core.$strip>>;
-}, {}, 1>;
 export declare const ActorState: z.ZodEnum<{
     closed: "closed";
     created: "created";
@@ -64,43 +19,15 @@ export declare const Actor: z.ZodObject<{
         stopped: "stopped";
     }>;
     connected: z.ZodBoolean;
-    restarts: z.ZodNumber;
-    lastExit: z.ZodOptional<z.ZodObject<{
-        code: z.ZodNullable<z.ZodNumber>;
-        signal: z.ZodNullable<z.ZodString>;
-        at: z.ZodString;
-    }, z.core.$strip>>;
-    host: z.ZodOptional<z.ZodObject<{
-        available: z.ZodBoolean;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    views: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    installedFor: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-/** One line of an Actor's log, from its `ctx.log` or its process's own output. */
-export declare const LogLine: z.ZodObject<{
-    level: z.ZodEnum<{
-        error: "error";
-        info: "info";
-        warn: "warn";
-    }>;
-    message: z.ZodString;
-    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-    module: z.ZodOptional<z.ZodString>;
-    at: z.ZodString;
-}, z.core.$strip>;
-/** `hub.actors@1`: Actors and their lifecycle. */
+/** `hub.actors@1`: Actors: who may join the Hub. */
 export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors", {
     /**
-     * With a package, an Actor that runs it; without, an external one, whose credential is returned
-     * once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
-     * (the creation is the slot side's yes), for example to its own `hub.grants@1`. `for` names
-     * the Actor it is made for, recorded as `installedFor`; only a manager may give it.
+     * An Actor for a program that connects itself, with a credential returned once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
+     * (the creation is the slot side's yes), for example to its own `hub.grants@1`.
      */
     create: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         name: z.ZodString;
-        package: z.ZodOptional<z.ZodString>;
-        for: z.ZodOptional<z.ZodString>;
         bindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
             slot: z.ZodString;
             provider: z.ZodString;
@@ -108,7 +35,7 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         actorId: z.ZodString;
-        credential: z.ZodOptional<z.ZodString>;
+        credential: z.ZodString;
     }, z.core.$strip>>;
     list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
         actors: z.ZodArray<z.ZodObject<{
@@ -122,18 +49,6 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
                 stopped: "stopped";
             }>;
             connected: z.ZodBoolean;
-            restarts: z.ZodNumber;
-            lastExit: z.ZodOptional<z.ZodObject<{
-                code: z.ZodNullable<z.ZodNumber>;
-                signal: z.ZodNullable<z.ZodString>;
-                at: z.ZodString;
-            }, z.core.$strip>>;
-            host: z.ZodOptional<z.ZodObject<{
-                available: z.ZodBoolean;
-                reason: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            views: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            installedFor: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
@@ -149,69 +64,15 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
             stopped: "stopped";
         }>;
         connected: z.ZodBoolean;
-        restarts: z.ZodNumber;
-        lastExit: z.ZodOptional<z.ZodObject<{
-            code: z.ZodNullable<z.ZodNumber>;
-            signal: z.ZodNullable<z.ZodString>;
-            at: z.ZodString;
-        }, z.core.$strip>>;
-        host: z.ZodOptional<z.ZodObject<{
-            available: z.ZodBoolean;
-            reason: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        views: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        installedFor: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
-    start: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actorId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    stop: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actorId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
     /** Final: its bindings, both ways, are removed. */
     close: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         actorId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /**
-     * Run another package as the same package Actor: its id, its stores and every binding whose
-     * interfaces still match stay. A binding through a slot or export the new package drops, or
-     * declares as another interface, is dropped and listed in `dropped`; the new package's own
-     * wiring is made where its slot is unbound. A running Actor restarts on the new package.
-     * Only a manager may upgrade: the new package runs as the Actor and keeps what it was granted
-     * (its bindings and its store), which only a manager could grant anyway.
-     */
-    upgrade: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actorId: z.ZodString;
-        package: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        dropped: z.ZodArray<z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    /** Its newest log lines, oldest first. */
-    logs: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        actorId: z.ZodString;
-        limit: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        lines: z.ZodArray<z.ZodObject<{
-            level: z.ZodEnum<{
-                error: "error";
-                info: "info";
-                warn: "warn";
-            }>;
-            message: z.ZodString;
-            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-            module: z.ZodOptional<z.ZodString>;
-            at: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
 }, {
     /**
-     * An Actor's record may differ: it was made, started, stopped or closed, its process exited,
-     * or it connected or went (`connected`). Read it again with `get` or `list`.
+     * An Actor's record may differ: it was made or closed, or it connected or went (`connected`).
+     * Read it again with `get` or `list`.
      */
     changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{
         actor: z.ZodString;
@@ -229,41 +90,20 @@ export declare const Binding: z.ZodObject<{
     at: z.ZodString;
     exposed: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
-export declare const BindingRequest: z.ZodObject<{
-    consumer: z.ZodString;
-    slot: z.ZodString;
-    provider: z.ZodString;
-    export: z.ZodString;
-    requestId: z.ZodString;
-    needs: z.ZodEnum<{
-        export: "export";
-        slot: "slot";
-    }>;
-    reason: z.ZodString;
-    requestedBy: z.ZodString;
-    at: z.ZodString;
-    exposed: z.ZodOptional<z.ZodLiteral<true>>;
-}, z.core.$strip>;
 /**
  * `hub.grants@1`: binding with the caller's own authority, so it is safe to give any Actor. A
  * binding needs both ends: the export side (the provider, an Actor already bound to that export,
- * or a manager) and the slot side (the consumer itself, or a manager). With both, `bind` binds.
- * With one, it approves an open request from the other end, or becomes a request to that end's
- * approvers. With neither it is refused.
+ * or a manager) and the slot side (the consumer itself, or a manager). Without both it is refused.
  */
 export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants", {
-    /** A request made by `bind` has an empty reason; `request` gives one. */
     bind: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         consumer: z.ZodString;
         slot: z.ZodString;
         provider: z.ZodString;
         export: z.ZodString;
-    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
-        bound: z.ZodLiteral<true>;
     }, z.core.$strip>, z.ZodObject<{
-        bound: z.ZodLiteral<false>;
-        requestId: z.ZodString;
-    }, z.core.$strip>]>>;
+        bound: z.ZodLiteral<true>;
+    }, z.core.$strip>>;
     /** The consumer, the provider or a manager may unbind. */
     unbind: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         consumer: z.ZodString;
@@ -272,135 +112,27 @@ export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants
     /**
      * Expose an `rpc` export to one Actor: a slot made on `to`, typed by the export's interface,
      * named `as` (by default the provider's name camelCased, `_`, and the export's last part, made
-     * unique on `to`), and bound to the export, in one step. Its authority is a binding's: with
-     * both ends it is made; with one, it is a request to the other end's approvers, who approve it
-     * by calling `expose` with the request's fields. The same export already exposed to `to`
-     * gives that slot back.
+     * unique on `to`), and bound to the export, in one step. Its authority is a binding's. The same export already
+     * exposed to `to` gives that slot back.
      */
     expose: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         provider: z.ZodString;
         export: z.ZodString;
         to: z.ZodString;
         as: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
-        exposed: z.ZodLiteral<true>;
-        slot: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
-        exposed: z.ZodLiteral<false>;
+        exposed: z.ZodLiteral<true>;
         slot: z.ZodString;
-        requestId: z.ZodString;
-    }, z.core.$strip>]>>;
+    }, z.core.$strip>>;
     /** Remove a slot made by `expose`, with its binding: as `unbind`, the consumer, the provider or a manager may. */
     unexpose: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         to: z.ZodString;
         slot: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    request: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        consumer: z.ZodString;
-        slot: z.ZodString;
-        provider: z.ZodString;
-        export: z.ZodString;
-        reason: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        requestId: z.ZodString;
-    }, z.core.$strip>>;
-    /** The open requests the caller could approve. */
-    requests: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        requests: z.ZodArray<z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-            requestId: z.ZodString;
-            needs: z.ZodEnum<{
-                export: "export";
-                slot: "slot";
-            }>;
-            reason: z.ZodString;
-            requestedBy: z.ZodString;
-            at: z.ZodString;
-            exposed: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    decline: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        requestId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /**
-     * The caller's own requests and how each stands, newest first: how a requester that missed
-     * `decided` learns the outcome.
-     */
-    mine: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
-        limit: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        requests: z.ZodArray<z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-            requestId: z.ZodString;
-            needs: z.ZodEnum<{
-                export: "export";
-                slot: "slot";
-            }>;
-            reason: z.ZodString;
-            requestedBy: z.ZodString;
-            at: z.ZodString;
-            exposed: z.ZodOptional<z.ZodLiteral<true>>;
-            status: z.ZodEnum<{
-                approved: "approved";
-                closed: "closed";
-                declined: "declined";
-                open: "open";
-            }>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, {
-    /** A request the subscriber could approve. */
-    requested: import("@agentorg/sdk").EventSpec<z.ZodObject<{
-        consumer: z.ZodString;
-        slot: z.ZodString;
-        provider: z.ZodString;
-        export: z.ZodString;
-        requestId: z.ZodString;
-        needs: z.ZodEnum<{
-            export: "export";
-            slot: "slot";
-        }>;
-        reason: z.ZodString;
-        requestedBy: z.ZodString;
-        at: z.ZodString;
-        exposed: z.ZodOptional<z.ZodLiteral<true>>;
-    }, z.core.$strip>>;
-    /**
-     * A request the subscriber could approve, or made, was approved (its binding made), declined,
-     * or closed (its slot was bound to something else, or one end went away).
-     */
-    decided: import("@agentorg/sdk").EventSpec<z.ZodObject<{
-        request: z.ZodObject<{
-            consumer: z.ZodString;
-            slot: z.ZodString;
-            provider: z.ZodString;
-            export: z.ZodString;
-            requestId: z.ZodString;
-            needs: z.ZodEnum<{
-                export: "export";
-                slot: "slot";
-            }>;
-            reason: z.ZodString;
-            requestedBy: z.ZodString;
-            at: z.ZodString;
-            exposed: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strip>;
-        status: z.ZodEnum<{
-            approved: "approved";
-            closed: "closed";
-            declined: "declined";
-        }>;
-    }, z.core.$strip>>;
-}, 1>;
+}, {}, 1>;
 /**
  * `hub.bindings@1`: management scope. An Actor bound to it is a manager: it holds both ends of
- * every binding and is an approver of every request, acting through `hub.grants@1`, which it needs
+ * every binding, acting through `hub.grants@1`, which it needs
  * as well. Here, the manager-wide reads.
  */
 export declare const hubBindings: import("@agentorg/sdk").RpcInterface<"hub.bindings", {
@@ -424,7 +156,6 @@ export declare const ExportEntry: z.ZodObject<{
     export: z.ZodString;
     interface: z.ZodString;
     hash: z.ZodString;
-    dynamic: z.ZodBoolean;
 }, z.core.$strip>;
 /** `hub.exports@1`: what each Actor offers right now. */
 export declare const hubExports: import("@agentorg/sdk").RpcInterface<"hub.exports", {
@@ -436,7 +167,6 @@ export declare const hubExports: import("@agentorg/sdk").RpcInterface<"hub.expor
             export: z.ZodString;
             interface: z.ZodString;
             hash: z.ZodString;
-            dynamic: z.ZodBoolean;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, {