@bubblebrain-ai/bubble 0.0.28 → 0.0.29

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/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

@@ -306,6 +306,13 @@ const builtinSlashCommandEntries = [
             ctx.openPicker("skill");
         },
     },
+    {
+        name: "agents",
+        description: "Inspect spawned subagents and their working traces (also Ctrl+G)",
+        async handler(_args, ctx) {
+            ctx.openPicker("agents");
+        },
+    },
     {
         name: "help",
         description: "Show available slash commands",
@@ -978,7 +985,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

@@ -11,6 +11,16 @@ 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";
+/**
+ * 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 SidebarCommandState {
     mode: SidebarMode;
     visible: boolean;
@@ -24,7 +34,7 @@ export interface SlashCommandContext {
     exit: () => void;
     sessionManager?: SessionManager;
     createProvider: (providerId: string, apiKey: string, baseURL: string) => Provider;
-    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout" | "skill" | "feishu-setup", providerId?: string) => void;
+    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout" | "skill" | "feishu-setup" | "agents", providerId?: string) => void;
     registry: ProviderRegistry;
     skillRegistry: SkillRegistry;
     bashAllowlist?: BashAllowlist;
@@ -56,6 +66,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 {};