@bubblebrain-ai/bubble 0.0.55 → 0.0.56

package/dist/context/budget.js

@@ -36,8 +36,11 @@ export function estimateMessageTokens(message, providerId) {
     }
 }
 function estimateProviderMetadataOverhead(metadata, providerId) {
-    const blocks = metadata?.anthropic?.contentBlocks;
-    if (!blocks || blocks.length === 0)
+    const blocks = [
+        ...(metadata?.anthropic?.contentBlocks ?? []),
+        ...(metadata?.openai?.contentBlocks ?? []),
+    ];
+    if (blocks.length === 0)
         return 0;
     const estimate = (text) => estimateTextTokens(text, providerId);
     return blocks.reduce((sum, block) => {
@@ -46,6 +49,8 @@ function estimateProviderMetadataOverhead(metadata, providerId) {
             overhead += estimate(block.signature);
         if (block.type === "redacted_thinking" && typeof block.data === "string")
             overhead += estimate(block.data);
+        if (block.type === "reasoning" && typeof block.encrypted_content === "string")
+            overhead += estimate(block.encrypted_content);
         return sum + overhead;
     }, 0);
 }

package/dist/model-catalog.d.ts

@@ -1,5 +1,5 @@
 import type { ReasoningEffort } from "./types.js";
-export type ProviderProtocol = "openai-chat" | "anthropic-messages" | "ark-responses" | "ai-sdk";
+export type ProviderProtocol = "openai-chat" | "openai-responses" | "anthropic-messages" | "ark-responses" | "ai-sdk";
 export interface BuiltinProviderDefinition {
     id: string;
     name: string;

package/dist/model-catalog.js

@@ -3,6 +3,7 @@ export const BUILTIN_PROVIDERS = [
     { id: "openrouter", name: "OpenRouter", baseURL: "https://openrouter.ai/api/v1" },
     { id: "openai", name: "OpenAI", baseURL: "https://api.openai.com/v1", supportsOAuth: true },
     { id: "openai-codex", name: "OpenAI Codex (ChatGPT)", baseURL: "https://chatgpt.com/backend-api" },
+    { id: "opencode-zen", name: "OpenCode Zen", baseURL: "https://opencode.ai/zen/v1", protocol: "openai-responses" },
     // Grok subscription models via the CLI chat proxy. OAuth-only: the proxy
     // accepts xAI session bearers (from /login grok), not api.x.ai API keys.
     { id: "grok", name: "Grok Subscription", baseURL: "https://cli-chat-proxy.grok.com/v1", supportsOAuth: true },
@@ -39,6 +40,7 @@ const GPT51_LEVELS = ["off", "low", "medium", "high"];
 const GPT51_CODEX_MAX_LEVELS = ["off", "low", "medium", "high", "xhigh"];
 const GPT51_CODEX_MINI_LEVELS = ["off", "medium", "high"];
 const OPENAI_CHAT_LEVELS = ["off"];
+const MUSE_SPARK_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
 // Ox Alpha declares mandatory reasoning with exactly low/high/max through
 // OpenRouter's live model metadata. The endpoint rejects disabled reasoning.
 const OPENROUTER_OX_REASONING_LEVELS = ["low", "high", "max"];
@@ -117,6 +119,9 @@ export const BUILTIN_MODELS = [
     { id: "o1-preview", name: "o1-preview", providerId: "openai", tier: "strong", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "o1-mini", name: "o1-mini", providerId: "openai", tier: "fast", reasoningLevels: ["off", "low", "medium", "high"], contextWindow: 128000 },
     { id: "gpt-4-turbo", name: "gpt-4-turbo", providerId: "openai", reasoningLevels: OPENAI_CHAT_LEVELS, contextWindow: 128000 },
+    { id: "muse-spark-1.3-contributor-free", name: "Muse Spark 1.3 Free", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "muse-spark-1.2", name: "Muse Spark 1.2", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "muse-spark-1.2-contributor-free", name: "Muse Spark 1.2 Free", providerId: "opencode-zen", reasoningLevels: MUSE_SPARK_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "claude-fable-5", name: "Claude Fable 5", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_FABLE_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-opus-4-8", name: "Claude Opus 4.8", providerId: "anthropic", tier: "strong", reasoningLevels: ANTHROPIC_OPUS_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },
     { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6", providerId: "anthropic", tier: "balanced", reasoningLevels: ANTHROPIC_SONNET_EFFORT_LEVELS, defaultReasoningLevel: "high", contextWindow: 1000000 },

package/dist/provider-ark-responses.d.ts

@@ -1,5 +1,5 @@
 import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel, TokenUsage, ToolChoiceMode, ToolDefinition } from "./types.js";
-export interface ArkResponsesProviderOptions {
+export interface ResponsesProviderOptions {
     providerId?: string;
     apiKey: string;
     baseURL: string;
@@ -7,7 +7,9 @@ export interface ArkResponsesProviderOptions {
     /** User-configured extra headers, merged last (client-identity gates). */
     headers?: Record<string, string>;
 }
+export type ArkResponsesProviderOptions = ResponsesProviderOptions;
 export declare function createArkResponsesProvider(options: ArkResponsesProviderOptions): Provider;
+export declare function createOpenAIResponsesProvider(options: ResponsesProviderOptions): Provider;
 export declare function buildArkResponsesBody(messages: ProviderMessage[], options: {
     model: string;
     tools?: ToolDefinition[];
@@ -15,5 +17,13 @@ export declare function buildArkResponsesBody(messages: ProviderMessage[], optio
     thinkingLevel?: ThinkingLevel;
     stream: boolean;
 }): Record<string, unknown>;
-export declare function translateArkResponsesStream(response: Response): AsyncIterable<StreamChunk>;
+export declare function buildOpenAIResponsesBody(messages: ProviderMessage[], options: {
+    model: string;
+    tools?: ToolDefinition[];
+    toolChoice?: ToolChoiceMode;
+    temperature?: number;
+    thinkingLevel?: ThinkingLevel;
+    stream: boolean;
+}): Record<string, unknown>;
+export declare function translateArkResponsesStream(response: Response, captureOpenAIReasoning?: boolean): AsyncIterable<StreamChunk>;
 export declare function normalizeArkResponsesUsage(usage: any): TokenUsage;

package/dist/provider-ark-responses.js

@@ -1,33 +1,43 @@
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { RateLimitError } from "./network/errors.js";
 import { computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, retryAfterMsFromResponse, sleepBeforeRetry, } from "./network/retry.js";
+import { providerFetch } from "./network/provider-transport.js";
 const DEFAULT_ARK_MODEL = "doubao-seed-2-1-pro-260628";
+const DEFAULT_MUSE_MODEL = "muse-spark-1.3-contributor-free";
 export function createArkResponsesProvider(options) {
+    return createResponsesProvider(options, "ark", DEFAULT_ARK_MODEL);
+}
+export function createOpenAIResponsesProvider(options) {
+    return createResponsesProvider(options, "openai", DEFAULT_MUSE_MODEL);
+}
+function createResponsesProvider(options, dialect, defaultModel) {
     async function* streamChat(messages, chatOptions) {
-        const body = buildArkResponsesBody(messages, {
+        const body = buildResponsesBody(messages, {
             model: chatOptions.model,
             tools: chatOptions.tools,
             toolChoice: chatOptions.toolChoice,
+            temperature: chatOptions.temperature,
             thinkingLevel: chatOptions.thinkingLevel ?? options.thinkingLevel ?? "high",
             stream: true,
-        });
+        }, dialect);
         for (let attempt = 0;; attempt += 1) {
             const response = await sendArkResponsesRequest(options, body, {
                 signal: chatOptions.abortSignal,
                 rateLimitPolicy: chatOptions.rateLimitPolicy,
                 attempt,
             });
-            yield* translateArkResponsesStream(response);
+            yield* translateArkResponsesStream(response, dialect === "openai");
             yield { type: "done" };
             return;
         }
     }
     async function complete(messages, chatOptions) {
-        const body = buildArkResponsesBody(messages, {
-            model: chatOptions?.model ?? DEFAULT_ARK_MODEL,
+        const body = buildResponsesBody(messages, {
+            model: chatOptions?.model ?? defaultModel,
+            temperature: chatOptions?.temperature,
             thinkingLevel: chatOptions?.thinkingLevel ?? options.thinkingLevel ?? "high",
             stream: false,
-        });
+        }, dialect);
         const response = await sendArkResponsesRequest(options, body, {
             signal: chatOptions?.abortSignal,
             attempt: 0,
@@ -38,15 +48,34 @@ export function createArkResponsesProvider(options) {
     return { streamChat, complete };
 }
 export function buildArkResponsesBody(messages, options) {
+    return buildResponsesBody(messages, options, "ark");
+}
+export function buildOpenAIResponsesBody(messages, options) {
+    return buildResponsesBody(messages, options, "openai");
+}
+function buildResponsesBody(messages, options, dialect) {
     const body = {
         model: options.model,
-        input: messages.flatMap((message) => convertMessageToArkResponsesInput(message)),
+        input: messages.flatMap((message) => convertMessageToResponsesInput(message, dialect)),
         store: false,
         stream: options.stream,
-        thinking: {
-            type: shouldDisableArkThinking(options.thinkingLevel) ? "disabled" : "enabled",
-        },
     };
+    if (dialect === "ark") {
+        body.thinking = {
+            type: shouldDisableArkThinking(options.thinkingLevel) ? "disabled" : "enabled",
+        };
+    }
+    else {
+        body.include = ["reasoning.encrypted_content"];
+        if (options.thinkingLevel && options.thinkingLevel !== "off") {
+            body.reasoning = {
+                effort: options.thinkingLevel === "ultra" ? "xhigh" : options.thinkingLevel,
+                summary: "auto",
+            };
+        }
+        if (options.temperature !== undefined)
+            body.temperature = options.temperature;
+    }
     if (options.tools && options.tools.length > 0) {
         body.tools = options.tools.map((tool) => ({
             type: "function",
@@ -63,7 +92,7 @@ export function buildArkResponsesBody(messages, options) {
 function shouldDisableArkThinking(level) {
     return level === "off" || level === "minimal";
 }
-function convertMessageToArkResponsesInput(message) {
+function convertMessageToResponsesInput(message, dialect) {
     if (message.role === "user") {
         if (typeof message.content === "string") {
             return [{
@@ -92,6 +121,17 @@ function convertMessageToArkResponsesInput(message) {
     }
     if (message.role === "assistant") {
         const items = [];
+        if (dialect === "openai") {
+            for (const block of message.providerMetadata?.openai?.contentBlocks ?? []) {
+                if (block.type !== "reasoning" || typeof block.encrypted_content !== "string")
+                    continue;
+                items.push({
+                    type: "reasoning",
+                    summary: Array.isArray(block.summary) ? block.summary : [],
+                    encrypted_content: block.encrypted_content,
+                });
+            }
+        }
         if (message.content) {
             items.push({
                 type: "message",
@@ -118,7 +158,7 @@ function convertMessageToArkResponsesInput(message) {
         }];
 }
 async function sendArkResponsesRequest(options, body, requestOptions) {
-    const response = await fetch(resolveArkResponsesUrl(options.baseURL), {
+    const response = await providerFetch(resolveArkResponsesUrl(options.baseURL), {
         method: "POST",
         headers: {
             "Authorization": `Bearer ${options.apiKey}`,
@@ -128,6 +168,8 @@ async function sendArkResponsesRequest(options, body, requestOptions) {
         },
         body: JSON.stringify(body),
         signal: requestOptions.signal,
+    }, {
+        providerName: options.providerId ?? "Responses provider",
     });
     if (response.ok)
         return response;
@@ -159,7 +201,7 @@ async function sendArkResponsesRequest(options, body, requestOptions) {
 function resolveArkResponsesUrl(baseURL) {
     return `${baseURL.trim().replace(/\/+$/, "")}/responses`;
 }
-export async function* translateArkResponsesStream(response) {
+export async function* translateArkResponsesStream(response, captureOpenAIReasoning = false) {
     const toolCalls = new Map();
     const textFilter = createProviderProtocolArtifactFilter();
     for await (const event of parseArkResponsesSse(response)) {
@@ -253,6 +295,19 @@ export async function* translateArkResponsesStream(response) {
         }
         if (type === "response.output_item.done") {
             const item = event.item;
+            if (captureOpenAIReasoning
+                && item?.type === "reasoning"
+                && typeof item.encrypted_content === "string") {
+                yield {
+                    type: "provider_content_block",
+                    provider: "openai",
+                    block: {
+                        type: "reasoning",
+                        summary: Array.isArray(item.summary) ? item.summary : [],
+                        encrypted_content: item.encrypted_content,
+                    },
+                };
+            }
             if (item?.type === "function_call") {
                 const key = toolCallEventKey(event, item);
                 const entry = toolCalls.get(key);

package/dist/provider.js

@@ -6,7 +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 { createArkResponsesProvider, createOpenAIResponsesProvider } from "./provider-ark-responses.js";
 import { createAiSdkProvider } from "./provider-ai-sdk.js";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
 import { buildGrokSubscriptionHeaders, createGrokSubscriptionFetch, isGrokSubscriptionBaseUrl, } from "./provider-grok.js";
@@ -89,6 +89,9 @@ export function createProviderInstance(options) {
     if (protocol === "ark-responses") {
         return createArkResponsesProvider(options);
     }
+    if (protocol === "openai-responses") {
+        return createOpenAIResponsesProvider(options);
+    }
     if (protocol === "ai-sdk") {
         return createAiSdkProvider(options);
     }
@@ -273,6 +276,9 @@ function resolveProviderProtocol(options) {
         return options.protocol;
     const providerId = (options.providerId || "").toLowerCase();
     const baseURL = (options.baseURL || "").toLowerCase();
+    if (providerId === "opencode-zen") {
+        return "openai-responses";
+    }
     if (providerId === "doubao"
         && baseURL.replace(/\/+$/, "") === "https://ark.cn-beijing.volces.com/api/v3") {
         return "ark-responses";

package/dist/tui/model/image-paste.js

@@ -299,20 +299,19 @@ export async function getImageFromClipboard() {
     }
 }
 async function getClipboardImageDarwin() {
-    // Probe first — `as «class PNGf»` throws if clipboard has no image.
-    try {
-        await execFileAsync("osascript", ["-e", "the clipboard as «class PNGf»"], {
-            timeout: 5000,
-        });
-    }
-    catch {
-        return null;
-    }
     const tmp = path.join(os.tmpdir(), `bubble_clip_${Date.now()}_${process.pid}.png`);
     const script = `set png_data to (the clipboard as «class PNGf»)\n` +
         `set fp to open for access POSIX file "${tmp}" with write permission\n` +
+        `try\n` +
+        `set eof fp to 0\n` +
         `write png_data to fp\n` +
-        `close access fp`;
+        `close access fp\n` +
+        `on error err_msg number err_num\n` +
+        `try\n` +
+        `close access fp\n` +
+        `end try\n` +
+        `error err_msg number err_num\n` +
+        `end try`;
     try {
         await execFileAsync("osascript", ["-e", script], { timeout: 5000 });
         const buf = await fs.readFile(tmp);

package/dist/types.d.ts

@@ -18,12 +18,14 @@ export type ReasoningEffort = ThinkingLevel;
 export type ProviderRawContentBlock = Record<string, unknown> & {
     type: string;
 };
-export type ProviderMetadataProvider = "anthropic" | "google";
+export type ProviderMetadataProvider = "anthropic" | "google" | "openai";
 export interface ProviderContentBlockStore {
     contentBlocks?: ProviderRawContentBlock[];
 }
 export interface AssistantProviderMetadata {
     anthropic?: ProviderContentBlockStore;
+    /** OpenAI Responses reasoning items captured for stateless tool-loop replay. */
+    openai?: ProviderContentBlockStore;
     /**
      * Gemini raw parts captured for replay: reasoning/tool-call parts carrying
      * thoughtSignature so multi-turn thinking round-trips through our own

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.55",
+  "version": "0.0.56",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {