@bubblebrain-ai/bubble 0.0.55 → 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/budget.js

@@ -36,8 +36,11 @@ export function estimateMessageTokens(message, providerId) {
     }
 }
 function estimateProviderMetadataOverhead(metadata, providerId) {
-    const blocks = metadata?.anthropic?.contentBlocks;
-    if (!blocks || blocks.length === 0)
+    const blocks = [
+        ...(metadata?.anthropic?.contentBlocks ?? []),
+        ...(metadata?.openai?.contentBlocks ?? []),
+    ];
+    if (blocks.length === 0)
         return 0;
     const estimate = (text) => estimateTextTokens(text, providerId);
     return blocks.reduce((sum, block) => {
@@ -46,6 +49,8 @@ function estimateProviderMetadataOverhead(metadata, providerId) {
             overhead += estimate(block.signature);
         if (block.type === "redacted_thinking" && typeof block.data === "string")
             overhead += estimate(block.data);
+        if (block.type === "reasoning" && typeof block.encrypted_content === "string")
+            overhead += estimate(block.encrypted_content);
         return sum + overhead;
     }, 0);
 }

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."));