@bubblebrain-ai/bubble 0.0.33 → 0.0.34

package/dist/agent.js

@@ -2555,13 +2555,11 @@ function estimateResidentChars(messages) {
     return total;
 }
 function appendProviderContentBlock(message, provider, block) {
-    if (provider !== "anthropic")
-        return;
-    const current = message.providerMetadata?.anthropic?.contentBlocks ?? [];
+    const current = message.providerMetadata?.[provider]?.contentBlocks ?? [];
     message.providerMetadata = {
         ...message.providerMetadata,
-        anthropic: {
-            ...message.providerMetadata?.anthropic,
+        [provider]: {
+            ...message.providerMetadata?.[provider],
             contentBlocks: [...current, cloneProviderRawContentBlock(block)],
         },
     };

package/dist/context/overflow.js

@@ -12,6 +12,8 @@ const OVERFLOW_PATTERNS = [
     /prompt is too long/i,
     /maximum context length/i,
     /too many tokens/i,
+    // Gemini: "The input token count (N) exceeds the maximum number of tokens allowed (M)."
+    /input token count.*exceeds the maximum/i,
 ];
 export function isContextOverflowError(error) {
     if (!error)

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";
+export type ProviderProtocol = "openai-chat" | "anthropic-messages" | "ark-responses" | "ai-sdk";
 export interface BuiltinProviderDefinition {
     id: string;
     name: string;

package/dist/model-catalog.js

@@ -4,7 +4,10 @@ export const BUILTIN_PROVIDERS = [
     { id: "openai-codex", name: "OpenAI Codex (ChatGPT)", baseURL: "https://chatgpt.com/backend-api" },
     { id: "anthropic", name: "Anthropic", baseURL: "https://api.anthropic.com", protocol: "anthropic-messages" },
     { id: "deepseek", name: "DeepSeek", baseURL: "https://api.deepseek.com" },
-    { id: "google", name: "Google", baseURL: "https://generativelanguage.googleapis.com/v1beta/openai" },
+    // Native Gemini API via the AI SDK google provider. Users who configured the
+    // old OpenAI-compat endpoint can keep it by setting protocol "openai-chat"
+    // and the /openai baseURL explicitly in models.json.
+    { id: "google", name: "Google Gemini", baseURL: "https://generativelanguage.googleapis.com/v1beta", protocol: "ai-sdk" },
     { id: "zhipuai", name: "Zhipu AI", baseURL: "https://open.bigmodel.cn/api/paas/v4" },
     { id: "zhipuai-coding-plan", name: "Zhipu AI Coding Plan", baseURL: "https://open.bigmodel.cn/api/coding/paas/v4" },
     { id: "zai", name: "Z.AI", baseURL: "https://api.z.ai/api/paas/v4" },
@@ -51,6 +54,10 @@ const ANTHROPIC_OPUS_EFFORT_LEVELS = ["off", "low", "medium", "high", "xhigh", "
 const ANTHROPIC_SONNET_EFFORT_LEVELS = ["off", "low", "medium", "high", "max"];
 const ANTHROPIC_FABLE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 const ANTHROPIC_CHAT_LEVELS = ["off"];
+const GEMINI_3_LEVELS = ["low", "medium", "high"];
+const GEMINI_3_FLASH_LEVELS = ["minimal", "low", "medium", "high"];
+const GEMINI_25_PRO_LEVELS = ["low", "medium", "high"];
+const GEMINI_25_FLASH_LEVELS = ["off", "low", "medium", "high"];
 export const BUILTIN_MODELS = [
     { id: "gpt-5.5", name: "gpt-5.5", providerId: "openai-codex", reasoningLevels: ALL_OPENAI_LEVELS, contextWindow: 272000, toolOutputTokenLimit: 10000 },
     { id: "gpt-5.4", name: "gpt-5.4", providerId: "openai-codex", reasoningLevels: ALL_OPENAI_LEVELS, contextWindow: 272000 },
@@ -73,9 +80,15 @@ export const BUILTIN_MODELS = [
     { id: "claude-haiku-4-5-20251001", name: "Claude Haiku 4.5", providerId: "anthropic", reasoningLevels: ANTHROPIC_CHAT_LEVELS, contextWindow: 200000 },
     { id: "deepseek-v4-flash", name: "deepseek-v4-flash", providerId: "deepseek", reasoningLevels: DEEPSEEK_V4_LEVELS, contextWindow: 1048576 },
     { id: "deepseek-v4-pro", name: "deepseek-v4-pro", providerId: "deepseek", reasoningLevels: DEEPSEEK_V4_LEVELS, contextWindow: 1048576 },
-    { id: "gemini-2.5-pro-preview-03-25", name: "gemini-2.5-pro-preview-03-25", providerId: "google", reasoningLevels: ["off", "low", "high"], contextWindow: 128000 },
-    { id: "gemini-2.0-flash-001", name: "gemini-2.0-flash-001", providerId: "google", reasoningLevels: ["off"], contextWindow: 128000 },
-    { id: "gemini-1.5-pro-latest", name: "gemini-1.5-pro-latest", providerId: "google", reasoningLevels: ["off"], contextWindow: 128000 },
+    // 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).
+    { id: "gemini-3.5-flash", name: "Gemini 3.5 Flash", providerId: "google", reasoningLevels: GEMINI_3_FLASH_LEVELS, contextWindow: 1048576 },
+    { id: "gemini-3.1-pro-preview", name: "Gemini 3.1 Pro", providerId: "google", reasoningLevels: GEMINI_3_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "gemini-3-flash-preview", name: "Gemini 3 Flash", providerId: "google", reasoningLevels: GEMINI_3_FLASH_LEVELS, contextWindow: 1048576 },
+    { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro", providerId: "google", reasoningLevels: GEMINI_25_PRO_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash", providerId: "google", reasoningLevels: GEMINI_25_FLASH_LEVELS, contextWindow: 1048576 },
     { id: "glm-5.2", name: "GLM-5.2", providerId: "zhipuai", reasoningLevels: GLM_5_2_LEVELS, contextWindow: 1000000 },
     { id: "glm-5.1", name: "GLM-5.1", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },

package/dist/provider-ai-sdk.d.ts

@@ -0,0 +1,56 @@
+/**
+ * AI SDK provider backend ("ai-sdk" protocol).
+ *
+ * Consumes AI SDK provider packages at the LanguageModelV3 spec layer
+ * (`model.doStream`) rather than through the high-level `streamText` API:
+ * pre-stream HTTP errors throw natively (which our retry/rate-limit contract
+ * needs), tool-call inputs arrive as JSON strings (matching `argumentsFull`),
+ * and no step machinery or extra dependencies come along.
+ *
+ * Registered providers: google (Gemini native API). Adding another AI SDK
+ * provider is one entry in AI_SDK_PROVIDER_FACTORIES.
+ */
+import { type ProviderFetch } from "./network/provider-transport.js";
+import type { Provider, ReasoningEffort, ThinkingLevel } from "./types.js";
+export interface AiSdkProviderOptions {
+    providerId?: string;
+    apiKey: string;
+    baseURL?: string;
+    thinkingLevel?: ThinkingLevel;
+    /** Transport override for tests; defaults to the shared provider fetch. */
+    fetch?: ProviderFetch;
+}
+export declare function isAiSdkProviderId(providerId: string | undefined): boolean;
+export declare function createAiSdkProvider(options: AiSdkProviderOptions): Provider;
+export interface GeminiModelDescriptor {
+    id: string;
+    name: string;
+    contextWindow?: number;
+    reasoningLevels: ReasoningEffort[];
+    defaultReasoningLevel?: ReasoningEffort;
+}
+interface GeminiModelListEntry {
+    name?: string;
+    displayName?: string;
+    inputTokenLimit?: number;
+    supportedGenerationMethods?: string[];
+}
+/**
+ * Fetch Google's model list and keep the newest general-purpose text models.
+ * Newly released Gemini versions appear without a catalog change; the static
+ * BUILTIN_MODELS entries stay as the offline/no-key fallback.
+ */
+export declare function fetchGeminiModels(options: {
+    apiKey: string;
+    baseURL?: string;
+    fetch?: ProviderFetch;
+    limit?: number;
+}): Promise<GeminiModelDescriptor[]>;
+/**
+ * Ranking: one entry per (version, tier) family — GA ids beat dated previews —
+ * then newest version first, pro before flash before flash-lite, top N.
+ */
+export declare function selectLatestGeminiModels(entries: GeminiModelListEntry[], limit?: number): GeminiModelDescriptor[];
+/** Mirrors the static catalog's per-family thinking support. */
+export declare function geminiReasoningLevels(modelId: string): ReasoningEffort[];
+export {};

package/dist/provider-ai-sdk.js

@@ -0,0 +1,518 @@
+/**
+ * AI SDK provider backend ("ai-sdk" protocol).
+ *
+ * Consumes AI SDK provider packages at the LanguageModelV3 spec layer
+ * (`model.doStream`) rather than through the high-level `streamText` API:
+ * pre-stream HTTP errors throw natively (which our retry/rate-limit contract
+ * needs), tool-call inputs arrive as JSON strings (matching `argumentsFull`),
+ * and no step machinery or extra dependencies come along.
+ *
+ * Registered providers: google (Gemini native API). Adding another AI SDK
+ * provider is one entry in AI_SDK_PROVIDER_FACTORIES.
+ */
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { APICallError } from "@ai-sdk/provider";
+import { RateLimitError } from "./network/errors.js";
+import { ProviderStreamInterruptedError, computeRetryDelayMs, getProviderMaxRetries, isRetryableHttpStatus, sleepBeforeRetry, } from "./network/retry.js";
+import { createProviderFetch, isProviderTransportError } from "./network/provider-transport.js";
+const GEMINI_DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const AI_SDK_PROVIDER_FACTORIES = {
+    google: (options) => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: options.apiKey,
+            ...(options.baseURL ? { baseURL: normalizeBaseURL(options.baseURL) } : {}),
+            fetch: (options.fetch ?? createProviderFetch({
+                providerName: "Google Gemini",
+                verboseEnvVar: "BUBBLE_AI_SDK_FETCH_VERBOSE",
+            })),
+        });
+        return (modelId) => provider(modelId);
+    },
+};
+export function isAiSdkProviderId(providerId) {
+    return !!providerId && providerId in AI_SDK_PROVIDER_FACTORIES;
+}
+export function createAiSdkProvider(options) {
+    const providerId = options.providerId || "google";
+    const factory = AI_SDK_PROVIDER_FACTORIES[providerId];
+    if (!factory) {
+        const known = Object.keys(AI_SDK_PROVIDER_FACTORIES).join(", ");
+        throw new Error(`Provider "${providerId}" is configured with protocol "ai-sdk" but no AI SDK backend is registered for it (known: ${known}).`);
+    }
+    const getModel = factory(options);
+    async function* streamChat(messages, chatOptions) {
+        const model = getModel(chatOptions.model);
+        const callOptions = buildCallOptions(messages, chatOptions, options);
+        const maxRetries = getProviderMaxRetries();
+        for (let attempt = 0;; attempt++) {
+            let stream;
+            try {
+                ({ stream } = await model.doStream(callOptions));
+            }
+            catch (error) {
+                // No stream established: the request is safe to classify and re-issue.
+                handlePreStreamError(error, {
+                    attempt,
+                    maxRetries,
+                    rateLimitPolicy: chatOptions.rateLimitPolicy,
+                    signal: chatOptions.abortSignal,
+                });
+                await sleepBeforeRetry(computeRetryDelayMs(attempt + 1, { retryAfterMs: retryAfterMsFromError(error) }), chatOptions.abortSignal);
+                continue;
+            }
+            const translator = new StreamTranslator();
+            let surfacedContent = false;
+            try {
+                for await (const part of stream) {
+                    // The SDK surfaces post-200 failures as error parts and lets the
+                    // stream "finish" normally; that would look like an empty reply to
+                    // the agent loop, so convert them back into throws here.
+                    if (part.type === "error") {
+                        throw coerceError(part.error);
+                    }
+                    for (const chunk of translator.translate(part)) {
+                        surfacedContent = surfacedContent || isContentChunk(chunk);
+                        yield chunk;
+                    }
+                }
+                yield { type: "done" };
+                return;
+            }
+            catch (error) {
+                if (chatOptions.abortSignal?.aborted)
+                    throw coerceError(error);
+                if (surfacedContent) {
+                    // Partial content already reached the UI — only the agent loop can
+                    // discard the half-built assistant message and re-issue the request.
+                    throw new ProviderStreamInterruptedError(`Gemini stream interrupted: ${errorMessage(error)}`, { cause: error });
+                }
+                if (attempt >= maxRetries || !isRetryableStreamError(error))
+                    throw coerceError(error);
+                await sleepBeforeRetry(computeRetryDelayMs(attempt + 1), chatOptions.abortSignal);
+            }
+        }
+    }
+    async function complete(messages, completeOptions) {
+        const modelId = completeOptions?.model;
+        if (!modelId)
+            throw new Error("ai-sdk provider requires an explicit model for complete().");
+        const model = getModel(modelId);
+        const callOptions = buildCallOptions(messages, {
+            model: modelId,
+            temperature: completeOptions?.temperature,
+            thinkingLevel: completeOptions?.thinkingLevel ?? "off",
+            abortSignal: completeOptions?.abortSignal,
+        }, options);
+        const result = await model.doGenerate(callOptions);
+        return result.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("");
+    }
+    return { streamChat, complete };
+}
+// ============================================================================
+// Request building
+// ============================================================================
+function buildCallOptions(messages, chatOptions, providerOptions) {
+    const prompt = convertMessages(messages);
+    const thinking = buildGoogleThinkingOptions(chatOptions.model, chatOptions.thinkingLevel ?? providerOptions.thinkingLevel);
+    return {
+        prompt,
+        ...(chatOptions.temperature !== undefined ? { temperature: chatOptions.temperature } : {}),
+        ...(chatOptions.abortSignal ? { abortSignal: chatOptions.abortSignal } : {}),
+        ...(chatOptions.tools?.length
+            ? {
+                tools: chatOptions.tools.map((tool) => ({
+                    type: "function",
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.parameters,
+                })),
+                toolChoice: { type: chatOptions.toolChoice === "none" ? "none" : "auto" },
+            }
+            : {}),
+        ...(thinking ? { providerOptions: { google: thinking } } : {}),
+    };
+}
+/**
+ * Gemini 3 models take a graded thinking_level; 2.5-era models take a token
+ * budget. "off" (budget 0) is only offered in the catalog for models that
+ * accept it (2.5 Flash); xhigh/max clamp to high.
+ */
+function buildGoogleThinkingOptions(modelId, level) {
+    if (!level)
+        return undefined;
+    if (level === "off")
+        return { thinkingConfig: { thinkingBudget: 0 } };
+    const clamped = level === "xhigh" || level === "max" ? "high" : level;
+    if (modelId.includes("gemini-3")) {
+        return { thinkingConfig: { thinkingLevel: clamped, includeThoughts: true } };
+    }
+    const budgets = { minimal: 512, low: 2048, medium: 8192, high: 24576 };
+    return { thinkingConfig: { thinkingBudget: budgets[clamped] ?? 8192, includeThoughts: true } };
+}
+function convertMessages(messages) {
+    const out = [];
+    const toolNamesById = new Map();
+    for (const message of messages) {
+        if (message.role === "system") {
+            out.push({ role: "system", content: message.content });
+            continue;
+        }
+        if (message.role === "user") {
+            out.push({ role: "user", content: convertUserContent(message.content) });
+            continue;
+        }
+        if (message.role === "assistant") {
+            for (const call of message.toolCalls ?? [])
+                toolNamesById.set(call.id, call.name);
+            const content = convertAssistantContent(message);
+            if (content.length > 0)
+                out.push({ role: "assistant", content });
+            continue;
+        }
+        // tool result
+        out.push({
+            role: "tool",
+            content: [{
+                    type: "tool-result",
+                    toolCallId: message.toolCallId,
+                    toolName: toolNamesById.get(message.toolCallId) ?? "unknown_tool",
+                    output: toToolResultOutput(message.content, message.isError),
+                }],
+        });
+    }
+    return out;
+}
+function convertUserContent(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    const parts = [];
+    for (const part of content) {
+        if (part.type === "text" && typeof part.text === "string") {
+            parts.push({ type: "text", text: part.text });
+        }
+        else if (part.type === "image_url" && part.image_url?.url) {
+            parts.push(toImageFilePart(part.image_url.url));
+        }
+    }
+    return parts.length > 0 ? parts : [{ type: "text", text: "" }];
+}
+function toImageFilePart(url) {
+    const dataUrl = /^data:([^;,]+)?(;base64)?,(.*)$/s.exec(url);
+    if (dataUrl) {
+        return {
+            type: "file",
+            mediaType: dataUrl[1] || "image/png",
+            data: dataUrl[2] ? dataUrl[3] : decodeURIComponent(dataUrl[3]),
+        };
+    }
+    const extension = /\.(png|jpe?g|gif|webp)(?:[?#]|$)/i.exec(url)?.[1]?.toLowerCase();
+    const mediaType = extension === "jpg" || extension === "jpeg"
+        ? "image/jpeg"
+        : extension
+            ? `image/${extension}`
+            : "image/png";
+    return { type: "file", mediaType, data: new URL(url) };
+}
+function convertAssistantContent(message) {
+    const parts = [];
+    const blocks = message.providerMetadata?.google?.contentBlocks ?? [];
+    const toolCallSignatures = new Map();
+    // Replay captured Gemini parts: signed reasoning comes back verbatim so the
+    // thought signature round-trips; tool-call signatures re-attach by id.
+    for (const block of blocks) {
+        if (block.type === "reasoning" && typeof block.text === "string" && typeof block.thoughtSignature === "string") {
+            parts.push({
+                type: "reasoning",
+                text: block.text,
+                providerOptions: { google: { thoughtSignature: block.thoughtSignature } },
+            });
+        }
+        else if (block.type === "tool-call" && typeof block.toolCallId === "string" && typeof block.thoughtSignature === "string") {
+            toolCallSignatures.set(block.toolCallId, block.thoughtSignature);
+        }
+    }
+    if (message.content)
+        parts.push({ type: "text", text: message.content });
+    for (const call of message.toolCalls ?? []) {
+        const signature = toolCallSignatures.get(call.id);
+        parts.push({
+            type: "tool-call",
+            toolCallId: call.id,
+            toolName: call.name,
+            input: parseToolArguments(call.arguments),
+            ...(signature ? { providerOptions: { google: { thoughtSignature: signature } } } : {}),
+        });
+    }
+    return parts;
+}
+function parseToolArguments(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function toToolResultOutput(content, isError) {
+    return isError ? { type: "error-text", value: content } : { type: "text", value: content };
+}
+function normalizeBaseURL(baseURL) {
+    return baseURL.trim().replace(/\/+$/, "");
+}
+// ============================================================================
+// Stream translation
+// ============================================================================
+class StreamTranslator {
+    reasoningText = "";
+    reasoningSignature;
+    toolNamesById = new Map();
+    translate(part) {
+        switch (part.type) {
+            case "text-delta":
+                return part.delta ? [{ type: "text", content: part.delta }] : [];
+            case "reasoning-start":
+                this.reasoningText = "";
+                this.reasoningSignature = thoughtSignatureOf(part.providerMetadata);
+                return [];
+            case "reasoning-delta": {
+                this.reasoningText += part.delta;
+                this.reasoningSignature ??= thoughtSignatureOf(part.providerMetadata);
+                return part.delta ? [{ type: "reasoning_delta", content: part.delta }] : [];
+            }
+            case "reasoning-end": {
+                this.reasoningSignature ??= thoughtSignatureOf(part.providerMetadata);
+                if (!this.reasoningSignature || !this.reasoningText)
+                    return [];
+                const block = {
+                    type: "reasoning",
+                    text: this.reasoningText,
+                    thoughtSignature: this.reasoningSignature,
+                };
+                this.reasoningText = "";
+                this.reasoningSignature = undefined;
+                return [{ type: "provider_content_block", provider: "google", block }];
+            }
+            case "tool-input-start":
+                this.toolNamesById.set(part.id, part.toolName);
+                return [{ type: "tool_call", id: part.id, name: part.toolName, arguments: "", isStart: true, isEnd: false }];
+            case "tool-input-delta": {
+                if (!part.delta)
+                    return [];
+                const name = this.toolNamesById.get(part.id) ?? "";
+                return [{ type: "tool_call", id: part.id, name, arguments: part.delta, isStart: false, isEnd: false }];
+            }
+            case "tool-call": {
+                const argumentsFull = typeof part.input === "string" ? part.input : JSON.stringify(part.input ?? {});
+                const chunks = [{
+                        type: "tool_call",
+                        id: part.toolCallId,
+                        name: part.toolName,
+                        arguments: "",
+                        isStart: false,
+                        isEnd: true,
+                        argumentsFull,
+                    }];
+                const signature = thoughtSignatureOf(part.providerMetadata);
+                if (signature) {
+                    chunks.push({
+                        type: "provider_content_block",
+                        provider: "google",
+                        block: { type: "tool-call", toolCallId: part.toolCallId, thoughtSignature: signature },
+                    });
+                }
+                return chunks;
+            }
+            case "finish": {
+                const usage = translateUsage(part.usage);
+                return usage ? [{ type: "usage", usage }] : [];
+            }
+            default:
+                // stream-start, response-metadata, text-start/end, tool-input-end,
+                // source, raw: nothing to surface.
+                return [];
+        }
+    }
+}
+function thoughtSignatureOf(metadata) {
+    const signature = metadata?.google?.thoughtSignature;
+    return typeof signature === "string" && signature.length > 0 ? signature : undefined;
+}
+function translateUsage(usage) {
+    const inputTokens = usage?.inputTokens?.total;
+    const outputTokens = usage?.outputTokens?.total;
+    // Without a real input count the chunk would poison the agent's context
+    // budget tracking (lastInputTokens), so skip rather than report zeros.
+    if (!Number.isFinite(inputTokens))
+        return undefined;
+    const result = {
+        promptTokens: inputTokens,
+        completionTokens: Number.isFinite(outputTokens) ? outputTokens : 0,
+    };
+    const cacheRead = usage?.inputTokens?.cacheRead;
+    const noCache = usage?.inputTokens?.noCache;
+    const cacheWrite = usage?.inputTokens?.cacheWrite;
+    const reasoning = usage?.outputTokens?.reasoning;
+    if (Number.isFinite(cacheRead))
+        result.promptCacheHitTokens = cacheRead;
+    if (Number.isFinite(noCache))
+        result.promptCacheMissTokens = noCache;
+    if (Number.isFinite(cacheWrite))
+        result.cacheCreationTokens = cacheWrite;
+    if (Number.isFinite(reasoning))
+        result.reasoningTokens = reasoning;
+    if (Number.isFinite(inputTokens) && Number.isFinite(outputTokens)) {
+        result.totalTokens = inputTokens + outputTokens;
+    }
+    return result;
+}
+function isContentChunk(chunk) {
+    return chunk.type === "text" || chunk.type === "reasoning_delta" || chunk.type === "tool_call";
+}
+// ============================================================================
+// Error handling
+// ============================================================================
+/**
+ * Classify a pre-stream error. Throws (RateLimitError / the original error)
+ * when the request must not be retried here; returns normally when the caller
+ * should back off and retry.
+ */
+function handlePreStreamError(error, context) {
+    if (context.signal?.aborted)
+        throw coerceError(error);
+    const status = APICallError.isInstance(error) ? error.statusCode : undefined;
+    if (status === 429) {
+        const retryAfterMs = retryAfterMsFromError(error);
+        if (context.rateLimitPolicy === "defer") {
+            // Rate-limit contract: under "defer" the transport does no 429 backoff;
+            // the subagent scheduler owns it.
+            throw new RateLimitError(`Gemini API rate limited (429): ${errorMessage(error)}`, {
+                status: 429,
+                retryAfterMs,
+                cause: error,
+            });
+        }
+        if (context.attempt >= context.maxRetries) {
+            throw new RateLimitError(`Gemini API rate limited (429) after ${context.attempt + 1} attempts: ${errorMessage(error)}`, { status: 429, retryAfterMs, cause: error });
+        }
+        return;
+    }
+    const retryable = APICallError.isInstance(error)
+        ? (error.isRetryable || (typeof status === "number" && isRetryableHttpStatus(status)))
+        : isProviderTransportError(error);
+    if (!retryable || context.attempt >= context.maxRetries)
+        throw coerceError(error);
+}
+function retryAfterMsFromError(error) {
+    if (!APICallError.isInstance(error))
+        return undefined;
+    const header = error.responseHeaders?.["retry-after"]?.trim();
+    if (!header)
+        return undefined;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.round(seconds * 1000);
+    const date = Date.parse(header);
+    if (!Number.isNaN(date))
+        return Math.max(0, date - Date.now());
+    return undefined;
+}
+function isRetryableStreamError(error) {
+    if (APICallError.isInstance(error)) {
+        return error.isRetryable || (typeof error.statusCode === "number" && isRetryableHttpStatus(error.statusCode));
+    }
+    return isProviderTransportError(error);
+}
+function coerceError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// Specialised variants that are not general text/coding models.
+const GEMINI_MODEL_EXCLUDE = /(tts|image|audio|embedding|live|computer-use|robotics|banana|aqa|learnlm|gemma|imagen|veo)/i;
+/**
+ * Fetch Google's model list and keep the newest general-purpose text models.
+ * Newly released Gemini versions appear without a catalog change; the static
+ * BUILTIN_MODELS entries stay as the offline/no-key fallback.
+ */
+export async function fetchGeminiModels(options) {
+    const baseURL = normalizeBaseURL(options.baseURL || GEMINI_DEFAULT_BASE_URL);
+    const fetchImpl = options.fetch ?? createProviderFetch({
+        providerName: "Google Gemini",
+        verboseEnvVar: "BUBBLE_AI_SDK_FETCH_VERBOSE",
+    });
+    const response = await fetchImpl(`${baseURL}/models?pageSize=1000`, {
+        headers: { "x-goog-api-key": options.apiKey },
+    });
+    if (!response.ok) {
+        throw new Error(`Gemini model list failed (${response.status}): ${await response.text().catch(() => response.statusText)}`);
+    }
+    const data = await response.json();
+    return selectLatestGeminiModels(data.models ?? [], options.limit ?? 5);
+}
+/**
+ * Ranking: one entry per (version, tier) family — GA ids beat dated previews —
+ * then newest version first, pro before flash before flash-lite, top N.
+ */
+export function selectLatestGeminiModels(entries, limit = 5) {
+    const TIER_RANK = { pro: 0, flash: 1, "flash-lite": 2 };
+    const candidates = [];
+    for (const entry of entries) {
+        const id = (entry.name ?? "").replace(/^models\//, "");
+        if (!id.startsWith("gemini-"))
+            continue;
+        if (GEMINI_MODEL_EXCLUDE.test(id))
+            continue;
+        if (entry.supportedGenerationMethods && !entry.supportedGenerationMethods.includes("generateContent"))
+            continue;
+        const match = /^gemini-(\d+(?:\.\d+)?)-(pro|flash)(-lite)?/.exec(id);
+        if (!match)
+            continue;
+        candidates.push({
+            id,
+            entry,
+            version: Number.parseFloat(match[1]),
+            tierRank: TIER_RANK[`${match[2]}${match[3] ?? ""}`] ?? 3,
+            isPreview: id.includes("preview") || id.includes("exp"),
+        });
+    }
+    // One winner per family: GA over preview, then the shortest (least-suffixed) id.
+    const families = new Map();
+    for (const candidate of candidates) {
+        const key = `${candidate.version}-${candidate.tierRank}`;
+        const current = families.get(key);
+        if (!current
+            || (current.isPreview && !candidate.isPreview)
+            || (current.isPreview === candidate.isPreview && candidate.id.length < current.id.length)) {
+            families.set(key, candidate);
+        }
+    }
+    return [...families.values()]
+        .sort((a, b) => (b.version - a.version) || (a.tierRank - b.tierRank))
+        .slice(0, limit)
+        .map((candidate) => ({
+        id: candidate.id,
+        name: candidate.entry.displayName || candidate.id,
+        contextWindow: Number.isFinite(candidate.entry.inputTokenLimit) ? candidate.entry.inputTokenLimit : undefined,
+        reasoningLevels: geminiReasoningLevels(candidate.id),
+        ...(candidate.tierRank === 0 ? { defaultReasoningLevel: "high" } : {}),
+    }));
+}
+/** Mirrors the static catalog's per-family thinking support. */
+export function geminiReasoningLevels(modelId) {
+    const version = Number.parseFloat(/^gemini-(\d+(?:\.\d+)?)/.exec(modelId)?.[1] ?? "0");
+    const isPro = modelId.includes("-pro");
+    if (version >= 3) {
+        return isPro ? ["low", "medium", "high"] : ["minimal", "low", "medium", "high"];
+    }
+    if (version >= 2.5) {
+        return isPro ? ["low", "medium", "high"] : ["off", "low", "medium", "high"];
+    }
+    return ["off"];
+}

package/dist/provider-registry.js

@@ -7,6 +7,7 @@
 import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, getBuiltinModel, getBuiltinProvider, listBuiltinModels, registerDynamicModelMetadata, } from "./model-catalog.js";
 import { ModelConfig } from "./model-config.js";
 import { AuthStorage } from "./oauth/index.js";
+import { fetchGeminiModels } from "./provider-ai-sdk.js";
 import { fetchOpenAICodexModels } from "./provider-openai-codex.js";
 import { refreshOpenAICodex } from "./oauth/openai-codex.js";
 export const BUILTIN_PROVIDERS = CATALOG_PROVIDERS;
@@ -123,7 +124,7 @@ export class ProviderRegistry {
             providers = keys.map((id) => {
                 const builtin = getBuiltinProvider(id);
                 const cfg = modelsJsonProviders[id];
-                const baseURL = cfg.baseURL || builtin?.baseURL || "";
+                const baseURL = upgradeLegacyBaseURL(id, cfg.baseURL || builtin?.baseURL || "", cfg.protocol);
                 return {
                     id,
                     name: builtin?.name || id,
@@ -138,10 +139,11 @@ export class ProviderRegistry {
         else {
             // 2. Fall back to config.json providers (interactive TUI style)
             providers = this.config.getProviders().map((provider) => {
-                const builtin = getBuiltinProvider(provider.id);
+                const baseURL = upgradeLegacyBaseURL(provider.id, provider.baseURL, provider.protocol);
                 return {
                     ...provider,
-                    protocol: resolveConfiguredProtocol(provider.id, provider.baseURL, provider.protocol),
+                    baseURL,
+                    protocol: resolveConfiguredProtocol(provider.id, baseURL, provider.protocol),
                 };
             });
         }
@@ -247,6 +249,31 @@ export class ProviderRegistry {
                 // fall through to static
             }
         }
+        if (provider.id === "google" && provider.protocol === "ai-sdk" && provider.apiKey) {
+            try {
+                const descriptors = await fetchGeminiModels({
+                    apiKey: provider.apiKey,
+                    baseURL: provider.baseURL,
+                });
+                if (descriptors.length > 0) {
+                    for (const d of descriptors) {
+                        const catalogEntry = getBuiltinModel("google", d.id);
+                        registerDynamicModelMetadata({
+                            id: d.id,
+                            name: d.name,
+                            providerId: "google",
+                            reasoningLevels: d.reasoningLevels,
+                            defaultReasoningLevel: d.defaultReasoningLevel ?? catalogEntry?.defaultReasoningLevel,
+                            contextWindow: d.contextWindow ?? catalogEntry?.contextWindow,
+                        });
+                    }
+                    return descriptors.map((d) => ({ id: d.id, name: d.name, providerId: provider.id }));
+                }
+            }
+            catch {
+                // fall through to static
+            }
+        }
         if (provider.id === "openai" && provider.authType === "oauth" && provider.apiKey) {
             try {
                 await this.prepareProvider(provider.id);
@@ -291,6 +318,25 @@ export class ProviderRegistry {
         }));
     }
 }
+/**
+ * Builtin defaults that were captured into stored profiles before a builtin's
+ * baseURL moved. Exactly these values are treated as "not customized" and
+ * follow the builtin to its new address (and thereby its new protocol);
+ * genuinely custom URLs and profiles with an explicit protocol are untouched.
+ */
+const LEGACY_BUILTIN_BASE_URLS = {
+    // google moved from the Gemini OpenAI-compat endpoint to the native API
+    // when the "ai-sdk" protocol landed.
+    google: "https://generativelanguage.googleapis.com/v1beta/openai",
+};
+function upgradeLegacyBaseURL(providerId, baseURL, explicitProtocol) {
+    if (explicitProtocol)
+        return baseURL;
+    const legacy = LEGACY_BUILTIN_BASE_URLS[providerId];
+    if (!legacy || normalizeBaseURL(baseURL) !== normalizeBaseURL(legacy))
+        return baseURL;
+    return getBuiltinProvider(providerId)?.baseURL ?? baseURL;
+}
 function resolveConfiguredProtocol(providerId, baseURL, explicitProtocol) {
     if (explicitProtocol)
         return explicitProtocol;

package/dist/provider.js

@@ -7,6 +7,7 @@ import OpenAI from "openai";
 import { appendFileSync } from "node:fs";
 import { createAnthropicMessagesProvider } from "./provider-anthropic.js";
 import { createArkResponsesProvider } from "./provider-ark-responses.js";
+import { createAiSdkProvider } from "./provider-ai-sdk.js";
 import { createOpenAICodexProvider, isOpenAICodexBaseUrl } from "./provider-openai-codex.js";
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
@@ -84,6 +85,9 @@ export function createProviderInstance(options) {
     if (protocol === "ark-responses") {
         return createArkResponsesProvider(options);
     }
+    if (protocol === "ai-sdk") {
+        return createAiSdkProvider(options);
+    }
     if (isOpenAICodexBaseUrl(options.baseURL)) {
         return createOpenAICodexProvider({
             ...options,

package/dist/slash-commands/commands.js

@@ -329,19 +329,15 @@ const builtinSlashCommandEntries = [
     },
     {
         name: "theme",
-        description: "Switch the color theme. Usage: /theme [auto|light|dark]",
+        description: "Pick the color theme. Usage: /theme [auto|light|dark]",
         async handler(args, ctx) {
             if (!ctx.setThemeMode || !ctx.getThemeMode || !ctx.getResolvedTheme) {
                 return "Theme switching is only available inside the TUI.";
             }
             const arg = args.trim().toLowerCase();
             if (!arg) {
-                const order = ["auto", "light", "dark"];
-                const current = ctx.getThemeMode();
-                const next = order[(order.indexOf(current) + 1) % order.length];
-                ctx.setThemeMode(next);
-                const resolved = next === "auto" ? ctx.getResolvedTheme() : next;
-                return `Theme: ${next}${next === "auto" ? ` (resolved to ${resolved})` : ""}`;
+                ctx.openPicker("theme");
+                return;
             }
             if (arg !== "auto" && arg !== "light" && arg !== "dark") {
                 return "Usage: /theme [auto|light|dark]";

package/dist/slash-commands/types.d.ts

@@ -28,7 +28,7 @@ export interface SlashCommandContext {
     exit: () => void;
     sessionManager?: SessionManager;
     createProvider: (providerId: string, apiKey: string, baseURL: string) => Provider;
-    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout" | "skill" | "feishu-setup", providerId?: string) => void;
+    openPicker: (mode: "model" | "key" | "provider" | "provider-add" | "login" | "logout" | "skill" | "theme" | "feishu-setup", providerId?: string) => void;
     registry: ProviderRegistry;
     skillRegistry: SkillRegistry;
     bashAllowlist?: BashAllowlist;

package/dist/tui-ink/app.js

@@ -254,6 +254,11 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
         setThemeMode(mode);
         onThemeModeChange?.(mode);
     }, [onThemeModeChange]);
+    // Theme mode at the moment the /theme picker opened, so Esc can restore it
+    // after live-previewing other themes while navigating the picker.
+    const themeModeRef = useRef(themeMode);
+    themeModeRef.current = themeMode;
+    const themePickerRevertRef = useRef("auto");
     const themeResolved = themeMode === "auto" ? autoResolved : themeMode;
     const { exit } = useApp();
     const [messages, setMessages] = useState(() => compactDisplayMessages(reconstructDisplayMessages(agent.messages)));
@@ -718,6 +723,9 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
         if (mode === "key") {
             setKeyProviderId(providerId ?? null);
         }
+        if (mode === "theme") {
+            themePickerRevertRef.current = themeModeRef.current;
+        }
         setStatsPanel(null);
         setPickerMode(mode);
     }, []);
@@ -836,6 +844,19 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
             closePicker();
         });
     }, [agent, addMessage, closePicker, sessionManager, userConfig, safeRegistry, createProvider]);
+    const handleThemeHighlight = useCallback((mode) => {
+        setThemeMode(mode);
+    }, []);
+    const handleThemeSelect = useCallback((mode) => {
+        applyThemeMode(mode);
+        const resolvedNote = mode === "auto" ? ` (resolved to ${autoResolved})` : "";
+        addMessage("assistant", `Theme set to ${mode}${resolvedNote}.`);
+        closePicker();
+    }, [addMessage, applyThemeMode, autoResolved, closePicker]);
+    const handleThemeCancel = useCallback(() => {
+        setThemeMode(themePickerRevertRef.current);
+        closePicker();
+    }, [closePicker]);
     const handleProviderSelect = useCallback((providerId) => {
         const run = async () => {
             await safeRegistry.prepareProvider(providerId);
@@ -1723,7 +1744,11 @@ export function App({ agent, args, sessionManager: initialSessionManager, switch
                         } }) })), pickerMode === "skill" && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(SkillPicker, { skills: safeSkillRegistry.summaries(), onSelect: (name) => {
                             fillComposer(`/${name} `);
                             closePicker();
-                        }, onCancel: closePicker }) })), pickerMode === "slash" && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(CommandPalette, { items: commandPaletteItems, terminalColumns: mainWidth, terminalRows: terminalRows, onSelect: (item) => {
+                        }, onCancel: closePicker }) })), pickerMode === "theme" && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(ProviderPicker, { title: "Select Theme", providers: [
+                            { id: "auto", name: `Auto — match terminal (${autoResolved})`, enabled: true },
+                            { id: "light", name: "Light", enabled: true },
+                            { id: "dark", name: "Dark", enabled: true },
+                        ], current: themePickerRevertRef.current, onSelect: handleThemeSelect, onHighlight: handleThemeHighlight, onCancel: handleThemeCancel }) })), pickerMode === "slash" && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(CommandPalette, { items: commandPaletteItems, terminalColumns: mainWidth, terminalRows: terminalRows, onSelect: (item) => {
                             closePicker();
                             if (item.action === "insert-skill") {
                                 fillComposer(`/${item.value} `);

package/dist/tui-ink/model-picker.d.ts

@@ -65,8 +65,10 @@ export interface ProviderPickerProps {
     onSelect: (providerId: string) => void;
     onCancel: () => void;
     title?: string;
+    /** Fires whenever the highlighted row changes (and once on mount) — lets callers live-preview the selection. */
+    onHighlight?: (providerId: string) => void;
 }
-export declare function ProviderPicker({ providers, current, onSelect, onCancel, title }: ProviderPickerProps): import("react/jsx-runtime").JSX.Element;
+export declare function ProviderPicker({ providers, current, onSelect, onCancel, title, onHighlight }: ProviderPickerProps): import("react/jsx-runtime").JSX.Element;
 export interface KeyPickerProps {
     providerName: string;
     onSubmit: (key: string) => void;

package/dist/tui-ink/model-picker.js

@@ -448,7 +448,7 @@ function reasoningLevelsForModel(model) {
     const { providerId, modelId } = decodeModel(model);
     return getAvailableThinkingLevels(providerId || "openai", modelId);
 }
-export function ProviderPicker({ providers, current, onSelect, onCancel, title }) {
+export function ProviderPicker({ providers, current, onSelect, onCancel, title, onHighlight }) {
     const theme = useTheme();
     const { stdout } = useStdout();
     const termHeight = stdout?.rows || 24;
@@ -457,6 +457,11 @@ export function ProviderPicker({ providers, current, onSelect, onCancel, title }
         const idx = providers.findIndex((p) => p.id === current);
         return idx >= 0 ? idx : 0;
     });
+    useEffect(() => {
+        const p = providers[selectedIndex];
+        if (p)
+            onHighlight?.(p.id);
+    }, [selectedIndex]);
     useInput((input, key) => {
         if (isKeyReleaseEvent(key))
             return;

package/dist/types.d.ts

@@ -17,10 +17,19 @@ export type ReasoningEffort = ThinkingLevel;
 export type ProviderRawContentBlock = Record<string, unknown> & {
     type: string;
 };
+export type ProviderMetadataProvider = "anthropic" | "google";
+export interface ProviderContentBlockStore {
+    contentBlocks?: ProviderRawContentBlock[];
+}
 export interface AssistantProviderMetadata {
-    anthropic?: {
-        contentBlocks?: ProviderRawContentBlock[];
-    };
+    anthropic?: ProviderContentBlockStore;
+    /**
+     * Gemini raw parts captured for replay: reasoning/tool-call parts carrying
+     * thoughtSignature so multi-turn thinking round-trips through our own
+     * message rebuild (the SDK's automatic replay assumes appending its
+     * response.messages verbatim, which we don't do).
+     */
+    google?: ProviderContentBlockStore;
 }
 export interface UserMessage {
     role: "user";
@@ -302,7 +311,7 @@ export type StreamChunk = {
     content: string;
 } | {
     type: "provider_content_block";
-    provider: "anthropic";
+    provider: ProviderMetadataProvider;
     block: ProviderRawContentBlock;
 } | {
     type: "tool_call";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {
@@ -24,6 +24,8 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@ai-sdk/google": "^3.0.88",
+    "@ai-sdk/provider": "^3.0.13",
     "@larksuiteoapi/node-sdk": "^1.65.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/react": "^19.2.14",
@@ -43,7 +45,8 @@
     "typescript-language-server": "^5.1.3",
     "undici": "^6.26.0",
     "vscode-jsonrpc": "^8.2.1",
-    "vscode-langservers-extracted": "^4.10.0"
+    "vscode-langservers-extracted": "^4.10.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",