@bivy/bivy 0.9.1-staging.136 → 0.10.0-staging.138

package/bin/acp-shim.mjs

@@ -125,6 +125,74 @@ let pendingModel = null;
 // right ACP permission request with a concrete optionId.
 const permissionRequests = new Map();
 
+// --- 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/
+// search/execute/think/fetch/other) that matches the node's tool taxonomy
+// (src/runtime/tool-call-map.ts) far better than prose does. It also often
+// splits the substantive data across three places — `rawInput` (frequently
+// empty on the *first* tool_call notification for some agents, opencode
+// included), `locations` (paths the call touches), and `content` (diff/text
+// blocks, usually only populated by a later tool_call_update) — so a naive
+// single-notification read sees "no real information". Accumulate everything
+// we've learned about a call across its whole lifecycle, keyed by toolCallId.
+const toolCallState = new Map();
+
+// The subset of ACP kinds that line up 1:1 with a bucket tool-call-map.ts
+// already recognizes by name; kinds outside this set (delete/move/think/other)
+// have no equivalent normalized rendering yet, so fall back to the agent's own
+// title/kind for display rather than inventing a bucket for them.
+const KIND_TOOL_NAME = { read: "read", edit: "edit", execute: "execute", search: "search", fetch: "fetch" };
+
+function mergeToolCallState(toolCallId, u) {
+  const prev = toolCallState.get(toolCallId) || {};
+  // `content` is normally a ContentBlock[], but some agents send a single block
+  // object (the existing `textOf` helper already tolerates both shapes) — wrap
+  // it so downstream array-walkers (diffContentFields) see it either way.
+  const content = u.content == null ? undefined : Array.isArray(u.content) ? u.content : [u.content];
+  const next = {
+    kind: u.kind ?? prev.kind,
+    title: u.title ?? prev.title,
+    rawInput: u.rawInput && typeof u.rawInput === "object" && Object.keys(u.rawInput).length ? u.rawInput : prev.rawInput,
+    locations: Array.isArray(u.locations) && u.locations.length ? u.locations : prev.locations,
+    content: content && content.length ? content : prev.content,
+  };
+  toolCallState.set(toolCallId, next);
+  return next;
+}
+
+/** The ACP "diff" content block, if the call carries one — the shape opencode
+ *  (and most ACP agents) use to report an edit's before/after text. */
+function diffContentFields(content) {
+  for (const c of content || []) {
+    if (c && c.type === "diff") return { path: c.path, oldText: c.oldText, newText: c.newText };
+  }
+  return {};
+}
+
+/** Merge everything accumulated about a call into one `input` object shaped the
+ *  way tool-call-map.ts's key scan expects (path/command/old_string/new_string/…),
+ *  so a call whose `rawInput` was sparse still classifies once its diff/locations
+ *  arrive. `rawInput` (the underlying tool's own arguments) wins on key conflicts
+ *  since it's the most literal source. */
+function toolCallInput(state) {
+  const input = { ...(state.rawInput || {}) };
+  const diff = diffContentFields(state.content);
+  if (input.path == null && diff.path != null) input.path = diff.path;
+  if (input.old_string == null && diff.oldText != null) input.old_string = diff.oldText;
+  if (input.new_string == null && diff.newText != null) input.new_string = diff.newText;
+  if (input.path == null && state.locations?.[0]?.path != null) input.path = state.locations[0].path;
+  return input;
+}
+
+/** Prefer ACP's structured `kind` (maps straight onto the node's taxonomy) over
+ *  the agent's free-text `title` — a title like "Edit `src/index.ts`" defeats
+ *  both the node's bucket classifier and the client's own name-based heuristic,
+ *  which both expect short tool-name-like tokens, not prose. */
+function toolCallName(state) {
+  return (state.kind && KIND_TOOL_NAME[state.kind]) || state.title || state.kind || "tool";
+}
+
 async function ensureInitialized() {
   if (initialized) return;
   // Bounded: a binary that accepts the launch args but never speaks ACP would
@@ -191,14 +259,27 @@ function onSessionUpdate(params) {
       // An auto-run tool (no permission requested) — surface it so the transcript
       // shows the action; the result arrives via tool_call_update.
       const toolCallId = String(u.toolCallId ?? u.id ?? "");
-      bivy({ type: "tool.call", toolCallId, name: String(u.title || u.kind || "tool"), input: u.rawInput ?? u.input ?? {} });
+      const state = mergeToolCallState(toolCallId, u);
+      bivy({ type: "tool.call", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
       break;
     }
     case "tool_call_update": {
       const toolCallId = String(u.toolCallId ?? u.id ?? "");
+      const state = mergeToolCallState(toolCallId, u);
       const status = String(u.status || "");
       if (status === "completed" || status === "failed") {
-        bivy({ type: "tool.result", toolCallId, name: String(u.title || "tool"), result: textOf(u.content) || status });
+        toolCallState.delete(toolCallId);
+        bivy({
+          type: "tool.result",
+          toolCallId,
+          name: toolCallName(state),
+          result: textOf(u.content) || status,
+          isError: status === "failed",
+        });
+      } else {
+        // Still running: forward the fuller name/input as it fills in so a live
+        // tool card isn't stuck with the sparse initial notification.
+        bivy({ type: "tool.update", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
       }
       break;
     }
@@ -222,7 +303,8 @@ async function onAgentRequest(id, method, params) {
       const toolCallId = String(tc.toolCallId ?? tc.id ?? `perm-${id}`);
       const options = Array.isArray(params?.options) ? params.options : [];
       permissionRequests.set(toolCallId, { requestId: id, options });
-      bivy({ type: "tool.call", toolCallId, name: String(tc.title || tc.kind || "tool"), input: tc.rawInput ?? tc.input ?? {} });
+      const state = mergeToolCallState(toolCallId, tc);
+      bivy({ type: "tool.call", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
       return;
     }
     case "fs/read_text_file": {

package/dist/runtime/cli-parsers.js

@@ -77,10 +77,25 @@ class TurnAccumulator {
     ended = false;
     reasoning = "";
     usageSnapshot;
-    toolUses = [];
     toolResults = [];
+    // Ordered content blocks (text + tool_use, interleaved exactly as they
+    // streamed) for the assistant turn. A prior version tracked `text` and tool
+    // uses separately and always emitted the whole turn's text ahead of every
+    // tool call on finish() — collapsing a turn like "Let me check." → tool →
+    // "Now editing." → tool into one merged text block followed by both tools.
+    // That read as interim messages "disappearing"/bundling at the end once
+    // history reconciled against it. `textFlushed` is the prefix of `text`
+    // already sealed into `content` as its own block.
+    content = [];
+    textFlushed = "";
     out = [];
     details = new Map();
+    flushPendingText() {
+        const pending = this.text.slice(this.textFlushed.length);
+        this.textFlushed = this.text;
+        if (pending)
+            this.content.push({ type: "text", text: pending });
+    }
     constructor(toolContext) {
         this.toolContext = toolContext;
     }
@@ -123,7 +138,8 @@ class TurnAccumulator {
         const detail = mapToolCall(name, input, this.toolContext);
         if (detail && id)
             this.details.set(id, detail);
-        this.toolUses.push({ type: "tool_use", id, name, input: input ?? {}, ...(detail ? { detail } : {}) });
+        this.flushPendingText();
+        this.content.push({ type: "tool_use", id, name, input: input ?? {}, ...(detail ? { detail } : {}) });
         events.push({ type: "tool_call", toolName: name, input, toolCallId: id, ...(detail ? { detail } : {}) });
     }
     addToolResult(toolUseId, name, content, events, isError = false) {
@@ -140,14 +156,16 @@ class TurnAccumulator {
         if (this.ended)
             return;
         this.ended = true;
+        // Whether this turn ever used a tool — checked BEFORE flushing trailing
+        // text, so a tool-free turn (content still empty at this point) keeps the
+        // plain-text message shape it always had instead of gaining a pointless
+        // single-text-block wrapper.
+        const hadTools = this.content.length > 0 || this.toolResults.length > 0;
         const message = { role: "assistant", content: this.text };
-        if (this.toolUses.length || this.toolResults.length) {
-            const content = [];
-            if (this.text)
-                content.push({ type: "text", text: this.text });
-            content.push(...this.toolUses);
-            if (content.length)
-                this.out.push({ role: "assistant", content });
+        if (hadTools) {
+            this.flushPendingText();
+            if (this.content.length)
+                this.out.push({ role: "assistant", content: this.content });
             if (this.toolResults.length)
                 this.out.push({ role: "user", content: this.toolResults });
         }

package/dist/runtime/protocol.js

@@ -8,6 +8,7 @@ import { bivySessionEnv } from "./session-env.js";
 import { mergeAgentCommands } from "./slash-commands.js";
 import { withExactCapabilitySurface } from "./types.js";
 import { extractTokenUsage } from "./cli-parsers.js";
+import { mapToolCall, mapToolResult } from "./tool-call-map.js";
 /** A protocol `usage` message → UsageSnapshot (reuses the CLI token-key scan). */
 function parseProtocolUsage(raw) {
     if (!raw || typeof raw !== "object")
@@ -170,11 +171,23 @@ class ProtocolSession {
     reasoningText = "";
     stderrOutput = "";
     lastUsage;
-    // Accumulate the current turn's tool calls/results so getMessages() keeps them
-    // in history — re-opening a session then shows what the agent actually did, not
-    // just its final text. Cleared at the start/end of each turn.
-    turnToolUses = [];
+    // Accumulate the current turn's content blocks (text + tool calls, in the order
+    // they actually happened) and tool results so getMessages() keeps them in
+    // history — re-opening a session then shows what the agent actually did,
+    // interleaved exactly as it happened, not just its final text. Cleared at the
+    // start/end of each turn. `turnTextFlushed` is the prefix of `assistantText`
+    // already sealed into `turnContent` as a text block — each tool call flushes
+    // the text since the last flush before appending its own block, so a turn like
+    // "Let me check." → tool → "Now editing." → tool persists as
+    // [text, tool_use, text, tool_use] instead of collapsing into one text block
+    // followed by every tool (which is what re-flattened on reconcile and read as
+    // interim messages "disappearing"/bundling at the end of the turn).
+    turnContent = [];
+    turnTextFlushed = "";
     turnToolResults = [];
+    // toolCallId -> the node's normalized classification, so a later tool.result
+    // (or tool.update) can attach/refresh `detail` on the already-pushed block.
+    toolDetailsByCallId = new Map();
     constructor(runtimeOptions, cwd, capabilitiesRef, toolInterceptor, 
     // When resuming, the agent's own session ref (e.g. a Codex thread id). Passed
     // back to the shim via the generic session.resume primitive so it reconnects
@@ -389,6 +402,15 @@ class ProtocolSession {
             this.handleMessage(msg);
         }
     }
+    /** Seal the assistant text streamed since the last flush as a text block in
+     *  `turnContent`, ahead of a tool call (or at turn end) — see turnContent's
+     *  doc comment for why this preserves interleaving on reconcile. */
+    flushPendingTurnText() {
+        const pending = this.assistantText.slice(this.turnTextFlushed.length);
+        this.turnTextFlushed = this.assistantText;
+        if (pending)
+            this.turnContent.push({ type: "text", text: pending });
+    }
     handleMessage(msg) {
         this.emitter.emit("protocol-message", msg);
         const replyTo = typeof msg.replyTo === "string" ? msg.replyTo : "";
@@ -458,19 +480,22 @@ class ProtocolSession {
             return;
         }
         if (type === "session.done") {
+            // Whether this turn ever used a tool — checked BEFORE flushing trailing
+            // text, so a tool-free turn (turnContent still empty at this point) keeps
+            // the plain-text message shape it always had instead of gaining a
+            // pointless single-text-block wrapper.
+            const hadTools = this.turnContent.length > 0 || this.turnToolResults.length > 0;
             const message = { role: "assistant", content: this.assistantText };
-            // Persist the assistant turn. When the turn used tools, store content blocks
-            // (text + tool_use) plus a trailing user message carrying the tool_result
-            // blocks, matched by tool_use_id — the same shape the PWA renders from live
-            // streaming, so a re-opened transcript looks identical to what was on screen.
-            // A tool-free turn keeps the plain-text form it always used.
-            if (this.turnToolUses.length || this.turnToolResults.length) {
-                const assistantContent = [];
-                if (this.assistantText)
-                    assistantContent.push({ type: "text", text: this.assistantText });
-                assistantContent.push(...this.turnToolUses);
-                if (assistantContent.length)
-                    this.messages.push({ role: "assistant", content: assistantContent, timestamp: Date.now() });
+            // Persist the assistant turn. When the turn used tools, store the ordered
+            // content blocks (text/tool_use interleaved exactly as they streamed — see
+            // turnContent's doc comment) plus a trailing user message carrying the
+            // tool_result blocks, matched by tool_use_id — the same shape the PWA
+            // renders from live streaming, so a re-opened transcript looks identical to
+            // what was on screen. A tool-free turn keeps the plain-text form it always used.
+            if (hadTools) {
+                this.flushPendingTurnText();
+                if (this.turnContent.length)
+                    this.messages.push({ role: "assistant", content: this.turnContent, timestamp: Date.now() });
                 if (this.turnToolResults.length)
                     this.messages.push({ role: "user", content: this.turnToolResults, timestamp: Date.now() });
             }
@@ -481,32 +506,38 @@ class ProtocolSession {
             this.streaming = false;
             this.assistantText = "";
             this.reasoningText = "";
-            this.turnToolUses = [];
+            this.turnContent = [];
+            this.turnTextFlushed = "";
             this.turnToolResults = [];
+            this.toolDetailsByCallId.clear();
             this.emit({ type: "agent_end" });
             return;
         }
         if (type === "session.error") {
             this.streaming = false;
             this.reasoningText = "";
-            this.turnToolUses = [];
+            this.turnContent = [];
+            this.turnTextFlushed = "";
             this.turnToolResults = [];
+            this.toolDetailsByCallId.clear();
             this.emit({ type: "session.error", error: String(msg.error || "Protocol agent error") });
             this.emit({ type: "agent_end" });
             return;
         }
         if (type === "tool.call") {
-            this.turnToolUses.push({
-                type: "tool_use",
-                id: String(msg.toolCallId || msg.id || ""),
-                name: String(msg.name || "tool"),
-                input: msg.input ?? {},
-            });
+            const toolCallId = String(msg.toolCallId || msg.id || "");
+            const toolName = String(msg.name || "tool");
+            const detail = mapToolCall(toolName, msg.input, { provider: this.runtimeOptions.id || "acp", protocol: "protocol" });
+            if (detail)
+                this.toolDetailsByCallId.set(toolCallId, detail);
+            this.flushPendingTurnText();
+            this.turnContent.push({ type: "tool_use", id: toolCallId, name: toolName, input: msg.input ?? {}, ...(detail ? { detail } : {}) });
         }
         if (type === "tool.call" && this.capabilitiesRef.toolInterception && this.toolInterceptor) {
             const toolCallId = String(msg.toolCallId || "");
             const toolName = String(msg.name || "tool");
-            this.emit({ type: "tool_call", toolName, input: msg.input, toolCallId });
+            const detail = this.toolDetailsByCallId.get(toolCallId);
+            this.emit({ type: "tool_call", toolName, input: msg.input, toolCallId, ...(detail ? { detail } : {}) });
             const decision = await this.toolInterceptor({ sessionId: this.id, toolName, input: msg.input });
             try {
                 this.write({ id: randomUUID(), type: "tool.decision", sessionId: this.id, toolCallId, decision: decision?.block ? "deny" : "allow", reason: decision?.reason });
@@ -518,14 +549,41 @@ class ProtocolSession {
             }
             return;
         }
+        if (type === "tool.update") {
+            // A tool call's structured data can arrive progressively (e.g. opencode's
+            // ACP shim often has an empty `rawInput` on the initial notification and
+            // fills in `content`/`locations` on a later update) — refresh the
+            // already-pushed turnContent block in place (never append a duplicate) and
+            // push a live update so an open tool card fills in without waiting for the
+            // turn to end and history to reconcile.
+            const toolCallId = String(msg.toolCallId || "");
+            const toolName = String(msg.name || "tool");
+            const detail = mapToolCall(toolName, msg.input, { provider: this.runtimeOptions.id || "acp", protocol: "protocol" });
+            if (detail)
+                this.toolDetailsByCallId.set(toolCallId, detail);
+            const block = this.turnContent.find((b) => b.type === "tool_use" && b.id === toolCallId);
+            if (block) {
+                block.name = toolName;
+                block.input = msg.input ?? {};
+                if (detail)
+                    block.detail = detail;
+            }
+            this.emit({ type: "tool_execution_update", toolName, input: msg.input, toolCallId, ...(detail ? { detail } : {}) });
+            return;
+        }
         if (type === "tool.result") {
+            const toolCallId = String(msg.toolCallId || msg.tool_use_id || msg.id || "");
             const result = msg.result ?? msg.output ?? msg.content ?? msg.text ?? msg.summary ?? "";
+            const isError = Boolean(msg.isError || msg.is_error);
             this.turnToolResults.push({
                 type: "tool_result",
-                tool_use_id: String(msg.toolCallId || msg.tool_use_id || msg.id || ""),
+                tool_use_id: toolCallId,
                 content: result,
+                ...(isError ? { is_error: true } : {}),
             });
-            this.emit({ type: "tool_result", toolName: String(msg.name || "tool"), toolCallId: String(msg.toolCallId || msg.tool_use_id || msg.id || ""), result });
+            const priorDetail = this.toolDetailsByCallId.get(toolCallId);
+            const detail = priorDetail ? { ...priorDetail, result: mapToolResult(result, isError) } : undefined;
+            this.emit({ type: "tool_result", toolName: String(msg.name || "tool"), toolCallId, result, ...(detail ? { detail } : {}) });
             return;
         }
         this.emit({ type, ...msg });
@@ -625,8 +683,10 @@ class ProtocolSession {
         this.assistantText = "";
         this.reasoningText = "";
         this.stderrOutput = "";
-        this.turnToolUses = [];
+        this.turnContent = [];
+        this.turnTextFlushed = "";
         this.turnToolResults = [];
+        this.toolDetailsByCallId.clear();
         await this.command("chat.send", {
             sessionId: this.id,
             runtimeSessionRef: this.runtimeSessionRef,

package/package.json

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