@bivy/bivy 0.16.20-staging.4 → 0.16.20-staging.6

package/dist/runtime/cli-parsers.js

@@ -313,13 +313,44 @@ export function claudeStreamJsonParser() {
  * codex-cli 0.142): a thread with turns, each turn a stream of typed items.
  *   {"type":"thread.started","thread_id":…}
  *   {"type":"turn.started"} / {"type":"turn.completed"} / {"type":"turn.failed","error":{message}}
+ *   {"type":"item.started","item":{…}}   ← a shell/patch/MCP call begins (live card)
  *   {"type":"item.completed","item":{"id":…,"type":"agent_message"|"reasoning"|
- *        "command_execution"|"mcp_tool_call"|"file_change"|"error", …}}
+ *        "command_execution"|"mcp_tool_call"|"file_change"|"error", "status":…, …}}
  *   {"type":"error","message":…}   ← transient reconnect noise (non-fatal)
+ * A `file_change`/`command_execution` item carries a terminal `status`
+ * (`completed`|`failed`); a `failed` one is surfaced as an errored tool result
+ * rather than a silent success (mirrors the governed app-server shim).
  */
 export function codexJsonParser() {
     const acc = new TurnAccumulator({ provider: "codex", protocol: "structured-pipe" });
     let sessionRef;
+    // Tool ids already surfaced as a running card, so `item.started` (live) and the
+    // later `item.completed` (terminal) render one card per call, not two.
+    const startedTools = new Set();
+    const ensureToolUse = (id, name, input, events) => {
+        if (id && startedTools.has(id))
+            return;
+        if (id)
+            startedTools.add(id);
+        acc.addToolUse(id, name, input, events);
+    };
+    // A tool item begins. Codex emits `item.started` for shell/patch/MCP calls
+    // before the matching `item.completed`, so surfacing it shows a long-running
+    // command or patch as a live "running" card instead of nothing until it ends.
+    const handleStarted = (item, events) => {
+        const id = String(item.id ?? "");
+        switch (String(item.type ?? "")) {
+            case "command_execution":
+                ensureToolUse(id, "shell", { command: item.command ?? "" }, events);
+                break;
+            case "file_change":
+                ensureToolUse(id, "apply_patch", { changes: item.changes ?? item }, events);
+                break;
+            case "mcp_tool_call":
+                ensureToolUse(id, String(item.tool ?? item.server ?? "mcp"), item.arguments ?? item.input, events);
+                break;
+        }
+    };
     const handleItem = (item, events) => {
         const id = String(item.id ?? "");
         switch (String(item.type ?? "")) {
@@ -327,19 +358,27 @@ export function codexJsonParser() {
                 acc.appendText(String(item.text ?? ""), events);
                 break;
             case "command_execution":
-                acc.addToolUse(id, "shell", { command: item.command ?? "" }, events);
-                if (item.aggregated_output != null || item.exit_code != null) {
-                    acc.addToolResult(id, "shell", { content: item.aggregated_output ?? "", exitCode: item.exit_code }, events, Number(item.exit_code) !== 0);
+                ensureToolUse(id, "shell", { command: item.command ?? "" }, events);
+                if (item.aggregated_output != null || item.exit_code != null || item.status != null) {
+                    acc.addToolResult(id, "shell", { content: item.aggregated_output ?? "", exitCode: item.exit_code }, events, Number(item.exit_code) !== 0 || item.status === "failed");
                 }
                 break;
             case "mcp_tool_call":
-                acc.addToolUse(id, String(item.tool ?? item.server ?? "mcp"), item.arguments ?? item.input, events);
-                if (item.result != null)
-                    acc.addToolResult(id, String(item.tool ?? "mcp"), item.result, events);
+                ensureToolUse(id, String(item.tool ?? item.server ?? "mcp"), item.arguments ?? item.input, events);
+                if (item.result != null || item.error != null || item.status != null) {
+                    acc.addToolResult(id, String(item.tool ?? "mcp"), item.result ?? item.error ?? item.status, events, item.error != null || item.status === "failed");
+                }
                 break;
-            case "file_change":
-                acc.addToolUse(id, "apply_patch", { changes: item.changes ?? item }, events);
+            case "file_change": {
+                ensureToolUse(id, "apply_patch", { changes: item.changes ?? item }, events);
+                // `file_change` is terminal in `exec --json` (no separate result event),
+                // so close the card with a result reflecting its status. Without this a
+                // completed patch hangs as "running" and — worse — a FAILED patch renders
+                // as a successful edit. Mirrors the app-server shim's handling.
+                const status = String(item.status ?? "completed");
+                acc.addToolResult(id, "apply_patch", status, events, status === "failed");
                 break;
+            }
             case "reasoning": {
                 // Codex reasoning items carry either `text` or a `summary` (string or an
                 // array of {text}) — surface whichever is present as a thinking stream.
@@ -380,6 +419,10 @@ export function codexJsonParser() {
                 case "turn.started":
                     events.push({ type: "turn_start" });
                     break;
+                case "item.started":
+                    if (msg.item && typeof msg.item === "object")
+                        handleStarted(msg.item, events);
+                    break;
                 case "item.completed":
                     if (msg.item && typeof msg.item === "object")
                         handleItem(msg.item, events);

package/dist/runtime/tool-call-map.js

@@ -116,13 +116,21 @@ export function mapToolCall(toolName, input, context = {}) {
     }
     if (inToolSet(EDIT, toolName, key)) {
         let path = str(o, ...PATH_KEYS);
-        // Codex `apply_patch`/`file_change` carries a `changes` map keyed by path.
+        // Codex `apply_patch`/`file_change` carries a `changes` collection. The
+        // app-server keys it by path (a map); `codex exec --json` sends an array of
+        // `{path, kind}` entries. Derive the first touched path from either shape so
+        // the patch renders as an edit card instead of an opaque blob.
         if (!path) {
             const changes = o.changes;
-            if (changes && typeof changes === "object" && !Array.isArray(changes)) {
-                const first = Object.keys(changes)[0];
+            if (Array.isArray(changes)) {
+                const first = changes.find((c) => !!c && typeof c === "object" && !Array.isArray(c));
                 if (first)
-                    path = first;
+                    path = str(first, ...PATH_KEYS);
+            }
+            else if (changes && typeof changes === "object") {
+                const firstKey = Object.keys(changes)[0];
+                if (firstKey)
+                    path = firstKey;
             }
         }
         if (!path)

package/package.json

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