@oharness/server 0.7.0 → 0.7.1

package/dist/server.js

@@ -204,7 +204,7 @@ export async function startWebServer(opts) {
     const makeRunner = (session, harness) => {
         const ledger = new ChangeLedger(session.cwd);
         ledger.attach(harness.hooks);
-        return { session, agent: harness.agent(session), harness, ledger };
+        return { session, agent: harness.agent(session), harness, ledger, queue: [] };
     };
     /** The runner a request names, or the most recently focused one. */
     let focused = opts.session.id;
@@ -2403,9 +2403,6 @@ export async function startWebServer(opts) {
                 if (!prompt && !ids.length && !references.length) {
                     return send(res, 400, { error: "prompt is required" });
                 }
-                // Per runner, not global: a turn in one tab must not block another.
-                if (runner.running)
-                    return send(res, 409, { error: "a turn is already running" });
                 const staged = ids
                     .map((id) => (typeof id === "string" ? attachments.get(id) : undefined))
                     .filter((entry) => Boolean(entry));
@@ -2416,6 +2413,19 @@ export async function startWebServer(opts) {
                 // a composer is known to have moved on, so it is a good moment to ask
                 // what else has been abandoned.
                 sweepAttachments();
+                // Per runner, not global: a turn in one tab must not block another.
+                // A second prompt into a busy runner waits, and is shown waiting. It
+                // is not handed to the running turn on its own: putting words in front
+                // of a model mid-thought is a thing to choose, not a thing that
+                // happens because you typed fast. /sendnow is that choice.
+                //
+                // This used to 409, and the page discarded the reply, so an impatient
+                // Enter cleared the composer and lost what had been typed.
+                if (runner.running) {
+                    runner.queue.push({ id: randomUUID(), prompt, staged, references });
+                    broadcastQueue(runner);
+                    return send(res, 202, { ok: true, queued: true });
+                }
                 void runTurn(runner, prompt, staged, references);
                 return send(res, 202, { ok: true, attached: staged.length, referenced: references.length });
             }
@@ -2451,6 +2461,84 @@ export async function startWebServer(opts) {
                     runnerFor(body.session)?.running?.abort();
                 }
                 return send(res, 200, { ok: true });
+            case "POST /unqueue": {
+                const body = await readJson(req);
+                const runner = runnerFor(body.session);
+                if (!runner)
+                    return send(res, 404, { error: "no such session" });
+                // Either kind: one handed to the running turn but not yet read, or
+                // one still waiting for the turn to end.
+                if (typeof body.id === "string" && runner.agent.retract(body.id)) {
+                    broadcastQueue(runner);
+                    return send(res, 200, { ok: true });
+                }
+                const at = runner.queue.findIndex((entry) => entry.id === body.id);
+                if (at >= 0) {
+                    // The bytes came out of the staging map when this was queued, so
+                    // they are held by the entry alone and go when it does.
+                    runner.queue.splice(at, 1);
+                    broadcastQueue(runner);
+                }
+                return send(res, 200, { ok: true });
+            }
+            /**
+             * One waiting message, now, without waiting for its place in the queue.
+             *
+             * While a turn runs that means handing it to the turn — the same path a
+             * prompt typed mid-turn takes — so it is read at the next gap rather
+             * than after the whole thing. Nothing is interrupted: "now" here is as
+             * soon as the conversation has a place to put it.
+             *
+             * A message carrying files cannot ride the inbox, so it moves to the
+             * head of the queue instead and the reply says so.
+             */
+            case "POST /sendnow": {
+                const body = await readJson(req);
+                const runner = runnerFor(body.session);
+                if (!runner)
+                    return send(res, 404, { error: "no such session" });
+                const at = runner.queue.findIndex((entry) => entry.id === body.id);
+                if (at < 0)
+                    return send(res, 404, { error: "no such queued message" });
+                const entry = runner.queue[at];
+                if (!runner.running) {
+                    runner.queue.splice(at, 1);
+                    broadcastQueue(runner);
+                    void runTurn(runner, entry.prompt, entry.staged, entry.references);
+                    return send(res, 202, { ok: true, sent: true });
+                }
+                const plain = entry.prompt && !entry.staged.length && !entry.references.length;
+                if (plain && runner.agent.interject(entry.prompt)) {
+                    runner.queue.splice(at, 1);
+                    broadcastQueue(runner);
+                    return send(res, 202, { ok: true, interjected: true });
+                }
+                // Cannot be handed over, so the most that can be done is to put it
+                // first in line for when the turn ends.
+                runner.queue.splice(at, 1);
+                runner.queue.unshift(entry);
+                broadcastQueue(runner);
+                return send(res, 200, { ok: true, moved: true });
+            }
+            /**
+             * Send what is waiting, now.
+             *
+             * The queue drains itself after a turn that ends on its own, but not
+             * after an interrupt or an error — stopping means stop, and a message
+             * typed before the failure should not fire into whatever caused it.
+             * This is how the page restarts a queue left standing that way.
+             */
+            case "POST /flush": {
+                const body = await readJson(req);
+                const runner = runnerFor(body.session);
+                if (!runner)
+                    return send(res, 404, { error: "no such session" });
+                if (runner.running)
+                    return send(res, 409, { error: "a turn is already running" });
+                if (!drainQueue(runner))
+                    return send(res, 200, { ok: true, sent: false });
+                return send(res, 202, { ok: true, sent: true });
+            }
             default:
                 return send(res, 404, { error: "not found" });
         }
@@ -2669,6 +2757,9 @@ export async function startWebServer(opts) {
             contextWindow: model.contextWindow,
             contextUsed: model.contextWindow ? Math.min(1, used / model.contextWindow) : undefined,
             busy: Boolean(runner.running),
+            // So a reload, or a second tab, sees what is still waiting. The queue
+            // lives on the runner rather than in the page for exactly this reason.
+            queued: queueView(runner),
         };
     }
     /**
@@ -2885,6 +2976,46 @@ export async function startWebServer(opts) {
         });
         return snapshot;
     }
+    /**
+     * What the page needs to draw the waiting chips, without the bytes.
+     *
+     * Interjections first, and marked as such: they reach the model during the
+     * running turn, while the queue waits for it to finish. Drawn as one list
+     * because that is the order the conversation will read them in.
+     */
+    const queueView = (runner) => [
+        ...runner.agent.pendingInterjections.map((entry) => ({
+            id: entry.id,
+            text: entry.text,
+            attachments: [],
+            references: [],
+            soon: true,
+        })),
+        ...runner.queue.map((entry) => ({
+            id: entry.id,
+            text: entry.prompt,
+            attachments: entry.staged.map((file) => file.name),
+            references: entry.references,
+            soon: false,
+        })),
+    ];
+    const broadcastQueue = (runner) => {
+        broadcast({ type: "queue", session: runner.session.id, queued: queueView(runner) });
+    };
+    /**
+     * Start the next waiting prompt, if there is one.
+     *
+     * Returns whether a turn was started, so a caller can tell an empty queue
+     * from one that is now running.
+     */
+    function drainQueue(runner) {
+        const next = runner.queue.shift();
+        if (!next)
+            return false;
+        broadcastQueue(runner);
+        void runTurn(runner, next.prompt, next.staged, next.references);
+        return true;
+    }
     async function runTurn(runner, prompt, staged = [], references = []) {
         const controller = new AbortController();
         runner.running = controller;
@@ -2907,6 +3038,7 @@ export async function startWebServer(opts) {
         const note = referenceNote(references);
         const text = note ? `${note}\n\n${prompt}` : prompt;
         const input = staged.length ? buildMessage(text, staged) : text;
+        let failed = false;
         try {
             for await (const event of runner.agent.run(input, { signal: controller.signal })) {
                 // The agent's own question_request is not forwarded: the page draws
@@ -2915,10 +3047,25 @@ export async function startWebServer(opts) {
                 // the copy without that id could only ever 404.
                 if (event.type === "question_request")
                     continue;
+                // The agent reports a provider failure as an event and breaks its own
+                // loop rather than throwing, so the catch below never sees it — and a
+                // queue that drained into a dead provider would replay the failure
+                // once per waiting message.
+                if (event.type === "error" && event.fatal)
+                    failed = true;
+                // Read into the conversation: the chip goes, and the words appear in
+                // the transcript where the model saw them rather than where they were
+                // typed. `prompt` is what the page draws a user message from.
+                if (event.type === "interjected") {
+                    broadcastQueue(runner);
+                    broadcast({ type: "prompt", session: id, text: event.text, interjected: true });
+                    continue;
+                }
                 broadcast({ ...event, session: id });
             }
         }
         catch (err) {
+            failed = true;
             broadcast({
                 type: "error",
                 session: id,
@@ -2942,12 +3089,24 @@ export async function startWebServer(opts) {
         }
         finally {
             runner.running = undefined;
+            // The window between the loop's last read of the inbox and the run
+            // admitting it is over. Whatever landed in it is put at the head of the
+            // queue rather than left unread inside a finished agent.
+            const unread = runner.agent.takeUnread();
+            for (let i = unread.length - 1; i >= 0; i--) {
+                runner.queue.unshift({ id: unread[i].id, prompt: unread[i].text, staged: [], references: [] });
+            }
             broadcast({
                 type: "idle",
                 session: id,
                 state: state(runner),
                 changes: runner.ledger.list(),
             });
+            // Only after a turn that ended on its own. An interrupt means stop, and
+            // an error would usually meet the next prompt with the same error, so
+            // both leave the queue standing for the person to send or drop.
+            if (!controller.signal.aborted && !failed)
+                drainQueue(runner);
         }
     }
     function stream(res) {