dsh-plugin-subscription-oauth 0.11.0 → 0.12.0

package/lib/index.js

@@ -167,7 +167,7 @@ export function apply(ctx, config = {}) {
                 break;
         }
     }
-    const registry = new SubscriptionRegistry(routes);
+    const registry = new SubscriptionRegistry(routes, preferences);
     // `auto` stands in for the other routes, so it is built after them and added
     // to the same registry it reads. Its list spans routes, which is why it is a
     // provider of its own rather than a model inside each one.

package/lib/protocol.d.ts

@@ -12,7 +12,7 @@
 /** Prefix of every RPC method this plugin serves. */
 export declare const RPC_PREFIX = "subscription-oauth.";
 /** Endpoints the Settings page may call. */
-export declare const RPC_ENDPOINTS: readonly ["status", "login", "cancel", "logout", "setDefault", "refresh", "discover", "setModelVisible", "setModelOrder", "addModel", "removeModel", "usage", "reload", "deepseek-balance", "ccswitch-balance", "model-variants"];
+export declare const RPC_ENDPOINTS: readonly ["status", "login", "cancel", "logout", "setDefault", "refresh", "discover", "setModelVisible", "setModelOrder", "addModel", "removeModel", "usage", "reload", "setAutoOn", "deepseek-balance", "ccswitch-balance", "model-variants"];
 /** One endpoint name. */
 export type RpcEndpoint = typeof RPC_ENDPOINTS[number];
 /** Client → host envelope. */
@@ -315,6 +315,10 @@ export interface RpcMap {
         payload: undefined;
         value: SubscriptionStatus;
     };
+    setAutoOn: {
+        payload: SetAutoOnRequest;
+        value: AutoStateResult;
+    };
     'deepseek-balance': {
         payload: DeepSeekBalanceRequest;
         value: DeepSeekBalanceResult;
@@ -382,6 +386,14 @@ export interface ModelVariantsRequest {
     provider: string;
     id: string;
 }
+/** Payload of `setAutoOn`: whether the `auto` provider is offered at all. */
+export interface SetAutoOnRequest {
+    enabled: boolean;
+}
+/** Result of `setAutoOn`: the `auto` provider's live enabled state. */
+export interface AutoStateResult {
+    enabled: boolean;
+}
 /** Payload of `deepseek-balance`. */
 export interface DeepSeekBalanceRequest {
     /** Client metadata the host's account service expects. */

package/lib/protocol.js

@@ -26,6 +26,7 @@ export const RPC_ENDPOINTS = [
     'removeModel',
     'usage',
     'reload',
+    'setAutoOn',
     'deepseek-balance',
     'ccswitch-balance',
     'model-variants',

package/lib/providers/auto.js

@@ -64,6 +64,9 @@ export class AutoAdapter extends LlmAdapter {
         return undefined;
     }
     async listModels(_provider) {
+        // A switched-off `auto` is not offered at all, so the picker shows the routes directly.
+        if (!(await this.options.preferences.autoPreferences()).enabled)
+            return [];
         const chain = await this.chain();
         // An `auto` with nothing to try is not offered at all, rather than offered
         // and guaranteed to fail.

package/lib/providers/grok.d.ts

@@ -116,6 +116,8 @@ interface GrokCliMetadata {
 export declare function isImageModel(id: string): boolean;
 /** True when a model id names a fast/lightspeed variant of a base model. */
 export declare function isFastVariant(id: string): boolean;
+/** The fast word a variant's own id names (`grok-4.7-build-fast` → `fast`), lowercased. */
+export declare function fastWordOf(id: string): string;
 /**
  * Every prefix of one model id, longest first, down to its first token.
  *

package/lib/providers/grok.js

@@ -52,18 +52,18 @@ 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';
+const FAST_RUNG = 'fast';
 /** 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' },
+    // 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.
+    // xAI's own word for it is "fast" (grok-4.7-build-fast), which names the rung.
+    [FAST_RUNG]: { name: 'Fast', description: 'xAI fast variant of this model' },
 };
 /**
  * Curated catalog entries.
@@ -127,18 +127,21 @@ export function parseGrokSession(value) {
 }
 /** One `reasoning.efforts` entry. */
 function effortInfo(effort) {
-    const label = EFFORT_LABELS[effort] ?? { name: effort, description: '' };
+    const known = EFFORT_LABELS[effort];
+    const label = known ?? { name: effort[0].toUpperCase() + effort.slice(1), description: `${effort} variant of this model` };
     return { id: ReasoningEffortId(effort), name: label.name, description: label.description };
 }
 /**
  * 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.
+ * @param fastWireId - the row's fast variant wire id, when it has one; the rung is the
+ *   variant's own fast word (`grok-4.7-build-fast` → `fast`).
  */
-function reasoningInfo(entry, fast = false) {
+function reasoningInfo(entry, fastWireId) {
     const efforts = entry.reasoningEfforts;
-    const ids = fast ? [...efforts ?? [], FAST_RUNG] : efforts;
+    const rung = fastWireId === undefined ? undefined : fastWordOf(fastWireId);
+    const ids = rung === undefined ? efforts : [...efforts ?? [], rung];
     if (ids === undefined || ids.length === 0)
         return undefined;
     return {
@@ -289,11 +292,15 @@ export function isImageModel(id) {
  * (`kimi-for-coding-highspeed`). A word has to stand on its own, so `highspeed` never
  * matches inside another word.
  */
-const FAST_VARIANT = /(?:^|[-_@])(?:fast|lightspeed|turbo|quick|highspeed)(?=[-_@]|$)/i;
+const FAST_VARIANT = /(?:^|[-_@])(fast|lightspeed|turbo|quick|highspeed)(?=[-_@]|$)/i;
 /** True when a model id names a fast/lightspeed variant of a base model. */
 export function isFastVariant(id) {
     return FAST_VARIANT.test(id);
 }
+/** The fast word a variant's own id names (`grok-4.7-build-fast` → `fast`), lowercased. */
+export function fastWordOf(id) {
+    return FAST_VARIANT.exec(id)?.[1]?.toLowerCase() ?? 'fast';
+}
 /**
  * Every prefix of one model id, longest first, down to its first token.
  *
@@ -503,9 +510,10 @@ export class GrokAdapter extends LlmAdapter {
                 ...reasoning === undefined ? {} : { reasoning },
             };
         }
-        // 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);
+        // A row with a fast variant offers a rung named for the variant's own word; the
+        // picker shows the row under its own name and the mode as the effort.
+        const fastWireId = this.fastVariants.variantOf(entry.id);
+        const reasoning = reasoningInfo(entry, fastWireId);
         return {
             provider: GROK_PROVIDER_ID,
             id: model,
@@ -520,13 +528,15 @@ export class GrokAdapter extends LlmAdapter {
     stream(options) {
         // Resolve @Nk context suffixes to the largest variant the endpoint offers.
         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;
+        // Fast mode rides the reasoning channel: the rung is the variant's own fast word, 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 effort = String(options.reasoningEffort ?? '');
+        const fastWireId = this.fastVariants.variantOf(base);
+        const fast = fastWireId !== undefined && effort === fastWordOf(fastWireId);
+        const model = fast ? fastWireId : base;
         const call = { ...options, model };
-        // xAI has no `fast` effort; the variant already carries the behaviour.
+        // xAI has no fast-variant effort; the variant already carries the behaviour.
         if (fast)
             delete call.reasoningEffort;
         return streamProviderResponses(call, {
@@ -1003,7 +1013,7 @@ export function createGrokProvider(options) {
             const pair = adapter.fastPairOf(id);
             const image = adapter.imageModelId();
             return {
-                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId, fastRung: 'lightspeed' },
+                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId, fastRung: fastWordOf(pair.wireId) },
                 ...image === undefined ? {} : { image },
             };
         },

package/lib/providers/kimi-provider.js

@@ -13,6 +13,7 @@ import { loadOrCreateDeviceId } from '../auth/device-id.js';
 import { kimiIdentityHeaders } from '../auth/headers.js';
 import { KimiAdapter, parseKimiSession } from './kimi.js';
 import { readKimiUsage } from './usage.js';
+import { fastWordOf } from './grok.js';
 import { ProviderController } from '../auth/provider-controller.js';
 import { proxiedFetch } from '../http.js';
 /**
@@ -154,7 +155,7 @@ export function createKimiProvider(options) {
             const pair = adapter.fastPairOf(id);
             const image = adapter.imageModelId();
             return {
-                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId, fastRung: 'highspeed' },
+                ...pair === undefined ? {} : { fast: pair.wireId, fastBase: pair.baseId, fastRung: fastWordOf(pair.wireId) },
                 ...image === undefined ? {} : { image },
             };
         },

package/lib/providers/kimi.js

@@ -15,7 +15,7 @@ import { streamProviderResponses, accountPoolHooks } from './responses-stream.js
 import { fallbackEntry, findEntry, resolveCatalog } from './catalog.js';
 import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
 import { prepareMoonshotTool } from '../translate/moonshot-schema.js';
-import { isImageModel, isFastVariant, baseModelOf, FastVariantIndex } from './grok.js';
+import { isImageModel, isFastVariant, baseModelOf, fastWordOf, FastVariantIndex } 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;
 /**
@@ -127,11 +127,13 @@ function effortInfo(effort) {
  * 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.
+ * @param fastWireId - the row's fast variant wire id, when it has one; the rung is the
+ *   variant's own fast word (`kimi-for-coding-highspeed` → `highspeed`).
  */
-function reasoningInfo(entry, fast = false) {
+function reasoningInfo(entry, fastWireId) {
     const efforts = entry.reasoningEfforts;
-    const ids = fast ? [...efforts ?? [], FAST_RUNG] : efforts;
+    const rung = fastWireId === undefined ? undefined : fastWordOf(fastWireId);
+    const ids = rung === undefined ? efforts : [...efforts ?? [], rung];
     if (ids === undefined || ids.length === 0)
         return undefined;
     const defaultEffort = entry.defaultEffort ?? ids[ids.length - 1];
@@ -271,9 +273,10 @@ export class KimiAdapter extends LlmAdapter {
                 ...reasoning === undefined ? {} : { reasoning },
             };
         }
-        // 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);
+        // A row with a fast variant offers a rung named for the variant's own word; the
+        // picker shows the row under its own name and the mode as the effort.
+        const fastWireId = this.fastVariants.variantOf(entry.id);
+        const reasoning = reasoningInfo(entry, fastWireId);
         // 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 {
@@ -288,13 +291,15 @@ export class KimiAdapter extends LlmAdapter {
         };
     }
     stream(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;
+        // Fast mode rides the reasoning channel: the rung is the variant's own fast word, 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 fastWireId = this.fastVariants.variantOf(options.model);
+        const effort = String(options.reasoningEffort ?? '');
+        const fast = fastWireId !== undefined && effort === fastWordOf(fastWireId);
+        const model = fast ? fastWireId : options.model;
         const call = { ...options, model };
-        // Kimi has no `fast` effort; the variant already carries the behaviour.
+        // Kimi has no fast-variant effort; the variant already carries the behaviour.
         if (fast)
             delete call.reasoningEffort;
         return streamProviderResponses(call, {

package/lib/providers/mimo.d.ts

@@ -82,6 +82,16 @@ export declare class MimoAdapter extends LlmAdapter {
     /** The ids the route itself serves, without hand-added extras. */
     ownCatalogEntries(): readonly MimoModelEntry[];
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /** The app's names for its models, as the Token Plan's endpoint names them. */
+    private static readonly TP_MODELS;
+    /**
+     * Re-ask a membership_required chat at the Token Plan's endpoint.
+     *
+     * Reads the account's tp- API key from the open platform, then posts the chat to the
+     * plan's OpenAI base with that key. Undefined when the account has no live plan or no
+     * readable key.
+     */
+    private tokenPlanRequest;
     /**
      * The session cookies as one Cookie header, in a steady order.
      *

package/lib/providers/mimo.js

@@ -11,7 +11,7 @@
 import { LlmAdapter, errorChain, } from '@deepseek-ai/dsh-llm';
 import { httpLlmError, isMissingOrInvalidCredential, mapFetchFailure, idleWatchdog } from './common.js';
 import { proxiedFetch } from '../http.js';
-import { refreshMimoSession } from '../auth/mimo-flow.js';
+import { readMimoPlanKey, refreshMimoSession } from '../auth/mimo-flow.js';
 /** The `mimo` provider route key. */
 export const MIMO_PROVIDER_ID = 'mimo';
 /** Human name for the route and its cards. */
@@ -145,6 +145,28 @@ export class MimoAdapter extends LlmAdapter {
                 body: JSON.stringify(body),
                 signal: watchdog.signal,
             });
+            // A 403 with code membership_required means the account has no app plan but a
+            // Token Plan at the open platform: re-ask at its endpoint with its tp- key.
+            if (response.status === 403) {
+                const text = await response.text();
+                let code;
+                try {
+                    code = JSON.parse(text).error !== undefined
+                        ? JSON.parse(text).error.code
+                        : JSON.parse(text).code;
+                }
+                catch {
+                    code = undefined;
+                }
+                if (code === 'membership_required') {
+                    const plan = await this.tokenPlanRequest(session, body, watchdog);
+                    if (plan !== undefined) {
+                        yield* this.readStream(plan, watchdog);
+                        return;
+                    }
+                }
+                throw new Error(`Xiaomi MiMo: ${text.slice(0, 200)}`);
+            }
             if (!response.ok || response.body === null) {
                 throw await httpLlmError(response, 'Xiaomi MiMo');
             }
@@ -157,6 +179,48 @@ export class MimoAdapter extends LlmAdapter {
             watchdog.stop();
         }
     }
+    /** The app's names for its models, as the Token Plan's endpoint names them. */
+    static TP_MODELS = {
+        'mimo-pro': 'mimo-v2.6-pro',
+        'mimo-flash': 'mimo-v2.6-flash',
+    };
+    /**
+     * Re-ask a membership_required chat at the Token Plan's endpoint.
+     *
+     * Reads the account's tp- API key from the open platform, then posts the chat to the
+     * plan's OpenAI base with that key. Undefined when the account has no live plan or no
+     * readable key.
+     */
+    async tokenPlanRequest(session, body, watchdog) {
+        let creds;
+        try {
+            creds = JSON.parse(session.mimoCreds);
+        }
+        catch {
+            return undefined;
+        }
+        try {
+            const plan = await readMimoPlanKey(creds, this.fetchFn);
+            if (plan === null)
+                return undefined;
+            const model = MimoAdapter.TP_MODELS[String(body.model)] ?? String(body.model);
+            const path = new URL(session.apiBase.replace(/\/+$/, '') + '/route/chat/completions').pathname;
+            const rest = path.replace(/^.*?\/route(?=\/|$)/, '');
+            return await this.fetchFn(`${plan.base}${rest}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'text/event-stream',
+                    'Authorization': `Bearer ${plan.key}`,
+                },
+                body: JSON.stringify({ ...body, model }),
+                signal: watchdog.signal,
+            });
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * The session cookies as one Cookie header, in a steady order.
      *

package/lib/settings.d.ts

@@ -33,6 +33,8 @@ export interface AutoPreferences {
     order: readonly string[];
     /** Keys `auto` must not use, whatever their own route offers. */
     off: readonly string[];
+    /** Whether the `auto` provider is offered at all. Defaults to true. */
+    enabled: boolean;
 }
 /**
  * Owns the model preference document.
@@ -89,6 +91,12 @@ export declare class ModelPreferences {
     removeExtra(provider: string, id: string): Promise<boolean>;
     /** The `auto` provider's arrangement. */
     autoPreferences(): Promise<AutoPreferences>;
+    /**
+     * Record whether the `auto` provider is offered at all.
+     * @param enabled - whether `auto` appears in the picker.
+     * @returns whether the stored state actually changed.
+     */
+    setAutoOn(enabled: boolean): Promise<boolean>;
     /**
      * Replace the `auto` provider's order.
      * @param keys - `provider/model` keys, most preferred first.

package/lib/settings.js

@@ -26,10 +26,11 @@ export const LEGACY_FLAT_PROVIDER = 'kimi';
 /** Read the `auto` section, keeping only usable keys. */
 function readAuto(document) {
     if (!isRecord(document.auto))
-        return { order: [], off: [] };
+        return { order: [], off: [], enabled: true };
     return {
         order: readIds(document.auto.order),
         off: readIds(document.auto.off),
+        enabled: document.auto.enabled !== false,
     };
 }
 /** True for a plain object usable as a JSON record. */
@@ -102,7 +103,7 @@ export class ModelPreferences {
     file;
     hidden = {};
     order = {};
-    auto = { order: [], off: [] };
+    auto = { order: [], off: [], enabled: true };
     extra = {};
     loaded = false;
     /** The in-flight first read, so concurrent callers share one. */
@@ -137,7 +138,7 @@ export class ModelPreferences {
         catch {
             this.hidden = {};
             this.order = {};
-            this.auto = { order: [], off: [] };
+            this.auto = { order: [], off: [], enabled: true };
             this.extra = {};
             this.loaded = true;
             return;
@@ -153,7 +154,7 @@ export class ModelPreferences {
         catch {
             this.hidden = {};
             this.order = {};
-            this.auto = { order: [], off: [] };
+            this.auto = { order: [], off: [], enabled: true };
             this.extra = {};
         }
         this.loaded = true;
@@ -220,7 +221,20 @@ export class ModelPreferences {
     /** The `auto` provider's arrangement. */
     async autoPreferences() {
         await this.ensureLoaded();
-        return { order: [...this.auto.order], off: [...this.auto.off] };
+        return { order: [...this.auto.order], off: [...this.auto.off], enabled: this.auto.enabled };
+    }
+    /**
+     * Record whether the `auto` provider is offered at all.
+     * @param enabled - whether `auto` appears in the picker.
+     * @returns whether the stored state actually changed.
+     */
+    async setAutoOn(enabled) {
+        await this.ensureLoaded();
+        if (this.auto.enabled === enabled)
+            return false;
+        this.auto = { ...this.auto, enabled };
+        await this.persist();
+        return true;
     }
     /**
      * Replace the `auto` provider's order.

package/package.json

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