@bubblebrain-ai/bubble 0.0.54 → 0.0.56

package/README.md

@@ -67,6 +67,49 @@ Resume your last conversation:
 bubble --resume
 ```
 
+## Embed with the SDK
+
+The npm package exports `BubbleSdk` from both `@bubblebrain-ai/bubble` and
+`@bubblebrain-ai/bubble/sdk`. Turns are serialized FIFO within one session and
+remain parallel across different sessions.
+
+```ts
+import { BubbleSdk } from "@bubblebrain-ai/bubble/sdk";
+
+const sdk = new BubbleSdk({ defaultCwd: process.cwd() });
+const session = sdk.createSession();
+const events = sdk.runTurn(session.id, { prompt: "Inspect this project" });
+
+for await (const event of events) {
+  if (event.type === "text_delta") process.stdout.write(event.content);
+}
+
+const queued = sdk.enqueueTurn(session.id, { prompt: "Run the tests next" });
+void (async () => {
+  for await (const event of queued) {
+    // Render the queued turn's events.
+  }
+})();
+```
+
+While a turn owns the session slot, `sdk.steer(session.id, text)` adds text at
+the next model-call boundary and returns a receipt: `steered` (injected into
+the active turn), `queued` (the session is idle or the active turn can no
+longer accept input, so the text becomes the next FIFO turn automatically),
+or `rejected`. Every accepted receipt includes an `outcome` promise that
+settles exactly once to `input_applied`, `input_queued`, or `input_rejected` —
+even if the host drops the event iterator early.
+
+Turns are driven by the SDK itself, not by iterator consumption: a returned
+iterator is a replay subscription, so dropping it never stalls or cancels the
+turn. `openSession(sessionId)` returns a durable handle whose `events` iterable
+replays the whole session log from sequence 1 and `eventsFrom(n)` resumes after
+the last sequence the host durably processed. `stop(sessionId)` is
+Claude-style: it interrupts the active turn and keeps the queue; pass
+`{ cancelQueued: true }` to clear both. `clearQueue(sessionId)` cancels only
+queued turns, and `deleteSession(sessionId)` awaits teardown before the JSONL
+file is removed.
+
 ## Model providers
 
 Bubble ships with a catalog of built-in providers. Configure them inside the app — no environment variables required.

package/dist/agent/input-controller.d.ts

@@ -3,9 +3,12 @@ export declare class AgentRunInputQueue implements AgentInputController {
     private readonly idPrefix;
     private pending;
     private nextInputId;
+    private accepting;
     constructor(idPrefix?: string);
     enqueue(content: string): AgentRunInput;
+    tryEnqueue(content: string): AgentRunInput | undefined;
     drainPendingInputs(): AgentRunInput[];
     pendingInputCount(): number;
     clear(): AgentRunInput[];
+    closePendingInputs(): AgentRunInput[];
 }

package/dist/agent/input-controller.js

@@ -2,10 +2,19 @@ export class AgentRunInputQueue {
     idPrefix;
     pending = [];
     nextInputId = 0;
+    accepting = true;
     constructor(idPrefix = "input") {
         this.idPrefix = idPrefix;
     }
     enqueue(content) {
+        const input = this.tryEnqueue(content);
+        if (!input)
+            throw new Error("Agent input queue is closed");
+        return input;
+    }
+    tryEnqueue(content) {
+        if (!this.accepting)
+            return undefined;
         const input = {
             id: `${this.idPrefix}-${++this.nextInputId}`,
             content,
@@ -27,4 +36,8 @@ export class AgentRunInputQueue {
     clear() {
         return this.drainPendingInputs();
     }
+    closePendingInputs() {
+        this.accepting = false;
+        return this.drainPendingInputs();
+    }
 }

package/dist/agent.js

@@ -644,7 +644,11 @@ export class Agent {
             return events;
         };
         const rejectPendingInputs = async (reason) => {
-            const pendingInputs = inputController?.drainPendingInputs() ?? [];
+            // Seal before the first await. A host can submit in reaction to the final
+            // turn boundary; accepting after this drain would orphan that input.
+            const pendingInputs = inputController?.closePendingInputs?.()
+                ?? inputController?.drainPendingInputs()
+                ?? [];
             if (pendingInputs.length === 0)
                 return [];
             const events = [];
@@ -697,6 +701,8 @@ export class Agent {
                 yield emit({ type: "turn_start" });
                 yield emit({ type: "text_delta", content: message });
                 yield emit({ type: "turn_end", willContinue: false });
+                for (const event of await rejectPendingInputs("no_continuation"))
+                    yield emit(event);
                 yield emit({ type: "agent_end" });
                 return;
             }

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"];
@@ -87,6 +89,9 @@ const ANTHROPIC_CHAT_LEVELS = ["off"];
 const GROK_45_LEVELS = ["low", "medium", "high"];
 const GEMINI_3_LEVELS = ["low", "medium", "high"];
 const GEMINI_3_FLASH_LEVELS = ["minimal", "low", "medium", "high"];
+// Verified against the native API on 2026-09-02: Gemini 3.7/3.8 Flash reject
+// thinkingLevel=minimal but accept thinkingBudget=0 plus low/medium/high.
+const GEMINI_37_38_FLASH_LEVELS = ["off", "low", "medium", "high"];
 const GEMINI_25_PRO_LEVELS = ["low", "medium", "high"];
 const GEMINI_25_FLASH_LEVELS = ["off", "low", "medium", "high"];
 export const BUILTIN_MODELS = [
@@ -114,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 },
@@ -126,8 +134,10 @@ export const BUILTIN_MODELS = [
     { id: "deepseek-v4-pro", name: "deepseek-v4-pro", providerId: "deepseek", tier: "strong", reasoningLevels: DEEPSEEK_V4_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     // Offline/no-key fallback only: with an API key the registry replaces this
     // list via fetchGeminiModels (GET /v1beta/models, newest five). Gemini 3
-    // exposes thinking_level (minimal/low/medium/high); 2.5 Pro cannot disable
-    // thinking (no "off"), 2.5 Flash can (thinkingBudget 0).
+    // thinking support varies by release: 3.7/3.8 Flash support off/low/medium/high
+    // while older Flash releases expose minimal/low/medium/high.
+    { id: "gemini-3.8-flash", name: "Gemini 3.8 Flash", providerId: "google", tier: "fast", reasoningLevels: GEMINI_37_38_FLASH_LEVELS, contextWindow: 1048576 },
+    { id: "gemini-3.7-flash", name: "Gemini 3.7 Flash", providerId: "google", tier: "fast", reasoningLevels: GEMINI_37_38_FLASH_LEVELS, contextWindow: 1048576 },
     { id: "gemini-3.5-flash", name: "Gemini 3.5 Flash", providerId: "google", tier: "fast", reasoningLevels: GEMINI_3_FLASH_LEVELS, contextWindow: 1048576 },
     { id: "gemini-3.1-pro-preview", name: "Gemini 3.1 Pro", providerId: "google", tier: "strong", reasoningLevels: GEMINI_3_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "gemini-3-flash-preview", name: "Gemini 3 Flash", providerId: "google", tier: "fast", reasoningLevels: GEMINI_3_FLASH_LEVELS, contextWindow: 1048576 },

package/dist/model-pricing.d.ts

@@ -35,11 +35,7 @@ export interface ModelPricing extends ModelPricingRate {
     /** Rate used before `effectiveFrom` (for historical session statistics). */
     prior?: ModelPricingRate;
     effectiveUntil?: string;
-    original?: {
-        inputCacheHitPerMillion: number;
-        inputCacheMissPerMillion: number;
-        outputPerMillion: number;
-    };
+    original?: ModelPricingRate;
 }
 /**
  * Hand-maintained corrections layered over the generated models.dev snapshot.

package/dist/provider-ai-sdk.js

@@ -509,6 +509,11 @@ export function selectLatestGeminiModels(entries, limit = 5) {
 export function geminiReasoningLevels(modelId) {
     const version = Number.parseFloat(/^gemini-(\d+(?:\.\d+)?)/.exec(modelId)?.[1] ?? "0");
     const isPro = modelId.includes("-pro");
+    // Live probes show 3.7 and 3.8 Flash share this newer ladder. Keep the
+    // exception bounded to verified releases instead of guessing for 3.9+.
+    if (!isPro && (version === 3.7 || version === 3.8)) {
+        return ["off", "low", "medium", "high"];
+    }
     if (version >= 3) {
         return isPro ? ["low", "medium", "high"] : ["minimal", "low", "medium", "high"];
     }

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-registry.js

@@ -11,7 +11,7 @@ import { getBubbleHome } from "./bubble-home.js";
 import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, clearDynamicModelMetadata, getBuiltinModel, getBuiltinProvider, inferGrokModelMetadata, listBuiltinModels, replaceDynamicModelMetadata, } from "./model-catalog.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
-import { fetchGeminiModels } from "./provider-ai-sdk.js";
+import { fetchGeminiModels, geminiReasoningLevels } from "./provider-ai-sdk.js";
 import { extractChatGptAccountId, fetchOpenAICodexModelCatalog } from "./provider-openai-codex.js";
 import { fetchGrokSubscriptionModels } from "./provider-grok.js";
 import { refreshOpenAICodex } from "./oauth/openai-codex.js";
@@ -169,18 +169,23 @@ export class ProviderRegistry {
                     continue;
                 if (!entry.result || !Array.isArray(entry.result.models))
                     continue;
+                const provider = { id: entry.providerId ?? "", authType: entry.authType, protocol: entry.protocol };
+                // Capability fields may have been derived by an older Bubble build.
+                // Recompute them with the current code while retaining cached remote
+                // membership, display names and context windows.
+                const result = normalizeProviderDiscoveryMetadata(provider, entry.result);
                 this.modelDiscoveryCache.set(key, {
-                    result: entry.result,
+                    result,
                     expiresAt: entry.expiresAt,
                     identityKey: entry.identityKey ?? "unknown",
-                    providerId: entry.providerId ?? "",
+                    providerId: provider.id,
                     authType: entry.authType,
                     protocol: entry.protocol,
                 });
                 // Rebuild the dynamic overlay so context window / reasoning levels
                 // resolve from the cached catalog at startup, not only on /model open.
                 if (entry.providerId) {
-                    this.applyDynamicDiscoveryMetadata({ id: entry.providerId, authType: entry.authType, protocol: entry.protocol }, entry.result);
+                    this.applyDynamicDiscoveryMetadata(provider, result);
                 }
             }
         }
@@ -513,6 +518,8 @@ export class ProviderRegistry {
         if (!options.forceRefresh) {
             const cached = this.modelDiscoveryCache.get(key);
             if (cached && cached.expiresAt > now) {
+                const cachedResult = normalizeProviderDiscoveryMetadata(provider, cached.result);
+                cached.result = cachedResult;
                 // A disk cache can outlive the application version that wrote it. Keep
                 // the current curated catalog authoritative over stale cached metadata,
                 // then retain cached remote-only ids for non-authoritative union results.
@@ -520,12 +527,12 @@ export class ProviderRegistry {
                 // without waiting up to 24 hours or requiring a manual Ctrl+R refresh.
                 const local = this.localModelsForProvider(provider);
                 const localIds = new Set(local.map((model) => model.id));
-                const models = cached.result.source === "static"
+                const models = cachedResult.source === "static"
                     ? local
-                    : cached.result.authoritative
-                        ? cached.result.models
-                        : [...local, ...cached.result.models.filter((model) => !localIds.has(model.id))];
-                const result = { ...cached.result, models, source: "cache" };
+                    : cachedResult.authoritative
+                        ? cachedResult.models
+                        : [...local, ...cachedResult.models.filter((model) => !localIds.has(model.id))];
+                const result = { ...cachedResult, models, source: "cache" };
                 const current = this.getConfigured().find((item) => item.id === provider.id);
                 if (!current || this.modelDiscoveryKey(current) === key) {
                     this.applyDynamicDiscoveryMetadata(provider, result);
@@ -544,7 +551,8 @@ export class ProviderRegistry {
         const generation = (this.modelDiscoveryGeneration.get(provider.id) ?? 0) + 1;
         this.modelDiscoveryGeneration.set(provider.id, generation);
         let pending;
-        pending = this.performModelDiscovery(provider).then((result) => {
+        pending = this.performModelDiscovery(provider).then((rawResult) => {
+            const result = normalizeProviderDiscoveryMetadata(provider, rawResult);
             if (!this.isCurrentModelDiscovery(provider, key, generation)) {
                 return {
                     models: this.localModelsForProvider(this.getConfigured().find((item) => item.id === provider.id) ?? provider),
@@ -879,6 +887,22 @@ export class ProviderRegistry {
         })));
     }
 }
+/**
+ * Remote Gemini discovery does not expose Bubble's reasoning ladder; that
+ * metadata is inferred locally. Never trust a persisted inference across app
+ * upgrades, or a corrected capability matrix can remain stale for the cache
+ * TTL after restart.
+ */
+function normalizeProviderDiscoveryMetadata(provider, result) {
+    if (provider.id !== "google" || provider.protocol !== "ai-sdk")
+        return result;
+    return {
+        ...result,
+        models: result.models.map((model) => model.id.startsWith("gemini-")
+            ? { ...model, reasoningLevels: geminiReasoningLevels(model.id) }
+            : model),
+    };
+}
 function modelDiscoveryError(error) {
     if (error instanceof Error && error.message.trim())
         return error.message;

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";