@agentorg/cli 0.0.8 → 0.0.9

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

@@ -17,18 +17,30 @@ export const Entry = z.object({
     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. */
+    /**
+     * For a user message said while a turn was running, or while a stopped turn was still writing:
+     * it is part of that turn. Also for what the main loop said in a thread, taken with such
+     * messages or said as it stopped the turn: it stays in its place among them.
+     */
     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.
+     * was said after that, or the main loop said it stopped the turn: the model reads it ahead of
+     * those, 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(),
+    /**
+     * For what the main loop said itself, which no piece of work said: the number in its thread it
+     * stands after, ahead of any said after that. For a reply that is the number it had read up to;
+     * for what it said as it stopped a piece of work, all the thread held then.
+     */
+    main: z.number().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 is where it stands in its thread: its number, or for what the main loop said, right
+     * after the number that names.
      */
     place: z.number().optional(),
 });
@@ -109,6 +121,17 @@ export const userEntry = (text) => ({
     role: "user",
     items: [{ type: "message", role: "user", content: text }],
 });
+/** What the main loop said, as it is kept: it stands after `after`, a number in its thread. */
+const mainEntry = (text, after) => ({
+    role: "assistant",
+    main: after,
+    items: [{ type: "message", role: "assistant", content: text }],
+});
+/**
+ * Where a message stands in its thread: its number, but what the main loop said stands right
+ * after the number it names, ahead of a message said while it answered.
+ */
+const orderOf = ({ seq, entry }) => (entry.main === undefined ? seq : entry.main + 0.5);
 /** A thread's messages in a store, by their numbers. */
 export function createThread(store, log, limits = { keep: KEEP, keepBytes: KEEP_BYTES }) {
     let loaded;
@@ -154,76 +177,97 @@ export function createThread(store, log, limits = { keep: KEEP, keepBytes: KEEP_
         });
         return attempt;
     };
+    /**
+     * 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.
+     */
+    const 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 };
+    };
     return {
         /** What it holds, read once. */
         load,
+        push,
         /**
-         * 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.
+         * What was said in it, as a conversation: each message and each reply the main loop gave, in
+         * the order they were answered; and the number it holds up to.
          */
-        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 };
+        async said() {
+            const held = await load();
+            const said = held.records
+                .filter(({ entry }) => entry.role !== "tool")
+                .sort((a, b) => orderOf(a) - orderOf(b))
+                .map(({ entry }) => ({ role: entry.role, text: textOf(entry) }));
+            return { said, upTo: held.last };
+        },
+        /**
+         * Keep, under `id`, a reply the main loop gave after it had read up to `upTo`. `late` says
+         * whether a message was said after that, which this reply doesn't answer.
+         */
+        async answer(text, upTo, id) {
+            const held = await load();
+            const { record, stored } = push(held, mainEntry(text, upTo), id);
+            await stored;
+            const late = held.records.some(({ seq, entry }) => seq > upTo && entry.role === "user");
+            return { entry: record.entry, late };
         },
         /**
-         * 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.
+         * Hold a message as `entry` from now on, in memory: `store` writes it as it then is, and
+         * `undo` puts it back as it was.
          */
-        async rewrite(held, record, entry) {
+        change(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;
-            }
+            return {
+                store: () => store.set({ key: record.key, value: record.entry }),
+                undo: () => swap(was),
+            };
         },
         /** Messages before `before`, oldest first, as many as fit `limit` and `PAGE_BUDGET`. */
         async page(before, limit) {
@@ -250,14 +294,14 @@ export function createThread(store, log, limits = { keep: KEEP, keepBytes: KEEP_
 /**
  * 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
+ * any other thread, the messages that name it are. A message's place is where it stands 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 placeOf = (record) => record.entry.place ?? orderOf(record);
     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 () => {
@@ -272,10 +316,7 @@ export function createRecord(options) {
      */
     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;
+        return records.sort((a, b) => placeOf(a.record) - placeOf(b.record));
     };
     /** The highest place among its messages. */
     const topOf = (records) => {
@@ -284,63 +325,93 @@ export function createRecord(options) {
     };
     /**
      * 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.
+     * `written` settles when each is stored, or rejects with the first that isn't, which stays
+     * waiting with those after it. Like a message being written, the model is sent none of them
+     * until that has settled.
      */
     const take = (held, thread, joined) => {
         const from = held.get(thread);
-        const waiting = thread === id ? [] : from.records.filter(({ entry }) => !entry.work);
+        const waiting = thread === id
+            ? []
+            : from.records.filter(({ entry }) => !entry.work).sort((a, b) => orderOf(a) - orderOf(b));
         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)
+        // Each gets its place in the order it was said and answered: at once in memory.
+        const changes = waiting.map((record) => {
             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 options.thread(thread).change(from, record, {
+                ...record.entry,
+                work: id,
+                place: ++top,
+                ...(joined ? { joined: true } : {}),
+            });
         });
+        // Stored one after another in that order, so what a crash or a refusal leaves taken is the
+        // start of them: the rest stay waiting, and are taken after it.
+        const written = (async () => {
+            try {
+                for (const [i, change] of changes.entries())
+                    await change.store().catch((error) => {
+                        for (const rest of changes.slice(i))
+                            rest.undo();
+                        throw error;
+                    });
+            }
+            finally {
+                for (const record of waiting)
+                    record.writing = false;
+            }
+        })();
         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));
+    /** Whether a user message of its, stored already, follows the place `read`. */
+    const saidAfter = (records, read) => records.some(({ record }) => record.entry.role === "user" && placeOf(record) > read && !record.writing);
+    /**
+     * Whether something the model reads after what a request made stands past the place `read`,
+     * which that request had read up to: a user message, or what the main loop said as it stopped
+     * the turn.
+     */
+    const heldBack = (records, read) => records.some(({ record }) => placeOf(record) > read && (record.entry.role === "user" || record.entry.joined === true));
     /** 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;
+    /** Keep an entry of its in `thread`, made once nothing waits there, from what the thread holds. */
+    const keep = async (thread, make, at) => {
+        const held = await load();
+        const from = held.get(thread);
+        // 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.
+        const joins = make(from).joined === true || at.read !== undefined;
+        await take(held, thread, joins).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(from, {
+            ...make(from),
+            ...(thread === id ? {} : { work: id }),
+            ...(held.size > 1 ? { place: topOf(records) + 1 } : {}),
+            ...(at.read !== undefined && heldBack(records, at.read) ? { ahead: at.read } : {}),
+        }, at.id);
+        await stored;
+        return { entry: record.entry, thread };
+    };
     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.
+         * message was said since, or the turn was stopped by saying so, it is kept as `ahead` of
+         * that.
          */
-        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 };
-        },
+        append: (entry, at) => keep(at.thread, () => entry, at),
+        /**
+         * Keep in `thread` what the main loop said as it stopped a turn of this work. It stands after
+         * all the thread holds, and like a message said in that turn, the work reads it after
+         * whatever the turn still writes.
+         */
+        stopLine: (text, thread) => keep(thread, (from) => ({ ...mainEntry(text, from.last), joined: true }), {}),
         /**
          * 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.
+         * when a turn of its is running or a stopped one is still writing. It says how many there were to answer: in its own thread,
+         * where nothing needs taking, those said since it last did anything itself.
          */
         async adopt(thread, joined) {
             const held = await load();
@@ -349,12 +420,20 @@ export function createRecord(options) {
             if (thread !== id)
                 return taken;
             const records = own(held);
-            const done = records.findLastIndex(({ record }) => record.entry.role !== "user");
-            return records.length - 1 - done;
+            const done = records.findLastIndex(({ record: { entry } }) => entry.role !== "user" && entry.main === undefined);
+            return records.slice(done + 1).filter(({ record }) => record.entry.role === "user").length;
         },
-        /** Whether it holds anything but what was said to it: it has had a turn that did something. */
+        /**
+         * Whether it has had a turn that did something: it holds more than what was said to it and
+         * what the main loop said.
+         */
         async begun() {
-            return own(await load()).some(({ record }) => record.entry.role !== "user");
+            return own(await load()).some(({ record: { entry } }) => entry.role !== "user" && entry.main === undefined);
+        },
+        /** What it last said, if anything. */
+        async last() {
+            const said = own(await load()).findLast(({ record: { entry } }) => entry.role === "assistant" && entry.main === undefined);
+            return said ? textOf(said.record.entry) : undefined;
         },
         /** Whether it has no message. */
         async empty() {
@@ -370,7 +449,7 @@ export function createRecord(options) {
             return first ? textOf(first.record.entry) : "";
         },
         /**
-         * The conversation to send: the newest exchanges (each from the user message that starts a turn
+         * The conversation to send: the newest exchanges (each from a user message that is not `joined`
          * 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
@@ -427,7 +506,7 @@ export function createRecord(options) {
         },
         /** 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);
+            return saidAfter(own(await load()), read);
         },
     };
 }