@bubblebrain-ai/bubble 0.0.24 → 0.0.26

package/dist/tui/input-history.js

@@ -5,9 +5,145 @@ const MAX_HISTORY_ENTRIES = 1000;
 export function defaultHistoryFilePath() {
     return join(getBubbleHome(), "input-history.jsonl");
 }
-// JSONL on disk: each line is a JSON-encoded string. JSON encoding handles
-// embedded newlines and quotes so multi-line composer entries round-trip safely.
-export function loadHistorySync(filePath = defaultHistoryFilePath()) {
+function nonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function normalizeScope(scope) {
+    return {
+        sessionFile: nonEmpty(scope?.sessionFile),
+        cwd: nonEmpty(scope?.cwd),
+    };
+}
+function parseLoadOptions(arg) {
+    if (typeof arg === "string")
+        return { filePath: arg };
+    return { filePath: arg?.filePath ?? defaultHistoryFilePath(), scope: arg?.scope, includeLegacy: arg?.includeLegacy };
+}
+function parseAppendOptions(arg) {
+    if (typeof arg === "string")
+        return { filePath: arg };
+    return { filePath: arg?.filePath ?? defaultHistoryFilePath(), scope: arg?.scope, createdAt: arg?.createdAt };
+}
+function base64FromDataUrl(dataUrl) {
+    const marker = ";base64,";
+    const index = dataUrl.indexOf(marker);
+    return index >= 0 ? dataUrl.slice(index + marker.length) : "";
+}
+function normalizeHistoryImage(input) {
+    if (!input || typeof input !== "object")
+        return null;
+    const image = input;
+    const mediaType = typeof image.mediaType === "string" ? image.mediaType : "";
+    const dataUrl = typeof image.dataUrl === "string" ? image.dataUrl : "";
+    const bytes = typeof image.bytes === "number" && Number.isFinite(image.bytes) ? image.bytes : 0;
+    if (!mediaType || !dataUrl || bytes <= 0)
+        return null;
+    const base64 = typeof image.base64 === "string" && image.base64
+        ? image.base64
+        : base64FromDataUrl(dataUrl);
+    if (!base64)
+        return null;
+    return {
+        mediaType,
+        bytes,
+        dataUrl,
+        base64,
+        ...(typeof image.filename === "string" && image.filename ? { filename: image.filename } : {}),
+        ...(typeof image.sourcePath === "string" && image.sourcePath ? { sourcePath: image.sourcePath } : {}),
+    };
+}
+function normalizeHistoryImages(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input.flatMap((image) => {
+        const normalized = normalizeHistoryImage(image);
+        return normalized ? [normalized] : [];
+    });
+}
+function normalizeImageDisplayStart(input) {
+    return typeof input === "number" && Number.isFinite(input) && input > 0
+        ? Math.floor(input)
+        : undefined;
+}
+function toHistoryEntry(input) {
+    if (typeof input === "string") {
+        return input.trim().length > 0 ? { text: input, images: [] } : null;
+    }
+    const text = typeof input.text === "string" ? input.text : "";
+    const images = normalizeHistoryImages(input.images);
+    const imageDisplayStart = normalizeImageDisplayStart(input.imageDisplayStart);
+    if (text.trim().length === 0 && images.length === 0)
+        return null;
+    return {
+        text,
+        images,
+        ...(imageDisplayStart !== undefined ? { imageDisplayStart } : {}),
+    };
+}
+function historyEntrySignature(entry) {
+    const normalized = typeof entry === "string" ? { text: entry, images: [] } : entry;
+    return JSON.stringify({
+        text: normalized.text,
+        images: normalizeHistoryImages(normalized.images).map((image) => ({
+            mediaType: image.mediaType,
+            bytes: image.bytes,
+            dataUrl: image.dataUrl,
+            filename: image.filename ?? "",
+            sourcePath: image.sourcePath ?? "",
+        })),
+    });
+}
+function serializableHistoryImages(images) {
+    return normalizeHistoryImages(images).map((image) => ({
+        mediaType: image.mediaType,
+        bytes: image.bytes,
+        dataUrl: image.dataUrl,
+        ...(image.filename ? { filename: image.filename } : {}),
+        ...(image.sourcePath ? { sourcePath: image.sourcePath } : {}),
+    }));
+}
+function parseHistoryLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed === "string") {
+            return parsed.length > 0 ? { text: parsed, images: [] } : null;
+        }
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const text = typeof parsed.text === "string" ? parsed.text : "";
+        const images = normalizeHistoryImages(parsed.images);
+        const imageDisplayStart = normalizeImageDisplayStart(parsed.imageDisplayStart);
+        if (text.length === 0 && images.length === 0)
+            return null;
+        return {
+            text,
+            images,
+            ...(imageDisplayStart !== undefined ? { imageDisplayStart } : {}),
+            sessionFile: nonEmpty(parsed.sessionFile),
+            cwd: nonEmpty(parsed.cwd),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function historyEntryMatchesScope(entry, scope, includeLegacy) {
+    const normalized = normalizeScope(scope);
+    if (!scope)
+        return true;
+    if (!normalized.sessionFile)
+        return includeLegacy && !entry.sessionFile;
+    if (!entry.sessionFile)
+        return includeLegacy;
+    return entry.sessionFile === normalized.sessionFile;
+}
+// JSONL on disk: new entries are JSON objects with session metadata and optional
+// image data. Older files used JSON strings; unscoped loads still read them,
+// while scoped loads match only sessionFile so old global history cannot leak
+// into a session.
+export function loadHistoryEntriesSync(arg) {
+    const { filePath, scope, includeLegacy = false } = parseLoadOptions(arg);
     try {
         if (!existsSync(filePath))
             return [];
@@ -16,13 +152,15 @@ export function loadHistorySync(filePath = defaultHistoryFilePath()) {
         for (const line of raw.split("\n")) {
             if (!line)
                 continue;
-            try {
-                const parsed = JSON.parse(line);
-                if (typeof parsed === "string" && parsed.length > 0)
-                    out.push(parsed);
-            }
-            catch {
-                // Malformed line - skip rather than fail the whole load.
+            const parsed = parseHistoryLine(line);
+            if (!parsed)
+                continue;
+            if (historyEntryMatchesScope(parsed, scope, includeLegacy)) {
+                out.push({
+                    text: parsed.text,
+                    images: parsed.images,
+                    ...(parsed.imageDisplayStart !== undefined ? { imageDisplayStart: parsed.imageDisplayStart } : {}),
+                });
             }
         }
         return out.length > MAX_HISTORY_ENTRIES ? out.slice(-MAX_HISTORY_ENTRIES) : out;
@@ -31,12 +169,29 @@ export function loadHistorySync(filePath = defaultHistoryFilePath()) {
         return [];
     }
 }
-export function appendHistoryEntry(entry, filePath = defaultHistoryFilePath()) {
-    if (!entry || entry.trim().length === 0)
+export function loadHistorySync(arg) {
+    return loadHistoryEntriesSync(arg).map((entry) => entry.text);
+}
+export function appendHistoryEntry(entry, arg) {
+    const normalizedEntry = toHistoryEntry(entry);
+    if (!normalizedEntry)
         return;
+    const { filePath, scope, createdAt } = parseAppendOptions(arg);
+    const normalizedScope = normalizeScope(scope);
+    const timestamp = typeof createdAt === "string"
+        ? createdAt
+        : (createdAt ?? new Date()).toISOString();
+    const record = {
+        text: normalizedEntry.text,
+        createdAt: timestamp,
+        ...(normalizedEntry.images.length > 0 ? { images: serializableHistoryImages(normalizedEntry.images) } : {}),
+        ...(normalizedEntry.imageDisplayStart !== undefined ? { imageDisplayStart: normalizedEntry.imageDisplayStart } : {}),
+        ...(normalizedScope.sessionFile ? { sessionFile: normalizedScope.sessionFile } : {}),
+        ...(normalizedScope.cwd ? { cwd: normalizedScope.cwd } : {}),
+    };
     try {
         mkdirSync(dirname(filePath), { recursive: true });
-        appendFileSync(filePath, JSON.stringify(entry) + "\n", "utf8");
+        appendFileSync(filePath, JSON.stringify(record) + "\n", "utf8");
     }
     catch {
         // Persistence is best-effort; never crash the composer over disk IO.
@@ -46,34 +201,50 @@ export function appendHistoryEntry(entry, filePath = defaultHistoryFilePath()) {
 // editing a fresh draft; otherwise it points at history[index]. When stepping
 // from the draft into history we snapshot the current text so down past the
 // newest entry can restore it.
-export function stepHistory(state, direction, currentText) {
+export function stepHistory(state, direction, currentEntry) {
     const { history, index, draft } = state;
-    const noChange = { text: currentText, index, draft, changed: false };
+    const current = toHistoryEntry(currentEntry) ?? { text: "", images: [] };
+    const currentDraft = typeof currentEntry === "string" ? currentEntry : current;
+    const noChange = { text: current.text, index, draft, changed: false };
+    const resultFromEntry = (entry, nextIndex, nextDraft) => {
+        const normalized = toHistoryEntry(entry) ?? { text: "", images: [] };
+        return {
+            text: normalized.text,
+            ...(normalized.images.length > 0 ? { images: normalized.images } : {}),
+            ...(normalized.imageDisplayStart !== undefined ? { imageDisplayStart: normalized.imageDisplayStart } : {}),
+            index: nextIndex,
+            draft: nextDraft,
+            changed: true,
+        };
+    };
     if (direction === "up") {
         if (history.length === 0)
             return noChange;
         if (index === null) {
             const newIdx = history.length - 1;
-            return { text: history[newIdx], index: newIdx, draft: currentText, changed: true };
+            return resultFromEntry(history[newIdx], newIdx, currentDraft);
         }
         if (index > 0) {
-            return { text: history[index - 1], index: index - 1, draft, changed: true };
+            return resultFromEntry(history[index - 1], index - 1, draft);
         }
         return noChange;
     }
     if (index === null)
         return noChange;
     if (index < history.length - 1) {
-        return { text: history[index + 1], index: index + 1, draft, changed: true };
+        return resultFromEntry(history[index + 1], index + 1, draft);
     }
-    return { text: draft, index: null, draft: "", changed: true };
+    return resultFromEntry(draft, null, "");
 }
-// Push to in-memory history with last-entry dedupe so repeated identical
-// submissions don't spam the stack.
 export function pushHistoryEntry(history, entry) {
-    if (!entry || entry.trim().length === 0)
+    const normalizedEntry = toHistoryEntry(entry);
+    if (!normalizedEntry)
         return history;
-    if (history.length > 0 && history[history.length - 1] === entry)
+    if (history.length > 0 && historyEntrySignature(history[history.length - 1]) === historyEntrySignature(normalizedEntry)) {
         return history;
+    }
+    if (typeof entry === "string" && history.every((item) => typeof item === "string")) {
+        return [...history, normalizedEntry.text];
+    }
     return [...history, entry];
 }

package/dist/tui/model-switch.d.ts

@@ -0,0 +1,42 @@
+import type { Provider, ThinkingLevel } from "../types.js";
+import type { ProviderProfile } from "../provider-registry.js";
+import { type SystemPromptOptions } from "../system-prompt.js";
+export interface ModelSwitchAgent {
+    model: string;
+    providerId: string;
+    thinking: ThinkingLevel;
+    setProvider(provider: Provider): void;
+    setSystemPrompt(prompt: string): void;
+}
+export interface ModelSwitchRegistry {
+    prepareProvider(providerId: string): Promise<void>;
+    getConfigured(): ProviderProfile[];
+    getDefault(): ProviderProfile | undefined;
+}
+export interface ModelSwitchSession {
+    updateMetadata(metadata: {
+        model: string;
+        thinkingLevel: ThinkingLevel;
+        reasoningEffort: ThinkingLevel;
+    }): void;
+    appendMarker(kind: "model_switch", value: string): void;
+}
+export interface SwitchAgentModelOptions {
+    model: string;
+    agent: ModelSwitchAgent;
+    registry: ModelSwitchRegistry;
+    createProvider: ((providerId: string, apiKey: string, baseURL: string) => Provider) | undefined;
+    workingDir: string;
+    systemPromptOptions: Omit<SystemPromptOptions, "agentName" | "configuredProvider" | "configuredModel" | "configuredModelId" | "thinkingLevel" | "workingDir">;
+    thinkingLevel?: ThinkingLevel;
+    rememberModel(model: string): void;
+    setThinkingLevel(level: ThinkingLevel): void;
+    sessionManager?: ModelSwitchSession;
+}
+export declare function modelSwitchTarget(model: string, fallbackProviderId: string | undefined): {
+    providerId: string;
+    modelId: string;
+};
+export declare function errorMessage(error: unknown): string;
+export declare function formatModelSwitchError(model: string, error: unknown): string;
+export declare function switchAgentModel(options: SwitchAgentModelOptions): Promise<ThinkingLevel>;

package/dist/tui/model-switch.js

@@ -0,0 +1,55 @@
+import { decodeModel, displayModel } from "../provider-registry.js";
+import { buildSystemPrompt } from "../system-prompt.js";
+import { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "../provider-transform.js";
+export function modelSwitchTarget(model, fallbackProviderId) {
+    const decoded = decodeModel(model);
+    return {
+        providerId: decoded.providerId || fallbackProviderId || "openai",
+        modelId: decoded.modelId,
+    };
+}
+export function errorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("refresh_token_reused")
+        || message.includes("invalid_grant")
+        || message.includes("Your refresh token has already been used")) {
+        return "OpenAI login expired. Run /login openai again to refresh your ChatGPT credentials.";
+    }
+    return message;
+}
+export function formatModelSwitchError(model, error) {
+    return `Failed to switch model to ${displayModel(model)}: ${errorMessage(error)}`;
+}
+export async function switchAgentModel(options) {
+    const { providerId, modelId } = modelSwitchTarget(options.model, options.agent.providerId || options.registry.getDefault()?.id);
+    await options.registry.prepareProvider(providerId);
+    const provider = options.registry.getConfigured().find((item) => item.id === providerId);
+    if (!provider?.apiKey || !options.createProvider) {
+        throw new Error(`Provider ${providerId} is not configured or has no active credentials.`);
+    }
+    const nextThinkingLevel = normalizeThinkingLevel((options.thinkingLevel ?? options.agent.thinking) || getDefaultThinkingLevel(providerId, modelId), getAvailableThinkingLevels(providerId, modelId));
+    const nextProvider = options.createProvider(providerId, provider.apiKey, provider.baseURL);
+    const nextSystemPrompt = buildSystemPrompt({
+        agentName: "Bubble",
+        configuredProvider: providerId,
+        configuredModel: displayModel(options.model),
+        configuredModelId: options.model,
+        thinkingLevel: nextThinkingLevel,
+        workingDir: options.workingDir,
+        ...options.systemPromptOptions,
+    });
+    options.agent.model = options.model;
+    options.agent.thinking = nextThinkingLevel;
+    options.agent.setProvider(nextProvider);
+    options.agent.providerId = providerId;
+    options.agent.setSystemPrompt(nextSystemPrompt);
+    options.rememberModel(options.model);
+    options.setThinkingLevel(nextThinkingLevel);
+    options.sessionManager?.updateMetadata({
+        model: options.model,
+        thinkingLevel: nextThinkingLevel,
+        reasoningEffort: nextThinkingLevel,
+    });
+    options.sessionManager?.appendMarker("model_switch", options.model);
+    return nextThinkingLevel;
+}

package/dist/tui-ink/app.d.ts

@@ -1,6 +1,6 @@
 import { type Agent } from "../agent.js";
 import type { CliArgs } from "../cli.js";
-import type { SessionManager } from "../session.js";
+import { SessionManager } from "../session.js";
 import type { PlanDecision, Provider } from "../types.js";
 import { type ResolvedTheme, type ThemeMode } from "./theme.js";
 import { ProviderRegistry } from "../provider-registry.js";
@@ -13,6 +13,7 @@ import type { LspService } from "../lsp/index.js";
 import type { QuestionController } from "../question/index.js";
 import type { MemoryScope } from "../memory/index.js";
 import type { ExternalHookController } from "../hooks/controller.js";
+import type { GoalStore } from "../goal/store.js";
 export interface PlanHandlerRef {
     current?: (plan: string) => Promise<PlanDecision>;
 }
@@ -23,6 +24,11 @@ interface AppProps {
     agent: Agent;
     args: CliArgs;
     sessionManager?: SessionManager;
+    switchSession?: (sessionFile: string) => {
+        manager: SessionManager;
+    } | {
+        error: string;
+    };
     createProvider?: (providerId: string, apiKey: string, baseURL: string) => Provider;
     registry?: ProviderRegistry;
     skillRegistry?: SkillRegistry;
@@ -41,9 +47,11 @@ interface AppProps {
     runMemoryCompaction?: () => Promise<string>;
     runMemorySummary?: (scope?: MemoryScope) => Promise<string>;
     runMemoryRefresh?: (scope?: MemoryScope) => Promise<string>;
+    goalStore?: GoalStore;
     /** Whether the bypassPermissions mode is reachable via Shift+Tab cycling. */
     bypassEnabled?: boolean;
     updateNotice?: string;
+    updateNoticeRefresh?: Promise<string | null>;
     hookController?: ExternalHookController;
     onExit?: (summary: ExitSummary) => void;
 }
@@ -51,5 +59,27 @@ export interface ExitSummary {
     /** Wall-clock duration of the session, in milliseconds. */
     wallMs: number;
 }
-export declare function App({ agent, args, sessionManager, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, bypassEnabled, updateNotice, hookController, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
+export declare const INK_LOCAL_SLASH_COMMANDS: readonly [{
+    readonly name: "thinking";
+    readonly description: "Toggle thinking block visibility";
+}, {
+    readonly name: "toggle-thinking";
+    readonly description: "Toggle thinking block visibility";
+}, {
+    readonly name: "goal";
+    readonly description: "Set/manage an autonomous goal (/goal <objective>|clear|pause|resume|edit)";
+}, {
+    readonly name: "trace";
+    readonly description: "Toggle verbose trace output";
+}, {
+    readonly name: "verbose";
+    readonly description: "Toggle verbose trace output";
+}, {
+    readonly name: "debug";
+    readonly description: "Toggle verbose trace output";
+}, {
+    readonly name: "write-previews";
+    readonly description: "Toggle write preview expansion";
+}];
+export declare function App({ agent, args, sessionManager: initialSessionManager, switchSession, createProvider, registry, skillRegistry, planHandlerRef, approvalHandlerRef, questionController, bashAllowlist, settingsManager, lspService, mcpManager, themeMode: initialThemeMode, themeOverrides, detectedTheme, onThemeModeChange, flushMemory, runMemoryCompaction, runMemorySummary, runMemoryRefresh, goalStore, bypassEnabled, updateNotice, updateNoticeRefresh, hookController, onExit }: AppProps): import("react/jsx-runtime").JSX.Element;
 export {};