@bubblebrain-ai/bubble 0.0.56 → 0.0.58

package/dist/mcp/transports.d.ts

@@ -27,7 +27,7 @@ export declare class StdioTransport implements McpTransport {
     constructor(config: StdioServerConfig);
     start(): Promise<void>;
     private onStdout;
-    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    send(message: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): Promise<void>;
     onMessage(handler: IncomingHandler): void;
     onError(handler: (err: Error) => void): void;
     onClose(handler: () => void): void;
@@ -44,7 +44,7 @@ export declare class HttpTransport implements McpTransport {
     private readonly baseHeaders;
     constructor(config: HttpServerConfig | SseServerConfig);
     start(): Promise<void>;
-    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    send(message: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): Promise<void>;
     private parseSseBody;
     onMessage(handler: IncomingHandler): void;
     onError(handler: (err: Error) => void): void;

package/dist/mcp/types.d.ts

@@ -100,7 +100,7 @@ export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcRespo
 /** Low-level transport interface. */
 export interface McpTransport {
     start(): Promise<void>;
-    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    send(message: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): Promise<void>;
     /** Called once per incoming JSON-RPC message (response or server→client request/notification). */
     onMessage(handler: (msg: JsonRpcResponse | JsonRpcNotification | JsonRpcRequest) => void): void;
     onError(handler: (err: Error) => void): void;

package/dist/memory/phase1.js

@@ -160,6 +160,10 @@ function serializeSessionEntry(entry) {
             return `[tool_call:${entry.toolCall.name}] ${truncate(entry.toolCall.arguments, 1_500)}`;
         case "tool_result":
             return `[tool_result${entry.message.isError ? " error=true" : ""}] ${truncate(entry.message.content, 2_000)}`;
+        case "provider_error":
+            // Operational diagnostics stay out of the memory-extraction prompt. The
+            // structured session record remains available for local debugging.
+            return "";
     }
 }
 function countMeaningfulEntries(entries) {

package/dist/model-catalog.js

@@ -25,6 +25,7 @@ export const BUILTIN_PROVIDERS = [
     { id: "minimax", name: "MiniMax Token Plan", baseURL: "https://api.minimaxi.com/anthropic", protocol: "anthropic-messages" },
     { id: "minimax-anthropic", name: "MiniMax API", baseURL: "https://api.minimaxi.com/anthropic", protocol: "anthropic-messages" },
     { id: "stepfun", name: "StepFun Step Plan", baseURL: "https://api.stepfun.com/step_plan/v1" },
+    { id: "stepfun-api", name: "StepFun API", baseURL: "https://api.stepfun.com/v1", protocol: "openai-chat" },
     { id: "moonshot-cn", name: "Moonshot (国内 platform.moonshot.cn)", baseURL: "https://api.moonshot.cn/v1" },
     { id: "moonshot-intl", name: "Moonshot (海外 platform.moonshot.ai)", baseURL: "https://api.moonshot.ai/v1" },
     { id: "kimi-for-coding", name: "Kimi for Coding", baseURL: "https://api.kimi.com/coding/v1" },
@@ -127,9 +128,11 @@ export const BUILTIN_MODELS = [
     { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", providerId: "anthropic", tier: "balanced", reasoningLevels: ANTHROPIC_SONNET_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", providerId: "anthropic", tier: "fast", reasoningLevels: ANTHROPIC_CHAT_LEVELS, contextWindow: 200000 },
     { id: "deepseek-v4-flash", name: "deepseek-v4-flash", providerId: "deepseek", tier: "fast", reasoningLevels: DEEPSEEK_V4_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
-    // Experimental vision model stays explicit-only: it is text-capable, but
-    // automatic fast-tier routing must not silently switch ordinary subagents
-    // from the stable Flash model to an experimental multimodal endpoint.
+    // V4.1 Flash (2026-09-10): high is the default, not the only effort.
+    // https://api-docs.deepseek.com/guides/thinking_mode
+    { id: "deepseek-flash", name: "deepseek-flash", providerId: "deepseek", reasoningLevels: DEEPSEEK_V4_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    // Legacy vision alias now routes to V4.1 Flash. Keep its explicit-only
+    // routing policy; existing sessions can continue using the old model ID.
     { id: "deepseek-v4-flash-vision-exp", name: "DeepSeek-V4-Flash-Vision-Exp", providerId: "deepseek", reasoningLevels: DEEPSEEK_V4_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "deepseek-v4-pro", name: "deepseek-v4-pro", providerId: "deepseek", tier: "strong", reasoningLevels: DEEPSEEK_V4_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     // Offline/no-key fallback only: with an API key the registry replaces this
@@ -190,6 +193,8 @@ export const BUILTIN_MODELS = [
     { id: "step-3.5-flash-2603", name: "Step 3.5 Flash 2603", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "step-3.5-flash", name: "Step 3.5 Flash", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
     { id: "step-router-v1", name: "Step Router V1", providerId: "stepfun", reasoningLevels: STEPFUN_REASONING_LEVELS },
+    // Use server-default reasoning until this model's effort controls are documented.
+    { id: "water18-0910", name: "water18-0910", providerId: "stepfun-api", reasoningLevels: [] },
     { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "moonshot-cn", tier: "strong", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.7-code-highspeed", name: "Kimi K2.7 Code Highspeed", providerId: "moonshot-cn", tier: "fast", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k3", name: "Kimi K3", providerId: "moonshot-cn", tier: "strong", reasoningLevels: KIMI_K3_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },

package/dist/model-pricing.d.ts

@@ -19,23 +19,27 @@ export interface UtcPricingWindow {
     /** Exclusive minute since 00:00 UTC. */
     endMinute: number;
 }
-export interface ModelPricing extends ModelPricingRate {
-    providerId: string;
-    modelId: string;
-    currency: PricingCurrency;
+export interface ModelPricingTariff extends ModelPricingRate {
     /**
      * Optional recurring UTC time-of-use tariff. Top-level rates are the peak
      * tariff; outside these windows, `offPeak` applies. DeepSeek introduced this
      * pricing shape for the V4 family on 2026-08-16.
      */
     peakWindowsUtc?: UtcPricingWindow[];
+    /** UTC weekdays with peak windows (0 = Sunday). Omitted means every day. */
+    peakWeekdaysUtc?: number[];
     offPeak?: ModelPricingRate;
     /** When the recurring tariff became effective. */
     effectiveFrom?: string;
     /** Rate used before `effectiveFrom` (for historical session statistics). */
-    prior?: ModelPricingRate;
+    prior?: ModelPricingTariff;
     effectiveUntil?: string;
-    original?: ModelPricingRate;
+    original?: ModelPricingTariff;
+}
+export interface ModelPricing extends ModelPricingTariff {
+    providerId: string;
+    modelId: string;
+    currency: PricingCurrency;
 }
 /**
  * Hand-maintained corrections layered over the generated models.dev snapshot.

package/dist/provider-error-record.d.ts

@@ -0,0 +1,34 @@
+import type { ThinkingLevel } from "./types.js";
+export interface SanitizedProviderError {
+    providerId: string;
+    modelId: string;
+    model?: string;
+    thinkingLevel: ThinkingLevel;
+    name: string;
+    message: string;
+    httpStatus?: number;
+    code?: string;
+    parameter?: string;
+    messageCount: number;
+    toolCount: number;
+    bubbleVersion: string;
+    pid: number;
+    runtimeStartedAt: number;
+}
+export interface ProviderErrorContext {
+    providerId: string;
+    modelId: string;
+    model?: string;
+    thinkingLevel: ThinkingLevel;
+    messageCount: number;
+    toolCount: number;
+}
+/**
+ * Build the allowlisted diagnostic record written to a session log.
+ *
+ * Deliberately do not serialize the original error object: SDK errors can
+ * contain request headers, request bodies, response bodies and stacks. Only
+ * scalar identifiers plus a locally-authored error category are retained.
+ */
+export declare function createSanitizedProviderError(error: unknown, context: ProviderErrorContext): SanitizedProviderError;
+export declare function sanitizeProviderErrorText(value: string): string;

package/dist/provider-error-record.js

@@ -0,0 +1,185 @@
+import { getCurrentVersion } from "./update/index.js";
+const MAX_FIELD_CHARS = 160;
+const RUNTIME_STARTED_AT = Date.now();
+const SAFE_ERROR_CODES = new Map([
+    ["authentication_error", "authentication_error"],
+    ["bad_request", "bad_request"],
+    ["context_length_exceeded", "context_length_exceeded"],
+    ["failed_precondition", "failed_precondition"],
+    ["internal_error", "internal_error"],
+    ["invalid_argument", "invalid_argument"],
+    ["invalidparameter", "invalid_parameter"],
+    ["invalid_parameter", "invalid_parameter"],
+    ["location_not_supported", "location_not_supported"],
+    ["permission_denied", "permission_denied"],
+    ["rate_limit_exceeded", "rate_limit_exceeded"],
+    ["rate_limit_exhausted", "rate_limit_exhausted"],
+    ["resource_exhausted", "resource_exhausted"],
+    ["service_unavailable", "service_unavailable"],
+    ["timeout", "timeout"],
+    ["unauthenticated", "unauthenticated"],
+    ["unsupported_parameter", "unsupported_parameter"],
+    ["unsupported_value", "unsupported_value"],
+]);
+const SAFE_PARAMETER_NAMES = new Set([
+    "contents",
+    "frequency_penalty",
+    "generationConfig",
+    "input",
+    "max_output_tokens",
+    "max_tokens",
+    "messages",
+    "model",
+    "n",
+    "presence_penalty",
+    "prompt",
+    "reasoning_effort",
+    "response_format",
+    "seed",
+    "stop",
+    "stream",
+    "temperature",
+    "thinkingConfig",
+    "thinkingLevel",
+    "thinking_level",
+    "tool_choice",
+    "tools",
+    "topP",
+    "top_p",
+]);
+/**
+ * Build the allowlisted diagnostic record written to a session log.
+ *
+ * Deliberately do not serialize the original error object: SDK errors can
+ * contain request headers, request bodies, response bodies and stacks. Only
+ * scalar identifiers plus a locally-authored error category are retained.
+ */
+export function createSanitizedProviderError(error, context) {
+    const sources = errorSources(error);
+    const rawMessage = firstString(sources, ["message"])
+        || (typeof error === "string" ? error : "Provider request failed.");
+    const httpStatus = firstHttpStatus(sources);
+    const code = sanitizeErrorCode(firstScalarString(sources, ["code", "errorCode", "type"]));
+    const parameter = sanitizeParameterName(firstScalarString(sources, ["param", "parameter"]));
+    return {
+        providerId: sanitizeControlledIdentifier(context.providerId),
+        modelId: sanitizeControlledIdentifier(context.modelId),
+        ...(context.model ? { model: sanitizeControlledIdentifier(context.model) } : {}),
+        thinkingLevel: context.thinkingLevel,
+        name: "ProviderError",
+        message: sanitizeProviderErrorText(rawMessage),
+        ...(httpStatus !== undefined ? { httpStatus } : {}),
+        ...(code ? { code } : {}),
+        ...(parameter ? { parameter } : {}),
+        messageCount: Math.max(0, Math.trunc(context.messageCount)),
+        toolCount: Math.max(0, Math.trunc(context.toolCount)),
+        bubbleVersion: getCurrentVersion(),
+        pid: process.pid,
+        runtimeStartedAt: RUNTIME_STARTED_AT,
+    };
+}
+export function sanitizeProviderErrorText(value) {
+    const text = value.replace(/[\r\n\t]+/g, " ").replace(/\s{2,}/g, " ").trim();
+    // Fail closed: provider/SDK messages can embed request headers, bodies,
+    // prompts, URLs or credentials in formats a denylist cannot anticipate.
+    // Persist only fixed, locally-authored summaries selected by broad error
+    // categories; never return any substring copied from the provider message.
+    if (/user location (?:is )?not supported|location[^.]{0,40}(?:unsupported|not supported)/i.test(text)) {
+        return "User location is not supported for API use.";
+    }
+    if (/context[_ -]?(?:length|window)|prompt (?:is )?too long|maximum context|token limit/i.test(text)) {
+        return "Provider context limit was exceeded.";
+    }
+    if (/rate limit|too many requests|quota|resource exhausted|\b429\b/i.test(text)) {
+        return "Provider rate limit was exceeded.";
+    }
+    if (/unauthori[sz]ed|authentication|invalid (?:api )?key|missing (?:api )?key|\b401\b/i.test(text)) {
+        return "Provider authentication failed.";
+    }
+    if (/forbidden|permission denied|access denied|\b403\b/i.test(text)) {
+        return "Provider denied the request.";
+    }
+    if (/invalid[^.]{0,60}(?:parameter|argument)|unsupported[^.]{0,60}(?:parameter|argument)|bad request|\b400\b/i.test(text)) {
+        return "Provider rejected a request parameter.";
+    }
+    if (/timed? ?out|timeout/i.test(text)) {
+        return "Provider request timed out.";
+    }
+    if (/network|connection|socket|fetch failed|stream (?:closed|interrupted)/i.test(text)) {
+        return "Provider connection failed.";
+    }
+    if (/abort|cancel/i.test(text)) {
+        return "Provider request was cancelled.";
+    }
+    return "Provider request failed.";
+}
+function errorSources(error) {
+    const sources = [];
+    const root = asRecord(error);
+    if (root)
+        sources.push(root);
+    const nested = asRecord(root?.error);
+    if (nested)
+        sources.push(nested);
+    const cause = asRecord(root?.cause);
+    if (cause)
+        sources.push(cause);
+    const causeError = asRecord(cause?.error);
+    if (causeError)
+        sources.push(causeError);
+    return sources;
+}
+function asRecord(value) {
+    return value !== null && (typeof value === "object" || typeof value === "function")
+        ? value
+        : undefined;
+}
+function firstString(sources, keys) {
+    for (const source of sources) {
+        for (const key of keys) {
+            const value = source[key];
+            if (typeof value === "string" && value.trim())
+                return value.trim();
+        }
+    }
+    return undefined;
+}
+function firstScalarString(sources, keys) {
+    for (const source of sources) {
+        for (const key of keys) {
+            const value = source[key];
+            if ((typeof value === "string" || typeof value === "number") && String(value).trim()) {
+                return String(value).trim();
+            }
+        }
+    }
+    return undefined;
+}
+function firstHttpStatus(sources) {
+    for (const source of sources) {
+        for (const key of ["status", "statusCode", "httpStatus"]) {
+            const value = source[key];
+            const numeric = typeof value === "number" ? value : Number(value);
+            if (Number.isInteger(numeric) && numeric >= 100 && numeric <= 599)
+                return numeric;
+        }
+    }
+    return undefined;
+}
+function sanitizeControlledIdentifier(value) {
+    const normalized = value.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:/@+-]*$/.test(normalized))
+        return "unknown";
+    return normalized.slice(0, MAX_FIELD_CHARS);
+}
+function sanitizeErrorCode(value) {
+    if (!value)
+        return undefined;
+    return SAFE_ERROR_CODES.get(value.trim().toLowerCase());
+}
+function sanitizeParameterName(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.trim();
+    return SAFE_PARAMETER_NAMES.has(normalized) ? normalized : undefined;
+}

package/dist/provider-transform.js

@@ -17,6 +17,7 @@ const KIMI_TOGGLE_THINKING_FAMILY = new Set(["kimi-k2.5", "kimi-k2.6"]);
 const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
 const MINIMAX_M3_FAMILY = new Set(["MiniMax-M3"]);
 const DEEPSEEK_V4_FAMILY = new Set([
+    "deepseek-flash",
     "deepseek-v4-flash",
     "deepseek-v4-flash-vision-exp",
     "deepseek-v4-pro",
@@ -111,6 +112,9 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
             },
         };
     }
+    if (providerId === "stepfun-api") {
+        return { effectiveThinkingLevel, reasoningContentEcho: "none" };
+    }
     if (providerId === "stepfun") {
         return {
             effectiveThinkingLevel,

package/dist/provider.js

@@ -314,6 +314,7 @@ function shouldRequestStreamUsage(options) {
         || providerId === "zai-coding-plan"
         // Bailian sends usage either way; ask explicitly so it stays guaranteed.
         || providerId === "bailian-token-plan"
+        || providerId === "stepfun-api"
         || isMiniMaxOpenAICompatible(options);
 }
 function shouldUseNonStreamingToolCalls(options, tools, toolChoice) {
@@ -503,6 +504,7 @@ function usageToStreamChunk(usage) {
         usage: {
             promptTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
             completionTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
+            outputTokensReported: typeof usage.completion_tokens === "number",
             promptCacheHitTokens: typeof usage.prompt_cache_hit_tokens === "number"
                 ? usage.prompt_cache_hit_tokens
                 : typeof usage.prompt_tokens_details?.cached_tokens === "number"
@@ -673,6 +675,7 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 usage: {
                     promptTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
                     completionTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
+                    outputTokensReported: typeof usage.completion_tokens === "number",
                     promptCacheHitTokens: typeof usage.prompt_cache_hit_tokens === "number"
                         ? usage.prompt_cache_hit_tokens
                         : typeof usage.prompt_tokens_details?.cached_tokens === "number"

package/dist/sdk/index.js

@@ -417,6 +417,11 @@ export class BubbleSdk {
                     if (message.role === "assistant")
                         recordMemoryCitations(cwd, message.content);
                 },
+                onProviderError: (error) => {
+                    if (this.turnCoordinator.isDeleted(sessionId))
+                        return;
+                    session.appendProviderError(error);
+                },
                 onCompactionApplied: (summary) => {
                     if (this.turnCoordinator.isDeleted(sessionId))
                         return;

package/dist/session-log.d.ts

@@ -1,5 +1,6 @@
 import type { Message } from "./types.js";
-import type { SessionLogEntry, SessionMarkerKind, SessionMetadata, SessionSummaryEntry } from "./session-types.js";
+import type { SessionLogEntry, SessionMarkerKind, SessionMetadata, SessionProviderErrorEntry, SessionSummaryEntry } from "./session-types.js";
+import type { SanitizedProviderError } from "./provider-error-record.js";
 export declare class SessionLog {
     private entries;
     load(lines: string[]): void;
@@ -10,5 +11,6 @@ export declare class SessionLog {
     appendMessage(message: Message): SessionLogEntry[];
     appendSummary(summary: string): SessionSummaryEntry;
     appendMarker(kind: SessionMarkerKind, value: string): SessionLogEntry;
+    appendProviderError(error: SanitizedProviderError): SessionProviderErrorEntry;
     toMessages(): Message[];
 }

package/dist/session-log.js

@@ -71,6 +71,16 @@ export class SessionLog {
         this.entries.push(entry);
         return entry;
     }
+    appendProviderError(error) {
+        const entry = {
+            id: nextEntryId(this.entries),
+            type: "provider_error",
+            error,
+            timestamp: Date.now(),
+        };
+        this.entries.push(entry);
+        return entry;
+    }
     toMessages() {
         const messages = [];
         let latestSummaryIndex = -1;
@@ -217,6 +227,7 @@ function isSessionLogEntry(entry) {
         "assistant_message",
         "tool_call",
         "tool_result",
+        "provider_error",
     ].includes(entry.type);
 }
 function nextEntryId(entries) {

package/dist/session-types.d.ts

@@ -1,5 +1,6 @@
 import type { AssistantMessage, Message, ThinkingLevel, ToolCall, ToolMessage, UserMessage } from "./types.js";
 import type { GoalState } from "./goal/store.js";
+import type { SanitizedProviderError } from "./provider-error-record.js";
 export interface ExternalRuntimeSessionMetadata {
     /** External agent runtime that owns the conversational state. */
     id: "grok";
@@ -65,7 +66,11 @@ export interface SessionToolResultEntry extends BaseSessionLogEntry {
     type: "tool_result";
     message: ToolMessage;
 }
-export type SessionLogEntry = SessionMetadataEntry | SessionSummaryEntry | SessionMarkerEntry | SessionUserMessageEntry | SessionAssistantMessageEntry | SessionToolCallEntry | SessionToolResultEntry;
+export interface SessionProviderErrorEntry extends BaseSessionLogEntry {
+    type: "provider_error";
+    error: SanitizedProviderError;
+}
+export type SessionLogEntry = SessionMetadataEntry | SessionSummaryEntry | SessionMarkerEntry | SessionUserMessageEntry | SessionAssistantMessageEntry | SessionToolCallEntry | SessionToolResultEntry | SessionProviderErrorEntry;
 export interface LegacySessionEntry {
     id: string;
     type: "metadata" | "message" | "compaction";

package/dist/session.d.ts

@@ -5,6 +5,7 @@ import { CheckpointStore } from "./checkpoints.js";
 import { type CompactOptions, type CompactResult } from "./context/compact.js";
 import type { Message } from "./types.js";
 import type { SessionLogEntry, SessionMarkerKind, SessionMetadata } from "./session-types.js";
+import type { SanitizedProviderError } from "./provider-error-record.js";
 export interface SessionSummary {
     file: string;
     name: string;
@@ -62,6 +63,7 @@ export declare class SessionManager {
     appendMessage(message: Message): void;
     appendCompaction(summary: string): void;
     appendMarker(kind: SessionMarkerKind, value: string): void;
+    appendProviderError(error: SanitizedProviderError): void;
     compact(options?: CompactOptions): CompactResult;
     /**
      * Inspect whether the session is large enough to compact and, if so, return

package/dist/session.js

@@ -172,6 +172,10 @@ export class SessionManager {
         const entry = this.log.appendMarker(kind, value);
         this.persist(entry);
     }
+    appendProviderError(error) {
+        const entry = this.log.appendProviderError(error);
+        this.persist(entry);
+    }
     compact(options) {
         const result = compactSessionEntries(this.log.list(), options);
         if (result.compacted && result.entries) {

package/dist/stream-json.d.ts

@@ -0,0 +1,13 @@
+/** Persistent headless transport. One Agent + MCP lifecycle, sequential user turns. */
+import type { Readable } from "node:stream";
+import type { AgentEvent } from "./types.js";
+interface StreamSessionOptions {
+    input: Readable;
+    write: (message: Record<string, unknown>) => void;
+    sessionId: string;
+    model: string;
+    run: (prompt: string) => AsyncIterable<AgentEvent>;
+    onEvent?: (event: AgentEvent) => void;
+}
+export declare function runStreamJsonSession(options: StreamSessionOptions): Promise<void>;
+export {};

package/dist/stream-json.js

@@ -0,0 +1,74 @@
+import { PrintRunCollector } from "./print-output.js";
+const maxLineBytes = 1024 * 1024;
+async function* lines(input) {
+    input.setEncoding("utf8");
+    let pending = "";
+    for await (const chunk of input) {
+        pending += chunk;
+        let index;
+        while ((index = pending.indexOf("\n")) >= 0) {
+            const line = pending.slice(0, index).replace(/\r$/, "");
+            pending = pending.slice(index + 1);
+            if (Buffer.byteLength(line) > maxLineBytes)
+                throw new Error("Input line exceeds 1 MiB");
+            if (line.trim())
+                yield line;
+        }
+        if (Buffer.byteLength(pending) > maxLineBytes)
+            throw new Error("Input line exceeds 1 MiB");
+    }
+    if (pending.trim())
+        yield pending;
+}
+function userText(value) {
+    if (typeof value === "string" && value.trim())
+        return value;
+    if (Array.isArray(value) && value.length && value.every(item => item && item.type === "text" && typeof item.text === "string")) {
+        const text = value.map(item => item.text).join("\n");
+        if (text.trim())
+            return text;
+    }
+    throw new Error("message.content must be non-empty text or text blocks");
+}
+export async function runStreamJsonSession(options) {
+    const { write, sessionId, model } = options;
+    write({ type: "system", subtype: "init", session_id: sessionId, model, protocol_version: 1 });
+    let sequence = 0;
+    // Read only as turns finish: the stream's own backpressure bounds queued input.
+    // EOF drains all accepted messages before main() shuts down MCP and the Agent.
+    for await (const line of lines(options.input)) {
+        let requestId;
+        let prompt;
+        try {
+            const message = JSON.parse(line);
+            if (typeof message?.request_id === "string")
+                requestId = message.request_id;
+            if (message?.type !== "user" || message.message?.role !== "user") {
+                throw new Error('Expected {type:"user",message:{role:"user",content:"..."}}');
+            }
+            if (message.session_id && message.session_id !== sessionId)
+                throw new Error("Session ID does not match this process");
+            prompt = userText(message.message.content);
+        }
+        catch (error) {
+            write({ type: "result", is_error: true, subtype: "invalid_input", session_id: sessionId,
+                request_id: requestId, result: error instanceof Error ? error.message : String(error) });
+            continue;
+        }
+        const collector = new PrintRunCollector();
+        const envelope = { session_id: sessionId, request_id: requestId, turn: ++sequence };
+        try {
+            for await (const event of options.run(prompt)) {
+                collector.onEvent(event);
+                options.onEvent?.(event);
+                write({ type: "stream_event", ...envelope, event });
+            }
+            const summary = collector.summary();
+            write({ type: "result", ...envelope, is_error: false, result: summary.text, stopReason: "end_turn", ...summary });
+        }
+        catch (error) {
+            write({ type: "result", ...envelope, is_error: true, stopReason: "error", ...collector.summary(),
+                result: error instanceof Error ? error.message : String(error) });
+        }
+    }
+}

package/dist/tui/controller/agent-event-reducer.js

@@ -84,7 +84,8 @@ export function reduceAgentEvent(state, event, ctx) {
             if (tc) {
                 tc.rawArguments = event.arguments;
                 tc.args = parsePartialArgs(event.arguments, tc.args);
-                effects.push({ kind: "tools-updated" });
+                // Parameter chunks are streaming data, like text/reasoning. Let the
+                // controller coalesce their paint instead of rendering for every byte.
                 return { state: { ...state, dirty: { ...state.dirty, tools: true } }, effects };
             }
             return { state, effects };

package/dist/tui/controller/controller.js

@@ -682,12 +682,13 @@ export class BubbleTuiController {
                     this.applyEffects(effects);
                 }
                 const hasDirty = Object.values(this.runState.dirty).some(Boolean);
-                // Text/reasoning deltas have no immediate effect notification. Batch
-                // them behind one coalesced 40ms paint. Tool events already notified
-                // through their effects, so acknowledging their dirty bits here avoids
-                // a redundant delayed repaint. Dirty means "paint pending", not
+                // Streamed text, reasoning, and tool arguments share one 40ms paint.
+                // Repainting each argument chunk can starve input/timers while a
+                // buffered response drains, especially with a long reasoning preview.
+                // Tool lifecycle events still notify immediately through their effects.
+                // Dirty means "paint pending", not
                 // "this run has ever changed", and must never remain latched forever.
-                if (hasDirty && (event.type === "text_delta" || event.type === "reasoning_delta")) {
+                if (hasDirty && (event.type === "text_delta" || event.type === "reasoning_delta" || event.type === "tool_call_delta")) {
                     this.deps.ports.flush.scheduleFlush(STREAMING_FLUSH_INTERVAL_MS, () => {
                         if (this.disposed || !this.runActive)
                             return;

package/dist/types.d.ts

@@ -322,6 +322,8 @@ export type StreamChunk = {
     type: "done";
 };
 export interface TokenUsage {
+    /** Whether the upstream response explicitly supplied completion_tokens. */
+    outputTokensReported?: boolean;
     promptTokens: number;
     completionTokens: number;
     promptCacheHitTokens?: number;

package/package.json

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