@bubblebrain-ai/bubble 0.0.56 → 0.0.57

package/README.md

@@ -67,6 +67,41 @@ Resume your last conversation:
 bubble --resume
 ```
 
+## Persistent headless sessions
+
+To keep one agent session and its MCP connections alive across multiple prompts:
+
+```bash
+bubble -p --input-format stream-json --output-format stream-json \
+  --model zhipuai-coding-plan:glm-5.3 --session my-session
+```
+
+Write one JSON message per line to stdin (keep stdin open between turns):
+
+```json
+{"type":"user","request_id":"turn-1","message":{"role":"user","content":"Inspect the page."}}
+{"type":"user","request_id":"turn-2","message":{"role":"user","content":"Continue with the next action."}}
+```
+
+Stdout contains only newline-delimited JSON: one `system/init` event with the model
+and `session_id`, `stream_event` messages wrapping native agent events (including
+`text_delta`, `tool_start`, and `tool_end`), and one `result` per input. Results
+include `is_error`, text in `result`, token usage, and the input `request_id` when
+provided. This is Bubble's protocol; it does not claim full Claude Code protocol
+compatibility. Input content may also be an array of text blocks.
+
+Turns run sequentially in arrival order and retain the same agent history, MCP
+connections, and tool discovery state. Malformed input and failed turns produce an
+error result; the process remains available for the next input. An optional
+`session_id` must match the initialized session. EOF drains submitted turns, then
+releases resources. SIGINT/SIGTERM stop the process. Input lines are limited to
+1 MiB. Permission settings remain unchanged unless explicitly overridden.
+
+Both stream format flags require `-p`; positional prompts are not accepted in this
+mode. To resume a saved session, pass both `--resume` and `--session <name>` so no
+interactive picker is needed. Existing plain and single-result JSON print modes
+retain their behavior.
+
 ## Embed with the SDK
 
 The npm package exports `BubbleSdk` from both `@bubblebrain-ai/bubble` and

package/dist/agent/child-runner.d.ts

@@ -11,6 +11,9 @@
 import type { SubagentRunOutcome } from "./subagent-scheduler.js";
 import type { SubagentFinalReason, SubagentThreadRecord } from "./subagent-control.js";
 import type { AgentEvent, Message, ToolRegistryEntry, ToolResult, ToolUpdate } from "../types.js";
+/** Bubble-authored configuration failure whose message contains no provider data. */
+export declare class SafeSubagentConfigurationError extends Error {
+}
 export interface ChildRunOptions {
     approval: "fail" | "disabled";
     abortSignal?: AbortSignal;
@@ -27,6 +30,10 @@ export interface ChildRunnerHost {
     runLifecycleHook(record: SubagentThreadRecord, cwd: string, eventName: "SubagentStart" | "SubagentStop", status?: string, error?: string, abortSignal?: AbortSignal): Promise<void>;
     finalizeBlocked(record: SubagentThreadRecord, error: string, options: ChildRunOptions): void;
     createInstance(record: SubagentThreadRecord, tools: ToolRegistryEntry[], cwd: string, forkContext?: boolean): Promise<NonNullable<SubagentThreadRecord["agent"]>>;
+    recordProviderError(record: SubagentThreadRecord, error: unknown, request: {
+        messageCount: number;
+        toolCount: number;
+    }): void;
     notifyWaiters(record: SubagentThreadRecord): void;
     /** Called on every final state so background results can be ingested (§5). */
     onFinal(record: SubagentThreadRecord, options: ChildRunOptions): void;

package/dist/agent/child-runner.js

@@ -13,8 +13,12 @@ import { composeAbortSignals } from "./budget-ledger.js";
 import { isOnlyProviderProtocolArtifacts, stripProviderProtocolArtifacts } from "../provider-artifacts.js";
 import { isRateLimitError } from "../network/errors.js";
 import { isProviderTransportError } from "../network/provider-transport.js";
+import { sanitizeProviderErrorText } from "../provider-error-record.js";
 import { mergeUsage, selectToolsForAgentProfile, validateAgentProfileTools } from "./profiles.js";
 import { estimateHandoffTokens, HANDOFF_TOKEN_FLOOR, isIntermediateHandoff, stripInternalTagFragments, } from "./subagent-summary.js";
+/** Bubble-authored configuration failure whose message contains no provider data. */
+export class SafeSubagentConfigurationError extends Error {
+}
 export class ChildRunner {
     host;
     constructor(host) {
@@ -58,7 +62,13 @@ export class ChildRunner {
         catch (error) {
             // Instance creation failed before the run started: no SubagentStart
             // fired, so no SubagentStop follows (§9 — hooks pair per started run).
-            this.host.finalizeBlocked(record, error?.message || String(error), options);
+            const isSafeConfigurationError = error instanceof SafeSubagentConfigurationError;
+            if (!isSafeConfigurationError) {
+                this.host.recordProviderError(record, error, { messageCount: 0, toolCount: tools.length });
+            }
+            this.host.finalizeBlocked(record, isSafeConfigurationError
+                ? error.message
+                : sanitizeProviderErrorText(error?.message || String(error)), options);
             record.finalReason = "failed_fatal";
             this.host.onFinal(record, options);
             return { kind: "final" };
@@ -168,7 +178,15 @@ export class ChildRunner {
                 ? classifySubagentAbortReason(record.abortController.signal.aborted ? record.abortController.signal.reason : error, options.abortSignal)
                 : "failed_transient";
             record.summary = sanitizeSubagentSummary(record.summary);
-            record.error = error?.message || String(error);
+            if (!cancelled) {
+                this.host.recordProviderError(record, error, {
+                    messageCount: messagesBeforeInterruptedBoundary(subAgent.messages),
+                    toolCount: tools.length,
+                });
+            }
+            record.error = cancelled
+                ? "Subagent was cancelled."
+                : sanitizeProviderErrorText(error?.message || String(error));
             record.updatedAt = Date.now();
             await this.host.runLifecycleHook(record, cwd, "SubagentStop", record.status, record.error, options.abortSignal);
             emit(record.status, undefined, record.error);
@@ -178,7 +196,49 @@ export class ChildRunner {
         }
         record.summary = sanitizeSubagentSummary(record.summary);
         if (needsExplicitFinalSummary(record, executedAnyTool)) {
-            await this.runFinalSummaryTurn(record, subAgent, runCwd, options.abortSignal, emit);
+            try {
+                await this.runFinalSummaryTurn(record, subAgent, runCwd, options.abortSignal, emit);
+            }
+            catch (error) {
+                const abortedNow = record.abortController.signal.aborted
+                    || options.abortSignal?.aborted
+                    || error instanceof AgentAbortError
+                    || error?.name === "AbortError";
+                if (isRateLimitError(error) && !abortedNow) {
+                    record.status = "queued";
+                    record.updatedAt = Date.now();
+                    stripTrailingModelInterruptedBoundary(subAgent.messages);
+                    emit("queued", undefined, `Rate limited; ${record.nickname} will retry with its context intact.`);
+                    return { kind: "rate_limited", retryAfterMs: error.retryAfterMs };
+                }
+                if (isProviderTransportError(error) && !abortedNow) {
+                    record.status = "queued";
+                    record.updatedAt = Date.now();
+                    stripTrailingModelInterruptedBoundary(subAgent.messages);
+                    emit("queued", undefined, `Connection error; ${record.nickname} will retry with its context intact.`);
+                    return { kind: "transport_retry" };
+                }
+                const cancelled = error instanceof AgentAbortError || error?.name === "AbortError";
+                record.status = cancelled ? "cancelled" : "failed";
+                record.finalReason = cancelled
+                    ? classifySubagentAbortReason(record.abortController.signal.aborted ? record.abortController.signal.reason : error, options.abortSignal)
+                    : "failed_transient";
+                if (!cancelled) {
+                    this.host.recordProviderError(record, error, {
+                        messageCount: messagesBeforeInterruptedBoundary(subAgent.messages),
+                        toolCount: tools.length,
+                    });
+                }
+                record.error = cancelled
+                    ? "Subagent was cancelled."
+                    : sanitizeProviderErrorText(error?.message || String(error));
+                record.updatedAt = Date.now();
+                await this.host.runLifecycleHook(record, cwd, "SubagentStop", record.status, record.error, options.abortSignal);
+                emit(record.status, undefined, record.error);
+                this.host.notifyWaiters(record);
+                this.host.onFinal(record, options);
+                return { kind: "final" };
+            }
         }
         record.status = "completed";
         record.finalReason = "completed";
@@ -289,6 +349,10 @@ export function stripTrailingModelInterruptedBoundary(messages) {
         break;
     }
 }
+function messagesBeforeInterruptedBoundary(messages) {
+    const last = messages.at(-1);
+    return Math.max(0, messages.length - (last?.role === "assistant" && last.content.startsWith("[model request interrupted") ? 1 : 0));
+}
 export function summarizeSubagentToolEnd(event) {
     const metadata = (event.result.metadata ?? {});
     const reason = readString(metadata.reason);

package/dist/agent/subagent/runtime.d.ts

@@ -4,6 +4,7 @@ import { SubagentStore } from "../subagent-store.js";
 import { type AgentCategoriesConfig, type ResolvedSubagentRoute } from "../categories.js";
 import type { SubagentRouter } from "./router.js";
 import type { AgentEvent, ContentPart, Message, PermissionMode, Provider, ThinkingLevel, ToolRegistryEntry, ToolUpdate } from "../../types.js";
+import type { ProviderErrorContext } from "../../provider-error-record.js";
 import type { AgentSubagentRuntimeConfig } from "../../agent.js";
 import type { HookCombinedResult } from "../../hooks/index.js";
 /** The child agent surface the runtime drives; structurally satisfied by Agent. */
@@ -44,6 +45,7 @@ export interface SubagentRuntimeParent {
      */
     allTools(): ToolRegistryEntry[];
     createChild(spec: ChildAgentSpec): ChildAgentLike;
+    recordProviderError(error: unknown, context: ProviderErrorContext): void;
     runExternalHook(input: {
         eventName: string;
         cwd: string;
@@ -185,6 +187,7 @@ export declare class SubagentRuntime {
     private maybeEnqueueIngestion;
     private finalizeSubagentBlocked;
     private dispatchSubagentRun;
+    private recordSubagentProviderError;
     private emitSubagentLifecycle;
     /** Lets a blocked tool-execution loop drain freshly queued subagent updates. */
     private wakeSubagentUpdateWaiters;

package/dist/agent/subagent/runtime.js

@@ -11,10 +11,10 @@
  *    `SubagentRuntimeParent` as a LIVE accessor, never a construction-time
  *    snapshot: `/model` reassigns the parent's provider/model/thinking
  *    mid-session and children must inherit the current values.
- *  - Nothing is pushed back into the parent. Tool updates and ingestion
- *    notices are PULLED (`drainToolUpdates` / `drainIngestionNotices`) at the
- *    points in Agent.run() that previously called the private flush methods,
- *    matching ResultIntegrator.drainNotices.
+ *  - Conversation state is never pushed back into the parent. Tool updates
+ *    and ingestion notices are PULLED (`drainToolUpdates` /
+ *    `drainIngestionNotices`). The only direct sink is a terminal,
+ *    fail-closed provider diagnostic that contains no child transcript.
  *
  * `new Agent(...)` stays on Agent, reached through `parent.createChild`. That
  * is the only genuine call back into the parent, and keeping it there is what
@@ -31,7 +31,7 @@ import { assignAgentNickname, discoverAgentProfiles, findAgentProfile, validateA
 import { snapshotSubagentThread, subagentResultFromThread } from "../subagent-control.js";
 import { SubagentStore } from "../subagent-store.js";
 import { SubagentScheduler } from "../subagent-scheduler.js";
-import { ChildRunner, classifySubagentAbortReason } from "../child-runner.js";
+import { ChildRunner, classifySubagentAbortReason, SafeSubagentConfigurationError, } from "../child-runner.js";
 import { ResultIntegrator } from "../result-integrator.js";
 import { SubagentAbortError } from "../abort-errors.js";
 import { createSubagentWorktree, finalizeSubagentWorktree } from "../worktree.js";
@@ -75,6 +75,7 @@ export class SubagentRuntime {
             runLifecycleHook: (record, cwd, eventName, status, error, abortSignal) => this.runSubagentLifecycleHookFor(record, cwd, eventName, status, error, abortSignal),
             finalizeBlocked: (record, error, options) => this.finalizeSubagentBlocked(record, error, options),
             createInstance: (record, tools, cwd, forkContext) => this.createSubAgentInstance(record, tools, cwd, forkContext),
+            recordProviderError: (record, error, request) => this.recordSubagentProviderError(record, error, request),
             notifyWaiters: (record) => this.store.notifyWaiters(record),
             onFinal: (record, options) => {
                 this.reclaimWorktree(record);
@@ -506,7 +507,7 @@ export class SubagentRuntime {
             onCancelledWhileQueued: (reason) => {
                 record.status = "cancelled";
                 record.finalReason = classifySubagentAbortReason(reason, options.abortSignal);
-                record.error = reason instanceof Error ? reason.message : reason ? String(reason) : "Cancelled while queued.";
+                record.error = "Subagent was cancelled.";
                 record.updatedAt = Date.now();
                 // This path is NOT only "run never started" — a 429/transport
                 // failure re-queues the entry with the abort listener re-armed, so
@@ -527,6 +528,7 @@ export class SubagentRuntime {
                 record.status = "failed";
                 record.finalReason = "rate_limited_exhausted";
                 record.error = `Provider rate limit persisted after ${attempts} attempts.`;
+                this.recordSubagentProviderError(record, Object.assign(new Error(record.error), { status: 429, code: "rate_limit_exhausted" }), { messageCount: record.agent?.messages.length ?? 0, toolCount: 0 });
                 record.updatedAt = Date.now();
                 // Reclaim before persist so the handoff note lands in the
                 // persisted toolNotes.
@@ -543,6 +545,10 @@ export class SubagentRuntime {
                 // to recover the child with its context intact.
                 record.finalReason = "failed_transient";
                 record.error = `Provider transport error persisted after ${attempts} attempts.`;
+                this.recordSubagentProviderError(record, new Error(record.error), {
+                    messageCount: record.agent?.messages.length ?? 0,
+                    toolCount: 0,
+                });
                 record.updatedAt = Date.now();
                 this.reclaimWorktree(record);
                 void this.runSubagentLifecycleHookFor(record, cwd, "SubagentStop", record.status, record.error);
@@ -553,6 +559,22 @@ export class SubagentRuntime {
             },
         });
     }
+    recordSubagentProviderError(record, error, request) {
+        const route = record.route ?? {
+            providerId: this.parent.providerId,
+            model: this.parent.apiModel,
+            thinkingLevel: this.parent.thinkingLevel,
+            inherited: true,
+        };
+        this.parent.recordProviderError(error, {
+            providerId: route.providerId,
+            modelId: route.model,
+            model: route.providerId ? `${route.providerId}:${route.model}` : route.model,
+            thinkingLevel: route.thinkingLevel,
+            messageCount: request.messageCount,
+            toolCount: request.toolCount,
+        });
+    }
     emitSubagentLifecycle(record, options, status, event, message) {
         const update = this.buildSubagentUpdate(record, status, event, message);
         options.directEmit?.(update);
@@ -633,7 +655,15 @@ export class SubagentRuntime {
             // NOTE: record.worktree must be assigned before anything below can
             // throw — ChildRunner's failure path reclaims it off the record.
             if (!record.worktree) {
-                record.worktree = createSubagentWorktree(cwd, record.agentId);
+                try {
+                    record.worktree = createSubagentWorktree(cwd, record.agentId);
+                }
+                catch (error) {
+                    const message = error instanceof Error && error.message.includes("need a git repository")
+                        ? "write_worktree subagents need a git repository: the working directory is not inside one."
+                        : "Failed to create subagent worktree.";
+                    throw new SafeSubagentConfigurationError(message);
+                }
             }
             childCwd = record.worktree.path;
             childMode = "default";
@@ -705,7 +735,7 @@ export class SubagentRuntime {
             return this.parent.provider;
         }
         if (!this.parent.providerFactory) {
-            throw new Error([
+            throw new SafeSubagentConfigurationError([
                 `Subagent route requires provider "${route.providerId}" for model "${route.model}",`,
                 `but the parent agent only has provider "${this.parent.providerId || "none"}" and no provider factory is configured.`,
             ].join(" "));

package/dist/agent/transcript-helpers.d.ts

@@ -8,7 +8,7 @@ export declare function findMissingRequiredArgs(schema: {
     required?: string[];
 } | undefined, args: Record<string, any> | undefined): string[];
 export declare function shouldAppendModelInterruptedBoundary(messages: Message[]): boolean;
-export declare function createModelInterruptedMessage(error: unknown, metadata: {
+export declare function createModelInterruptedMessage(_error: unknown, metadata: {
     model: string;
     providerId: string;
     modelId: string;

package/dist/agent/transcript-helpers.js

@@ -1,4 +1,3 @@
-import { summarizeInterruptError } from "./abort-errors.js";
 export function findMissingRequiredArgs(schema, args) {
     const required = schema?.required;
     if (!required || required.length === 0)
@@ -19,10 +18,12 @@ export function findMissingRequiredArgs(schema, args) {
 export function shouldAppendModelInterruptedBoundary(messages) {
     return messages.at(-1)?.role === "tool";
 }
-export function createModelInterruptedMessage(error, metadata) {
+export function createModelInterruptedMessage(_error, metadata) {
     return {
         role: "assistant",
-        content: `[model request interrupted before a final answer was produced: ${summarizeInterruptError(error)}]`,
+        // This boundary is replayed to future providers and memory extraction.
+        // Never copy provider error text into conversational history.
+        content: "[model request interrupted before a final answer was produced]",
         model: metadata.model,
         providerId: metadata.providerId,
         modelId: metadata.modelId,

package/dist/agent.d.ts

@@ -18,6 +18,7 @@ export { createUpdateQueue } from "./agent/update-queue.js";
 import { type RateLimitPolicy } from "./network/errors.js";
 import type { SkillSummary } from "./skills/types.js";
 import type { FileStateTracker } from "./tools/file-state.js";
+import { type SanitizedProviderError } from "./provider-error-record.js";
 export { AgentAbortError, SubagentAbortError } from "./agent/abort-errors.js";
 export declare const INTERRUPTED_ASSISTANT_CONTENT = "Interrupted by user. The prior request was stopped and should not be resumed unless the user asks.";
 /** Runtime tuning for the subagent scheduler. */
@@ -51,6 +52,8 @@ export interface AgentOptions {
     };
     systemPrompt?: string;
     onMessageAppend?: (message: Message) => void;
+    /** Persistable, allowlisted diagnostics for terminal provider failures. */
+    onProviderError?: (error: SanitizedProviderError) => void;
     onToolResult?: (toolName: string, result: ToolResult) => void;
     onModeUpdate?: (mode: PermissionMode) => void;
     /**
@@ -157,6 +160,7 @@ export declare class Agent {
     private onModeUpdate?;
     private onCompactionApplied?;
     private onMessageAppend?;
+    private onProviderError?;
     private onToolResult?;
     private hookDefinitions;
     private externalHooks?;
@@ -440,6 +444,8 @@ export declare class Agent {
      */
     private persistCompactionSummary;
     private appendMessage;
+    private persistProviderError;
+    private recordProviderError;
     private appendInterruptedAssistantBoundary;
     private executeTool;
 }

package/dist/agent.js

@@ -32,6 +32,7 @@ import { createStreamingInternalReminderSanitizer, sanitizeAssistantProviderMeta
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
 import { buildToolPromptOptions } from "./tools/prompt-metadata.js";
 import { stopAutoServersForSession } from "./tools/server-manager.js";
+import { createSanitizedProviderError, } from "./provider-error-record.js";
 import { summarizeAgentEventForTrace, summarizeTraceError, summarizeTraceMessage, summarizeTraceToolResult, summarizeTraceValue, traceEvent, } from "./debug-trace.js";
 const MAX_CONSECUTIVE_OVERFLOW_RECOVERIES = 2;
 const MAX_EMPTY_ASSISTANT_RECOVERIES = 1;
@@ -127,6 +128,7 @@ export class Agent {
     onModeUpdate;
     onCompactionApplied;
     onMessageAppend;
+    onProviderError;
     onToolResult;
     hookDefinitions;
     externalHooks;
@@ -174,6 +176,7 @@ export class Agent {
         this.thinkingLevel = options.thinkingLevel ?? "off";
         this._mode = options.mode ?? "default";
         this.onMessageAppend = options.onMessageAppend;
+        this.onProviderError = options.onProviderError;
         this.onToolResult = options.onToolResult;
         this.onModeUpdate = options.onModeUpdate;
         this.onCompactionApplied = options.onCompactionApplied;
@@ -228,6 +231,7 @@ export class Agent {
                 // profile is the author pre-unlocking them).
                 allTools: () => [...this.tools.values()],
                 createChild: (spec) => this.createChildAgent(spec),
+                recordProviderError: (error, context) => this.recordProviderError(error, context),
                 runExternalHook: (input, abortSignal) => this.runExternalHook(input, abortSignal),
             },
             router: this.router,
@@ -826,6 +830,11 @@ export class Agent {
                     parameters: t.parameters,
                 }));
                 const toolDefinitionTokens = estimateToolDefinitionsTokens(toolDefinitions, this.providerId);
+                let currentRequestMessageCount = this.messages.length;
+                const persistTerminalProviderError = (error) => this.persistProviderError(error, {
+                    messageCount: currentRequestMessageCount,
+                    toolCount: toolDefinitions.length,
+                });
                 // LLM-driven compaction runs ahead of projector's algorithmic passes. If
                 // it succeeds, this.messages is replaced with [preserved system+meta] +
                 // [LLM summary] + [last user msg], and the projector becomes a no-op for
@@ -845,6 +854,7 @@ export class Agent {
                         // A fresh estimate also lets us account for current tool schemas.
                         additionalInputTokens: toolDefinitionTokens,
                     });
+                    currentRequestMessageCount = projectedMessages.length;
                     const requestBudget = getContextBudget(this.providerId, this.apiModel, projectedMessages, { additionalInputTokens: toolDefinitionTokens });
                     currentRequestEstimate = requestBudget.estimatedTokens;
                     const maxInputTokens = getMaxInputTokens(requestBudget.contextWindow);
@@ -1043,6 +1053,8 @@ export class Agent {
                         error: summarizeTraceError(error),
                     }, traceContext);
                     if (assistantAppended) {
+                        if (!isAbortLikeError(error, abortSignal))
+                            persistTerminalProviderError(error);
                         throw error;
                     }
                     const streamInterruption = isProviderStreamInterruption(error) ? error : undefined;
@@ -1077,9 +1089,12 @@ export class Agent {
                             }));
                             assistantAppended = true;
                         }
+                        if (!isAbortLikeError(error, abortSignal))
+                            persistTerminalProviderError(error);
                         throw error;
                     }
                     if (consecutiveOverflowRecoveries >= MAX_CONSECUTIVE_OVERFLOW_RECOVERIES) {
+                        persistTerminalProviderError(error);
                         throw error;
                     }
                     const messagesBeforeRecovery = this.messages;
@@ -1108,6 +1123,7 @@ export class Agent {
                         this.messages = messagesBeforeRecovery;
                         this.lastInputTokens = inputTokensBeforeRecovery;
                         this.lastAnchorMessageCount = anchorBeforeRecovery;
+                        persistTerminalProviderError(error);
                         throw error;
                     }
                     consecutiveOverflowRecoveries += 1;
@@ -1983,6 +1999,26 @@ export class Agent {
         this.onMessageAppend?.(message);
         this.notifyContextChanged();
     }
+    persistProviderError(error, request) {
+        this.recordProviderError(error, {
+            providerId: this.providerId,
+            modelId: this.apiModel,
+            model: this._model,
+            thinkingLevel: this.thinkingLevel,
+            messageCount: request.messageCount,
+            toolCount: request.toolCount,
+        });
+    }
+    recordProviderError(error, context) {
+        if (!this.onProviderError)
+            return;
+        try {
+            this.onProviderError(createSanitizedProviderError(error, context));
+        }
+        catch {
+            // Diagnostics are best-effort and must never replace the provider error.
+        }
+    }
     appendInterruptedAssistantBoundary(currentAssistant, currentAssistantAppended) {
         const last = lastProviderMessage(this.messages);
         if (last?.role === "assistant" && last.error?.aborted) {

package/dist/cli.d.ts

@@ -12,7 +12,8 @@ export interface CliArgs {
     sessionName?: string;
     print?: boolean;
     /** Print-mode output: plain (default) or a single JSON object on stdout. */
-    outputFormat?: "plain" | "json";
+    outputFormat?: "plain" | "json" | "stream-json";
+    inputFormat?: "text" | "stream-json";
     prompt?: string;
     thinkingLevel?: ThinkingLevel;
     mode?: PermissionMode;

package/dist/cli.js

@@ -57,13 +57,21 @@ export function parseArgs(argv) {
                 break;
             case "--output-format": {
                 const value = argv[++i];
-                if (value !== "plain" && value !== "json") {
-                    console.error(`Invalid --output-format: ${value ?? "(missing)"}. Expected plain or json.`);
+                if (value !== "plain" && value !== "json" && value !== "stream-json") {
+                    console.error(`Invalid --output-format: ${value ?? "(missing)"}. Expected plain, json, or stream-json.`);
                     process.exit(1);
                 }
                 args.outputFormat = value;
                 break;
             }
+            case "--input-format": {
+                const value = argv[++i];
+                if (value !== "text" && value !== "stream-json") {
+                    throw new Error("--input-format expects text or stream-json");
+                }
+                args.inputFormat = value;
+                break;
+            }
             case "--plan":
                 args.mode = "plan";
                 break;
@@ -96,6 +104,16 @@ export function parseArgs(argv) {
                 break;
         }
     }
+    const streamingInput = args.inputFormat === "stream-json";
+    const streamingOutput = args.outputFormat === "stream-json";
+    if (streamingInput || streamingOutput) {
+        if (!streamingInput || !streamingOutput || !args.print || args.prompt || args.command !== "default") {
+            throw new Error("Persistent mode requires -p --input-format stream-json --output-format stream-json and prompts on stdin");
+        }
+        if (args.resume && !args.sessionName) {
+            throw new Error("Persistent mode requires --session when using --resume (no interactive picker)");
+        }
+    }
     return args;
 }
 export function printHelp() {
@@ -117,8 +135,9 @@ Options (default):
   --dangerously-skip-permissions
                            Enable bypass mode (auto-approve EVERY tool; disables all safety prompts)
   -p, --print              Non-interactive mode (single prompt)
-  --output-format <fmt>    Print-mode output: plain (default) or json
+  --output-format <fmt>    Print-mode output: plain (default), json, or stream-json
                            (one JSON object on stdout: text, usage, num_turns)
+  --input-format <fmt>     text (default) or stream-json; use both stream-json flags with -p\n                           for a persistent session (one user JSON message per line)
   -v, --version            Print the installed version and exit
   -h, --help               Show this help
 

package/dist/context/compact.js

@@ -118,8 +118,14 @@ export function buildCompactionSummaryMessage(summary) {
 }
 export function planSessionCompaction(entries, options = {}) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
-    const metadataEntries = entries.filter((entry) => entry.type === "metadata");
-    const nonMetadataEntries = entries.filter((entry) => entry.type !== "metadata");
+    // Provider errors are diagnostics, not model context. Keep the latest audit
+    // records across compaction without allowing repeated failures to grow the
+    // compacted session forever.
+    const metadataEntries = [
+        ...entries.filter((entry) => entry.type === "metadata"),
+        ...entries.filter((entry) => entry.type === "provider_error").slice(-20),
+    ];
+    const nonMetadataEntries = entries.filter((entry) => entry.type !== "metadata" && entry.type !== "provider_error");
     const latestSummaryIndex = findLatestSummaryIndex(nonMetadataEntries);
     const baseIndex = latestSummaryIndex >= 0 ? latestSummaryIndex + 1 : 0;
     const activeEntries = nonMetadataEntries.slice(baseIndex);

package/dist/feishu/agent-host/run-driver.js

@@ -130,6 +130,9 @@ export class RunDriver {
                     recordMemoryCitations(session.cwd, message.content);
                 }
             },
+            onProviderError: (error) => {
+                session.manager.appendProviderError(error);
+            },
             onCompactionApplied: (summary) => {
                 session.manager.applyLLMCompaction(summary);
             },

package/dist/main.js

@@ -20,6 +20,7 @@ import { SkillRegistry } from "./skills/registry.js";
 import { buildToolPromptOptions, createAllTools } from "./tools/index.js";
 import { getProcessManager } from "./tasks/manager.js";
 import { PromotionChannel } from "./tasks/promotion.js";
+import { runStreamJsonSession } from "./stream-json.js";
 import { PrintRunCollector, formatPrintJson, formatPrintJsonError } from "./print-output.js";
 import { FileStateTracker } from "./tools/file-state.js";
 import { GoalStore } from "./goal/store.js";
@@ -418,6 +419,9 @@ async function main() {
                 recordMemoryCitations(args.cwd, message.content);
             }
         },
+        onProviderError: (error) => {
+            sessionManager?.appendProviderError(error);
+        },
         // Auto-compaction summaries are meta messages (dropped above); persist the
         // compacted state as a session summary entry so it survives resume.
         onCompactionApplied: (summary) => {
@@ -556,7 +560,7 @@ async function main() {
             }
             agent.injectDeferredToolsReminder();
             // JSON print mode reserves stdout for the single result object.
-            (args.outputFormat === "json" ? console.error : console.log)(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
+            (args.outputFormat === "json" || args.outputFormat === "stream-json" ? console.error : console.log)(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
         }
     }
     try {
@@ -567,6 +571,17 @@ async function main() {
                 process.exitCode = 1;
                 return;
             }
+            if (args.inputFormat === "stream-json") {
+                await runStreamJsonSession({
+                    input: process.stdin,
+                    write: (message) => { process.stdout.write(JSON.stringify(message) + "\n"); },
+                    sessionId: basename(sessionManager.getSessionFile()),
+                    model: agent.model,
+                    run: (prompt) => agent.run(prompt, args.cwd),
+                    onEvent: (event) => traceEvent("print_agent_event", summarizeAgentEventForTrace(event)),
+                });
+                return;
+            }
             const prompt = args.prompt || (await readPipedStdin()) || "";
             if (!prompt) {
                 console.error(chalk.red("Error: No prompt provided."));

package/dist/mcp/client.js

@@ -154,7 +154,21 @@ export class MCPClient {
             }
             return;
         }
-        // Server→client request or notification. v1 ignores these (no sampling, no roots).
+        // Ping is a core MCP request and requires no advertised capability. Long-lived
+        // servers (including Playwright) close healthy sessions when it is ignored.
+        if ("id" in msg && "method" in msg) {
+            const response = msg.method === "ping"
+                ? { jsonrpc: "2.0", id: msg.id, result: {} }
+                : { jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: `Unsupported client method: ${msg.method}` } };
+            void this.transport.send(response).catch((error) => {
+                for (const pending of this.pending.values()) {
+                    clearTimeout(pending.timer);
+                    pending.reject(error instanceof Error ? error : new Error(String(error)));
+                }
+                this.pending.clear();
+            });
+        }
+        // Notifications need no response; sampling and roots are not advertised.
     }
     async close() {
         this.closed = true;

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

@@ -127,6 +127,8 @@ 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 },
+    // DeepSeek Flash: retain the high effort used by the previous preview.
+    { id: "deepseek-flash", name: "deepseek-flash", providerId: "deepseek", reasoningLevels: ["high"], defaultReasoningLevel: "high" },
     // 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.

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",

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/package.json

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