@chatpanel/bridge 0.10.33 → 0.10.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.10.33",
+  "version": "0.10.34",
   "type": "module",
   "description": "Local bridge that exposes the AI coding agents installed on your machine \u2014 Claude Code (CLI), Codex (CLI), and Antigravity CLI (formerly Gemini CLI, which remains available for business/enterprise) \u2014 to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
   "keywords": [

package/src/engines/claude.js

@@ -166,6 +166,18 @@ function runClaude({ prompt, args, cwd, emit, signal }) {
   });
 }
 
+// A tool_result's content is either a string or Anthropic's block array. Flatten to text and
+// cap it: the panel truncates for display anyway, and an un-capped file read would otherwise
+// push megabytes through the SSE for no benefit.
+function toolResultText(content) {
+  let text = '';
+  if (typeof content === 'string') text = content;
+  else if (Array.isArray(content)) {
+    text = content.map((c) => (typeof c === 'string' ? c : (c?.text || ''))).filter(Boolean).join('\n');
+  }
+  return text.length > 4000 ? `${text.slice(0, 4000)}…` : text;
+}
+
 // Map one stream-json message to emit() calls. Returns { streamed, result }.
 // The CLI's stream-json mirrors the SDK message shapes. Exported so the custom
 // engine can reuse it for agents that emit Claude-style stream-json.
@@ -184,12 +196,33 @@ export function handleMessage(msg, emit, alreadyStreamed, cwdForSteps = '') {
   } else if (msg.type === 'assistant') {
     for (const block of msg.message?.content || []) {
       if (block.type === 'tool_use') {
-        emit({ type: 'tool', name: block.name, summary: toolSummary(block, cwdForSteps) });
+        // PHASE-BASED, like the Codex engine: the panel renders a step with the call's
+        // arguments and then fills in its status and output when the result arrives. The old
+        // single `summary` event produced one anonymous line per call and no outcome — you
+        // could see that Claude did something, never what it returned. `summary` is still
+        // sent so an older extension keeps the line it used to draw.
+        emit({
+          type: 'tool', name: block.name, phase: 'start',
+          callId: block.id, input: block.input,
+          summary: toolSummary(block, cwdForSteps),
+        });
       } else if (block.type === 'text' && !alreadyStreamed) {
         out.streamed = true;
         emit({ type: 'delta', text: block.text });
       }
     }
+  } else if (msg.type === 'user') {
+    // Claude reports every tool's OUTCOME as a tool_result block on a synthetic user message.
+    // Pairing it with the call by tool_use_id is what turns the step list into a readable
+    // log: each action shows ok / error and the text the tool actually returned.
+    for (const block of msg.message?.content || []) {
+      if (block.type !== 'tool_result') continue;
+      emit({
+        type: 'tool', phase: 'done', callId: block.tool_use_id,
+        status: block.is_error ? 'error' : 'ok',
+        result: toolResultText(block.content),
+      });
+    }
   } else if (msg.type === 'result') {
     if (msg.subtype === 'success') out.result = msg.result || '';
     else emit({ type: 'status', text: `(${msg.subtype})` });

package/src/engines/stream-formats.js

@@ -86,8 +86,23 @@ function opencodeJson(emit) {
       streamed = true;
       emit({ type: 'delta', text: ev.part.text });
     } else if (ev.type === 'tool' || ev.type === 'tool_use') {
+      // Phase-based where opencode gives us enough to pair a call with its outcome: its tool
+      // parts carry a callID and a state that moves running → completed/error. Without that we
+      // still emit a start, so the step at least appears (the old behaviour).
       const p = ev.part || {};
-      emit({ type: 'tool', name: p.tool || p.name || p.type || 'tool', summary: '' });
+      const name = p.tool || p.name || p.type || 'tool';
+      const callId = p.callID || p.callId || p.id || undefined;
+      const state = p.state || {};
+      const status = String(state.status || '').toLowerCase();
+      if (status === 'completed' || status === 'error') {
+        emit({
+          type: 'tool', name, phase: 'done', callId,
+          status: status === 'error' ? 'error' : 'ok',
+          result: String(state.output || state.error || '').slice(0, 4000),
+        });
+      } else {
+        emit({ type: 'tool', name, phase: 'start', callId, input: state.input || p.input, summary: '' });
+      }
     } else if (ev.type === 'error') {
       const msg = ev.error?.data?.message || ev.error?.message || ev.error?.name || 'error';
       emit({ type: 'status', text: String(msg).slice(0, 300) });

package/src/server.js

@@ -67,7 +67,7 @@ import {
 // Hardcoded (not read from package.json) so it survives Bun's single-file
 // --compile, where package.json isn't on a readable FS. CI fails the publish if
 // this drifts from package.json, so the two can't silently diverge.
-const VERSION = '0.10.33';
+const VERSION = '0.10.34';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;