@bubblebrain-ai/bubble 0.0.28 → 0.0.30

package/dist/context/compact.js

@@ -1,6 +1,5 @@
-export function compactSessionEntries(entries, options = {}) {
+export function planSessionCompaction(entries, options = {}) {
     const keepRecentTurns = options.keepRecentTurns ?? 2;
-    const maxSummaryItems = options.maxSummaryItems ?? 4;
     const metadataEntries = entries.filter((entry) => entry.type === "metadata");
     const nonMetadataEntries = entries.filter((entry) => entry.type !== "metadata");
     const latestSummaryIndex = findLatestSummaryIndex(nonMetadataEntries);
@@ -10,34 +9,52 @@ export function compactSessionEntries(entries, options = {}) {
         .map((entry, index) => (entry.type === "user_message" ? index : -1))
         .filter((index) => index >= 0);
     if (turnStartIndexes.length <= keepRecentTurns) {
-        return { compacted: false };
+        return { compactable: false };
     }
     const keepStartIndex = turnStartIndexes[Math.max(0, turnStartIndexes.length - keepRecentTurns)];
     if (keepStartIndex <= 0) {
-        return { compacted: false };
-    }
-    const oldEntries = activeEntries.slice(0, keepStartIndex);
-    const keptEntries = activeEntries.slice(keepStartIndex);
-    const summary = buildCompactionSummary(oldEntries, maxSummaryItems);
-    if (!summary) {
-        return { compacted: false };
+        return { compactable: false };
     }
+    return {
+        compactable: true,
+        metadataEntries,
+        oldEntries: activeEntries.slice(0, keepStartIndex),
+        keptEntries: activeEntries.slice(keepStartIndex),
+    };
+}
+/**
+ * Assemble the post-compaction entry list from a plan and a (possibly
+ * LLM-generated) summary string. The summary entry is keyed off the full
+ * original `entries` so its id never collides with a prior summary.
+ */
+export function buildCompactedEntries(entries, plan, summary) {
     const summaryEntry = {
         id: nextSummaryId(entries),
         type: "summary",
         summary,
         timestamp: Date.now(),
     };
-    const nextEntries = [
-        ...metadataEntries,
-        summaryEntry,
-        ...keptEntries,
-    ];
+    return [...plan.metadataEntries, summaryEntry, ...plan.keptEntries];
+}
+/** Flatten a plan's old entries into messages for an external summarizer. */
+export function planOldMessages(plan) {
+    return entriesToMessages(plan.oldEntries);
+}
+export function compactSessionEntries(entries, options = {}) {
+    const maxSummaryItems = options.maxSummaryItems ?? 4;
+    const plan = planSessionCompaction(entries, options);
+    if (!plan.compactable) {
+        return { compacted: false };
+    }
+    const summary = buildCompactionSummary(plan.oldEntries, maxSummaryItems);
+    if (!summary) {
+        return { compacted: false };
+    }
     return {
         compacted: true,
         summary,
-        entries: nextEntries,
-        droppedEntries: oldEntries.length,
+        entries: buildCompactedEntries(entries, plan, summary),
+        droppedEntries: plan.oldEntries.length,
     };
 }
 export function compactMessages(messages, options = {}) {

package/dist/goal/format.d.ts

@@ -14,5 +14,5 @@ export declare function goalSummaryText(goal: GoalState): string;
  * update_goal tool can't report this — see goal/tools.ts).
  */
 export declare function goalCompleteNotice(goal: GoalState): string;
-/** Compact single-line indicator for the status line / sidebar. */
+/** Compact single-line indicator for status surfaces. */
 export declare function goalIndicatorLine(goal: GoalState, maxObjective?: number): string;

package/dist/goal/format.js

@@ -95,7 +95,7 @@ function completionTokenUsagePhrase(goal) {
         ? `${formatTokensCompact(goal.tokensUsed)}/${formatTokensCompact(goal.tokenBudget)} tok used`
         : `${formatTokensCompact(goal.tokensUsed)} tok used`;
 }
-/** Compact single-line indicator for the status line / sidebar. */
+/** Compact single-line indicator for status surfaces. */
 export function goalIndicatorLine(goal, maxObjective = 48) {
     const segments = [`goal: ${goalStatusLabel(goal.status)}`, `${goal.turnsSpent} turns`];
     const tokens = tokensPart(goal);

package/dist/network/provider-transport.d.ts

@@ -28,5 +28,14 @@ export declare function normalizeProviderNetworkError(error: unknown, options: {
     env?: NodeJS.ProcessEnv;
 }): Error;
 export declare function isProviderTransportError(error: unknown): boolean;
+/**
+ * Request/response timeouts surface as prose rather than errno tokens — e.g.
+ * Bun fetch throws a DOMException named "TimeoutError" with message
+ * "The operation timed out.", and openai-node raises APIConnectionTimeoutError.
+ * These are kept OUT of isProviderNetworkErrorText on purpose: that predicate
+ * drives normalizeProviderNetworkError's proxy/TLS/CA advice, and a plain
+ * timeout must not be rewrapped into a misleading "check your proxy" message.
+ */
+export declare function isProviderTimeoutErrorText(text: string): boolean;
 export declare function shouldEnableFetchVerbose(env?: NodeJS.ProcessEnv, providerVerboseEnvVar?: string): boolean;
 export {};

package/dist/network/provider-transport.js

@@ -99,7 +99,25 @@ export function normalizeProviderNetworkError(error, options) {
     return new Error(message, { cause: error });
 }
 export function isProviderTransportError(error) {
-    return isProviderNetworkErrorText(errorMessageChain(error).join("\n"));
+    const text = errorMessageChain(error).join("\n");
+    return isProviderNetworkErrorText(text) || isProviderTimeoutErrorText(text);
+}
+/**
+ * Request/response timeouts surface as prose rather than errno tokens — e.g.
+ * Bun fetch throws a DOMException named "TimeoutError" with message
+ * "The operation timed out.", and openai-node raises APIConnectionTimeoutError.
+ * These are kept OUT of isProviderNetworkErrorText on purpose: that predicate
+ * drives normalizeProviderNetworkError's proxy/TLS/CA advice, and a plain
+ * timeout must not be rewrapped into a misleading "check your proxy" message.
+ */
+export function isProviderTimeoutErrorText(text) {
+    return [
+        /operation timed out/i,
+        /request timed out/i,
+        /\bTimeoutError\b/i,
+        /\bAPIConnectionTimeoutError\b/i,
+        /\bESOCKETTIMEDOUT\b/i,
+    ].some((pattern) => pattern.test(text));
 }
 export function shouldEnableFetchVerbose(env = process.env, providerVerboseEnvVar) {
     const providerValue = providerVerboseEnvVar ? env[providerVerboseEnvVar] : undefined;

package/dist/provider.d.ts

@@ -54,4 +54,18 @@ export declare function translateOpenAIFullResponse(response: any): AsyncIterabl
  * in index order to keep multi-call turns deterministic.
  */
 export declare function translateOpenAIStream(stream: AsyncIterable<any>, options?: TranslateOpenAIStreamOptions): AsyncIterable<StreamChunk>;
+/** Largest value Node's 32-bit timers accept; ~24.8 days. */
+export declare const MAX_TIMER_MS = 2147483647;
+/**
+ * Resolve the provider request timeout (ms) from the operator override.
+ *
+ * Default is effectively NO TIMEOUT — safe for streaming APIs where the model
+ * sends chunks continuously. But Node's timers are 32-bit: a duration above
+ * 2**31-1 ms overflows, which makes Node print a TimeoutOverflowWarning to
+ * stderr (corrupting the Ink TUI) AND silently clamp the timeout to 1ms,
+ * aborting the request almost immediately. So we use the largest SAFE timer
+ * value as the "no timeout" sentinel — never Number.MAX_SAFE_INTEGER — and
+ * clamp any operator-supplied value into range too.
+ */
+export declare function resolveRequestTimeoutMs(raw: string | undefined): number;
 export {};

package/dist/provider.js

@@ -94,6 +94,7 @@ export function createProviderInstance(options) {
     const client = new OpenAI({
         apiKey: options.apiKey,
         baseURL: options.baseURL,
+        timeout: resolveRequestTimeoutMs(process.env.BUBBLE_PROVIDER_REQUEST_TIMEOUT_MS),
     });
     const fallbackModel = "gpt-4o";
     async function* streamChat(messages, chatOptions) {
@@ -704,6 +705,29 @@ function mergeToolArgumentDelta(current, incoming, mode) {
     debugToolArgs({ stage: "merge", branch: mode === "delta" ? "delta-append" : "snapshot-fallback-concat", current, incoming, args: current + incoming, delta: incoming });
     return { args: current + incoming, delta: incoming };
 }
+function parsePositiveInt(raw) {
+    if (!raw?.trim())
+        return undefined;
+    const value = Number(raw);
+    return Number.isInteger(value) && value > 0 ? value : undefined;
+}
+/** Largest value Node's 32-bit timers accept; ~24.8 days. */
+export const MAX_TIMER_MS = 2_147_483_647; // 2**31 - 1
+/**
+ * Resolve the provider request timeout (ms) from the operator override.
+ *
+ * Default is effectively NO TIMEOUT — safe for streaming APIs where the model
+ * sends chunks continuously. But Node's timers are 32-bit: a duration above
+ * 2**31-1 ms overflows, which makes Node print a TimeoutOverflowWarning to
+ * stderr (corrupting the Ink TUI) AND silently clamp the timeout to 1ms,
+ * aborting the request almost immediately. So we use the largest SAFE timer
+ * value as the "no timeout" sentinel — never Number.MAX_SAFE_INTEGER — and
+ * clamp any operator-supplied value into range too.
+ */
+export function resolveRequestTimeoutMs(raw) {
+    const requested = parsePositiveInt(raw);
+    return Math.min(requested ?? MAX_TIMER_MS, MAX_TIMER_MS);
+}
 function mergeStreamingText(current, incoming, mode) {
     if (!current)
         return { args: incoming, delta: incoming };

package/dist/session.d.ts

@@ -57,6 +57,22 @@ export declare class SessionManager {
     appendTodosSnapshot(todos: Todo[]): void;
     getTodos(): Todo[];
     compact(options?: CompactOptions): CompactResult;
+    /**
+     * Inspect whether the session is large enough to compact and, if so, return
+     * the older messages an external summarizer should condense. Returns null
+     * when there isn't enough history past the last summary to bother — the
+     * caller should then report "already compact enough" without calling a model.
+     */
+    getCompactionPlan(options?: CompactOptions): {
+        oldMessages: Message[];
+    } | null;
+    /**
+     * Apply a precomputed (typically LLM-generated) summary as the compaction
+     * checkpoint, rewriting the log to [metadata, summary, kept turns]. Mirrors
+     * `compact()` but skips the built-in heuristic summarizer. Returns
+     * `{ compacted: false }` if the session is no longer compactable.
+     */
+    applyLLMCompaction(summary: string, options?: CompactOptions): CompactResult;
     getMessages(): Message[];
     /**
      * Pre-edit file snapshot store for this session, used by /rewind.

package/dist/session.js

@@ -6,7 +6,7 @@ import { mkdirSync, appendFileSync, existsSync, readFileSync, readdirSync, statS
 import { basename, dirname, join } from "node:path";
 import { getBubbleHome } from "./bubble-home.js";
 import { CheckpointStore } from "./checkpoints.js";
-import { compactSessionEntries } from "./context/compact.js";
+import { buildCompactedEntries, compactSessionEntries, planOldMessages, planSessionCompaction, } from "./context/compact.js";
 import { SessionLog } from "./session-log.js";
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
 import { deterministicTitleFromUserContent } from "./session-title.js";
@@ -162,6 +162,38 @@ export class SessionManager {
         }
         return result;
     }
+    /**
+     * Inspect whether the session is large enough to compact and, if so, return
+     * the older messages an external summarizer should condense. Returns null
+     * when there isn't enough history past the last summary to bother — the
+     * caller should then report "already compact enough" without calling a model.
+     */
+    getCompactionPlan(options) {
+        const plan = planSessionCompaction(this.log.list(), options);
+        if (!plan.compactable)
+            return null;
+        return { oldMessages: planOldMessages(plan) };
+    }
+    /**
+     * Apply a precomputed (typically LLM-generated) summary as the compaction
+     * checkpoint, rewriting the log to [metadata, summary, kept turns]. Mirrors
+     * `compact()` but skips the built-in heuristic summarizer. Returns
+     * `{ compacted: false }` if the session is no longer compactable.
+     */
+    applyLLMCompaction(summary, options) {
+        const entries = this.log.list();
+        const plan = planSessionCompaction(entries, options);
+        if (!plan.compactable)
+            return { compacted: false };
+        const nextEntries = buildCompactedEntries(entries, plan, summary);
+        this.rewrite(nextEntries);
+        return {
+            compacted: true,
+            summary,
+            entries: nextEntries,
+            droppedEntries: plan.oldEntries.length,
+        };
+    }
     getMessages() {
         return this.log.toMessages();
     }

package/dist/slash-commands/commands.js

@@ -1,4 +1,4 @@
-import { UserConfig, maskKey } from "../config.js";
+import { UserConfig } from "../config.js";
 import { formatContextUsage } from "../context/usage.js";
 import { formatDiagnostics } from "../lsp/index.js";
 import { normalizeNameForMCP } from "../mcp/name.js";
@@ -8,7 +8,6 @@ import { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingL
 import { SessionManager } from "../session.js";
 import { buildSystemPrompt } from "../system-prompt.js";
 import { normalizeSingleLine } from "../text-display.js";
-import { copyToClipboard } from "../clipboard.js";
 import { formatRelativeTime } from "../tui/recent-activity.js";
 import { HOOK_EVENT_NAMES, isHookEventName } from "../hooks/index.js";
 import { isThinkingLevel } from "../variant/thinking-level.js";
@@ -287,17 +286,6 @@ async function handleMemoryCommand(args, ctx) {
     }
     return "Usage: /memory [status|search|compact|summarize|refresh|reset]";
 }
-function parseKeyArgs(args, ctx) {
-    const trimmed = args.trim();
-    const [first, ...rest] = trimmed.split(/\s+/);
-    const explicitProvider = first
-        ? ctx.registry.getConfigured().find((provider) => provider.id === first)
-        : undefined;
-    if (explicitProvider) {
-        return { provider: explicitProvider, apiKey: rest.join(" ") };
-    }
-    return { provider: ctx.registry.getDefault(), apiKey: trimmed };
-}
 const builtinSlashCommandEntries = [
     {
         name: "skills",
@@ -363,33 +351,6 @@ const builtinSlashCommandEntries = [
             return `Theme set to ${arg}${arg === "auto" ? ` (resolved to ${resolved})` : ""}.`;
         },
     },
-    {
-        name: "sidebar",
-        description: "Toggle the right sidebar. Usage: /sidebar [open|close|auto]",
-        async handler(args, ctx) {
-            if (!ctx.toggleSidebar || !ctx.setSidebarMode) {
-                return "Sidebar control is only available inside the TUI.";
-            }
-            const arg = args.trim().toLowerCase();
-            if (!arg) {
-                ctx.toggleSidebar();
-                return;
-            }
-            if (["open", "show", "expand", "expanded", "on"].includes(arg)) {
-                ctx.setSidebarMode("expanded");
-                return;
-            }
-            if (["close", "hide", "collapse", "collapsed", "off"].includes(arg)) {
-                ctx.setSidebarMode("collapsed");
-                return;
-            }
-            if (arg === "auto") {
-                ctx.setSidebarMode("auto");
-                return;
-            }
-            return "Usage: /sidebar [open|close|auto]";
-        },
-    },
     {
         name: "clear",
         description: "Clear the current conversation history",
@@ -403,27 +364,6 @@ const builtinSlashCommandEntries = [
             ctx.clearMessages();
         },
     },
-    {
-        name: "copy",
-        description: "Copy the last assistant message to the system clipboard",
-        async handler(args, ctx) {
-            const lastAssistant = [...ctx.agent.messages]
-                .reverse()
-                .find((m) => m.role === "assistant" && typeof m.content === "string" && m.content.trim().length > 0);
-            if (!lastAssistant || typeof lastAssistant.content !== "string") {
-                return "No assistant message to copy yet.";
-            }
-            const text = lastAssistant.content;
-            try {
-                await copyToClipboard(text);
-            }
-            catch (err) {
-                return `Failed to copy to clipboard: ${err?.message || String(err)}`;
-            }
-            const chars = text.length;
-            return `Copied last assistant message to clipboard (${chars} character${chars === 1 ? "" : "s"}).`;
-        },
-    },
     {
         name: "rewind",
         description: "Rewind conversation and/or file edits to before an earlier message. Usage: /rewind [n] [--code|--chat]",
@@ -667,31 +607,6 @@ const builtinSlashCommandEntries = [
             return `Model switched to ${displaySelectedModel(next, ctx.agent.thinking)}.`;
         },
     },
-    {
-        name: "key",
-        description: "Set API key for the current or a specific provider. Usage: /key [provider-id] <key>",
-        async handler(args, ctx) {
-            if (!args) {
-                ctx.openPicker("key");
-                return;
-            }
-            const { provider, apiKey } = parseKeyArgs(args, ctx);
-            if (!provider) {
-                return "No provider configured. Use /provider --add <id> first.";
-            }
-            if (!apiKey) {
-                return `Usage: /key ${provider.id} <key>`;
-            }
-            if (ctx.registry.getModelConfig().hasProvider(provider.id)) {
-                return `API key for ${provider.name} is managed in ~/.bubble/models.json. Please edit that file directly.`;
-            }
-            ctx.registry.updateProviderKey(provider.id, apiKey);
-            ctx.registry.setDefault(provider.id);
-            ctx.agent.setProvider(ctx.createProvider(provider.id, apiKey, provider.baseURL));
-            ctx.agent.providerId = provider.id;
-            return `API key updated for ${provider.name} to ${maskKey(apiKey)}.`;
-        },
-    },
     {
         name: "logout",
         description: "Remove OAuth credentials for a provider. Usage: /logout [openai]",
@@ -732,32 +647,6 @@ const builtinSlashCommandEntries = [
                 : "Exited plan mode.";
         },
     },
-    {
-        name: "todos",
-        description: "Show the current todo list. Use /todos clear to reset it.",
-        async handler(args, ctx) {
-            const sub = args.trim();
-            if (sub === "clear") {
-                const previous = ctx.agent.getTodos().length;
-                if (previous === 0) {
-                    return "Todo list is already empty.";
-                }
-                ctx.agent.setTodos([]);
-                return `Cleared ${previous} todo item${previous === 1 ? "" : "s"}.`;
-            }
-            const todos = ctx.agent.getTodos();
-            if (todos.length === 0) {
-                return "No todos yet. The assistant will create some when working on multi-step tasks.";
-            }
-            const glyph = (status) => status === "completed" ? "✔" : status === "in_progress" ? "▶" : "○";
-            const lines = ["Todos:"];
-            for (const todo of todos) {
-                const label = todo.status === "in_progress" ? (todo.activeForm || todo.content) : todo.content;
-                lines.push(`  ${glyph(todo.status)} ${label}`);
-            }
-            return lines.join("\n");
-        },
-    },
     {
         name: "permissions",
         description: "Inspect or edit allow/deny rules. Subcommands: add <scope> <list> <rule>, remove <scope> <list> <rule>, clear (session allowlist), reload.",
@@ -978,7 +867,46 @@ const builtinSlashCommandEntries = [
             if (preHook?.decision === "deny") {
                 return preHook.reason ?? `Compaction blocked by hook ${preHook.sourceHookId ?? "<unknown>"}.`;
             }
-            const result = ctx.sessionManager.compact();
+            // Plan first so we can report "already compact" without spending a model
+            // call, and so the LLM summarizer gets the exact set of evicted messages.
+            const plan = ctx.sessionManager.getCompactionPlan();
+            if (!plan) {
+                await ctx.hookController?.runEvent({
+                    eventName: "PostCompact",
+                    cwd: ctx.cwd,
+                    sessionId: ctx.sessionManager.getSessionFile(),
+                    agentRole: "driver",
+                    target: "manual",
+                    payload: { kind: "manual", compacted: false },
+                });
+                return "Session is already compact enough.";
+            }
+            // Stream an LLM summary for high fidelity, reporting progress to the TUI.
+            // On any failure (or empty output) fall back to the instant heuristic
+            // compaction so /compact always makes progress.
+            let result;
+            try {
+                ctx.compactionProgress?.({ phase: "collecting", streamedChars: 0 });
+                let summary = "";
+                try {
+                    summary = await ctx.agent.summarizeForCompaction(plan.oldMessages, (full) => {
+                        ctx.compactionProgress?.({ phase: "summarizing", streamedChars: full.length });
+                    });
+                }
+                catch {
+                    summary = "";
+                }
+                if (summary) {
+                    ctx.compactionProgress?.({ phase: "applying", streamedChars: summary.length });
+                    result = ctx.sessionManager.applyLLMCompaction(summary);
+                }
+                else {
+                    result = ctx.sessionManager.compact();
+                }
+            }
+            finally {
+                ctx.compactionProgress?.(null);
+            }
             if (!result.compacted) {
                 await ctx.hookController?.runEvent({
                     eventName: "PostCompact",

package/dist/slash-commands/types.d.ts

@@ -10,11 +10,15 @@ import type { LspService } from "../lsp/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ThemeMode } from "../config.js";
 import type { ExternalHookController } from "../hooks/controller.js";
-export type SidebarMode = "auto" | "expanded" | "collapsed";
-export interface SidebarCommandState {
-    mode: SidebarMode;
-    visible: boolean;
-    active: boolean;
+/**
+ * Live progress for a manual `/compact` run, pushed to the TUI so it can render
+ * a progress bar. `phase` advances collecting → summarizing → applying;
+ * `streamedChars` is the running length of the streamed summary (drives the
+ * bar's fill within the summarizing phase). Hosts without a UI omit the sink.
+ */
+export interface CompactionProgress {
+    phase: "collecting" | "summarizing" | "applying";
+    streamedChars: number;
 }
 export interface SlashCommandContext {
     agent: Agent;
@@ -42,10 +46,6 @@ export interface SlashCommandContext {
     getResolvedTheme?: () => "light" | "dark";
     /** Persist a new theme mode AND apply it to the running TUI. */
     setThemeMode?: (mode: ThemeMode) => void;
-    /** Toggle the right session sidebar in the running TUI. */
-    toggleSidebar?: () => SidebarCommandState;
-    /** Set the right session sidebar mode in the running TUI. */
-    setSidebarMode?: (mode: SidebarMode) => SidebarCommandState;
     /** Open the feedback dialog. `initialDescription` prefills the description field. */
     openFeedback?: (initialDescription: string) => void;
     /** Open the interactive rewind picker. When absent, /rewind falls back to a text listing. */
@@ -56,6 +56,11 @@ export interface SlashCommandContext {
     fillComposer?: (text: string) => void;
     /** Open the interactive usage stats panel. */
     openStats?: () => void;
+    /**
+     * Push live compaction progress to the running TUI. Pass a progress object
+     * while compacting and `null` to clear the indicator. Absent in non-TUI hosts.
+     */
+    compactionProgress?: (progress: CompactionProgress | null) => void;
 }
 /**
  * Return types for a slash command handler:

package/dist/tools/agent-lifecycle.d.ts

@@ -28,5 +28,11 @@ export declare function createListAgentsTool(): ToolRegistryEntry;
 export declare const AGENT_TEAM_MIN_ITEMS = 2;
 export declare const AGENT_TEAM_MAX_ITEMS = 32;
 export declare function createAgentTeamTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
+/** Specs bound for one agent_batch call (design v2 §1.3). */
+export declare const AGENT_BATCH_MIN_SPECS = 2;
+export declare const AGENT_BATCH_MAX_SPECS = 32;
+export declare function createAgentBatchTool(options?: AgentLifecycleToolOptions, sharedTrust?: ProjectProfileTrust): ToolRegistryEntry;
+export declare function createRunWorkflowTool(options?: AgentLifecycleToolOptions): ToolRegistryEntry;
+export declare function createWaitWorkflowTool(): ToolRegistryEntry;
 export declare function createAgentLifecycleTools(options?: AgentLifecycleToolOptions): ToolRegistryEntry[];
 export {};