@agentorg/cli 0.0.5 → 0.0.6

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

@@ -2,35 +2,43 @@
   "name": "@agentorg/shell",
   "version": "0.0.0",
   "private": true,
-  "description": "The person's web shell for AgentOrg: their agents, their views and their settings.",
+  "description": "The person's web shell for AgentOrg: their agents, what each is made of, and their settings.",
   "license": "MIT",
   "type": "module",
   "engines": {
     "node": ">=22.15"
   },
   "exports": {
-    "./package.json": "./package.json",
-    "./agent-bindings": {
-      "types": "./src/agent-bindings.ts",
-      "default": "./dist/agent-bindings.js"
-    }
+    "./package.json": "./package.json"
   },
   "files": [
-    "dist",
-    "src/agent-bindings.ts"
+    "dist"
   ],
   "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node scripts/build.js"
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && tsc -p tsconfig.test.json && node scripts/build.js",
+    "test": "node --experimental-strip-types --no-warnings --test --test-timeout=60000 \"test/**/*.test.ts\""
   },
   "devDependencies": {
     "@agentorg/interfaces": "0.0.0",
-    "@agentorg/kit": "0.0.0",
     "@agentorg/sdk": "0.0.0",
+    "@playwright/test": "1.64.1",
+    "@shadcn/react": "0.3.1",
+    "@tailwindcss/cli": "4.3.5",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
+    "@types/ws": "8.18.2",
+    "class-variance-authority": "0.7.1",
+    "clsx": "2.1.1",
     "esbuild": "0.28.2",
+    "lucide-react": "1.70.0",
+    "radix-ui": "1.8.1",
     "react": "19.3.1",
     "react-dom": "19.3.1",
+    "streamdown": "2.7.1",
+    "tailwind-merge": "3.7.0",
+    "tailwindcss": "4.3.5",
+    "tw-animate-css": "1.4.0",
+    "ws": "8.22.1",
     "zod": "^4.6.7"
   }
 }

package/dist/node_modules/@agentorg/wire/dist/src/frames.d.ts

@@ -1,4 +1,4 @@
-/** The largest JSON frame: 1 MiB. `stream` and `http` bodies are raw bytes, not frames. */
+/** The largest JSON frame: 1 MiB. */
 export declare const MAX_FRAME: number;
 export declare class FrameError extends Error {
     readonly name = "FrameError";
@@ -6,8 +6,7 @@ export declare class FrameError extends Error {
 /** A frame: a 4-byte big-endian length, then that many bytes of UTF-8 JSON. */
 export declare function encodeFrame(value: unknown): Uint8Array;
 /**
- * Reads frames from a byte stream, then hands over what follows them untouched: a stream starts
- * with a header frame, and for `open` and `http` the rest is raw bytes.
+ * Reads frames from a byte stream, and can hand over what follows them untouched.
  */
 export declare class FrameReader {
     #private;

package/dist/node_modules/@agentorg/wire/dist/src/frames.js

@@ -1,5 +1,5 @@
 import { ByteQueue } from "./bytes.js";
-/** The largest JSON frame: 1 MiB. `stream` and `http` bodies are raw bytes, not frames. */
+/** The largest JSON frame: 1 MiB. */
 export const MAX_FRAME = 1024 * 1024;
 export class FrameError extends Error {
     name = "FrameError";
@@ -16,8 +16,7 @@ export function encodeFrame(value) {
     return frame;
 }
 /**
- * Reads frames from a byte stream, then hands over what follows them untouched: a stream starts
- * with a header frame, and for `open` and `http` the rest is raw bytes.
+ * Reads frames from a byte stream, and can hand over what follows them untouched.
  */
 export class FrameReader {
     #reader;

package/dist/node_modules/@agentorg/wire/dist/src/ops.d.ts

@@ -7,9 +7,7 @@
  *   closes the channel too. Without `declares` the Actor keeps what it declared before; with it,
  *   `declares` replaces that. The result is `{actorId, bound}`: the Actor's slots bound now. A
  *   newer channel for an Actor replaces its older one; with `replace: false` the hello is refused
- *   instead (`Refused`, code `connected`) while the Actor has a live channel. On a pipe the Hub
- *   made for a package Actor's process, the hello names that Actor and carries no credential (the
- *   pipe is the proof) and no `declares` (a package declares through its manifest).
+ *   instead (`Refused`, code `connected`) while the Actor has a live channel.
  * - `slot`: from the Hub, one of the Actor's slots was bound or unbound after its channel's hello
  *   result was taken. The header is the whole message: the Hub closes its side, and the Actor
  *   closes its side once it has read it (an open notice counts against its streams). Applied in
@@ -17,22 +15,16 @@
  *   they give each slot's state. A `bound: true` for a slot already bound means its provider came
  *   back after going away: the slot is usable again, and what was subscribed must be again. A
  *   provider going away sends nothing; calls meanwhile are `NotConnected`.
- * - `offer` and `withdraw`: the channel's own Actor offers an export at run time, or withdraws
- *   one it offered; one body (`{result: {}}` or `{error}`) answers, then the stream closes.
  * - `call`: the caller sends one `{input}` body and closes its side; the answer is one `{result}`
  *   or `{error}` body, then the stream closes.
  * - `subscribe`: `{event}` bodies flow until the subscriber resets the stream, or the provider
  *   side closes it (with an `{error}` body first when it was refused).
- * - `open` and `http`: the answering side sends exactly one body first, `{result: {}}` to accept
- *   or `{error}` to refuse; after an accept, raw bytes flow both ways, each side closing its own
- *   direction, and a reset ends both. The provider answers the Hub, and the Hub forwards that
- *   answer. The opener may send bytes before the answer; they wait.
  * Cancelling a reader of a yamux stream resets it.
  */
 export type Header = 
 /**
- * Admits a channel; its first stream. An external client's carries its credential and may
- * declare (the Hub validates `declares`); a pipe's names its Actor only.
+ * Admits a channel; its first stream. It carries the Actor's credential and may declare (the
+ * Hub validates `declares`).
  */
 {
     op: "hello";
@@ -49,26 +41,6 @@ export type Header =
     slot: string;
     event: string;
 }
-/** Raw bytes in the interface's protocol, after the Hub validates `params`. */
- | {
-    op: "open";
-    slot: string;
-    params: unknown;
-}
-/** HTTP/1.1 bytes. */
- | {
-    op: "http";
-    slot: string;
-}
-/** Offer an export at run time, as a described interface; it lasts until withdrawn or disconnect. */
- | {
-    op: "offer";
-    name: string;
-    interface: unknown;
-} | {
-    op: "withdraw";
-    name: string;
-}
 /**
  * From the Hub to an Actor: one of its slots was bound or unbound. A slot made at run time (an
  * export exposed to this Actor) carries `exposed` while bound: the export's described interface
@@ -81,18 +53,17 @@ export type Header =
     exposed?: Exposure;
 }
 /**
- * From the Hub to a provider: the same four, naming its export, who is calling, and through which
+ * From the Hub to a provider: the same two, naming its export, who is calling, and through which
  * of the caller's slots (a provider keeping state per consumer keys it by both).
  */
  | {
     op: "serve";
-    kind: "call" | "subscribe" | "open" | "http";
+    kind: "call" | "subscribe";
     export: string;
     caller: string;
     slot: string;
     method?: string;
     event?: string;
-    params?: unknown;
 };
 /** A slot made at run time, as the Hub describes it: the export's interface, and whose it is. */
 export interface Exposure {

package/dist/node_modules/@agentorg/wire/dist/src/ops.js

@@ -25,18 +25,6 @@ export function parseHeader(value) {
             return { op: "call", slot: text(value, "slot"), method: text(value, "method") };
         case "subscribe":
             return { op: "subscribe", slot: text(value, "slot"), event: text(value, "event") };
-        case "open":
-            if (!("params" in value))
-                throw new HeaderError("An open header needs params.");
-            return { op: "open", slot: text(value, "slot"), params: value.params };
-        case "http":
-            return { op: "http", slot: text(value, "slot") };
-        case "offer":
-            if (!isRecord(value.interface))
-                throw new HeaderError("An offer header needs an interface.");
-            return { op: "offer", name: text(value, "name"), interface: value.interface };
-        case "withdraw":
-            return { op: "withdraw", name: text(value, "name") };
         case "slot": {
             if (typeof value.bound !== "boolean")
                 throw new HeaderError("A slot header needs bound.");
@@ -63,10 +51,8 @@ export function parseHeader(value) {
         }
         case "serve": {
             const kind = value.kind;
-            if (kind !== "call" && kind !== "subscribe" && kind !== "open" && kind !== "http")
-                throw new HeaderError("A serve header's kind must be call, subscribe, open or http.");
-            if (kind === "open" && !("params" in value))
-                throw new HeaderError("An open serve header needs params.");
+            if (kind !== "call" && kind !== "subscribe")
+                throw new HeaderError("A serve header's kind must be call or subscribe.");
             return {
                 op: "serve",
                 kind,
@@ -75,7 +61,6 @@ export function parseHeader(value) {
                 slot: text(value, "slot"),
                 ...(kind === "call" ? { method: text(value, "method") } : {}),
                 ...(kind === "subscribe" ? { event: text(value, "event") } : {}),
-                ...(kind === "open" ? { params: value.params } : {}),
             };
         }
         default:

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

@@ -0,0 +1,62 @@
+/**
+ * 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

@@ -0,0 +1,226 @@
+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/engine.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The engine: one agent's chat, its loop, and what a request says and offers. Its host says where
+ * the record is kept and what the agent is told when no `settings` is bound.
+ */
+import type { agentSettings, chat, kv, llmSession } from "@agentorg/interfaces";
+import { type Context, type Slot } from "@agentorg/sdk";
+type Host = Pick<Context<{
+    model: typeof llmSession;
+    settings: typeof agentSettings;
+}, {
+    chat: typeof chat;
+}>, "slots" | "exports" | "exposed" | "log">;
+export declare function startEngine(ctx: Host, options: {
+    store: Slot<typeof kv>["call"];
+    /** What the agent is told while no `settings` is bound. */
+    instructions(): string;
+}): {
+    /** Stop the turn in progress. */
+    cancel: () => Promise<void>;
+    /** Settles when the latest turn has written all it will. */
+    settled: () => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,88 @@
+import { Refused } from "@agentorg/sdk";
+import { createAgent } from "./agent.js";
+import { createHistory } from "./history.js";
+import { instructionsWith, skillTool } from "./settings.js";
+import { listedBy, listsTools, offered } from "./tools.js";
+/** Where the agent keeps the model chosen for it, beside its record in the store. */
+const MODEL_KEY = "settings/model";
+export function startEngine(ctx, options) {
+    const { store } = options;
+    const history = createHistory(store, ctx.log);
+    /** The model chosen for this agent, if any; read for each request. */
+    const chosen = async () => {
+        const { value } = await store.get({ key: MODEL_KEY });
+        return typeof value === "string" ? value : undefined;
+    };
+    /** What was last reported as left out, so a change is logged once. */
+    let reported = "[]";
+    const report = (leftOut) => {
+        const now = JSON.stringify(leftOut);
+        if (now === reported)
+            return;
+        reported = now;
+        if (leftOut.length > 0)
+            ctx.log.warn("Not everything is offered to the model.", { leftOut });
+        else
+            ctx.log.info("Everything is offered to the model again.");
+    };
+    /** What a request says and offers, read afresh: nothing here outlives the request. */
+    const request = async () => {
+        const settings = ctx.slots.settings.bound ? await ctx.slots.settings.call.get({}) : undefined;
+        const told = settings
+            ? instructionsWith(settings.instructions, settings.skills)
+            : { instructions: options.instructions(), leftOut: [] };
+        const own = settings?.skills.length ? [skillTool(ctx.slots.settings)] : [];
+        // In the order they came, each asked at once so one slow server delays only itself.
+        const exposed = await Promise.all(ctx
+            .exposed()
+            .filter((slot) => listsTools(slot.described))
+            .map((slot) => listedBy(slot.slot, slot)));
+        const { tools, leftOut } = offered([...own, ...exposed.flatMap((one) => one.candidates)]);
+        report([...told.leftOut, ...exposed.flatMap((one) => one.leftOut), ...leftOut]);
+        return { instructions: told.instructions, tools };
+    };
+    const agent = createAgent({
+        request,
+        model: ctx.slots.model,
+        chosenModel: chosen,
+        history,
+        chat: {
+            message: (message) => ctx.exports.chat.emit("message", message),
+            delta: (id, text) => ctx.exports.chat.emit("delta", { id, text }),
+            status: (status) => ctx.exports.chat.emit("status", status),
+        },
+        log: ctx.log,
+    });
+    ctx.slots.model.on("delta", ({ requestId, text }) => agent.delta(requestId, text));
+    ctx.exports.chat.implement({
+        send: ({ text }) => agent.send(text),
+        history: ({ before, limit }) => history.page(before, limit ?? 50),
+        cancel: async () => {
+            await agent.cancel();
+            return {};
+        },
+        state: () => agent.state(),
+        retry: () => agent.retry(),
+        models: async () => {
+            const [{ models }, current] = await Promise.all([ctx.slots.model.call.models({}), chosen()]);
+            return { models, ...(current ? { current } : {}) };
+        },
+        setModel: async ({ model }) => {
+            if (!model) {
+                await store.delete({ key: MODEL_KEY });
+                return {};
+            }
+            const { models } = await ctx.slots.model.call.models({});
+            if (!models.some((offered) => offered.id === model))
+                throw new Refused("unknown", `${model} isn't one of the models offered.`);
+            await store.set({ key: MODEL_KEY, value: model });
+            return {};
+        },
+    });
+    return {
+        /** Stop the turn in progress. */
+        cancel: () => agent.cancel(),
+        /** Settles when the latest turn has written all it will. */
+        settled: () => agent.settled(),
+    };
+}