dsh-plugin-subscription-oauth 0.8.14 → 0.8.16

package/lib/providers/grok.js

@@ -268,15 +268,152 @@ const IMAGE_MODEL = /(?:^|[-_/])(?:image|imagine|draw|pic|photo)(?:[-_/]|$)/i;
 export function isImageModel(id) {
     return IMAGE_MODEL.test(id);
 }
-/** Model ids that are the fast/lightspeed variant of a base model, matched per base. */
-const FAST_VARIANT = /(?:^|[-_])(?:fast|lightspeed|turbo|quick)$/i;
+/**
+ * Model ids that are the fast/lightspeed variant of a base model, matched per base.
+ *
+ * The vocabulary is the providers' own: xAI says `fast` (`grok-4.7-build-fast`), the
+ * Claude/Codex world says `lightspeed` or `turbo`, and Kimi says `highspeed`
+ * (`kimi-for-coding-highspeed`). A word has to stand on its own, so `highspeed` never
+ * matches inside another word.
+ */
+const FAST_VARIANT = /(?:^|[-_@])(?:fast|lightspeed|turbo|quick|highspeed)(?=[-_@]|$)/i;
 /** True when a model id names a fast/lightspeed variant of a base model. */
 export function isFastVariant(id) {
     return FAST_VARIANT.test(id);
 }
-/** The base model id a fast variant belongs to (`grok-4.7-fast` → `grok-4.7`). */
+/**
+ * Every prefix of one model id, longest first, down to its first token.
+ *
+ * `grok-4.7-build-fast` → [`grok-4.7-build`, `grok-4.7`, `grok`]. A fast variant pairs
+ * with the longest prefix that is itself a listed model id, which is how
+ * `grok-4.7-build-fast` lands on `grok-4.7` (its own prefix `grok-4.7-build` is not a
+ * model) instead of inventing a base that no catalog row serves.
+ *
+ * @param id - model id.
+ * @returns the candidate bases, longest first.
+ */
+export function baseCandidatesOf(id) {
+    const out = [];
+    let at = id.length;
+    while (at > 0) {
+        at = id.lastIndexOf('-', at - 1);
+        if (at <= 0)
+            break;
+        out.push(id.slice(0, at));
+    }
+    return out;
+}
+/**
+ * The base model id a fast variant belongs to, derived only from its own name.
+ *
+ * The fast token is removed, then any trailing generation qualifier (`build`, `beta`,
+ * `rc`, …) left behind by that removal, then any `@Nk` context suffix. What remains is
+ * the base (`grok-4.7-build-fast@500k` → `grok-4.7`, `kimi-for-coding-highspeed` →
+ * `kimi-for-coding`). Whether the base is a real catalog row is the index's job, not
+ * this function's.
+ */
 export function baseModelOf(id) {
-    return id.replace(FAST_VARIANT, '');
+    return id
+        .replace(FAST_VARIANT, '')
+        .replace(/@\d+k$/i, '')
+        .replace(/[-_]$/, '')
+        .replace(/-(?:build|beta|alpha|rc|stable)$/i, '')
+        .replace(/[-_]$/, '');
+}
+/**
+ * The fast variant of one picker row, from either side of the pair.
+ *
+ * Shared by every route that discovers fast ids, so the composer's quick-mode button
+ * behaves the same wherever a fast model is identifiable: it finds the pair when asked
+ * about the base row, and when asked about the fast id itself — which is what the
+ * selection becomes once the mode is on — so it can switch back off again.
+ */
+export class FastVariantIndex {
+    byBase = new Map();
+    rowOfVariant = new Map();
+    knownIds = new Set();
+    /** Forget every pair and every known id, before re-reading a catalog. */
+    clear() {
+        this.byBase.clear();
+        this.rowOfVariant.clear();
+        this.knownIds.clear();
+    }
+    /**
+     * Record one id the catalog listed.
+     *
+     * Listed ids are what a variant may pair with: the pair is the longest listed prefix
+     * of the variant's own name, so nothing is invented that no row actually serves.
+     *
+     * @param id - a wire id from a catalog.
+     */
+    noteListed(id) {
+        this.knownIds.add(id);
+    }
+    /**
+     * Pair one fast id with its base, purely from its own name.
+     *
+     * Every listed prefix of the id is a candidate base, longest first; the first one
+     * that is itself a listed model wins. No curated alias or hardcoded map is needed:
+     * a provider that names its variants after the base model pairs them automatically.
+     *
+     * @param id - a wire id the catalog named.
+     * @returns the base id, or undefined when no listed prefix names one.
+     */
+    pair(id) {
+        if (!isFastVariant(id))
+            return undefined;
+        for (const base of baseCandidatesOf(id)) {
+            if (this.knownIds.has(base))
+                return base;
+        }
+        return undefined;
+    }
+    /**
+     * Record one id, if it names a fast variant.
+     *
+     * The first variant named for a row wins: a catalog that lists two spellings of the
+     * same variant (`kimi-for-coding-highspeed` and `kimi-k2.7-code-highspeed`) offers
+     * one button, and the earlier entry is the more specific one.
+     *
+     * @param id - a wire id from a catalog.
+     * @param rowOf - maps a base id to the picker row that serves it, when the catalog
+     *   spells the base differently from the variant's own prefix.
+     */
+    note(id, rowOf) {
+        if (!isFastVariant(id))
+            return;
+        const base = baseModelOf(id);
+        if (base.length === 0)
+            return;
+        const row = rowOf?.(base) ?? base;
+        if (!this.byBase.has(row))
+            this.byBase.set(row, id);
+        if (!this.rowOfVariant.has(id))
+            this.rowOfVariant.set(id, row);
+    }
+    /** The fast variant's wire id for one picker row, when the catalog named one. */
+    variantOf(baseId) {
+        return this.byBase.get(baseId);
+    }
+    /** The pair one picker id belongs to, from either side. */
+    pairOf(id) {
+        const direct = this.byBase.get(id);
+        if (direct !== undefined)
+            return { baseId: id, wireId: direct };
+        const row = this.rowOfVariant.get(id);
+        return row === undefined ? undefined : { baseId: row, wireId: id };
+    }
+}
+/** A context-size suffix like `@500k` on a model id. */
+const CONTEXT_SUFFIX = /@(\d+)k$/i;
+/** Extract the context size from a model id's `@Nk` suffix, or undefined. */
+export function contextOf(id) {
+    const match = CONTEXT_SUFFIX.exec(id);
+    return match ? parseInt(match[1], 10) : undefined;
+}
+/** Strip the `@Nk` context suffix from a model id. */
+export function stripContext(id) {
+    return id.replace(CONTEXT_SUFFIX, '');
 }
 /** Grok wire adapter: one instance serves the `grok` provider route. */
 export class GrokAdapter extends LlmAdapter {
@@ -286,7 +423,7 @@ export class GrokAdapter extends LlmAdapter {
     /** Capability metadata from the CLI catalog, keyed by model id. */
     metadata = new Map();
     /** Fast-variant wire id per base model, for the picker's quick-mode button. */
-    fastVariants = new Map();
+    fastVariants = new FastVariantIndex();
     /** Image-generation model id, when discovery reported one. */
     imageModel;
     /** Ids the user added by hand, cached so the sync catalog can name them. */
@@ -309,15 +446,24 @@ export class GrokAdapter extends LlmAdapter {
             return [];
         await this.syncUserModels();
         const hidden = await this.hidden();
-        // Image models are never picker rows: they are agent-called, always on.
+        // The host validates a GUI selection against the exact ids `listModels` returns
+        // and refuses an unknown one with `session/model-unavailable`, and its picker
+        // lists every returned id as its own row. So a fast variant is published under
+        // its base id: selecting it names the variant the request must send, and the
+        // base's own id is withheld so the variant does not appear twice.
         const imageless = this.catalog().filter((entry) => !isImageModel(entry.id));
-        return resolveCatalog(imageless, [], hidden).entries.map((entry) => ({
-            provider: GROK_PROVIDER_ID,
-            id: entry.id,
-            name: entry.name,
-            ...entry.description === undefined ? {} : { description: entry.description },
-            ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
-        }));
+        const listed = resolveCatalog(imageless, [], hidden).entries.map((entry) => {
+            const fast = this.fastVariants.variantOf(entry.id);
+            const id = fast ?? entry.id;
+            return {
+                provider: GROK_PROVIDER_ID,
+                id,
+                name: entry.name,
+                ...entry.description === undefined ? {} : { description: entry.description },
+                ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
+            };
+        });
+        return listed;
     }
     async hidden() {
         if (this.options.hiddenModels === undefined)
@@ -332,7 +478,12 @@ export class GrokAdapter extends LlmAdapter {
     }
     async resolveModel(_provider, model) {
         await this.syncUserModels();
-        const entry = findEntry(this.catalog(), model);
+        // A fast variant is not a catalog row of its own: it answers with its base model's
+        // metadata — the same 500k window, name and ladder the picker shows — while the id
+        // stays the fast wire id the request must send.
+        const pair = this.fastPairOf(model);
+        const entry = findEntry(this.catalog(), model)
+            ?? (pair === undefined ? undefined : findEntry(this.catalog(), pair.baseId));
         if (entry === undefined) {
             const template = findEntry(GROK_MODELS, 'grok-4.6');
             const reasoning = template === undefined ? undefined : reasoningInfo(template);
@@ -346,10 +497,13 @@ export class GrokAdapter extends LlmAdapter {
             };
         }
         const reasoning = reasoningInfo(entry);
+        // The fast selection names itself "Fast" so the picker trigger reads the mode, not
+        // the base model it replaces; the id stays the fast wire id the request must send.
+        const fast = pair !== undefined && pair.wireId === model;
         return {
             provider: GROK_PROVIDER_ID,
-            id: entry.id,
-            name: entry.name,
+            id: model,
+            name: fast ? `${entry.name} Fast` : entry.name,
             ...entry.description === undefined ? {} : { description: entry.description },
             ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
             context: { contextWindow: entry.contextWindow },
@@ -358,7 +512,9 @@ export class GrokAdapter extends LlmAdapter {
         };
     }
     stream(options) {
-        return streamProviderResponses(options, {
+        // Resolve @Nk context suffixes to the largest variant the endpoint offers.
+        const model = this.resolveModelId(options.model);
+        return streamProviderResponses({ ...options, model }, {
             label: 'xAI API',
             tokens: this.options.tokens,
             request: (call, model, accessToken, signal) => this.request(call, model, accessToken, signal),
@@ -409,14 +565,17 @@ export class GrokAdapter extends LlmAdapter {
                 ...meta?.defaultEffort === undefined ? {} : { defaultEffort: meta.defaultEffort },
             });
         }
-        // The seeds also pick up live metadata (context window, reasoning ladder).
+        // The seeds also pick up live metadata (reasoning ladder, default effort). The
+        // curated context window is never narrowed by a live figure: the CLI catalog states
+        // 256k for `grok-4.7`, which serves 500k, and a live read may only widen what this
+        // build ships.
         const seeded = GROK_MODELS.map((entry) => {
             const meta = this.metadata.get(entry.id);
             if (meta === undefined)
                 return entry;
             return {
                 ...entry,
-                contextWindow: meta.contextWindow ?? entry.contextWindow,
+                contextWindow: Math.max(entry.contextWindow, meta.contextWindow ?? 0),
                 ...meta.reasoningEfforts === undefined ? {} : { reasoningEfforts: meta.reasoningEfforts },
                 ...meta.defaultEffort === undefined ? {} : { defaultEffort: meta.defaultEffort },
             };
@@ -459,7 +618,11 @@ export class GrokAdapter extends LlmAdapter {
     }
     /** The fast/lightspeed variant wire id for a base model, when discovery reported one. */
     fastVariant(baseId) {
-        return this.fastVariants.get(baseId);
+        return this.fastVariants.variantOf(baseId);
+    }
+    /** The fast pair one picker id belongs to, from either side. */
+    fastPairOf(id) {
+        return this.fastVariants.pairOf(id);
     }
     /** The image-generation model id, when discovery reported one. */
     imageModelId() {
@@ -474,6 +637,22 @@ export class GrokAdapter extends LlmAdapter {
         return this.shippedCatalog();
     }
     /** Build and send one request for one model. */
+    /** The default context variant per base model, set during discovery. */
+    defaultContext = new Map();
+    /** Resolve a model id to the wire id the endpoint accepts (largest context). */
+    resolveModelId(model) {
+        return this.defaultContext.get(model) ?? model;
+    }
+    /** Record one default-context mapping. */
+    noteContextVariant(base, context, wireId) {
+        const existing = this.defaultContext.get(base);
+        if (existing !== undefined) {
+            const existingCtx = contextOf(existing);
+            if (existingCtx !== undefined && existingCtx >= context)
+                return;
+        }
+        this.defaultContext.set(base, wireId);
+    }
     async request(options, model, accessToken, signal) {
         const resolved = await toResponsesInput(options.messages, options.system, this.imageResolver(signal));
         const body = {
@@ -552,24 +731,37 @@ export class GrokAdapter extends LlmAdapter {
             const rawIds = allIds.filter((id) => !NON_CHAT_ID.test(id));
             // Fast/lightspeed variants ride with their base model: they share the base's
             // visibility switch and are reached by a picker button, not a separate row.
+            // Context variants (@500k) also fold into the base; the largest context wins.
             this.fastVariants.clear();
+            this.defaultContext.clear();
             for (const id of rawIds) {
-                if (!isFastVariant(id))
-                    continue;
-                const base = baseModelOf(id);
-                if (!this.fastVariants.has(base))
-                    this.fastVariants.set(base, id);
+                this.fastVariants.noteListed(id);
             }
+            this.noteWireVariants(rawIds);
             const ids = rawIds
-                .map((id) => (isFastVariant(id) ? baseModelOf(id) : id))
+                .map((id) => {
+                if (isFastVariant(id))
+                    return this.fastVariants.pair(id) ?? baseModelOf(id);
+                const ctx = contextOf(id);
+                if (ctx !== undefined)
+                    return stripContext(id);
+                return id;
+            })
                 .filter((id, index, list) => list.indexOf(id) === index);
             if (ids.length === 0) {
                 this.options.onWarn?.('xAI model discovery returned an empty catalog; using the built-in catalog');
                 return undefined;
             }
-            const metadata = await this.fetchCliMetadata(fetchFn, signal);
-            for (const [id, meta] of metadata)
+            const cli = await this.readCliCatalog(fetchFn, signal, accessToken);
+            for (const [id, meta] of cli.metadata)
                 this.metadata.set(id, meta);
+            // The account's own CLI catalog is the only surface that names a fast variant:
+            // the public `/models` list omits `grok-4.7-build-fast` entirely. Its ids fold
+            // into the same base rows, and are never added as picker rows of their own.
+            for (const id of cli.ids) {
+                this.fastVariants.noteListed(id);
+            }
+            this.noteWireVariants(cli.ids);
             return ids;
         }
         catch (error) {
@@ -579,21 +771,55 @@ export class GrokAdapter extends LlmAdapter {
             return undefined;
         }
     }
-    /** Read per-model capabilities from the CLI catalog; failures are silent. */
-    async fetchCliMetadata(fetchFn, signal) {
+    /**
+     * Fold the fast and context variants of one id list into their base models.
+     *
+     * @param ids - wire ids to classify.
+     */
+    noteWireVariants(ids) {
+        for (const id of ids) {
+            if (NON_CHAT_ID.test(id) || isImageModel(id))
+                continue;
+            if (isFastVariant(id)) {
+                // Pair with the longest listed prefix, not a derived string: the prefix is a
+                // model the account actually serves, so the button always targets a real row.
+                const base = this.fastVariants.pair(id);
+                this.fastVariants.note(id, () => base);
+                continue;
+            }
+            const ctx = contextOf(id);
+            if (ctx !== undefined)
+                this.noteContextVariant(stripContext(id), ctx, id);
+        }
+    }
+    /**
+     * Read per-model capabilities from the CLI catalog; failures are silent.
+     *
+     * The catalog answers only for the signed-in account's own bearer — an anonymous
+     * request is refused — and it, unlike the public `/models` list, names the account's
+     * fast variant.
+     *
+     * @param fetchFn - fetch implementation.
+     * @param signal - caller cancellation.
+     * @param accessToken - the account's bearer.
+     * @returns the capability metadata and every id the catalog named.
+     */
+    async readCliCatalog(fetchFn, signal, accessToken) {
         const result = new Map();
+        const ids = [];
         try {
             const response = await fetchFn(GROK_CLI_MODELS_URL, {
-                headers: attributedHeaders({ 'authorization': 'Bearer anonymous' }),
+                headers: attributedHeaders({ 'authorization': `Bearer ${accessToken}` }),
                 ...signal === undefined ? {} : { signal },
             });
             if (!response.ok)
-                return result;
+                return { metadata: result, ids };
             const payload = await response.json();
             for (const entry of payload.data ?? []) {
                 const id = typeof entry.id === 'string' && entry.id.length > 0 ? entry.id : undefined;
                 if (id === undefined)
                     continue;
+                ids.push(id);
                 const contextWindow = typeof entry.context_window === 'number' && Number.isFinite(entry.context_window)
                     ? entry.context_window
                     : undefined;
@@ -617,7 +843,7 @@ export class GrokAdapter extends LlmAdapter {
         catch {
             // Capability metadata is a bonus; the id list is what matters.
         }
-        return result;
+        return { metadata: result, ids };
     }
 }
 /**
@@ -759,10 +985,10 @@ export function createGrokProvider(options) {
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
         modelVariants: (id) => {
-            const fast = adapter.fastVariant(id);
+            const pair = adapter.fastPairOf(id);
             const image = adapter.imageModelId();
             return {
-                ...fast === undefined ? {} : { fast },
+                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId },
                 ...image === undefined ? {} : { image },
             };
         },

package/lib/providers/kimi-provider.js

@@ -151,10 +151,10 @@ export function createKimiProvider(options) {
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
         modelVariants: (id) => {
-            const fast = adapter.fastVariant(id);
+            const pair = adapter.fastPairOf(id);
             const image = adapter.imageModelId();
             return {
-                ...fast === undefined ? {} : { fast },
+                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId },
                 ...image === undefined ? {} : { image },
             };
         },

package/lib/providers/kimi.d.ts

@@ -104,13 +104,33 @@ export declare class KimiAdapter extends LlmAdapter {
     private discovered;
     /** Image-generation model id, when discovery reported one. */
     private imageModel;
-    /** Fast-variant wire id per base model, for the picker's quick-mode button. */
+    /**
+     * Fast-variant wire id per picker row, for the composer's quick-mode button.
+     *
+     * Seeded from the curated aliases — `kimi-for-coding-highspeed` is one — so the button
+     * exists before any discovery run, and then updated from the live catalog, which is
+     * the authority on what this account actually serves.
+     */
     private readonly fastVariants;
     /** Ids the user added by hand, cached so the sync catalog can name them. */
     private userAddedIds;
     /** Tools already reported as flattened, so each is stated once. */
     private readonly flattenedTools;
     constructor(options: KimiAdapterOptions);
+    /**
+     * Record the fast variants the curated catalog already names as aliases.
+     *
+     * The alias is the recognition: `kimi-for-coding-highspeed` is stated as an accepted
+     * id of `kimi-for-coding`, so the route can offer the quick-mode button without
+     * waiting for a live list that may never name it. A row a live catalog already paired
+     * keeps that pairing, so this only fills the gaps.
+     */
+    private seedCuratedFastVariants;
+    /** The fast pair one picker id belongs to, from either side. */
+    fastPairOf(id: string): {
+        baseId: string;
+        wireId: string;
+    } | undefined;
     /**
      * Tool schemas in the shape Moonshot accepts: no `$ref`, and under its size
      * ceiling. A declaration too large to send keeps its arguments, and that is
@@ -122,7 +142,7 @@ export declare class KimiAdapter extends LlmAdapter {
     listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
     /** The image-generation model id, when discovery reported one. */
     imageModelId(): string | undefined;
-    /** The fast/lightspeed variant wire id for a base model, when discovery reported one. */
+    /** The fast/lightspeed variant wire id for a picker row. */
     fastVariant(baseId: string): string | undefined;
     /** The ids the picker must currently omit. */
     private hidden;

package/lib/providers/kimi.js

@@ -15,7 +15,7 @@ import { streamProviderResponses, accountPoolHooks } from './responses-stream.js
 import { fallbackEntry, findEntry, resolveCatalog } from './catalog.js';
 import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
 import { prepareMoonshotTool } from '../translate/moonshot-schema.js';
-import { isImageModel, isFastVariant, baseModelOf } from './grok.js';
+import { isImageModel, isFastVariant, baseModelOf, FastVariantIndex } from './grok.js';
 /** Model ids that are clearly not chat models. */
 const NON_CHAT_ID = /(?:^|[-_/])(?:image|video|imagine|embed|embedding|whisper|tts|vision-only)/i;
 /**
@@ -134,8 +134,14 @@ export class KimiAdapter extends LlmAdapter {
     discovered;
     /** Image-generation model id, when discovery reported one. */
     imageModel;
-    /** Fast-variant wire id per base model, for the picker's quick-mode button. */
-    fastVariants = new Map();
+    /**
+     * Fast-variant wire id per picker row, for the composer's quick-mode button.
+     *
+     * Seeded from the curated aliases — `kimi-for-coding-highspeed` is one — so the button
+     * exists before any discovery run, and then updated from the live catalog, which is
+     * the authority on what this account actually serves.
+     */
+    fastVariants = new FastVariantIndex();
     /** Ids the user added by hand, cached so the sync catalog can name them. */
     userAddedIds = [];
     /** Tools already reported as flattened, so each is stated once. */
@@ -143,6 +149,28 @@ export class KimiAdapter extends LlmAdapter {
     constructor(options) {
         super();
         this.options = options;
+        this.seedCuratedFastVariants();
+    }
+    /**
+     * Record the fast variants the curated catalog already names as aliases.
+     *
+     * The alias is the recognition: `kimi-for-coding-highspeed` is stated as an accepted
+     * id of `kimi-for-coding`, so the route can offer the quick-mode button without
+     * waiting for a live list that may never name it. A row a live catalog already paired
+     * keeps that pairing, so this only fills the gaps.
+     */
+    seedCuratedFastVariants() {
+        for (const entry of KIMI_MODELS) {
+            for (const alias of entry.aliases ?? []) {
+                // Every alias of one row maps back to that row, so a variant whose own prefix
+                // names another alias (`kimi-k2.7-code-highspeed`) still pairs with the row.
+                this.fastVariants.note(alias, (base) => this.entryFor(base)?.id ?? base);
+            }
+        }
+    }
+    /** The fast pair one picker id belongs to, from either side. */
+    fastPairOf(id) {
+        return this.fastVariants.pairOf(id);
     }
     /**
      * Tool schemas in the shape Moonshot accepts: no `$ref`, and under its size
@@ -178,23 +206,32 @@ export class KimiAdapter extends LlmAdapter {
             return [];
         await this.syncUserModels();
         const hidden = await this.hidden();
-        // Image models are never picker rows: they are agent-called, always on.
+        // The host validates a GUI selection against the exact ids `listModels` returns
+        // and refuses an unknown one with `session/model-unavailable`, and its picker
+        // lists every returned id as its own row. So a fast variant is published under
+        // its base id: selecting it names the variant the request must send, and the
+        // base's own id is withheld so the variant does not appear twice.
         const imageless = this.catalog().filter((entry) => !isImageModel(entry.id));
-        return resolveCatalog(imageless, [], hidden).entries.map((entry) => ({
-            provider: KIMI_PROVIDER_ID,
-            id: entry.id,
-            name: entry.name,
-            ...entry.description === undefined ? {} : { description: entry.description },
-            ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
-        }));
+        const listed = resolveCatalog(imageless, [], hidden).entries.map((entry) => {
+            const fast = this.fastVariants.variantOf(entry.id);
+            const id = fast ?? entry.id;
+            return {
+                provider: KIMI_PROVIDER_ID,
+                id,
+                name: entry.name,
+                ...entry.description === undefined ? {} : { description: entry.description },
+                ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
+            };
+        });
+        return listed;
     }
     /** The image-generation model id, when discovery reported one. */
     imageModelId() {
         return this.imageModel;
     }
-    /** The fast/lightspeed variant wire id for a base model, when discovery reported one. */
+    /** The fast/lightspeed variant wire id for a picker row. */
     fastVariant(baseId) {
-        return this.fastVariants.get(baseId);
+        return this.fastVariants.variantOf(baseId);
     }
     /** The ids the picker must currently omit. */
     async hidden() {
@@ -228,10 +265,16 @@ export class KimiAdapter extends LlmAdapter {
             };
         }
         const reasoning = reasoningInfo(entry);
+        // A fast variant is a wire id of its own — the button switches to it and back, so the
+        // selection must keep that id — while an ordinary alias is just another spelling of
+        // the row and resolves onto it. The fast selection names itself "Fast" so the picker
+        // trigger reads the mode, not the base model it replaces.
+        const pair = this.fastVariants.pairOf(model);
+        const fast = pair !== undefined && pair.wireId === model;
         return {
             provider: KIMI_PROVIDER_ID,
-            id: entry.id,
-            name: entry.name,
+            id: fast ? model : entry.id,
+            name: fast ? `${entry.name} Fast` : entry.name,
             ...entry.description === undefined ? {} : { description: entry.description },
             ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
             context: { contextWindow: entry.contextWindow },
@@ -436,17 +479,25 @@ export class KimiAdapter extends LlmAdapter {
                 .filter((id) => typeof id === 'string' && id.length > 0);
             // Image models are never picker rows: they are agent-called, always on.
             this.imageModel = allIds.find((id) => isImageModel(id));
-            // Fast/lightspeed variants ride with their base model: they share the base's
-            // visibility switch and are reached by a picker button, not a separate row.
+            // Fast/lightspeed variants ride with their base row: they share the row's
+            // visibility switch and are reached by the composer's quick-mode button, not a
+            // separate row. The live list is the authority on what this account serves, so
+            // it is recorded first, and each variant pairs with the longest listed prefix
+            // of its own name — a provider that names its variants after the base model
+            // pairs them with no curated map at all.
             this.fastVariants.clear();
             for (const id of allIds) {
-                if (!isFastVariant(id))
-                    continue;
-                const base = baseModelOf(id);
-                if (!this.fastVariants.has(base))
-                    this.fastVariants.set(base, id);
+                this.fastVariants.noteListed(id);
+            }
+            for (const id of allIds) {
+                const base = this.fastVariants.pair(id);
+                this.fastVariants.note(id, () => base ?? this.entryFor(baseModelOf(id))?.id ?? baseModelOf(id));
             }
-            const ids = allIds.filter((id) => !NON_CHAT_ID.test(id));
+            this.seedCuratedFastVariants();
+            const ids = allIds
+                .filter((id) => !NON_CHAT_ID.test(id))
+                .map((id) => (isFastVariant(id) ? this.fastVariants.pair(id) ?? baseModelOf(id) : id))
+                .filter((id, index, list) => list.indexOf(id) === index);
             if (ids.length === 0) {
                 this.options.onWarn?.('Kimi model discovery returned an empty catalog; using the built-in catalog');
                 return undefined;

package/lib/translate/antigravity.js

@@ -25,7 +25,7 @@ import { parseSse } from './sse.js';
 export function antigravityReasoning(model) {
     const ids = model.startsWith('claude-') ? ['high']
         : model.startsWith('gpt-oss-') ? ['medium']
-            : model.startsWith('gemini-3.1-pro') || model === 'gemini-pro-agent' ? ['low', 'high']
+            : model.startsWith('gemini-3.1-pro') || model === 'gemini-pro' || model === 'gemini-pro-agent' ? ['low', 'high']
                 : /^gemini-(?:2\.5|3)/.test(model) ? ['low', 'medium', 'high'] : [];
     const fixed = /^gemini-.*-(low|medium|high)$/.exec(model)?.[1];
     const efforts = fixed !== undefined && ids.includes(fixed) ? [fixed] : ids;
@@ -59,10 +59,10 @@ export function antigravityThinking(model, effort, maxTokens) {
         budget = 1024;
     else if (model.startsWith('gpt-oss-'))
         budget = 8192;
-    else if (model.startsWith('gemini-3.1-pro') || model === 'gemini-pro-agent') {
+    else if (model.startsWith('gemini-3.1-pro') || model === 'gemini-pro' || model === 'gemini-pro-agent') {
         budget = effort === 'high' ? 10001 : 1001;
     }
-    else if (model.startsWith('gemini-3.5-flash') || model === 'gemini-3-flash-agent') {
+    else if (model.startsWith('gemini-3.5-flash') || model === 'gemini-3-flash' || model === 'gemini-3-flash-agent') {
         budget = effort === 'high' ? 10000 : effort === 'medium' ? 4000 : 1000;
     }
     else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.8.14",
+  "version": "0.8.16",
   "description": "Use subscription accounts as DeepSeek Harness LLM providers — Kimi Code (OAuth device flow), Grok / X Premium (OIDC + PKCE), Google Antigravity (Google OAuth + Cloud Code Assist) and GLM / BigModel (ZCode's browser sign-in) — with per-model visibility, drag-to-reorder Auto fallback and plan quotas from the web Settings page",
   "license": "MIT",
   "author": "EricFL1998",