@agentorg/cli 0.0.6 → 0.0.7

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

@@ -16,7 +16,7 @@
   ],
   "scripts": {
     "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\""
+    "test": "node --experimental-strip-types --no-warnings --test --test-concurrency=3 --test-timeout=60000 \"test/**/*.test.ts\""
   },
   "devDependencies": {
     "@agentorg/interfaces": "0.0.0",
@@ -27,6 +27,8 @@
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
     "@types/ws": "8.18.2",
+    "@xterm/addon-fit": "0.10.0",
+    "@xterm/xterm": "5.5.0",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
     "esbuild": "0.28.2",
@@ -40,5 +42,8 @@
     "tw-animate-css": "1.4.0",
     "ws": "8.22.1",
     "zod": "^4.6.7"
+  },
+  "dependencies": {
+    "react-diff-view": "3.3.3"
   }
 }

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

@@ -0,0 +1,92 @@
+/**
+ * An agent's chats: each one's entry in the store, and the looper's thread it is. A chat is made by
+ * the message that starts it and is never deleted. The entries are read when a chat is first asked
+ * for, all of them, and then stay in memory.
+ */
+import { type ChatEntry, type chat, type kv } from "@agentorg/interfaces";
+import { type Model, type Tool } from "@agentorg/looper";
+import { type Log, type Slot } from "@agentorg/sdk";
+import { z } from "zod";
+type Store = Slot<typeof kv>["call"];
+type Listed = z.input<typeof ChatEntry>;
+type Input<M extends keyof (typeof chat)["methods"]> = z.output<(typeof chat)["methods"][M]["input"]>;
+type Emitted<E extends keyof (typeof chat)["events"]> = z.input<(typeof chat)["events"][E]["payload"]>;
+export declare function createChats(options: {
+    store: Store;
+    /** The agent's model, and what a request to it says and offers, as its looper asks for them. */
+    model: Model;
+    request(): Promise<{
+        instructions: string;
+        tools: Tool[];
+        model?: string | undefined;
+    }>;
+    /** Whether the agent is stopped when its chats are first held. */
+    stopped: boolean;
+    emit: {
+        message(message: Emitted<"message">): void;
+        delta(delta: Emitted<"delta">): void;
+        status(status: Emitted<"status">): void;
+        chat(entry: Listed): void;
+    };
+    log: Log;
+}): {
+    /**
+     * Say a message in a chat, or in a new chat it starts. With no turn in the chat it starts one;
+     * a turn running there takes it at its next model request.
+     */
+    send({ chat, text }: Input<"send">): Promise<{
+        chat: string;
+        messageId: string;
+    }>;
+    history: ({ chat, before, limit }: Input<"history">) => Promise<{
+        messages: import("@agentorg/looper").Shown[];
+        more: boolean;
+    }>;
+    /** What the agent is doing now. */
+    state: () => {
+        state: "idle" | "working";
+    };
+    /**
+     * The chats after `before` in the list, the one a message was last sent in first. `before`
+     * holds its place whether it is archived or not, so a page never leaves out a chat that hasn't
+     * moved since the page before it.
+     */
+    list({ archived, before, limit }: Input<"list">): Promise<{
+        chats: {
+            id: string;
+            title: string;
+            at: string;
+            latest?: {
+                id: string;
+                at: string;
+            } | undefined;
+            problem?: {
+                code: string;
+                message: string;
+            } | undefined;
+            archived: boolean;
+        }[];
+        more: boolean;
+    }>;
+    rename({ chat, title }: Input<"rename">): Promise<{}>;
+    archive({ chat, archived }: Input<"archive">): Promise<{}>;
+    /**
+     * Stop the agent: its turns are cut, and none starts until it is started. A call already
+     * running finishes first, so this answers when nothing more will be written. Its chats stay as
+     * they are, to be read.
+     */
+    stop: () => Promise<void>;
+    start: () => void;
+    /** Go on with the turns that were cut off when the agent last ran, each once. */
+    resume(): Promise<void>;
+    /**
+     * Close for good: its turns are cut, and none starts after. They stay marked, so the engine
+     * that opens this store next goes on with them.
+     */
+    close: () => Promise<void>;
+    /** Settles when every chat's latest turn has written all it will. */
+    settled(): Promise<void>;
+    /** Streamed text of the model request running now. */
+    delta(requestId: string, text: string): void;
+};
+export {};

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

@@ -0,0 +1,357 @@
+/**
+ * An agent's chats: each one's entry in the store, and the looper's thread it is. A chat is made by
+ * the message that starts it and is never deleted. The entries are read when a chat is first asked
+ * for, all of them, and then stay in memory.
+ */
+import { CHAT_TITLE_MAX, } from "@agentorg/interfaces";
+import { createLooper, Entry, Refusal, textOf, } from "@agentorg/looper";
+import { Refused } from "@agentorg/sdk";
+import { z } from "zod";
+import { head, relayed } from "./tools.js";
+/** A chat's entry is kept under `chats/<id>`. */
+const ENTRIES = "chats/";
+/**
+ * The looper's keys in the agent's store. A chat is a thread by its id, and a thread's record is
+ * where a chat's has always been, under `chat/<id>/`; anything else the looper keeps is under
+ * `loop/`. A list is of one or of the other, never across both. What the store refuses, the looper
+ * is told as its own refusal.
+ */
+const THREADS = "thread/";
+const CHATS = "chat/";
+const REST = "loop/";
+const toStore = (key) => key.startsWith(THREADS) ? CHATS + key.slice(THREADS.length) : REST + key;
+const fromStore = (key) => key.startsWith(CHATS) ? THREADS + key.slice(CHATS.length) : key.slice(REST.length);
+function forLooper(store) {
+    return {
+        get: ({ key }) => relayed(store.get({ key: toStore(key) })),
+        set: ({ key, value }) => relayed(store.set({ key: toStore(key), value })),
+        delete: ({ key }) => relayed(store.delete({ key: toStore(key) })),
+        async list({ prefix = "", after, limit }) {
+            const page = await relayed(store.list({
+                prefix: toStore(prefix),
+                ...(after === undefined ? {} : { after: toStore(after) }),
+                ...(limit === undefined ? {} : { limit }),
+            }));
+            return {
+                keys: page.keys.map(fromStore),
+                next: page.next === null ? null : fromStore(page.next),
+            };
+        },
+    };
+}
+/**
+ * The looper as the chats call it: every call into it passes here. What the looper refuses is
+ * refused as the chat's, and what the store refused comes back as the store's own error.
+ */
+function forChats(looper) {
+    const outward = (error) => {
+        if (!(error instanceof Refusal))
+            throw error;
+        throw error.cause ?? new Refused(error.code, error.message);
+    };
+    return new Proxy(looper, {
+        get(target, name, receiver) {
+            const member = Reflect.get(target, name, receiver);
+            if (typeof member !== "function")
+                return member;
+            return (...given) => {
+                try {
+                    const result = member.apply(target, given);
+                    return result instanceof Promise ? result.catch(outward) : result;
+                }
+                catch (error) {
+                    return outward(error);
+                }
+            };
+        },
+    });
+}
+/** Where the one conversation an agent had before it had chats was kept. */
+const LEGACY = "msg/";
+/** Stored values read at once when the entries, or that conversation, are first loaded. */
+const READS = 16;
+/** The chat that the one conversation an agent had before it had chats becomes. */
+const FIRST = "first";
+const PAGE = 50;
+/** What is kept of a chat beside its record. */
+const Stored = z.object({
+    title: z.string(),
+    at: z.string(),
+    /** Its place in the list: the highest is the chat a message was last sent in. */
+    order: z.number(),
+    latest: z.object({ id: z.string(), at: z.string() }).optional(),
+    /** Why a message in it got no answer, until its next reply. */
+    problem: z.object({ code: z.string(), message: z.string() }).optional(),
+    archived: z.boolean(),
+});
+/** A title from a message: its first line with anything in it, on one line. */
+const titleOf = (text) => head((text.split("\n").find((line) => /\S/.test(line)) ?? "").replace(/\s+/g, " ").trim(), CHAT_TITLE_MAX);
+/** Every key under `prefix`, in order. */
+async function keysUnder(store, prefix) {
+    const keys = [];
+    let after;
+    do {
+        const page = await store.list({ prefix, limit: 1000, ...(after ? { after } : {}) });
+        keys.push(...page.keys);
+        after = page.next ?? undefined;
+    } while (after);
+    return keys;
+}
+export function createChats(options) {
+    const { store, emit, log } = options;
+    /** The highest place in the list given so far. */
+    let top = 0;
+    /** Entries being written, one after another, so the latest written is the latest said. */
+    let writing = Promise.resolve();
+    /** The chats, by id, once their entries are read. */
+    const chats = new Map();
+    let loaded;
+    /** The chats whose loops are at work now: the agent is working while there is one. */
+    const atWork = new Set();
+    const stateNow = () => ({ state: atWork.size > 0 ? "working" : "idle" });
+    /** The chats' loops: a chat is the looper's thread of the same name. */
+    const looper = forChats(createLooper({
+        store: forLooper(store),
+        model: options.model,
+        request: options.request,
+        out: {
+            message(thread, message) {
+                const held = chats.get(thread);
+                if (held)
+                    sent(held, message);
+                emit.message({ ...message, chat: thread });
+            },
+            delta: (thread, id, text) => emit.delta({ chat: thread, id, text }),
+            status(thread, status) {
+                const was = atWork.size > 0;
+                if (status.state === "thinking" || status.state === "tool")
+                    atWork.add(thread);
+                else
+                    atWork.delete(thread);
+                // A turn that failed left its chat's message with no answer: the chat is told why,
+                // before the agent is said to be idle.
+                const held = chats.get(thread);
+                if (status.state === "error" && held) {
+                    const { code, message } = status.detail;
+                    held.stored.problem = { code: head(code, 128), message: head(message, 2000) };
+                    told(held);
+                }
+                if (atWork.size > 0 !== was)
+                    emit.status(stateNow());
+            },
+        },
+        stopped: options.stopped,
+        log,
+    }));
+    const entryOf = ({ id, stored }) => ({
+        id,
+        title: stored.title,
+        at: stored.at,
+        ...(stored.latest ? { latest: stored.latest } : {}),
+        ...(stored.problem ? { problem: stored.problem } : {}),
+        archived: stored.archived,
+    });
+    /** Write a chat's entry as it now is, after any write before it. */
+    const save = (held) => {
+        const value = { ...held.stored };
+        const written = writing.then(() => store.set({ key: ENTRIES + held.id, value }));
+        writing = written.catch(() => { });
+        return written;
+    };
+    /** Say a chat's entry as it now is; its write follows. */
+    const told = (held) => {
+        // What it tells is already so: an entry that can't be written is behind until the next.
+        save(held).catch((error) => log.error("A chat's entry couldn't be stored.", { chat: held.id, error: String(error) }));
+        emit.chat(entryOf(held));
+    };
+    /**
+     * A message sent in a chat moves it to the front of the list; a reply is what is new in it, and
+     * its message has its answer.
+     */
+    const sent = (held, message) => {
+        if (message.role === "tool")
+            return;
+        held.stored.order = ++top;
+        if (message.role === "assistant") {
+            held.stored.latest = { id: message.id, at: message.at };
+            delete held.stored.problem;
+        }
+        told(held);
+    };
+    /** Change what a chat is called or where it is listed: a change the store refuses isn't made. */
+    const keep = async (held, key, value) => {
+        const was = held.stored[key];
+        held.stored[key] = value;
+        try {
+            await save(held);
+        }
+        catch (error) {
+            held.stored[key] = was;
+            throw error;
+        }
+        emit.chat(entryOf(held));
+    };
+    /**
+     * The conversation an agent had before it had chats becomes its first chat. Its entry is written
+     * before any message moves, from all of them, so a move cut short goes on from where it stopped
+     * with the entry it began with.
+     */
+    const adopt = async () => {
+        const keys = await keysUnder(store, LEGACY);
+        if (keys.length === 0)
+            return;
+        const values = [];
+        for (let at = 0; at < keys.length; at += READS)
+            values.push(...(await Promise.all(keys.slice(at, at + READS).map((key) => store.get({ key })))).map((read) => read.value));
+        if (!Stored.safeParse((await store.get({ key: ENTRIES + FIRST })).value).success) {
+            const read = values.flatMap((value) => {
+                const entry = Entry.safeParse(value);
+                return entry.success ? [entry.data] : [];
+            });
+            const reply = read.findLast((entry) => entry.role === "assistant");
+            const opening = read.find((entry) => entry.role === "user") ?? read[0];
+            const stored = {
+                title: opening ? titleOf(textOf(opening)) : "",
+                at: read[0]?.at ?? new Date().toISOString(),
+                // Behind every chat started since.
+                order: 0,
+                ...(reply ? { latest: { id: reply.id, at: reply.at } } : {}),
+                archived: false,
+            };
+            await store.set({ key: ENTRIES + FIRST, value: stored });
+        }
+        for (const [i, key] of keys.entries()) {
+            if (values[i] !== undefined)
+                await store.set({
+                    key: `${CHATS}${FIRST}/${key}`,
+                    value: values[i],
+                });
+            await store.delete({ key });
+        }
+        log.info("The conversation it had is now its first chat.", { messages: keys.length });
+    };
+    const load = () => {
+        if (loaded)
+            return loaded;
+        const attempt = (async () => {
+            await adopt();
+            const keys = await keysUnder(store, ENTRIES);
+            for (let at = 0; at < keys.length; at += READS) {
+                const some = keys.slice(at, at + READS);
+                const values = await Promise.all(some.map((key) => store.get({ key })));
+                some.forEach((key, i) => {
+                    const stored = Stored.safeParse(values[i]?.value);
+                    const id = key.slice(ENTRIES.length);
+                    if (!stored.success) {
+                        log.warn("A chat's entry didn't read back; the chat is left out.", { key });
+                        return;
+                    }
+                    chats.set(id, { id, stored: stored.data });
+                    top = Math.max(top, stored.data.order);
+                });
+            }
+            return chats;
+        })();
+        loaded = attempt;
+        attempt.catch(() => {
+            if (loaded === attempt)
+                loaded = undefined;
+        });
+        return attempt;
+    };
+    const heldOf = async (id) => {
+        const held = (await load()).get(id);
+        if (!held)
+            throw new Refused("unknown", "This agent has no such chat.");
+        return held;
+    };
+    return {
+        /**
+         * Say a message in a chat, or in a new chat it starts. With no turn in the chat it starts one;
+         * a turn running there takes it at its next model request.
+         */
+        async send({ chat, text }) {
+            if (chat !== undefined) {
+                await heldOf(chat);
+                const { messageId } = await looper.send(chat, text);
+                return { chat, messageId };
+            }
+            const found = await load();
+            const held = {
+                id: crypto.randomUUID(),
+                stored: {
+                    title: titleOf(text),
+                    at: new Date().toISOString(),
+                    order: ++top,
+                    archived: false,
+                },
+            };
+            try {
+                // Its entry first: a record with no entry would be a chat nobody can find.
+                await store.set({ key: ENTRIES + held.id, value: held.stored });
+                found.set(held.id, held);
+                const { messageId } = await looper.send(held.id, text);
+                return { chat: held.id, messageId };
+            }
+            catch (error) {
+                found.delete(held.id);
+                await store.delete({ key: ENTRIES + held.id }).catch(() => { });
+                throw error;
+            }
+        },
+        history: async ({ chat, before, limit }) => looper.page((await heldOf(chat)).id, before, limit ?? PAGE),
+        /** What the agent is doing now. */
+        state: stateNow,
+        /**
+         * The chats after `before` in the list, the one a message was last sent in first. `before`
+         * holds its place whether it is archived or not, so a page never leaves out a chat that hasn't
+         * moved since the page before it.
+         */
+        async list({ archived = false, before, limit = PAGE }) {
+            const found = await load();
+            const mark = before === undefined ? undefined : found.get(before);
+            if (before !== undefined && !mark)
+                return { chats: [], more: false };
+            const rest = [...found.values()]
+                .filter(({ stored }) => stored.archived === archived && (!mark || stored.order < mark.stored.order))
+                .sort((a, b) => b.stored.order - a.stored.order);
+            return { chats: rest.slice(0, limit).map(entryOf), more: rest.length > limit };
+        },
+        async rename({ chat, title }) {
+            await keep(await heldOf(chat), "title", titleOf(title));
+            return {};
+        },
+        async archive({ chat, archived }) {
+            await keep(await heldOf(chat), "archived", archived);
+            return {};
+        },
+        /**
+         * Stop the agent: its turns are cut, and none starts until it is started. A call already
+         * running finishes first, so this answers when nothing more will be written. Its chats stay as
+         * they are, to be read.
+         */
+        stop: () => looper.stop(),
+        start: () => looper.start(),
+        /** Go on with the turns that were cut off when the agent last ran, each once. */
+        async resume() {
+            // The chats first: what a turn says moves its chat in the list.
+            await load();
+            await looper.resume();
+        },
+        /**
+         * Close for good: its turns are cut, and none starts after. They stay marked, so the engine
+         * that opens this store next goes on with them.
+         */
+        close: () => looper.close(),
+        /** Settles when every chat's latest turn has written all it will. */
+        async settled() {
+            await loaded?.catch(() => undefined);
+            await looper.settled();
+            await writing;
+        },
+        /** Streamed text of the model request running now. */
+        delta(requestId, text) {
+            looper.delta(requestId, text);
+        },
+    };
+}

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

@@ -1,6 +1,7 @@
 /**
- * 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.
+ * The engine: the looper bound to one agent. Its chats are the looper's threads, its model is the
+ * agent's `model` slot, and what a request says and offers is read from what the agent is bound to.
+ * Its host says where the records are 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";
@@ -9,15 +10,33 @@ type Host = Pick<Context<{
     settings: typeof agentSettings;
 }, {
     chat: typeof chat;
-}>, "slots" | "exports" | "exposed" | "log">;
+}>, "slots" | "exports" | "exposed" | "onExposed" | "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;
+    /** Whether it starts stopped, as it was left. */
+    stopped?: boolean;
 }): {
-    /** Stop the turn in progress. */
-    cancel: () => Promise<void>;
-    /** Settles when the latest turn has written all it will. */
-    settled: () => Promise<void>;
+    /** The models the agent can use, and the one chosen for it. */
+    models(): Promise<{
+        models: {
+            id: string;
+            name: string;
+        }[];
+        current?: string | undefined;
+    }>;
+    /** Choose the model for its next requests, kept with it; with none, the provider's default. */
+    setModel(model: string | undefined): Promise<void>;
+    /** Stop the agent: its turns are cut and none starts until `start`. Its chats stay readable. */
+    stop(): Promise<void>;
+    start: () => void;
+    /**
+     * Close for good: its turns are cut, and none starts after. They go on in the engine that
+     * opens this store next.
+     */
+    close(): Promise<void>;
+    /** Settles when every chat's latest turn has written all it will. */
+    settled(): Promise<void>;
 };
 export {};