@agentorg/cli 0.0.5 → 0.0.6

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

@@ -1,12 +1,10 @@
 import type { DescribedInterface } from "@agentorg/sdk";
-/** A part of an interface with its own schema: a method's input or output, an event, or `open`. */
+/** A part of an interface with its own schema: a method's input or output, or an event. */
 export type Part = {
     method: string;
     side: "input" | "output";
 } | {
     event: string;
-} | {
-    open: true;
 };
 /** How long checking one value may take, once compiled, before it is refused and its worker replaced. */
 export declare const CHECK_BUDGET_MS = 250;

package/dist/node_modules/@agentorg/hub/dist/src/validate.js

@@ -1,28 +1,16 @@
 import { availableParallelism } from "node:os";
 import { Worker } from "node:worker_threads";
 import { Refused } from "@agentorg/sdk";
-const describe = (part) => "method" in part
-    ? `${part.method} ${part.side}`
-    : "event" in part
-        ? `${part.event} event`
-        : "open";
+const describe = (part) => "method" in part ? `${part.method} ${part.side}` : `${part.event} event`;
 function schemaOf(iface, part) {
     if ("method" in part)
-        return iface.kind === "rpc" && Object.hasOwn(iface.methods, part.method)
+        return Object.hasOwn(iface.methods, part.method)
             ? iface.methods[part.method]?.[part.side]
             : undefined;
-    if ("event" in part)
-        return iface.kind === "rpc" && Object.hasOwn(iface.events, part.event)
-            ? iface.events[part.event]
-            : undefined;
-    return iface.kind === "stream" ? iface.open : undefined;
+    return Object.hasOwn(iface.events, part.event) ? iface.events[part.event] : undefined;
 }
 const keyOf = (iface, part) => `${iface.hash} ${describe(part)}`;
 function partsOf(iface) {
-    if (iface.kind === "stream")
-        return [{ open: true }];
-    if (iface.kind !== "rpc")
-        return [];
     return [
         ...Object.keys(iface.methods).flatMap((method) => [
             { method, side: "input" },

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

@@ -23,12 +23,9 @@
   },
   "dependencies": {
     "@agentorg/interfaces": "0.0.0",
-    "@agentorg/kit": "0.0.0",
     "@agentorg/sdk": "0.0.0",
     "@agentorg/wire": "0.0.0",
     "ajv": "^8.20.0",
-    "react": "^19.3.1",
-    "react-dom": "^19.3.1",
     "ws": "^8.22.1",
     "zod": "^4.6.7"
   },

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

@@ -0,0 +1,132 @@
+import { z } from "zod";
+/** A creatable's id, unique within its provider. */
+export declare const CreatableId: z.ZodString;
+/** What the person gives at creation, by the id of each ask. Never a secret. */
+export declare const Answers: z.ZodRecord<z.ZodString, z.ZodString>;
+/**
+ * A predefined set an agent is made from. Its skills are listed by name and files, `SKILL.md` among
+ * them; `skill` reads each file.
+ */
+export declare const Creatable: 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">>;
+}, z.core.$strip>;
+/**
+ * How an agent stands now, as what runs it knows: `starting`, `running`, `stopped` by the person,
+ * or `down`, which it didn't ask for. `detail` says why it is down.
+ */
+export declare const AgentStatus: z.ZodObject<{
+    state: z.ZodEnum<{
+        down: "down";
+        running: "running";
+        starting: "starting";
+        stopped: "stopped";
+    }>;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * `agent.provider@1`: a program that makes agents: an execution system and its way of running one.
+ * It says what it can create, and makes, starts, stops and removes the agents it made; each is an
+ * Actor. `status`, `start`, `stop` and `remove` are refused `unknown` for an agent it didn't make.
+ */
+export declare const agentProvider: import("@agentorg/sdk").RpcInterface<"agent.provider", {
+    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">>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /** A file of a skill a creatable comes with. Refused `unknown` when there is no such file. */
+    skill: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        creatable: z.ZodString;
+        name: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    /**
+     * Make and start an agent of a creatable, named `name`. `settings` is the agent's slot typed
+     * `agent.settings@1`, for whoever serves it to bind, and `chat` its export typed `chat@1`.
+     * Refused `unknown` for a creatable it doesn't offer, and `invalid` when an ask with no
+     * `optional` has no answer.
+     */
+    create: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        creatable: z.ZodString;
+        name: z.ZodString;
+        answers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        agent: z.ZodString;
+        settings: z.ZodString;
+        chat: z.ZodString;
+    }, z.core.$strip>>;
+    status: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodEnum<{
+            down: "down";
+            running: "running";
+            starting: "starting";
+            stopped: "stopped";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    start: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /** It ends the agent's process; its record, bindings and connections stay. */
+    stop: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /** Final: the agent's Actor is closed. */
+    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, {}, 1>;

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

@@ -0,0 +1,105 @@
+import { defineInterface, method } from "@agentorg/sdk";
+import { z } from "zod";
+import { SKILL_FILE_MAX, SkillName, SkillPath } from "./agent-settings.js";
+import { Id, Name, SlotName } from "./hub.js";
+import { ConnectionKind, ConnectionParams } from "./mcp-provider.js";
+const Title = z.string().min(1).max(128);
+const Description = z.string().max(2000);
+/** A creatable's id, unique within its provider. */
+export const CreatableId = z
+    .string()
+    .regex(/^[a-z][a-z0-9-]*$/)
+    .max(64);
+const AskId = z
+    .string()
+    .regex(/^[a-z][A-Za-z0-9_]*$/)
+    .max(64);
+/** What the person gives at creation, by the id of each ask. Never a secret. */
+export const Answers = z.record(AskId, z.string().max(4096));
+/** One thing a creatable asks the person when an agent is made from it. */
+const Ask = z.object({
+    id: AskId,
+    title: Title,
+    description: Description.optional(),
+    optional: z.literal(true).optional(),
+});
+/**
+ * An MCP connection an agent of this creatable needs, exposed to it as `slot`. With `pick`, the
+ * person picks one they have. With `create`, one is made for the agent through a connected provider
+ * offering `kind`, with `params`, each top-level parameter in `fromAnswers` set to the answer it
+ * names.
+ */
+const McpNeed = z.discriminatedUnion("how", [
+    z.object({ how: z.literal("pick"), slot: SlotName, title: Title }),
+    z.object({
+        how: z.literal("create"),
+        slot: SlotName,
+        title: Title,
+        kind: ConnectionKind,
+        params: ConnectionParams,
+        fromAnswers: z.record(z.string(), AskId).optional(),
+    }),
+]);
+/**
+ * A predefined set an agent is made from. Its skills are listed by name and files, `SKILL.md` among
+ * them; `skill` reads each file.
+ */
+export const Creatable = z.object({
+    id: CreatableId,
+    title: Title,
+    description: Description,
+    instructions: z.string().max(200_000),
+    asks: z.array(Ask).max(32),
+    skills: z.array(z.object({ name: SkillName, files: z.array(SkillPath).min(1).max(256) })).max(64),
+    mcp: z.array(McpNeed).max(32),
+});
+const OnAgent = z.object({ agent: Id });
+/**
+ * How an agent stands now, as what runs it knows: `starting`, `running`, `stopped` by the person,
+ * or `down`, which it didn't ask for. `detail` says why it is down.
+ */
+export const AgentStatus = z.object({
+    state: z.enum(["starting", "running", "stopped", "down"]),
+    detail: z.string().max(2000).optional(),
+});
+/**
+ * `agent.provider@1`: a program that makes agents: an execution system and its way of running one.
+ * It says what it can create, and makes, starts, stops and removes the agents it made; each is an
+ * Actor. `status`, `start`, `stop` and `remove` are refused `unknown` for an agent it didn't make.
+ */
+export const agentProvider = defineInterface({
+    name: "agent.provider",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        creatable: method({
+            input: z.object({}),
+            output: z.object({ creatables: z.array(Creatable) }),
+        }),
+        /** A file of a skill a creatable comes with. Refused `unknown` when there is no such file. */
+        skill: method({
+            input: z.object({ creatable: CreatableId, name: SkillName, path: SkillPath }),
+            output: z.object({ text: z.string().max(SKILL_FILE_MAX) }),
+        }),
+        /**
+         * Make and start an agent of a creatable, named `name`. `settings` is the agent's slot typed
+         * `agent.settings@1`, for whoever serves it to bind, and `chat` its export typed `chat@1`.
+         * Refused `unknown` for a creatable it doesn't offer, and `invalid` when an ask with no
+         * `optional` has no answer.
+         */
+        create: method({
+            input: z.object({
+                creatable: CreatableId,
+                name: Title,
+                answers: Answers,
+            }),
+            output: z.object({ agent: Id, settings: Name, chat: Name }),
+        }),
+        status: method({ input: OnAgent, output: AgentStatus }),
+        start: method({ input: OnAgent, output: z.object({}) }),
+        /** It ends the agent's process; its record, bindings and connections stay. */
+        stop: method({ input: OnAgent, output: z.object({}) }),
+        /** Final: the agent's Actor is closed. */
+        remove: method({ input: OnAgent, output: z.object({}) }),
+    },
+});

package/dist/node_modules/@agentorg/interfaces/dist/src/agent-settings.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+/** A skill's name, as the Agent Skills convention writes it. */
+export declare const SkillName: z.ZodString;
+/**
+ * A file of a skill: a relative path inside its folder, of plain segments, never `.` or `..`, with
+ * no backslash or control character.
+ */
+export declare const SkillPath: z.ZodString;
+/** The most one file of a skill holds, as text. */
+export declare const SKILL_FILE_MAX: number;
+/** What a list says of a skill, from its `SKILL.md` front matter. */
+export declare const SkillEntry: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `agent.settings@1`: what an agent is run with, read by the program that runs it. Each caller is
+ * answered with its own: the instructions it was given and the skills exposed to it, so an agent
+ * sees nothing of another's. It is read at each model request.
+ */
+export declare const agentSettings: import("@agentorg/sdk").RpcInterface<"agent.settings", {
+    get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        instructions: z.ZodString;
+        skills: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /**
+     * A file of a skill exposed to the caller, `SKILL.md` if no `path`. Refused `unknown` when the
+     * skill isn't exposed to it or has no such file.
+     */
+    skill: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, {
+    /** The caller's instructions or skills changed: read them again at the next request. */
+    changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{}, z.core.$strip>>;
+}, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/agent-settings.js

@@ -0,0 +1,53 @@
+import { defineInterface, event, method } from "@agentorg/sdk";
+import { z } from "zod";
+/** A skill's name, as the Agent Skills convention writes it. */
+export const SkillName = z
+    .string()
+    .regex(/^[a-z0-9]+(-[a-z0-9]+)*$/)
+    .max(64);
+/**
+ * A file of a skill: a relative path inside its folder, of plain segments, never `.` or `..`, with
+ * no backslash or control character.
+ */
+export const SkillPath = z
+    .string()
+    .regex(/^(?!\.\.?(\/|$))(?!.*\/\.\.?(\/|$))([^/\\\p{Cc}\p{Zl}\p{Zp}]+\/)*[^/\\\p{Cc}\p{Zl}\p{Zp}]+$/u)
+    .max(1024);
+/** The most one file of a skill holds, as text. */
+export const SKILL_FILE_MAX = 256 * 1024;
+/** What a list says of a skill, from its `SKILL.md` front matter. */
+export const SkillEntry = z.object({
+    name: SkillName,
+    description: z.string().max(1024),
+});
+/**
+ * `agent.settings@1`: what an agent is run with, read by the program that runs it. Each caller is
+ * answered with its own: the instructions it was given and the skills exposed to it, so an agent
+ * sees nothing of another's. It is read at each model request.
+ */
+export const agentSettings = defineInterface({
+    name: "agent.settings",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        get: method({
+            input: z.object({}),
+            output: z.object({
+                instructions: z.string().max(200_000),
+                skills: z.array(SkillEntry),
+            }),
+        }),
+        /**
+         * A file of a skill exposed to the caller, `SKILL.md` if no `path`. Refused `unknown` when the
+         * skill isn't exposed to it or has no such file.
+         */
+        skill: method({
+            input: z.object({ name: SkillName, path: SkillPath.optional() }),
+            output: z.object({ text: z.string().max(SKILL_FILE_MAX) }),
+        }),
+    },
+    events: {
+        /** The caller's instructions or skills changed: read them again at the next request. */
+        changed: event(z.object({})),
+    },
+});

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

@@ -125,6 +125,21 @@ export declare const chat: import("@agentorg/sdk").RpcInterface<"chat", {
     retry: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
         messageId: z.ZodString;
     }, z.core.$strip>>;
+    /** The models this agent can use, and the one chosen; none chosen means the provider's default. */
+    models: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+        current: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    /**
+     * Choose the model for this agent's next requests, kept with the agent; with no `model`, go
+     * back to the provider's default. Refused `unknown` when the model isn't one of `models`.
+     */
+    setModel: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
 }, {
     message: import("@agentorg/sdk").EventSpec<z.ZodObject<{
         id: z.ZodString;

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

@@ -1,6 +1,7 @@
 import { defineInterface, event, method } from "@agentorg/sdk";
 import { z } from "zod";
 const MessageId = z.string().min(1).max(128);
+const ChatModelId = z.string().min(1).max(128);
 /**
  * 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
@@ -69,6 +70,19 @@ export const chat = defineInterface({
          * message has been sent.
          */
         retry: method({ input: z.object({}), output: z.object({ messageId: MessageId }) }),
+        /** The models this agent can use, and the one chosen; none chosen means the provider's default. */
+        models: method({
+            input: z.object({}),
+            output: z.object({
+                models: z.array(z.object({ id: ChatModelId, name: z.string().max(256) })),
+                current: ChatModelId.optional(),
+            }),
+        }),
+        /**
+         * Choose the model for this agent's next requests, kept with the agent; with no `model`, go
+         * back to the provider's default. Refused `unknown` when the model isn't one of `models`.
+         */
+        setModel: method({ input: z.object({ model: ChatModelId.optional() }), output: z.object({}) }),
     },
     events: {
         message: event(ChatMessage),