@agentorg/cli 0.0.6 → 0.0.8

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

@@ -0,0 +1,116 @@
+/**
+ * The main loop: one per looper. It is given the messages that have come in where no piece of
+ * work is listening, and says whose they are: new work, or work under way. It does none of the
+ * work and answers nobody. It has one function to call, and each decision is one model request
+ * that holds nothing of the decisions before it.
+ */
+import { head } from "./record.js";
+/** What the main loop is told. */
+export const MAIN_INSTRUCTIONS = `You are the front desk. You do none of the work and you answer nobody: you say whose a message is, by calling \`route\` once.
+
+You are given the pieces of work under way, each by its id and title, and what has come in where no work is listening yet.
+
+- Give it to a piece of work under way only when it points at that work explicitly: it names it, quotes it, or refers to what it is doing, and exactly one piece of work fits. Call \`route\` with that work's id. Its worker will read it with everything it already knows, and answer where it came in. From then on everything said there goes to that work.
+- Anything else is new work, also when it is on a subject like that of work under way. Call \`route\` with no \`work\`, and a \`title\` of a few words that says what the new work is.
+
+A wrong match stays, so when in doubt it is new work. Your only answer is the call.`;
+/** The one function the main loop calls. */
+export const ROUTE = {
+    name: "route",
+    description: "Says whose what came in is: a piece of work under way, or new work.",
+    parameters: {
+        type: "object",
+        properties: {
+            work: {
+                type: "string",
+                description: "The id of the work under way that it points at. Leave it out for new work.",
+            },
+            title: {
+                type: "string",
+                description: "For new work: a few words that say what it is.",
+            },
+        },
+    },
+};
+/** A work's title: the first line of `text` that says anything, in a few words. */
+export const titled = (text) => head((text.split("\n").find((line) => /\S/.test(line)) ?? "").replace(/\s+/g, " ").trim(), 80);
+/** The main loop is put the newest messages waiting, and the start of each: enough to place them. */
+const PUT = { messages: 8, each: 4000 };
+/** What has come in, as it is put to the main loop with the work under way. */
+export const put = (texts, underway) => [
+    underway.length === 0 ? "No work is under way." : "Work under way:",
+    ...underway.map(({ id, title }) => `- ${id}: ${title}`),
+    "",
+    "What came in:",
+    texts
+        .slice(-PUT.messages)
+        .map((text) => (text.length > PUT.each ? `${head(text, PUT.each)}…` : text))
+        .join("\n\n"),
+].join("\n");
+export function createMain(options) {
+    /** The decision being made now, and how to drop it. */
+    let deciding;
+    return {
+        /**
+         * Say whose `texts` are, given the work under way: one decision at a time. Nothing is said
+         * for a decision that is cancelled. A request the model refuses rejects, as it refused.
+         */
+        async route(texts, underway) {
+            let drop = () => { };
+            const dropped = new Promise((resolve) => {
+                drop = () => resolve(undefined);
+            });
+            const mine = { drop };
+            deciding = mine;
+            try {
+                const chosen = await Promise.race([options.chosen().then((model) => ({ model })), dropped]);
+                if (!chosen)
+                    return undefined;
+                mine.requestId = crypto.randomUUID();
+                const asked = options.model.respond({
+                    requestId: mine.requestId,
+                    ...(chosen.model ? { model: chosen.model } : {}),
+                    instructions: MAIN_INSTRUCTIONS,
+                    input: [{ type: "message", role: "user", content: put(texts, underway) }],
+                    tools: [ROUTE],
+                });
+                // A model that never answers a request it was told to cancel holds nothing up.
+                asked.catch(() => { });
+                const answer = await Promise.race([asked, dropped]);
+                if (!answer)
+                    return undefined;
+                const call = answer.output.find((item) => item.type === "function_call" && item.name === ROUTE.name);
+                let said = {};
+                if (call?.type === "function_call")
+                    try {
+                        said = (JSON.parse(call.arguments) ?? {});
+                    }
+                    catch {
+                        // Arguments that don't read: new work, as with no call.
+                    }
+                if (underway.some(({ id }) => id === said.work))
+                    return { work: said.work };
+                // Anything else starts new work, titled by what came in if the model gave no title.
+                if (typeof said.work === "string" && said.work !== "")
+                    options.log.warn("The main loop named work that isn't under way; it is new work.", {
+                        work: head(said.work, 128),
+                    });
+                const title = titled(typeof said.title === "string" ? said.title : "");
+                return { title: title || titled(texts.join("\n")) };
+            }
+            finally {
+                if (deciding === mine)
+                    deciding = undefined;
+            }
+        },
+        /** Drop the decision being made: its request is cancelled, and it says nothing. */
+        async cancel() {
+            const cut = deciding;
+            if (!cut)
+                return;
+            cut.drop();
+            if (cut.requestId)
+                await options.model.cancel({ requestId: cut.requestId }).catch(() => { });
+        },
+    };
+}

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

@@ -0,0 +1,181 @@
+/**
+ * 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, type Log, type Shown, type Store } from "./types.js";
+/** A message as the record keeps it. */
+export 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";
+    }>>;
+    joined: z.ZodOptional<z.ZodLiteral<true>>;
+    ahead: z.ZodOptional<z.ZodNumber>;
+    work: z.ZodOptional<z.ZodString>;
+    place: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type Entry = z.output<typeof Entry>;
+/** Where a record's messages are kept in its store. */
+export declare const MESSAGES = "msg/";
+/** 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 it is shown. 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): Shown;
+/** Stored values read at once when what is kept is first loaded. */
+export declare const READS = 16;
+/** A user message as it is kept when said. */
+export declare const userEntry: (text: string) => {
+    role: "user";
+    items: {
+        type: "message";
+        role: "user";
+        content: string;
+    }[];
+};
+/** A message as a thread holds it. */
+interface Kept {
+    /** Its number in its thread. */
+    seq: number;
+    key: string;
+    entry: Entry;
+    bytes: number;
+    /** Set while a user message is being written, or taken: the model is sent it once stored. */
+    writing?: boolean;
+}
+interface Held {
+    records: Kept[];
+    last: number;
+    bytes: number;
+}
+/** A thread's messages in a store, by their numbers. */
+export declare function createThread(store: Store, log: Log, limits?: {
+    keep: number;
+    keepBytes: number;
+}): {
+    /** What it holds, read once. */
+    load: () => Promise<Held>;
+    /**
+     * 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: Held, entry: Omit<Entry, "id" | "at">, id?: string): {
+        record: Kept;
+        stored: Promise<void>;
+    };
+    /**
+     * 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.
+     */
+    rewrite(held: Held, record: Kept, entry: Entry): Promise<void>;
+    /** Messages before `before`, oldest first, as many as fit `limit` and `PAGE_BUDGET`. */
+    page(before: string | undefined, limit: number): Promise<{
+        messages: Shown[];
+        more: boolean;
+    }>;
+};
+export type Thread = ReturnType<typeof createThread>;
+/**
+ * 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 declare function createRecord(options: {
+    id: string;
+    /** The threads it follows now, its own first. */
+    follows(): string[];
+    thread(name: string): Thread;
+}): {
+    id: string;
+    /**
+     * 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.
+     */
+    append(entry: Omit<Entry, "id" | "at" | "work" | "place" | "ahead">, at: {
+        thread: string;
+        id?: string;
+        read?: number;
+    }): Promise<{
+        entry: Entry;
+        thread: string;
+    }>;
+    /**
+     * 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.
+     */
+    adopt(thread: string, joined: boolean): Promise<number>;
+    /** Whether it holds anything but what was said to it: it has had a turn that did something. */
+    begun(): Promise<boolean>;
+    /** Whether it has no message. */
+    empty(): Promise<boolean>;
+    /** The thread it answers in now. */
+    where(): Promise<string>;
+    /** Its first user message, for a title. */
+    opening(): Promise<string>;
+    /**
+     * 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.
+     */
+    input(): Promise<{
+        items: Item[];
+        read: number;
+        thread: string;
+    }>;
+    /** Whether a user message of its has been stored after the place `read`, which `input` gave. */
+    saidAfter(read: number): Promise<boolean>;
+};
+export type LoopRecord = ReturnType<typeof createRecord>;
+export {};