@bubblebrain-ai/bubble 0.0.34 → 0.0.36

package/dist/provider-registry.js

@@ -4,12 +4,16 @@
  * Supports OpenAI-compatible providers with dynamic or static model lists.
  * Reads provider configuration from models.json first, then falls back to config.json.
  */
-import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, getBuiltinModel, getBuiltinProvider, listBuiltinModels, registerDynamicModelMetadata, } from "./model-catalog.js";
+import { createHash } from "node:crypto";
+import { BUILTIN_PROVIDERS as CATALOG_PROVIDERS, clearDynamicModelMetadata, getBuiltinModel, getBuiltinProvider, 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 { fetchOpenAICodexModels } from "./provider-openai-codex.js";
+import { extractChatGptAccountId, fetchOpenAICodexModelCatalog } from "./provider-openai-codex.js";
 import { refreshOpenAICodex } from "./oauth/openai-codex.js";
+import { refreshGrok } from "./oauth/grok.js";
+const MODEL_DISCOVERY_SUCCESS_TTL_MS = 60_000;
+const MODEL_DISCOVERY_FAILURE_TTL_MS = 10_000;
 export const BUILTIN_PROVIDERS = CATALOG_PROVIDERS;
 export const USER_VISIBLE_PROVIDER_IDS = BUILTIN_PROVIDERS
     .filter((provider) => !provider.hidden && provider.id !== "openrouter" && provider.id !== "openai-codex")
@@ -21,10 +25,59 @@ export class ProviderRegistry {
     config;
     modelConfig;
     authStorage;
+    modelDiscoveryCache = new Map();
+    modelDiscoveryInFlight = new Map();
+    modelDiscoveryGeneration = new Map();
+    /** Last membership seen per discovery key — survives cache eviction/TTL so
+     *  a re-discovery with identical membership never bumps the revision. */
+    lastDiscoveryMembership = new Map();
+    routingRevision = 0;
+    identityFingerprints = new Map();
     constructor(config) {
         this.config = config;
         this.modelConfig = new ModelConfig();
         this.authStorage = new AuthStorage();
+        for (const authKey of this.authStorage.list()) {
+            const fingerprint = this.credentialFingerprint(authKey);
+            if (fingerprint)
+                this.identityFingerprints.set(authKey, fingerprint);
+        }
+        this.authStorage.onMutation((authKey) => this.handleAuthMutation(authKey));
+    }
+    /**
+     * Monotonic counter of semantic routing-world changes: provider set,
+     * credential identity, provider key/config, discovery membership.
+     * Same-account OAuth token rotation deliberately does NOT bump it
+     * (docs/model-routing-design.md §1.6).
+     */
+    getRoutingRevision() {
+        return this.routingRevision;
+    }
+    bumpRoutingRevision() {
+        this.routingRevision++;
+    }
+    /** Stable identity for stored credentials: account id, else refresh-token hash. */
+    credentialFingerprint(authKey) {
+        const credentials = this.authStorage.get(authKey);
+        if (!credentials)
+            return undefined;
+        if (credentials.accountId)
+            return credentials.accountId;
+        const stable = credentials.refreshToken || credentials.accessToken;
+        return createHash("sha256").update(stable).digest("hex").slice(0, 16);
+    }
+    handleAuthMutation(authKey) {
+        const next = this.credentialFingerprint(authKey);
+        const prev = this.identityFingerprints.get(authKey);
+        if (next === prev)
+            return; // same-identity token rotation: not a routing change
+        if (next === undefined) {
+            this.identityFingerprints.delete(authKey);
+        }
+        else {
+            this.identityFingerprints.set(authKey, next);
+        }
+        this.bumpRoutingRevision();
     }
     getModelConfig() {
         return this.modelConfig;
@@ -84,6 +137,37 @@ export class ProviderRegistry {
             },
         };
     }
+    createGrokAuthAdapter(providerId) {
+        if (providerId !== "grok" || !this.authStorage.has("grok"))
+            return undefined;
+        let refreshPromise;
+        return {
+            getCredentials: () => this.authStorage.get("grok"),
+            isExpired: (_credentials, graceMs) => this.authStorage.isExpired("grok", graceMs),
+            refreshCredentials: async () => {
+                if (!refreshPromise) {
+                    refreshPromise = (async () => {
+                        const current = this.authStorage.get("grok");
+                        if (!current?.refreshToken) {
+                            throw new Error("Grok OAuth credentials are missing a refresh token. Run /login grok again.");
+                        }
+                        const refreshed = await refreshGrok(current.refreshToken);
+                        const next = {
+                            type: "oauth",
+                            accessToken: refreshed.accessToken,
+                            refreshToken: refreshed.refreshToken,
+                            expiresAt: refreshed.expiresAt,
+                        };
+                        this.authStorage.set("grok", next);
+                        return next;
+                    })().finally(() => {
+                        refreshPromise = undefined;
+                    });
+                }
+                return refreshPromise;
+            },
+        };
+    }
     getDefaultModel(providerId, authType = "api") {
         const customModels = this.modelConfig.getCustomModels(providerId);
         if (customModels.length > 0) {
@@ -95,6 +179,19 @@ export class ProviderRegistry {
         return listBuiltinModels(providerId)[0]?.id;
     }
     async prepareProvider(providerId) {
+        if (providerId === "grok" && this.authStorage.isExpired("grok")) {
+            const creds = this.authStorage.get("grok");
+            if (creds?.refreshToken) {
+                const refreshed = await refreshGrok(creds.refreshToken);
+                this.authStorage.set("grok", {
+                    type: "oauth",
+                    accessToken: refreshed.accessToken,
+                    refreshToken: refreshed.refreshToken,
+                    expiresAt: refreshed.expiresAt,
+                });
+            }
+            return;
+        }
         const authKey = this.resolveOAuthAuthKey(providerId);
         if ((providerId === "openai" || providerId === "openai-codex") && this.authStorage.isExpired(authKey)) {
             const creds = this.authStorage.get(authKey);
@@ -213,11 +310,13 @@ export class ProviderRegistry {
             providers.push(profile);
         }
         this.config.setProviders(providers);
+        this.bumpRoutingRevision();
         return true;
     }
     removeProvider(id) {
         const providers = this.config.getProviders().filter((p) => p.id !== id);
         this.config.setProviders(providers);
+        this.bumpRoutingRevision();
     }
     updateProviderKey(id, apiKey) {
         const providers = this.config.getProviders();
@@ -225,28 +324,92 @@ export class ProviderRegistry {
         if (p) {
             p.apiKey = apiKey;
             this.config.setProviders(providers);
+            this.bumpRoutingRevision();
         }
     }
     async listModels(provider) {
-        // 1. Custom models from models.json always take precedence
+        return (await this.discoverModels(provider)).models;
+    }
+    async discoverModels(provider, options = {}) {
+        const key = this.modelDiscoveryKey(provider);
+        const now = Date.now();
+        if (!options.forceRefresh) {
+            const cached = this.modelDiscoveryCache.get(key);
+            if (cached && cached.expiresAt > now) {
+                const result = { ...cached.result, source: "cache" };
+                const current = this.getConfigured().find((item) => item.id === provider.id);
+                if (!current || this.modelDiscoveryKey(current) === key) {
+                    this.applyDynamicDiscoveryMetadata(provider, result);
+                }
+                return result;
+            }
+            const inFlight = this.modelDiscoveryInFlight.get(key);
+            if (inFlight)
+                return inFlight;
+        }
+        else {
+            this.modelDiscoveryCache.delete(key);
+            // Do not let a superseded request's finally-handler remove this retry.
+            this.modelDiscoveryInFlight.delete(key);
+        }
+        const generation = (this.modelDiscoveryGeneration.get(provider.id) ?? 0) + 1;
+        this.modelDiscoveryGeneration.set(provider.id, generation);
+        let pending;
+        pending = this.performModelDiscovery(provider).then((result) => {
+            if (!this.isCurrentModelDiscovery(provider, key, generation)) {
+                return {
+                    models: this.localModelsForProvider(this.getConfigured().find((item) => item.id === provider.id) ?? provider),
+                    source: "fallback",
+                    authoritative: false,
+                    error: "Model catalog changed while it was refreshing.",
+                };
+            }
+            this.applyDynamicDiscoveryMetadata(provider, result);
+            const previous = this.lastDiscoveryMembership.get(key);
+            this.modelDiscoveryCache.set(key, {
+                result: { ...result, source: result.source === "cache" ? "remote" : result.source },
+                expiresAt: Date.now() + (result.error ? MODEL_DISCOVERY_FAILURE_TTL_MS : MODEL_DISCOVERY_SUCCESS_TTL_MS),
+                identityKey: this.discoveryIdentity(provider),
+            });
+            this.lastDiscoveryMembership.set(key, {
+                ids: result.models.map((model) => model.id),
+                authoritative: result.authoritative,
+            });
+            if (discoveryMembershipChanged(previous, result)) {
+                this.bumpRoutingRevision();
+            }
+            return result;
+        }).finally(() => {
+            if (this.modelDiscoveryInFlight.get(key) === pending) {
+                this.modelDiscoveryInFlight.delete(key);
+            }
+        });
+        this.modelDiscoveryInFlight.set(key, pending);
+        return pending;
+    }
+    async performModelDiscovery(provider) {
         const customModels = this.modelConfig.getCustomModels(provider.id);
         if (customModels.length > 0) {
-            return customModels;
+            return { models: customModels, source: "static", authoritative: true };
         }
-        // 2. Built-in provider dynamic/static lists
         if (provider.id === "openrouter") {
             try {
-                const res = await fetch("https://openrouter.ai/api/v1/models");
-                const data = (await res.json());
-                const models = data.data || [];
-                return models.map((m) => ({
-                    id: m.id,
-                    name: m.name || m.id,
-                    providerId: provider.id,
-                }));
+                const response = await fetch("https://openrouter.ai/api/v1/models");
+                if (!response.ok)
+                    throw new Error(`HTTP ${response.status}`);
+                const data = (await response.json());
+                return {
+                    models: (data.data ?? []).map((model) => ({
+                        id: model.id,
+                        name: model.name || model.id,
+                        providerId: provider.id,
+                    })),
+                    source: "remote",
+                    authoritative: true,
+                };
             }
-            catch {
-                // fall through to static
+            catch (error) {
+                return this.fallbackDiscovery(provider, error);
             }
         }
         if (provider.id === "google" && provider.protocol === "ai-sdk" && provider.apiKey) {
@@ -255,68 +418,182 @@ export class ProviderRegistry {
                     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 }));
-                }
+                return {
+                    models: descriptors.map((descriptor) => {
+                        const catalogEntry = getBuiltinModel("google", descriptor.id);
+                        return {
+                            id: descriptor.id,
+                            name: descriptor.name,
+                            providerId: provider.id,
+                            reasoningLevels: descriptor.reasoningLevels,
+                            defaultReasoningLevel: descriptor.defaultReasoningLevel ?? catalogEntry?.defaultReasoningLevel,
+                            contextWindow: descriptor.contextWindow ?? catalogEntry?.contextWindow,
+                        };
+                    }),
+                    source: "remote",
+                    authoritative: true,
+                };
             }
-            catch {
-                // fall through to static
+            catch (error) {
+                return this.fallbackDiscovery(provider, error);
             }
         }
         if (provider.id === "openai" && provider.authType === "oauth" && provider.apiKey) {
             try {
                 await this.prepareProvider(provider.id);
-                const currentProvider = this.getConfigured().find((p) => p.id === provider.id) || provider;
-                const descriptors = await fetchOpenAICodexModels({
+                const currentProvider = this.getConfigured().find((item) => item.id === provider.id) ?? provider;
+                const catalog = await fetchOpenAICodexModelCatalog({
                     baseURL: currentProvider.baseURL,
                     accessToken: currentProvider.apiKey,
                 });
-                const visible = descriptors.filter((d) => d.visibility !== "hide");
-                if (visible.length > 0) {
-                    for (const d of visible) {
-                        const catalogEntry = getBuiltinModel("openai-codex", d.id);
-                        registerDynamicModelMetadata({
-                            id: d.id,
-                            name: d.displayName || catalogEntry?.name || d.id,
-                            providerId: "openai-codex",
-                            reasoningLevels: d.reasoningLevels ?? catalogEntry?.reasoningLevels ?? ["off"],
-                            contextWindow: d.contextWindow ?? catalogEntry?.contextWindow,
-                            toolOutputTokenLimit: d.toolOutputTokenLimit ?? catalogEntry?.toolOutputTokenLimit,
-                        });
-                    }
-                    return visible.map((d) => ({
-                        id: d.id,
-                        name: d.displayName || d.id,
-                        providerId: provider.id,
-                    }));
+                if (catalog.status === "unavailable") {
+                    throw new Error("OpenAI Codex model catalog is unavailable.");
                 }
+                const visible = catalog.descriptors.filter((descriptor) => descriptor.visibility !== "hide");
+                return {
+                    models: visible.map((descriptor) => {
+                        const catalogEntry = getBuiltinModel("openai-codex", descriptor.id);
+                        return {
+                            id: descriptor.id,
+                            name: descriptor.displayName || catalogEntry?.name || descriptor.id,
+                            providerId: provider.id,
+                            reasoningLevels: descriptor.reasoningLevels ?? catalogEntry?.reasoningLevels,
+                            defaultReasoningLevel: descriptor.defaultReasoningLevel ?? catalogEntry?.defaultReasoningLevel,
+                            contextWindow: descriptor.contextWindow ?? catalogEntry?.contextWindow,
+                            useResponsesLite: descriptor.useResponsesLite ?? catalogEntry?.useResponsesLite,
+                            toolOutputTokenLimit: descriptor.toolOutputTokenLimit ?? catalogEntry?.toolOutputTokenLimit,
+                        };
+                    }),
+                    source: "remote",
+                    authoritative: true,
+                };
             }
-            catch {
-                // fall through to static
+            catch (error) {
+                return this.fallbackDiscovery(provider, error);
             }
-            return listBuiltinModels("openai-codex").map((model) => ({
-                id: model.id,
-                name: model.name,
-                providerId: provider.id,
-            }));
         }
-        return listBuiltinModels(provider.id).map((model) => ({
+        return {
+            models: this.localModelsForProvider(provider),
+            source: "static",
+            authoritative: true,
+        };
+    }
+    fallbackDiscovery(provider, error) {
+        return {
+            models: this.localModelsForProvider(provider),
+            source: "fallback",
+            authoritative: false,
+            error: modelDiscoveryError(error),
+        };
+    }
+    localModelsForProvider(provider) {
+        const customModels = this.modelConfig.getCustomModels(provider.id);
+        if (customModels.length > 0)
+            return customModels;
+        const catalogProviderId = provider.id === "openai" && provider.authType === "oauth"
+            ? "openai-codex"
+            : provider.id;
+        return listBuiltinModels(catalogProviderId).map((model) => ({
             id: model.id,
             name: model.name,
             providerId: provider.id,
+            reasoningLevels: model.reasoningLevels,
+            defaultReasoningLevel: model.defaultReasoningLevel,
+            contextWindow: model.contextWindow,
+            useResponsesLite: model.useResponsesLite,
+            toolOutputTokenLimit: model.toolOutputTokenLimit,
         }));
     }
+    discoveryIdentity(provider) {
+        if (provider.id === "openai" && provider.authType === "oauth") {
+            const credentials = this.authStorage.get(this.resolveOAuthAuthKey(provider.id));
+            return credentials?.accountId
+                || extractChatGptAccountId(provider.apiKey)
+                || "unknown-account";
+        }
+        if (provider.apiKey) {
+            return createHash("sha256").update(provider.apiKey).digest("hex").slice(0, 16);
+        }
+        return "anonymous";
+    }
+    modelDiscoveryKey(provider) {
+        return JSON.stringify([
+            provider.id,
+            normalizeBaseURL(provider.baseURL),
+            provider.authType ?? "api",
+            provider.protocol ?? "default",
+            this.discoveryIdentity(provider),
+        ]);
+    }
+    /**
+     * Read-only view of the cached discovery result for the provider's CURRENT
+     * configuration/identity (docs/model-routing-design.md §1.4). Returns
+     * undefined when nothing is cached or the cache has expired. `complete` is
+     * derived strictly: only a successful full remote catalog qualifies —
+     * never static or fallback results, whose internal `authoritative` flag
+     * this design does not trust.
+     */
+    getCachedDiscoverySnapshot(providerId) {
+        const provider = this.getConfigured().find((item) => item.id === providerId);
+        if (!provider)
+            return undefined;
+        const cached = this.modelDiscoveryCache.get(this.modelDiscoveryKey(provider));
+        if (!cached || cached.expiresAt <= Date.now())
+            return undefined;
+        return {
+            models: cached.result.models,
+            source: cached.result.source,
+            complete: cached.result.source === "remote" && cached.result.authoritative && !cached.result.error,
+            expiresAt: cached.expiresAt,
+            identityKey: cached.identityKey,
+        };
+    }
+    isCurrentModelDiscovery(provider, key, generation) {
+        if (this.modelDiscoveryGeneration.get(provider.id) !== generation)
+            return false;
+        const current = this.getConfigured().find((item) => item.id === provider.id);
+        return !current || this.modelDiscoveryKey(current) === key;
+    }
+    applyDynamicDiscoveryMetadata(provider, result) {
+        const dynamicProviderId = provider.id === "openai" && provider.authType === "oauth"
+            ? "openai-codex"
+            : provider.id === "google" && provider.protocol === "ai-sdk"
+                ? "google"
+                : undefined;
+        if (!dynamicProviderId)
+            return;
+        if (!result.authoritative) {
+            clearDynamicModelMetadata(dynamicProviderId);
+            return;
+        }
+        replaceDynamicModelMetadata(dynamicProviderId, result.models.map((model) => ({
+            id: model.id,
+            name: model.name,
+            providerId: dynamicProviderId,
+            // Empty means the remote model exists but declared no trusted effort metadata.
+            reasoningLevels: model.reasoningLevels ?? [],
+            defaultReasoningLevel: model.defaultReasoningLevel,
+            contextWindow: model.contextWindow,
+            useResponsesLite: model.useResponsesLite,
+            toolOutputTokenLimit: model.toolOutputTokenLimit,
+        })));
+    }
+}
+function modelDiscoveryError(error) {
+    if (error instanceof Error && error.message.trim())
+        return error.message;
+    return "Remote model catalog is unavailable.";
+}
+/** True when a discovery write changes the routing world: member ids or completeness. */
+function discoveryMembershipChanged(previous, next) {
+    if (!previous)
+        return true;
+    if (previous.authoritative !== next.authoritative)
+        return true;
+    const previousIds = new Set(previous.ids);
+    if (previousIds.size !== next.models.length)
+        return true;
+    return next.models.some((model) => !previousIds.has(model.id));
 }
 /**
  * Builtin defaults that were captured into stored profiles before a builtin's

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, normalizeInheritedThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
 export interface ProviderRequestConfig {
     effectiveThinkingLevel: ThinkingLevel;
     reasoningEffort?: ThinkingLevel;

package/dist/provider-transform.js

@@ -1,9 +1,9 @@
-import { getAvailableThinkingLevels, normalizeThinkingLevel } from "./variant/variant-resolver.js";
-export { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+import { getBuiltinModel } from "./model-catalog.js";
+import { getAvailableThinkingLevels, normalizeInheritedThinkingLevel, normalizeThinkingLevel } from "./variant/variant-resolver.js";
+export { getAvailableThinkingLevels, getDefaultThinkingLevel, isThinkingOnlyLevels, isThinkingOnlyModel, isThinkingToggleModel, normalizeInheritedThinkingLevel, 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) {
@@ -15,10 +15,32 @@ function isFireworksKimi(providerId, modelId) {
 export function resolveProviderRequestConfig(providerId, modelId, requestedLevel) {
     const supportedLevels = getAvailableThinkingLevels(providerId, modelId);
     const effectiveThinkingLevel = normalizeThinkingLevel(requestedLevel, supportedLevels);
-    // ChatGPT OAuth via openai-codex currently rejects explicit reasoning params for this account path.
-    // Keep the session/UI state, but don't send reasoning flags on this provider until the protocol is clearer.
     if (providerId === "openai-codex") {
-        return { effectiveThinkingLevel };
+        const model = getBuiltinModel(providerId, modelId);
+        if (!model || model.reasoningLevels.length === 0) {
+            return { effectiveThinkingLevel: "off" };
+        }
+        // Provider serialization is the final defensive boundary. Upstream model
+        // selection validates explicit choices, while inherited stale state falls
+        // back to the model's declared default here rather than leaking an invalid
+        // effort to the ChatGPT Responses endpoint.
+        const codexThinkingLevel = normalizeInheritedThinkingLevel(providerId, modelId, requestedLevel);
+        return {
+            effectiveThinkingLevel: codexThinkingLevel,
+            reasoningEffort: codexThinkingLevel !== "off" && model.reasoningLevels.includes(codexThinkingLevel)
+                ? codexThinkingLevel
+                : undefined,
+        };
+    }
+    // Grok's CLI chat proxy is OpenAI-compatible; effort rides in the body as
+    // `reasoning_effort`, and reasoning arrives back as `reasoning_content`.
+    if (providerId === "grok") {
+        return {
+            effectiveThinkingLevel,
+            extraBody: effectiveThinkingLevel === "off"
+                ? undefined
+                : { reasoning_effort: effectiveThinkingLevel },
+        };
     }
     if (isFireworksKimi(providerId, modelId)) {
         return {
@@ -99,12 +121,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 +137,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 +147,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.d.ts

@@ -4,6 +4,7 @@
  * Works with OpenRouter, OpenAI, DeepSeek, Google, Groq, Together, and local OpenAI-compatible endpoints.
  */
 import { type OpenAICodexAuthAdapter } from "./provider-openai-codex.js";
+import { type GrokAuthAdapter } from "./provider-grok.js";
 import type { ProviderProtocol } from "./model-catalog.js";
 import type { Provider, ProviderMessage, StreamChunk, ThinkingLevel } from "./types.js";
 type ReasoningContentEcho = "tool_calls" | "all" | "none" | "minimax";
@@ -29,6 +30,8 @@ export interface ProviderInstanceOptions {
     protocol?: ProviderProtocol;
     /** Dynamic OAuth access-token loader/refresh hook for ChatGPT Codex requests. */
     openAICodexAuth?: OpenAICodexAuthAdapter;
+    /** Dynamic OAuth access-token loader/refresh hook for Grok subscription requests. */
+    grokAuth?: GrokAuthAdapter;
 }
 export declare function createUnavailableProvider(message: string): Provider;
 export declare function createProviderInstance(options: ProviderInstanceOptions): Provider;

package/dist/provider.js

@@ -9,6 +9,8 @@ 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 { buildGrokSubscriptionHeaders, createGrokSubscriptionFetch, isGrokSubscriptionBaseUrl, } from "./provider-grok.js";
+import { getChatGptFetch } from "./network/chatgpt-transport.js";
 import { createProviderProtocolArtifactFilter } from "./provider-artifacts.js";
 import { resolveProviderRequestConfig } from "./provider-transform.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
@@ -95,10 +97,22 @@ export function createProviderInstance(options) {
             auth: options.openAICodexAuth,
         });
     }
+    // Grok subscription rides the generic chat-completions path but needs the
+    // CLI identity headers the proxy gates on, plus a fetch that keeps the
+    // short-lived OAuth bearer fresh (and proxy-aware) across long sessions.
+    const grokSubscription = options.providerId === "grok" || isGrokSubscriptionBaseUrl(options.baseURL);
     const client = new OpenAI({
         apiKey: options.apiKey,
         baseURL: options.baseURL,
         timeout: resolveRequestTimeoutMs(process.env.BUBBLE_PROVIDER_REQUEST_TIMEOUT_MS),
+        ...(grokSubscription
+            ? {
+                defaultHeaders: buildGrokSubscriptionHeaders(),
+                fetch: (options.grokAuth
+                    ? createGrokSubscriptionFetch(options.grokAuth)
+                    : getChatGptFetch()),
+            }
+            : {}),
     });
     const fallbackModel = "gpt-4o";
     async function* streamChat(messages, chatOptions) {

package/dist/session-types.d.ts

@@ -1,5 +1,17 @@
 import type { AssistantMessage, Message, ThinkingLevel, Todo, ToolCall, ToolMessage, UserMessage } from "./types.js";
 import type { GoalState } from "./goal/store.js";
+export interface ExternalRuntimeSessionMetadata {
+    /** External agent runtime that owns the conversational state. */
+    id: "grok";
+    /** Opaque ACP session identifier. Never contains credentials. */
+    sessionId?: string;
+    /** Server-selected model, when the runtime reports one. */
+    modelId?: string;
+    /** Reasoning effort selected for the external runtime. */
+    reasoningEffort?: ThinkingLevel;
+    /** Exact external runtime version used to create the session. */
+    version?: string;
+}
 export interface SessionMetadata {
     model?: string;
     thinkingLevel?: ThinkingLevel;
@@ -12,8 +24,14 @@ export interface SessionMetadata {
     promptCacheKey?: string;
     /** Persisted autonomous goal (see src/goal). Survives /session resume. */
     goal?: GoalState;
+    /**
+     * External runtimes keep their own conversation state. Bubble persists only
+     * the opaque session binding and a UI transcript mirror; it never stores the
+     * runtime's OAuth credentials.
+     */
+    externalRuntime?: ExternalRuntimeSessionMetadata;
 }
-export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch" | "conversation_clear";
+export type SessionMarkerKind = "model_switch" | "provider_switch" | "thinking_level_switch" | "skill_activated" | "mode_switch" | "runtime_switch" | "conversation_clear";
 interface BaseSessionLogEntry {
     id: string;
     timestamp: number;