@agentorg/cli 0.0.5 → 0.0.6

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

@@ -0,0 +1,97 @@
+/**
+ * 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 {};

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

@@ -0,0 +1,235 @@
+/**
+ * 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 { Item } from "@agentorg/interfaces";
+import { z } from "zod";
+const Entry = z.object({
+    id: z.string(),
+    role: z.enum(["user", "assistant", "tool"]),
+    /** What the person sees, for a tool message; the others show their message items. */
+    text: z.string().optional(),
+    at: z.string(),
+    items: z.array(Item),
+    /** For a tool message whose call ran: how it ended. */
+    state: z.enum(["done", "refused"]).optional(),
+});
+const PREFIX = "msg/";
+const keyOf = (seq) => `${PREFIX}${String(seq).padStart(12, "0")}`;
+/** What the model is sent of the past: the newest exchanges up to this many bytes of JSON. */
+export const INPUT_BUDGET = 400_000;
+/** At most this many messages are kept, in at most this many bytes, oldest deleted first. */
+export const KEEP = 2000;
+export const KEEP_BYTES = 16 * 1024 * 1024;
+/** A stored message's text, and a call's arguments, are cut to fit these, in bytes of JSON. */
+const MAX_TEXT = 192 * 1024;
+const MAX_ARGUMENTS = 16 * 1024;
+/** A history page stays well inside one frame. */
+const PAGE_BUDGET = 512 * 1024;
+const encoder = new TextEncoder();
+const size = (value) => encoder.encode(JSON.stringify(value)).byteLength;
+const LEFT_OUT = "(Left out: the conversation was too large to send it.)";
+const ARGUMENTS_LEFT_OUT = '{"left_out":"too large to keep"}';
+/** The first `length` UTF-16 units of `text`, never ending inside a surrogate pair. */
+export function head(text, length) {
+    const cut = text.slice(0, length);
+    return /[\uD800-\uDBFF]$/.test(cut) ? cut.slice(0, -1) : cut;
+}
+/** `text`, cut so its JSON fits `max` bytes, saying so when it is cut. */
+export function fitted(text, max) {
+    let kept = text;
+    for (let bytes = size(kept); bytes > max; bytes = size(kept))
+        kept = `${head(kept, Math.floor((kept.length * max) / bytes) - 16)}… (cut)`;
+    return kept;
+}
+/** A chat message shows at most this much; the record keeps all of it. */
+const MAX_SHOWN = 100_000;
+/** What the person sees of a message. */
+export const textOf = (entry) => head(entry.text ??
+    entry.items.flatMap((item) => (item.type === "message" ? [item.content] : [])).join(""), MAX_SHOWN);
+/** A call's arguments as they are kept and shown: past their cap, a note in their place. */
+export const argumentsOf = (args) => size(args) > MAX_ARGUMENTS ? ARGUMENTS_LEFT_OUT : args;
+/**
+ * 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 function messageOf(entry) {
+    const message = { id: entry.id, role: entry.role, text: textOf(entry), at: entry.at };
+    const call = entry.items.find((item) => item.type === "function_call");
+    if (entry.role !== "tool" || !entry.state || !call)
+        return message;
+    const output = entry.items.find((item) => item.type === "function_call_output");
+    return {
+        ...message,
+        tool: {
+            name: head(call.name, 128),
+            state: entry.state,
+            input: head(call.arguments, MAX_SHOWN),
+            ...(output ? { output: head(output.output, MAX_SHOWN) } : {}),
+        },
+    };
+}
+/** A message as it is stored: each text once, and nothing past its cap. */
+const kept = (entry) => ({
+    ...entry,
+    items: entry.items.map((item) => {
+        if (item.type === "message")
+            return { ...item, content: fitted(item.content, MAX_TEXT) };
+        if (item.type === "function_call_output")
+            return { ...item, output: fitted(item.output, MAX_TEXT) };
+        return { ...item, arguments: argumentsOf(item.arguments) };
+    }),
+});
+/** Stored messages read at once when the record is first loaded. */
+const READS = 16;
+export function createHistory(store, log, limits = { keep: KEEP, keepBytes: KEEP_BYTES }) {
+    let loaded;
+    const load = () => {
+        if (loaded)
+            return loaded;
+        const attempt = (async () => {
+            const records = [];
+            let last = 0;
+            let bytes = 0;
+            let after;
+            do {
+                const page = await store.list({ prefix: PREFIX, limit: 1000, ...(after ? { after } : {}) });
+                // A few at a time, in order: a long record shouldn't hold up the first send one read at
+                // a time, nor flood the Hub.
+                for (let at = 0; at < page.keys.length; at += READS) {
+                    const keys = page.keys.slice(at, at + READS);
+                    const values = await Promise.all(keys.map((key) => store.get({ key })));
+                    keys.forEach((key, i) => {
+                        last = Math.max(last, Number(key.slice(PREFIX.length)) || 0);
+                        const parsed = Entry.safeParse(values[i]?.value);
+                        if (!parsed.success) {
+                            log.warn("A stored message didn't read back; it is left out.", { key });
+                            return;
+                        }
+                        const record = { key, entry: parsed.data, bytes: size(parsed.data) };
+                        records.push(record);
+                        bytes += record.bytes;
+                    });
+                }
+                after = page.next ?? undefined;
+            } while (after);
+            return { records, last, bytes };
+        })();
+        loaded = attempt;
+        attempt.catch(() => {
+            if (loaded === attempt)
+                loaded = undefined;
+        });
+        return attempt;
+    };
+    return {
+        /**
+         * 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.
+         */
+        async append(entry, id) {
+            const state = await load();
+            const key = keyOf(++state.last);
+            const record = {
+                key,
+                entry: kept({ id: id ?? key.slice(PREFIX.length), at: new Date().toISOString(), ...entry }),
+                bytes: 0,
+            };
+            record.bytes = size(record.entry);
+            state.records.push(record);
+            state.bytes += record.bytes;
+            try {
+                await store.set({ key, value: record.entry });
+            }
+            catch (error) {
+                if (entry.role !== "tool") {
+                    state.records.splice(state.records.indexOf(record), 1);
+                    state.bytes -= record.bytes;
+                    throw error;
+                }
+                log.error("A tool message couldn't be stored; it is kept until a restart.", {
+                    error: String(error),
+                });
+            }
+            while (state.records.length > 1 &&
+                (state.records.length > limits.keep || state.bytes > limits.keepBytes)) {
+                const oldest = state.records.shift();
+                state.bytes -= oldest.bytes;
+                await store.delete({ key: oldest.key }).catch((error) => log.warn("An old message couldn't be deleted.", {
+                    key: oldest.key,
+                    error: String(error),
+                }));
+            }
+            return record.entry;
+        },
+        /** Forget everything after the message `id`: a retry takes the place of what followed it. */
+        async dropAfter(id) {
+            const state = await load();
+            const at = state.records.findLastIndex((record) => record.entry.id === id);
+            if (at === -1)
+                return;
+            for (const gone of state.records.splice(at + 1)) {
+                state.bytes -= gone.bytes;
+                await store.delete({ key: gone.key }).catch((error) => log.warn("A replaced message couldn't be deleted.", {
+                    key: gone.key,
+                    error: String(error),
+                }));
+            }
+        },
+        /** The person's last message, if any. */
+        async lastUser() {
+            return (await load()).records.findLast((record) => record.entry.role === "user")?.entry;
+        },
+        /** Messages before `before`, oldest first, as many as fit `limit` and one frame. */
+        async page(before, limit) {
+            const { records } = await load();
+            const end = before === undefined
+                ? records.length
+                : records.findIndex((record) => record.entry.id === before);
+            const messages = [];
+            let bytes = 0;
+            let start = Math.max(end, 0);
+            while (start > 0 && messages.length < limit) {
+                const { entry } = records[start - 1];
+                const message = messageOf(entry);
+                bytes += size(message);
+                if (bytes > PAGE_BUDGET && messages.length > 0)
+                    break;
+                messages.unshift(message);
+                start--;
+            }
+            return { messages, more: start > 0 };
+        },
+        /**
+         * 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.
+         */
+        async input() {
+            const { records } = await load();
+            const exchanges = [];
+            for (const { entry } of records) {
+                if (entry.role === "user" || exchanges.length === 0)
+                    exchanges.push([]);
+                exchanges.at(-1)?.push(...entry.items);
+            }
+            let total = exchanges.reduce((sum, items) => sum + size(items), 0);
+            while (exchanges.length > 1 && total > INPUT_BUDGET)
+                total -= size(exchanges.shift());
+            const items = exchanges.flat();
+            for (let i = 0; i < items.length && total > INPUT_BUDGET; i++) {
+                const item = items[i];
+                if (item.type === "function_call_output" && item.output !== LEFT_OUT) {
+                    total -= size(item.output) - size(LEFT_OUT);
+                    items[i] = { ...item, output: LEFT_OUT };
+                }
+                else if (item.type === "function_call" && item.arguments !== ARGUMENTS_LEFT_OUT) {
+                    total -= size(item.arguments) - size(ARGUMENTS_LEFT_OUT);
+                    items[i] = { ...item, arguments: ARGUMENTS_LEFT_OUT };
+                }
+            }
+            return items;
+        },
+    };
+}

package/dist/node_modules/assistant/dist/src/local-store.d.ts

@@ -0,0 +1,3 @@
+import type { kv } from "@agentorg/interfaces";
+import type { Slot } from "@agentorg/sdk";
+export declare function createLocalStore(dir: string): Slot<typeof kv>["call"];

package/dist/node_modules/assistant/dist/src/local-store.js

@@ -0,0 +1,58 @@
+/**
+ * The engine's record when it runs as an ordinary program: one small JSON file per key, in the
+ * agent's own folder. A new message writes one file, however long the record is, and each write
+ * lands whole. It answers as `kv@1` does, so the history reads it as it reads any store.
+ */
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const missing = (error) => error.code === "ENOENT";
+export function createLocalStore(dir) {
+    const keys = join(dir, "kv");
+    const scratch = join(dir, "tmp");
+    const pathOf = (key) => join(keys, encodeURIComponent(key));
+    return {
+        async get({ key }) {
+            try {
+                return { value: JSON.parse(await readFile(pathOf(key), "utf8")) };
+            }
+            catch (error) {
+                if (missing(error))
+                    return {};
+                throw error;
+            }
+        },
+        async set({ key, value }) {
+            await mkdir(keys, { recursive: true, mode: 0o700 });
+            await mkdir(scratch, { recursive: true, mode: 0o700 });
+            const temporary = join(scratch, randomUUID());
+            await writeFile(temporary, JSON.stringify(value), { mode: 0o600, flush: true });
+            await rename(temporary, pathOf(key));
+            return {};
+        },
+        async delete({ key }) {
+            try {
+                await rm(pathOf(key));
+                return { deleted: true };
+            }
+            catch (error) {
+                if (missing(error))
+                    return { deleted: false };
+                throw error;
+            }
+        },
+        async list({ prefix = "", after, limit = 1000 }) {
+            const names = await readdir(keys).catch((error) => {
+                if (missing(error))
+                    return [];
+                throw error;
+            });
+            const found = names
+                .map(decodeURIComponent)
+                .filter((key) => key.startsWith(prefix) && (after === undefined || key > after))
+                .sort();
+            const page = found.slice(0, limit);
+            return { keys: page, next: found.length > limit ? (page.at(-1) ?? null) : null };
+        },
+    };
+}

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

@@ -0,0 +1,21 @@
+import { type Log } from "@agentorg/sdk";
+export interface AgentProviderOptions {
+    hubUrl: string;
+    /** The provider's own Actor, bound to `hub.actors@1` at `actors` and to the model at `model`. */
+    actorId: string;
+    credential: string;
+    /** The export its `model` slot is bound to, which each agent it makes is bound to in turn. */
+    model: {
+        actor: string;
+        export: string;
+    };
+    /** A private folder of the provider's, which holds each agent's credential and record. */
+    dir: string;
+    log?: Log;
+}
+export interface AgentProvider {
+    /** Leave the Hub and stop every agent. They stay, and those not stopped resume at the next start. */
+    close(): Promise<void>;
+}
+/** Run the bundled agent provider as an Actor exporting `agent.provider@1` as `provider`. */
+export declare function startAgentProvider(options: AgentProviderOptions): Promise<AgentProvider>;

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

@@ -0,0 +1,231 @@
+/**
+ * The bundled agent provider: it offers one creatable, Assistant, and runs each agent in this
+ * process as its own Actor on its own channel. Stopping an agent closes its channel; starting it
+ * opens one. Each agent's record and model choice are kept in the provider's private folder.
+ */
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { agentProvider, agentSettings, chat, hubActors, llmSession } from "@agentorg/interfaces";
+import { Refused } from "@agentorg/sdk";
+import { connect } from "@agentorg/sdk/client";
+import { z } from "zod";
+import { startEngine } from "./engine.js";
+import { createLocalStore } from "./local-store.js";
+const ASSISTANT_INSTRUCTIONS = `You are an assistant in AgentOrg, working for the person who created you.
+You act only through your tools, and your tools are exactly the connections the person gave you. If something needs a connection you don't have, say which.
+Before you promise to do something, check that one of your tools does it. A connection you are given later shows up as new tools at your next turn; until then, don't say you can use it.
+Keep replies short and plain.`;
+const ASSISTANT = {
+    id: "assistant",
+    title: "Assistant",
+    description: "An agent that chats, and acts through the connections you give it.",
+    instructions: ASSISTANT_INSTRUCTIONS,
+    asks: [],
+    skills: [],
+    mcp: [],
+};
+/** What is kept of an agent between runs, in the provider's private file. */
+const Stored = z.object({ credential: z.string(), stopped: z.boolean() });
+const FILE = "agents.json";
+const quiet = { info() { }, warn() { }, error() { } };
+/** Run the bundled agent provider as an Actor exporting `agent.provider@1` as `provider`. */
+export async function startAgentProvider(options) {
+    const log = options.log ?? quiet;
+    const { hubUrl, dir } = options;
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    const path = join(dir, FILE);
+    const folderOf = (agent) => join(dir, "agents", agent);
+    /** The file; one that can't be read is set aside, so the agents in it can be recovered by hand. */
+    const read = () => {
+        let raw;
+        try {
+            raw = readFileSync(path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return {};
+            throw error;
+        }
+        try {
+            return z.record(z.string(), Stored).parse(JSON.parse(raw));
+        }
+        catch {
+            renameSync(path, `${path}.unreadable-${Date.now()}`);
+            log.error("The agents file can't be read: it is set aside and starts empty.");
+            return {};
+        }
+    };
+    const stored = read();
+    const save = () => {
+        writeFileSync(`${path}.tmp`, JSON.stringify(stored), { mode: 0o600, flush: true });
+        renameSync(`${path}.tmp`, path);
+    };
+    const agents = new Map();
+    let closing = false;
+    const held = (agent) => {
+        const found = agents.get(agent);
+        if (!found)
+            throw new Refused("unknown", `This provider made no agent ${agent}.`);
+        return found;
+    };
+    const inTurn = (agent, work) => {
+        const one = held(agent);
+        const done = one.queue.then(() => work(one));
+        one.queue = done.catch(() => { });
+        return done;
+    };
+    /** Join the Hub as the agent, with its engine running. */
+    const open = async (agent, one) => {
+        one.state = "starting";
+        delete one.detail;
+        let engine;
+        try {
+            const channel = await connect({
+                hubUrl,
+                actorId: agent,
+                credential: stored[agent].credential,
+                slots: { model: llmSession, settings: agentSettings },
+                exports: { chat },
+                log,
+                start(ctx) {
+                    engine = startEngine(ctx, {
+                        store: createLocalStore(folderOf(agent)),
+                        instructions: () => ASSISTANT_INSTRUCTIONS,
+                    });
+                },
+            });
+            one.channel = channel;
+            one.engine = engine;
+            one.state = "running";
+            void channel.closed.then(() => {
+                if (one.channel !== channel)
+                    return;
+                delete one.channel;
+                one.state = "down";
+                one.detail = "Its connection to the Hub ended.";
+            });
+        }
+        catch (error) {
+            one.state = "down";
+            one.detail = error instanceof Error ? error.message : String(error);
+            throw error;
+        }
+    };
+    /** Cut its turn, close its channel, and wait until its engine has written all it will. */
+    const halt = async (one) => {
+        const { channel, engine } = one;
+        delete one.channel;
+        if (!channel || !engine)
+            return;
+        await engine.cancel();
+        channel.close();
+        await channel.closed;
+        await engine.settled();
+    };
+    await Promise.all(Object.entries(stored).map(async ([agent, { stopped }]) => {
+        const one = { state: "stopped", queue: Promise.resolve() };
+        agents.set(agent, one);
+        if (stopped)
+            return;
+        try {
+            await open(agent, one);
+        }
+        catch (error) {
+            log.error(`Agent ${agent} didn't rejoin the Hub: ${String(error)}`);
+            // The Hub no longer knows it: its Actor was closed while the provider was away.
+            if (error instanceof Refused && error.code === "forbidden") {
+                agents.delete(agent);
+                delete stored[agent];
+                save();
+            }
+        }
+    }));
+    const haltAll = () => Promise.all([...agents.keys()].map((agent) => inTurn(agent, halt).catch(() => { })));
+    const provider = await connect({
+        hubUrl,
+        actorId: options.actorId,
+        credential: options.credential,
+        slots: { actors: hubActors, model: llmSession },
+        exports: { provider: agentProvider },
+        log,
+        start(ctx) {
+            ctx.exports.provider.implement({
+                creatable: async () => ({ creatables: [ASSISTANT] }),
+                skill: async ({ creatable, name, path: file }) => {
+                    throw new Refused("unknown", `${creatable} has no file ${file} of a skill ${name}.`);
+                },
+                async create({ creatable, name }) {
+                    if (creatable !== ASSISTANT.id)
+                        throw new Refused("unknown", `This provider offers no ${creatable}.`);
+                    // The provider is bound to the model's export, so it can give the agent that binding.
+                    const { actorId: agent, credential } = await ctx.slots.actors.call.create({
+                        name,
+                        bindings: [
+                            { slot: "model", provider: options.model.actor, export: options.model.export },
+                        ],
+                    });
+                    const one = { state: "starting", queue: Promise.resolve() };
+                    try {
+                        stored[agent] = { credential: credential, stopped: false };
+                        await open(agent, one);
+                        if (closing)
+                            throw new Refused("unavailable", "This provider is stopping.");
+                        agents.set(agent, one);
+                        save();
+                    }
+                    catch (error) {
+                        delete stored[agent];
+                        await halt(one);
+                        await ctx.slots.actors.call.close({ actorId: agent }).catch(() => { });
+                        await rm(folderOf(agent), { recursive: true, force: true });
+                        throw error;
+                    }
+                    return { agent, settings: "settings", chat: "chat" };
+                },
+                status: async ({ agent }) => {
+                    const { state, detail } = held(agent);
+                    return { state, ...(detail ? { detail } : {}) };
+                },
+                start: ({ agent }) => inTurn(agent, async (one) => {
+                    if (one.state === "running")
+                        return {};
+                    stored[agent].stopped = false;
+                    save();
+                    await open(agent, one);
+                    return {};
+                }),
+                stop: ({ agent }) => inTurn(agent, async (one) => {
+                    stored[agent].stopped = true;
+                    save();
+                    await halt(one);
+                    one.state = "stopped";
+                    delete one.detail;
+                    return {};
+                }),
+                remove: ({ agent }) => inTurn(agent, async (one) => {
+                    await halt(one);
+                    one.state = "down";
+                    one.detail = "It is being removed.";
+                    await ctx.slots.actors.call.close({ actorId: agent });
+                    agents.delete(agent);
+                    delete stored[agent];
+                    save();
+                    await rm(folderOf(agent), { recursive: true, force: true });
+                    return {};
+                }),
+            });
+        },
+    }).catch(async (error) => {
+        await haltAll();
+        throw error;
+    });
+    return {
+        async close() {
+            closing = true;
+            await haltAll();
+            provider.close();
+        },
+    };
+}

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

@@ -0,0 +1,17 @@
+/**
+ * What the `settings` slot adds to a request: the skills exposed to this agent, named in its
+ * instructions, and one tool to read them. A skill's text is read only when the model asks for it.
+ */
+import type { agentSettings, SkillEntry } from "@agentorg/interfaces";
+import type { Slot } from "@agentorg/sdk";
+import type { z } from "zod";
+import type { Candidate, LeftOut } from "./tools.js";
+/** The longest instructions a request can carry. */
+export declare const MAX_INSTRUCTIONS = 200000;
+/** The agent's instructions and the skills that fit in them; any that don't are reported. */
+export declare function instructionsWith(instructions: string, skills: z.output<typeof SkillEntry>[]): {
+    instructions: string;
+    leftOut: LeftOut[];
+};
+/** The one way the model reads a skill: its `SKILL.md`, or a file of its folder by `path`. */
+export declare function skillTool(slot: Slot<typeof agentSettings>): Candidate;