dsh-plugin-subscription-oauth 0.8.13 → 0.8.15

package/lib/providers/grok.d.ts

@@ -116,8 +116,86 @@ interface GrokCliMetadata {
 export declare function isImageModel(id: string): boolean;
 /** True when a model id names a fast/lightspeed variant of a base model. */
 export declare function isFastVariant(id: string): boolean;
-/** 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 declare function baseCandidatesOf(id: string): readonly string[];
+/**
+ * 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 declare function baseModelOf(id: string): string;
+/**
+ * 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 declare class FastVariantIndex {
+    private readonly byBase;
+    private readonly rowOfVariant;
+    private readonly knownIds;
+    /** Forget every pair and every known id, before re-reading a catalog. */
+    clear(): void;
+    /**
+     * 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: string): void;
+    /**
+     * 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: string): string | 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: string, rowOf?: (base: string) => string | undefined): void;
+    /** The fast variant's wire id for one picker row, when the catalog named one. */
+    variantOf(baseId: string): string | undefined;
+    /** The pair one picker id belongs to, from either side. */
+    pairOf(id: string): {
+        baseId: string;
+        wireId: string;
+    } | undefined;
+}
+/** Extract the context size from a model id's `@Nk` suffix, or undefined. */
+export declare function contextOf(id: string): number | undefined;
+/** Strip the `@Nk` context suffix from a model id. */
+export declare function stripContext(id: string): string;
 /** Constructor dependencies for {@link GrokAdapter}. */
 export interface GrokAdapterOptions {
     /** API base; `<base>/responses` and `<base>/models`. */
@@ -190,6 +268,11 @@ export declare class GrokAdapter extends LlmAdapter {
     discover(ids: readonly string[], metadata?: ReadonlyMap<string, GrokCliMetadata>): void;
     /** The fast/lightspeed variant wire id for a base model, when discovery reported one. */
     fastVariant(baseId: string): string | undefined;
+    /** The fast pair one picker id belongs to, from either side. */
+    fastPairOf(id: string): {
+        baseId: string;
+        wireId: string;
+    } | undefined;
     /** The image-generation model id, when discovery reported one. */
     imageModelId(): string | undefined;
     /** The curated catalog, for the Settings page's model list. */
@@ -197,6 +280,12 @@ export declare class GrokAdapter extends LlmAdapter {
     /** What this route itself serves, without the ids added by hand. */
     ownCatalogEntries(): readonly CatalogEntry[];
     /** Build and send one request for one model. */
+    /** The default context variant per base model, set during discovery. */
+    private defaultContext;
+    /** Resolve a model id to the wire id the endpoint accepts (largest context). */
+    resolveModelId(model: string): string;
+    /** Record one default-context mapping. */
+    private noteContextVariant;
     private request;
     /** Resolve image blocks through the attachment service, when it is present. */
     private imageResolver;
@@ -206,8 +295,25 @@ export declare class GrokAdapter extends LlmAdapter {
      * @returns the model ids, or undefined when discovery is off or unavailable.
      */
     fetchCatalog(accessToken: string, signal?: AbortSignal): Promise<readonly string[] | undefined>;
-    /** Read per-model capabilities from the CLI catalog; failures are silent. */
-    private fetchCliMetadata;
+    /**
+     * Fold the fast and context variants of one id list into their base models.
+     *
+     * @param ids - wire ids to classify.
+     */
+    private noteWireVariants;
+    /**
+     * 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.
+     */
+    private readCliCatalog;
 }
 /** Everything the `grok` route needs from the plugin configuration. */
 export interface GrokProviderOptions {

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,25 @@ 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.
+        // A fast variant is not a picker row, but the host validates a GUI selection
+        // against the exact list `listModels` returns, so the variant must appear there
+        // or selecting it is refused with `session/model-unavailable`. The picker's
+        // menu collapses entries that share one `group` value into a single choice,
+        // so the variant rides with its base id as the group: the host can name and
+        // select it, and the picker still shows one row per model.
         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.flatMap((entry) => {
+            const fast = this.fastVariants.variantOf(entry.id);
+            const base = {
+                provider: GROK_PROVIDER_ID,
+                id: entry.id,
+                name: entry.name,
+                ...entry.description === undefined ? {} : { description: entry.description },
+                ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
+            };
+            return fast === undefined ? [base] : [base, { provider: GROK_PROVIDER_ID, id: fast, name: entry.name, group: entry.id, description: 'Fast variant', ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities } }];
+        });
+        return listed;
     }
     async hidden() {
         if (this.options.hiddenModels === undefined)
@@ -332,7 +479,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);
@@ -348,7 +500,7 @@ export class GrokAdapter extends LlmAdapter {
         const reasoning = reasoningInfo(entry);
         return {
             provider: GROK_PROVIDER_ID,
-            id: entry.id,
+            id: model,
             name: entry.name,
             ...entry.description === undefined ? {} : { description: entry.description },
             ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
@@ -358,7 +510,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 +563,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 +616,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 +635,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 +729,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 +769,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 +841,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 +983,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

@@ -119,6 +119,7 @@ export function createKimiProvider(options) {
             { key: 'credentialFile', value: options.credentialFile },
         ],
         applyDiscovery: (ids) => { adapter.discover(ids); },
+        fastVariant: (baseId) => adapter.fastVariant(baseId),
     };
     const controller = new ProviderController({
         spec,
@@ -149,5 +150,13 @@ export function createKimiProvider(options) {
         removeModel: (id) => controller.removeModel(id),
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
+        modelVariants: (id) => {
+            const pair = adapter.fastPairOf(id);
+            const image = adapter.imageModelId();
+            return {
+                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId },
+                ...image === undefined ? {} : { image },
+            };
+        },
     };
 }

package/lib/providers/kimi.d.ts

@@ -102,11 +102,35 @@ export declare class KimiAdapter extends LlmAdapter {
     private readonly options;
     /** Live catalog ids seen this session, used to accept renamed models. */
     private discovered;
+    /** Image-generation model id, when discovery reported one. */
+    private imageModel;
+    /**
+     * 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
@@ -116,6 +140,10 @@ export declare class KimiAdapter extends LlmAdapter {
     providerInfo(provider: string): LlmProviderInfo;
     providerRetryPolicy(): undefined;
     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 picker row. */
+    fastVariant(baseId: string): string | undefined;
     /** The ids the picker must currently omit. */
     private hidden;
     resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;