@bubblebrain-ai/bubble 0.0.30 → 0.0.31

package/dist/agent/child-runner.js

@@ -88,6 +88,13 @@ export class ChildRunner {
                 record.abortController.signal,
             ]);
             for await (const event of subAgent.run(input, runCwd, { abortSignal: childAbortSignal, resumeWithoutInput })) {
+                if (event.type === "turn_start") {
+                    // Leftovers here belong to a half-built attempt the agent discarded
+                    // (stream-interruption retry re-issues the whole request); keeping
+                    // them would duplicate the retried text in the turn summary.
+                    turnSummaryBuffer = "";
+                    turnHadToolCall = false;
+                }
                 if (event.type === "text_delta") {
                     turnSummaryBuffer += event.content;
                 }
@@ -213,6 +220,11 @@ export class ChildRunner {
         let finalHadToolCall = false;
         const finalAbortSignal = composeAbortSignals([abortSignal, record.abortController.signal]);
         for await (const event of subAgent.run(prompt, cwd, { abortSignal: finalAbortSignal })) {
+            if (event.type === "turn_start") {
+                // Discarded stream-interruption attempt — drop its partial text so the
+                // retried response doesn't carry a duplicated prefix.
+                finalBuffer = "";
+            }
             if (event.type === "text_delta") {
                 finalBuffer += event.content;
             }

package/dist/feishu/card/run-state.js

@@ -13,7 +13,12 @@ export function reduceRunState(state, event) {
     state.updatedAt = Date.now();
     switch (event.type) {
         case "turn_start":
-            // No state change — just signals a new LLM round trip.
+            // A new LLM round trip. turn_end settles (closes) the blocks of every
+            // finished call, so anything still marked streaming here belongs to a
+            // half-built attempt the agent discarded (its stream-interruption retry
+            // re-issues the whole request). Drop it, or the retry re-streams the
+            // same opening text into the block and the card shows it twice.
+            state.blocks = state.blocks.filter((block) => !((block.kind === "text" || block.kind === "thinking") && block.streaming));
             return state;
         case "text_delta": {
             const last = state.blocks[state.blocks.length - 1];
@@ -81,6 +86,9 @@ export function reduceRunState(state, event) {
             return state;
         }
         case "turn_end": {
+            // Settle this call's output so the turn_start cleanup above can tell
+            // kept content (closed here) apart from a discarded retry attempt.
+            closeStreamingBlocks(state);
             if (event.usage) {
                 state.usage = mergeUsage(state.usage, event.usage);
             }

package/dist/main.js

@@ -483,9 +483,22 @@ async function main() {
                 console.error(chalk.red("Error: No prompt provided."));
                 process.exit(1);
             }
+            let printedTurnText = false;
             for await (const event of agent.run(prompt, args.cwd)) {
                 traceEvent("print_agent_event", summarizeAgentEventForTrace(event));
-                if (event.type === "text_delta") {
+                if (event.type === "turn_start") {
+                    printedTurnText = false;
+                }
+                else if (event.type === "provider_retry") {
+                    // The stream died mid-response and the agent re-issues the whole
+                    // request. Text already on stdout cannot be un-printed, so at least
+                    // separate the retried response and say what happened.
+                    if (printedTurnText)
+                        process.stdout.write("\n");
+                    console.error(chalk.yellow(`[Stream interrupted; retrying (${event.attempt}/${event.maxAttempts}) — the partial text above is superseded by the retried response]`));
+                }
+                else if (event.type === "text_delta") {
+                    printedTurnText = true;
                     process.stdout.write(event.content);
                 }
                 else if (event.type === "tool_start") {

package/dist/tui-ink/app.js

@@ -1125,6 +1125,16 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                         inputController,
                     })) {
                         switch (event.type) {
+                            case "turn_start":
+                                // A fresh provider call is starting. Everything worth keeping
+                                // was committed at the preceding turn_end, so leftovers here
+                                // can only be a half-built attempt the agent discarded (its
+                                // stream-interruption retry re-issues the whole request and
+                                // never appends the partial message — see agent.ts). Drop the
+                                // stale buffer, or the retry re-streams the same opening text
+                                // on top of it and the answer duplicates on screen.
+                                clearAssistantStream();
+                                break;
                             case "text_delta":
                                 assistantContent += event.content;
                                 appendTextPart(assistantParts, event.content);

package/dist/tui-ink/markdown.js

@@ -5,7 +5,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
  */
 import React from "react";
 import { Box, Text } from "ink";
-import { visualWidth, graphemeWidth } from "./width.js";
+import { ambiguousIsWide, visualWidth, graphemeWidth } from "./width.js";
 import { useTerminalSize } from "./use-terminal-size.js";
 import { useTheme } from "./theme.js";
 import { highlightCode, highlightCodeSync } from "./code-highlight.js";
@@ -383,6 +383,15 @@ function TableBlock({ headers, rows, maxWidth, }) {
     // Reserve a buffer so the table fits even when wrapped inside an indented
     // box (e.g. the timeline gutter contributes marginLeft + "●  " = 5 cells).
     const budget = Math.max(20, (maxWidth ?? termWidth) - 8);
+    // Box-drawing ─│┌┬┼… are East Asian *Ambiguous*-width: on a terminal that
+    // renders them 2 cells wide, border rows would paint at twice the width the
+    // cell rows were budgeted for (and twice what Ink itself measures), so the
+    // terminal hard-wraps them into scattered fragments. There is no way to hit
+    // odd widths with 2-cell dashes, so on such terminals draw ASCII borders —
+    // the only glyphs whose width every layer agrees on.
+    const g = ambiguousIsWide()
+        ? { h: "-", v: "|", tl: "+", tm: "+", tr: "+", ml: "+", mm: "+", mr: "+", bl: "+", bm: "+", br: "+" }
+        : { h: "─", v: "│", tl: "┌", tm: "┬", tr: "┐", ml: "├", mm: "┼", mr: "┤", bl: "└", bm: "┴", br: "┘" };
     const maxWidths = headers.map((h, i) => {
         let max = visualWidth(inlinePlainText(h));
         for (const row of rows) {
@@ -399,11 +408,26 @@ function TableBlock({ headers, rows, maxWidth, }) {
         const available = Math.max(budget - separatorsWidth, colCount * 4);
         const ratio = totalInnerWidth > 0 ? available / totalInnerWidth : 1;
         widths = maxWidths.map((w) => Math.max(4, Math.floor(w * ratio)));
+        // The 4-cell floor can push the sum back above `available`; shave the
+        // overshoot off the widest columns so the row never exceeds the budget
+        // and gets hard-wrapped by the terminal.
+        let excess = widths.reduce((a, b) => a + b, 0) - available;
+        while (excess > 0) {
+            let widest = -1;
+            for (let i = 0; i < widths.length; i++) {
+                if (widths[i] > 4 && (widest === -1 || widths[i] > widths[widest]))
+                    widest = i;
+            }
+            if (widest === -1)
+                break;
+            widths[widest] -= 1;
+            excess -= 1;
+        }
     }
-    const top = "┌" + widths.map((w) => "─".repeat(w + 2)).join("┬") + "┐";
-    const mid = "├" + widths.map((w) => "─".repeat(w + 2)).join("┼") + "┤";
-    const bot = "└" + widths.map((w) => "─".repeat(w + 2)).join("┴") + "┘";
-    const renderRow = (cells, keyPrefix, isHeader = false) => (_jsxs(Text, { children: ["│ ", cells.map((c, i) => (_jsxs(React.Fragment, { children: [renderTableCell(c, widths[i] ?? 4, isHeader, `${keyPrefix}-cell-${i}`), i < colCount - 1 ? " │ " : " │"] }, i)))] }, keyPrefix));
+    const top = g.tl + widths.map((w) => g.h.repeat(w + 2)).join(g.tm) + g.tr;
+    const mid = g.ml + widths.map((w) => g.h.repeat(w + 2)).join(g.mm) + g.mr;
+    const bot = g.bl + widths.map((w) => g.h.repeat(w + 2)).join(g.bm) + g.br;
+    const renderRow = (cells, keyPrefix, isHeader = false) => (_jsxs(Text, { children: [`${g.v} `, cells.map((c, i) => (_jsxs(React.Fragment, { children: [renderTableCell(c, widths[i] ?? 4, isHeader, `${keyPrefix}-cell-${i}`), i < colCount - 1 ? ` ${g.v} ` : ` ${g.v}`] }, i)))] }, keyPrefix));
     return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { children: top }), renderRow(headers, "header", true), _jsx(Text, { children: mid }), rows.map((row, ri) => renderRow(row, `row-${ri}`)), _jsx(Text, { children: bot })] }));
 }
 function renderTableCell(cell, width, isHeader, keyPrefix) {
@@ -417,9 +441,12 @@ function renderTableCell(cell, width, isHeader, keyPrefix) {
 function truncateInlineSegments(segments, width) {
     if (inlineSegmentsWidth(segments) <= width)
         return segments;
-    if (width <= 1)
+    // The ellipsis is itself ambiguous-width (2 cells on an ambiguous-wide
+    // terminal) — reserve its real width or every truncated cell overflows.
+    const ellipsisWidth = graphemeWidth("…");
+    if (width <= ellipsisWidth)
         return [{ text: "…" }];
-    const target = width - 1;
+    const target = width - ellipsisWidth;
     const output = [];
     let used = 0;
     for (const segment of segments) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {