@agentorg/cli 0.0.5 → 0.0.6

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({}) }),
+    },
+});

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+/** One tool: `inputSchema` is the JSON Schema of its arguments, as its server states it. */
+export declare const ToolEntry: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strip>;
+/**
+ * `tools@1`: a set of tools whose names and arguments are known only at run time. It is one fixed
+ * contract however the tools change, so a binding to it holds while they do: the Hub checks a
+ * call's envelope, and whoever runs the tool checks its arguments.
+ *
+ * A call is refused `unknown` when no tool has that name and `not_connected` when what runs the
+ * tools can't be reached now. A tool that ran and failed isn't a refusal: it answers with
+ * `failed`, and its `output` says why, for the caller's model to read.
+ *
+ * A provider fits what it has to these limits: it leaves out a tool whose name is too long or that
+ * won't fit one frame, cuts a long description, and cuts an output, saying that it did.
+ */
+export declare const tools: import("@agentorg/sdk").RpcInterface<"tools", {
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /** Run one tool. `output` is its result as text. */
+    call: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strip>, z.ZodObject<{
+        output: z.ZodString;
+        failed: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>>;
+}, {
+    /** The tools changed: `list` again. */
+    changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{}, z.core.$strip>>;
+}, 1>;

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

@@ -0,0 +1,43 @@
+import { defineInterface, event, method } from "@agentorg/sdk";
+import { z } from "zod";
+const ToolName = z.string().min(1).max(128);
+/** The most a call's output carries: what a model's function output can take. */
+const OUTPUT_MAX = 200_000;
+/** One tool: `inputSchema` is the JSON Schema of its arguments, as its server states it. */
+export const ToolEntry = z.object({
+    name: ToolName,
+    description: z.string().max(16_384).optional(),
+    inputSchema: z.record(z.string(), z.json()),
+});
+/**
+ * `tools@1`: a set of tools whose names and arguments are known only at run time. It is one fixed
+ * contract however the tools change, so a binding to it holds while they do: the Hub checks a
+ * call's envelope, and whoever runs the tool checks its arguments.
+ *
+ * A call is refused `unknown` when no tool has that name and `not_connected` when what runs the
+ * tools can't be reached now. A tool that ran and failed isn't a refusal: it answers with
+ * `failed`, and its `output` says why, for the caller's model to read.
+ *
+ * A provider fits what it has to these limits: it leaves out a tool whose name is too long or that
+ * won't fit one frame, cuts a long description, and cuts an output, saying that it did.
+ */
+export const tools = defineInterface({
+    name: "tools",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        list: method({ input: z.object({}), output: z.object({ tools: z.array(ToolEntry) }) }),
+        /** Run one tool. `output` is its result as text. */
+        call: method({
+            input: z.object({ name: ToolName, arguments: z.record(z.string(), z.json()) }),
+            output: z.object({
+                output: z.string().max(OUTPUT_MAX),
+                failed: z.literal(true).optional(),
+            }),
+        }),
+    },
+    events: {
+        /** The tools changed: `list` again. */
+        changed: event(z.object({})),
+    },
+});

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

@@ -0,0 +1 @@
+export { type Manager, type ManagerOptions, startManager } from "./manager.js";

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

@@ -0,0 +1 @@
+export { startManager } from "./manager.js";

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

@@ -0,0 +1,21 @@
+import { type Log } from "@agentorg/sdk";
+export interface ManagerOptions {
+    hubUrl: string;
+    /** Its own Actor, bound to `hub.actors@1`, `hub.grants@1` and `hub.bindings@1`, which make it a manager. */
+    actorId: string;
+    credential: string;
+    /** A private folder of its own, which holds its records and the skills. */
+    dir: string;
+    log?: Log;
+}
+export interface Manager {
+    /** Leave the Hub. What it keeps stays. */
+    close(): Promise<void>;
+}
+/**
+ * Run management as an Actor exporting `agents@1`, `connections@1`, `skills@1` and, as `settings`,
+ * `agent.settings@1`. It keeps only what the Hub can't know. A provider is connected by exposing
+ * its export to this Actor: the Hub's slots are the list of them, and what is exposed to an agent
+ * is the Hub's bindings. No status is stored, and no secret reaches it to keep.
+ */
+export declare function startManager(options: ManagerOptions): Promise<Manager>;