@bivy/bivy 0.16.24-staging.1 → 0.16.24-staging.2

package/bin/acp-shim.mjs

@@ -346,7 +346,14 @@ function onSessionUpdate(params) {
           type: "tool.result",
           toolCallId,
           name: toolCallName(state),
-          result: textOf(u.content) || status,
+          // Use the ACCUMULATED content (mergeToolCallState keeps the fullest
+          // seen across the call's lifecycle), not just this terminal frame's.
+          // Agents like opencode stream a command's stdout in an earlier
+          // (in_progress) tool_call_update and leave `content` empty on the
+          // closing frame — reading only `u.content` there collapsed the result
+          // to the bare status ("completed"), dropping the real output. Prefer
+          // the terminal frame's content when it has some, else the accumulated.
+          result: textOf(u.content) || textOf(state.content) || status,
           isError: status === "failed",
         });
       } else {

package/dist/runtime/cli-parsers.js

@@ -72,6 +72,7 @@ export function extractTokenUsage(raw) {
  *  persisted transcript shape matches the live-streaming shape (see protocol.ts). */
 class TurnAccumulator {
     toolContext;
+    inferSegmentBoundaries;
     text = "";
     started = false;
     ended = false;
@@ -88,6 +89,16 @@ class TurnAccumulator {
     // already sealed into `content` as its own block.
     content = [];
     textFlushed = "";
+    // A tool call interrupts the assistant's prose/reasoning: the text that
+    // resumes after it is a NEW message segment, not a continuation of the last
+    // token. Without a separator the two run together ("…what it does.The next…",
+    // "…shell commandI have…") — exactly the seam the governed ProtocolRuntime
+    // guards with its `assistantItemBoundary` \n\n insertion. Mirror that here so
+    // every CliParser agent (Grok, Goose, Gemini, the generic streams) gets the
+    // same clean paragraph break instead of a concatenated blob. Tracked per
+    // stream because text and reasoning accumulate into separate buffers.
+    pendingTextBoundary = false;
+    pendingReasoningBoundary = false;
     out = [];
     details = new Map();
     // Not every CLI includes a stable id on both halves of a tool exchange.
@@ -102,8 +113,15 @@ class TurnAccumulator {
         if (pending)
             this.content.push({ type: "text", text: pending });
     }
-    constructor(toolContext) {
+    constructor(toolContext, 
+    // Native CLI streams (Grok, Goose, Claude/Codex JSON, …) start a fresh
+    // prose/reasoning segment after each tool call without re-emitting a
+    // separator, so we infer the paragraph break. The bivy-agent-protocol path
+    // instead carries continuation faithfully (a shim can emit an explicit
+    // boundary when it wants one), so it opts out.
+    inferSegmentBoundaries = true) {
         this.toolContext = toolContext;
+        this.inferSegmentBoundaries = inferSegmentBoundaries;
     }
     ensureStart(events) {
         if (!this.started) {
@@ -121,6 +139,9 @@ class TurnAccumulator {
     appendReasoning(text, events) {
         if (!text)
             return;
+        if (this.pendingReasoningBoundary && this.reasoning)
+            this.reasoning += "\n\n";
+        this.pendingReasoningBoundary = false;
         this.reasoning += text;
         events.push({ type: "message_update", message: { role: "assistant", content: [{ type: "thinking", thinking: this.reasoning }] } });
     }
@@ -133,6 +154,18 @@ class TurnAccumulator {
         if (!text)
             return;
         this.ensureStart(events);
+        if (this.pendingTextBoundary && this.text) {
+            // Advance the sealed prefix over the display-only separator when the prior
+            // segment was already flushed to a content block, so the next persisted
+            // block holds `Second message`, not `\n\nSecond message` (matching
+            // ProtocolRuntime). The cumulative `text` still carries the break for the
+            // live stream and the final answer.
+            const wasFullyFlushed = this.textFlushed === this.text;
+            this.text += "\n\n";
+            if (wasFullyFlushed)
+                this.textFlushed = this.text;
+        }
+        this.pendingTextBoundary = false;
         this.text += text;
         events.push({ type: "message_update", message: { role: "assistant", content: this.text } });
     }
@@ -147,6 +180,12 @@ class TurnAccumulator {
         if (detail)
             this.details.set(callId, detail);
         this.flushPendingText();
+        // Prose/reasoning that resumes after this call is a fresh segment — arm the
+        // boundary so the next appendText/appendReasoning inserts a separator.
+        if (this.inferSegmentBoundaries) {
+            this.pendingTextBoundary = true;
+            this.pendingReasoningBoundary = true;
+        }
         this.content.push({ type: "tool_use", id: callId, name, input: input ?? {}, ...(detail ? { detail } : {}) });
         events.push({ type: "tool_call", toolName: name, input, toolCallId: callId, ...(detail ? { detail } : {}) });
     }
@@ -198,7 +237,10 @@ class TurnAccumulator {
 }
 /** Parser for the bivy-agent-protocol JSONL event vocabulary (the universal path). */
 export function bivyProtocolParser() {
-    const acc = new TurnAccumulator({ provider: "bivy-protocol", protocol: "protocol" });
+    // The universal protocol carries continuation faithfully: text after a tool is
+    // appended verbatim (a shim emits an explicit break when it wants one), so it
+    // opts out of inferred segment boundaries.
+    const acc = new TurnAccumulator({ provider: "bivy-protocol", protocol: "protocol" }, false);
     return {
         onLine(line) {
             const events = [];

package/package.json

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