@agentorg/cli 0.0.6 → 0.0.8

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

@@ -1,78 +0,0 @@
-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/assistant/dist/src/agent.d.ts

@@ -1,62 +0,0 @@
-/**
- * The agent loop: a turn sends the conversation and the tools to the model, runs each function the
- * model calls through its slot, and sends the results back, until the model answers without
- * calling anything, or the turn has made its 20 calls.
- */
-import type { ChatMessage, llmSession } from "@agentorg/interfaces";
-import { type Log, type Slot } from "@agentorg/sdk";
-import type { z } from "zod";
-import { type History } from "./history.js";
-import { type Tools } from "./tools.js";
-export declare const MAX_CALLS = 20;
-type Status = {
-    state: "idle" | "thinking" | "tool";
-} | {
-    state: "error";
-    detail: {
-        code: string;
-        message: string;
-    };
-};
-export interface Chat {
-    message(message: z.input<typeof ChatMessage>): void;
-    delta(id: string, text: string): void;
-    status(status: Status): void;
-}
-export declare function createAgent(options: {
-    /** Read for each model request: what it's told and what it can call follow what it's bound to. */
-    request(): Promise<{
-        instructions: string;
-        tools: Tools;
-    }>;
-    model: Slot<typeof llmSession>;
-    /** The model chosen for this agent, read for each request; none means the provider's default. */
-    chosenModel(): Promise<string | undefined>;
-    history: History;
-    chat: Chat;
-    log: Log;
-}): {
-    /** Start a turn with the person's message; its progress arrives as events. */
-    send(text: string): Promise<{
-        messageId: string;
-    }>;
-    /**
-     * Run the last turn again, without recording the person's message again. What followed it goes
-     * from the record, so the new reply takes its place; what its tools did stays done.
-     */
-    retry(): Promise<{
-        messageId: string;
-    }>;
-    /** The status now. */
-    state: () => Status;
-    /**
-     * Stop the turn now: its model request is cancelled, no further call starts, and a new turn
-     * may begin at once. A call already running finishes, and its result is kept.
-     */
-    cancel(): Promise<void>;
-    /** Settles when the latest turn has written all it will. */
-    settled: () => Promise<void>;
-    /** Streamed text of the model request running now, for the reply it becomes. */
-    delta(requestId: string, text: string): void;
-};
-export {};

package/dist/node_modules/assistant/dist/src/agent.js

@@ -1,226 +0,0 @@
-import { Refused } from "@agentorg/sdk";
-import { argumentsOf, head, messageOf } from "./history.js";
-import { capped, codeOf, runTool } from "./tools.js";
-export const MAX_CALLS = 20;
-export function createAgent(options) {
-    const { model, history, chat, log } = options;
-    let turn;
-    /** A cancelled turn whose running call hasn't settled: the next turn waits for its records. */
-    let draining;
-    /** Settles when the latest turn's loop has ended. */
-    let ending;
-    /** The latest status, for a view that asks. */
-    let latest = { state: "idle" };
-    const say = (next) => {
-        latest = next;
-        chat.status(next);
-    };
-    /** A turn's status, while it is still the turn: a cancelled one has already said idle. */
-    const status = (current, next) => {
-        if (turn === current)
-            say(next);
-    };
-    /** Run a turn on the record as it stands; its progress arrives as events. */
-    const begin = (current) => {
-        current.ended = run(current)
-            .then(() => status(current, { state: "idle" }), (error) => {
-            if (current.cancelled)
-                return;
-            log.error("A turn failed.", { error: String(error) });
-            status(current, { state: "error", detail: codeOf(error) });
-        })
-            .finally(() => {
-            if (turn === current)
-                turn = undefined;
-        })
-            .catch((error) => log.error("A turn's status failed.", { error: String(error) }));
-        ending = current.ended;
-    };
-    const show = (entry) => chat.message(messageOf(entry));
-    /** A call starting: shown as running, under the id its record will have when it ends. */
-    const running = (call, id) => chat.message({
-        id,
-        role: "tool",
-        text: `${call.name}: running`,
-        at: new Date().toISOString(),
-        tool: { name: head(call.name, 128), state: "running", input: argumentsOf(call.arguments) },
-    });
-    /**
-     * Record a function call with its output, keeping every call paired, as the API needs. Its end
-     * is shown even if the record can't be written, so no call is left shown as running.
-     */
-    const answered = async (call, result, id) => {
-        const entry = {
-            role: "tool",
-            text: `${call.name}: ${result.ok ? "done" : result.code}`,
-            state: result.ok ? "done" : "refused",
-            items: [
-                call,
-                {
-                    type: "function_call_output",
-                    callId: call.callId,
-                    output: capped(result.output),
-                },
-            ],
-        };
-        try {
-            show(await history.append(entry, id));
-        }
-        catch (error) {
-            chat.message(messageOf({
-                ...entry,
-                id,
-                at: new Date().toISOString(),
-                items: [{ ...call, arguments: argumentsOf(call.arguments) }, ...entry.items.slice(1)],
-            }));
-            throw error;
-        }
-    };
-    /**
-     * Note calls that won't run, in one message however many there are. They never ran, so the
-     * record leaves them out: what the model is sent next holds only calls with their outputs.
-     */
-    const skipped = async (calls, code) => {
-        if (calls.length === 0)
-            return;
-        const text = calls.length === 1 ? `${calls[0]?.name}: ${code}` : `${calls.length} calls: ${code}`;
-        show(await history.append({ role: "tool", text, items: [] }));
-    };
-    async function run(current) {
-        let calls = 0;
-        for (;;) {
-            status(current, { state: "thinking" });
-            const { instructions, tools } = await options.request();
-            const input = await history.input();
-            const chosen = await options.chosenModel();
-            if (current.cancelled)
-                return;
-            const requestId = crypto.randomUUID();
-            const replyId = crypto.randomUUID();
-            current.requestId = requestId;
-            current.replyId = replyId;
-            let output;
-            try {
-                ({ output } = await model.call.respond({
-                    requestId,
-                    ...(chosen ? { model: chosen } : {}),
-                    instructions,
-                    input,
-                    tools: [...tools.values()].map((found) => found.tool),
-                }));
-            }
-            finally {
-                current.requestId = undefined;
-            }
-            if (current.cancelled)
-                return;
-            const texts = output.flatMap((item) => (item.type === "message" ? [item.content] : []));
-            const called = output.filter((item) => item.type === "function_call");
-            if (texts.length > 0 || called.length === 0)
-                show(await history.append({
-                    role: "assistant",
-                    items: texts.map((content) => ({ type: "message", role: "assistant", content })),
-                }, replyId));
-            if (called.length === 0)
-                return;
-            for (const [i, call] of called.entries()) {
-                if (current.cancelled || calls >= MAX_CALLS) {
-                    const rest = called.slice(i);
-                    await skipped(rest, current.cancelled ? "cancelled" : "limit");
-                    break;
-                }
-                calls++;
-                status(current, { state: "tool" });
-                // A call that has started runs to its end, and its real result is kept: it may have
-                // taken effect.
-                const id = crypto.randomUUID();
-                running(call, id);
-                const result = await runTool(tools, call.name, call.arguments);
-                await answered(call, result, id);
-            }
-            if (current.cancelled)
-                return;
-            if (calls >= MAX_CALLS)
-                throw new Refused("limit", `This turn stopped after ${MAX_CALLS} tool calls.`);
-        }
-    }
-    return {
-        /** Start a turn with the person's message; its progress arrives as events. */
-        async send(text) {
-            if (turn)
-                throw new Refused("busy", "A turn is running. Wait for it, or cancel it.");
-            const current = { cancelled: false };
-            turn = current;
-            try {
-                // A cancelled turn's last call lands in the record before this message does.
-                await draining;
-                draining = undefined;
-                const entry = await history.append({
-                    role: "user",
-                    items: [{ type: "message", role: "user", content: text }],
-                });
-                show(entry);
-                begin(current);
-                return { messageId: entry.id };
-            }
-            catch (error) {
-                if (turn === current)
-                    turn = undefined;
-                throw error;
-            }
-        },
-        /**
-         * Run the last turn again, without recording the person's message again. What followed it goes
-         * from the record, so the new reply takes its place; what its tools did stays done.
-         */
-        async retry() {
-            if (turn)
-                throw new Refused("busy", "A turn is running. Wait for it, or cancel it.");
-            const current = { cancelled: false };
-            turn = current;
-            try {
-                await draining;
-                draining = undefined;
-                const last = await history.lastUser();
-                if (!last)
-                    throw new Refused("nothing_to_retry", "No message has been sent yet.");
-                await history.dropAfter(last.id);
-                begin(current);
-                return { messageId: last.id };
-            }
-            catch (error) {
-                if (turn === current)
-                    turn = undefined;
-                throw error;
-            }
-        },
-        /** The status now. */
-        state: () => latest,
-        /**
-         * Stop the turn now: its model request is cancelled, no further call starts, and a new turn
-         * may begin at once. A call already running finishes, and its result is kept.
-         */
-        async cancel() {
-            const current = turn;
-            if (!current)
-                return;
-            current.cancelled = true;
-            turn = undefined;
-            // In a model call, nothing more is recorded; in a tool call, its result still is.
-            if (!current.requestId)
-                draining = current.ended;
-            say({ state: "idle" });
-            if (current.requestId && model.bound)
-                await model.call.cancel({ requestId: current.requestId }).catch(() => { });
-        },
-        /** Settles when the latest turn has written all it will. */
-        settled: async () => {
-            await ending;
-        },
-        /** Streamed text of the model request running now, for the reply it becomes. */
-        delta(requestId, text) {
-            if (turn?.requestId === requestId && turn.replyId)
-                chat.delta(turn.replyId, text);
-        },
-    };
-}

package/dist/node_modules/assistant/dist/src/history.d.ts

@@ -1,97 +0,0 @@
-/**
- * The assistant's record of its chat, kept in its `store` slot: one key per message, holding the
- * Responses items it stands for, and for a tool message the line the person sees. It is read once,
- * then kept in memory, and the oldest messages are deleted past a retention cap.
- */
-import { type ChatMessage, Item, type kv } from "@agentorg/interfaces";
-import type { Log, Slot } from "@agentorg/sdk";
-import { z } from "zod";
-export type ResponseItem = z.output<typeof Item>;
-declare const Entry: z.ZodObject<{
-    id: z.ZodString;
-    role: z.ZodEnum<{
-        assistant: "assistant";
-        tool: "tool";
-        user: "user";
-    }>;
-    text: z.ZodOptional<z.ZodString>;
-    at: z.ZodString;
-    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"message">;
-        role: z.ZodEnum<{
-            assistant: "assistant";
-            user: "user";
-        }>;
-        content: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"function_call">;
-        callId: z.ZodString;
-        name: z.ZodString;
-        arguments: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"function_call_output">;
-        callId: z.ZodString;
-        output: z.ZodString;
-    }, z.core.$strip>], "type">>;
-    state: z.ZodOptional<z.ZodEnum<{
-        done: "done";
-        refused: "refused";
-    }>>;
-}, z.core.$strip>;
-export type Entry = z.output<typeof Entry>;
-/** What the model is sent of the past: the newest exchanges up to this many bytes of JSON. */
-export declare const INPUT_BUDGET = 400000;
-/** At most this many messages are kept, in at most this many bytes, oldest deleted first. */
-export declare const KEEP = 2000;
-export declare const KEEP_BYTES: number;
-/** The first `length` UTF-16 units of `text`, never ending inside a surrogate pair. */
-export declare function head(text: string, length: number): string;
-/** `text`, cut so its JSON fits `max` bytes, saying so when it is cut. */
-export declare function fitted(text: string, max: number): string;
-/** What the person sees of a message. */
-export declare const textOf: (entry: Entry) => string;
-/** A call's arguments as they are kept and shown: past their cap, a note in their place. */
-export declare const argumentsOf: (args: string) => string;
-/**
- * A message as the chat shows it. A tool message whose call ran carries `tool`: the call's name,
- * how it ended, its arguments and its output.
- */
-export declare function messageOf(entry: Entry): z.input<typeof ChatMessage>;
-export declare function createHistory(store: Slot<typeof kv>["call"], log: Log, limits?: {
-    keep: number;
-    keepBytes: number;
-}): {
-    /**
-     * Keep a message, under `id` or its own number, and delete the oldest past the cap. A tool
-     * message the store refuses is still kept in memory, since its call has run.
-     */
-    append(entry: Omit<Entry, "id" | "at">, id?: string): Promise<Entry>;
-    /** Forget everything after the message `id`: a retry takes the place of what followed it. */
-    dropAfter(id: string): Promise<void>;
-    /** The person's last message, if any. */
-    lastUser(): Promise<Entry | undefined>;
-    /** Messages before `before`, oldest first, as many as fit `limit` and one frame. */
-    page(before: string | undefined, limit: number): Promise<{
-        messages: {
-            id: string;
-            role: "assistant" | "tool" | "user";
-            text: string;
-            at: string;
-            tool?: {
-                name: string;
-                state: "done" | "refused" | "running";
-                input?: string | undefined;
-                output?: string | undefined;
-            } | undefined;
-        }[];
-        more: boolean;
-    }>;
-    /**
-     * The conversation to send: the newest whole exchanges (each from a user message on) that fit
-     * the budget, and always the latest one. A latest one that alone is over the budget has its
-     * oldest function arguments and outputs left out, each call still paired with an output.
-     */
-    input(): Promise<ResponseItem[]>;
-};
-export type History = ReturnType<typeof createHistory>;
-export {};