dsh-plugin-subscription-oauth 0.8.13 → 0.8.15

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/ark-provider.js

@@ -170,5 +170,9 @@ export function createArkProvider(options) {
         removeModel: (id) => controller.removeModel(id),
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
+        modelVariants: (id) => {
+            const image = adapter.imageModelId();
+            return image === undefined ? undefined : { image };
+        },
     };
 }

package/lib/providers/ark.d.ts

@@ -100,10 +100,14 @@ export interface ArkAdapterOptions {
 export declare class ArkAdapter extends LlmAdapter {
     private readonly options;
     private live;
+    /** Image-generation model id, when discovery reported one. */
+    private imageModel;
     constructor(options: ArkAdapterOptions);
     providerInfo(provider: string): LlmProviderInfo;
     providerRetryPolicy(): undefined;
     listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
+    /** The image-generation model id, when discovery reported one. */
+    imageModelId(): string | undefined;
     resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
     /** Translate an auth failure into the message a user can act on. */

package/lib/providers/ark.js

@@ -23,6 +23,9 @@ import { proxiedFetch } from '../http.js';
 import { findEntry, resolveCatalog } from './catalog.js';
 import { streamProviderResponses, accountPoolHooks } from './responses-stream.js';
 import { toResponsesInput, toResponsesTools } from '../translate/responses.js';
+import { isImageModel } 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;
 /** Provider route this module serves. */
 export const ARK_PROVIDER_ID = 'ark';
 /** Display name for the picker group and the Settings card. */
@@ -113,6 +116,8 @@ function extraEntry(id) {
 export class ArkAdapter extends LlmAdapter {
     options;
     live;
+    /** Image-generation model id, when discovery reported one. */
+    imageModel;
     constructor(options) {
         super();
         this.options = options;
@@ -129,7 +134,9 @@ export class ArkAdapter extends LlmAdapter {
         if (await this.options.tokens.session() === undefined)
             return [];
         const hidden = await this.hidden();
-        return resolveCatalog(this.catalog(), [], hidden).entries.map((entry) => ({
+        // Image models are never picker rows: they are agent-called, always on.
+        const imageless = this.catalog().filter((entry) => !isImageModel(entry.id));
+        return resolveCatalog(imageless, [], hidden).entries.map((entry) => ({
             provider: ARK_PROVIDER_ID,
             id: entry.id,
             name: entry.name,
@@ -137,6 +144,10 @@ export class ArkAdapter extends LlmAdapter {
             ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
         }));
     }
+    /** The image-generation model id, when discovery reported one. */
+    imageModelId() {
+        return this.imageModel;
+    }
     async resolveModel(_provider, model) {
         const entry = findEntry(this.catalog(), model);
         if (entry === undefined) {
@@ -246,9 +257,12 @@ export class ArkAdapter extends LlmAdapter {
                 return undefined;
             }
             const body = await response.json();
-            const ids = (body.data ?? [])
+            const allIds = (body.data ?? [])
                 .map((entry) => (typeof entry?.id === 'string' ? entry.id.trim() : ''))
                 .filter((id) => id !== '');
+            // Image models are never picker rows: they are agent-called, always on.
+            this.imageModel = allIds.find((id) => isImageModel(id));
+            const ids = allIds.filter((id) => !NON_CHAT_ID.test(id));
             return ids.length === 0 ? undefined : ids;
         }
         catch (error) {

package/lib/providers/glm-provider.js

@@ -166,5 +166,9 @@ export function createGlmProvider(options) {
         removeModel: (id) => controller.removeModel(id),
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
+        modelVariants: (id) => {
+            const image = adapter.imageModelId();
+            return image === undefined ? undefined : { image };
+        },
     };
 }

package/lib/providers/glm.d.ts

@@ -120,6 +120,8 @@ export declare class GlmAdapter extends LlmAdapter {
     private readonly options;
     /** Live catalog ids, once discovery succeeded this session. */
     private live;
+    /** Image-generation model id, when discovery reported one. */
+    private imageModel;
     constructor(options: GlmAdapterOptions);
     providerInfo(provider: string): LlmProviderInfo;
     providerRetryPolicy(): undefined;
@@ -134,6 +136,8 @@ export declare class GlmAdapter extends LlmAdapter {
     private shippedCatalog;
     /** Ids the user published by hand that this route does not already serve. */
     private addedEntries;
+    /** The image-generation model id, when discovery reported one. */
+    imageModelId(): string | undefined;
     /** The ids the picker must currently omit. */
     private hidden;
     /**

package/lib/providers/glm.js

@@ -15,6 +15,9 @@ import { proxiedFetch } from '../http.js';
 import { findEntry, resolveCatalog } from './catalog.js';
 import { streamProviderResponses, accountPoolHooks } from './responses-stream.js';
 import { toResponsesInput, toResponsesTools } from '../translate/responses.js';
+import { isImageModel } 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;
 /** Provider route this module serves. */
 export const GLM_PROVIDER_ID = 'glm';
 /** Display name for the picker group and the Settings card. */
@@ -220,6 +223,8 @@ export class GlmAdapter extends LlmAdapter {
     options;
     /** Live catalog ids, once discovery succeeded this session. */
     live;
+    /** Image-generation model id, when discovery reported one. */
+    imageModel;
     constructor(options) {
         super();
         this.options = options;
@@ -238,7 +243,9 @@ export class GlmAdapter extends LlmAdapter {
         if (await this.options.tokens.session() === undefined)
             return [];
         const hidden = await this.hidden();
-        return resolveCatalog(this.catalog(), [], hidden).entries.map((entry) => ({
+        // Image models are never picker rows: they are agent-called, always on.
+        const imageless = this.catalog().filter((entry) => !isImageModel(entry.id));
+        return resolveCatalog(imageless, [], hidden).entries.map((entry) => ({
             provider: GLM_PROVIDER_ID,
             id: entry.id,
             name: entry.name,
@@ -326,6 +333,10 @@ export class GlmAdapter extends LlmAdapter {
             .filter((id) => findEntry(own, id) === undefined)
             .map((id) => extraEntry(id));
     }
+    /** The image-generation model id, when discovery reported one. */
+    imageModelId() {
+        return this.imageModel;
+    }
     /** The ids the picker must currently omit. */
     async hidden() {
         if (this.options.hiddenModels === undefined)
@@ -367,9 +378,12 @@ export class GlmAdapter extends LlmAdapter {
                 return undefined;
             }
             const body = await response.json();
-            const ids = (body.data ?? [])
+            const allIds = (body.data ?? [])
                 .map((entry) => (typeof entry?.id === 'string' ? entry.id.trim() : ''))
                 .filter((id) => id !== '');
+            // Image models are never picker rows: they are agent-called, always on.
+            this.imageModel = allIds.find((id) => isImageModel(id));
+            const ids = allIds.filter((id) => !NON_CHAT_ID.test(id));
             return ids.length === 0 ? undefined : ids;
         }
         catch (error) {