@bubblebrain-ai/bubble 0.0.5 → 0.0.6

package/dist/tools/write.js

@@ -1,86 +1,165 @@
 /**
- * Write tool - create or overwrite files.
+ * Write tool - create files or safely replace full file contents.
  */
-import { constants } from "node:fs";
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { createTwoFilesPatch } from "diff";
 import { gateToolAction } from "../approval/tool-helper.js";
 import { formatDiagnosticBlocks } from "../lsp/index.js";
-export function createWriteTool(cwd, options = {}, approval, lsp) {
+import { isWithinWorkspace } from "./file-state.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+export function createWriteTool(cwd, options = {}, approval, lsp, fileState) {
     return {
         name: "write",
         effect: "write_direct",
         requiresApproval: true,
-        description: `Write a file to disk. Creates parent directories if needed.${options.refuseOverwrite ? " Will not overwrite existing files." : ""}`,
+        description: "Write a file to disk. Creates parent directories if needed. For an existing file, use overwrite=true only for full-file replacement after the file has been read or modified in this session; use edit for small targeted changes.",
         parameters: {
             type: "object",
             properties: {
                 path: { type: "string", description: "Path to the file (relative or absolute)" },
                 content: { type: "string", description: "File contents" },
+                overwrite: {
+                    type: "boolean",
+                    description: "Set true only for full-file replacement of an existing file. Existing files must have been read or modified in this session.",
+                },
             },
             required: ["path", "content"],
         },
         async execute(args) {
             const filePath = resolve(cwd, args.path);
-            if (options.refuseOverwrite) {
+            const overwrite = args.overwrite === true;
+            if (!isWithinWorkspace(cwd, filePath)) {
+                return {
+                    content: `Error: Write path is outside the workspace: ${filePath}`,
+                    isError: true,
+                    status: "blocked",
+                    metadata: {
+                        kind: "security",
+                        path: filePath,
+                        reason: "Write path is outside the workspace.",
+                    },
+                };
+            }
+            return withFileMutationQueue(filePath, async () => {
+                let existed = false;
+                let oldContent = "";
                 try {
-                    await access(filePath, constants.F_OK);
+                    oldContent = await readFile(filePath, "utf-8");
+                    existed = true;
+                }
+                catch {
+                    // New file.
+                }
+                if (existed && options.refuseOverwrite && !overwrite) {
                     return {
-                        content: `Error: File already exists: ${filePath}. Use edit tool to modify existing files.`,
+                        content: `Error: File already exists: ${filePath}.\n\n`
+                            + "For small targeted changes, use edit.\n"
+                            + "For a full-file replacement, call write again with overwrite=true. Existing files must be read or modified in this session before they can be safely overwritten.\n"
+                            + "Do not delete and recreate the file just to overwrite it.",
                         isError: true,
                     };
                 }
-                catch {
-                    // file doesn't exist, proceed
+                if (existed && overwrite && options.refuseOverwrite) {
+                    if (!fileState) {
+                        return {
+                            content: `Error: Cannot safely overwrite ${filePath} because file-state tracking is unavailable. `
+                                + "Read the file first in this agent session, then retry the full-file replacement.",
+                            isError: true,
+                            status: "blocked",
+                        };
+                    }
+                    const freshness = await fileState.checkFresh(filePath);
+                    if (!freshness.ok) {
+                        return staleOverwriteResult(filePath, freshness.reason);
+                    }
                 }
-            }
-            let existed = false;
-            let oldContent = "";
-            try {
-                oldContent = await readFile(filePath, "utf-8");
-                existed = true;
-            }
-            catch {
-                // new file
-            }
-            const diff = createTwoFilesPatch(filePath, filePath, oldContent, args.content, "original", "modified", { context: 3 });
-            const gate = await gateToolAction(approval, {
-                type: "write",
-                path: filePath,
-                content: args.content,
-                diff,
-                fileExists: existed,
-            });
-            if (!gate.approved)
-                return gate.result;
-            try {
-                await mkdir(dirname(filePath), { recursive: true });
-                await writeFile(filePath, args.content, "utf-8");
-                const lineCount = args.content.split("\n").length;
-                const verb = existed ? "Updated" : "Wrote";
-                let content = `${verb} ${lineCount} lines to ${filePath}`;
-                if (lsp) {
-                    try {
-                        await lsp.touchFile(filePath, "document");
-                        content += formatDiagnosticBlocks(cwd, filePath, lsp.diagnostics());
+                const diff = createTwoFilesPatch(filePath, filePath, oldContent, args.content, "original", "modified", { context: 3 });
+                const gate = await gateToolAction(approval, {
+                    type: "write",
+                    path: filePath,
+                    content: args.content,
+                    diff,
+                    fileExists: existed,
+                });
+                if (!gate.approved)
+                    return gate.result;
+                if (existed && overwrite && options.refuseOverwrite && fileState) {
+                    const freshness = await fileState.checkFresh(filePath);
+                    if (!freshness.ok) {
+                        return staleOverwriteResult(filePath, freshness.reason);
                     }
-                    catch {
-                        // LSP diagnostics should not turn a successful write into a failed tool call.
+                }
+                try {
+                    await mkdir(dirname(filePath), { recursive: true });
+                    await writeFile(filePath, args.content, "utf-8");
+                    await fileState?.observe(filePath, "write", args.content).catch(() => undefined);
+                    const lineCount = args.content.split("\n").length;
+                    const verb = existed ? "Updated" : "Wrote";
+                    let content = `${verb} ${lineCount} lines to ${filePath}`;
+                    if (lsp) {
+                        try {
+                            await lsp.touchFile(filePath, "document");
+                            content += formatDiagnosticBlocks(cwd, filePath, lsp.diagnostics());
+                        }
+                        catch {
+                            // LSP diagnostics should not turn a successful write into a failed tool call.
+                        }
                     }
+                    return {
+                        content,
+                        status: "success",
+                        metadata: {
+                            kind: "write",
+                            path: filePath,
+                            overwrite,
+                        },
+                    };
                 }
-                return {
-                    content,
-                    status: "success",
-                    metadata: {
-                        kind: "write",
-                        path: filePath,
-                    },
-                };
-            }
-            catch (err) {
-                return { content: `Error: ${err.message}`, isError: true };
-            }
+                catch (err) {
+                    return { content: `Error: ${err.message}`, isError: true };
+                }
+            });
+        },
+    };
+}
+function staleOverwriteResult(filePath, reason) {
+    if (reason === "unobserved") {
+        return {
+            content: `Error: Cannot safely overwrite existing file: ${filePath}.\n\n`
+                + "This file has not been read or modified in this agent session. Read it first, then retry write with overwrite=true.\n"
+                + "For small targeted changes, use edit. Do not delete and recreate the file just to overwrite it.",
+            isError: true,
+            status: "blocked",
+            metadata: {
+                kind: "security",
+                path: filePath,
+                reason,
+            },
+        };
+    }
+    if (reason === "changed") {
+        return {
+            content: `Error: Cannot safely overwrite ${filePath} because it changed since the last read/write/edit in this agent session.\n\n`
+                + "Re-read the file to pick up the latest content, then retry write with overwrite=true if a full-file replacement is still intended.",
+            isError: true,
+            status: "blocked",
+            metadata: {
+                kind: "security",
+                path: filePath,
+                reason,
+            },
+        };
+    }
+    return {
+        content: `Error: Cannot safely overwrite ${filePath} because it is missing now.\n\n`
+            + "Check the path before retrying.",
+        isError: true,
+        status: "blocked",
+        metadata: {
+            kind: "security",
+            path: filePath,
+            reason,
         },
     };
 }

package/dist/tui/display-history.d.ts

@@ -30,6 +30,8 @@ export interface DisplayToolCall {
     args: Record<string, any>;
     rawArguments?: string;
     streamingArgs?: boolean;
+    /** During streaming, an approximate line count derived from `\n` escapes in rawArguments. */
+    streamingNewlineCount?: number;
     status?: "pending" | "running" | "completed" | "error";
     result?: string;
     isError?: boolean;

package/dist/tui/run.js

@@ -18,6 +18,7 @@ import { hashString } from "./render-signature.js";
 import { findToolRenderer } from "./tool-renderers/registry.js";
 import { writeToolKey } from "./tool-renderers/write.js";
 import { formatWritePreview, isWritePreviewTool } from "./tool-renderers/write-preview.js";
+import { extractStreamingArgsHint } from "./streaming-tool-args.js";
 import { getNextPermissionMode, PERMISSION_MODE_INFO } from "../permission/mode.js";
 import { getContextBudget } from "../context/budget.js";
 import { getLspService } from "../lsp/index.js";
@@ -3565,6 +3566,33 @@ function OpenTuiApp(props) {
         let turnStartedAt;
         let runError;
         let runCancelled = false;
+        // Throttle redraws driven by per-token streaming events (reasoning_delta
+        // and tool_call_delta). Both can fire hundreds of times per second on a
+        // long reply; coalescing into ~16fps keeps the transcript alive without
+        // thrashing OpenTUI's layout or re-parsing markdown per token.
+        let pendingStreamingRedrawTimer;
+        const STREAMING_REDRAW_INTERVAL_MS = 60;
+        const buildStreamingDisplay = (status) => ({
+            role: "assistant",
+            content: "",
+            reasoning: assistantReasoning || undefined,
+            toolCalls: toolCalls.length ? [...toolCalls] : undefined,
+            status,
+            streaming: true,
+            turnStartedAt,
+        });
+        const flushStreamingRedraw = () => {
+            if (pendingStreamingRedrawTimer === undefined)
+                return;
+            clearTimeout(pendingStreamingRedrawTimer);
+            pendingStreamingRedrawTimer = undefined;
+            redrawTranscript(buildStreamingDisplay(toolCalls.length ? undefined : "thinking"));
+        };
+        const scheduleStreamingRedraw = () => {
+            if (pendingStreamingRedrawTimer !== undefined)
+                return;
+            pendingStreamingRedrawTimer = setTimeout(flushStreamingRedraw, STREAMING_REDRAW_INTERVAL_MS);
+        };
         try {
             for await (const event of props.agent.run(actualInput, props.args.cwd, { abortSignal: run.abortController.signal })) {
                 if (event.type === "turn_start") {
@@ -3586,41 +3614,60 @@ function OpenTuiApp(props) {
                 }
                 else if (event.type === "reasoning_delta") {
                     assistantReasoning += event.content;
-                    redrawTranscript({
-                        role: "assistant",
-                        content: "",
-                        reasoning: assistantReasoning || undefined,
-                        toolCalls: toolCalls.length ? [...toolCalls] : undefined,
-                        status: "thinking",
-                        streaming: true,
-                        turnStartedAt,
-                    });
+                    scheduleStreamingRedraw();
                 }
                 else if (event.type === "tool_call_start") {
                     currentTurnHasToolCall = true;
+                    // Insert a streaming placeholder so the user sees feedback the moment
+                    // the model commits to a tool call, instead of waiting for the args
+                    // JSON to fully stream + parse.
+                    if (!toolCalls.find((item) => item.id === event.id)) {
+                        toolCalls.push({
+                            id: event.id,
+                            name: event.name,
+                            args: {},
+                            rawArguments: "",
+                            streamingArgs: true,
+                            status: "pending",
+                        });
+                    }
                     redrawTranscript({
                         role: "assistant",
                         content: "",
                         reasoning: assistantReasoning || undefined,
-                        toolCalls: toolCalls.length ? [...toolCalls] : undefined,
-                        status: toolCalls.length ? undefined : "thinking",
+                        toolCalls: [...toolCalls],
                         streaming: true,
                         turnStartedAt,
                     });
                 }
                 else if (event.type === "tool_call_delta") {
                     currentTurnHasToolCall = true;
+                    const existing = toolCalls.find((item) => item.id === event.id);
+                    if (existing) {
+                        existing.name = event.name || existing.name;
+                        existing.rawArguments = event.arguments;
+                        existing.streamingArgs = true;
+                        const hint = extractStreamingArgsHint(event.arguments);
+                        if (hint.path && existing.args.path !== hint.path) {
+                            existing.args = { ...existing.args, path: hint.path };
+                        }
+                        existing.streamingNewlineCount = hint.newlineCount;
+                        scheduleStreamingRedraw();
+                    }
                 }
                 else if (event.type === "tool_call_end") {
                     currentTurnHasToolCall = true;
                 }
                 else if (event.type === "tool_start") {
                     currentTurnHasToolCall = true;
+                    flushStreamingRedraw();
                     const now = Date.now();
                     const existing = toolCalls.find((item) => item.id === event.id);
                     if (existing) {
                         existing.args = event.args;
                         existing.streamingArgs = false;
+                        existing.streamingNewlineCount = undefined;
+                        existing.rawArguments = undefined;
                         existing.status = "running";
                         existing.startedAt = existing.startedAt ?? now;
                     }
@@ -3697,6 +3744,10 @@ function OpenTuiApp(props) {
                     bumpSidebar();
                 }
                 else if (event.type === "turn_end") {
+                    if (pendingStreamingRedrawTimer !== undefined) {
+                        clearTimeout(pendingStreamingRedrawTimer);
+                        pendingStreamingRedrawTimer = undefined;
+                    }
                     if (event.usage) {
                         setSidebarUsage((current) => ({
                             contextTokens: event.usage.promptTokens || current.contextTokens,
@@ -3739,6 +3790,10 @@ function OpenTuiApp(props) {
             }
         }
         finally {
+            if (pendingStreamingRedrawTimer !== undefined) {
+                clearTimeout(pendingStreamingRedrawTimer);
+                pendingStreamingRedrawTimer = undefined;
+            }
             pendingApprovalRef = undefined;
             setPendingApproval(undefined);
             setApprovalOptionIdx(0);
@@ -5139,14 +5194,27 @@ function updateAssistantEntry(entry, message, showThinking, options) {
     if (entry.refs.statusBox) {
         entry.refs.statusBox.visible = showStatus;
     }
+    const streamingReasoning = message.streaming === true;
     if (entry.refs.reasoningToggleText) {
-        entry.refs.reasoningStreaming = message.streaming === true;
+        entry.refs.reasoningStreaming = streamingReasoning;
         entry.refs.reasoningToggleText.content = visibleReasoning
-            ? thinkingLabelContent(message.streaming === true, reasoningElapsedMs(message))
+            ? thinkingLabelContent(streamingReasoning, reasoningElapsedMs(message))
             : new StyledText([fg(theme.messageThinkingText)("")]);
     }
+    // During streaming we update only the plain text node — cheap per-delta. The
+    // markdown node stays hidden + stale. Once streaming ends (turn_end), we
+    // pay the parse cost exactly once and swap visibility.
+    if (entry.refs.reasoningPlainText) {
+        if (streamingReasoning) {
+            entry.refs.reasoningPlainText.content = formatThinkingMarkdown(visibleReasoning);
+        }
+        entry.refs.reasoningPlainText.visible = streamingReasoning && !!visibleReasoning;
+    }
     if (entry.refs.reasoningMarkdown) {
-        syncMarkdownRenderable(entry.refs.reasoningMarkdown, formatThinkingMarkdown(visibleReasoning), message.streaming === true);
+        if (!streamingReasoning) {
+            syncMarkdownRenderable(entry.refs.reasoningMarkdown, formatThinkingMarkdown(visibleReasoning), false);
+        }
+        entry.refs.reasoningMarkdown.visible = !streamingReasoning && !!visibleReasoning;
     }
     if (entry.refs.reasoningBox) {
         entry.refs.reasoningBox.visible = !!visibleReasoning;
@@ -5562,11 +5630,24 @@ function createAssistantEntry(ctx, message, syntaxStyle, subtleSyntaxStyle, key,
         wrapMode: "none",
     });
     refs.reasoningToggleText = labelText;
-    refs.reasoningStreaming = message.streaming === true;
-    const markdown = createMarkdown(ctx, formatThinkingMarkdown(visibleReasoning ?? ""), subtleSyntaxStyle, {
-        streaming: message.streaming === true,
+    const streamingReasoning = message.streaming === true;
+    refs.reasoningStreaming = streamingReasoning;
+    // While the model is still streaming we render reasoning as plain text — a
+    // single TextRenderable.content update is cheap, whereas re-parsing markdown
+    // (treesitter + cache clear) per token grows to O(N²) and freezes the TUI.
+    // The markdown variant is parsed once at turn_end and only then becomes
+    // visible.
+    const plainText = createText(ctx, formatThinkingMarkdown(visibleReasoning ?? ""), {
+        fg: theme.messageThinkingContentText,
+        wrapMode: "word",
+        visible: streamingReasoning && !!visibleReasoning,
+    });
+    refs.reasoningPlainText = plainText;
+    const markdown = createMarkdown(ctx, streamingReasoning ? "" : formatThinkingMarkdown(visibleReasoning ?? ""), subtleSyntaxStyle, {
+        streaming: false,
         fg: theme.messageThinkingContentText,
     });
+    markdown.visible = !streamingReasoning && !!visibleReasoning;
     refs.reasoningMarkdown = markdown;
     const reasoningBox = createBox(ctx, {
         paddingLeft: 2,
@@ -5580,6 +5661,7 @@ function createAssistantEntry(ctx, message, syntaxStyle, subtleSyntaxStyle, key,
         createBox(ctx, {
             flexShrink: 0,
         }, [labelText]),
+        plainText,
         markdown,
     ]);
     refs.reasoningBox = reasoningBox;
@@ -5886,11 +5968,16 @@ function renderTool(tool, syntaxStyle, width = 80) {
         return h("box", { paddingLeft: 3, marginTop: 1, flexDirection: "column", flexShrink: 0 }, h("text", { fg: color }, `${icon} ${displayToolName(tool.name)}${toolHeader(tool) ? ` ${toolHeader(tool)}` : ""}`), h("box", { paddingLeft: 1, marginTop: 1, border: ["left"], borderColor: theme.borderSubtle, flexDirection: "column", flexShrink: 0 }, renderDiffContent(diff, toolPath(tool), syntaxStyle, width)));
     }
     if (isWritePreviewTool(tool)) {
-        const preview = formatWritePreview(tool.args.content, false);
-        const summary = tool.result ?? `${isToolFinished(tool) ? "Prepared" : "Writing"} ${tool.args.content.split(/\r?\n/).length} lines to ${toolPath(tool) ?? "file"}`;
-        return h("box", { paddingLeft: 3, marginTop: 1, flexDirection: "column", flexShrink: 0 }, h("text", { fg: color }, `${icon} ${displayToolName(tool.name)}${toolHeader(tool) ? ` ${toolHeader(tool)}` : ""}`), h("box", { paddingLeft: 1, marginTop: 0, border: ["left"], borderColor: theme.borderSubtle, flexDirection: "column", flexShrink: 0 }, h("text", { fg: theme.textMuted }, `└ ${summary}`), renderCodeBlockContent(preview.content, toolPath(tool), syntaxStyle), preview.omittedLines > 0
+        const hasContent = typeof tool.args.content === "string";
+        const contentStr = hasContent ? String(tool.args.content) : "";
+        const preview = hasContent ? formatWritePreview(contentStr, false) : null;
+        const lineCount = hasContent
+            ? contentStr.split(/\r?\n/).length
+            : (tool.streamingNewlineCount ?? 0) + 1;
+        const summary = tool.result ?? `${isToolFinished(tool) ? "Prepared" : "Writing"} ${lineCount} lines to ${toolPath(tool) ?? "file"}`;
+        return h("box", { paddingLeft: 3, marginTop: 1, flexDirection: "column", flexShrink: 0 }, h("text", { fg: color }, `${icon} ${displayToolName(tool.name)}${toolHeader(tool) ? ` ${toolHeader(tool)}` : ""}`), h("box", { paddingLeft: 1, marginTop: 0, border: ["left"], borderColor: theme.borderSubtle, flexDirection: "column", flexShrink: 0 }, h("text", { fg: theme.textMuted }, `└ ${summary}`), preview ? renderCodeBlockContent(preview.content, toolPath(tool), syntaxStyle) : null, preview && preview.omittedLines > 0
             ? h("text", { fg: theme.textMuted }, `... +${preview.omittedLines} lines (ctrl+o to expand)`)
-            : preview.omittedChars > 0
+            : preview && preview.omittedChars > 0
                 ? h("text", { fg: theme.textMuted }, `... +${preview.omittedChars} chars (ctrl+o to expand)`)
                 : null));
     }
@@ -6750,8 +6837,13 @@ function formatDuration(ms) {
         return `${seconds.toFixed(1)}s`;
     if (seconds < 60)
         return `${Math.round(seconds)}s`;
-    const minutes = Math.floor(seconds / 60);
-    const remSec = Math.round(seconds - minutes * 60);
+    let minutes = Math.floor(seconds / 60);
+    let remSec = Math.round(seconds - minutes * 60);
+    // Math.round can lift remSec to exactly 60 (e.g. 239.6s → 3m60s). Carry into minutes.
+    if (remSec >= 60) {
+        minutes += Math.floor(remSec / 60);
+        remSec = remSec % 60;
+    }
     return remSec === 0 ? `${minutes}m` : `${minutes}m${remSec}s`;
 }
 function reasoningElapsedMs(message) {

package/dist/tui/streaming-tool-args.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Extract user-visible signals from a partial tool-call JSON buffer.
+ *
+ * We deliberately do NOT attempt a full partial-JSON parse. The goal is just
+ * to surface the file path (so the tool header can render) and a coarse
+ * "how much has been streamed" hint, both available the moment the model has
+ * emitted enough text for them to be unambiguous.
+ */
+export interface StreamingArgsHint {
+    /** First fully-closed string value found for a known path field. */
+    path?: string;
+    /** Count of escaped newline sequences (`\n`) seen so far — proxy for written line count. */
+    newlineCount: number;
+}
+export declare function extractStreamingArgsHint(raw: string): StreamingArgsHint;

package/dist/tui/streaming-tool-args.js

@@ -0,0 +1,30 @@
+/**
+ * Extract user-visible signals from a partial tool-call JSON buffer.
+ *
+ * We deliberately do NOT attempt a full partial-JSON parse. The goal is just
+ * to surface the file path (so the tool header can render) and a coarse
+ * "how much has been streamed" hint, both available the moment the model has
+ * emitted enough text for them to be unambiguous.
+ */
+const PATH_FIELDS = ["path", "file_path", "filePath"];
+export function extractStreamingArgsHint(raw) {
+    let path;
+    for (const field of PATH_FIELDS) {
+        const re = new RegExp(`"${field}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`);
+        const m = raw.match(re);
+        if (m) {
+            try {
+                path = JSON.parse(`"${m[1]}"`);
+                break;
+            }
+            catch {
+                // The matched substring ended mid-escape; ignore and wait for more.
+            }
+        }
+    }
+    const newlines = raw.match(/\\n/g);
+    return {
+        path,
+        newlineCount: newlines ? newlines.length : 0,
+    };
+}

package/dist/tui/tool-renderers/write-preview.d.ts

@@ -2,7 +2,7 @@ import type { DisplayToolCall } from "../display-history.js";
 export declare const WRITE_PREVIEW_CHAR_LIMIT = 5000;
 export declare function isWritePreviewTool(tool: DisplayToolCall): tool is DisplayToolCall & {
     args: {
-        content: string;
+        content?: string;
     };
 };
 export declare function formatWritePreview(content: string, expanded: boolean): {

package/dist/tui/tool-renderers/write-preview.js

@@ -1,7 +1,15 @@
 const WRITE_PREVIEW_LINE_LIMIT = 10;
 export const WRITE_PREVIEW_CHAR_LIMIT = 5000;
 export function isWritePreviewTool(tool) {
-    return !tool.isError && tool.name === "write" && typeof tool.args?.content === "string";
+    if (tool.isError)
+        return false;
+    if (tool.name !== "write")
+        return false;
+    if (typeof tool.args?.content === "string")
+        return true;
+    // While the model is still streaming the JSON args, content may not be
+    // populated yet — keep ownership so the header renders progressively.
+    return tool.streamingArgs === true;
 }
 export function formatWritePreview(content, expanded) {
     const lines = content.split(/\r?\n/);

package/dist/tui/tool-renderers/write.js

@@ -19,7 +19,7 @@ export function writeToolExpansionDigest(message, messageKey, expandedWrites) {
 export function writeToolExpansionSignature(messageKey, tool, expandedWrites) {
     if (!isWritePreviewTool(tool))
         return "";
-    const content = tool.args.content;
+    const content = typeof tool.args.content === "string" ? tool.args.content : "";
     return [
         tool.id,
         expandedWrites.has(writeToolKey(messageKey, tool)) ? "expanded" : "collapsed",
@@ -34,16 +34,20 @@ function renderWriteTool({ ctx, tool, syntaxStyle, writeExpanded, onToggleWrite,
     const color = helpers.toolColor(tool);
     const icon = "●";
     const header = helpers.toolHeader(tool);
-    const preview = formatWritePreview(String(tool.args.content), writeExpanded);
-    const writeLineCount = String(tool.args.content).split(/\r?\n/).length;
+    const hasContent = typeof tool.args.content === "string";
+    const contentStr = hasContent ? String(tool.args.content) : "";
+    const preview = hasContent ? formatWritePreview(contentStr, writeExpanded) : null;
+    const writeLineCount = hasContent
+        ? contentStr.split(/\r?\n/).length
+        : (tool.streamingNewlineCount ?? 0) + 1;
     const summary = tool.result
         ? helpers.summarizeToolResult(tool)
         : `${helpers.isToolFinished(tool) ? "Prepared" : "Writing"} ${writeLineCount} line${writeLineCount === 1 ? "" : "s"} to ${helpers.toolPath(tool) ?? "file"}`;
-    const hint = preview.omittedLines > 0
+    const hint = preview && preview.omittedLines > 0
         ? `... +${preview.omittedLines} lines (${writeExpanded ? "ctrl+o to collapse" : "ctrl+o to expand"})`
-        : preview.omittedChars > 0
+        : preview && preview.omittedChars > 0
             ? `... +${preview.omittedChars} chars (${writeExpanded ? "ctrl+o to collapse" : "ctrl+o to expand"})`
-            : writeExpanded
+            : preview && writeExpanded
                 ? "(ctrl+o to collapse)"
                 : "";
     return helpers.createBox(ctx, {
@@ -70,7 +74,9 @@ function renderWriteTool({ ctx, tool, syntaxStyle, writeExpanded, onToggleWrite,
                 fg: tool.isError ? theme.toolError : theme.textMuted,
                 onMouseUp: onToggleWrite,
             }),
-            helpers.createCodeBlockRenderable(ctx, preview.content, helpers.toolPath(tool), syntaxStyle),
+            preview
+                ? helpers.createCodeBlockRenderable(ctx, preview.content, helpers.toolPath(tool), syntaxStyle)
+                : null,
             hint
                 ? helpers.createText(ctx, hint, {
                     fg: theme.textMuted,

package/dist/types.d.ts

@@ -72,9 +72,23 @@ export interface ToolCall {
     id: string;
     name: string;
     arguments: string;
+    /**
+     * Provider-side flag set when the streamed arguments were unsalvageable
+     * (truncated mid-JSON, malformed snapshot). Persists into history so the
+     * model and the orchestrator can both see the call was rejected upstream
+     * rather than executed silently with empty args.
+     */
+    argsCorrupt?: boolean;
 }
 export interface ParsedToolCall extends ToolCall {
     parsedArgs: Record<string, any>;
+    /**
+     * Set when the raw `arguments` string failed to JSON.parse, indicating
+     * upstream streaming corruption (truncated chunks, malformed deltas, etc.).
+     * Consumers should refuse to execute the tool and surface a tool_use_error
+     * so the model can re-issue the call.
+     */
+    argsCorrupt?: boolean;
 }
 export type ToolResultStatus = "success" | "no_match" | "partial" | "timeout" | "blocked" | "command_error";
 export interface ToolResultMetadata {
@@ -214,6 +228,7 @@ export type StreamChunk = {
     isStart: boolean;
     isEnd: boolean;
     argumentsFull?: string;
+    argumentsCorrupt?: boolean;
 } | {
     type: "usage";
     usage: TokenUsage;

package/package.json

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