dsh-plugin-subscription-oauth 0.16.3 → 0.17.1

package/lib/providers/common.js

@@ -141,6 +141,29 @@ export function isMissingOrInvalidCredential(error) {
     }
     return false;
 }
+/** Body text that says the request named a model the account does not serve. */
+const UNKNOWN_MODEL = /model id does not exist|unknown model|model (?:id )?not found|does not exist, recognized as/i;
+/** Body text that names the model id to use instead. */
+const MODEL_REPLACEMENT = /set model id as\s*`?([A-Za-z0-9][A-Za-z0-9._:@[\]/-]*)`?/i;
+/**
+ * The model id a provider's failure names as the one to use instead.
+ *
+ * A 401/403 is not always about the credential: a provider also answers it when the
+ * request names a model id the account does not serve — Kimi says `Your model id does
+ * not exist, recognized as other:k3[1m]. Please set model id as \`k3\``. That message
+ * is the endpoint's own answer to "which id should I have used", so it is worth acting
+ * on rather than reporting: refreshing a healthy token, or marking the account as
+ * needing a new login, would both be wrong answers to a model rename.
+ *
+ * @param message - the failure text.
+ * @returns the replacement id, or undefined when the failure is not about the model id.
+ */
+export function unknownModelReplacement(message) {
+    if (!UNKNOWN_MODEL.test(message))
+        return undefined;
+    const replacement = MODEL_REPLACEMENT.exec(message)?.[1];
+    return replacement === undefined || replacement === '' ? undefined : replacement;
+}
 /**
  * Map a thrown transport failure onto a harness error, distinguishing caller
  * cancellation from an idle timeout from a genuine network fault.

package/lib/providers/glm-provider.d.ts

@@ -22,6 +22,16 @@ export interface GlmProviderOptions {
     defaultModel?: string;
     /** Extra model ids published without shipped metadata. */
     extraModels?: readonly string[];
+    /**
+     * The endpoint's last live listing, from this plugin's cache.
+     *
+     * The cached table is what the picker shows before any request: the endpoint's own
+     * answer from the last read, so a release does not need a plugin update and a refresh
+     * does not need a request.
+     */
+    cachedListing?: () => Promise<unknown>;
+    /** Record what a live listing just produced, replacing the cached table. */
+    saveListing?: (payload: unknown) => Promise<void>;
     /** Shared model-visibility preferences. */
     preferences: ModelPreferences;
     /** Resolve the attachment service per request. */

package/lib/providers/glm-provider.js

@@ -116,8 +116,14 @@ export function createGlmProvider(options) {
             return read.windows;
         },
         ...options.extraModels === undefined ? {} : { extraModels: options.extraModels },
+        ...options.defaultModel === undefined ? {} : { defaultModel: options.defaultModel },
+        ...options.cachedListing === undefined ? {} : { cachedListing: options.cachedListing },
+        ...options.saveListing === undefined ? {} : { saveListing: options.saveListing },
         fetchFn,
     });
+    // Read the cached table now rather than at the first picker query: the Settings page
+    // reads the catalog synchronously, so a request-free start must already have it.
+    void adapter.hydrate().catch(() => undefined);
     const spec = {
         id: GLM_PROVIDER_ID,
         displayName: GLM_PROVIDER_NAME,
@@ -166,9 +172,17 @@ export function createGlmProvider(options) {
         removeModel: (id) => controller.removeModel(id),
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
-        modelVariants: (id) => {
+        modelVariants: async (id) => {
+            // The image model is a row of the listing, so the read is awaited before answering:
+            // the composer asks once, and "no image model" must mean there is none.
+            void id;
+            await adapter.hydrate();
             const image = adapter.imageModelId();
-            return image === undefined ? undefined : { image };
+            return {
+                ...image === undefined ? {} : { image },
+                // Nothing read yet: the answer above is provisional, and the caller is told so.
+                ...adapter.hasListing() ? {} : { pending: true },
+            };
         },
     };
 }

package/lib/providers/glm.d.ts

@@ -6,6 +6,11 @@
  * requests and the model list then go to the coding-plan host, whose
  * `/responses` route answers the same wire the `kimi` and `grok` routes use.
  *
+ * The model table this route publishes is that host's own `/models` answer, read once
+ * and kept in this plugin's cache (see `hydrate` and `fetchCatalog`). Nothing in this
+ * module decides which models exist, so one released, renamed or retired server-side
+ * reaches the picker without a plugin update and without a request per refresh.
+ *
  * @module dsh-plugin-subscription-oauth/providers/glm
  */
 import { LlmAdapter } from '@deepseek-ai/dsh-llm';
@@ -44,14 +49,6 @@ export declare const GLM_DEFAULT_MODEL = "glm-5.3";
 export declare const GLM_CONTEXT_WINDOW = 1048576;
 /** Output budget used when the caller sets no cap. */
 export declare const GLM_DEFAULT_MAX_TOKENS = 131072;
-/**
- * The catalog this build ships, so a signed-in route is usable with no discovery.
- *
- * Ids are the wire ids, lowercase: the coding plan answers `glm-5.3`, not the
- * `GLM-5.3` display name its own client shows. `glm-5.3-flash` is the multimodal
- * member of the family; the rest read text only.
- */
-export declare const GLM_MODELS: readonly CatalogEntry[];
 /** One signed-in BigModel account. */
 export interface GlmSession extends SessionBase {
     /** ZCode JWT the coding plan is bound to; presented as the API key. */
@@ -82,6 +79,25 @@ export interface GlmAdapterOptions {
     userModels?: () => Promise<readonly string[]> | readonly string[];
     /** Extra ids published without shipped metadata. */
     extraModels?: readonly string[];
+    /**
+     * Model this route preselects, and therefore always offers.
+     *
+     * Configuration rather than a shipped fact: a subscription that re-points its
+     * alias at a new release follows the config instead of this build's release
+     * cadence. Defaults to {@link GLM_DEFAULT_MODEL}.
+     */
+    defaultModel?: string;
+    /**
+     * The endpoint's last live listing, from this plugin's cache.
+     *
+     * Read once per session, before the first catalog query, so the picker offers real
+     * models without asking the endpoint anything. A route that fetched once and cached
+     * the answer has no reason to fetch again on every refresh; the Settings "refresh
+     * models" action is what re-reads it.
+     */
+    cachedListing?: () => Promise<unknown>;
+    /** Record what a live listing just produced, replacing the cached table. */
+    saveListing?: (payload: unknown) => Promise<void>;
     /** Resolve the attachment service per request. */
     resolveAttachments?: () => AttachmentStore | undefined;
     onWarn?: (message: string) => void;
@@ -118,11 +134,46 @@ export declare function readGlmUsage(input: {
 /** The adapter behind the `glm` route. */
 export declare class GlmAdapter extends LlmAdapter {
     private readonly options;
-    /** Live catalog ids, once discovery succeeded this session. */
+    /**
+     * The catalog this route serves: entries derived from the endpoint's own listing,
+     * either the one just read or the one the cache kept from the last read.
+     *
+     * Undefined means neither source has produced a listing yet, so only the configured
+     * default model is offered until one does.
+     */
     private live;
-    /** Image-generation model id, when discovery reported one. */
+    /** Whether the cached listing has been read; it is read at most once per session. */
+    private hydrated;
+    /** Image-generation model id, when the listing reported one. */
     private imageModel;
+    /**
+     * Fast-variant wire id per picker row.
+     *
+     * Derived from the listing rather than a curated alias map: a row whose name is a
+     * listed model plus the provider's own fast word rides that row instead of becoming
+     * one of its own. GLM's own `-flash` id is a distinct model, not a variant, and is
+     * left as a row.
+     */
+    private readonly fastVariants;
     constructor(options: GlmAdapterOptions);
+    /**
+     * Adopt the rows of one live listing as this route's catalog.
+     *
+     * Everything the picker shows is derived here from the endpoint's own answer: the
+     * rows that become picker entries and the fast variant that pairs with each row.
+     * Nothing about which models exist, or what each one is, is decided by this build.
+     *
+     * @param rows - decoded rows of the endpoint's listing, in the endpoint's order.
+     * @returns the entries to publish, in picker order.
+     */
+    private adoptListing;
+    /**
+     * Read the cached listing, once, so the picker works without asking the endpoint.
+     *
+     * Called before the first catalog query. A read failure is a cache miss, never a
+     * failure: the route simply has no listing until one is fetched.
+     */
+    hydrate(): Promise<void>;
     providerInfo(provider: string): LlmProviderInfo;
     providerRetryPolicy(): undefined;
     listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
@@ -130,30 +181,63 @@ export declare class GlmAdapter extends LlmAdapter {
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
     /** Translate an auth failure into the message a user can act on. */
     private refreshHint;
-    /** The catalog served: the shipped list, the live one, then hand-added ids. */
+    /** The catalog served: the route's own entries, then hand-added ids. */
     private catalog;
-    /** The route's own catalog, without ids the user added by hand. */
+    /**
+     * The catalog to present: the models the endpoint's listing named, in its own order,
+     * each with the metadata that listing stated, then the configured extras.
+     *
+     * There is no shipped roster. A listing is read once and cached (see {@link hydrate}
+     * and {@link fetchCatalog}), and that cached table is what the picker shows until the
+     * next read, so a model released, renamed or retired server-side is reflected without
+     * a plugin update. Only the configured default is always offered, because the picker
+     * preselects it.
+     */
     private shippedCatalog;
+    /** The model the picker preselects, from configuration. */
+    private defaultModel;
     /** 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;
+    /**
+     * Whether this route has read a model listing yet.
+     *
+     * The image model is a row of the listing, so until one has been read "there is no image
+     * model" and "the listing has not arrived" look identical from outside; a caller that asks
+     * once needs to tell them apart.
+     */
+    hasListing(): boolean;
     /** The ids the picker must currently omit. */
     private hidden;
     /**
-     * Adopt the endpoint's live catalog.
+     * Adopt the ids a caller reports as the served set, without a listing.
+     *
+     * {@link fetchCatalog} already derived the entries from the rows it read, and the
+     * controller reports those same ids back here; the entries it recorded are kept. A
+     * caller that only has ids (a test, another discovery path) gets conservative entries
+     * for them.
      *
-     * @param ids - model ids the endpoint reported.
+     * @param ids - model ids the caller reports.
      */
     discover(ids: readonly string[]): void;
     /**
-     * Read the live model list.
+     * Read the endpoint's model listing and adopt it as this route's catalog.
+     *
+     * This is the one place a model table is produced, and it is the endpoint's own
+     * answer: what the listing names is what the picker offers, with the display name,
+     * context window, modalities and reasoning ladder the listing states. The rows are
+     * also handed to {@link GlmAdapterOptions.saveListing}, so the next session starts
+     * from this table instead of asking again — the Settings "refresh models" action is
+     * what re-reads it.
      *
      * @param accessToken - bearer for the account.
      * @param signal - optional cancellation.
-     * @returns the ids the endpoint serves, or undefined when it cannot be read.
+     * @returns the model ids now served, or undefined when the listing is unavailable.
      */
     fetchCatalog(accessToken: string, signal?: AbortSignal): Promise<readonly string[] | undefined>;
+    /** Persist one live listing, reporting a cache failure without failing the read. */
+    private saveListing;
     /** Send one streaming request over the Responses wire. */
     private request;
     /** Resolve image blocks through the attachment service, when it is present. */

package/lib/providers/glm.js

@@ -6,16 +6,21 @@
  * requests and the model list then go to the coding-plan host, whose
  * `/responses` route answers the same wire the `kimi` and `grok` routes use.
  *
+ * The model table this route publishes is that host's own `/models` answer, read once
+ * and kept in this plugin's cache (see `hydrate` and `fetchCatalog`). Nothing in this
+ * module decides which models exist, so one released, renamed or retired server-side
+ * reaches the picker without a plugin update and without a request per refresh.
+ *
  * @module dsh-plugin-subscription-oauth/providers/glm
  */
 import { LlmAdapter, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { REAUTH_REQUIRED, ProviderError } from '../errors.js';
 import { finiteInstant, nonEmpty } from '../auth/store.js';
 import { proxiedFetch } from '../http.js';
-import { findEntry, resolveCatalog } from './catalog.js';
+import { composeCatalog, fallbackEntry, findEntry, liveEntry, liveModelFacts, resolveCatalog } from './catalog.js';
 import { streamProviderResponses, accountPoolHooks } from './responses-stream.js';
 import { toResponsesInput, toResponsesTools } from '../translate/responses.js';
-import { isImageModel } from './grok.js';
+import { baseModelOf, FastVariantIndex, isFastVariant, 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. */
@@ -45,54 +50,6 @@ export const GLM_DEFAULT_MODEL = 'glm-5.3';
 export const GLM_CONTEXT_WINDOW = 1_048_576;
 /** Output budget used when the caller sets no cap. */
 export const GLM_DEFAULT_MAX_TOKENS = 131_072;
-/** Reasoning ladder the GLM 5.3 family accepts. */
-const GLM_53_EFFORTS = ['low', 'high', 'max'];
-/**
- * The catalog this build ships, so a signed-in route is usable with no discovery.
- *
- * Ids are the wire ids, lowercase: the coding plan answers `glm-5.3`, not the
- * `GLM-5.3` display name its own client shows. `glm-5.3-flash` is the multimodal
- * member of the family; the rest read text only.
- */
-export const GLM_MODELS = [
-    {
-        id: 'glm-5.3',
-        name: 'GLM-5.3',
-        description: 'Coding plan flagship, text only',
-        contextWindow: GLM_CONTEXT_WINDOW,
-        inputModalities: ['text'],
-        reasoningEfforts: [...GLM_53_EFFORTS],
-    },
-    {
-        id: 'glm-5.3-flash',
-        name: 'GLM-5.3 Flash',
-        description: 'Fast, reads images',
-        contextWindow: GLM_CONTEXT_WINDOW,
-        inputModalities: ['text', 'image'],
-        reasoningEfforts: [...GLM_53_EFFORTS],
-    },
-    {
-        id: 'glm-5.2',
-        name: 'GLM-5.2',
-        description: 'Previous flagship',
-        contextWindow: GLM_CONTEXT_WINDOW,
-        inputModalities: ['text'],
-    },
-    {
-        id: 'glm-5.1',
-        name: 'GLM-5.1',
-        description: 'Earlier 5.x release',
-        contextWindow: GLM_CONTEXT_WINDOW,
-        inputModalities: ['text'],
-    },
-    {
-        id: 'glm-5',
-        name: 'GLM-5',
-        description: 'First 5.x release',
-        contextWindow: GLM_CONTEXT_WINDOW,
-        inputModalities: ['text'],
-    },
-];
 /**
  * Coerce one decoded credential entry into a GLM session.
  *
@@ -221,14 +178,88 @@ async function httpFailure(response, label) {
 /** The adapter behind the `glm` route. */
 export class GlmAdapter extends LlmAdapter {
     options;
-    /** Live catalog ids, once discovery succeeded this session. */
+    /**
+     * The catalog this route serves: entries derived from the endpoint's own listing,
+     * either the one just read or the one the cache kept from the last read.
+     *
+     * Undefined means neither source has produced a listing yet, so only the configured
+     * default model is offered until one does.
+     */
     live;
-    /** Image-generation model id, when discovery reported one. */
+    /** Whether the cached listing has been read; it is read at most once per session. */
+    hydrated = false;
+    /** Image-generation model id, when the listing reported one. */
     imageModel;
+    /**
+     * Fast-variant wire id per picker row.
+     *
+     * Derived from the listing rather than a curated alias map: a row whose name is a
+     * listed model plus the provider's own fast word rides that row instead of becoming
+     * one of its own. GLM's own `-flash` id is a distinct model, not a variant, and is
+     * left as a row.
+     */
+    fastVariants = new FastVariantIndex();
     constructor(options) {
         super();
         this.options = options;
     }
+    /**
+     * Adopt the rows of one live listing as this route's catalog.
+     *
+     * Everything the picker shows is derived here from the endpoint's own answer: the
+     * rows that become picker entries and the fast variant that pairs with each row.
+     * Nothing about which models exist, or what each one is, is decided by this build.
+     *
+     * @param rows - decoded rows of the endpoint's listing, in the endpoint's order.
+     * @returns the entries to publish, in picker order.
+     */
+    adoptListing(rows) {
+        const facts = rows
+            .map((row) => liveModelFacts(row))
+            .filter((fact) => fact !== undefined);
+        // Image models are never picker rows: they are agent-called, always on.
+        this.imageModel = facts.find((fact) => isImageModel(fact.id))?.id;
+        this.fastVariants.clear();
+        for (const fact of facts)
+            this.fastVariants.noteListed(fact.id);
+        for (const fact of facts) {
+            const base = this.fastVariants.pair(fact.id);
+            this.fastVariants.note(fact.id, () => base ?? baseModelOf(fact.id));
+        }
+        // Fold a variant onto its row and drop the ids that are not chat models, keeping the
+        // endpoint's order. A row's own facts describe the row; a variant's describe the
+        // variant, so a row that is also listed is never overwritten by its variant.
+        const byId = new Map();
+        for (const fact of facts) {
+            if (NON_CHAT_ID.test(fact.id))
+                continue;
+            const id = isFastVariant(fact.id) ? this.fastVariants.pair(fact.id) ?? baseModelOf(fact.id) : fact.id;
+            if (id === fact.id || !byId.has(id))
+                byId.set(id, { ...fact, id });
+        }
+        return [...byId.values()].map((fact) => liveEntry(fact, [], GLM_CONTEXT_WINDOW, 'Reported by the GLM model list'));
+    }
+    /**
+     * Read the cached listing, once, so the picker works without asking the endpoint.
+     *
+     * Called before the first catalog query. A read failure is a cache miss, never a
+     * failure: the route simply has no listing until one is fetched.
+     */
+    async hydrate() {
+        if (this.hydrated)
+            return;
+        this.hydrated = true;
+        if (this.live !== undefined || this.options.cachedListing === undefined)
+            return;
+        try {
+            const rows = listingRows(await this.options.cachedListing());
+            if (rows.length > 0)
+                this.live = this.adoptListing(rows);
+        }
+        catch (error) {
+            this.options.onWarn?.(`cached model catalog unavailable (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
     providerInfo(provider) {
         return { id: provider, name: GLM_PROVIDER_NAME };
     }
@@ -242,6 +273,7 @@ export class GlmAdapter extends LlmAdapter {
         // must not appear in the picker, and Auto must not try it.
         if (await this.options.tokens.session() === undefined)
             return [];
+        await this.hydrate();
         const hidden = await this.hidden();
         // Image models are never picker rows: they are agent-called, always on.
         const imageless = this.catalog().filter((entry) => !isImageModel(entry.id));
@@ -254,11 +286,12 @@ export class GlmAdapter extends LlmAdapter {
         }));
     }
     async resolveModel(_provider, model) {
+        await this.hydrate();
         const entry = findEntry(this.catalog(), model);
         if (entry === undefined) {
             // An id this build has never heard of is still dispatchable: the endpoint is
             // the authority on what it serves, and a newer model should not be refused.
-            const template = findEntry(this.catalog(), GLM_DEFAULT_MODEL) ?? this.catalog()[0];
+            const template = findEntry(this.catalog(), this.defaultModel()) ?? this.catalog()[0];
             return {
                 provider: GLM_PROVIDER_ID,
                 id: model,
@@ -304,24 +337,34 @@ export class GlmAdapter extends LlmAdapter {
         }
         return error;
     }
-    /** The catalog served: the shipped list, the live one, then hand-added ids. */
+    /** The catalog served: the route's own entries, then hand-added ids. */
     catalog() {
         return [...this.shippedCatalog(), ...this.addedEntries()];
     }
-    /** The route's own catalog, without ids the user added by hand. */
+    /**
+     * The catalog to present: the models the endpoint's listing named, in its own order,
+     * each with the metadata that listing stated, then the configured extras.
+     *
+     * There is no shipped roster. A listing is read once and cached (see {@link hydrate}
+     * and {@link fetchCatalog}), and that cached table is what the picker shows until the
+     * next read, so a model released, renamed or retired server-side is reflected without
+     * a plugin update. Only the configured default is always offered, because the picker
+     * preselects it.
+     */
     shippedCatalog() {
-        const shipped = this.options.extraModels === undefined
-            ? [...GLM_MODELS]
-            : [...GLM_MODELS, ...this.options.extraModels.map((id) => extraEntry(id))];
-        const live = this.live;
-        if (live === undefined)
-            return shipped;
-        const merged = [...shipped];
-        for (const id of live) {
-            if (findEntry(merged, id) === undefined)
-                merged.push(extraEntry(id));
-        }
-        return merged;
+        return composeCatalog({
+            curated: [],
+            ...this.live === undefined ? {} : { live: this.live },
+            ...this.options.extraModels === undefined ? {} : { extra: this.options.extraModels },
+            defaultModel: this.defaultModel(),
+            fallbackContextWindow: GLM_CONTEXT_WINDOW,
+            liveDescription: 'Reported by the GLM model list',
+            extraDescription: 'Extra model from the plugin configuration',
+        });
+    }
+    /** The model the picker preselects, from configuration. */
+    defaultModel() {
+        return this.options.defaultModel ?? GLM_DEFAULT_MODEL;
     }
     /** Ids the user published by hand that this route does not already serve. */
     addedEntries() {
@@ -331,12 +374,22 @@ export class GlmAdapter extends LlmAdapter {
             return [];
         return (Array.isArray(added) ? added : [])
             .filter((id) => findEntry(own, id) === undefined)
-            .map((id) => extraEntry(id));
+            .map((id) => fallbackEntry(id, 'Added by hand in Settings', GLM_CONTEXT_WINDOW));
     }
     /** The image-generation model id, when discovery reported one. */
     imageModelId() {
         return this.imageModel;
     }
+    /**
+     * Whether this route has read a model listing yet.
+     *
+     * The image model is a row of the listing, so until one has been read "there is no image
+     * model" and "the listing has not arrived" look identical from outside; a caller that asks
+     * once needs to tell them apart.
+     */
+    hasListing() {
+        return this.live !== undefined;
+    }
     /** The ids the picker must currently omit. */
     async hidden() {
         if (this.options.hiddenModels === undefined)
@@ -350,19 +403,33 @@ export class GlmAdapter extends LlmAdapter {
         }
     }
     /**
-     * Adopt the endpoint's live catalog.
+     * Adopt the ids a caller reports as the served set, without a listing.
+     *
+     * {@link fetchCatalog} already derived the entries from the rows it read, and the
+     * controller reports those same ids back here; the entries it recorded are kept. A
+     * caller that only has ids (a test, another discovery path) gets conservative entries
+     * for them.
      *
-     * @param ids - model ids the endpoint reported.
+     * @param ids - model ids the caller reports.
      */
     discover(ids) {
-        this.live = [...ids];
+        const known = new Map((this.live ?? []).map((entry) => [entry.id, entry]));
+        this.live = ids.map((id) => known.get(id)
+            ?? liveEntry({ id }, [], GLM_CONTEXT_WINDOW, 'Reported by the GLM model list'));
     }
     /**
-     * Read the live model list.
+     * Read the endpoint's model listing and adopt it as this route's catalog.
+     *
+     * This is the one place a model table is produced, and it is the endpoint's own
+     * answer: what the listing names is what the picker offers, with the display name,
+     * context window, modalities and reasoning ladder the listing states. The rows are
+     * also handed to {@link GlmAdapterOptions.saveListing}, so the next session starts
+     * from this table instead of asking again — the Settings "refresh models" action is
+     * what re-reads it.
      *
      * @param accessToken - bearer for the account.
      * @param signal - optional cancellation.
-     * @returns the ids the endpoint serves, or undefined when it cannot be read.
+     * @returns the model ids now served, or undefined when the listing is unavailable.
      */
     async fetchCatalog(accessToken, signal) {
         if (!this.options.discovery)
@@ -374,23 +441,40 @@ export class GlmAdapter extends LlmAdapter {
                 ...signal === undefined ? {} : { signal },
             });
             if (!response.ok) {
-                this.options.onWarn?.(`GLM model list unavailable (HTTP ${response.status})`);
+                this.options.onWarn?.(`GLM model list unavailable (HTTP ${response.status}); keeping the last catalog`);
                 return undefined;
             }
-            const body = await response.json();
-            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;
+            const payload = await response.json();
+            const rows = Array.isArray(payload.data) ? payload.data : [];
+            const entries = this.adoptListing(rows);
+            if (entries.length === 0) {
+                this.options.onWarn?.('GLM model discovery returned an empty catalog; keeping the last catalog');
+                return undefined;
+            }
+            this.live = entries;
+            // The cached table is the endpoint's answer, kept so the next session does not ask
+            // again. A cache failure never fails the read that produced it.
+            await this.saveListing(rows);
+            return entries.map((entry) => entry.id);
         }
         catch (error) {
+            if (signal?.aborted === true)
+                return undefined;
             this.options.onWarn?.(`GLM model list unavailable (${error instanceof Error ? error.message : String(error)})`);
             return undefined;
         }
     }
+    /** Persist one live listing, reporting a cache failure without failing the read. */
+    async saveListing(rows) {
+        if (this.options.saveListing === undefined)
+            return;
+        try {
+            await this.options.saveListing(rows);
+        }
+        catch (error) {
+            this.options.onWarn?.(`model catalog cache write failed (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
     /** Send one streaming request over the Responses wire. */
     async request(options, model, accessToken, signal) {
         const resolveImage = this.imageResolver(signal);
@@ -446,9 +530,22 @@ export class GlmAdapter extends LlmAdapter {
         return this.catalog();
     }
 }
-/** An entry for an id this build ships no metadata for. */
-function extraEntry(id) {
-    return { id, name: id, contextWindow: GLM_CONTEXT_WINDOW };
+/**
+ * The rows of one cached listing.
+ *
+ * The cache holds the rows this plugin stored; a payload written as the endpoint's own
+ * envelope is read too, so a differently shaped cache cannot silently empty the picker.
+ *
+ * @param payload - whatever `cachedListing` returned.
+ * @returns the rows to adopt, or an empty list when the payload names none.
+ */
+function listingRows(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    const data = typeof payload === 'object' && payload !== null
+        ? payload.data
+        : undefined;
+    return Array.isArray(data) ? data : [];
 }
 /** The reasoning block for a catalog entry, or undefined when it supports none. */
 function reasoningInfo(entry) {