@bubblebrain-ai/bubble 0.0.60 → 0.0.62

package/dist/model-catalog.js

@@ -62,8 +62,16 @@ const KIMI_THINKING_ONLY_LEVELS = ["medium"];
 // verified against the live endpoint: low spent 92 reasoning tokens on a task
 // where high spent 1310. Thinking is disableable on k3 (thinking.type
 // "disabled"); the 256k variant exposes effort only, so it has no "off".
+// K3.1 Pro (and its highspeed slot) is effort-only too: GET /coding/v1/models
+// reports reasoning.type "only" and the endpoint 400s on thinking disabled.
+// The default of "high" is Bubble's choice and matches the coding endpoint's
+// reported default; Moonshot's open platform defaults to max server-side.
 const KIMI_K3_LEVELS = ["off", "low", "high", "max"];
 const KIMI_K3_EFFORT_ONLY_LEVELS = ["low", "high", "max"];
+// DashScope's Moonshot passthrough (kimi/ ids) documents K3 as thinking-only
+// with reasoning_effort "max" as its sole value. Not live-verified: the probing
+// account has the passthrough product disabled.
+const KIMI_PASSTHROUGH_K3_LEVELS = ["max"];
 // DeepSeek V4 defaults to thinking/high, but the OpenAI-compatible API also
 // supports disabling thinking and selecting low/high/max effort explicitly.
 const DEEPSEEK_V4_LEVELS = ["off", "low", "high", "max"];
@@ -88,6 +96,9 @@ const ANTHROPIC_CHAT_LEVELS = ["off"];
 // Grok 4.5 exposes low/medium/high effort with no "off" (thinking always on);
 // the composer model declares no effort support at all.
 const GROK_45_LEVELS = ["low", "medium", "high"];
+// Gemini 4 documents only low/medium (default)/high. Verified live on
+// 2026-10-13: thinkingLevel=minimal returns 400, so there is no off/minimal.
+const GEMINI_4_LEVELS = ["low", "medium", "high"];
 const GEMINI_3_LEVELS = ["low", "medium", "high"];
 const GEMINI_3_FLASH_LEVELS = ["minimal", "low", "medium", "high"];
 // Verified against the native API on 2026-09-02: Gemini 3.7/3.8 Flash reject
@@ -149,6 +160,9 @@ export const BUILTIN_MODELS = [
     // list via fetchGeminiModels (GET /v1beta/models, newest five). Gemini 3
     // thinking support varies by release: 3.7/3.8 Flash support off/low/medium/high
     // while older Flash releases expose minimal/low/medium/high.
+    // Gemini 4 Argon: 1,048,576-token window shared by input, thinking and output.
+    // https://ai.google.dev/gemini-api/docs/models/gemini-4-argon
+    { id: "gemini-4-argon", name: "Gemini 4 Argon", providerId: "google", tier: "strong", reasoningLevels: GEMINI_4_LEVELS, defaultReasoningLevel: "medium", contextWindow: 1048576 },
     { id: "gemini-3.8-flash", name: "Gemini 3.8 Flash", providerId: "google", tier: "fast", reasoningLevels: GEMINI_37_38_FLASH_LEVELS, contextWindow: 1048576 },
     { id: "gemini-3.7-flash", name: "Gemini 3.7 Flash", providerId: "google", tier: "fast", reasoningLevels: GEMINI_37_38_FLASH_LEVELS, contextWindow: 1048576 },
     { id: "gemini-3.5-flash", name: "Gemini 3.5 Flash", providerId: "google", tier: "fast", reasoningLevels: GEMINI_3_FLASH_LEVELS, contextWindow: 1048576 },
@@ -182,6 +196,20 @@ export const BUILTIN_MODELS = [
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "qwen3.6-plus", name: "Qwen3.6 Plus", providerId: "alibaba", tier: "balanced", reasoningLevels: ["off"], contextWindow: 1048576 },
     { id: "qwen3.7-max", name: "Qwen3.7 Max", providerId: "alibaba", tier: "strong", reasoningLevels: ["off"], contextWindow: 1048576 },
+    // DashScope Kimi, first-party ids (probed 2026-10-26: kimi-k3 tiers track
+    // upstream, k2.5/k2.6 default to thinking off, K2.7 Code always thinks).
+    { id: "kimi-k3", name: "Kimi K3", providerId: "alibaba", tier: "strong", reasoningLevels: KIMI_K3_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "alibaba", tier: "strong", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
+    { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "alibaba", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
+    { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "alibaba", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
+    // Moonshot passthrough ids, per DashScope's Kimi doc: K3 is max-only, K2.7
+    // Code always thinks, K2.6 toggles via enable_thinking.
+    { id: "kimi/kimi-k3.1-pro", name: "Kimi K3.1 Pro", providerId: "alibaba", tier: "strong", reasoningLevels: KIMI_PASSTHROUGH_K3_LEVELS, defaultReasoningLevel: "max", contextWindow: 1048576 },
+    { id: "kimi/kimi-k3.1-pro-highspeed", name: "Kimi K3.1 Pro Highspeed", providerId: "alibaba", tier: "fast", reasoningLevels: KIMI_PASSTHROUGH_K3_LEVELS, defaultReasoningLevel: "max", contextWindow: 1048576 },
+    { id: "kimi/kimi-k3", name: "Kimi K3 (Moonshot)", providerId: "alibaba", tier: "strong", reasoningLevels: KIMI_PASSTHROUGH_K3_LEVELS, defaultReasoningLevel: "max", contextWindow: 1048576 },
+    { id: "kimi/kimi-k2.7-code", name: "Kimi K2.7 Code (Moonshot)", providerId: "alibaba", tier: "strong", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
+    { id: "kimi/kimi-k2.7-code-highspeed", name: "Kimi K2.7 Code Highspeed", providerId: "alibaba", tier: "fast", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
+    { id: "kimi/kimi-k2.6", name: "Kimi K2.6 (Moonshot)", providerId: "alibaba", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     // Bailian token plan (GET /models on the plan endpoint, probed 2026-08-04).
     // Image/TTS entries from that list are omitted — this is a text agent.
     { id: "qwen3.8-max", name: "Qwen3.8 Max", providerId: "bailian-token-plan", tier: "strong", reasoningLevels: BAILIAN_FULL_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
@@ -214,17 +242,24 @@ export const BUILTIN_MODELS = [
     { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "moonshot-cn", tier: "strong", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.7-code-highspeed", name: "Kimi K2.7 Code Highspeed", providerId: "moonshot-cn", tier: "fast", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k3", name: "Kimi K3", providerId: "moonshot-cn", tier: "strong", reasoningLevels: KIMI_K3_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "kimi-k3.1-pro", name: "Kimi K3.1 Pro", providerId: "moonshot-cn", tier: "strong", reasoningLevels: KIMI_K3_EFFORT_ONLY_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "kimi-k3.1-pro-highspeed", name: "Kimi K3.1 Pro Highspeed", providerId: "moonshot-cn", tier: "fast", reasoningLevels: KIMI_K3_EFFORT_ONLY_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "moonshot-cn", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "moonshot-intl", tier: "strong", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.7-code-highspeed", name: "Kimi K2.7 Code Highspeed", providerId: "moonshot-intl", tier: "fast", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k3", name: "Kimi K3", providerId: "moonshot-intl", tier: "strong", reasoningLevels: KIMI_K3_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "kimi-k3.1-pro", name: "Kimi K3.1 Pro", providerId: "moonshot-intl", tier: "strong", reasoningLevels: KIMI_K3_EFFORT_ONLY_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "kimi-k3.1-pro-highspeed", name: "Kimi K3.1 Pro Highspeed", providerId: "moonshot-intl", tier: "fast", reasoningLevels: KIMI_K3_EFFORT_ONLY_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "kimi-k2.6", name: "Kimi K2.6", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     { id: "kimi-k2.5", name: "Kimi K2.5", providerId: "moonshot-intl", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 256000 },
     // Kimi for Coding serves plan-slot ids (verified via GET /coding/v1/models):
-    // k3, k3-256k, kimi-for-coding, kimi-for-coding-highspeed.
+    // k3, k3-256k, k3.1-pro, k3.1-pro-highspeed, kimi-for-coding,
+    // kimi-for-coding-highspeed.
     { id: "k3", name: "Kimi K3", providerId: "kimi-for-coding", tier: "strong", reasoningLevels: KIMI_K3_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "k3-256k", name: "Kimi K3 256K", providerId: "kimi-for-coding", tier: "strong", reasoningLevels: KIMI_K3_EFFORT_ONLY_LEVELS, defaultReasoningLevel: "high", contextWindow: 262144 },
+    { id: "k3.1-pro", name: "Kimi K3.1 Pro", providerId: "kimi-for-coding", tier: "strong", reasoningLevels: KIMI_K3_EFFORT_ONLY_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
+    { id: "k3.1-pro-highspeed", name: "Kimi K3.1 Pro Highspeed", providerId: "kimi-for-coding", tier: "fast", reasoningLevels: KIMI_K3_EFFORT_ONLY_LEVELS, defaultReasoningLevel: "high", contextWindow: 1048576 },
     { id: "kimi-for-coding", name: "Kimi for Coding", providerId: "kimi-for-coding", tier: "strong", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-for-coding-highspeed", name: "Kimi for Coding Highspeed", providerId: "kimi-for-coding", tier: "fast", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },
     { id: "kimi-k2.7-code", name: "Kimi K2.7 Code", providerId: "kimi-for-coding", tier: "strong", reasoningLevels: KIMI_THINKING_ONLY_LEVELS, contextWindow: 262144 },

package/dist/model-pricing.js

@@ -64,6 +64,23 @@ export const MODEL_PRICING_OVERRIDES = [
             outputPerMillion: 7.5,
         },
     })),
+    // Gemini 4 Argon introductory pricing through 2026-11-30; standard rates from
+    // 2026-12-01. Implicit caching only (95% off input), so no cache-write rate.
+    // https://ai.google.dev/gemini-api/docs/pricing
+    {
+        providerId: "google",
+        modelId: "gemini-4-argon",
+        currency: "USD",
+        inputCacheHitPerMillion: 0.1,
+        inputCacheMissPerMillion: 2,
+        outputPerMillion: 10,
+        effectiveUntil: "2026-12-01T00:00:00Z",
+        original: {
+            inputCacheHitPerMillion: 0.2,
+            inputCacheMissPerMillion: 4,
+            outputPerMillion: 20,
+        },
+    },
     {
         providerId: "deepseek",
         modelId: "deepseek-flash",

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

@@ -50,7 +50,8 @@ export declare function fetchGeminiModels(options: {
 }): 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.
+ * then newest version first, flagship (pro/argon) 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. */

package/dist/provider-ai-sdk.js

@@ -137,17 +137,23 @@ function buildCallOptions(messages, chatOptions, providerOptions) {
     };
 }
 /**
- * Gemini 3 models take a graded thinking_level; 2.5-era models take a token
+ * 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/ultra clamp to high.
  */
 function buildGoogleThinkingOptions(modelId, level) {
     if (!level)
         return undefined;
+    const version = geminiVersion(modelId);
+    // Gemini 4 accepts only low/medium/high: MINIMAL is a 400 and thinkingBudget
+    // is undocumented. Side calls (titles, compaction) request "off" by default,
+    // so floor those at low rather than sending a value the API rejects.
+    if (version >= 4 && (level === "off" || level === "minimal"))
+        level = "low";
     if (level === "off")
         return { thinkingConfig: { thinkingBudget: 0 } };
     const clamped = level === "xhigh" || level === "max" || level === "ultra" ? "high" : level;
-    if (modelId.includes("gemini-3")) {
+    if (version >= 3) {
         return { thinkingConfig: { thinkingLevel: clamped, includeThoughts: true } };
     }
     const budgets = { minimal: 512, low: 2048, medium: 8192, high: 24576 };
@@ -459,10 +465,13 @@ export async function fetchGeminiModels(options) {
 }
 /**
  * Ranking: one entry per (version, tier) family — GA ids beat dated previews —
- * then newest version first, pro before flash before flash-lite, top N.
+ * then newest version first, flagship (pro/argon) before flash before
+ * flash-lite, top N.
  */
 export function selectLatestGeminiModels(entries, limit = 5) {
-    const TIER_RANK = { pro: 0, flash: 1, "flash-lite": 2 };
+    // Gemini 4 introduced named flagship tiers (gemini-4-argon). Unknown names
+    // stay excluded rather than guessing whether they are text models.
+    const TIER_RANK = { argon: 0, pro: 0, flash: 1, "flash-lite": 2 };
     const candidates = [];
     for (const entry of entries) {
         const id = (entry.name ?? "").replace(/^models\//, "");
@@ -472,21 +481,23 @@ export function selectLatestGeminiModels(entries, limit = 5) {
             continue;
         if (entry.supportedGenerationMethods && !entry.supportedGenerationMethods.includes("generateContent"))
             continue;
-        const match = /^gemini-(\d+(?:\.\d+)?)-(pro|flash)(-lite)?/.exec(id);
+        const match = /^gemini-(\d+(?:\.\d+)?)-(argon|pro|flash)(-lite)?/.exec(id);
         if (!match)
             continue;
+        const tier = `${match[2]}${match[3] ?? ""}`;
         candidates.push({
             id,
             entry,
             version: Number.parseFloat(match[1]),
-            tierRank: TIER_RANK[`${match[2]}${match[3] ?? ""}`] ?? 3,
+            tier,
+            tierRank: TIER_RANK[tier] ?? 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 key = `${candidate.version}-${candidate.tier}`;
         const current = families.get(key);
         if (!current
             || (current.isPreview && !candidate.isPreview)
@@ -502,13 +513,19 @@ export function selectLatestGeminiModels(entries, limit = 5) {
         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" } : {}),
+        // Argon defaults to Google's recommended medium via the catalog.
+        ...(candidate.tier === "pro" ? { defaultReasoningLevel: "high" } : {}),
     }));
 }
+function geminiVersion(modelId) {
+    return Number.parseFloat(/^gemini-(\d+(?:\.\d+)?)/.exec(modelId)?.[1] ?? "0");
+}
 /** 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 version = geminiVersion(modelId);
     const isPro = modelId.includes("-pro");
+    if (version >= 4)
+        return ["low", "medium", "high"];
     // Live probes show 3.7 and 3.8 Flash share this newer ladder. Keep the
     // exception bounded to verified releases instead of guessing for 3.9+.
     if (!isPro && (version === 3.7 || version === 3.8)) {

package/dist/provider-transform.js

@@ -12,7 +12,17 @@ const KIMI_K27_FAMILY = new Set([
 // K3 takes OpenAI-style reasoning_effort (low/high/max, no "medium"); "off"
 // disables thinking via top-level thinking.type. Verified live: effort changes
 // reasoning-token spend, and nested extra_body.thinking is ignored server-side.
-const KIMI_K3_FAMILY = new Set(["k3", "k3-256k", "kimi-k3"]);
+// K3.1 Pro takes the same body but is thinking-only (thinking.type "disabled"
+// 400s); its catalog levels have no "off", so the disabled branch never fires.
+const KIMI_K3_FAMILY = new Set([
+    "k3",
+    "k3-256k",
+    "kimi-k3",
+    "k3.1-pro",
+    "k3.1-pro-highspeed",
+    "kimi-k3.1-pro",
+    "kimi-k3.1-pro-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"]);
@@ -22,6 +32,21 @@ const DEEPSEEK_V4_FAMILY = new Set([
     "deepseek-v4-flash-vision-exp",
     "deepseek-v4-pro",
 ]);
+// DashScope serves Kimi first-party ("kimi-k3") and as a Moonshot passthrough
+// under a vendor prefix ("kimi/kimi-k3.1-pro"). The two take different thinking
+// controls; the passthrough contract comes from DashScope's Kimi doc
+// (help.aliyun.com/zh/model-studio/kimi-api-by-moonshot-ai): its K3 ids accept
+// reasoning_effort "max" only, K2.6 toggles via enable_thinking, and the K2.7
+// Code ids take no thinking parameter at all.
+const ALIBABA_KIMI_PASSTHROUGH_EFFORT = new Set([
+    "kimi/kimi-k3",
+    "kimi/kimi-k3.1-pro",
+    "kimi/kimi-k3.1-pro-highspeed",
+]);
+const ALIBABA_KIMI_PASSTHROUGH_TOGGLE = new Set(["kimi/kimi-k2.6"]);
+function isAlibabaKimi(providerId, modelId) {
+    return providerId === "alibaba" && /^(kimi\/)?kimi-/i.test(modelId);
+}
 function isFireworksKimi(providerId, modelId) {
     const model = modelId.toLowerCase();
     return providerId === "fireworks" && (model.includes("kimi")
@@ -120,6 +145,31 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
             },
         };
     }
+    // DashScope-hosted Kimi: the server rejects any temperature but the locked
+    // one ("Parameter 'temperature'=0.2 is not supported for kimi-k3 model").
+    // First-party ids take reasoning_effort validated against DashScope's own
+    // list, where "none" disables thinking (verified on kimi-k3/k2.5/k2.6; K2.7
+    // Code stays in thinking mode whatever is sent). Passthrough ids follow the
+    // documented contract above. Models missing from the catalog get no
+    // thinking field, so a thinking-only newcomer is never switched off.
+    if (isAlibabaKimi(providerId, modelId)) {
+        let extraBody;
+        if (ALIBABA_KIMI_PASSTHROUGH_EFFORT.has(modelId)) {
+            extraBody = { reasoning_effort: effectiveThinkingLevel };
+        }
+        else if (ALIBABA_KIMI_PASSTHROUGH_TOGGLE.has(modelId)) {
+            extraBody = { enable_thinking: effectiveThinkingLevel !== "off" };
+        }
+        else if (!modelId.toLowerCase().startsWith("kimi/") && getBuiltinModel(providerId, modelId)) {
+            extraBody = { reasoning_effort: effectiveThinkingLevel === "off" ? "none" : effectiveThinkingLevel };
+        }
+        return {
+            effectiveThinkingLevel,
+            omitTemperature: true,
+            reasoningContentEcho: "tool_calls",
+            extraBody,
+        };
+    }
     if (providerId === "stepfun-api") {
         return { effectiveThinkingLevel, reasoningContentEcho: "none" };
     }
@@ -223,7 +273,12 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
                 },
             };
         }
-        return { effectiveThinkingLevel };
+        // Unlisted Moonshot models: every generation since K2.5 locks temperature
+        // and 400s on any other value, so let the server pick its own default.
+        // Pre-K2.5 ids (moonshot-v1, kimi-k2-*-preview) are deliberately not
+        // supported: the endpoints no longer list them, and they would merely lose
+        // the 0.2 default here rather than fail.
+        return { effectiveThinkingLevel, omitTemperature: true };
     }
     if (providerId === "openai"
         || providerId === "google"

package/dist/tui/composer-autocomplete.js

@@ -1,6 +1,6 @@
 import { CombinedAutocompleteProvider, } from "@bubblebrain-ai/pi-tui";
 import { BUILTIN_PROVIDERS, encodeModel, isUserVisibleProvider, } from "../provider-registry.js";
-import { getAvailableThinkingLevels, isThinkingToggleModel, normalizeThinkingLevel, } from "../provider-transform.js";
+import { getAvailableThinkingLevels, isThinkingOnlyLevels, isThinkingToggleModel, normalizeThinkingLevel, } from "../provider-transform.js";
 import { GROK_SUBSCRIPTION_PROVIDER_ID, isGrokSubscriptionProviderId, } from "../external-runtime/grok-provider.js";
 import { discoverModelProviderGroups, getVisibleModelProviders, localModelsForProvider, } from "./model-picker-data.js";
 const MODEL_COMMAND_PREFIX = "/model ";
@@ -109,9 +109,14 @@ export function buildModelAutocompleteItems(groups, argumentPrefix = "", current
     for (const selection of selections) {
         const { provider, model, value, levels } = selection;
         const label = model.name || model.id;
-        const description = label === model.id
-            ? provider.name
-            : `${provider.name} · ${model.id}`;
+        // A model with one fixed grade skips the effort step, so name the grade
+        // here or the user never learns which effort it runs at.
+        const fixedEffort = levels.length === 1 && levels[0] !== "off" && !isThinkingOnlyLevels(levels)
+            ? `${levels[0]} effort`
+            : undefined;
+        const description = [provider.name, label === model.id ? undefined : model.id, fixedEffort]
+            .filter(Boolean)
+            .join(" · ");
         const searchable = `${value} ${label} ${description}`.toLowerCase();
         if (query && !searchable.includes(query))
             continue;

package/dist/variant/variant-resolver.d.ts

@@ -2,9 +2,11 @@ import type { ThinkingLevel } from "../types.js";
 export declare function getAvailableThinkingLevels(providerId: string, modelId: string): ThinkingLevel[];
 export declare function getDefaultThinkingLevel(providerId: string, modelId: string): ThinkingLevel;
 /**
- * A single non-"off" level means the model is always in thinking mode with no
+ * A lone "medium" means the model is always in thinking mode with no
  * user-facing grades (e.g. kimi-k2.7-code) — the level value is an internal
- * placeholder and must not be shown to the user as an effort grade.
+ * placeholder and must not be shown to the user as an effort grade. Any other
+ * lone level (e.g. DashScope's max-only Kimi K3) is a real fixed grade that
+ * the provider sends verbatim, so it is shown.
  */
 export declare function isThinkingOnlyLevels(levels: readonly ThinkingLevel[]): boolean;
 export declare function isThinkingOnlyModel(providerId?: string, modelId?: string): boolean;

package/dist/variant/variant-resolver.js

@@ -1,7 +1,7 @@
 import { getBuiltinModel, getModelDefaultReasoningLevel } from "../model-catalog.js";
 import { clampThinkingLevel } from "./thinking-level.js";
-const KIMI_TOGGLE_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding"]);
-const KIMI_THINKING_TOGGLE_MODELS = new Set(["kimi-k2.5", "kimi-k2.6"]);
+const KIMI_TOGGLE_PROVIDER_IDS = new Set(["moonshot-cn", "moonshot-intl", "kimi-for-coding", "alibaba"]);
+const KIMI_THINKING_TOGGLE_MODELS = new Set(["kimi-k2.5", "kimi-k2.6", "kimi/kimi-k2.6"]);
 export function getAvailableThinkingLevels(providerId, modelId) {
     return getBuiltinModel(providerId, modelId)?.reasoningLevels ?? ["off"];
 }
@@ -13,12 +13,14 @@ export function getDefaultThinkingLevel(providerId, modelId) {
     return levels.includes("medium") ? "medium" : levels[0] || "off";
 }
 /**
- * A single non-"off" level means the model is always in thinking mode with no
+ * A lone "medium" means the model is always in thinking mode with no
  * user-facing grades (e.g. kimi-k2.7-code) — the level value is an internal
- * placeholder and must not be shown to the user as an effort grade.
+ * placeholder and must not be shown to the user as an effort grade. Any other
+ * lone level (e.g. DashScope's max-only Kimi K3) is a real fixed grade that
+ * the provider sends verbatim, so it is shown.
  */
 export function isThinkingOnlyLevels(levels) {
-    return levels.length === 1 && levels[0] !== "off";
+    return levels.length === 1 && levels[0] === "medium";
 }
 export function isThinkingOnlyModel(providerId = "", modelId = "") {
     return isThinkingOnlyLevels(getAvailableThinkingLevels(providerId, modelId));

package/package.json

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