dsh-plugin-subscription-oauth 0.8.16 → 0.8.18

package/lib/protocol.d.ts

@@ -364,6 +364,14 @@ export interface ModelVariants {
      * already the fast variant, which is not itself a listed row.
      */
     fastBase?: string;
+    /**
+     * The reasoning rung that selects the fast variant.
+     *
+     * Each provider names its own variant (xAI `lightspeed`, Kimi `highspeed`), so the
+     * rung is the provider's word — the picker reads it, and the stream maps it back to
+     * the variant's wire id. Defaults to `fast`.
+     */
+    fastRung?: string;
     /** Image-generation model wire id, when the provider reported one. */
     image?: string;
 }

package/lib/providers/grok.js

@@ -51,12 +51,19 @@ export const GROK_DEFAULT_MAX_TOKENS = 32_000;
 export const GROK_PREEMPT_MS = 2 * 60 * 1000;
 /** Hosts an authorization server endpoint may live on. */
 const TRUSTED_AUTH_HOSTS = new Set(['auth.x.ai', 'accounts.x.ai']);
+/** The rung id the composer's quick-mode button selects. */
+const FAST_RUNG = 'lightspeed';
 /** Display metadata for the reasoning ladder xAI documents. */
 const EFFORT_LABELS = {
     none: { name: 'Off', description: 'Answer without spending thinking tokens' },
     low: { name: 'Low', description: 'Short chain of thought' },
     medium: { name: 'Medium', description: 'Balanced thinking budget' },
     high: { name: 'High', description: 'Deep chain of thought' },
+    // Not a thinking budget: this rung is the model's fast/lightspeed variant, which the
+    // composer's quick-mode button selects. It rides the effort channel so the row keeps
+    // its own id — a swapped model id would leave the picker with no way back. xAI's own
+    // word for it is "lightspeed", which is what the rung is named here.
+    [FAST_RUNG]: { name: 'Lightspeed', description: 'xAI lightspeed variant of this model' },
 };
 /**
  * Curated catalog entries.
@@ -123,13 +130,19 @@ function effortInfo(effort) {
     const label = EFFORT_LABELS[effort] ?? { name: effort, description: '' };
     return { id: ReasoningEffortId(effort), name: label.name, description: label.description };
 }
-/** The reasoning block for a catalog entry, or undefined when it supports none. */
-function reasoningInfo(entry) {
+/**
+ * The reasoning block for a catalog entry, or undefined when it supports none.
+ *
+ * @param entry - the catalog row.
+ * @param fast - add the `fast` rung when this row has a fast variant.
+ */
+function reasoningInfo(entry, fast = false) {
     const efforts = entry.reasoningEfforts;
-    if (efforts === undefined || efforts.length === 0)
+    const ids = fast ? [...efforts ?? [], FAST_RUNG] : efforts;
+    if (ids === undefined || ids.length === 0)
         return undefined;
     return {
-        efforts: efforts.map(effortInfo),
+        efforts: ids.map(effortInfo),
         ...entry.defaultEffort === undefined ? {} : { defaultEffort: ReasoningEffortId(entry.defaultEffort) },
     };
 }
@@ -446,24 +459,18 @@ export class GrokAdapter extends LlmAdapter {
             return [];
         await this.syncUserModels();
         const hidden = await this.hidden();
-        // The host validates a GUI selection against the exact ids `listModels` returns
-        // and refuses an unknown one with `session/model-unavailable`, and its picker
-        // lists every returned id as its own row. So a fast variant is published under
-        // its base id: selecting it names the variant the request must send, and the
-        // base's own id is withheld so the variant does not appear twice.
+        // One row per model, always under the model's own id: the host validates every GUI
+        // selection against this list, so publishing only the fast variant would leave the
+        // picker with no way back to the standard model. Fast mode is the row's `fast`
+        // reasoning rung instead (see `stream`).
         const imageless = this.catalog().filter((entry) => !isImageModel(entry.id));
-        const listed = resolveCatalog(imageless, [], hidden).entries.map((entry) => {
-            const fast = this.fastVariants.variantOf(entry.id);
-            const id = fast ?? entry.id;
-            return {
-                provider: GROK_PROVIDER_ID,
-                id,
-                name: entry.name,
-                ...entry.description === undefined ? {} : { description: entry.description },
-                ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
-            };
-        });
-        return listed;
+        return resolveCatalog(imageless, [], hidden).entries.map((entry) => ({
+            provider: GROK_PROVIDER_ID,
+            id: entry.id,
+            name: entry.name,
+            ...entry.description === undefined ? {} : { description: entry.description },
+            ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
+        }));
     }
     async hidden() {
         if (this.options.hiddenModels === undefined)
@@ -496,14 +503,13 @@ export class GrokAdapter extends LlmAdapter {
                 ...reasoning === undefined ? {} : { reasoning },
             };
         }
-        const reasoning = reasoningInfo(entry);
-        // The fast selection names itself "Fast" so the picker trigger reads the mode, not
-        // the base model it replaces; the id stays the fast wire id the request must send.
-        const fast = pair !== undefined && pair.wireId === model;
+        // A row with a fast variant offers the `fast` rung; the picker shows the row under
+        // its own name and the mode as the effort, which is what the trigger already reads.
+        const reasoning = reasoningInfo(entry, this.fastVariants.variantOf(entry.id) !== undefined);
         return {
             provider: GROK_PROVIDER_ID,
             id: model,
-            name: fast ? `${entry.name} Fast` : entry.name,
+            name: entry.name,
             ...entry.description === undefined ? {} : { description: entry.description },
             ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
             context: { contextWindow: entry.contextWindow },
@@ -513,8 +519,17 @@ export class GrokAdapter extends LlmAdapter {
     }
     stream(options) {
         // Resolve @Nk context suffixes to the largest variant the endpoint offers.
-        const model = this.resolveModelId(options.model);
-        return streamProviderResponses({ ...options, model }, {
+        const base = this.resolveModelId(options.model);
+        // Fast mode rides the reasoning channel: `fast` is a rung of the row, not a model id
+        // of its own, so the row the picker selected stays dispatchable and the user can
+        // always select the standard model again. Only the wire id changes.
+        const fast = String(options.reasoningEffort ?? '') === FAST_RUNG;
+        const model = fast ? this.fastVariants.variantOf(base) ?? base : base;
+        const call = { ...options, model };
+        // xAI has no `fast` effort; the variant already carries the behaviour.
+        if (fast)
+            delete call.reasoningEffort;
+        return streamProviderResponses(call, {
             label: 'xAI API',
             tokens: this.options.tokens,
             request: (call, model, accessToken, signal) => this.request(call, model, accessToken, signal),
@@ -988,7 +1003,7 @@ export function createGrokProvider(options) {
             const pair = adapter.fastPairOf(id);
             const image = adapter.imageModelId();
             return {
-                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId },
+                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId, fastRung: 'lightspeed' },
                 ...image === undefined ? {} : { image },
             };
         },

package/lib/providers/kimi-provider.js

@@ -154,7 +154,7 @@ export function createKimiProvider(options) {
             const pair = adapter.fastPairOf(id);
             const image = adapter.imageModelId();
             return {
-                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId },
+                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId, fastRung: 'highspeed' },
                 ...image === undefined ? {} : { image },
             };
         },

package/lib/providers/kimi.js

@@ -55,6 +55,8 @@ const EFFORT_WIRE_MAP = {
     xhigh: 'max',
     max: 'max',
 };
+/** The rung id the composer's quick-mode button selects. */
+const FAST_RUNG = 'highspeed';
 /** Display metadata for the reasoning ladder shared by every live coding model. */
 const EFFORT_LABELS = {
     none: { name: 'Off', description: 'Answer without spending thinking tokens' },
@@ -63,6 +65,11 @@ const EFFORT_LABELS = {
     high: { name: 'High', description: 'Deep chain of thought' },
     xhigh: { name: 'Max', description: 'Highest thinking budget Kimi accepts' },
     max: { name: 'Max', description: 'Highest thinking budget Kimi accepts' },
+    // Not a thinking budget: this rung is the model's fast variant, which the composer's
+    // quick-mode button selects. It rides the effort channel so the row keeps its own id —
+    // a swapped model id would leave the picker with no way back. Kimi's own word for it
+    // is "highspeed", which is what the rung is named here.
+    [FAST_RUNG]: { name: 'Highspeed', description: 'Kimi highspeed variant of this model' },
 };
 /**
  * Kimi Code's live coding catalog.
@@ -116,14 +123,20 @@ function effortInfo(effort) {
     const label = EFFORT_LABELS[effort] ?? { name: effort, description: '' };
     return { id: ReasoningEffortId(effort), name: label.name, description: label.description };
 }
-/** The reasoning block for a catalog entry, or undefined when it supports none. */
-function reasoningInfo(entry) {
+/**
+ * The reasoning block for a catalog entry, or undefined when it supports none.
+ *
+ * @param entry - the catalog row.
+ * @param fast - add the `fast` rung when this row has a fast variant.
+ */
+function reasoningInfo(entry, fast = false) {
     const efforts = entry.reasoningEfforts;
-    if (efforts === undefined || efforts.length === 0)
+    const ids = fast ? [...efforts ?? [], FAST_RUNG] : efforts;
+    if (ids === undefined || ids.length === 0)
         return undefined;
-    const defaultEffort = entry.defaultEffort ?? efforts[efforts.length - 1];
+    const defaultEffort = entry.defaultEffort ?? ids[ids.length - 1];
     return {
-        efforts: efforts.map(effortInfo),
+        efforts: ids.map(effortInfo),
         ...defaultEffort === undefined ? {} : { defaultEffort: ReasoningEffortId(defaultEffort) },
     };
 }
@@ -206,24 +219,18 @@ export class KimiAdapter extends LlmAdapter {
             return [];
         await this.syncUserModels();
         const hidden = await this.hidden();
-        // The host validates a GUI selection against the exact ids `listModels` returns
-        // and refuses an unknown one with `session/model-unavailable`, and its picker
-        // lists every returned id as its own row. So a fast variant is published under
-        // its base id: selecting it names the variant the request must send, and the
-        // base's own id is withheld so the variant does not appear twice.
+        // One row per model, always under the model's own id: the host validates every GUI
+        // selection against this list, so publishing only the fast variant would leave the
+        // picker with no way back to the standard model. Fast mode is the row's `fast`
+        // reasoning rung instead (see `stream`).
         const imageless = this.catalog().filter((entry) => !isImageModel(entry.id));
-        const listed = resolveCatalog(imageless, [], hidden).entries.map((entry) => {
-            const fast = this.fastVariants.variantOf(entry.id);
-            const id = fast ?? entry.id;
-            return {
-                provider: KIMI_PROVIDER_ID,
-                id,
-                name: entry.name,
-                ...entry.description === undefined ? {} : { description: entry.description },
-                ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
-            };
-        });
-        return listed;
+        return resolveCatalog(imageless, [], hidden).entries.map((entry) => ({
+            provider: KIMI_PROVIDER_ID,
+            id: entry.id,
+            name: entry.name,
+            ...entry.description === undefined ? {} : { description: entry.description },
+            ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
+        }));
     }
     /** The image-generation model id, when discovery reported one. */
     imageModelId() {
@@ -264,17 +271,15 @@ export class KimiAdapter extends LlmAdapter {
                 ...reasoning === undefined ? {} : { reasoning },
             };
         }
-        const reasoning = reasoningInfo(entry);
-        // A fast variant is a wire id of its own — the button switches to it and back, so the
-        // selection must keep that id — while an ordinary alias is just another spelling of
-        // the row and resolves onto it. The fast selection names itself "Fast" so the picker
-        // trigger reads the mode, not the base model it replaces.
-        const pair = this.fastVariants.pairOf(model);
-        const fast = pair !== undefined && pair.wireId === model;
+        // A row with a fast variant offers the `fast` rung; the picker shows the row under
+        // its own name and the mode as the effort, which is what the trigger already reads.
+        const reasoning = reasoningInfo(entry, this.fastVariants.variantOf(entry.id) !== undefined);
+        // An alias is just another spelling of the row, so it resolves onto the row's own id:
+        // that is what keeps a selection dispatchable and the picker able to show it.
         return {
             provider: KIMI_PROVIDER_ID,
-            id: fast ? model : entry.id,
-            name: fast ? `${entry.name} Fast` : entry.name,
+            id: entry.id,
+            name: entry.name,
             ...entry.description === undefined ? {} : { description: entry.description },
             ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
             context: { contextWindow: entry.contextWindow },
@@ -283,7 +288,16 @@ export class KimiAdapter extends LlmAdapter {
         };
     }
     stream(options) {
-        return streamProviderResponses(options, {
+        // Fast mode rides the reasoning channel: `fast` is a rung of the row, not a model id
+        // of its own, so the row the picker selected stays dispatchable and the user can
+        // always select the standard model again. Only the wire id changes.
+        const fast = String(options.reasoningEffort ?? '') === FAST_RUNG;
+        const model = fast ? this.fastVariants.variantOf(options.model) ?? options.model : options.model;
+        const call = { ...options, model };
+        // Kimi has no `fast` effort; the variant already carries the behaviour.
+        if (fast)
+            delete call.reasoningEffort;
+        return streamProviderResponses(call, {
             label: 'Kimi API',
             tokens: this.options.tokens,
             request: (call, model, accessToken, signal) => this.request(call, model, accessToken, signal),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.8.16",
+  "version": "0.8.18",
   "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",