@bubblebrain-ai/bubble 0.0.24 → 0.0.26

package/dist/provider.js

@@ -6,6 +6,7 @@
 import OpenAI from "openai";
 import { appendFileSync } from "node:fs";
 import { createAnthropicMessagesProvider } from "./provider-anthropic.js";
+import { createArkResponsesProvider } from "./provider-ark-responses.js";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
@@ -76,9 +77,13 @@ export function createUnavailableProvider(message) {
     return { streamChat, complete };
 }
 export function createProviderInstance(options) {
-    if (resolveProviderProtocol(options) === "anthropic-messages") {
+    const protocol = resolveProviderProtocol(options);
+    if (protocol === "anthropic-messages") {
         return createAnthropicMessagesProvider(options);
     }
+    if (protocol === "ark-responses") {
+        return createArkResponsesProvider(options);
+    }
     if (isOpenAICodexBaseUrl(options.baseURL)) {
         return createOpenAICodexProvider({
             ...options,
@@ -110,8 +115,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) {
@@ -129,28 +136,39 @@ export function createProviderInstance(options) {
         if (requestConfig.reasoningEffort && requestConfig.reasoningEffort !== "off") {
             body.reasoning = { enabled: true };
         }
+        const createCompletion = async (requestBody) => {
+            try {
+                return await client.chat.completions.create(requestBody, {
+                    signal: chatOptions.abortSignal,
+                    ...(chatOptions.rateLimitPolicy === "defer" ? { maxRetries: 0 } : {}),
+                });
+            }
+            catch (error) {
+                if (error?.status === 429) {
+                    const retryAfterHeader = error?.headers?.["retry-after"];
+                    const retryAfterSeconds = Number(retryAfterHeader);
+                    throw new RateLimitError(error?.message || "Rate limited (429)", {
+                        status: 429,
+                        retryAfterMs: Number.isFinite(retryAfterSeconds) ? Math.round(retryAfterSeconds * 1000) : undefined,
+                        cause: error,
+                    });
+                }
+                throw error;
+            }
+        };
+        if (shouldUseNonStreamingToolCalls(options, tools, chatOptions.toolChoice)) {
+            body.stream = false;
+            delete body.stream_options;
+            const response = await createCompletion(body);
+            yield* translateOpenAIFullResponse(response);
+            yield { type: "done" };
+            return;
+        }
         // Rate-limit contract (design §4.5): "defer" disables the SDK's own
         // retries so the caller is the single 429 backoff layer; either policy
         // surfaces a final 429 as a typed RateLimitError instead of a string.
         let stream;
-        try {
-            stream = (await client.chat.completions.create(body, {
-                signal: chatOptions.abortSignal,
-                ...(chatOptions.rateLimitPolicy === "defer" ? { maxRetries: 0 } : {}),
-            }));
-        }
-        catch (error) {
-            if (error?.status === 429) {
-                const retryAfterHeader = error?.headers?.["retry-after"];
-                const retryAfterSeconds = Number(retryAfterHeader);
-                throw new RateLimitError(error?.message || "Rate limited (429)", {
-                    status: 429,
-                    retryAfterMs: Number.isFinite(retryAfterSeconds) ? Math.round(retryAfterSeconds * 1000) : undefined,
-                    cause: error,
-                });
-            }
-            throw error;
-        }
+        stream = (await createCompletion(body));
         yield* translateOpenAIStream(stream, {
             toolArgsMergeMode: resolveToolArgsMergeMode(options.providerId || "", options.baseURL),
             reasoningMergeMode: resolveReasoningMergeMode(options.providerId || "", options.baseURL),
@@ -192,6 +210,10 @@ function resolveProviderProtocol(options) {
         return options.protocol;
     const providerId = (options.providerId || "").toLowerCase();
     const baseURL = options.baseURL.toLowerCase();
+    if (providerId === "doubao"
+        && baseURL.replace(/\/+$/, "") === "https://ark.cn-beijing.volces.com/api/v3") {
+        return "ark-responses";
+    }
     if (providerId === "anthropic"
         || providerId.endsWith("-anthropic")
         || baseURL.includes("/anthropic")) {
@@ -207,6 +229,24 @@ 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);
+}
+function shouldUseNonStreamingToolCalls(options, tools, toolChoice) {
+    return (options.providerId || "").toLowerCase() === "doubao"
+        && !!tools
+        && tools.length > 0
+        && toolChoice !== "none";
+}
 export function normalizeToolArgsDetailed(raw) {
     const s = (raw ?? "").trim();
     if (!s) {
@@ -307,6 +347,101 @@ function extractBalancedJson(s, start) {
     }
     return null;
 }
+/**
+ * Convert a non-streaming OpenAI-compatible chat-completions response into the
+ * same chunk protocol used by the streaming adapter. This is used for provider
+ * tool-call paths where streamed function arguments are not reliable enough to
+ * execute safely.
+ */
+export async function* translateOpenAIFullResponse(response) {
+    const usageChunk = usageToStreamChunk(response?.usage);
+    if (usageChunk)
+        yield usageChunk;
+    const choice = response?.choices?.[0];
+    const finishReason = choice?.finish_reason;
+    const truncatedByLength = finishReason === "length";
+    const message = choice?.message;
+    if (!message)
+        return;
+    const reasoningDetails = extractReasoningDetailsText(message.reasoning_details);
+    const reasoning = reasoningDetails
+        ?? (typeof message.reasoning === "string" ? message.reasoning : undefined)
+        ?? (typeof message.thinking === "string" ? message.thinking : undefined)
+        ?? (typeof message.reasoning_content === "string" ? message.reasoning_content : undefined);
+    if (reasoning) {
+        yield { type: "reasoning_delta", content: reasoning };
+    }
+    if (typeof message.content === "string" && message.content) {
+        const textFilter = createProviderProtocolArtifactFilter();
+        const cleaned = textFilter.push(message.content) + textFilter.flush();
+        if (cleaned) {
+            yield { type: "text", content: cleaned };
+        }
+    }
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    for (let index = 0; index < toolCalls.length; index += 1) {
+        const toolCall = toolCalls[index];
+        const name = typeof toolCall?.function?.name === "string" ? toolCall.function.name : "";
+        if (!name)
+            continue;
+        const id = typeof toolCall?.id === "string" && toolCall.id
+            ? toolCall.id
+            : `call_${index}`;
+        const rawArgs = typeof toolCall?.function?.arguments === "string"
+            ? toolCall.function.arguments
+            : JSON.stringify(toolCall?.function?.arguments ?? {});
+        const normalized = normalizeToolArgsDetailed(rawArgs);
+        const corrupt = normalized.corrupt || truncatedByLength;
+        debugToolArgs({
+            stage: "full-response-tool-call",
+            id,
+            name,
+            entryArgs: rawArgs,
+            finalArgs: normalized.args,
+            finishReason,
+            corrupt,
+        });
+        yield { type: "tool_call", id, name, arguments: "", isStart: true, isEnd: false };
+        if (rawArgs) {
+            yield { type: "tool_call", id, name, arguments: rawArgs, isStart: false, isEnd: false };
+        }
+        yield {
+            type: "tool_call",
+            id,
+            name,
+            arguments: "",
+            argumentsFull: normalized.args,
+            argumentsCorrupt: corrupt || undefined,
+            isStart: false,
+            isEnd: true,
+        };
+    }
+}
+function usageToStreamChunk(usage) {
+    if (!usage)
+        return undefined;
+    return {
+        type: "usage",
+        usage: {
+            promptTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
+            completionTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
+            promptCacheHitTokens: typeof usage.prompt_cache_hit_tokens === "number"
+                ? usage.prompt_cache_hit_tokens
+                : typeof usage.prompt_tokens_details?.cached_tokens === "number"
+                    ? usage.prompt_tokens_details.cached_tokens
+                    : undefined,
+            promptCacheMissTokens: typeof usage.prompt_cache_miss_tokens === "number"
+                ? usage.prompt_cache_miss_tokens
+                : typeof usage.prompt_tokens_details?.cached_tokens === "number" && typeof usage.prompt_tokens === "number"
+                    ? Math.max(0, usage.prompt_tokens - usage.prompt_tokens_details.cached_tokens)
+                    : undefined,
+            reasoningTokens: typeof usage.completion_tokens_details?.reasoning_tokens === "number"
+                ? usage.completion_tokens_details.reasoning_tokens
+                : undefined,
+            totalTokens: typeof usage.total_tokens === "number" ? usage.total_tokens : undefined,
+        },
+    };
+}
 /**
  * Convert an OpenAI-compatible chat-completions stream into our internal StreamChunk events.
  *
@@ -345,14 +480,15 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 }
             }
             const normalized = normalizeToolArgsDetailed(entry.args);
-            debugToolArgs({ stage: "flush-end", id: entry.id, name: entry.name, entryArgs: entry.args, finalArgs: normalized.args, corrupt: normalized.corrupt });
+            const corrupt = normalized.corrupt || !!entry.corrupt;
+            debugToolArgs({ stage: "flush-end", id: entry.id, name: entry.name, entryArgs: entry.args, finalArgs: normalized.args, corrupt });
             yield {
                 type: "tool_call",
                 id: entry.id,
                 name: entry.name,
                 arguments: "",
                 argumentsFull: normalized.args,
-                argumentsCorrupt: normalized.corrupt || undefined,
+                argumentsCorrupt: corrupt || undefined,
                 isStart: false,
                 isEnd: true,
             };
@@ -370,9 +506,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,
@@ -511,7 +648,13 @@ export async function* translateOpenAIStream(stream, options = {}) {
                 }
             }
         }
-        if (finishReason === "tool_calls") {
+        if (finishReason === "length") {
+            for (const entry of toolCalls.values()) {
+                entry.corrupt = true;
+            }
+            yield* flushToolCalls();
+        }
+        else if (finishReason === "tool_calls") {
             yield* flushToolCalls();
         }
     }

package/dist/slash-commands/commands.js

@@ -8,6 +8,7 @@ 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";
@@ -402,6 +403,27 @@ 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]",

package/dist/tools/todo.js

@@ -13,50 +13,33 @@ export function createTodoTool(store) {
 
 ## When to use
 
-Use this tool proactively when any of these apply:
-1. Complex multi-step work — 3 or more distinct steps or file locations
-2. Non-trivial tasks requiring planning or coordination across multiple operations
-3. The user explicitly asks for a todo list
-4. The user provides a list of things to do (numbered, comma-separated, bulleted)
-5. New instructions arrive mid-session — capture them as todos before starting
-6. Starting work on a task — mark it in_progress BEFORE beginning. Only one item may be in_progress at a time
-7. Finishing a task — mark it completed immediately, don't batch completions
+Default to just doing the work. Reach for a list only when actively tracking progress would genuinely help you or the user follow it — never to pad simple work with filler steps or to state the obvious. When in doubt, skip the list and do the task; a list you never meaningfully update is just noise.
 
-## When NOT to use
+A list earns its place when:
+- The task is non-trivial and spans many actions across several areas of the codebase
+- There are non-obvious phases or dependencies you must hold in mind to avoid losing track (a plain read → edit → test sequence does not count)
+- The work is ambiguous and benefits from outlining the goals up front
+- The user asked for several distinct things in one prompt, or gave a numbered/bulleted list
+- The user explicitly asked for a todo list (aka TODOs)
+- You discover extra steps mid-task and intend to finish them before yielding
 
-Skip this tool when:
-1. There is a single, straightforward task
-2. The task is trivial and tracking provides no organizational benefit
-3. The work can be completed in fewer than 3 trivial steps
-4. The request is purely conversational or informational
+## Quality bar
 
-If there is only one trivial task, just do it — don't create a todo first.
+If you do make a list, make a good one: meaningful, logically ordered steps that are easy to verify as you go.
 
-## Examples
+Good — distinct, verifiable steps for genuinely multi-part work:
+1. Add CSS variables for the color palette
+2. Add the toggle with localStorage state
+3. Refactor components to use the variables
+4. Verify every view for readability
 
-<example>
-User: Add a dark mode toggle to the settings page, then run tests and build.
-Assistant: *creates a 5-item todo: toggle UI, theme state, CSS tokens, update components, run tests + build*
-<reasoning>Multiple distinct steps across UI, state, styles, and verification. User explicitly asked for tests + build.</reasoning>
-</example>
+Good — scope a search uncovers makes the list worth it:
+"Rename getCwd across the project" → grep finds 15 call sites in 8 files → one item per file so none are missed.
 
-<example>
-User: Rename getCwd to getCurrentWorkingDirectory across the project.
-Assistant: *greps, finds 15 call sites across 8 files, creates a per-file todo list*
-<reasoning>Scope discovered via grep shows many locations; a todo ensures each file is tracked and none are missed.</reasoning>
-</example>
+Bad — padding a task you could just do; do NOT create a list for this:
+"Fix the typo in the README title" → 1. Find typo  2. Open file  3. Fix it  4. Save. That is one edit — just make it.
 
-<example>
-User: How do I print "Hello World" in Python?
-Assistant: *answers in one sentence with a snippet — no todo*
-<reasoning>Informational, one-step, no tracking benefit.</reasoning>
-</example>
-
-<example>
-User: Add a comment to calculateTotal explaining what it does.
-Assistant: *calls edit directly — no todo*
-<reasoning>Single, localized change in one file.</reasoning>
-</example>
+Bad — vague, unverifiable filler: "Make it work", "Improve the styling", "Clean things up".
 
 ## Task states
 
@@ -73,7 +56,8 @@ Each item needs:
 - Update status in real time; mark completed IMMEDIATELY on finishing.
 - Never mark completed if tests are failing, implementation is partial, errors are unresolved, or needed files are missing — keep as in_progress.
 - When blocked, add a new task describing what must be resolved.
-- Remove items that are no longer relevant; don't leave stale entries.`,
+- Remove items that are no longer relevant; don't leave stale entries.
+- Do not re-send the list when nothing meaningful has changed since the last call; update only after real progress.`,
         parameters: {
             type: "object",
             properties: {

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[];