dsh-plugin-subscription-oauth 0.17.0 → 0.17.2

package/lib/protocol.d.ts

@@ -397,6 +397,15 @@ export interface ModelVariants {
     fastRung?: string;
     /** Image-generation model wire id, when the provider reported one. */
     image?: string;
+    /**
+     * The route has not read its model listing yet, so "no variant" is not yet an answer.
+     *
+     * A listing is read once per session and its variants are derived from it, so an early
+     * read of this endpoint cannot tell "this model has no fast variant" from "the route has
+     * not looked yet". Saying so lets the caller ask again later instead of hiding a control
+     * that should be there — and, once a listing has been read, lets it stop asking.
+     */
+    pending?: boolean;
 }
 /** Result of `model-variants`: the variants for one model id. */
 export type ModelVariantsResult = ModelVariants | undefined;

package/lib/providers/ark-provider.js

@@ -176,9 +176,17 @@ export function createArkProvider(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/ark.d.ts

@@ -163,6 +163,14 @@ export declare class ArkAdapter extends LlmAdapter {
     listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
     /** 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;
     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

@@ -228,6 +228,16 @@ export class ArkAdapter extends LlmAdapter {
     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;
+    }
     async resolveModel(_provider, model) {
         await this.hydrate();
         const entry = findEntry(this.catalog(), model);

package/lib/providers/catalog.d.ts

@@ -88,7 +88,8 @@ export declare function liveModelFacts(row: unknown): LiveModelFacts | undefined
  * What the endpoint stated wins; the curated table fills only what the listing was
  * silent about, so a live figure — the window a model actually serves today — is
  * never overridden by a shipped guess, and a retired figure never survives a live
- * read that contradicts it.
+ * read that contradicts it. A route whose ids are stable aliases the service re-points
+ * per release keeps its own labels instead (see the kimi route's alias labels).
  *
  * @param facts - what the listing stated for this id.
  * @param curated - the curated metadata table.

package/lib/providers/catalog.js

@@ -163,7 +163,8 @@ export function liveModelFacts(row) {
  * What the endpoint stated wins; the curated table fills only what the listing was
  * silent about, so a live figure — the window a model actually serves today — is
  * never overridden by a shipped guess, and a retired figure never survives a live
- * read that contradicts it.
+ * read that contradicts it. A route whose ids are stable aliases the service re-points
+ * per release keeps its own labels instead (see the kimi route's alias labels).
  *
  * @param facts - what the listing stated for this id.
  * @param curated - the curated metadata table.

package/lib/providers/glm-provider.js

@@ -172,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

@@ -200,6 +200,14 @@ export declare class GlmAdapter extends LlmAdapter {
     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;
     /**

package/lib/providers/glm.js

@@ -380,6 +380,16 @@ export class GlmAdapter extends LlmAdapter {
     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)

package/lib/providers/grok.d.ts

@@ -337,6 +337,14 @@ export declare class GrokAdapter extends LlmAdapter {
     } | undefined;
     /** The image-generation model id, when discovery reported one. */
     imageModelId(): string | undefined;
+    /**
+     * Whether this route has read a model listing yet.
+     *
+     * A variant is derived from the listing, so until one has been read "this model has no
+     * variant" and "the listing has not arrived" look identical from outside; a caller that
+     * asks once (the composer's quick-mode button) needs to tell them apart.
+     */
+    hasListing(): boolean;
     /** The curated catalog, for the Settings page's model list. */
     catalogEntries(): readonly CatalogEntry[];
     /** What this route itself serves, without the ids added by hand. */

package/lib/providers/grok.js

@@ -868,6 +868,16 @@ export class GrokAdapter extends LlmAdapter {
     imageModelId() {
         return this.imageModel;
     }
+    /**
+     * Whether this route has read a model listing yet.
+     *
+     * A variant is derived from the listing, so until one has been read "this model has no
+     * variant" and "the listing has not arrived" look identical from outside; a caller that
+     * asks once (the composer's quick-mode button) needs to tell them apart.
+     */
+    hasListing() {
+        return this.live !== undefined;
+    }
     /** The curated catalog, for the Settings page's model list. */
     catalogEntries() {
         return this.catalog();
@@ -1193,12 +1203,19 @@ export function createGrokProvider(options) {
         removeModel: (id) => controller.removeModel(id),
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
-        modelVariants: (id) => {
+        modelVariants: async (id) => {
+            // A variant is known only once the route has read its listing, whose rows name it.
+            // The composer asks exactly once, so the read is awaited here: "no fast variant"
+            // must mean the route really has none, not that its table was still loading.
+            await adapter.hydrate();
             const pair = adapter.fastPairOf(id);
             const image = adapter.imageModelId();
             return {
                 ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId, fastRung: fastWordOf(pair.wireId) },
                 ...image === undefined ? {} : { image },
+                // Nothing read yet: the answer above is provisional, and the caller is told so
+                // rather than being left to read silence as "this model has no variant".
+                ...adapter.hasListing() ? {} : { pending: true },
             };
         },
     };

package/lib/providers/kimi-provider.js

@@ -156,12 +156,19 @@ export function createKimiProvider(options) {
         removeModel: (id) => controller.removeModel(id),
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
-        modelVariants: (id) => {
+        modelVariants: async (id) => {
+            // A variant is known only once the route has read its listing, whose row names it.
+            // The composer asks exactly once, so the read is awaited here: "no fast variant"
+            // must mean the route really has none, not that its table was still loading.
+            await adapter.hydrate();
             const pair = adapter.fastPairOf(id);
             const image = adapter.imageModelId();
             return {
                 ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId, fastRung: fastWordOf(pair.wireId) },
                 ...image === undefined ? {} : { image },
+                // Nothing read yet: the answer above is provisional, and the caller is told so
+                // rather than being left to read silence as "this model has no variant".
+                ...adapter.hasListing() ? {} : { pending: true },
             };
         },
     };

package/lib/providers/kimi.d.ts

@@ -161,6 +161,16 @@ export declare class KimiAdapter extends LlmAdapter {
      * @returns the entries to publish, in picker order.
      */
     private adoptListing;
+    /**
+     * Put this route's stable label on one entry, when the id has one.
+     *
+     * The listing states what the model *is*; the label states what the *id* is, which only
+     * this route knows (see {@link STABLE_MODEL_LABELS}).
+     *
+     * @param entry - the entry built from the listing.
+     * @returns the entry, relabelled when its id has a stable label.
+     */
+    private labelled;
     /**
      * Read the cached listing, once, so the picker works without asking the endpoint.
      *
@@ -173,6 +183,14 @@ export declare class KimiAdapter extends LlmAdapter {
         baseId: string;
         wireId: string;
     } | undefined;
+    /**
+     * Whether this route has read a model listing yet.
+     *
+     * A variant is derived from the listing, so until one has been read "this model has no
+     * variant" and "the listing has not arrived" look identical from outside; a caller that
+     * asks once (the composer's quick-mode button) needs to tell them apart.
+     */
+    hasListing(): boolean;
     /**
      * Tool schemas in the shape Moonshot accepts: no `$ref`, and under its size
      * ceiling. A declaration too large to send keeps its arguments, and that is

package/lib/providers/kimi.js

@@ -71,6 +71,35 @@ const EFFORT_LABELS = {
     // is "highspeed", which is what the rung is named here.
     [FAST_RUNG]: { name: 'Highspeed', description: 'Kimi highspeed variant of this model' },
 };
+/**
+ * Stable labels for the ids this route is known for.
+ *
+ * Labels, not a roster: nothing here decides which models exist or what they serve —
+ * membership, windows, ladders and modalities are the endpoint's listing. What it fixes is
+ * the one thing the listing cannot answer, because the id does not name it: `kimi-for-coding`
+ * is the subscription alias the service re-points at each coding release, so its
+ * `display_name` names the release of the moment (`K2.8 Preview` the week K2.8 ships) while
+ * the id the user selected stays the same. Labelling that row by release would rename the
+ * user's saved selection overnight, so the alias keeps its own name — and the endpoint's
+ * release name is deliberately not shown, because the row is the alias, not the version.
+ *
+ * A model the endpoint adds that this map does not name is published exactly as the
+ * endpoint describes it.
+ */
+const STABLE_MODEL_LABELS = {
+    'kimi-for-coding': {
+        name: 'Kimi for Coding',
+        description: 'Subscription alias — the endpoint re-points it at the current coding release',
+    },
+    'k3': {
+        name: 'Kimi K3',
+        description: 'Flagship reasoning model',
+    },
+    'k3-256k': {
+        name: 'Kimi K3 (256K)',
+        description: 'Flagship reasoning model pinned to the 256K-token window',
+    },
+};
 /**
  * Spellings the endpoint has retired, and the model each one became.
  *
@@ -185,7 +214,20 @@ export class KimiAdapter extends LlmAdapter {
             if (id === fact.id || !byId.has(id))
                 byId.set(id, { ...fact, id });
         }
-        return [...byId.values()].map((fact) => liveEntry(fact, [], KIMI_CONTEXT_WINDOW, 'Reported by the Kimi Code model list'));
+        return [...byId.values()].map((fact) => this.labelled(liveEntry(fact, [], KIMI_CONTEXT_WINDOW, 'Reported by the Kimi Code model list')));
+    }
+    /**
+     * Put this route's stable label on one entry, when the id has one.
+     *
+     * The listing states what the model *is*; the label states what the *id* is, which only
+     * this route knows (see {@link STABLE_MODEL_LABELS}).
+     *
+     * @param entry - the entry built from the listing.
+     * @returns the entry, relabelled when its id has a stable label.
+     */
+    labelled(entry) {
+        const stable = STABLE_MODEL_LABELS[entry.id];
+        return stable === undefined ? entry : { ...entry, name: stable.name, description: stable.description };
     }
     /**
      * Read the cached listing, once, so the picker works without asking the endpoint.
@@ -212,6 +254,16 @@ export class KimiAdapter extends LlmAdapter {
     fastPairOf(id) {
         return this.fastVariants.pairOf(id);
     }
+    /**
+     * Whether this route has read a model listing yet.
+     *
+     * A variant is derived from the listing, so until one has been read "this model has no
+     * variant" and "the listing has not arrived" look identical from outside; a caller that
+     * asks once (the composer's quick-mode button) needs to tell them apart.
+     */
+    hasListing() {
+        return this.live !== undefined;
+    }
     /**
      * Tool schemas in the shape Moonshot accepts: no `$ref`, and under its size
      * ceiling. A declaration too large to send keeps its arguments, and that is
@@ -465,7 +517,7 @@ export class KimiAdapter extends LlmAdapter {
     discover(ids) {
         const known = new Map((this.live ?? []).map((entry) => [entry.id, entry]));
         this.live = ids.map((id) => known.get(id)
-            ?? liveEntry({ id }, [], KIMI_CONTEXT_WINDOW, 'Reported by the Kimi Code model list'));
+            ?? this.labelled(liveEntry({ id }, [], KIMI_CONTEXT_WINDOW, 'Reported by the Kimi Code model list')));
     }
     /** The catalog, for the Settings page's model list. */
     catalogEntries() {

package/lib/providers/workbuddy.d.ts

@@ -181,18 +181,20 @@ export declare class WorkBuddyAdapter extends LlmAdapter {
     /**
      * The stored session one access token belongs to.
      *
-     * Discovery is handed the account's token rather than the session it came from, and the
-     * console route is attributed by that session's own fields, so the session is read back
-     * here. The first account whose stored token matches wins; a token that matches none
-     * falls back to the route's current session. A read failure is never fatal — the listing
-     * is still read with the token the caller passed.
-     *
-     * @param accessToken - the token discovery was called with.
-     * @returns the session's fields as a signable token, or undefined when none was readable.
+     * The chat signs with the resolved token, but the request still needs the session's
+     * attribution fields (`uid`, `enterpriseId`, `domain`). They are read back by matching
+     * the resolved token against each stored account; a token that matches none (already
+     * rotated away) leaves the caller to sign with the bare token.
      */
     private sessionFor;
     providerRetryPolicy(): undefined;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /**
+     * One chat-completions POST, named the way WorkBuddy's own client names a chat: the
+     * message, the request, the turn, and the conversation. Without these the gateway
+     * counts the request under no client and can cut the stream.
+     */
+    private post;
     /** The stored session's fields as the token the request signs with. */
     private tokenOf;
     private requestBody;

package/lib/providers/workbuddy.js

@@ -614,14 +614,10 @@ export class WorkBuddyAdapter extends LlmAdapter {
     /**
      * The stored session one access token belongs to.
      *
-     * Discovery is handed the account's token rather than the session it came from, and the
-     * console route is attributed by that session's own fields, so the session is read back
-     * here. The first account whose stored token matches wins; a token that matches none
-     * falls back to the route's current session. A read failure is never fatal — the listing
-     * is still read with the token the caller passed.
-     *
-     * @param accessToken - the token discovery was called with.
-     * @returns the session's fields as a signable token, or undefined when none was readable.
+     * The chat signs with the resolved token, but the request still needs the session's
+     * attribution fields (`uid`, `enterpriseId`, `domain`). They are read back by matching
+     * the resolved token against each stored account; a token that matches none (already
+     * rotated away) leaves the caller to sign with the bare token.
      */
     async sessionFor(accessToken) {
         try {
@@ -630,8 +626,7 @@ export class WorkBuddyAdapter extends LlmAdapter {
                 if (held?.session.accessToken === accessToken)
                     return this.tokenOf(held.session);
             }
-            const current = await this.options.tokens.session();
-            return current === undefined ? undefined : this.tokenOf(current.session);
+            return undefined;
         }
         catch {
             return undefined;
@@ -642,10 +637,11 @@ export class WorkBuddyAdapter extends LlmAdapter {
     }
     async *stream(options) {
         diag(`stream entered: model=${options.model} provider=${options.provider}`);
-        const held = await this.options.tokens.session();
-        if (held === undefined)
-            throw new Error('WorkBuddy is not signed in');
-        const token = this.tokenOf(held.session);
+        // Resolve (not just read) the session so a token close to its end is refreshed
+        // eagerly, the way WorkBuddy's own app does — a bare session can carry an expired
+        // access token into the request, which the gateway refuses with a 403.
+        const held = await this.options.tokens.resolve();
+        const session = await this.sessionFor(held.accessToken);
         const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
         // Capture the tool-call history so unsafe tool names in past turns can be renamed to
         // the safe ones the model now sees, keeping the conversation consistent.
@@ -653,28 +649,24 @@ export class WorkBuddyAdapter extends LlmAdapter {
         // The last usage frame carries the turn's real billed credit; record it so the spend
         // total is a sum of real figures, not an estimate.
         const turn = { credit: 0 };
-        diag(`stream start: model=${options.model} account=${held.account} expiresAt=${held.session.expiresAt} now=${Date.now()}`);
+        diag(`stream start: model=${options.model} account=${held.account} expiresAt=${held.expiresAt} now=${Date.now()}`);
         try {
             const { body, names } = this.requestBody(options, history);
             diag(`body: keys=${Object.keys(body).join(',')} messages=${Array.isArray(body.messages) ? body.messages.length : 0} model=${String(body.model)}`);
-            const response = await this.fetchFn(WORKBUDDY_API, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Accept': 'text/event-stream',
-                    ...workbuddyHeaders(token),
-                    // Name the chat the way WorkBuddy's own client does: the message, the request,
-                    // the turn, and the conversation. Without these the gateway counts the request
-                    // under no client and can cut the stream.
-                    'X-Conversation-Message-ID': randomHex(),
-                    'X-Request-ID': randomHex(),
-                    'X-Conversation-Request-ID': randomHex(),
-                    'X-Conversation-ID': randomHex(),
-                },
-                body: JSON.stringify(body),
-                signal: watchdog.signal,
-            });
-            diag(`response: status=${response.status} ok=${response.ok} ct=${response.headers.get('content-type') ?? ''}`);
+            // Post once with the resolved token. A 401/403 can mean the access token lapsed
+            // between resolve() and now: force one refresh and post again, as WorkBuddy's own
+            // client does — a 403 with a genuinely dead credential keeps its meaning below.
+            let response = await this.post(body, session ?? held, watchdog.signal);
+            if (response.status === 401 || response.status === 403) {
+                diag(`response: ${response.status} on resolved token; forcing one refresh and retrying`);
+                const refreshed = await this.options.tokens.resolve(held.account, true);
+                const fresh = await this.sessionFor(refreshed.accessToken);
+                response = await this.post(body, fresh ?? refreshed, watchdog.signal);
+                diag(`response after refresh: status=${response.status} ok=${response.ok} ct=${response.headers.get('content-type') ?? ''}`);
+            }
+            else {
+                diag(`response: status=${response.status} ok=${response.ok} ct=${response.headers.get('content-type') ?? ''}`);
+            }
             // WorkBuddy refuses a chat mid-stream when the request carries words it filters; a
             // 403/400 here names why, so surface it instead of dying on an empty stream.
             if (!response.ok || response.body === null) {
@@ -692,6 +684,27 @@ export class WorkBuddyAdapter extends LlmAdapter {
             }
         }
     }
+    /**
+     * One chat-completions POST, named the way WorkBuddy's own client names a chat: the
+     * message, the request, the turn, and the conversation. Without these the gateway
+     * counts the request under no client and can cut the stream.
+     */
+    post(body, token, signal) {
+        return this.fetchFn(WORKBUDDY_API, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'text/event-stream',
+                ...workbuddyHeaders(token),
+                'X-Conversation-Message-ID': randomHex(),
+                'X-Request-ID': randomHex(),
+                'X-Conversation-Request-ID': randomHex(),
+                'X-Conversation-ID': randomHex(),
+            },
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
     /** The stored session's fields as the token the request signs with. */
     tokenOf(session) {
         return {

package/package.json

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