@agentorg/cli 0.0.4 → 0.0.6

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

@@ -1,12 +1,10 @@
 export { Account, accountLogin, LoginState } from "./account-login.js";
+export { AgentStatus, Answers, agentProvider, Creatable, CreatableId, } from "./agent-provider.js";
+export { agentSettings, SKILL_FILE_MAX, SkillEntry, SkillName, SkillPath, } from "./agent-settings.js";
 export { ChatMessage, ChatState, ChatStatus, ChatTool, chat } from "./chat.js";
-export { httpEgress } from "./http-egress.js";
-export { Actor, ActorState, AuditEntry, Binding, BindingRequest, ExportEntry, hubActors, hubAudit, hubBindings, hubExports, hubGrants, hubPackages, LogLine, Package, } from "./hub.js";
-export { Composition, installer } from "./installer.js";
+export { Actor, ActorState, AuditEntry, Binding, ExportEntry, hubActors, hubAudit, hubBindings, hubExports, hubGrants, } from "./hub.js";
 export { kv } from "./kv.js";
-export { layout, Placement } from "./layout.js";
 export { Item, llmSession, OutputItem, Tool } from "./llm-session.js";
-export { appRules, Rule } from "./rules.js";
-export { storageAdmin } from "./storage-admin.js";
-export { uiShell } from "./ui-shell.js";
-export { uiView } from "./ui-view.js";
+export { agents, ConnectionOrigin, connections, skills } from "./manager.js";
+export { ConnectionKind, ConnectionParams, ConnectionSecrets, ConnectionState, ConnectionStatus, ConnectionTarget, ConnectionTool, mcpProvider, } from "./mcp-provider.js";
+export { ToolEntry, tools } from "./tools.js";

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 /**
- * `kv@1`: a key-value store of JSON values, the state slot a host module uses. A storage provider
- * keeps one store per consumer slot, so the store is the slot's own; `list` pages through its keys.
+ * `kv@1`: a key-value store of JSON values, the shape of the engine's and the app's local stores;
+ * `list` pages through its keys.
  */
 export declare const kv: import("@agentorg/sdk").RpcInterface<"kv", {
     /** The value under `key`; `value` is absent when there is none, and a stored `null` is `null`. */

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

@@ -2,8 +2,8 @@ import { defineInterface, method } from "@agentorg/sdk";
 import { z } from "zod";
 const Key = z.string().min(1).max(1024);
 /**
- * `kv@1`: a key-value store of JSON values, the state slot a host module uses. A storage provider
- * keeps one store per consumer slot, so the store is the slot's own; `list` pages through its keys.
+ * `kv@1`: a key-value store of JSON values, the shape of the engine's and the app's local stores;
+ * `list` pages through its keys.
  */
 export const kv = defineInterface({
     name: "kv",

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

@@ -0,0 +1,272 @@
+import { z } from "zod";
+/** Where a connection came from, written once when it was made. */
+export declare const ConnectionOrigin: z.ZodObject<{
+    provider: z.ZodString;
+    kind: z.ZodString;
+    target: z.ZodString;
+    madeBy: z.ZodString;
+    madeFor: z.ZodOptional<z.ZodString>;
+    at: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `agents@1`: the agents the person has, each made from a creatable a connected agent provider
+ * offers. What each agent is doing is read from the agent's own `chat@1`.
+ */
+export declare const agents: import("@agentorg/sdk").RpcInterface<"agents", {
+    /** What every connected agent provider offers. */
+    creatable: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        creatables: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            instructions: z.ZodString;
+            asks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                optional: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strip>>;
+            skills: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                files: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            mcp: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                how: z.ZodLiteral<"pick">;
+                slot: z.ZodString;
+                title: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                how: z.ZodLiteral<"create">;
+                slot: z.ZodString;
+                title: z.ZodString;
+                kind: z.ZodString;
+                params: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                fromAnswers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>], "how">>;
+            provider: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /** The agent providers connected now. */
+    providers: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        providers: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /**
+     * Make an agent of a creatable, with what it asks and a connection for each of its `pick`
+     * needs, by slot. All or none: if any step fails, what this creation made is removed. A skill
+     * it comes with whose name is already here keeps the one here.
+     */
+    create: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        provider: z.ZodString;
+        creatable: z.ZodString;
+        name: z.ZodString;
+        answers: z.ZodRecord<z.ZodString, z.ZodString>;
+        connections: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>>;
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            agent: z.ZodString;
+            name: z.ZodString;
+            status: z.ZodObject<{
+                state: z.ZodEnum<{
+                    down: "down";
+                    running: "running";
+                    starting: "starting";
+                    stopped: "stopped";
+                }>;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            provider: z.ZodString;
+            creatable: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /** What the agent is made of, in one read. */
+    get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        agent: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodObject<{
+            state: z.ZodEnum<{
+                down: "down";
+                running: "running";
+                starting: "starting";
+                stopped: "stopped";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        provider: z.ZodString;
+        creatable: z.ZodString;
+        instructions: z.ZodString;
+        skills: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        mcp: z.ZodArray<z.ZodObject<{
+            slot: z.ZodString;
+            connection: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                kind: z.ZodString;
+                target: z.ZodString;
+                madeBy: z.ZodString;
+                madeFor: z.ZodOptional<z.ZodString>;
+                at: z.ZodString;
+            }, z.core.$strip>>;
+            status: 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>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    start: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /** Ends the agent's process, and a turn in progress with it; all else about it stays. */
+    stop: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /** Expose a skill or a connection to the agent; `as` names a connection's slot. */
+    expose: import("@agentorg/sdk").MethodSpec<z.ZodUnion<readonly [z.ZodObject<{
+        agent: z.ZodString;
+        skill: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        agent: z.ZodString;
+        connection: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>, z.ZodObject<{
+        slot: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    unexpose: import("@agentorg/sdk").MethodSpec<z.ZodUnion<readonly [z.ZodObject<{
+        agent: z.ZodString;
+        skill: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        agent: z.ZodString;
+        slot: z.ZodString;
+    }, z.core.$strict>]>, z.ZodObject<{}, z.core.$strip>>;
+    /** Final: removes the agent and the connections made for it. */
+    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, {}, 1>;
+/** `connections@1`: the person's connections to MCP servers, through the connected providers. */
+export declare const connections: import("@agentorg/sdk").RpcInterface<"connections", {
+    /** The MCP providers connected now, each with the kinds it offers. */
+    providers: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        providers: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            name: z.ZodString;
+            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>>;
+    }, z.core.$strip>>;
+    /** `secrets` go to the provider and nowhere else: they are never read back. */
+    create: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        provider: z.ZodString;
+        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;
+    }, z.core.$strip>>;
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        connections: z.ZodArray<z.ZodObject<{
+            connection: z.ZodString;
+            name: z.ZodString;
+            state: z.ZodEnum<{
+                connected: "connected";
+                connecting: "connecting";
+                down: "down";
+            }>;
+            origin: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                kind: z.ZodString;
+                target: z.ZodString;
+                madeBy: z.ZodString;
+                madeFor: z.ZodOptional<z.ZodString>;
+                at: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        connection: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        connection: z.ZodString;
+        name: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            kind: z.ZodString;
+            target: z.ZodString;
+            madeBy: z.ZodString;
+            madeFor: z.ZodOptional<z.ZodString>;
+            at: z.ZodString;
+        }, z.core.$strip>>;
+        status: 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>;
+    }, z.core.$strip>>;
+    /** Final: every exposure of it goes with it. */
+    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        connection: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, {}, 1>;
+/** `skills@1`: the person's skills, each a `SKILL.md` folder. */
+export declare const skills: import("@agentorg/sdk").RpcInterface<"skills", {
+    /**
+     * Add a skill from a folder on the Hub's machine or as files; its name and description come
+     * from `SKILL.md`. The same name replaces the skill, for every agent it's exposed to.
+     */
+    add: import("@agentorg/sdk").MethodSpec<z.ZodUnion<readonly [z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        files: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>]>, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        skills: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /** The skill: its `SKILL.md`, the paths of its files, and the agents it's exposed to. */
+    get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        text: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        agents: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    /** Final: it is taken off every agent it's exposed to. */
+    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, {}, 1>;

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

@@ -0,0 +1,185 @@
+import { defineInterface, method } from "@agentorg/sdk";
+import { z } from "zod";
+import { AgentStatus, Answers, Creatable, CreatableId } from "./agent-provider.js";
+import { SKILL_FILE_MAX, SkillEntry, SkillName, SkillPath } from "./agent-settings.js";
+import { Id, SlotName } from "./hub.js";
+import { ConnectionKind, ConnectionParams, ConnectionSecrets, ConnectionState, ConnectionStatus, ConnectionTarget, } from "./mcp-provider.js";
+const Time = z.string().max(64);
+const ActorName = z.string().min(1).max(128);
+const OnAgent = z.object({ agent: Id });
+const OnConnection = z.object({ connection: Id });
+const OnSkill = z.object({ name: SkillName });
+/** Where a connection came from, written once when it was made. */
+export const ConnectionOrigin = z.object({
+    provider: Id,
+    kind: ConnectionKind,
+    target: ConnectionTarget,
+    /** The Actor that asked for it. */
+    madeBy: Id,
+    /** The agent it was made for, which it goes with; none when the person connected it. */
+    madeFor: Id.optional(),
+    at: Time,
+});
+/** An agent as the list shows it: its status is its provider's. */
+const AgentEntry = z.object({
+    agent: Id,
+    name: ActorName,
+    status: AgentStatus,
+    provider: Id,
+    creatable: CreatableId,
+});
+/**
+ * `agents@1`: the agents the person has, each made from a creatable a connected agent provider
+ * offers. What each agent is doing is read from the agent's own `chat@1`.
+ */
+export const agents = defineInterface({
+    name: "agents",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        /** What every connected agent provider offers. */
+        creatable: method({
+            input: z.object({}),
+            output: z.object({ creatables: z.array(Creatable.extend({ provider: Id })) }),
+        }),
+        /** The agent providers connected now. */
+        providers: method({
+            input: z.object({}),
+            output: z.object({ providers: z.array(z.object({ provider: Id, name: ActorName })) }),
+        }),
+        /**
+         * Make an agent of a creatable, with what it asks and a connection for each of its `pick`
+         * needs, by slot. All or none: if any step fails, what this creation made is removed. A skill
+         * it comes with whose name is already here keeps the one here.
+         */
+        create: method({
+            input: z.object({
+                provider: Id,
+                creatable: CreatableId,
+                name: ActorName,
+                answers: Answers,
+                connections: z.record(SlotName, Id).optional(),
+            }),
+            output: OnAgent,
+        }),
+        list: method({ input: z.object({}), output: z.object({ agents: z.array(AgentEntry) }) }),
+        /** What the agent is made of, in one read. */
+        get: method({
+            input: OnAgent,
+            output: AgentEntry.extend({
+                instructions: z.string().max(200_000),
+                skills: z.array(SkillEntry),
+                mcp: z.array(z.object({
+                    slot: SlotName,
+                    connection: Id,
+                    origin: ConnectionOrigin.optional(),
+                    status: ConnectionStatus,
+                })),
+            }),
+        }),
+        start: method({ input: OnAgent, output: z.object({}) }),
+        /** Ends the agent's process, and a turn in progress with it; all else about it stays. */
+        stop: method({ input: OnAgent, output: z.object({}) }),
+        /** Expose a skill or a connection to the agent; `as` names a connection's slot. */
+        expose: method({
+            input: z.union([
+                z.strictObject({ agent: Id, skill: SkillName }),
+                z.strictObject({ agent: Id, connection: Id, as: SlotName.optional() }),
+            ]),
+            output: z.object({ slot: SlotName.optional() }),
+        }),
+        unexpose: method({
+            input: z.union([
+                z.strictObject({ agent: Id, skill: SkillName }),
+                z.strictObject({ agent: Id, slot: SlotName }),
+            ]),
+            output: z.object({}),
+        }),
+        /** Final: removes the agent and the connections made for it. */
+        remove: method({ input: OnAgent, output: z.object({}) }),
+    },
+});
+/** A connection as the list shows it. */
+const ConnectionEntry = z.object({
+    connection: Id,
+    name: ActorName,
+    state: ConnectionState,
+    origin: ConnectionOrigin.optional(),
+});
+/** `connections@1`: the person's connections to MCP servers, through the connected providers. */
+export const connections = defineInterface({
+    name: "connections",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        /** The MCP providers connected now, each with the kinds it offers. */
+        providers: method({
+            input: z.object({}),
+            output: z.object({
+                providers: z.array(z.object({
+                    provider: Id,
+                    name: ActorName,
+                    kinds: z.array(z.object({
+                        kind: ConnectionKind,
+                        title: z.string().min(1).max(128),
+                        params: z.record(z.string(), z.json()),
+                        secrets: z.record(z.string(), z.json()),
+                    })),
+                })),
+            }),
+        }),
+        /** `secrets` go to the provider and nowhere else: they are never read back. */
+        create: method({
+            input: z.object({
+                provider: Id,
+                kind: ConnectionKind,
+                params: ConnectionParams,
+                secrets: ConnectionSecrets.optional(),
+                name: ActorName,
+            }),
+            output: OnConnection,
+        }),
+        list: method({
+            input: z.object({}),
+            output: z.object({ connections: z.array(ConnectionEntry) }),
+        }),
+        get: method({
+            input: OnConnection,
+            output: ConnectionEntry.omit({ state: true }).extend({ status: ConnectionStatus }),
+        }),
+        /** Final: every exposure of it goes with it. */
+        remove: method({ input: OnConnection, output: z.object({}) }),
+    },
+});
+const SkillFiles = z.record(SkillPath, z.string().max(SKILL_FILE_MAX));
+/** `skills@1`: the person's skills, each a `SKILL.md` folder. */
+export const skills = defineInterface({
+    name: "skills",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        /**
+         * Add a skill from a folder on the Hub's machine or as files; its name and description come
+         * from `SKILL.md`. The same name replaces the skill, for every agent it's exposed to.
+         */
+        add: method({
+            input: z.union([
+                z.strictObject({ path: z.string().min(1).max(4096) }),
+                z.strictObject({ files: SkillFiles }),
+            ]),
+            output: SkillEntry,
+        }),
+        list: method({ input: z.object({}), output: z.object({ skills: z.array(SkillEntry) }) }),
+        /** The skill: its `SKILL.md`, the paths of its files, and the agents it's exposed to. */
+        get: method({
+            input: OnSkill,
+            output: SkillEntry.extend({
+                text: z.string().max(SKILL_FILE_MAX),
+                files: z.array(SkillPath),
+                agents: z.array(Id),
+            }),
+        }),
+        /** Final: it is taken off every agent it's exposed to. */
+        remove: method({ input: OnSkill, output: z.object({}) }),
+    },
+});

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

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

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

@@ -0,0 +1,78 @@
+import { defineInterface, method } from "@agentorg/sdk";
+import { z } from "zod";
+import { Id } from "./hub.js";
+/** 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);
+/**
+ * `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 const mcpProvider = defineInterface({
+    name: "mcp.provider",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        /** The kinds it offers; `params` and `secrets` are the JSON Schemas of what each one takes. */
+        kinds: method({
+            input: z.object({}),
+            output: z.object({
+                kinds: z.array(z.object({
+                    kind: ConnectionKind,
+                    title: z.string().min(1).max(128),
+                    params: z.record(z.string(), z.json()),
+                    secrets: z.record(z.string(), z.json()),
+                })),
+            }),
+        }),
+        /**
+         * 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: method({
+            input: z.object({
+                kind: ConnectionKind,
+                params: ConnectionParams,
+                secrets: ConnectionSecrets.optional(),
+                name: z.string().min(1).max(128),
+            }),
+            output: z.object({ connection: Id, target: ConnectionTarget }),
+        }),
+        status: method({ input: z.object({ connection: Id }), output: ConnectionStatus }),
+        /** End the connection and close its Actor, which removes what was bound to it. */
+        remove: method({ input: z.object({ connection: Id }), output: z.object({}) }),
+    },
+});