@bubblebrain-ai/bubble 0.0.24 → 0.0.25

package/README.md

@@ -249,7 +249,7 @@ npm test           # run the test suite (vitest)
 npm start          # run the built agent
 ```
 
-`npm run dev` compiles and launches in one step. The TUI is built on [OpenTUI](https://github.com/anomalyco/opentui) and Solid.
+`npm run dev` compiles and launches in one step. The interactive TUI is built on React Ink.
 
 ## Feishu host (optional)
 

package/dist/config.d.ts

@@ -10,6 +10,7 @@ export type ThemeMode = "auto" | "light" | "dark";
 export interface ThemeConfig {
     mode: ThemeMode;
     overrides?: Record<string, string>;
+    explicit?: boolean;
 }
 export interface UserConfigData {
     defaultModel?: string;
@@ -65,5 +66,7 @@ export declare class UserConfig {
     getAgentCategories(): AgentCategoriesConfig;
     getSubagents(): SubagentsUserConfig;
 }
+export declare function shouldProbeTerminalTheme(config: ThemeConfig): boolean;
+export declare function effectiveThemeModeForTerminal(config: ThemeConfig, detectedTheme: Exclude<ThemeMode, "auto">): ThemeMode;
 /** Mask an API key for safe display. */
 export declare function maskKey(key: string): string;

package/dist/config.js

@@ -55,7 +55,7 @@ function sanitizeTheme(value) {
         return undefined;
     if (typeof value === "string") {
         return value === "auto" || value === "light" || value === "dark"
-            ? { mode: value }
+            ? { mode: value, explicit: true }
             : undefined;
     }
     if (typeof value !== "object" || Array.isArray(value))
@@ -68,7 +68,12 @@ function sanitizeTheme(value) {
         if (mode !== "auto" && mode !== "light" && mode !== "dark")
             return undefined;
         const overrides = isStringMap(maybeNew.overrides) ? maybeNew.overrides : undefined;
-        return overrides ? { mode, overrides } : { mode };
+        const explicit = maybeNew.explicit === true ? true : undefined;
+        return {
+            mode,
+            ...(overrides ? { overrides } : {}),
+            ...(explicit ? { explicit } : {}),
+        };
     }
     const overrides = pickStringEntries(value);
     if (Object.keys(overrides).length === 0)
@@ -188,15 +193,15 @@ export class UserConfig {
     setThemeMode(mode) {
         const current = this.getTheme();
         this.data.theme = current.overrides
-            ? { mode, overrides: current.overrides }
-            : { mode };
+            ? { mode, overrides: current.overrides, explicit: true }
+            : { mode, explicit: true };
         this.save();
     }
     setThemeOverrides(overrides) {
         const current = this.getTheme();
         this.data.theme = Object.keys(overrides).length === 0
-            ? { mode: current.mode }
-            : { mode: current.mode, overrides: { ...overrides } };
+            ? { mode: current.mode, ...(current.explicit ? { explicit: true } : {}) }
+            : { mode: current.mode, overrides: { ...overrides }, ...(current.explicit ? { explicit: true } : {}) };
         this.save();
     }
     getAgentCategories() {
@@ -206,6 +211,17 @@ export class UserConfig {
         return sanitizeSubagentsConfig(this.data.subagents) ?? {};
     }
 }
+export function shouldProbeTerminalTheme(config) {
+    return config.mode === "auto" || isLegacyBareDarkTheme(config);
+}
+export function effectiveThemeModeForTerminal(config, detectedTheme) {
+    if (isLegacyBareDarkTheme(config) && detectedTheme === "light")
+        return "auto";
+    return config.mode;
+}
+function isLegacyBareDarkTheme(config) {
+    return config.mode === "dark" && config.explicit !== true && !config.overrides;
+}
 /** Mask an API key for safe display. */
 export function maskKey(key) {
     if (key.length <= 12)

package/dist/goal/format.js

@@ -30,6 +30,20 @@ function trimZero(value) {
     return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
 }
 function tokensPart(goal) {
+    const untracked = goal.untrackedTokenTurns ?? 0;
+    if (untracked > 0) {
+        const turns = `${untracked} ${untracked === 1 ? "turn" : "turns"}`;
+        if (goal.tokensUsed > 0) {
+            const budget = goal.tokenBudget !== undefined
+                ? `/${formatTokensCompact(goal.tokenBudget)}`
+                : "";
+            return `${formatTokensCompact(goal.tokensUsed)}${budget} tok tracked; usage unavailable for ${turns}`;
+        }
+        if (goal.tokenBudget !== undefined) {
+            return `usage unavailable for ${turns}; budget ${formatTokensCompact(goal.tokenBudget)} tok`;
+        }
+        return `usage unavailable for ${turns}`;
+    }
     if (goal.tokenBudget !== undefined) {
         return `${formatTokensCompact(goal.tokensUsed)}/${formatTokensCompact(goal.tokenBudget)} tok`;
     }
@@ -59,11 +73,27 @@ export function goalSummaryText(goal) {
  * update_goal tool can't report this — see goal/tools.ts).
  */
 export function goalCompleteNotice(goal) {
-    const tokens = goal.tokenBudget !== undefined
-        ? `${formatTokensCompact(goal.tokensUsed)}/${formatTokensCompact(goal.tokenBudget)} tok`
-        : `${formatTokensCompact(goal.tokensUsed)} tok`;
+    const tokens = completionTokenUsagePhrase(goal);
     const turns = `${goal.turnsSpent} ${goal.turnsSpent === 1 ? "turn" : "turns"}`;
-    return `Goal complete — ${tokens} used over ${turns}.`;
+    return `Goal complete — ${tokens} over ${turns}.`;
+}
+function completionTokenUsagePhrase(goal) {
+    const untracked = goal.untrackedTokenTurns ?? 0;
+    if (untracked > 0) {
+        if (goal.tokensUsed > 0) {
+            const budget = goal.tokenBudget !== undefined
+                ? `/${formatTokensCompact(goal.tokenBudget)}`
+                : "";
+            return `${formatTokensCompact(goal.tokensUsed)}${budget} tok used, plus unavailable usage`;
+        }
+        if (goal.tokenBudget !== undefined) {
+            return `token usage unavailable (budget ${formatTokensCompact(goal.tokenBudget)} tok)`;
+        }
+        return "token usage unavailable";
+    }
+    return goal.tokenBudget !== undefined
+        ? `${formatTokensCompact(goal.tokensUsed)}/${formatTokensCompact(goal.tokenBudget)} tok used`
+        : `${formatTokensCompact(goal.tokensUsed)} tok used`;
 }
 /** Compact single-line indicator for the status line / sidebar. */
 export function goalIndicatorLine(goal, maxObjective = 48) {

package/dist/goal/store.d.ts

@@ -15,6 +15,8 @@ export interface GoalState {
     /** Optional positive token budget; auto-continuation stops once reached. */
     tokenBudget?: number;
     tokensUsed: number;
+    /** Goal turns where the provider did not report token usage. */
+    untrackedTokenTurns?: number;
     /** Number of completed goal turns (including the initial turn). */
     turnsSpent: number;
     createdAt: number;
@@ -52,6 +54,7 @@ export declare class GoalStore {
     markBudgetLimited(): GoalState | null;
     private setStatus;
     addTokens(n: number): void;
+    markTokenUsageUnavailable(): void;
     incrementTurn(): void;
     /** True when a token budget is set and usage has reached or exceeded it. */
     isBudgetExceeded(): boolean;

package/dist/goal/store.js

@@ -54,6 +54,7 @@ export class GoalStore {
             status: "active",
             tokenBudget,
             tokensUsed: 0,
+            untrackedTokenTurns: 0,
             turnsSpent: 0,
             createdAt: ts,
             updatedAt: ts,
@@ -131,6 +132,13 @@ export class GoalStore {
         this.touch();
         this.emit();
     }
+    markTokenUsageUnavailable() {
+        if (!this.goal)
+            return;
+        this.goal.untrackedTokenTurns = (this.goal.untrackedTokenTurns ?? 0) + 1;
+        this.touch();
+        this.emit();
+    }
     incrementTurn() {
         if (!this.goal)
             return;
@@ -154,7 +162,12 @@ export class GoalStore {
             this.goal = null;
         }
         else {
-            this.goal = { ...state };
+            this.goal = {
+                ...state,
+                untrackedTokenTurns: state.untrackedTokenTurns !== undefined && state.untrackedTokenTurns > 0
+                    ? Math.round(state.untrackedTokenTurns)
+                    : 0,
+            };
         }
         this.emit();
     }

package/dist/goal/usage.d.ts

@@ -0,0 +1,2 @@
+import type { TokenUsage } from "../types.js";
+export declare function tokenUsageTotal(usage: TokenUsage): number;

package/dist/goal/usage.js

@@ -0,0 +1,3 @@
+export function tokenUsageTotal(usage) {
+    return usage.totalTokens ?? ((usage.promptTokens || 0) + (usage.completionTokens || 0));
+}

package/dist/main.js

@@ -6,7 +6,7 @@ import chalk from "chalk";
 import { Agent } from "./agent.js";
 import { BudgetLedger } from "./agent/budget-ledger.js";
 import { parseArgs, printHelp } from "./cli.js";
-import { UserConfig } from "./config.js";
+import { effectiveThemeModeForTerminal, shouldProbeTerminalTheme, UserConfig } from "./config.js";
 import { createProviderInstance, createUnavailableProvider } from "./provider.js";
 import { resolveConfiguredModel } from "./model-selection.js";
 import { getDefaultThinkingLevel } from "./provider-transform.js";
@@ -31,10 +31,6 @@ import { basename } from "node:path";
 import { normalizeSingleLine, truncateVisual } from "./text-display.js";
 import { BUBBLE_WORDMARK } from "./tui/wordmark.js";
 import { configureDebugTrace, summarizeAgentEventForTrace, summarizeTraceMessage, traceEvent, } from "./debug-trace.js";
-// OpenTUI is the default renderer. The React Ink implementation (alt-screen
-// viewport, src/tui-ink) is feature-complete but still maturing — opt in with
-// BUBBLE_TUI=ink.
-const USE_OPENTUI = process.env.BUBBLE_TUI !== "ink";
 async function main() {
     const args = parseArgs(process.argv.slice(2));
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
@@ -229,21 +225,21 @@ async function main() {
         }
         else {
             const themeConfig = userConfig.getTheme();
-            if (themeConfig.mode === "auto") {
+            if (shouldProbeTerminalTheme(themeConfig)) {
                 const { detectTerminalTheme } = await import("./tui/detect-theme.js");
                 preResolvedTheme = await detectTerminalTheme();
             }
             else {
-                preResolvedTheme = themeConfig.mode;
+                preResolvedTheme = themeConfig.mode === "light" ? "light" : "dark";
             }
-            const { runSessionPicker } = USE_OPENTUI
-                ? await import("./tui-opentui/run-session-picker.js")
-                : await import("./tui-ink/run-session-picker.js");
+            const pickerThemeMode = effectiveThemeModeForTerminal(themeConfig, preResolvedTheme);
+            const pickerResolvedTheme = pickerThemeMode === "auto" ? preResolvedTheme : pickerThemeMode;
+            const { runSessionPicker } = await import("./tui-ink/run-session-picker.js");
             const picked = await runSessionPicker({
                 currentCwd: args.cwd,
                 currentSessions,
                 allSessions,
-                resolvedTheme: preResolvedTheme,
+                resolvedTheme: pickerResolvedTheme,
                 themeOverrides: themeConfig.overrides,
             });
             if (picked) {
@@ -317,7 +313,7 @@ async function main() {
         sessionFile: sessionManager?.getSessionFile(),
         provider: activeProviderId || "none",
         model: activeModel || "none",
-        renderer: printMode ? "print" : USE_OPENTUI ? "opentui-core" : "ink",
+        renderer: printMode ? "print" : "ink",
     });
     if (traceInfo.enabled) {
         traceEvent("run_start", {
@@ -508,15 +504,16 @@ async function main() {
         if (preResolvedTheme) {
             detectedTheme = preResolvedTheme;
         }
-        else if (themeConfig.mode === "auto") {
-            // Probe before OpenTUI owns stdin. OSC 11 needs raw mode, and the
+        else if (shouldProbeTerminalTheme(themeConfig)) {
+            // Probe before the renderer owns stdin. OSC 11 needs raw mode, and the
             // runtime renderer can consume the reply before startup code sees it.
             const { detectTerminalTheme } = await import("./tui/detect-theme.js");
             detectedTheme = await detectTerminalTheme();
         }
         else {
-            detectedTheme = themeConfig.mode;
+            detectedTheme = themeConfig.mode === "light" ? "light" : "dark";
         }
+        const effectiveThemeMode = effectiveThemeModeForTerminal(themeConfig, detectedTheme);
         // In-place session switch for the /session picker: rebind every closure
         // that persists to the session (onMessageAppend, markers, title updater)
         // by reassigning the outer `sessionManager`, then replace the agent's
@@ -572,33 +569,17 @@ async function main() {
         const { startStartupUpdateCheck } = await import("./update/index.js");
         const updateCheck = await startStartupUpdateCheck();
         const updateNotice = updateCheck.notice;
-        // Two explicit branches (not a dynamic ternary import) so TypeScript
-        // checks each renderer's RunTuiOptions shape independently.
-        let exitWallMs;
-        if (USE_OPENTUI) {
-            const { runTui } = await import("./tui/run.js");
-            await runTui(agent, args, {
-                ...commonOptions,
-                themeMode: themeConfig.mode,
-                themeOverrides: themeConfig.overrides,
-                detectedTheme,
-                onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
-                updateNotice: updateNotice ?? undefined,
-                updateNoticeRefresh: updateCheck.refreshed,
-            });
-        }
-        else {
-            const { runTui } = await import("./tui-ink/run.js");
-            const summary = await runTui(agent, args, {
-                ...commonOptions,
-                themeMode: themeConfig.mode,
-                themeOverrides: themeConfig.overrides,
-                detectedTheme,
-                onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
-                updateNotice: updateNotice ?? undefined,
-            });
-            exitWallMs = summary?.wallMs;
-        }
+        const { runTui } = await import("./tui-ink/run.js");
+        const summary = await runTui(agent, args, {
+            ...commonOptions,
+            themeMode: effectiveThemeMode,
+            themeOverrides: themeConfig.overrides,
+            detectedTheme,
+            onThemeModeChange: (mode) => userConfig.setThemeMode(mode),
+            updateNotice: updateNotice ?? undefined,
+            updateNoticeRefresh: updateCheck.refreshed,
+        });
+        const exitWallMs = summary?.wallMs;
         if (sessionManager) {
             printExitSummary(sessionManager, {
                 resumed: resumedExistingSession,

package/dist/provider.js

@@ -110,8 +110,10 @@ export function createProviderInstance(options) {
             tool_choice: tools && tools.length > 0 ? chatOptions.toolChoice ?? "auto" : undefined,
             stream: true,
         };
-        // DeepSeek and MiniMax only emit final usage in streaming mode when this flag is set.
-        if (options.providerId === "deepseek" || isMiniMaxOpenAICompatible(options)) {
+        // Several OpenAI-compatible streaming APIs only emit final usage when this
+        // flag is set. Without it, downstream goal/stat accounting can only report
+        // "usage unavailable".
+        if (shouldRequestStreamUsage(options)) {
             body.stream_options = { include_usage: true };
         }
         if (!requestConfig.omitTemperature) {
@@ -207,6 +209,18 @@ function isMiniMaxOpenAICompatible(options) {
         || baseURL.includes("api.minimaxi.com/v1")
         || baseURL.includes("api.minimax.io/v1");
 }
+function shouldRequestStreamUsage(options) {
+    const providerId = (options.providerId || "").toLowerCase();
+    return providerId === "openai"
+        || providerId === "deepseek"
+        || providerId === "moonshot-cn"
+        || providerId === "moonshot-intl"
+        || providerId === "zhipuai"
+        || providerId === "zhipuai-coding-plan"
+        || providerId === "zai"
+        || providerId === "zai-coding-plan"
+        || isMiniMaxOpenAICompatible(options);
+}
 export function normalizeToolArgsDetailed(raw) {
     const s = (raw ?? "").trim();
     if (!s) {
@@ -370,9 +384,10 @@ export async function* translateOpenAIStream(stream, options = {}) {
     }
     for await (const chunk of stream) {
         rawChunkSeq += 1;
-        const delta = chunk.choices?.[0]?.delta;
-        const usage = chunk.usage;
-        const finishReason = chunk.choices?.[0]?.finish_reason;
+        const choice = chunk.choices?.[0];
+        const delta = choice?.delta;
+        const usage = chunk.usage ?? choice?.usage;
+        const finishReason = choice?.finish_reason;
         debugReasoningStream({
             stage: "provider_raw",
             providerId: options.debugProviderId,

package/dist/tui/detect-theme.d.ts

@@ -1,2 +1,3 @@
 export type ResolvedTheme = "light" | "dark";
 export declare function detectTerminalTheme(timeoutMs?: number): Promise<ResolvedTheme>;
+export declare function themeFromMacOsAppearance(output: string | null | undefined): ResolvedTheme;

package/dist/tui/detect-theme.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 export async function detectTerminalTheme(timeoutMs = 150) {
     const fromEnv = parseColorFgBg(process.env.COLORFGBG);
     if (fromEnv)
@@ -7,6 +8,9 @@ export async function detectTerminalTheme(timeoutMs = 150) {
         if (fromOsc)
             return fromOsc;
     }
+    const fromOs = detectOsAppearanceTheme();
+    if (fromOs)
+        return fromOs;
     return "dark";
 }
 function parseColorFgBg(value) {
@@ -85,3 +89,22 @@ function relativeLuminance(r, g, b) {
     const channel = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
     return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
 }
+function detectOsAppearanceTheme() {
+    if (process.platform !== "darwin")
+        return null;
+    try {
+        const output = execFileSync("/usr/bin/defaults", ["read", "-g", "AppleInterfaceStyle"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 100,
+        });
+        return themeFromMacOsAppearance(output);
+    }
+    catch {
+        // On macOS the key is absent in Light mode, and `defaults read` exits 1.
+        return "light";
+    }
+}
+export function themeFromMacOsAppearance(output) {
+    return output?.trim().toLowerCase() === "dark" ? "dark" : "light";
+}

package/dist/tui/image-display.d.ts

@@ -0,0 +1,13 @@
+export interface ImageDisplayMessage {
+    content?: string | null;
+}
+export declare function imageDisplayLabel(index: number): string;
+export declare function imageDisplayLabels(count: number, labelStart?: number): string[];
+export declare function imageDisplayReferenceLine(label: string): string;
+export declare function isImageDisplayReferenceLine(line: string): boolean;
+export declare function splitImageDisplayContent(content: string): {
+    bodyLines: string[];
+    referenceLines: string[];
+};
+export declare function formatImageUserDisplayText(input: string, imageCount: number, labelStart?: number): string;
+export declare function nextImageDisplayLabelStart(messages: Iterable<ImageDisplayMessage>): number;

package/dist/tui/image-display.js

@@ -0,0 +1,49 @@
+export function imageDisplayLabel(index) {
+    return `[Image #${index}]`;
+}
+export function imageDisplayLabels(count, labelStart = 1) {
+    return Array.from({ length: Math.max(0, count) }, (_, index) => imageDisplayLabel(labelStart + index));
+}
+export function imageDisplayReferenceLine(label) {
+    return `└ ${label}`;
+}
+export function isImageDisplayReferenceLine(line) {
+    return /^└ \[Image #\d+\]$/.test(line.trimEnd());
+}
+export function splitImageDisplayContent(content) {
+    const bodyLines = [];
+    const referenceLines = [];
+    for (const line of content.split("\n")) {
+        if (isImageDisplayReferenceLine(line)) {
+            referenceLines.push(line);
+        }
+        else {
+            bodyLines.push(line);
+        }
+    }
+    return { bodyLines, referenceLines };
+}
+export function formatImageUserDisplayText(input, imageCount, labelStart = 1) {
+    if (imageCount <= 0)
+        return input;
+    const labels = imageDisplayLabels(imageCount, labelStart);
+    const base = input.trim();
+    const headline = base ? `${labels.join(" ")} ${base}` : labels.join(" ");
+    return [
+        headline,
+        ...labels.map(imageDisplayReferenceLine),
+    ].join("\n");
+}
+export function nextImageDisplayLabelStart(messages) {
+    let max = 0;
+    const pattern = /\[Image #(\d+)\]/g;
+    for (const message of messages) {
+        const content = message.content ?? "";
+        for (const match of content.matchAll(pattern)) {
+            const value = Number(match[1]);
+            if (Number.isFinite(value))
+                max = Math.max(max, value);
+        }
+    }
+    return max + 1;
+}

package/dist/tui/input-history.d.ts

@@ -1,16 +1,47 @@
+export interface HistoryScope {
+    sessionFile?: string | null;
+    cwd?: string | null;
+}
+export interface HistoryLoadOptions {
+    filePath?: string;
+    scope?: HistoryScope;
+    includeLegacy?: boolean;
+}
+export interface HistoryAppendOptions {
+    filePath?: string;
+    scope?: HistoryScope;
+    createdAt?: Date | string;
+}
+export interface HistoryImageAttachment {
+    mediaType: string;
+    bytes: number;
+    dataUrl: string;
+    base64: string;
+    filename?: string;
+    sourcePath?: string;
+}
+export interface HistoryEntry {
+    text: string;
+    images: HistoryImageAttachment[];
+    imageDisplayStart?: number;
+}
 export declare function defaultHistoryFilePath(): string;
-export declare function loadHistorySync(filePath?: string): string[];
-export declare function appendHistoryEntry(entry: string, filePath?: string): void;
+export declare function loadHistoryEntriesSync(arg?: string | HistoryLoadOptions): HistoryEntry[];
+export declare function loadHistorySync(arg?: string | HistoryLoadOptions): string[];
+export declare function appendHistoryEntry(entry: string | HistoryEntry, arg?: string | HistoryAppendOptions): void;
 export interface HistoryNavState {
-    history: string[];
+    history: Array<string | HistoryEntry>;
     index: number | null;
-    draft: string;
+    draft: string | HistoryEntry;
 }
 export interface HistoryNavResult {
     text: string;
+    images?: HistoryImageAttachment[];
+    imageDisplayStart?: number;
     index: number | null;
-    draft: string;
+    draft: string | HistoryEntry;
     changed: boolean;
 }
-export declare function stepHistory(state: HistoryNavState, direction: "up" | "down", currentText: string): HistoryNavResult;
+export declare function stepHistory(state: HistoryNavState, direction: "up" | "down", currentEntry: string | HistoryEntry): HistoryNavResult;
 export declare function pushHistoryEntry(history: string[], entry: string): string[];
+export declare function pushHistoryEntry(history: HistoryEntry[], entry: HistoryEntry): HistoryEntry[];