@bubblebrain-ai/bubble 0.0.30 → 0.0.32

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.d.ts

@@ -44,6 +44,13 @@ export declare function parseMarkdownBlocks(text: string): MarkdownBlock[];
  */
 export declare function findLastBlockStart(text: string): number;
 export declare function parseMarkdownInlineSegments(text: string, style?: InlineStyle): MarkdownInlineSegment[];
+/**
+ * Distribute `available` inner cells across columns. Columns whose natural
+ * width already fits their fair share keep it untouched (numbers and dates
+ * never wrap); only the wider columns split the remainder proportionally and
+ * wrap their content.
+ */
+export declare function allocateColumnWidths(natural: number[], available: number): number[];
 /**
  * CJK-aware line wrap over styled inline segments.
  *

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) {
@@ -397,17 +406,92 @@ function TableBlock({ headers, rows, maxWidth, }) {
     let widths = [...maxWidths];
     if (totalWidth > budget) {
         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)));
+        widths = allocateColumnWidths(maxWidths, available);
     }
-    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;
+    // A cell wider than its column wraps onto continuation lines (CJK-aware, so
+    // 、-joined user lists break cleanly); the row grows to its tallest cell.
+    const renderRow = (cells, keyPrefix, isHeader = false) => {
+        const wrapped = cells.map((c, i) => {
+            const width = widths[i] ?? 4;
+            let lines = wrapInlineSegments(parseMarkdownInlineSegments(c, { bold: isHeader }), width);
+            if (lines.length > MAX_TABLE_CELL_LINES) {
+                lines = lines.slice(0, MAX_TABLE_CELL_LINES);
+                const last = lines[MAX_TABLE_CELL_LINES - 1];
+                lines[MAX_TABLE_CELL_LINES - 1] = truncateInlineSegments([...last, { text: " …" }], width);
+            }
+            return lines;
+        });
+        const height = Math.max(1, ...wrapped.map((lines) => lines.length));
+        return (_jsx(Box, { flexDirection: "column", children: Array.from({ length: height }, (_, line) => (_jsxs(Text, { children: [`${g.v} `, wrapped.map((cellLines, i) => (_jsxs(React.Fragment, { children: [renderCellLine(cellLines[line] ?? [], widths[i] ?? 4, `${keyPrefix}-cell-${i}-${line}`), i < colCount - 1 ? ` ${g.v} ` : ` ${g.v}`] }, i)))] }, `${keyPrefix}-line-${line}`))) }, 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) {
-    const segments = truncateInlineSegments(parseMarkdownInlineSegments(cell, { bold: isHeader }), width);
+/** Cap a pathological cell (huge blob of text) at this many wrapped lines. */
+const MAX_TABLE_CELL_LINES = 8;
+/**
+ * Distribute `available` inner cells across columns. Columns whose natural
+ * width already fits their fair share keep it untouched (numbers and dates
+ * never wrap); only the wider columns split the remainder proportionally and
+ * wrap their content.
+ */
+export function allocateColumnWidths(natural, available) {
+    const count = natural.length;
+    const widths = new Array(count).fill(0);
+    const fixed = new Array(count).fill(false);
+    let remaining = available;
+    let unfixed = count;
+    // Each fixed column frees slack that can fit further columns — iterate to a
+    // fixpoint. Terminates: natural sum exceeds `available` (only caller path),
+    // so at least one column always stays unfixed.
+    let changed = true;
+    while (changed && unfixed > 0) {
+        changed = false;
+        const fair = remaining / unfixed;
+        for (let i = 0; i < count; i++) {
+            if (fixed[i] || natural[i] > fair)
+                continue;
+            fixed[i] = true;
+            widths[i] = natural[i];
+            remaining -= natural[i];
+            unfixed -= 1;
+            changed = true;
+        }
+    }
+    if (unfixed > 0) {
+        const wideTotal = natural.reduce((sum, w, i) => sum + (fixed[i] ? 0 : w), 0);
+        let assigned = 0;
+        let lastWide = -1;
+        for (let i = 0; i < count; i++) {
+            if (fixed[i])
+                continue;
+            widths[i] = Math.max(4, Math.floor((remaining * natural[i]) / wideTotal));
+            assigned += widths[i];
+            lastWide = i;
+        }
+        // Flooring leftovers go to the last wide column instead of being wasted.
+        if (lastWide >= 0 && assigned < remaining)
+            widths[lastWide] += remaining - assigned;
+    }
+    // On a very narrow budget the 4-cell floor can overshoot; shave the widest
+    // columns so the row never exceeds `available` and hard-wraps.
+    let excess = widths.reduce((a, b) => a + b, 0) - available;
+    while (excess > 0) {
+        let widest = -1;
+        for (let i = 0; i < count; i++) {
+            if (widths[i] > 4 && (widest === -1 || widths[i] > widths[widest]))
+                widest = i;
+        }
+        if (widest === -1)
+            break;
+        widths[widest] -= 1;
+        excess -= 1;
+    }
+    return widths;
+}
+function renderCellLine(segments, width, keyPrefix) {
     const padding = " ".repeat(Math.max(0, width - inlineSegmentsWidth(segments)));
     return [
         ...segments.map((segment, index) => (_jsx(Text, { bold: segment.bold, italic: segment.italic, color: segment.code ? "#a78bfa" : undefined, children: segment.text }, `${keyPrefix}-${index}`))),
@@ -417,9 +501,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/dist/tui-ink/message-list.js

@@ -139,7 +139,11 @@ const MessageItem = React.memo(function MessageItem({ message, terminalColumns,
         message.taskElapsedMs !== undefined;
     if (!hasVisibleAssistantContent)
         return null;
-    return (_jsxs(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column", children: [visibleReasoning && (showThinking || verboseTrace) && _jsx(ReasoningTraceBlock, { reasoning: visibleReasoning }), message.parts && message.parts.length > 0 ? (_jsx(MessageParts, { parts: message.parts, terminalColumns: terminalColumns, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })) : (_jsxs(_Fragment, { children: [message.toolCalls && (_jsx(ToolsPart, { toolCalls: message.toolCalls, terminalColumns: terminalColumns, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })), visibleContent.trim() && _jsx(MarkdownContent, { content: visibleContent })] })), verboseTrace && message.toolCalls && message.toolCalls.length > 0 && (_jsx(TurnDigest, { toolCalls: message.toolCalls })), message.taskElapsedMs !== undefined && (_jsx(TaskDurationLine, { elapsedMs: message.taskElapsedMs }))] }));
+    return (_jsxs(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column", children: [visibleReasoning && (showThinking || verboseTrace) && _jsx(ReasoningTraceBlock, { reasoning: visibleReasoning }), message.parts && message.parts.length > 0 ? (_jsx(MessageParts, { parts: message.parts, terminalColumns: terminalColumns, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })) : (_jsxs(_Fragment, { children: [message.toolCalls && (_jsx(ToolsPart, { toolCalls: message.toolCalls, terminalColumns: terminalColumns, verboseTrace: verboseTrace, pendingApproval: undefined, showExpandHint: showExpandHint, nowTick: nowTick })), visibleContent.trim() && (
+                    // Thread the real terminal width down (minus the row's paddingX
+                    // inset); without it, width-aware blocks like tables fall back to
+                    // a stale/default useTerminalSize and mis-budget their columns.
+                    _jsx(MarkdownContent, { content: visibleContent, maxWidth: Math.max(20, terminalColumns - 4) }))] })), verboseTrace && message.toolCalls && message.toolCalls.length > 0 && (_jsx(TurnDigest, { toolCalls: message.toolCalls })), message.taskElapsedMs !== undefined && (_jsx(TaskDurationLine, { elapsedMs: message.taskElapsedMs }))] }));
 });
 function StreamingMessage({ content, reasoning, tools, parts, terminalColumns, showThinking, verboseTrace, pendingApproval, nowTick, }) {
     const deferredContent = React.useDeferredValue(content);

package/package.json

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