@bubblebrain-ai/bubble 0.0.33 → 0.0.35

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-transform.d.ts

@@ -1,5 +1,5 @@
 import type { ThinkingLevel } from "./types.js";
-export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+export { getAvailableThinkingLevels, getDefaultThinkingLevel, isThinkingOnlyLevels, isThinkingOnlyModel, isThinkingToggleModel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 export interface ProviderRequestConfig {
     effectiveThinkingLevel: ThinkingLevel;
     reasoningEffort?: ThinkingLevel;

package/dist/provider-transform.js

@@ -1,9 +1,8 @@
 import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./variant/variant-resolver.js";
-export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+export { getAvailableThinkingLevels, getDefaultThinkingLevel, isThinkingOnlyLevels, isThinkingOnlyModel, isThinkingToggleModel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 const MOONSHOT_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
-const KIMI_K27_FAMILY = new Set(["kimi-k2.7-code"]);
-const KIMI_K25_FAMILY = new Set(["kimi-k2.5", "k2.6-code-preview", "kimi-k2.6"]);
-const KIMI_THINKING_FAMILY = new Set(["kimi-k2-thinking", "kimi-k2-thinking-turbo"]);
+const KIMI_K27_FAMILY = new Set(["kimi-k2.7-code", "kimi-k2.7-code-highspeed"]);
+const KIMI_TOGGLE_THINKING_FAMILY = new Set(["kimi-k2.5", "kimi-k2.6"]);
 const KIMI_K26_DEFAULT_MAX_TOKENS = 32768;
 const MINIMAX_M3_FAMILY = new Set(["MiniMax-M3"]);
 function isFireworksKimi(providerId, modelId) {
@@ -99,12 +98,11 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 },
         };
     }
-    // Moonshot / Kimi: kimi-k2.5 family (incl. k2.6-code-preview, kimi-k2.6) locks
-    // temperature/top_p/n/penalties and exposes thinking via extra_body.thinking;
-    // kimi-k2-thinking family locks temperature=1.
+    // Moonshot / Kimi: K2.5/K2.6 lock temperature/top_p/n/penalties and expose
+    // thinking via extra_body.thinking.
     if (MOONSHOT_PROVIDER_IDS.has(providerId)) {
-        // kimi-k2.7-code is thinking-only: temperature is locked to 1.0 server-side
-        // (any explicit value errors), thinking can never be disabled, and
+        // Kimi K2.7 Code variants are thinking-only: temperature is locked to 1.0
+        // server-side (any explicit value errors), thinking can never be disabled, and
         // reasoning_content must be echoed back on tool-call turns.
         if (KIMI_K27_FAMILY.has(modelId)) {
             return {
@@ -116,7 +114,7 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 },
             };
         }
-        if (KIMI_K25_FAMILY.has(modelId)) {
+        if (KIMI_TOGGLE_THINKING_FAMILY.has(modelId)) {
             return {
                 effectiveThinkingLevel,
                 omitTemperature: true,
@@ -126,9 +124,6 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 },
             };
         }
-        if (KIMI_THINKING_FAMILY.has(modelId)) {
-            return { effectiveThinkingLevel, omitTemperature: true };
-        }
         return { effectiveThinkingLevel };
     }
     if (providerId === "openai"

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,