@bivy/bivy 0.10.0 → 0.10.1-staging.141

package/bin/acp-shim.mjs

@@ -125,6 +125,31 @@ let pendingModel = null;
 // right ACP permission request with a concrete optionId.
 const permissionRequests = new Map();
 
+// --- trailing-update drain ---------------------------------------------------
+// opencode's ACP server resolves `session/prompt` (the end_turn reply) BEFORE the
+// final `agent_message_chunk` frames are flushed — a known upstream ordering race
+// (opencode#17505). If the shim declared session.done the instant the prompt reply
+// arrived, the turn would seal at ProtocolRuntime with the reply's tail still
+// unstreamed: the trailing text then streams live (message_update) but never
+// reaches getMessages(), so it vanishes the moment the session reopens. So the
+// turn is NOT done at prompt-resolve — hold session.done until the session/update
+// stream has been quiet for TRAILING_DRAIN_MS, letting the late chunks land while
+// the turn is still open and get sealed into history.
+const TRAILING_DRAIN_MS = 250;
+let turnDrainTimer = null;
+let turnDraining = false;
+function scheduleTurnDone() {
+  clearTimeout(turnDrainTimer);
+  turnDrainTimer = setTimeout(finishTurnDone, TRAILING_DRAIN_MS);
+}
+function finishTurnDone() {
+  turnDrainTimer = null;
+  if (!turnDraining) return;
+  turnDraining = false;
+  bivy({ type: "session.status", status: "idle" });
+  bivy({ type: "session.done" });
+}
+
 // --- tool-call field normalization -------------------------------------------
 // ACP's `tool_call`/`tool_call_update` carries a free-text `title` (whatever
 // prose the agent chose) AND a small fixed `kind` enum (read/edit/delete/move/
@@ -235,6 +260,10 @@ function publishModels(result) {
 function onSessionUpdate(params) {
   const u = params?.update;
   if (!u || typeof u !== "object") return;
+  // Any update arriving while the turn is draining means the agent is still
+  // emitting the tail of this turn (see the drain note above) — reset the quiet
+  // window so session.done waits for it instead of sealing history short.
+  if (turnDraining) scheduleTurnDone();
   const kind = String(u.sessionUpdate || "");
   const textOf = (content) => {
     if (!content) return "";
@@ -432,8 +461,19 @@ async function onBivyCommand(msg) {
         bivy({ replyTo: id, ok: true });
         bivy({ type: "session.status", status: "working" });
         agentRequest("session/prompt", { sessionId, prompt: [{ type: "text", text: String(msg.text ?? "") }] })
-          .then(() => { bivy({ type: "session.status", status: "idle" }); bivy({ type: "session.done" }); })
-          .catch((e) => bivy({ type: "session.error", error: e instanceof Error ? e.message : String(e) }));
+          .then(() => {
+            // The prompt reply is NOT the end of the turn for opencode — the last
+            // agent_message_chunk frames trail it (see the drain note above). Arm
+            // the drain; session.done fires once the update stream goes quiet.
+            turnDraining = true;
+            scheduleTurnDone();
+          })
+          .catch((e) => {
+            clearTimeout(turnDrainTimer);
+            turnDrainTimer = null;
+            turnDraining = false;
+            bivy({ type: "session.error", error: e instanceof Error ? e.message : String(e) });
+          });
         return;
       }
       case "tool.decision": {
@@ -465,6 +505,11 @@ async function onBivyCommand(msg) {
         return;
       }
       case "session.abort": {
+        // A pending drain must not fire session.done after the user cancelled —
+        // the turn is being torn down, not finishing on its own.
+        clearTimeout(turnDrainTimer);
+        turnDrainTimer = null;
+        turnDraining = false;
         if (sessionId) agentNotify("session/cancel", { sessionId });
         if (id !== undefined) bivy({ replyTo: id, ok: true });
         return;

package/dist/runtime/protocol.js

@@ -411,6 +411,40 @@ class ProtocolSession {
         if (pending)
             this.turnContent.push({ type: "text", text: pending });
     }
+    /**
+     * Fold assistant text that arrives after the turn was sealed (session.done)
+     * onto the last persisted assistant message — the ACP end_turn race (see the
+     * message.delta branch). The daemon's message_end handler re-snapshots the
+     * base transcript, so the tail survives a reopen; live viewers catch up via
+     * the emitted message_update + message_end. Text with no assistant message to
+     * fold onto is dropped (there is nowhere durable for it to go).
+     */
+    foldLateAssistantDelta(text) {
+        let lastIndex = -1;
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            if (this.messages[i]?.role === "assistant") {
+                lastIndex = i;
+                break;
+            }
+        }
+        if (lastIndex < 0)
+            return;
+        const msg = this.messages[lastIndex];
+        const raw = msg.content;
+        const content = Array.isArray(raw)
+            ? raw
+            : typeof raw === "string" && raw
+                ? [{ type: "text", text: raw }]
+                : [];
+        const lastBlock = content[content.length - 1];
+        if (lastBlock && lastBlock.type === "text")
+            lastBlock.text = `${lastBlock.text ?? ""}${text}`;
+        else
+            content.push({ type: "text", text });
+        msg.content = content;
+        this.emit({ type: "message_update", message: { role: "assistant", content } });
+        this.emit({ type: "message_end", message: { role: "assistant", content } });
+    }
     handleMessage(msg) {
         this.emitter.emit("protocol-message", msg);
         const replyTo = typeof msg.replyTo === "string" ? msg.replyTo : "";
@@ -450,10 +484,22 @@ class ProtocolSession {
         }
         if (type === "message.delta") {
             const text = String(msg.text ?? "");
-            if (!this.assistantText)
-                this.emit({ type: "message_start", message: { role: "assistant", content: "" } });
-            this.assistantText += text;
-            this.emit({ type: "message_update", message: { role: "assistant", content: this.assistantText } });
+            if (!text)
+                return;
+            if (this.streaming) {
+                if (!this.assistantText)
+                    this.emit({ type: "message_start", message: { role: "assistant", content: "" } });
+                this.assistantText += text;
+                this.emit({ type: "message_update", message: { role: "assistant", content: this.assistantText } });
+                return;
+            }
+            // The turn was already sealed (session.done) yet the agent is still
+            // streaming text — the ACP end_turn race where the final agent_message_chunk
+            // frames land after the prompt reply (opencode#17505). The shim drains the
+            // tail before declaring done, but this is the net for a chunk that outlives
+            // the drain: fold it onto the last assistant message so it survives a reopen
+            // instead of opening a fresh draft that is never persisted.
+            this.foldLateAssistantDelta(text);
             return;
         }
         if (type === "message.reasoning" || type === "reasoning.delta") {

package/dist/server.js

@@ -76,7 +76,7 @@ import { captureDirtyPatch, applyDirtyPatch } from "./session/fork-dirty.js";
 import { thinkingTextFromContent } from "./session/transcript-merge.js";
 import { normalizeMessages } from "./session/transcript-normal.js";
 import { buildNativeImportSeedPrompt } from "./session/native-import.js";
-import { EventLog } from "./session/event-log.js";
+import { EventLog, mergeBases } from "./session/event-log.js";
 import { revertFile } from "./session/revert-file.js";
 import { buildDiagnosticsReport, activationRecord } from "./diagnostics.js";
 import { AttachmentStore, isValidAttachmentHash } from "./session/attachment-store.js";
@@ -2443,12 +2443,25 @@ retireTranscriptsDir();
  * with no build-free `readMessages` and no external rollout. Skips the write when the
  * runtime has nothing yet, so a transient empty read can never clobber a good base
  * with `[]`. The log stores it as a bounded delta (see EventLog.appendBaseSnapshot).
+ *
+ * The snapshot must never SHRINK the log. A protocol runtime that resumes via a
+ * blank reconnect (e.g. opencode through the ACP shim: session/load returns no
+ * message history) starts empty and only reports the turns that ran after the
+ * resume — a transcript SHORTER than what the log already holds, despite being
+ * the same ongoing conversation. `appendBaseSnapshot` reads a shorter snapshot
+ * as a compaction and REPLACES the logged base, silently dropping every prior
+ * turn. Rebase the runtime's snapshot onto the logged history instead (the same
+ * union `EventLog.deriveHistory` applies on read): the merged view is exactly
+ * the prefix-extend case the log already handles, so the log grows monotonically.
+ * A genuine runtime compaction isn't a supported feature, so never treating a
+ * snapshot as a shrink is safe.
  */
 function persistTranscriptSnapshot(record) {
     const base = record.session.getMessages();
     if (!base.length)
         return;
-    eventLog.appendBaseSnapshot(record.id, base);
+    const logged = eventLog.readBase(record.id);
+    eventLog.appendBaseSnapshot(record.id, logged.length ? mergeBases(logged, base) : base);
 }
 // In-flight dedupe so two sessions (or two turns) referencing the same remote
 // image URL only ever trigger one outbound fetch. Process-lifetime only — a

package/dist/session/event-log.js

@@ -29,6 +29,30 @@
 import fs from "node:fs";
 import path from "node:path";
 import { normalizedIntermediateText, thinkingTextFromContent, mergeTranscript } from "./transcript-merge.js";
+/**
+ * Union of a persisted base and a runtime's live transcript, such that the result
+ * is never shorter than either input alone. A live session's runtime transcript
+ * extends the persisted base, so the union is just the runtime's (no duplication).
+ * A resumed runtime that reconnected blank and only re-saw post-resume turns
+ * reports a strict prefix of the persisted base, so the union keeps the persisted
+ * copy. Disjoint inputs (a resumed runtime whose new turns aren't in the log yet)
+ * concatenate in log-then-runtime order. Duplicates are collapsed by message
+ * identity, so the same conversation serialized twice never double-appears.
+ */
+export function mergeBases(logged, runtime) {
+    if (!logged.length)
+        return runtime;
+    const known = new Set(logged.map((m) => JSON.stringify(m)));
+    const merged = [...logged];
+    for (const m of runtime) {
+        const key = JSON.stringify(m);
+        if (!known.has(key)) {
+            known.add(key);
+            merged.push(m);
+        }
+    }
+    return merged;
+}
 /** Content-block type carried by a folded outbound attachment. MUST match
  *  `AGENT_ATTACHMENT_BLOCK` in packages/core/src/store-render.ts — the client's
  *  renderHistory keys on this exact string to render the chip. */
@@ -456,12 +480,21 @@ export class EventLog {
     }
     /**
      * The full derived conversation: overlay detail merged into the base transcript.
-     * Prefers the runtime's own live transcript when it has one; otherwise replays the
-     * base persisted in the log (a reopened session on a runtime that can't rebuild it).
-     * This is the single read path — it absorbs the former `mergeConversation` helper.
+     * The base is the UNION of the runtime's live transcript and the base persisted
+     * in the log — never one at the other's expense. A live session's runtime
+     * transcript extends the log (both are the same conversation, the runtime one
+     * message newer), so the union is just the runtime's. But a runtime that resumes
+     * via a blank reconnect (e.g. opencode through the ACP shim: session/load
+     * returns no message history) reports only the turns that ran AFTER the resume —
+     * a truncation of the same conversation, not the whole story. Preferring the
+     * runtime base there would mask every prior turn from every history read, so the
+     * union keeps the log's fuller copy while still surfacing whatever the runtime
+     * alone knows. This is the single read path — it absorbs the former
+     * `mergeConversation` helper.
      */
     deriveHistory(id, runtimeBase) {
-        const base = runtimeBase && runtimeBase.length ? runtimeBase : this.readBase(id);
+        const logged = this.readBase(id);
+        const base = runtimeBase && runtimeBase.length ? mergeBases(logged, runtimeBase) : logged;
         return mergeTranscript(base, this.read(id));
     }
     /** Full ordered record list (already-flushed followed by pending). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.10.0",
+  "version": "0.10.1-staging.141",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",