@bubblebrain-ai/bubble 0.0.53 → 0.0.55

package/dist/sdk/index.js

@@ -16,7 +16,10 @@
 import os from "node:os";
 import { rmSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { Agent } from "../agent.js";
+import { Agent, AgentAbortError } from "../agent.js";
+import { AgentRunInputQueue } from "../agent/input-controller.js";
+import { SessionTurnCoordinator, } from "./session-turn-coordinator.js";
+import { ReplayEventLog } from "./replay-event-log.js";
 import { SessionManager } from "../session.js";
 import { PermissionAwareApprovalController } from "../approval/controller.js";
 import { BashAllowlist } from "../approval/session-cache.js";
@@ -48,8 +51,13 @@ export class BubbleSdk {
     mcpEnabled;
     cwdBySession = new Map();
     bashAllowlists = new Map();
-    activeTurns = new Map();
+    turnCoordinator = new SessionTurnCoordinator();
+    turnRuntimes = new Map();
+    lastTurnOptions = new Map();
     mcpToolsByCwd = new Map();
+    inputIdNonce = randomUUID().slice(0, 6);
+    nextTurnInputPrefix = 0;
+    nextDetachedInputId = 0;
     /** id -> {cwd,file} rebuilt from disk so sessions survive host restarts. */
     sessionIndex = new Map();
     constructor(options = {}) {
@@ -58,31 +66,129 @@ export class BubbleSdk {
     }
     // ── Sessions ─────────────────────────────────────────────────────────────
     listSessions() {
-        const sessions = SessionManager.listAllSessions();
+        const sessions = SessionManager.listAllSessions().filter((session) => !this.turnCoordinator.isDeleted(session.name));
         this.sessionIndex = new Map(sessions.map((s) => [s.name, { cwd: s.cwd ?? s.cwdLabel ?? this.defaultCwd, file: s.file }]));
         return sessions;
     }
     createSession(options = {}) {
         const cwd = options.cwd || this.defaultCwd;
         const id = options.id || `sdk-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+        this.turnCoordinator.revive(id);
         SessionManager.create(cwd, sessionFileName(id));
+        processSessionLocations.set(id, cwd);
         this.cwdBySession.set(id, cwd);
         return { id, cwd };
     }
+    openSession(sessionId) {
+        const resolved = this.resolveSession(sessionId);
+        if (!resolved)
+            throw new Error(`Unknown session: ${sessionId}`);
+        const ownerKey = resolved.manager.getSessionFile();
+        const eventLog = sessionEventLogFor(ownerKey);
+        const closed = new AbortController();
+        return {
+            id: sessionId,
+            cwd: resolved.cwd,
+            events: eventLog.iterate({ signal: closed.signal }),
+            eventsFrom: (afterSequence) => eventLog.iterate({
+                from: Math.max(0, afterSequence),
+                signal: closed.signal,
+            }),
+            send: (options) => this.runTurn(sessionId, options),
+            steer: (content) => this.steer(sessionId, content),
+            stop: (options) => this.stop(sessionId, options),
+            close: () => closed.abort(),
+        };
+    }
     getHistory(sessionId) {
+        if (this.turnCoordinator.isDeleted(sessionId))
+            return [];
         return this.resolveSession(sessionId)?.manager.getMessages() ?? [];
     }
-    deleteSession(sessionId) {
+    async deleteSession(sessionId) {
+        const owner = this.ownerForSession(sessionId);
+        if (owner && owner !== this)
+            return owner.deleteSession(sessionId);
         const resolved = this.resolveSession(sessionId);
+        for (const runtime of this.runtimesForSession(sessionId))
+            runtime.inputController.closePendingInputs();
+        await this.turnCoordinator.delete(sessionId);
         if (resolved)
             rmSync(resolved.manager.getSessionFile(), { force: true });
         this.cwdBySession.delete(sessionId);
         this.bashAllowlists.delete(sessionId);
+        this.lastTurnOptions.delete(sessionId);
         this.sessionIndex.delete(sessionId);
+        processSessionLocations.delete(sessionId);
+        if (resolved) {
+            releaseSessionEventLog(resolved.manager.getSessionFile());
+            releaseProcessOwner(resolved.manager.getSessionFile(), this);
+        }
+    }
+    /** Interrupt the active turn. Queued turns survive unless cancelQueued is true. */
+    stop(sessionId, options = {}) {
+        const owner = this.ownerForSession(sessionId);
+        if (owner && owner !== this)
+            return owner.stop(sessionId, options);
+        const current = this.turnCoordinator.getCurrent(sessionId);
+        const runtime = current ? this.turnRuntimes.get(current.id) : undefined;
+        runtime?.inputController.closePendingInputs();
+        const stopped = this.turnCoordinator.stopCurrent(sessionId);
+        return stopped + (options.cancelQueued ? this.turnCoordinator.clearQueue(sessionId) : 0);
+    }
+    /** Cancel queued turns without interrupting the turn that owns the session slot. */
+    clearQueue(sessionId) {
+        const owner = this.ownerForSession(sessionId);
+        if (owner && owner !== this)
+            return owner.clearQueue(sessionId);
+        return this.turnCoordinator.clearQueue(sessionId);
     }
-    /** Abort the in-flight turn of a session, if any. */
-    stop(sessionId) {
-        this.activeTurns.get(sessionId)?.abort();
+    getSessionRunState(sessionId) {
+        const owner = this.ownerForSession(sessionId);
+        if (owner && owner !== this)
+            return owner.getSessionRunState(sessionId);
+        const state = this.turnCoordinator.getState(sessionId);
+        const current = this.turnCoordinator.getCurrent(sessionId);
+        const runtime = current ? this.turnRuntimes.get(current.id) : undefined;
+        return {
+            active: state.active,
+            queuedTurns: state.queued,
+            pendingSteers: runtime?.outcomes.size ?? 0,
+            phase: state.phase,
+        };
+    }
+    /**
+     * Add text to the turn that currently owns the session slot. Every accepted
+     * input exposes an outcome promise, independent of event-stream consumption.
+     */
+    steer(sessionId, content) {
+        if (this.turnCoordinator.isDeleted(sessionId)) {
+            return { accepted: false, disposition: "rejected", reason: "session_deleted" };
+        }
+        const owner = this.ownerForSession(sessionId);
+        if (owner && owner !== this)
+            return owner.steer(sessionId, content);
+        const resolved = this.resolveSession(sessionId);
+        if (!resolved) {
+            return { accepted: false, disposition: "rejected", reason: "unknown_session" };
+        }
+        const current = this.turnCoordinator.getCurrent(sessionId);
+        const runtime = current ? this.turnRuntimes.get(current.id) : undefined;
+        if (runtime) {
+            const input = runtime.inputController.tryEnqueue(content);
+            if (input) {
+                const pending = pendingSteerOutcome(input);
+                runtime.outcomes.set(input.id, pending);
+                return { accepted: true, disposition: "steered", input, outcome: pending.promise };
+            }
+        }
+        return this.queueDetachedInput(sessionId, content, resolved);
+    }
+    enqueueTurn(sessionId, options) {
+        return this.runTurn(sessionId, options);
+    }
+    queueTurn(sessionId, options) {
+        return this.enqueueTurn(sessionId, options);
     }
     // ── Discovery (composer pickers) ─────────────────────────────────────────
     listSkills(cwd) {
@@ -103,30 +209,99 @@ export class BubbleSdk {
         };
     }
     // ── The turn ─────────────────────────────────────────────────────────────
-    async *runTurn(sessionId, options) {
+    /**
+     * Reserve and start a session turn immediately. Execution is driven by the
+     * SDK's own pump, not by consumption of the returned iterator: the iterator
+     * is a replay subscription, so a host may drop it (or reconnect later via
+     * `openSession`) without stalling or cancelling the turn. Cancel with
+     * `stop()`, the options signal, or `deleteSession()`.
+     */
+    runTurn(sessionId, options) {
         const resolved = this.resolveSession(sessionId);
         if (!resolved)
             throw new Error(`Unknown session: ${sessionId}`);
+        const ownerKey = resolved.manager.getSessionFile();
+        const owner = processSessionOwners.get(ownerKey);
+        if (owner && owner !== this)
+            return owner.runTurn(sessionId, options);
+        claimProcessOwner(ownerKey, this);
+        try {
+            const runtime = this.startOwnedTurn(sessionId, options, resolved, ownerKey);
+            return runtime.events.iterate();
+        }
+        catch (error) {
+            // A synchronous reserve() failure (e.g. pre-aborted signal) must not
+            // leave this SDK pinned as process owner of a session it never ran.
+            if (!this.turnCoordinator.getState(sessionId).active) {
+                releaseProcessOwner(ownerKey, this);
+            }
+            throw error;
+        }
+    }
+    startOwnedTurn(sessionId, options, resolved, ownerKey) {
+        const reservation = this.turnCoordinator.reserve(sessionId, options.signal);
+        const runtime = {
+            sessionId,
+            ownerKey,
+            reservation,
+            inputController: new AgentRunInputQueue(`sdk-turn-${this.inputIdNonce}-${++this.nextTurnInputPrefix}`),
+            outcomes: new Map(),
+            options,
+            events: new ReplayEventLog(),
+        };
+        this.lastTurnOptions.set(sessionId, inheritableTurnOptions(options));
+        this.turnRuntimes.set(reservation.id, runtime);
+        void this.pumpTurn(runtime, resolved);
+        return runtime;
+    }
+    async pumpTurn(runtime, resolved) {
+        let failure;
+        try {
+            for await (const event of this.runReservedTurn(runtime, runtime.options, resolved)) {
+                runtime.events.append(event);
+                this.publishSessionEvent(runtime, event);
+            }
+        }
+        catch (error) {
+            failure = error;
+        }
+        finally {
+            if (failure !== undefined) {
+                // The session-level log never closes per turn, so replay subscribers
+                // need an explicit terminal record — otherwise a failed turn is
+                // indistinguishable from one that is still running.
+                this.publishSessionEvent(runtime, { type: "turn_end", willContinue: false }, {
+                    kind: failure instanceof AgentAbortError || runtime.reservation.signal.aborted
+                        ? "cancelled"
+                        : "failed",
+                    message: failure instanceof Error ? failure.message : String(failure),
+                });
+            }
+            runtime.events.close(failure);
+            if (this.turnRuntimes.get(runtime.reservation.id) === runtime) {
+                this.turnRuntimes.delete(runtime.reservation.id);
+            }
+            if (!this.turnCoordinator.getState(runtime.sessionId).active) {
+                releaseProcessOwner(runtime.ownerKey, this);
+            }
+        }
+    }
+    async *runReservedTurn(runtime, options, resolved) {
+        const { sessionId, reservation, inputController } = runtime;
         const { manager: session, cwd } = resolved;
         const mode = options.mode ?? "default";
-        const abort = new AbortController();
-        if (options.signal) {
-            if (options.signal.aborted)
-                abort.abort();
-            else
-                options.signal.addEventListener("abort", () => abort.abort(), { once: true });
-        }
-        this.activeTurns.set(sessionId, abort);
+        const abortSignal = reservation.signal;
         let agentRef;
+        let streamCompleted = false;
         const hookController = new ExternalHookController({ cwd, sessionId });
         // Settles as reject the moment the turn aborts, so a tool blocked on a
         // host approval (or question) can never hang the abort path.
         const abortedDecision = new Promise((resolve) => {
             const decide = () => resolve({ action: "reject", feedback: "Turn aborted" });
-            if (abort.signal.aborted)
+            if (abortSignal.aborted)
                 decide();
             else
-                abort.signal.addEventListener("abort", decide, { once: true });
+                abortSignal.addEventListener("abort", decide, { once: true });
         });
         const approvalController = new PermissionAwareApprovalController({
             getMode: () => agentRef?.mode ?? mode,
@@ -146,7 +321,9 @@ export class BubbleSdk {
         const planController = {
             getMode: () => agentRef?.mode ?? mode,
             requestApproval: async (plan) => {
-                const approved = options.onPlanApproval ? await options.onPlanApproval(plan) : false;
+                const approved = options.onPlanApproval
+                    ? await awaitWithAbort(options.onPlanApproval(plan), abortSignal)
+                    : false;
                 if (approved) {
                     agentRef?.setMode("default");
                     return { action: "approve", plan };
@@ -166,8 +343,9 @@ export class BubbleSdk {
             }
             options.onQuestion(request).then((answers) => answers ? questionController.reply(request.id, answers) : questionController.reject(request.id), () => questionController.reject(request.id));
         });
-        abort.signal.addEventListener("abort", () => questionController.rejectAll(), { once: true });
+        abortSignal.addEventListener("abort", () => questionController.rejectAll(), { once: true });
         try {
+            await reservation.waitForStart();
             const skillRegistry = new SkillRegistry({
                 cwd,
                 skillPaths: this.userConfig.getSkillPaths(),
@@ -181,9 +359,12 @@ export class BubbleSdk {
                 goalStore: new GoalStore(),
                 checkpoints: () => session.getCheckpoints(),
             });
-            tools.push(...(await this.mcpToolsFor(cwd)));
+            tools.push(...(await awaitWithAbort(this.mcpToolsFor(cwd), abortSignal)));
+            throwAbortSignal(abortSignal);
             const promptCacheKey = session.getOrCreatePromptCacheKey();
-            session.updateMetadata({ cwd }); // recoverable by cwd after host restart
+            if (!this.turnCoordinator.isDeleted(sessionId)) {
+                session.updateMetadata({ cwd }); // recoverable by cwd after host restart
+            }
             const { provider, providerId, model } = this.resolveProvider(promptCacheKey, options.model);
             const thinkingLevel = options.thinkingLevel ??
                 this.userConfig.getDefaultThinkingLevel() ??
@@ -230,20 +411,28 @@ export class BubbleSdk {
                 onMessageAppend: (message) => {
                     if (message.role === "system" || message.role === "meta")
                         return;
+                    if (this.turnCoordinator.isDeleted(sessionId))
+                        return;
                     session.appendMessage(message);
                     if (message.role === "assistant")
                         recordMemoryCitations(cwd, message.content);
                 },
                 onCompactionApplied: (summary) => {
+                    if (this.turnCoordinator.isDeleted(sessionId))
+                        return;
                     session.applyLLMCompaction(summary);
                 },
-                onModeUpdate: (m) => session.appendMarker("mode_switch", m),
+                onModeUpdate: (m) => {
+                    if (!this.turnCoordinator.isDeleted(sessionId))
+                        session.appendMarker("mode_switch", m);
+                },
             });
             agentRef = agent;
             const history = session.getMessages();
             if (history.length > 0) {
                 agent.messages = [{ role: "system", content: systemPrompt }, ...history];
             }
+            reservation.markActive();
             options.onStart?.({
                 providerId,
                 model,
@@ -257,23 +446,146 @@ export class BubbleSdk {
             // recognizing the slash syntax on its own.
             const prompt = rewriteSkillInvocationPrompt(options.prompt, skillRegistry);
             const bareModelId = decodeModel(model).modelId;
-            for await (const event of agent.run(prompt, cwd, { abortSignal: abort.signal })) {
-                yield attachTurnCost(event, providerId, bareModelId);
-                if (abort.signal.aborted)
-                    break;
+            for await (const event of agent.run(prompt, cwd, {
+                abortSignal,
+                inputController,
+            })) {
+                const sdkEvent = this.handleSteerEvent(runtime, event, resolved);
+                yield attachTurnCost(sdkEvent, providerId, bareModelId);
             }
+            streamCompleted = true;
+            for (const event of this.rejectOutstandingSteers(runtime, "no_continuation", resolved))
+                yield event;
+        }
+        catch (error) {
+            const reason = abortSignal.aborted ? "turn_cancelled" : "turn_failed";
+            for (const event of this.rejectOutstandingSteers(runtime, reason))
+                yield event;
+            throw error;
         }
         finally {
-            // Also reached via generator.return() when the host stops consuming
-            // early: aborting here unblocks any tool still awaiting an approval.
-            abort.abort();
+            inputController.closePendingInputs();
+            this.rejectOutstandingSteers(runtime, streamCompleted ? "no_continuation" : abortSignal.aborted ? "turn_cancelled" : "turn_failed", streamCompleted ? resolved : undefined);
             unsubscribeQuestions();
             questionController.rejectAll();
-            if (this.activeTurns.get(sessionId) === abort)
-                this.activeTurns.delete(sessionId);
+            reservation.finish();
+            if (this.turnRuntimes.get(reservation.id) === runtime)
+                this.turnRuntimes.delete(reservation.id);
         }
     }
     // ── Internals ────────────────────────────────────────────────────────────
+    runtimesForSession(sessionId) {
+        return [...this.turnRuntimes.values()].filter((runtime) => runtime.sessionId === sessionId);
+    }
+    settleSteerFromEvent(runtime, event) {
+        if (event.type !== "input_applied" && event.type !== "input_rejected")
+            return;
+        const pending = runtime.outcomes.get(event.id);
+        if (!pending)
+            return;
+        runtime.outcomes.delete(event.id);
+        pending.resolve(event);
+    }
+    handleSteerEvent(runtime, event, resolved) {
+        if (event.type === "input_rejected" && event.reason === "no_continuation") {
+            const pending = runtime.outcomes.get(event.id);
+            if (pending)
+                return this.queuePendingSteer(runtime, pending, resolved, event);
+        }
+        this.settleSteerFromEvent(runtime, event);
+        return event;
+    }
+    rejectOutstandingSteers(runtime, reason, resolved) {
+        runtime.inputController.closePendingInputs();
+        const events = [];
+        for (const [id, pending] of runtime.outcomes) {
+            const event = {
+                type: "input_rejected",
+                id,
+                content: pending.input.content,
+                reason,
+                target: "next_turn",
+            };
+            runtime.outcomes.delete(id);
+            if (reason === "no_continuation" && resolved) {
+                events.push(this.queuePendingSteer(runtime, pending, resolved, event));
+            }
+            else {
+                pending.resolve(event);
+                events.push(event);
+            }
+        }
+        return events;
+    }
+    queuePendingSteer(runtime, pending, resolved, rejected) {
+        try {
+            const queuedRuntime = this.startOwnedTurn(runtime.sessionId, { ...inheritableTurnOptions(runtime.options), prompt: pending.input.content }, resolved, runtime.ownerKey);
+            const queued = {
+                type: "input_queued",
+                id: pending.input.id,
+                content: pending.input.content,
+                turnId: queuedRuntime.reservation.id,
+                target: "next_turn",
+            };
+            // The follow-up turn's own subscribers also see the queue marker; the
+            // session-level log already gets it once via this turn's yielded event.
+            queuedRuntime.events.append(queued);
+            runtime.outcomes.delete(pending.input.id);
+            pending.resolve(queued);
+            return queued;
+        }
+        catch {
+            runtime.outcomes.delete(pending.input.id);
+            pending.resolve(rejected);
+            return rejected;
+        }
+    }
+    queueDetachedInput(sessionId, content, resolved) {
+        const ownerKey = resolved.manager.getSessionFile();
+        try {
+            claimProcessOwner(ownerKey, this);
+            const input = {
+                id: `sdk-steer-${this.inputIdNonce}-${++this.nextDetachedInputId}`,
+                content,
+                submittedAt: Date.now(),
+            };
+            const runtime = this.startOwnedTurn(sessionId, { ...(this.lastTurnOptions.get(sessionId) ?? {}), prompt: content }, resolved, ownerKey);
+            const queued = {
+                type: "input_queued",
+                id: input.id,
+                content,
+                turnId: runtime.reservation.id,
+                target: "next_turn",
+            };
+            runtime.events.append(queued);
+            this.publishSessionEvent(runtime, queued);
+            return {
+                accepted: true,
+                disposition: "queued",
+                input,
+                turnId: runtime.reservation.id,
+                outcome: Promise.resolve(queued),
+            };
+        }
+        catch {
+            releaseProcessOwner(ownerKey, this);
+            return { accepted: false, disposition: "rejected", reason: "ownership_conflict" };
+        }
+    }
+    publishSessionEvent(runtime, event, terminal) {
+        const log = sessionEventLogFor(runtime.ownerKey);
+        log.append({
+            sequence: log.length + 1,
+            sessionId: runtime.sessionId,
+            turnId: runtime.reservation.id,
+            event,
+            ...(terminal ? { terminal } : {}),
+        });
+    }
+    ownerForSession(sessionId) {
+        const resolved = this.resolveSession(sessionId);
+        return resolved ? processSessionOwners.get(resolved.manager.getSessionFile()) : undefined;
+    }
     bashAllowlistFor(sessionId) {
         let allowlist = this.bashAllowlists.get(sessionId);
         if (!allowlist) {
@@ -332,6 +644,8 @@ export class BubbleSdk {
         return cached;
     }
     resolveSession(sessionId) {
+        if (this.turnCoordinator.isDeleted(sessionId))
+            return undefined;
         const memCwd = this.cwdBySession.get(sessionId);
         if (memCwd) {
             // create() only resolves the path and loads iff the file exists, so this
@@ -341,8 +655,20 @@ export class BubbleSdk {
         if (this.sessionIndex.size === 0)
             this.listSessions();
         const entry = this.sessionIndex.get(sessionId);
-        if (!entry)
-            return undefined;
+        if (!entry) {
+            // A session created in this process but not yet persisted to disk is
+            // still resolvable (and routable) for other SDK instances.
+            const registeredCwd = processSessionLocations.get(sessionId);
+            if (!registeredCwd)
+                return undefined;
+            this.cwdBySession.set(sessionId, registeredCwd);
+            return {
+                manager: SessionManager.create(registeredCwd, sessionFileName(sessionId)),
+                cwd: registeredCwd,
+            };
+        }
+        // The disk entry supersedes the pre-persistence registry entry.
+        processSessionLocations.delete(sessionId);
         this.cwdBySession.set(sessionId, entry.cwd);
         return { manager: new SessionManager(entry.file), cwd: entry.cwd };
     }
@@ -379,9 +705,93 @@ export class BubbleSdk {
         return { provider, providerId: activeProviderId, model: activeModel };
     }
 }
+/**
+ * Process-local ownership routes every producer to one SDK runner. Hosts that
+ * run multiple OS processes still need a broker or distributed per-session
+ * lease; two processes cannot safely share a local JSONL transcript directly.
+ */
+const processSessionOwners = new Map();
+const sessionEventLogs = new Map();
+/** sessionId -> cwd for sessions created in this process but not yet on disk. */
+const processSessionLocations = new Map();
+function claimProcessOwner(ownerKey, sdk) {
+    const existing = processSessionOwners.get(ownerKey);
+    if (existing && existing !== sdk) {
+        throw new Error(`SDK session is owned by another runner: ${ownerKey}`);
+    }
+    processSessionOwners.set(ownerKey, sdk);
+}
+function releaseProcessOwner(ownerKey, sdk) {
+    if (processSessionOwners.get(ownerKey) === sdk)
+        processSessionOwners.delete(ownerKey);
+}
+function sessionEventLogFor(ownerKey) {
+    let log = sessionEventLogs.get(ownerKey);
+    if (!log) {
+        log = new ReplayEventLog();
+        sessionEventLogs.set(ownerKey, log);
+    }
+    return log;
+}
+/** End live iterators and drop the buffered events of a deleted session. */
+function releaseSessionEventLog(ownerKey) {
+    const log = sessionEventLogs.get(ownerKey);
+    if (!log)
+        return;
+    log.close();
+    sessionEventLogs.delete(ownerKey);
+}
+function inheritableTurnOptions(options) {
+    const { prompt: _prompt, signal: _signal, ...inherited } = options;
+    return inherited;
+}
 function sessionFileName(sessionId) {
     return sessionId.endsWith(".jsonl") ? sessionId : `${sessionId}.jsonl`;
 }
+function pendingSteerOutcome(input) {
+    let resolve;
+    const promise = new Promise((done) => {
+        resolve = done;
+    });
+    return { input, promise, resolve };
+}
+function throwAbortSignal(signal) {
+    if (!signal.aborted)
+        return;
+    if (signal.reason instanceof Error)
+        throw signal.reason;
+    throw new AgentAbortError(typeof signal.reason === "string" ? signal.reason : "SDK turn cancelled.");
+}
+function awaitWithAbort(promise, signal) {
+    if (signal.aborted) {
+        try {
+            throwAbortSignal(signal);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            cleanup();
+            try {
+                throwAbortSignal(signal);
+            }
+            catch (error) {
+                reject(error);
+            }
+        };
+        const cleanup = () => signal.removeEventListener("abort", onAbort);
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
 /**
  * Attach a `cost` field to turn_end events that carry usage, priced via the
  * static pricing table. Pricing is an accounting concern, so it rides along
@@ -417,6 +827,7 @@ export function rewriteSkillInvocationPrompt(prompt, registry) {
 }
 // ── Building blocks (escape hatch for custom hosts) ────────────────────────
 export { Agent, AgentAbortError } from "../agent.js";
+export { AgentRunInputQueue } from "../agent/input-controller.js";
 export { SessionManager, getSessionsDir, } from "../session.js";
 export { PermissionAwareApprovalController } from "../approval/controller.js";
 export { BashAllowlist } from "../approval/session-cache.js";

package/dist/sdk/replay-event-log.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 declare class ReplayEventLog<T> {
+    private readonly entries;
+    private signal;
+    private closed;
+    private failure;
+    get length(): number;
+    append(value: T): void;
+    close(error?: unknown): void;
+    iterate(options?: {
+        from?: number;
+        signal?: AbortSignal;
+    }): AsyncGenerator<T>;
+    private readFrom;
+    private wake;
+}