dsh-plugin-subscription-oauth 0.8.14 → 0.8.16

package/lib/index.js

@@ -243,6 +243,8 @@ export function apply(ctx, config = {}) {
     };
     registerSubscriptionRpc(ctx, registry, balanceContext);
     // Warm each route's live catalog for an install that is already signed in.
+    // Discovery uses the stored token as-is (no resolve, no refresh), so a dead grant
+    // is skipped silently rather than opening the browser.
     for (const id of registry.ids()) {
         void registry.discover(id, false).catch((error) => {
             onWarn(`${id} startup discovery failed: ${error instanceof Error ? error.message : String(error)}`);

package/lib/protocol.d.ts

@@ -324,7 +324,7 @@ export interface RpcMap {
         value: CcSwitchBalanceResult;
     };
     'model-variants': {
-        payload: DiscoverRequest;
+        payload: ModelVariantsRequest;
         value: ModelVariantsResult;
     };
 }
@@ -357,11 +357,23 @@ export type BalanceResult =
 export interface ModelVariants {
     /** Fast/lightspeed variant wire id, when the provider reported one. */
     fast?: string;
+    /**
+     * The base model the fast variant belongs to.
+     *
+     * Sent with `fast` so the picker button can switch back off when the selection is
+     * already the fast variant, which is not itself a listed row.
+     */
+    fastBase?: string;
     /** Image-generation model wire id, when the provider reported one. */
     image?: string;
 }
 /** Result of `model-variants`: the variants for one model id. */
 export type ModelVariantsResult = ModelVariants | undefined;
+/** Payload of `model-variants`. */
+export interface ModelVariantsRequest {
+    provider: string;
+    id: string;
+}
 /** Payload of `deepseek-balance`. */
 export interface DeepSeekBalanceRequest {
     /** Client metadata the host's account service expects. */

package/lib/providers/antigravity-catalog.d.ts

@@ -14,20 +14,40 @@
  */
 import type { UsageWindow } from '../protocol.js';
 import type { CatalogEntry } from './catalog.js';
-/** True when a model id names a specific tier of a family, not a model with a ladder. */
-export declare function isTierMarked(id: string): boolean;
-/** The base family a tier-marked id belongs to (`gemini-3-flash-agent` → `gemini-3-flash`). */
-export declare function baseFamilyOf(id: string): string;
+/** True when a model id names an image-generation model. */
+export declare function isImageModel(id: string): boolean;
+/**
+ * The wire id one gemini flash family and effort level map to when no live listing
+ * has been parsed yet.
+ *
+ * The live listing is the authority (see `wireIdFor`); this is the fallback that
+ * keeps a cold start — a persisted selection used before discovery ran — from
+ * sending a bare family id the endpoint does not serve. The service names tiers
+ * inconsistently: the High tier of 3.5 Flash is `gemini-3.5-flash-high` in some
+ * groups and `gemini-3.5-flash-agent` in others; 3.8 Flash is
+ * `gemini-3.8-flash-tiered`.
+ */
+export declare function geminiTierId(base: string, effort: string): string;
 /** Antigravity's own reasoning ladder, per model family. */
 export declare function antigravityEffortsFor(model: string): readonly string[];
+/**
+ * The wire id one picker row and effort level must dispatch.
+ *
+ * @param rowId - the row the picker offered.
+ * @param effort - the chosen level, when the caller picked one.
+ * @returns the wire id, or undefined when no live listing covers this row.
+ */
+export declare function wireIdFor(rowId: string, effort?: string): string | undefined;
+/** Collapse families into one row each, as magpie does. */
+export declare function collapseFamilies(raw: CatalogEntry[]): CatalogEntry[];
 /**
  * Read the agent-callable catalog from a `fetchAvailableModels` response.
  *
- * Every listed id is a wire id the response itself named, so each row stays
- * dispatchable; the filter removes the surfaces the agent envelope cannot call
- * (tabs, commit messages, transcription, standalone image generation) and keeps the
- * response's own grouping order. A tier-suffixed id advertises no effort ladder,
- * because its suffix already fixes the tier.
+ * The response's own grouping decides which ids the agent envelope may call; this
+ * removes the surfaces it cannot (tabs, commit messages, transcription, standalone
+ * image generation) and keeps the response's own order. Tiers of one family then
+ * collapse into the single picker row that serves them, with a wire-id map so the
+ * request still names an id the account listed (see `wireIdFor`).
  *
  * @param payload - the decoded response.
  * @returns the catalog entries, in the response's order.

package/lib/providers/antigravity-catalog.js

@@ -12,6 +12,7 @@
  *
  * @module dsh-plugin-subscription-oauth/providers/antigravity-catalog
  */
+import { baseCandidatesOf } from './grok.js';
 /** Effort rungs that fold into one picker row. */
 const EFFORTS = ['low', 'medium', 'high'];
 /** True for a plain object usable as a JSON record. */
@@ -48,19 +49,33 @@ function modelInfo(raw) {
         ...raw.supportsImages === true ? { supportsImages: true } : {},
     };
 }
-/** A model id whose suffix or infix names a fixed reasoning tier, folded into its base family. */
-const TIER_MARKED = /(?:^|[-_])(?:extra-low|low|medium|high|max)(?:$|[-_])/i;
-/** True when a model id names a specific tier of a family, not a model with a ladder. */
-export function isTierMarked(id) {
-    return TIER_MARKED.test(id);
+/** Model ids that are image-generation models, never picker rows. */
+const IMAGE_MODEL = /(?:^|[-_])(?:image|imagine|draw|pic|photo)(?:[-_]|$)/i;
+/** True when a model id names an image-generation model. */
+export function isImageModel(id) {
+    return IMAGE_MODEL.test(id);
 }
-/** The base family a tier-marked id belongs to (`gemini-3-flash-agent` → `gemini-3-flash`). */
-export function baseFamilyOf(id) {
-    // Remove the tier token wherever it sits (suffix or infix), then tidy any trailing
-    // separator the removal left behind.
-    return id
-        .replace(/[-_](?:extra-low|low|medium|high|max)(?=[-_]|$)/i, '')
-        .replace(/[-_]$/, '');
+/**
+ * The wire id one gemini flash family and effort level map to when no live listing
+ * has been parsed yet.
+ *
+ * The live listing is the authority (see `wireIdFor`); this is the fallback that
+ * keeps a cold start — a persisted selection used before discovery ran — from
+ * sending a bare family id the endpoint does not serve. The service names tiers
+ * inconsistently: the High tier of 3.5 Flash is `gemini-3.5-flash-high` in some
+ * groups and `gemini-3.5-flash-agent` in others; 3.8 Flash is
+ * `gemini-3.8-flash-tiered`.
+ */
+export function geminiTierId(base, effort) {
+    if (effort === 'high') {
+        if (base === 'gemini-3.5-flash')
+            return 'gemini-3.5-flash-agent';
+        if (base === 'gemini-3.8-flash')
+            return 'gemini-3.8-flash-tiered';
+        if (base === 'gemini-3-flash')
+            return 'gemini-3-flash-agent';
+    }
+    return `${base}-${effort}`;
 }
 /** Antigravity's own reasoning ladder, per model family. */
 export function antigravityEffortsFor(model) {
@@ -72,6 +87,180 @@ export function antigravityEffortsFor(model) {
         return ['low', 'medium', 'high'];
     return [];
 }
+// ── magpie-style family collapse ─────────────────────────────────────────
+/** One effort word of Antigravity's ids and the level it means. */
+const EFFORT_WORDS = [
+    { word: 'extra-high', level: 'xhigh' },
+    { word: 'extra-low', level: 'minimal' },
+    { word: 'xhigh', level: 'xhigh' },
+    { word: 'minimal', level: 'minimal' },
+    // A flash family's High tier is spelled `-high`, `-tiered` or `-agent` depending on
+    // the generation, so all three mean the same rung of the ladder.
+    { word: 'tiered', level: 'high' },
+    { word: 'agent', level: 'high' },
+    { word: 'low', level: 'low' },
+    { word: 'medium', level: 'medium' },
+    { word: 'high', level: 'high' },
+    { word: 'max', level: 'max' },
+];
+/** A ladder's canonical order. */
+const LEVEL_ORDER = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+/** An id's family and the level its effort word says, '' when it has none. */
+function splitEffortId(id) {
+    for (const { word, level } of EFFORT_WORDS) {
+        if (id.endsWith(`-${word}`)) {
+            const base = id.slice(0, id.length - word.length - 1);
+            if (base.length > 0)
+                return { family: base, effort: level };
+        }
+    }
+    return { family: id, effort: '' };
+}
+/** The level a display name's bracketed suffix says ("Gemini 3.7 Flash (High)" → high). */
+function nameEffort(name) {
+    const open = name.lastIndexOf(' (');
+    if (open < 0 || !name.endsWith(')'))
+        return { base: name, effort: '' };
+    const inner = name.slice(open + 2, -1).toLowerCase();
+    let effort = '';
+    if (inner === 'minimal' || inner === 'extra low')
+        effort = 'minimal';
+    else if (inner === 'low')
+        effort = 'low';
+    else if (inner === 'medium')
+        effort = 'medium';
+    else if (inner === 'high')
+        effort = 'high';
+    else if (inner === 'extra high' || inner === 'xhigh')
+        effort = 'xhigh';
+    if (effort === '')
+        return { base: name, effort: '' };
+    return { base: name.slice(0, open).trim(), effort };
+}
+/**
+ * Group raw entries into the families the service names.
+ *
+ * Grouping follows the display name, not the id, because the service names the family
+ * and lets the wire id drift: the High tier of Gemini 3.5 Flash is
+ * `gemini-3-flash-agent` — an id that names a different generation than the name it
+ * carries. A level is stated by the name's own bracket when it has one, and by the
+ * id's effort word otherwise; the family a variant belongs to is the longest listed
+ * prefix of its own id, so `gemini-3.5-flash-low` folds into whichever listed row its
+ * prefix names with no hand-written family map.
+ *
+ * @param raw - one entry per wire id the listing exposed.
+ * @returns the families, in the order their first member appeared.
+ */
+function familiesOf(raw) {
+    const byName = new Map();
+    const order = [];
+    const listed = new Set(raw.map((entry) => entry.id));
+    const familyOf = (id, fallback) => {
+        for (const base of baseCandidatesOf(id)) {
+            if (listed.has(base))
+                return base;
+        }
+        return fallback;
+    };
+    for (const entry of raw) {
+        const { base: name, effort: named } = nameEffort(entry.name);
+        const { family: idBase, effort: idLevel } = splitEffortId(entry.id);
+        // The family's key: the name's bracket-free base, when the name states a level, so
+        // "Gemini 3.5 Flash (Medium)" is always that family even if no listed id starts
+        // with `gemini-3.5-flash`; otherwise the longest listed prefix of the id itself.
+        const familyBase = named !== '' ? name : (idBase !== entry.id ? familyOf(entry.id, name) : name);
+        let f = byName.get(familyBase);
+        if (f === undefined) {
+            f = { name: familyBase, variants: [], base: '' };
+            byName.set(familyBase, f);
+            order.push(f);
+        }
+        if (f.base === '' && idBase !== entry.id)
+            f.base = idBase;
+        f.variants.push({
+            id: entry.id,
+            contextWindow: entry.contextWindow,
+            inputModalities: entry.inputModalities ?? ['text'],
+            level: named !== '' ? named : idLevel,
+        });
+    }
+    return order;
+}
+/** The rungs a family defaults to, best first, when no variant is the bare model. */
+const DEFAULT_ORDER = ['xhigh', 'high', 'medium', 'low', 'minimal', 'max'];
+/** The variant whose id the family's row carries: the bare model, else its top rung. */
+function defaultVariant(f) {
+    const bare = f.variants.find((v) => v.level === '');
+    if (bare !== undefined)
+        return bare;
+    for (const level of DEFAULT_ORDER) {
+        const found = f.variants.find((v) => v.level === level);
+        if (found !== undefined)
+            return found;
+    }
+    return f.variants[0];
+}
+/**
+ * The wire id each picker row must send per effort level, as the last parsed family
+ * listing reported it.
+ *
+ * Collapsing gives the picker one row per family, but the endpoint only serves the
+ * suffixed ids the listing named: the High tier of Gemini 3.5 Flash is
+ * `gemini-3-flash-agent`, and `gpt-oss-120b` only exists as `gpt-oss-120b-medium`.
+ * Nothing here is invented — a level the listing did not name falls back to the
+ * family's own default id, and only a tiered gemini family may synthesise the tier
+ * spelling the endpoint accepts (see `geminiTierId`).
+ */
+const wireIds = new Map();
+/**
+ * The wire id one picker row and effort level must dispatch.
+ *
+ * @param rowId - the row the picker offered.
+ * @param effort - the chosen level, when the caller picked one.
+ * @returns the wire id, or undefined when no live listing covers this row.
+ */
+export function wireIdFor(rowId, effort) {
+    const row = wireIds.get(rowId);
+    if (row === undefined)
+        return undefined;
+    const chosen = effort === undefined ? undefined : row.levels.get(effort);
+    if (chosen !== undefined)
+        return chosen;
+    // A tiered gemini family the listing exposed only one way still takes its own tier
+    // spelling for the three levels this build knows (`gemini-3.8-flash` + low →
+    // `gemini-3.8-flash-low`). Nothing else is synthesised.
+    const tiered = effort === 'low' || effort === 'medium' || effort === 'high';
+    if (tiered && row.base !== '' && row.base !== rowId)
+        return geminiTierId(row.base, effort);
+    return row.levels.get('') ?? rowId;
+}
+/** Collapse families into one row each, as magpie does. */
+export function collapseFamilies(raw) {
+    const out = [];
+    for (const f of familiesOf(raw)) {
+        const levels = new Map();
+        for (const v of f.variants)
+            if (!levels.has(v.level))
+                levels.set(v.level, v.id);
+        const def = defaultVariant(f);
+        levels.set('', def.id);
+        wireIds.set(def.id, { levels, base: f.base });
+        const aliases = f.variants.map((v) => v.id).filter((id) => id !== def.id);
+        out.push({
+            // The row keeps an id the account listed, so a selection made from it stays
+            // dispatchable; the name is what the picker shows.
+            id: def.id,
+            name: f.name,
+            ...aliases.length === 0 ? {} : { aliases },
+            contextWindow: Math.min(...f.variants.map((v) => v.contextWindow)),
+            inputModalities: def.inputModalities,
+            // Only the rungs this listing really serves: a level with no id of its own must
+            // not be offered as a choice the request would ignore.
+            reasoningEfforts: LEVEL_ORDER.filter((level) => levels.has(level)),
+        });
+    }
+    return out;
+}
 /**
  * The ids the agent can actually call, in the order the response groups them.
  *
@@ -154,11 +343,11 @@ const NON_AGENT = /(?:^|[-_])(?:tab|tabs|commit|transcription|audio|embedding|co
 /**
  * Read the agent-callable catalog from a `fetchAvailableModels` response.
  *
- * Every listed id is a wire id the response itself named, so each row stays
- * dispatchable; the filter removes the surfaces the agent envelope cannot call
- * (tabs, commit messages, transcription, standalone image generation) and keeps the
- * response's own grouping order. A tier-suffixed id advertises no effort ladder,
- * because its suffix already fixes the tier.
+ * The response's own grouping decides which ids the agent envelope may call; this
+ * removes the surfaces it cannot (tabs, commit messages, transcription, standalone
+ * image generation) and keeps the response's own order. Tiers of one family then
+ * collapse into the single picker row that serves them, with a wire-id map so the
+ * request still names an id the account listed (see `wireIdFor`).
  *
  * @param payload - the decoded response.
  * @returns the catalog entries, in the response's order.
@@ -167,54 +356,21 @@ export function parseAntigravityModels(payload) {
     if (!isRecord(payload) || !isRecord(payload.models))
         return [];
     const models = payload.models;
-    // TEMP diagnostics: write the raw model-id list to a file so an over-eager filter is
-    // inspectable after a discovery run, since the node half's stdout is unreachable in
-    // the desktop shell.
-    try {
-        const all = Object.keys(models);
-        const kept = agentIds(payload);
-        const { writeFileSync } = require('node:fs');
-        const { homedir } = require('node:os');
-        const { join } = require('node:path');
-        writeFileSync(join(homedir(), '.dsh', 'antigravity-models-debug.json'), JSON.stringify({ all, kept, dropped: all.filter((id) => !kept.includes(id)) }, null, 2), 'utf8');
-    }
-    catch { /* diagnostics never break parsing */ }
-    const entries = [];
-    const seenBase = new Set();
+    const raw = [];
     for (const wireId of agentIds(payload)) {
-        const info = modelInfo(models[wireId]);
-        // Tier-marked ids (gemini-3.5-flash-low, gemini-3-flash-agent, …) are the family's
-        // fixed tiers; they fold into the base family row so the picker shows one entry with
-        // a ladder, not one row per tier. The base row is inserted the first time a tier of
-        // it is seen.
-        if (isTierMarked(wireId)) {
-            const base = baseFamilyOf(wireId);
-            if (seenBase.has(base))
-                continue;
-            seenBase.add(base);
-            const baseInfo = modelInfo(models[base]) ?? info;
-            entries.push({
-                id: base,
-                name: displayNameOf(base, models[base] ?? {}),
-                contextWindow: baseInfo.maxTokens ?? baseInfo.maxInputTokens ?? baseInfo.inputTokenLimit ?? 1_048_576,
-                inputModalities: baseInfo.supportsImages === true ? ['text', 'image'] : ['text'],
-                reasoningEfforts: antigravityEffortsFor(base),
-            });
+        // Image-generation models are never picker rows: they are agent-called, always on.
+        if (isImageModel(wireId))
             continue;
-        }
-        seenBase.add(wireId);
-        const tiers = /-(?:low|medium|high)$/.test(wireId);
-        const efforts = tiers ? [] : antigravityEffortsFor(wireId);
+        const info = modelInfo(models[wireId]);
         const contextWindow = info.maxTokens ?? info.maxInputTokens ?? info.inputTokenLimit ?? 1_048_576;
-        entries.push({
+        raw.push({
             id: wireId,
             name: displayNameOf(wireId, models[wireId] ?? {}),
             contextWindow,
             inputModalities: info.supportsImages === true ? ['text', 'image'] : ['text'],
-            ...efforts.length === 0 ? {} : { reasoningEfforts: efforts },
         });
     }
-    return entries;
+    return collapseFamilies(raw);
 }
 /** A quota reading normalised to a percentage spent. */
 function usedPercentOf(raw) {

package/lib/providers/antigravity.d.ts

@@ -228,6 +228,8 @@ export declare class AntigravityAdapter extends LlmAdapter {
     private resetAt;
     /** Remember an account as spent (its exact reset is learned separately). */
     private noteSpent;
+    /** Resolve the default account's token without the preempt window. */
+    private resolveNoPreempt;
     /** Translate an auth failure into the message a user can act on. */
     private refreshHint;
     /** Build and send one streaming request for one model. */

package/lib/providers/antigravity.js

@@ -20,7 +20,7 @@ import { ProviderController } from '../auth/provider-controller.js';
 import { proxiedFetch } from '../http.js';
 import { fallbackEntry, findEntry, resolveCatalog } from './catalog.js';
 import { idleWatchdog, mapFetchFailure, httpLlmError } from './common.js';
-import { parseAntigravityModelQuota, parseAntigravityModels, parseAntigravityQuotaSummary, } from './antigravity-catalog.js';
+import { parseAntigravityModelQuota, parseAntigravityModels, parseAntigravityQuotaSummary, geminiTierId, wireIdFor, } from './antigravity-catalog.js';
 import { toAntigravityRequest, streamAntigravity, antigravityReasoning } from '../translate/antigravity.js';
 /** Route key this module registers. */
 export const ANTIGRAVITY_PROVIDER_ID = 'antigravity';
@@ -456,7 +456,14 @@ export class AntigravityAdapter extends LlmAdapter {
             // `auto` owns the fallback chain now, so this route serves exactly the
             // model it was asked for — but it draws on every account the provider holds, so a
             // spent allowance moves to the next account rather than failing the call.
-            const model = options.model;
+            // A picker row is the family, not the wire id: `gemini-3.8-flash` is served as
+            // `gemini-3.8-flash-tiered` and `gpt-oss-120b` only exists as
+            // `gpt-oss-120b-medium`. The live listing's own mapping is the authority; the
+            // built-in tier names are the fallback for a cold start, before discovery ran.
+            const model = wireIdFor(options.model, options.reasoningEffort)
+                ?? (/^gemini-.*-flash$/.test(options.model)
+                    ? geminiTierId(options.model, options.reasoningEffort ?? 'medium')
+                    : options.model);
             // Accounts come from the manager when it can list them; a minimal manager (or a
             // test double) without `accounts()` means a single account, which is just the
             // default one.
@@ -467,7 +474,10 @@ export class AntigravityAdapter extends LlmAdapter {
             // diagnosable from the browser where the node stdout is hidden.
             const diag = [`pool=${accounts.join(',') || '(none)'}`];
             const tried = new Set();
-            let token = await this.options.tokens.resolve();
+            // Resolve without preempt: use the stored token if it is still within its life,
+            // refresh only when it has actually expired. The 5-minute preempt was causing
+            // a refresh on every stream, which made Google show the consent page.
+            let token = await this.resolveNoPreempt();
             // Stay on the default account until it refuses. opencodex keeps account affinity —
             // a request stays on one account and only moves after a 429 — because switching
             // accounts on every request is what reads to Google as two accounts in play at once
@@ -571,6 +581,18 @@ export class AntigravityAdapter extends LlmAdapter {
     noteSpent(account) {
         this.options.onWarn?.(`antigravity: account ${account} allowance spent; moving to another account`);
     }
+    /** Resolve the default account's token without the preempt window. */
+    async resolveNoPreempt() {
+        const found = await this.options.tokens.session();
+        if (found === undefined) {
+            throw new ProviderError(`${ANTIGRAVITY_PROVIDER_NAME} no account is signed in`, REAUTH_REQUIRED);
+        }
+        const { account, session } = found;
+        if (Date.now() < session.expiresAt) {
+            return { account, accessToken: session.accessToken, expiresAt: session.expiresAt };
+        }
+        return await this.options.tokens.resolve(account, true);
+    }
     /** Translate an auth failure into the message a user can act on. */
     refreshHint(error) {
         if (error instanceof ProviderError && error.code === REAUTH_REQUIRED) {

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 {