@bivy/bivy 0.16.25-staging.2 → 0.16.25-staging.4

package/bin/agent-manifest.json

@@ -193,7 +193,10 @@
       "certification": "release-tested",
       "testedVersion": "1.0.0",
       "headlessFlags": [
+        "--always-approve",
         "-p",
+        "--output-format",
+        "streaming-json",
         "--resume"
       ],
       "install": {

package/dist/agents/profiles.js

@@ -370,19 +370,28 @@ export const AGENT_PROFILES = {
         // UUID (sessions live under ~/.grok/sessions/<cwd>/<id>/). The interactive
         // TUI uses the same store via `grok --resume <id>`. Model ids match
         // `grok models` for the official CLI (override with BIVY_GROK_MODELS).
-        args: ["-p"],
-        // The current CLI's `--output-format streaming-json` emits newline-delimited
-        // JSON keyed off `type`: {type:"text",data} for the answer, {type:"thought",
-        // data} for reasoning, {type:"end"} to close the turn (plus tool frames). The
-        // shared tolerant generic-stream-json parser understands this shape (and the
-        // ACP session/update envelope other CLIs use), so Grok gets faithful
-        // transcripts — answer prose, a thinking sidecar, and tool cards — without a
-        // Grok-specific adapter. Keep the plain args as the explicit
-        // BIVY_AGENT_STRUCTURED=0 fallback.
-        jsonArgs: ["--output-format", "streaming-json", "-p"],
+        // `--always-approve` auto-approves every tool execution. Without it, Grok's
+        // headless `-p` turn emits a tool_call and then waits for the client to
+        // approve it over the streaming-json (ACP) channel; Bivy governs effects at
+        // the sandbox tier and closes stdin, so the pending call races to a "User
+        // cancelled the execution" — i.e. Grok could never actually run a tool under
+        // Bivy. The flag is the Grok analogue of Cursor's `--force`, Copilot's
+        // `--allow-all-tools`, Droid's `--auto`, etc.
+        args: ["--always-approve", "-p"],
+        // The current CLI's `--output-format streaming-json` emits NDJSON of the
+        // agent-native ACP session updates: assistant text, a {type:"thought"}
+        // reasoning sidecar, and tool_call/tool_call_update frames. The shared
+        // tolerant generic-stream-json parser understands this shape (and the ACP
+        // session/update envelope other CLIs use), so Grok gets faithful transcripts
+        // — answer prose, a thinking sidecar, and tool cards — without a Grok-specific
+        // adapter. Keep the plain args as the explicit BIVY_AGENT_STRUCTURED=0
+        // fallback.
+        jsonArgs: ["--output-format", "streaming-json", "--always-approve", "-p"],
         parserId: "generic-stream-json",
+        // Resume mirrors the fresh-launch recipe (structured output + auto-approve)
+        // so a continued turn streams and runs tools exactly like the first one.
         resume: {
-            template: ["--resume", "{id}", "-p"],
+            template: ["--output-format", "streaming-json", "--resume", "{id}", "--always-approve", "-p"],
             historyLoader: "grok",
         },
         model: {

package/dist/runtime/process.js

@@ -369,8 +369,14 @@ class ProcessSession {
                 this.nativeSessionRef = learnedRef;
                 this.upstreamSessionStarted = true;
             }
-            for (const event of events)
-                this.emit(event);
+            // Sync the parser's final transcript into this.messages BEFORE emitting the
+            // terminal events (message_end/turn_end/agent_end). The daemon persists a
+            // base-transcript snapshot synchronously on message_end/turn_end by reading
+            // getMessages() — so if the push happened after the emit loop (as it once
+            // did), that snapshot saw an empty turn and the agent's answer + paired
+            // tool blocks were never persisted, vanishing on reload for every
+            // structured-pipe CLI (Grok, Goose, Gemini, …). Populating first makes
+            // getMessages() authoritative the instant message_end fires.
             if (!messagesPushed && events.some((e) => e.type === "agent_end")) {
                 messagesPushed = true;
                 for (const message of activeParser.messages())
@@ -381,6 +387,8 @@ class ProcessSession {
                 if (usage)
                     this.lastUsage = usage;
             }
+            for (const event of events)
+                this.emit(event);
         };
         const feedParser = (activeParser, text) => {
             lineBuf += text;

package/dist/session/transcript-persistence.js

@@ -31,7 +31,15 @@ function capThinkingForPersistence(text) {
 function toolEventId(event) {
     const toolCall = event.toolCall;
     const input = (event.input || event.toolInput || event.args || toolCall?.input || {});
-    const explicit = event.toolUseId || event.tool_use_id || event.toolCallId || event.callId || event.id || toolCall?.id;
+    // Structured-pipe parsers (Grok/Goose/Gemini/… via the shared TurnAccumulator)
+    // emit a `tool_result` whose id lives under `result.toolCallId`, not at the top
+    // level. Without reading it here the result overlay was keyed `"<name>:"` and
+    // never paired with its `tool_call` overlay — orphaning the output in the
+    // transcript. Check the nested result id as a general shape, not a per-agent
+    // branch (protocol agents that already set a top-level id are unaffected).
+    const result = (event.result || event.toolResult);
+    const explicit = event.toolUseId || event.tool_use_id || event.toolCallId || event.callId || event.id || toolCall?.id ||
+        result?.toolCallId || result?.tool_use_id || result?.toolUseId || result?.id;
     if (explicit)
         return String(explicit);
     return `${String(event.toolName || event.name || toolCall?.name || "tool")}:${String(input.path || input.file || input.filePath || input.command || input.cmd || input.query || "")}`;

package/package.json

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