@bubblebrain-ai/bubble 0.0.4 → 0.0.6

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

@@ -0,0 +1,2 @@
+import type { ToolRenderer } from "./types.js";
+export declare const fallbackToolRenderer: ToolRenderer;

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

@@ -0,0 +1,75 @@
+import { fg, StyledText } from "@opentui/core";
+export const fallbackToolRenderer = {
+    canRender: (_tool) => true,
+    render: renderFallbackTool,
+};
+function renderFallbackTool({ ctx, tool, syntaxStyle, width, helpers }) {
+    const { theme } = helpers;
+    const icon = helpers.toolStateIcon(tool);
+    const color = helpers.toolColor(tool);
+    const header = helpers.toolHeader(tool);
+    const diff = helpers.extractToolDiff(tool);
+    const isError = tool.isError === true || tool.status === "error";
+    if (diff && !isError && tool.name === "edit") {
+        return helpers.createBox(ctx, {
+            paddingLeft: 3,
+            marginTop: 1,
+            flexDirection: "column",
+            flexShrink: 0,
+        }, [
+            helpers.createText(ctx, new StyledText([
+                fg(color)(`${icon} ${helpers.displayToolName(tool.name)}`),
+                fg(theme.toolText)(header ? ` ${header}` : ""),
+            ])),
+            helpers.createBox(ctx, {
+                paddingLeft: 1,
+                marginTop: 1,
+                border: ["left"],
+                borderColor: theme.borderSubtle,
+                flexDirection: "column",
+                flexShrink: 0,
+            }, [helpers.createDiffRenderable(ctx, diff, helpers.toolPath(tool), syntaxStyle, width)]),
+        ]);
+    }
+    const chunks = [
+        fg(color)(`${icon} ${helpers.displayToolName(tool.name)}`),
+    ];
+    if (header)
+        chunks.push(fg(theme.toolText)(` ${header}`));
+    const showTail = !!tool.result || tool.status === "running" || tool.status === "pending" || tool.streamingArgs === true;
+    if (showTail) {
+        const summary = helpers.summarizeToolResult(tool);
+        if (summary) {
+            chunks.push(fg(theme.text)("\n"));
+            chunks.push(fg(theme.borderSubtle)("  "));
+            chunks.push(fg(isError ? theme.toolError : theme.textMuted)(summary));
+        }
+        const preview = helpers.toolPreview(tool);
+        if (preview) {
+            for (const line of preview.lines) {
+                chunks.push(fg(theme.text)("\n"));
+                chunks.push(fg(theme.borderSubtle)("  "));
+                chunks.push(fg(theme.toolText)(line));
+            }
+            if (preview.omitted > 0) {
+                chunks.push(fg(theme.text)("\n"));
+                chunks.push(fg(theme.borderSubtle)("  "));
+                chunks.push(fg(theme.textMuted)(`+ ${preview.omitted} more`));
+            }
+        }
+    }
+    const containerProps = {
+        paddingLeft: isError ? 1 : 3,
+        marginTop: 1,
+        flexDirection: "column",
+        flexShrink: 0,
+    };
+    if (isError) {
+        containerProps.border = ["left"];
+        containerProps.borderColor = theme.toolError;
+        containerProps.paddingLeft = 2;
+    }
+    return helpers.createBox(ctx, containerProps, [
+        helpers.createText(ctx, new StyledText(chunks), { wrapMode: "word" }),
+    ]);
+}

package/dist/tui/tool-renderers/registry.d.ts

@@ -0,0 +1,3 @@
+import type { DisplayToolCall } from "../display-history.js";
+import type { ToolRenderer } from "./types.js";
+export declare function findToolRenderer(tool: DisplayToolCall): ToolRenderer | undefined;

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

@@ -0,0 +1,11 @@
+import { fallbackToolRenderer } from "./fallback.js";
+import { subagentToolRenderer } from "./subagent.js";
+import { writeToolRenderer } from "./write.js";
+const TOOL_RENDERERS = [
+    writeToolRenderer,
+    subagentToolRenderer,
+    fallbackToolRenderer,
+];
+export function findToolRenderer(tool) {
+    return TOOL_RENDERERS.find((renderer) => renderer.canRender(tool));
+}

package/dist/tui/tool-renderers/subagent.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRenderer } from "./types.js";
+export declare const subagentToolRenderer: ToolRenderer;

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

@@ -0,0 +1,114 @@
+import { fg, StyledText } from "@opentui/core";
+export const subagentToolRenderer = {
+    canRender: (tool) => tool.name === "subagent" || tool.metadata?.kind === "subagent",
+    render: renderSubagentTool,
+};
+function renderSubagentTool({ ctx, tool, width, helpers }) {
+    const { theme } = helpers;
+    const metadata = tool.metadata ?? {};
+    const subagents = subagentsFrom(tool);
+    const mode = typeof metadata.mode === "string" ? metadata.mode : (subagents.length > 1 ? "parallel" : "single");
+    const completed = subagents.filter((item) => item.status === "completed").length;
+    const color = tool.isError ? theme.toolError : tool.status === "running" ? theme.toolPending : theme.toolSuccess;
+    const headerChunks = [
+        fg(color)(`> ${helpers.displayToolName(tool.name)}`),
+        fg(theme.toolText)(` ${mode}`),
+    ];
+    if (subagents.length > 0) {
+        headerChunks.push(fg(theme.textMuted)(` ${completed}/${subagents.length}`));
+    }
+    const children = [
+        helpers.createText(ctx, new StyledText(headerChunks), { wrapMode: "word" }),
+    ];
+    const rows = subagents.map((subagent) => renderSubagentRow(ctx, subagent, width, helpers));
+    if (rows.length > 0) {
+        children.push(helpers.createBox(ctx, {
+            paddingLeft: 1,
+            marginTop: 0,
+            border: ["left"],
+            borderColor: theme.borderSubtle,
+            flexDirection: "column",
+            flexShrink: 0,
+        }, rows));
+    }
+    else if (tool.result) {
+        children.push(helpers.createText(ctx, helpers.summarizeToolResult(tool), {
+            fg: tool.isError ? theme.toolError : theme.textMuted,
+            wrapMode: "word",
+        }));
+    }
+    return helpers.createBox(ctx, {
+        paddingLeft: 3,
+        marginTop: 1,
+        flexDirection: "column",
+        flexShrink: 0,
+    }, children);
+}
+function renderSubagentRow(ctx, subagent, width, helpers) {
+    const { theme } = helpers;
+    const status = subagent.status ?? "running";
+    const color = status === "completed"
+        ? theme.toolSuccess
+        : status === "running" || status === "queued"
+            ? theme.toolPending
+            : theme.toolError;
+    const source = subagent.profileSource ? ` [${subagent.profileSource}]` : "";
+    const usage = subagent.usage?.totalTokens ? ` ${subagent.usage.totalTokens} tokens` : "";
+    const summary = firstUsefulLine(subagent.error || subagent.summary || lastToolNote(subagent.toolNotes));
+    const task = firstUsefulLine(subagent.task);
+    const maxLine = Math.max(24, width - 12);
+    const lines = [
+        helpers.createText(ctx, new StyledText([
+            fg(color)(`${statusIcon(status)} ${subagentLabel(subagent)}`),
+            fg(theme.textMuted)(`${source} ${status}${usage}`),
+        ]), { wrapMode: "word" }),
+    ];
+    if (task) {
+        lines.push(helpers.createText(ctx, shorten(`task: ${task}`, maxLine), {
+            fg: theme.textMuted,
+            wrapMode: "word",
+        }));
+    }
+    if (summary) {
+        lines.push(helpers.createText(ctx, shorten(summary, maxLine), {
+            fg: subagent.error ? theme.toolError : theme.toolText,
+            wrapMode: "word",
+        }));
+    }
+    return helpers.createBox(ctx, {
+        flexDirection: "column",
+        flexShrink: 0,
+    }, lines);
+}
+function subagentLabel(subagent) {
+    if (subagent.nickname && subagent.agentName) {
+        return `${subagent.nickname} (${subagent.agentName})`;
+    }
+    return subagent.nickname ?? subagent.agentName ?? "subagent";
+}
+function subagentsFrom(tool) {
+    const raw = tool.metadata?.subagents;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((item) => typeof item === "object" && item !== null);
+}
+function statusIcon(status) {
+    if (status === "completed")
+        return "+";
+    if (status === "running")
+        return ">";
+    if (status === "queued")
+        return ".";
+    return "!";
+}
+function lastToolNote(notes) {
+    return notes?.filter(Boolean).at(-1);
+}
+function firstUsefulLine(value) {
+    return value?.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
+}
+function shorten(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, Math.max(0, max - 3))}...`;
+}

package/dist/tui/tool-renderers/types.d.ts

@@ -0,0 +1,36 @@
+import type { RenderContext, Renderable, StyledText, SyntaxStyle, TextRenderable } from "@opentui/core";
+import type { DisplayToolCall } from "../display-history.js";
+export interface ToolRenderer {
+    canRender(tool: DisplayToolCall): boolean;
+    expansionKey?(messageKey: string, tool: DisplayToolCall): string | undefined;
+    signature?(messageKey: string, tool: DisplayToolCall, expandedWrites: Set<string>): string;
+    render(context: ToolRenderContext): Renderable;
+}
+export interface ToolRenderContext {
+    ctx: RenderContext;
+    tool: DisplayToolCall;
+    syntaxStyle: SyntaxStyle;
+    width: number;
+    writeExpanded: boolean;
+    onToggleWrite?: () => void;
+    helpers: ToolRenderHelpers;
+}
+export interface ToolRenderHelpers {
+    theme: Record<string, string>;
+    createBox: (ctx: RenderContext, options: Record<string, unknown>, children?: Array<Renderable | null | undefined>) => Renderable;
+    createText: (ctx: RenderContext, content: string | StyledText, options?: Record<string, unknown>) => TextRenderable;
+    createCodeBlockRenderable: (ctx: RenderContext, content: string, filePath: string | undefined, syntaxStyle: SyntaxStyle) => Renderable;
+    createDiffRenderable: (ctx: RenderContext, diff: string, filePath: string | undefined, syntaxStyle: SyntaxStyle, width?: number) => Renderable;
+    toolColor: (tool: DisplayToolCall) => string;
+    displayToolName: (name: string) => string;
+    toolHeader: (tool: DisplayToolCall) => string;
+    toolPath: (tool: DisplayToolCall) => string | undefined;
+    extractToolDiff: (tool: DisplayToolCall) => string | undefined;
+    summarizeToolResult: (tool: DisplayToolCall) => string;
+    isToolFinished: (tool: DisplayToolCall) => boolean;
+    toolPreview: (tool: DisplayToolCall) => {
+        lines: string[];
+        omitted: number;
+    } | undefined;
+    toolStateIcon: (tool: DisplayToolCall) => string;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,12 @@
+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;
+    };
+};
+export declare function formatWritePreview(content: string, expanded: boolean): {
+    content: string;
+    omittedLines: number;
+    omittedChars: number;
+};

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

@@ -0,0 +1,30 @@
+const WRITE_PREVIEW_LINE_LIMIT = 10;
+export const WRITE_PREVIEW_CHAR_LIMIT = 5000;
+export function isWritePreviewTool(tool) {
+    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/);
+    if (expanded) {
+        return { content, omittedLines: 0, omittedChars: 0 };
+    }
+    let previewContent = lines.slice(0, WRITE_PREVIEW_LINE_LIMIT).join("\n");
+    let omittedLines = Math.max(0, lines.length - WRITE_PREVIEW_LINE_LIMIT);
+    if (previewContent.length > WRITE_PREVIEW_CHAR_LIMIT) {
+        previewContent = previewContent.slice(0, WRITE_PREVIEW_CHAR_LIMIT);
+        omittedLines = Math.max(omittedLines, lines.length - previewContent.split(/\r?\n/).length);
+    }
+    return {
+        content: previewContent,
+        omittedLines,
+        omittedChars: Math.max(0, content.length - previewContent.length),
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { DisplayMessage, DisplayToolCall } from "../display-history.js";
+import type { ToolRenderer } from "./types.js";
+export declare const writeToolRenderer: ToolRenderer;
+export declare function writeToolKey(messageKey: string, tool: DisplayToolCall): string;
+export declare function writeToolExpansionDigest(message: DisplayMessage, messageKey: string, expandedWrites: Set<string>): string;
+export declare function writeToolExpansionSignature(messageKey: string, tool: DisplayToolCall, expandedWrites: Set<string>): string;

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

@@ -0,0 +1,88 @@
+import { fg, StyledText } from "@opentui/core";
+import { hashString } from "../render-signature.js";
+import { formatWritePreview, isWritePreviewTool, WRITE_PREVIEW_CHAR_LIMIT } from "./write-preview.js";
+export const writeToolRenderer = {
+    canRender: isWritePreviewTool,
+    expansionKey: writeToolKey,
+    signature: writeToolExpansionSignature,
+    render: renderWriteTool,
+};
+export function writeToolKey(messageKey, tool) {
+    return `${messageKey}:write:${tool.id}`;
+}
+export function writeToolExpansionDigest(message, messageKey, expandedWrites) {
+    return (message.toolCalls ?? [])
+        .filter((tool) => isWritePreviewTool(tool))
+        .map((tool) => writeToolExpansionSignature(messageKey, tool, expandedWrites))
+        .join("|");
+}
+export function writeToolExpansionSignature(messageKey, tool, expandedWrites) {
+    if (!isWritePreviewTool(tool))
+        return "";
+    const content = typeof tool.args.content === "string" ? tool.args.content : "";
+    return [
+        tool.id,
+        expandedWrites.has(writeToolKey(messageKey, tool)) ? "expanded" : "collapsed",
+        content.length,
+        content.split(/\r?\n/).length,
+        hashString(content.slice(0, WRITE_PREVIEW_CHAR_LIMIT)),
+        hashString(content.slice(-WRITE_PREVIEW_CHAR_LIMIT)),
+    ].join(":");
+}
+function renderWriteTool({ ctx, tool, syntaxStyle, writeExpanded, onToggleWrite, helpers }) {
+    const { theme } = helpers;
+    const color = helpers.toolColor(tool);
+    const icon = "●";
+    const header = helpers.toolHeader(tool);
+    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 && preview.omittedLines > 0
+        ? `... +${preview.omittedLines} lines (${writeExpanded ? "ctrl+o to collapse" : "ctrl+o to expand"})`
+        : preview && preview.omittedChars > 0
+            ? `... +${preview.omittedChars} chars (${writeExpanded ? "ctrl+o to collapse" : "ctrl+o to expand"})`
+            : preview && writeExpanded
+                ? "(ctrl+o to collapse)"
+                : "";
+    return helpers.createBox(ctx, {
+        paddingLeft: 3,
+        marginTop: 1,
+        flexDirection: "column",
+        flexShrink: 0,
+    }, [
+        helpers.createText(ctx, new StyledText([
+            fg(color)(`${icon} ${helpers.displayToolName(tool.name)}`),
+            fg(theme.toolText)(header ? ` ${header}` : ""),
+        ]), {
+            onMouseUp: onToggleWrite,
+        }),
+        helpers.createBox(ctx, {
+            paddingLeft: 1,
+            marginTop: 0,
+            border: ["left"],
+            borderColor: theme.borderSubtle,
+            flexDirection: "column",
+            flexShrink: 0,
+        }, [
+            helpers.createText(ctx, `└ ${summary}`, {
+                fg: tool.isError ? theme.toolError : theme.textMuted,
+                onMouseUp: onToggleWrite,
+            }),
+            preview
+                ? helpers.createCodeBlockRenderable(ctx, preview.content, helpers.toolPath(tool), syntaxStyle)
+                : null,
+            hint
+                ? helpers.createText(ctx, hint, {
+                    fg: theme.textMuted,
+                    onMouseUp: onToggleWrite,
+                })
+                : null,
+        ]),
+    ]);
+}

package/dist/types.d.ts

@@ -17,11 +17,6 @@ export type ReasoningEffort = ThinkingLevel;
 export interface UserMessage {
     role: "user";
     content: string | ContentPart[];
-    /**
-     * Marks this message as harness-emitted metadata (e.g. a <system-reminder>),
-     * not actual user input. Renderers may hide these; compaction should generally preserve them.
-     */
-    isMeta?: boolean;
 }
 export interface AssistantMessage {
     role: "assistant";
@@ -40,7 +35,19 @@ export interface SystemMessage {
     role: "system";
     content: string;
 }
-export type Message = UserMessage | AssistantMessage | ToolMessage | SystemMessage;
+export type MetaMessageKind = "system-reminder" | "runtime-context";
+export interface MetaMessage {
+    role: "meta";
+    kind: MetaMessageKind;
+    content: string;
+    /**
+     * Runtime metadata is hidden from transcript and session persistence. When
+     * true or omitted, the projector may convert it into model context.
+     */
+    includeInLlm?: boolean;
+}
+export type ProviderMessage = UserMessage | AssistantMessage | ToolMessage | SystemMessage;
+export type Message = ProviderMessage | MetaMessage;
 export interface ToolParameter {
     type?: string;
     description?: string;
@@ -65,13 +72,27 @@ 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 {
-    kind?: "search" | "read" | "write" | "edit" | "shell" | "web" | "security" | "lsp" | "question";
+    kind?: "search" | "read" | "write" | "edit" | "shell" | "web" | "security" | "lsp" | "question" | "subagent";
     path?: string;
     pattern?: string;
     matches?: number;
@@ -88,6 +109,22 @@ export interface ToolResult {
     status?: ToolResultStatus;
     metadata?: ToolResultMetadata;
 }
+export type ToolEffect = "read" | "write_patch" | "write_direct" | "unknown";
+export interface ToolUpdate {
+    type: "subagent_update";
+    parentToolCallId: string;
+    runId: string;
+    subAgentId: string;
+    agentName: string;
+    nickname?: string;
+    status: "queued" | "running" | "completed" | "failed" | "blocked" | "cancelled";
+    childEvent?: AgentEvent;
+    summaryDelta?: string;
+    toolName?: string;
+    toolCallId?: string;
+    message?: string;
+    metadata?: ToolResultMetadata;
+}
 export type ToolExecutor = (args: Record<string, any>, ctx: ToolContext) => Promise<ToolResult>;
 export interface ToolContext {
     cwd: string;
@@ -102,16 +139,52 @@ export interface ToolContext {
             subtaskType?: string;
             description?: string;
         }) => Promise<ToolResult>;
+        runSubAgent?: (input: string | ContentPart[], cwd: string, options: {
+            profile: import("./agent/profiles.js").AgentProfile;
+            runId: string;
+            subAgentId: string;
+            parentToolCallId: string;
+            approval?: "fail" | "disabled";
+            emitUpdate?: (update: ToolUpdate) => void;
+            description?: string;
+            abortSignal?: AbortSignal;
+            nickname?: string;
+            forkContext?: boolean;
+        }) => Promise<import("./agent/profiles.js").SubagentRunResult>;
+        spawnSubAgent?: (input: string | ContentPart[], cwd: string, options: {
+            profile: import("./agent/profiles.js").AgentProfile;
+            parentToolCallId: string;
+            approval?: "fail" | "disabled";
+            description?: string;
+            abortSignal?: AbortSignal;
+            forkContext?: boolean;
+        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
+        waitSubAgents?: (options: {
+            agentIds?: string[];
+            timeoutMs?: number;
+        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot[]>;
+        sendSubAgentInput?: (agentId: string, input: string | ContentPart[], cwd: string, options?: {
+            interrupt?: boolean;
+            parentToolCallId?: string;
+            abortSignal?: AbortSignal;
+        }) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
+        closeSubAgent?: (agentId: string) => Promise<import("./agent/subagent-control.js").SubagentThreadSnapshot>;
+        listSubAgents?: () => import("./agent/subagent-control.js").SubagentThreadSnapshot[];
     };
+    emitUpdate?: (update: ToolUpdate) => void;
 }
 export interface ToolRegistryEntry extends ToolDefinition {
     execute: ToolExecutor;
     /** Whether this tool is allowed in plan mode. Defaults to false (treated as write-capable). */
     readOnly?: boolean;
+    /** Capability classification used by subagent profiles. Defaults to "unknown". */
+    effect?: ToolEffect;
+    /** True when the tool may call ApprovalController.request(...) for an interactive decision. */
+    requiresApproval?: boolean;
     /**
      * If true, this tool is omitted from the tool list sent to the model on each
      * turn until unlocked via `tool_search`. Only the tool's name appears in a
-     * startup &lt;system-reminder&gt;. Used for MCP tools to keep them out of the
+     * startup runtime reminder. Used for MCP tools to keep them out of the
      * per-turn context cost when not in use.
      */
     deferred?: boolean;
@@ -154,6 +227,8 @@ export type StreamChunk = {
     arguments: string;
     isStart: boolean;
     isEnd: boolean;
+    argumentsFull?: string;
+    argumentsCorrupt?: boolean;
 } | {
     type: "usage";
     usage: TokenUsage;
@@ -169,14 +244,14 @@ export interface TokenUsage {
     totalTokens?: number;
 }
 export interface Provider {
-    streamChat(messages: Message[], options: {
+    streamChat(messages: ProviderMessage[], options: {
         model: string;
         tools?: ToolDefinition[];
         temperature?: number;
         thinkingLevel?: ThinkingLevel;
         abortSignal?: AbortSignal;
     }): AsyncIterable<StreamChunk>;
-    complete(messages: Message[], options?: {
+    complete(messages: ProviderMessage[], options?: {
         model?: string;
         temperature?: number;
         thinkingLevel?: ThinkingLevel;
@@ -191,11 +266,31 @@ export type AgentEvent = {
 } | {
     type: "reasoning_delta";
     content: string;
+} | {
+    type: "tool_call_start";
+    id: string;
+    name: string;
+} | {
+    type: "tool_call_delta";
+    id: string;
+    name: string;
+    argumentsDelta: string;
+    arguments: string;
+} | {
+    type: "tool_call_end";
+    id: string;
+    name: string;
+    arguments: string;
 } | {
     type: "tool_start";
     id: string;
     name: string;
     args: Record<string, any>;
+} | {
+    type: "tool_update";
+    id: string;
+    name: string;
+    update: ToolUpdate;
 } | {
     type: "tool_end";
     id: string;

package/package.json

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