@bivy/bivy 0.16.25-staging.21 → 0.16.25-staging.23

package/bin/acp-shim.mjs

@@ -313,6 +313,13 @@ function onSessionUpdate(params) {
     if (!content) return "";
     if (typeof content === "string") return content;
     if (Array.isArray(content)) return content.map(textOf).join("");
+    // ACP's ToolCallContent wraps a ContentBlock: `{ type: "content", content:
+    // { type: "text", text } }`. Unwrap it (recursively) so a tool's real output
+    // — a command's stdout, a fetched document, a read's text — isn't dropped,
+    // which collapsed the tool_result to the bare status ("completed"). opencode
+    // and most spec-compliant ACP agents deliver tool output in this wrapped
+    // shape, so reading only the bare `{type:"text"}` form lost it in production.
+    if (content.type === "content" && content.content != null) return textOf(content.content);
     if (content.type === "text" && typeof content.text === "string") return content.text;
     if (typeof content.text === "string") return content.text;
     return "";

package/bin/codex-app-server-shim.mjs

@@ -415,6 +415,16 @@ function onNotification(m) {
       bivy({ type: "session.status", status: "working" });
       return;
     case "turn/completed": {
+      // The completion event is authoritative about a terminal failure: a turn
+      // that hit a usage limit (or any provider error) arrives here as
+      // `status: "failed"` carrying `turn.error`. Capture it directly instead of
+      // depending on a separate `error` notification landing first — otherwise a
+      // completion that omits that notification seals as session.done and the
+      // user sees a silent empty turn (fail loud, never swallow the error).
+      const turnError =
+        params?.turn?.error?.message ||
+        (params?.turn?.status === "failed" ? params?.error?.message || params?.message || "Codex turn failed" : undefined);
+      if (turnError && !sawError) sawError = turnError;
       // Codex 0.147 can publish turn/completed just before the final
       // collabAgentToolCall item/completed notification. Sealing immediately
       // leaves the sub-agent card running forever and drops its persisted

package/dist/runtime/protocol.js

@@ -711,14 +711,41 @@ class ProtocolSession {
             return;
         }
         if (type === "session.error") {
+            const errorText = String(msg.error || "Protocol agent error");
+            // Preserve whatever the failed turn already streamed — a partial assistant
+            // reply and its tool calls/results — persisted exactly as session.done
+            // persists a clean turn. The old handler wiped turnContent here, so a mid-
+            // turn failure dropped all of that work from the reopened transcript.
+            const hadTools = this.turnContent.length > 0 || this.turnToolResults.length > 0;
+            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() });
+            }
+            else if (this.assistantText) {
+                this.messages.push({ role: "assistant", content: this.assistantText, timestamp: Date.now() });
+            }
+            // Append a terminal error marker in the shape store-render + terminalTurnError
+            // recognize (stopReason "error" + errorMessage), so the failure itself
+            // survives a reload as an inline error instead of the turn reopening blank
+            // ("looks done, no reply"). Matches the live session.error emitted just below.
+            const errored = { role: "assistant", content: "", stopReason: "error", errorMessage: errorText, timestamp: Date.now() };
+            this.messages.push(errored);
             this.streaming = false;
+            this.assistantText = "";
+            this.assistantItemBoundary = false;
             this.reasoningText = "";
             this.turnContent = [];
             this.turnTextFlushed = "";
             this.turnToolResults = [];
             this.toolDetailsByCallId.clear();
             this.openToolIds = [];
-            this.emit({ type: "session.error", error: String(msg.error || "Protocol agent error") });
+            // message_end drives the daemon's base-transcript snapshot (agent_end does
+            // not), so the preserved content + error marker are durably persisted.
+            this.emit({ type: "message_end", message: errored });
+            this.emit({ type: "session.error", error: errorText });
             this.emit({ type: "agent_end" });
             return;
         }
@@ -872,7 +899,10 @@ class ProtocolSession {
         const preflightError = await this.preparePreflight();
         if (preflightError) {
             this.streaming = false;
-            const message = { role: "assistant", content: "", errorMessage: preflightError };
+            // stopReason "error" is what store-render keys on to re-render this as an
+            // inline error on reload (without it the turn reopened blank); it also
+            // matches the terminal-error message shape every other failure path uses.
+            const message = { role: "assistant", content: "", stopReason: "error", errorMessage: preflightError };
             this.messages.push(message);
             this.emit({ type: "message_start", message: { role: "assistant", content: "" } });
             this.emit({ type: "session.error", error: preflightError });

package/package.json

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