@bubblebrain-ai/bubble 0.0.55 → 0.0.57

package/dist/session.js

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

package/dist/stream-json.d.ts

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

package/dist/stream-json.js

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

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

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

package/dist/tui/controller/controller.js

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

package/dist/tui/model/image-paste.js

@@ -299,20 +299,19 @@ export async function getImageFromClipboard() {
     }
 }
 async function getClipboardImageDarwin() {
-    // Probe first — `as «class PNGf»` throws if clipboard has no image.
-    try {
-        await execFileAsync("osascript", ["-e", "the clipboard as «class PNGf»"], {
-            timeout: 5000,
-        });
-    }
-    catch {
-        return null;
-    }
     const tmp = path.join(os.tmpdir(), `bubble_clip_${Date.now()}_${process.pid}.png`);
     const script = `set png_data to (the clipboard as «class PNGf»)\n` +
         `set fp to open for access POSIX file "${tmp}" with write permission\n` +
+        `try\n` +
+        `set eof fp to 0\n` +
         `write png_data to fp\n` +
-        `close access fp`;
+        `close access fp\n` +
+        `on error err_msg number err_num\n` +
+        `try\n` +
+        `close access fp\n` +
+        `end try\n` +
+        `error err_msg number err_num\n` +
+        `end try`;
     try {
         await execFileAsync("osascript", ["-e", script], { timeout: 5000 });
         const buf = await fs.readFile(tmp);

package/dist/types.d.ts

@@ -18,12 +18,14 @@ export type ReasoningEffort = ThinkingLevel;
 export type ProviderRawContentBlock = Record<string, unknown> & {
     type: string;
 };
-export type ProviderMetadataProvider = "anthropic" | "google";
+export type ProviderMetadataProvider = "anthropic" | "google" | "openai";
 export interface ProviderContentBlockStore {
     contentBlocks?: ProviderRawContentBlock[];
 }
 export interface AssistantProviderMetadata {
     anthropic?: ProviderContentBlockStore;
+    /** OpenAI Responses reasoning items captured for stateless tool-loop replay. */
+    openai?: ProviderContentBlockStore;
     /**
      * Gemini raw parts captured for replay: reasoning/tool-call parts carrying
      * thoughtSignature so multi-turn thinking round-trips through our own

package/package.json

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