@bubblebrain-ai/bubble 0.0.54 → 0.0.56

package/dist/sdk/replay-event-log.js

@@ -0,0 +1,72 @@
+/**
+ * A small append-only event log for SDK streams. Producers never wait for a
+ * consumer, and consumers can attach again with their last seen sequence.
+ */
+export class ReplayEventLog {
+    entries = [];
+    signal = deferredSignal();
+    closed = false;
+    failure;
+    get length() {
+        return this.entries.length;
+    }
+    append(value) {
+        if (this.closed)
+            return;
+        this.entries.push(value);
+        this.wake();
+    }
+    close(error) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.failure = error;
+        this.wake();
+    }
+    iterate(options = {}) {
+        const start = Math.max(0, options.from ?? 0);
+        return this.readFrom(start, options.signal);
+    }
+    async *readFrom(start, abortSignal) {
+        let index = start;
+        while (true) {
+            while (index < this.entries.length)
+                yield this.entries[index++];
+            if (this.closed) {
+                if (this.failure !== undefined)
+                    throw this.failure;
+                return;
+            }
+            if (abortSignal?.aborted)
+                return;
+            const currentSignal = this.signal.promise;
+            await waitForSignal(currentSignal, abortSignal);
+        }
+    }
+    wake() {
+        const previous = this.signal;
+        this.signal = deferredSignal();
+        previous.resolve();
+    }
+}
+function deferredSignal() {
+    let resolve;
+    const promise = new Promise((done) => {
+        resolve = done;
+    });
+    return { promise, resolve };
+}
+function waitForSignal(signal, abortSignal) {
+    if (!abortSignal)
+        return signal;
+    if (abortSignal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const done = () => {
+            abortSignal.removeEventListener("abort", done);
+            resolve();
+        };
+        abortSignal.addEventListener("abort", done, { once: true });
+        signal.then(done);
+    });
+}

package/dist/sdk/session-turn-coordinator.d.ts

@@ -0,0 +1,45 @@
+export type SessionTurnPhase = "queued" | "reserved" | "starting" | "active" | "stopping" | "settled";
+export interface SessionTurnQueueState {
+    active: boolean;
+    queued: number;
+    phase: Exclude<SessionTurnPhase, "queued" | "settled"> | "idle" | "deleted";
+}
+export interface SessionTurnReservation {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly signal: AbortSignal;
+    readonly phase: SessionTurnPhase;
+    readonly completion: Promise<void>;
+    waitForStart(): Promise<void>;
+    markActive(): void;
+    cancel(error?: Error): void;
+    finish(): void;
+}
+/**
+ * One synchronous state machine owns the complete per-session turn lifecycle.
+ * A reservation and its AbortController are created when runTurn() is called,
+ * before its async iterator is consumed, so stop/delete never have a handoff
+ * window in which a turn is invisible.
+ */
+export declare class SessionTurnCoordinator {
+    private readonly sessions;
+    private readonly deletedSessions;
+    private readonly turnIdPrefix;
+    private nextTurnId;
+    reserve(sessionId: string, signal?: AbortSignal): SessionTurnReservation;
+    getCurrent(sessionId: string): SessionTurnReservation | undefined;
+    getState(sessionId: string): SessionTurnQueueState;
+    stop(sessionId: string, message?: string): number;
+    stopCurrent(sessionId: string, message?: string): number;
+    clearQueue(sessionId: string, message?: string): number;
+    delete(sessionId: string): Promise<void>;
+    isDeleted(sessionId: string): boolean;
+    revive(sessionId: string): void;
+    private reservationFor;
+    private cancelTurn;
+    private finishTurn;
+    private settleDetached;
+    private promoteNext;
+    private deleteEmptySession;
+    private detachExternalAbort;
+}

package/dist/sdk/session-turn-coordinator.js

@@ -0,0 +1,227 @@
+import { AgentAbortError, throwIfAborted } from "../agent/abort-errors.js";
+import { randomUUID } from "node:crypto";
+/**
+ * One synchronous state machine owns the complete per-session turn lifecycle.
+ * A reservation and its AbortController are created when runTurn() is called,
+ * before its async iterator is consumed, so stop/delete never have a handoff
+ * window in which a turn is invisible.
+ */
+export class SessionTurnCoordinator {
+    sessions = new Map();
+    deletedSessions = new Set();
+    turnIdPrefix = `sdk-turn-${randomUUID().slice(0, 6)}`;
+    nextTurnId = 0;
+    reserve(sessionId, signal) {
+        if (this.deletedSessions.has(sessionId)) {
+            throw new Error(`Session is deleted: ${sessionId}`);
+        }
+        throwIfAborted(signal);
+        const turn = {
+            id: `${this.turnIdPrefix}-${++this.nextTurnId}`,
+            sessionId,
+            phase: "queued",
+            abort: new AbortController(),
+            start: deferred(),
+            completion: deferred(),
+            externalSignal: signal,
+        };
+        // A reservation can legally be stopped before its iterator is consumed.
+        // Keep that rejected start promise observed until waitForStart() reads it.
+        void turn.start.promise.catch(() => undefined);
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            session = { queued: [] };
+            this.sessions.set(sessionId, session);
+        }
+        if (!session.current) {
+            session.current = turn;
+            turn.phase = "reserved";
+            turn.start.resolve(undefined);
+        }
+        else {
+            session.queued.push(turn);
+        }
+        if (signal) {
+            turn.onExternalAbort = () => {
+                this.cancelTurn(turn, abortReason(signal, "SDK turn cancelled."));
+            };
+            signal.addEventListener("abort", turn.onExternalAbort, { once: true });
+        }
+        return this.reservationFor(turn);
+    }
+    getCurrent(sessionId) {
+        const turn = this.sessions.get(sessionId)?.current;
+        return turn ? this.reservationFor(turn) : undefined;
+    }
+    getState(sessionId) {
+        if (this.deletedSessions.has(sessionId)) {
+            return { active: false, queued: 0, phase: "deleted" };
+        }
+        const session = this.sessions.get(sessionId);
+        const currentPhase = session?.current?.phase;
+        return {
+            active: Boolean(session?.current),
+            queued: session?.queued.length ?? 0,
+            phase: currentPhase && currentPhase !== "queued" && currentPhase !== "settled"
+                ? currentPhase
+                : "idle",
+        };
+    }
+    stop(sessionId, message = "SDK turn stopped.") {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return 0;
+        const turns = [session.current, ...session.queued].filter((turn) => Boolean(turn));
+        for (const turn of turns)
+            this.cancelTurn(turn, new AgentAbortError(message));
+        return turns.length;
+    }
+    stopCurrent(sessionId, message = "SDK turn stopped.") {
+        const current = this.sessions.get(sessionId)?.current;
+        if (!current)
+            return 0;
+        this.cancelTurn(current, new AgentAbortError(message));
+        return 1;
+    }
+    clearQueue(sessionId, message = "Queued SDK turn cancelled.") {
+        const queued = [...(this.sessions.get(sessionId)?.queued ?? [])];
+        for (const turn of queued)
+            this.cancelTurn(turn, new AgentAbortError(message));
+        return queued.length;
+    }
+    async delete(sessionId) {
+        this.deletedSessions.add(sessionId);
+        const session = this.sessions.get(sessionId);
+        const turns = session
+            ? [session.current, ...session.queued].filter((turn) => Boolean(turn))
+            : [];
+        for (const turn of turns) {
+            this.cancelTurn(turn, new AgentAbortError("SDK session deleted."));
+        }
+        await Promise.all(turns.map((turn) => turn.completion.promise));
+    }
+    isDeleted(sessionId) {
+        return this.deletedSessions.has(sessionId);
+    }
+    revive(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session?.current || session?.queued.length) {
+            throw new Error(`Cannot recreate session while turns are still settling: ${sessionId}`);
+        }
+        this.deletedSessions.delete(sessionId);
+    }
+    reservationFor(turn) {
+        return {
+            id: turn.id,
+            sessionId: turn.sessionId,
+            signal: turn.abort.signal,
+            get phase() {
+                return turn.phase;
+            },
+            completion: turn.completion.promise,
+            waitForStart: async () => {
+                await turn.start.promise;
+                if (turn.phase === "settled")
+                    throw turn.terminalError ?? new AgentAbortError("SDK turn cancelled.");
+                if (turn.phase === "reserved")
+                    turn.phase = "starting";
+                throwIfAborted(turn.abort.signal);
+            },
+            markActive: () => {
+                throwIfAborted(turn.abort.signal);
+                if (turn.phase === "starting")
+                    turn.phase = "active";
+            },
+            cancel: (error = new AgentAbortError("SDK turn cancelled.")) => {
+                this.cancelTurn(turn, error);
+            },
+            finish: () => this.finishTurn(turn),
+        };
+    }
+    cancelTurn(turn, error) {
+        if (turn.phase === "settled")
+            return;
+        turn.terminalError = error;
+        turn.abort.abort(error);
+        const session = this.sessions.get(turn.sessionId);
+        if (!session) {
+            this.settleDetached(turn);
+            return;
+        }
+        if (turn.phase === "queued") {
+            const index = session.queued.indexOf(turn);
+            if (index >= 0)
+                session.queued.splice(index, 1);
+            this.settleDetached(turn);
+            this.deleteEmptySession(turn.sessionId, session);
+            return;
+        }
+        if (turn.phase === "reserved") {
+            if (session.current === turn)
+                session.current = undefined;
+            this.settleDetached(turn);
+            this.promoteNext(turn.sessionId, session);
+            return;
+        }
+        turn.phase = "stopping";
+    }
+    finishTurn(turn) {
+        if (turn.phase === "settled")
+            return;
+        const session = this.sessions.get(turn.sessionId);
+        if (session?.current === turn)
+            session.current = undefined;
+        this.settleDetached(turn);
+        if (session)
+            this.promoteNext(turn.sessionId, session);
+    }
+    settleDetached(turn) {
+        this.detachExternalAbort(turn);
+        const error = turn.terminalError;
+        turn.phase = "settled";
+        if (error)
+            turn.start.reject(error);
+        turn.completion.resolve(undefined);
+    }
+    promoteNext(sessionId, session) {
+        if (this.deletedSessions.has(sessionId)) {
+            for (const queued of [...session.queued]) {
+                this.cancelTurn(queued, new AgentAbortError("SDK session deleted."));
+            }
+            this.deleteEmptySession(sessionId, session);
+            return;
+        }
+        while (!session.current && session.queued.length > 0) {
+            const next = session.queued.shift();
+            if (!next || next.phase === "settled")
+                continue;
+            session.current = next;
+            next.phase = "reserved";
+            next.start.resolve(undefined);
+        }
+        this.deleteEmptySession(sessionId, session);
+    }
+    deleteEmptySession(sessionId, session) {
+        if (!session.current && session.queued.length === 0)
+            this.sessions.delete(sessionId);
+    }
+    detachExternalAbort(turn) {
+        if (turn.externalSignal && turn.onExternalAbort) {
+            turn.externalSignal.removeEventListener("abort", turn.onExternalAbort);
+        }
+    }
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((onResolve, onReject) => {
+        resolve = onResolve;
+        reject = onReject;
+    });
+    return { promise, resolve, reject };
+}
+function abortReason(signal, fallback) {
+    if (signal.reason instanceof Error)
+        return signal.reason;
+    return new AgentAbortError(typeof signal.reason === "string" ? signal.reason : fallback);
+}

package/dist/tui/app.js

@@ -483,8 +483,8 @@ export class PiTuiApp {
             // into a text steer.
             if (payload.images.length > 0)
                 controller.queueInput(payload);
-            else
-                controller.steer(trimmed);
+            else if (!controller.steer(trimmed))
+                controller.queueInput(payload);
             this.renderSnapshot();
         }
         else if (controller.queueAfterCommand?.(payload)) {
@@ -520,7 +520,9 @@ export class PiTuiApp {
             this.pushUserRow({ text: command, images: [] });
             const controller = this.options.controller;
             if (controller.isRunning()) {
-                controller.steer(skillInvocation.actualPrompt);
+                if (!controller.steer(skillInvocation.actualPrompt)) {
+                    controller.queueInput(skillInvocation.actualPrompt);
+                }
                 this.renderSnapshot();
             }
             else {

package/dist/tui/controller/controller.js

@@ -449,7 +449,9 @@ export class BubbleTuiController {
     steer(content) {
         if (!this.runActive || !this.activeInputController)
             return false;
-        const input = this.activeInputController.enqueue(content);
+        const input = this.activeInputController.tryEnqueue(content);
+        if (!input)
+            return false;
         const displayKey = nextDisplayMessageKey("steer");
         beginSteer(this.queue, {
             id: input.id,
@@ -539,11 +541,15 @@ export class BubbleTuiController {
             throw new Error("A command is already running.");
         }
         if (this.runActive) {
-            if (typeof input === "string")
-                this.steer(input);
+            if (typeof input === "string") {
+                if (!this.steer(input))
+                    this.queueInput(input);
+            }
             else if (isSubmitPayload(input)) {
-                if (input.images.length === 0)
-                    this.steer(input.text);
+                if (input.images.length === 0) {
+                    if (!this.steer(input.text))
+                        this.queueInput(input);
+                }
                 else
                     this.queueInput(input);
             }
@@ -716,7 +722,7 @@ export class BubbleTuiController {
             this.notify();
         }
         finally {
-            const leftoverSteers = inputController.clear();
+            const leftoverSteers = inputController.closePendingInputs();
             // The signal is the source of truth. A provider may observe cancellation
             // and end its iterator without throwing, but the user's pending steers
             // must still be dropped exactly as they are in the Ink implementation.

package/dist/tui/fullscreen.js

@@ -118,7 +118,8 @@ export class FullscreenApp {
                     return;
                 }
                 if (this.options.controller.isRunning()) {
-                    this.options.controller.steer(trimmed);
+                    if (!this.options.controller.steer(trimmed))
+                        this.options.controller.queueInput(trimmed);
                 }
                 else if (this.options.controller.queueAfterCommand?.(trimmed)) {
                     this.render();

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
@@ -368,10 +370,14 @@ export interface AgentRunInput {
     submittedAt?: number;
 }
 export interface AgentInputController {
+    /** Enqueue only while the current run can still accept boundary input. */
+    tryEnqueue?(content: string): AgentRunInput | undefined;
     drainPendingInputs(): AgentRunInput[];
     pendingInputCount(): number;
+    /** Atomically stop accepting input and return everything still pending. */
+    closePendingInputs?(): AgentRunInput[];
 }
-export type AgentInputRejectedReason = "no_continuation";
+export type AgentInputRejectedReason = "no_continuation" | "turn_failed" | "turn_cancelled";
 export type AgentEvent = {
     type: "turn_start";
 } | {
@@ -455,6 +461,12 @@ export type AgentEvent = {
     id: string;
     content: string;
     target: "current_turn";
+} | {
+    type: "input_queued";
+    id: string;
+    content: string;
+    turnId: string;
+    target: "next_turn";
 } | {
     type: "input_rejected";
     id: string;

package/package.json

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