@agentorg/cli 0.0.6 → 0.0.8

package/dist/node_modules/@agentorg/looper/dist/src/record.js

@@ -0,0 +1,433 @@
+/**
+ * What a loop runs on, kept in a store. A thread keeps its messages, one key each: the items a
+ * model reads for it, and for a tool message the line a person sees. A thread is read once, then
+ * kept in memory, and its oldest messages are deleted past a retention cap. A piece of work reads
+ * its context from the threads it follows: each message is kept once, in the thread where it is
+ * shown, and says which work it belongs to when that isn't its thread's own.
+ */
+import { z } from "zod";
+import { Item } from "./types.js";
+/** A message as the record keeps it. */
+export 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(),
+    /** For a user message said while a turn was running: it is part of that turn. */
+    joined: z.literal(true).optional(),
+    /**
+     * For what came of a model request that had read its work up to this place, when a user message
+     * was said after that: the model reads it ahead of that message, which it doesn't answer.
+     */
+    ahead: z.number().optional(),
+    /** The piece of work it belongs to, when that isn't its thread's own. */
+    work: z.string().optional(),
+    /**
+     * Its place in its work's order, once that work follows more than one thread. Without it, its
+     * place is its number in its thread.
+     */
+    place: z.number().optional(),
+});
+/** Where a record's messages are kept in its store. */
+export const MESSAGES = "msg/";
+const keyOf = (seq) => `${MESSAGES}${String(seq).padStart(12, "0")}`;
+const seqOf = (key) => Number(key.slice(MESSAGES.length)) || 0;
+// The record's limits are fixed here for now, sized for a host that carries a model request, or a
+// page of messages, in one piece of about a megabyte.
+/** 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 page of messages stays under this, so whatever carries it can do so in one piece. */
+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 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 it is shown. 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 values read at once when what is kept is first loaded. */
+export const READS = 16;
+/** A user message as it is kept when said. */
+export const userEntry = (text) => ({
+    role: "user",
+    items: [{ type: "message", role: "user", content: text }],
+});
+/** A thread's messages in a store, by their numbers. */
+export function createThread(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: MESSAGES,
+                    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 its store.
+                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, seqOf(key));
+                        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 = { seq: seqOf(key), 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 {
+        /** What it holds, read once. */
+        load,
+        /**
+         * Keep a message in a thread already read, at once, under `id` or its own number; `stored`
+         * settles when it is written and the oldest past the cap are deleted. A tool message the store
+         * refuses is still kept in memory, since its call has run; any other is taken out again.
+         */
+        push(held, entry, id) {
+            const seq = ++held.last;
+            const key = keyOf(seq);
+            const record = {
+                seq,
+                key,
+                entry: kept({
+                    id: id ?? key.slice(MESSAGES.length),
+                    at: new Date().toISOString(),
+                    ...entry,
+                }),
+                bytes: 0,
+                writing: entry.role === "user",
+            };
+            record.bytes = size(record.entry);
+            held.records.push(record);
+            held.bytes += record.bytes;
+            const stored = (async () => {
+                try {
+                    await store.set({ key, value: record.entry });
+                    record.writing = false;
+                }
+                catch (error) {
+                    if (entry.role !== "tool") {
+                        held.records.splice(held.records.indexOf(record), 1);
+                        held.bytes -= record.bytes;
+                        throw error;
+                    }
+                    log.error("A tool message couldn't be stored; it is kept until a restart.", {
+                        error: String(error),
+                    });
+                }
+                while (held.records.length > 1 &&
+                    (held.records.length > limits.keep || held.bytes > limits.keepBytes)) {
+                    const oldest = held.records.shift();
+                    held.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, stored };
+        },
+        /**
+         * Keep a message as `entry` from now on: at once in memory, then in the store. A write the
+         * store refuses leaves it as it was.
+         */
+        async rewrite(held, record, entry) {
+            const was = { entry: record.entry, bytes: record.bytes };
+            const swap = (to) => {
+                held.bytes += to.bytes - record.bytes;
+                Object.assign(record, to);
+            };
+            swap({ entry, bytes: size(entry) });
+            try {
+                await store.set({ key: record.key, value: entry });
+            }
+            catch (error) {
+                swap(was);
+                throw error;
+            }
+        },
+        /** Messages before `before`, oldest first, as many as fit `limit` and `PAGE_BUDGET`. */
+        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 };
+        },
+    };
+}
+/**
+ * A piece of work's record: its messages across the threads it follows, in the order it took them.
+ * Its id is the name of its own thread, whose messages are its unless they name another work; in
+ * any other thread, the messages that name it are. A message's place is its number in its own
+ * thread until the work follows a second thread, and a count kept with each message after. A
+ * message waiting in a thread it follows, said before the work had the thread, names no work yet:
+ * the work takes it, in the order it was said, before it keeps anything else there.
+ */
+export function createRecord(options) {
+    const { id } = options;
+    const placeOf = (record) => record.entry.place ?? record.seq;
+    const mine = (thread, record) => record.entry.work === undefined ? thread === id : record.entry.work === id;
+    /** Every thread it follows, read: what each holds, as it changes. */
+    const load = async () => {
+        const held = new Map();
+        for (const name of options.follows())
+            held.set(name, await options.thread(name).load());
+        return held;
+    };
+    /**
+     * Its own messages in the threads read, in order, as they stand now. Nothing waits between
+     * this and what is decided from it.
+     */
+    const own = (held) => {
+        const records = [...held].flatMap(([thread, { records }]) => records.flatMap((record) => (mine(thread, record) ? [{ thread, record }] : [])));
+        // One thread's messages are in order already.
+        if (held.size > 1)
+            records.sort((a, b) => placeOf(a.record) - placeOf(b.record));
+        return records;
+    };
+    /** The highest place among its messages. */
+    const topOf = (records) => {
+        const last = records.at(-1);
+        return last ? placeOf(last.record) : 0;
+    };
+    /**
+     * Take the messages waiting in `thread` as its own, after all it holds: at once in memory, and
+     * `written` settles when each is stored, or rejects with one that isn't and stays waiting. Like
+     * a message being written, the model is sent none of them until all are stored.
+     */
+    const take = (held, thread, joined) => {
+        const from = held.get(thread);
+        const waiting = thread === id ? [] : from.records.filter(({ entry }) => !entry.work);
+        let top = topOf(own(held));
+        const writes = waiting.map((record) => options.thread(thread).rewrite(from, record, {
+            ...record.entry,
+            work: id,
+            place: ++top,
+            ...(joined && record.entry.role === "user" ? { joined: true } : {}),
+        }));
+        for (const record of waiting)
+            record.writing = true;
+        const written = Promise.allSettled(writes).then((all) => {
+            for (const record of waiting)
+                record.writing = false;
+            const refused = all.find((one) => one.status === "rejected");
+            if (refused)
+                throw refused.reason;
+        });
+        return { taken: waiting.length, written };
+    };
+    /** Whether a user message of its follows the place `read`: one `stored` already, when asked. */
+    const saidAfter = (records, read, stored = false) => records.some(({ record }) => record.entry.role === "user" && placeOf(record) > read && !(stored && record.writing));
+    /** The thread of its newest user message: where it answers. Its own, with none. */
+    const whereOf = (records) => records.findLast(({ record }) => record.entry.role === "user")?.thread ?? id;
+    return {
+        id,
+        /**
+         * Keep a message of its in `thread`, one of those it follows, after any waiting there. `read`
+         * is given for what came of a model request that had read it up to that place: when a user
+         * message was said since, it is kept as `ahead` of it.
+         */
+        async append(entry, at) {
+            const held = await load();
+            const { thread } = at;
+            // What waits there is taken and stored first, so this is never kept ahead of it: it joins
+            // a turn if this does, or comes of one. If the store won't take it, nothing is kept.
+            await take(held, thread, entry.joined === true || at.read !== undefined).written;
+            // From here to the push nothing waits, so its place and what is ahead of it are decided
+            // with the record as it stands.
+            const records = own(held);
+            const { record, stored } = options.thread(thread).push(held.get(thread), {
+                ...entry,
+                ...(thread === id ? {} : { work: id }),
+                ...(held.size > 1 ? { place: topOf(records) + 1 } : {}),
+                ...(at.read !== undefined && saidAfter(records, at.read) ? { ahead: at.read } : {}),
+            }, at.id);
+            await stored;
+            return { entry: record.entry, thread };
+        },
+        /**
+         * Take the messages waiting in `thread`, which it has come to follow, as its own: `joined`,
+         * when a turn of its is running. It says how many there were to answer: in its own thread,
+         * where nothing needs taking, those said since it last did anything.
+         */
+        async adopt(thread, joined) {
+            const held = await load();
+            const { taken, written } = take(held, thread, joined);
+            await written;
+            if (thread !== id)
+                return taken;
+            const records = own(held);
+            const done = records.findLastIndex(({ record }) => record.entry.role !== "user");
+            return records.length - 1 - done;
+        },
+        /** Whether it holds anything but what was said to it: it has had a turn that did something. */
+        async begun() {
+            return own(await load()).some(({ record }) => record.entry.role !== "user");
+        },
+        /** Whether it has no message. */
+        async empty() {
+            return own(await load()).length === 0;
+        },
+        /** The thread it answers in now. */
+        async where() {
+            return whereOf(own(await load()));
+        },
+        /** Its first user message, for a title. */
+        async opening() {
+            const first = own(await load()).find(({ record }) => record.entry.role === "user");
+            return first ? textOf(first.record.entry) : "";
+        },
+        /**
+         * The conversation to send: the newest exchanges (each from the user message that starts a turn
+         * on) that fit the budget, and always the latest two, so "go on" after a long turn still has
+         * that turn. When those two are over the budget, their oldest function arguments and outputs
+         * are left out, each call still paired with an output. A message said during a turn comes after
+         * whatever is `ahead` of it, so the model reads it as not yet answered. `read` is the place up
+         * to which every user message was read, for `append` and `saidAfter`: one still being written
+         * is not read yet. `thread` is where what comes of it is kept.
+         */
+        async input() {
+            const records = own(await load());
+            const last = topOf(records);
+            const unwritten = records.find(({ record }) => record.writing);
+            const read = unwritten ? placeOf(unwritten.record) - 1 : last;
+            const exchanges = [];
+            /** Said during a turn, and not yet put: what is ahead of them goes first. */
+            const late = [];
+            const put = (entry) => {
+                if ((entry.role === "user" && !entry.joined) || exchanges.length === 0)
+                    exchanges.push([]);
+                exchanges.at(-1)?.push(...entry.items);
+            };
+            /** Put the late messages placed up to `read`. */
+            const putLate = (read) => {
+                while (late[0] && placeOf(late[0]) <= read)
+                    put(late.shift().entry);
+            };
+            for (const { record } of records) {
+                // Nothing to send: a user message still being written, or a line with no items.
+                if (record.writing || record.entry.items.length === 0)
+                    continue;
+                if (record.entry.joined) {
+                    late.push(record);
+                    continue;
+                }
+                putLate(record.entry.ahead ?? last);
+                put(record.entry);
+            }
+            putLate(last);
+            let total = exchanges.reduce((sum, items) => sum + size(items), 0);
+            while (exchanges.length > 2 && 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, read, thread: whereOf(records.filter(({ record }) => !record.writing)) };
+        },
+        /** Whether a user message of its has been stored after the place `read`, which `input` gave. */
+        async saidAfter(read) {
+            return saidAfter(own(await load()), read, true);
+        },
+    };
+}

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

@@ -0,0 +1,11 @@
+/** Running the functions a model calls, and what is kept of their output. */
+import { type Outcome, type Tool } from "./types.js";
+/** A function's output keeps this many characters, so one result can't fill a request. */
+export declare const MAX_OUTPUT = 30000;
+/**
+ * `text`, or its first and last `MAX_OUTPUT / 2` characters with what was cut between them: a
+ * failing command's error is at the end, and what it was doing at the start.
+ */
+export declare function capped(text: string): string;
+/** Run a function call: the result, or the refusal, as the function's output. */
+export declare function runTool(tools: Tool[], name: string, args: string): Promise<Outcome>;

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

@@ -0,0 +1,42 @@
+/** Running the functions a model calls, and what is kept of their output. */
+import { codeOf } from "./types.js";
+/** A function's output keeps this many characters, so one result can't fill a request. */
+export const MAX_OUTPUT = 30_000;
+/**
+ * `text`, or its first and last `MAX_OUTPUT / 2` characters with what was cut between them: a
+ * failing command's error is at the end, and what it was doing at the start.
+ */
+export function capped(text) {
+    if (text.length <= MAX_OUTPUT)
+        return text;
+    // Between characters: never half of a surrogate pair at either cut.
+    const head = text.slice(0, MAX_OUTPUT / 2).replace(/[\uD800-\uDBFF]$/, "");
+    const tail = text.slice(-MAX_OUTPUT / 2).replace(/^[\uDC00-\uDFFF]/, "");
+    return `${head}\n… [${text.length - head.length - tail.length} characters cut] …\n${tail}`;
+}
+const failure = ({ code, message }) => JSON.stringify({ error: { code, message } });
+/** Run a function call: the result, or the refusal, as the function's output. */
+export async function runTool(tools, name, args) {
+    const refused = (code, message) => ({
+        output: failure({ code, message }),
+        ok: false,
+        code,
+    });
+    const found = tools.find((tool) => tool.name === name);
+    if (!found)
+        return refused("unknown_tool", `No tool is named ${name.slice(0, 64)}.`);
+    let input;
+    try {
+        input = args.trim() === "" ? {} : JSON.parse(args);
+    }
+    catch {
+        return refused("invalid", "The arguments aren't JSON.");
+    }
+    try {
+        return await found.run(input);
+    }
+    catch (error) {
+        const { code, message } = codeOf(error);
+        return refused(code, message);
+    }
+}

package/dist/node_modules/@agentorg/looper/dist/src/types.d.ts

@@ -0,0 +1,147 @@
+/**
+ * What the looper is given and what it gives back, in its own words. Whoever hosts it maps its own
+ * world onto these: the looper names no interface, no chat and no agent.
+ */
+import { z } from "zod";
+/** A JSON value. */
+export type Json = string | number | boolean | null | Json[] | {
+    [key: string]: Json;
+};
+/** One item of a conversation as a model reads it: something said, a function call, or its output. */
+export declare const Item: 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">;
+export type Item = z.output<typeof Item>;
+/** What a model gives back: something it says, or a function it calls. */
+export type OutputItem = Exclude<Item, {
+    type: "function_call_output";
+}>;
+/** A function the model may call, as a request describes it. */
+export interface ToolSpec {
+    name: string;
+    description?: string;
+    /** The JSON Schema of its arguments. */
+    parameters: Record<string, Json>;
+}
+/** How a function call ended, as the model and the record see it. */
+export interface Outcome {
+    output: string;
+    ok: boolean;
+    /** Why it didn't, when `ok` is false. */
+    code?: string;
+}
+/**
+ * A function the model may call, with the way to run it. `run` gets the call's arguments, parsed;
+ * what it throws is the call's output, as a refusal: with its code when it is a `Refusal`.
+ */
+export interface Tool extends ToolSpec {
+    run(input: unknown): Promise<Outcome>;
+}
+/**
+ * The model: one stateless answer to a whole conversation. A request that can't be answered rejects,
+ * with a `Refusal` when there is a code to show. Text it writes while it answers is given to the
+ * looper's `delta`, with the request's id.
+ */
+export interface Model {
+    respond(request: {
+        requestId: string;
+        model?: string;
+        instructions: string;
+        input: Item[];
+        tools: ToolSpec[];
+    }): Promise<{
+        output: OutputItem[];
+    }>;
+    /** Stop the answer to `requestId`, if it is still being made; its `respond` then rejects. */
+    cancel(request: {
+        requestId: string;
+    }): Promise<unknown>;
+}
+/** Where the looper keeps its records: values by key, listed in key order a page at a time. */
+export interface Store {
+    get(input: {
+        key: string;
+    }): Promise<{
+        value?: Json | undefined;
+    }>;
+    set(input: {
+        key: string;
+        value: Json;
+    }): Promise<unknown>;
+    delete(input: {
+        key: string;
+    }): Promise<unknown>;
+    list(input: {
+        prefix?: string;
+        after?: string;
+        limit?: number;
+    }): Promise<{
+        keys: string[];
+        next: string | null;
+    }>;
+}
+/** Where the looper says what an operator may want to know; nothing a thread shows. */
+export interface Log {
+    info(message: string, fields?: Record<string, unknown>): void;
+    warn(message: string, fields?: Record<string, unknown>): void;
+    error(message: string, fields?: Record<string, unknown>): void;
+}
+/**
+ * A message as a thread shows it. A `tool` message tells what the loop did: with `tool`, the call
+ * it stands for, said as `running` when it starts and again under the same id when it ends;
+ * without, its `text` says it in one line, as for calls that never ran or a turn that goes on
+ * after it was cut off.
+ */
+export interface Shown {
+    id: string;
+    role: "user" | "assistant" | "tool";
+    text: string;
+    /** An ISO 8601 time. */
+    at: string;
+    tool?: {
+        name: string;
+        state: "running" | "done" | "refused";
+        input?: string;
+        output?: string;
+    };
+}
+/** What a loop is doing. On `error`, `detail.code` is the refusal's code. */
+export type Status = {
+    state: "idle" | "thinking" | "tool";
+} | {
+    state: "error";
+    detail: {
+        code: string;
+        message: string;
+    };
+};
+/**
+ * Something refused, with a stable code a host can show or map. A host that refuses for a reason of
+ * its own can keep that reason as the `cause`.
+ */
+export declare class Refusal extends Error {
+    readonly name = "Refusal";
+    readonly code: string;
+    constructor(code: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** The code and message of anything a call or a turn can throw. */
+export declare function codeOf(error: unknown): {
+    code: string;
+    message: string;
+};

package/dist/node_modules/@agentorg/looper/dist/src/types.js

@@ -0,0 +1,32 @@
+/**
+ * What the looper is given and what it gives back, in its own words. Whoever hosts it maps its own
+ * world onto these: the looper names no interface, no chat and no agent.
+ */
+import { z } from "zod";
+/** What one text of a model request can hold, and one name in it. */
+const Text = z.string().max(200_000);
+const Name = z.string().min(1).max(256);
+/** One item of a conversation as a model reads it: something said, a function call, or its output. */
+export const Item = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("message"), role: z.enum(["user", "assistant"]), content: Text }),
+    z.object({ type: z.literal("function_call"), callId: Name, name: Name, arguments: Text }),
+    z.object({ type: z.literal("function_call_output"), callId: Name, output: Text }),
+]);
+/**
+ * Something refused, with a stable code a host can show or map. A host that refuses for a reason of
+ * its own can keep that reason as the `cause`.
+ */
+export class Refusal extends Error {
+    name = "Refusal";
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+/** The code and message of anything a call or a turn can throw. */
+export function codeOf(error) {
+    if (error instanceof Refusal)
+        return { code: error.code, message: error.message };
+    return { code: "failed", message: "The call failed." };
+}