@hachej/boring-agent 0.4.20 → 0.4.21

package/dist/room.js

@@ -287,19 +287,38 @@ export function createRoomTurn(options) {
         if (index >= 0)
             change(items, index);
     }, context);
-    /** Relay the run's frames and each new `ask_user` while the wake is open. */
-    async function follow(wakeId, from) {
+    /**
+     * Relay the run's frames and each new `ask_user` while the wake is open. A queued wake has no entry yet: its input
+     * lands when the earlier run is done, so follow from the start and learn `from` the first time its entry exists.
+     * Nothing is relayed before then, and never anything at or below the input's own entry (that is another wake's run).
+     * Text is relayed as growth: per entry the text length and step count already sent are remembered, only the rest goes.
+     */
+    async function follow(wakeId, known) {
         const watch = await conversation.watch(context);
-        const seen = new Set();
+        const sent = new Map();
+        let from = known;
         let queue = Promise.resolve();
         // Port calls are chained off the watch so a slow room never holds native frames.
         const relay = async (view) => {
-            const fresh = view.entries.filter(entry => entry.id > from && !seen.has(entry.id));
-            for (const entry of fresh)
-                seen.add(entry.id);
-            const frames = framesOf(fresh);
-            const questions = pendingQuestions(view.entries);
             queue = queue.then(async () => {
+                if (from === undefined)
+                    from = (await conversation.commit(tx => tx.submissionByRequest(conversation.id, requestId(wakeId)), context))?.entry;
+                if (from === undefined)
+                    return;
+                const own = view.entries.filter(entry => entry.id > from);
+                const frames = [];
+                for (const entry of own) {
+                    const before = sent.get(entry.id) ?? { text: 0, steps: 0 };
+                    const all = framesOf([entry]);
+                    const text = all.flatMap(frame => frame.type === 'text' ? [frame.text] : []).join('\n\n');
+                    const steps = all.filter(frame => frame.type === 'step');
+                    // Steps first: a tool call that began after the text belongs after it, but a lost order costs only polish.
+                    frames.push(...steps.slice(before.steps));
+                    if (text.length > before.text)
+                        frames.push({ type: 'text', text: text.slice(before.text) });
+                    sent.set(entry.id, { text: Math.max(before.text, text.length), steps: Math.max(before.steps, steps.length) });
+                }
+                const questions = pendingQuestions(own);
                 if (frames.length && port.stream)
                     await port.stream(wakeId, frames);
                 if (!port.question)
@@ -328,7 +347,8 @@ export function createRoomTurn(options) {
             // The same `requestId` returns the first submission: a resend or a restart never starts a second run.
             const submission = await conversation.submit({ type: 'input', requestId: requestId(wakeId), content: item.input, whenBusy: 'followUp' }, context);
             const placed = await conversation.commit(tx => tx.submissionByRequest(conversation.id, requestId(wakeId)), context);
-            const stop = placed?.entry === undefined || placed.status === 'done' || placed.status === 'unanswered' ? async () => { } : await follow(wakeId, placed.entry);
+            // A queued submission has no entry yet; it is followed all the same (see `follow`).
+            const stop = placed?.status === 'done' || placed?.status === 'unanswered' ? async () => { } : await follow(wakeId, placed?.entry);
             let record;
             try {
                 record = await submission.wait(context);
@@ -336,11 +356,13 @@ export function createRoomTurn(options) {
             finally {
                 await stop();
             }
-            // An unanswered run leaves the wake open: the room's resend cap closes it with its own line.
+            // An unanswered run is closed with the room's own line, never dropped: left open it would only wait for its resends.
             if (record.type === 'input' && record.status === 'done') {
                 const entry = (await conversation.entries({ minEntryId: record.answer, maxEntryId: record.answer }, 1, undefined, context)).items[0];
                 await port.settle(wakeId, { text: answerText(entry) });
             }
+            else if (record.type === 'input' && record.status === 'unanswered')
+                await port.settle(wakeId, { text: ROOM.unanswered });
             await update(wakeId, (items, index) => { items.splice(index, 1); });
         })().catch(report).finally(() => delivering.delete(wakeId));
         delivering.set(wakeId, run);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.4.20",
+  "version": "0.4.21",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -160,8 +160,8 @@
     "@earendil-works/pi-durable": "~1.2.0",
     "@earendil-works/pi-ai": "~1.2.0",
     "@earendil-works/chord": "~1.2.0",
-    "@hachej/boring-files": "^0.4.20",
-    "@hachej/boring-ui-kit": "^0.4.20",
+    "@hachej/boring-files": "^0.4.21",
+    "@hachej/boring-ui-kit": "^0.4.21",
     "xlsx": "^0.20.3"
   },
   "peerDependenciesMeta": {