dsh-plugin-subscription-oauth 0.8.17 → 0.9.0

package/lib/index.d.ts

@@ -16,9 +16,9 @@ export declare const name = "dsh-plugin-subscription-oauth";
 /** The provider routes need the LLM runtime; everything else is optional. */
 export declare const inject: string[];
 /** Every route key this plugin accepts in configuration. */
-export declare const PROVIDER_IDS: readonly ["kimi", "grok", "antigravity", "glm", "ark"];
+export declare const PROVIDER_IDS: readonly ["kimi", "grok", "antigravity", "glm", "ark", "mimo"];
 /** The routes this build can actually register. */
-export declare const IMPLEMENTED_PROVIDER_IDS: readonly ["kimi", "grok", "antigravity", "glm", "ark"];
+export declare const IMPLEMENTED_PROVIDER_IDS: readonly ["kimi", "grok", "antigravity", "glm", "ark", "mimo"];
 /** One route key. */
 export type ProviderId = typeof PROVIDER_IDS[number];
 /** Plugin configuration, as accepted from `cordis.patch.yml`. */

package/lib/index.js

@@ -22,15 +22,16 @@ import { createGrokProvider } from './providers/grok.js';
 import { createKimiProvider } from './providers/kimi-provider.js';
 import { createGlmProvider } from './providers/glm-provider.js';
 import { createArkProvider } from './providers/ark-provider.js';
+import { createMimoProvider } from './providers/mimo-provider.js';
 import { ModelPreferences } from './settings.js';
 /** Plugin id; also the name every effect label and log line is prefixed with. */
 export const name = 'dsh-plugin-subscription-oauth';
 /** The provider routes need the LLM runtime; everything else is optional. */
 export const inject = ['llm'];
 /** Every route key this plugin accepts in configuration. */
-export const PROVIDER_IDS = ['kimi', 'grok', 'antigravity', 'glm', 'ark'];
+export const PROVIDER_IDS = ['kimi', 'grok', 'antigravity', 'glm', 'ark', 'mimo'];
 /** The routes this build can actually register. */
-export const IMPLEMENTED_PROVIDER_IDS = ['kimi', 'grok', 'antigravity', 'glm', 'ark'];
+export const IMPLEMENTED_PROVIDER_IDS = ['kimi', 'grok', 'antigravity', 'glm', 'ark', 'mimo'];
 /** Configuration schema, with the config file's own defaults applied. */
 export const Config = z.object({
     providers: z.array(z.union([...PROVIDER_IDS])).default([...IMPLEMENTED_PROVIDER_IDS]),
@@ -138,6 +139,17 @@ export function apply(ctx, config = {}) {
                     fetchFn: proxiedFetch,
                 }));
                 break;
+            case 'mimo':
+                routes.push(createMimoProvider({
+                    credentialFile,
+                    streamIdleTimeoutMs,
+                    preferences,
+                    resolveAttachments: () => ctx.get('attachments'),
+                    onCatalogChanged: () => { reannounce('mimo'); },
+                    onWarn,
+                    fetchFn: proxiedFetch,
+                }));
+                break;
             default:
                 // A configured route with no module yet must not silently disappear.
                 onWarn(`provider ${id} is configured but not implemented in this build`);

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,16 +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 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 to the standard model.
-    fast: { name: 'Fast', description: 'Lightspeed variant of this model' },
+    // 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.
@@ -135,7 +138,7 @@ function effortInfo(effort) {
  */
 function reasoningInfo(entry, fast = false) {
     const efforts = entry.reasoningEfforts;
-    const ids = fast ? [...efforts ?? [], 'fast'] : efforts;
+    const ids = fast ? [...efforts ?? [], FAST_RUNG] : efforts;
     if (ids === undefined || ids.length === 0)
         return undefined;
     return {
@@ -520,7 +523,7 @@ export class GrokAdapter extends LlmAdapter {
         // 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';
+        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.
@@ -1000,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' },
@@ -65,8 +67,9 @@ const EFFORT_LABELS = {
     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 to the standard model.
-    fast: { name: 'Fast', description: 'Highspeed variant of this model' },
+    // 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.
@@ -128,7 +131,7 @@ function effortInfo(effort) {
  */
 function reasoningInfo(entry, fast = false) {
     const efforts = entry.reasoningEfforts;
-    const ids = fast ? [...efforts ?? [], 'fast'] : efforts;
+    const ids = fast ? [...efforts ?? [], FAST_RUNG] : efforts;
     if (ids === undefined || ids.length === 0)
         return undefined;
     const defaultEffort = entry.defaultEffort ?? ids[ids.length - 1];
@@ -288,7 +291,7 @@ export class KimiAdapter extends LlmAdapter {
         // 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';
+        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.

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

@@ -0,0 +1,35 @@
+/**
+ * The `mimo` provider route's wiring: credential store, Xiaomi QR/password
+ * login, model catalog, and its Settings card facts.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/mimo-provider
+ */
+import type { ProviderRoute } from '../auth/registry.js';
+import type { ModelPreferences } from '../settings.js';
+import type { FetchFn } from '../http.js';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+/** Everything the MiMo route needs from the plugin configuration. */
+export interface MimoProviderOptions {
+    /** Absolute path of `auth.json`. */
+    credentialFile: string;
+    /** Abandon a stream after this much silence. */
+    streamIdleTimeoutMs: number;
+    /** Model the picker preselects. */
+    defaultModel?: string;
+    /** Shared model-visibility preferences. */
+    preferences: ModelPreferences;
+    /** Resolve the attachment service per request. */
+    resolveAttachments?: () => AttachmentStore | undefined;
+    /** Invoked when the catalog or its visibility changed. */
+    onCatalogChanged?: () => void;
+    onWarn?: (message: string) => void;
+    /** Fetch implementation; defaults to the proxy-aware fetch. */
+    fetchFn?: FetchFn;
+}
+/**
+ * Build the `mimo` route: its adapter and its login/lifecycle controller.
+ *
+ * @param options - resolved endpoints, paths, and shared services.
+ * @returns the route, ready to register and to serve over RPC.
+ */
+export declare function createMimoProvider(options: MimoProviderOptions): ProviderRoute;

package/lib/providers/mimo-provider.js

@@ -0,0 +1,170 @@
+/**
+ * The `mimo` provider route's wiring: credential store, Xiaomi QR/password
+ * login, model catalog, and its Settings card facts.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/mimo-provider
+ */
+import { REAUTH_REQUIRED, ProviderError } from '../errors.js';
+import { TokenStore } from '../auth/store.js';
+import { TokenManager } from '../auth/tokens.js';
+import { LOGIN_CANCELLED_MESSAGE } from '../auth/device-flow.js';
+import { finishMimoSignIn, mimoCredentialsFrom, refreshMimoSession, startMimoSignIn, waitMimoPoll, } from '../auth/mimo-flow.js';
+import { MimoAdapter, MIMO_CODE_URL, MIMO_CONTEXT_WINDOW, MIMO_DEFAULT_MODEL, MIMO_MODELS, MIMO_PROVIDER_ID, MIMO_PROVIDER_NAME, parseMimoSession, } from './mimo.js';
+import { ProviderController } from '../auth/provider-controller.js';
+import { proxiedFetch } from '../http.js';
+/** Wait, honouring cancellation. */
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error(LOGIN_CANCELLED_MESSAGE));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        function onAbort() {
+            clearTimeout(timer);
+            reject(new Error(LOGIN_CANCELLED_MESSAGE));
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/**
+ * Build the `mimo` route: its adapter and its login/lifecycle controller.
+ *
+ * @param options - resolved endpoints, paths, and shared services.
+ * @returns the route, ready to register and to serve over RPC.
+ */
+export function createMimoProvider(options) {
+    const fetchFn = options.fetchFn ?? proxiedFetch;
+    const store = new TokenStore(options.credentialFile, MIMO_PROVIDER_ID, parseMimoSession);
+    const toSession = (creds, cookies, userId) => ({
+        accessToken: JSON.stringify(cookies),
+        expiresAt: Date.now() + 24 * 60 * 60 * 1000,
+        accountId: userId,
+        apiBase: creds.base,
+        mimoCreds: JSON.stringify(creds),
+        mimoCookies: JSON.stringify(cookies),
+        region: creds.region,
+    });
+    /** The in-flight attempt, so `pending()` is stable across calls. */
+    let current;
+    const flow = {
+        async start() {
+            const start = await startMimoSignIn(fetchFn);
+            const controller = new AbortController();
+            const session = (async () => {
+                while (true) {
+                    if (controller.signal.aborted)
+                        throw new Error(LOGIN_CANCELLED_MESSAGE);
+                    const poll = await waitMimoPoll(start, fetchFn);
+                    if (poll !== undefined) {
+                        const { creds, cookies } = await finishMimoSignIn(poll, start.device, fetchFn);
+                        return toSession(creds, cookies, creds.userId);
+                    }
+                    await sleep(1000, controller.signal);
+                }
+            })();
+            const attempt = {
+                prompt: {
+                    url: start.url,
+                    expiresAt: start.until,
+                    mode: 'open-url',
+                },
+                session,
+                cancel: () => { controller.abort(); },
+            };
+            current = attempt;
+            void session.catch(() => undefined).finally(() => {
+                if (current === attempt)
+                    current = undefined;
+            });
+            return attempt;
+        },
+        pending() {
+            return current;
+        },
+    };
+    const tokens = new TokenManager({
+        store,
+        displayName: MIMO_PROVIDER_NAME,
+        // The app signs on again after a day; renew a little ahead of that.
+        preemptMs: 10 * 60 * 1000,
+        refresh: async (session) => {
+            let creds;
+            try {
+                creds = JSON.parse(session.mimoCreds);
+            }
+            catch {
+                throw new ProviderError(`${MIMO_PROVIDER_NAME} sign-in has expired; connect the account again`, REAUTH_REQUIRED);
+            }
+            try {
+                const renewed = await refreshMimoSession(creds, fetchFn);
+                return { accessToken: JSON.stringify(renewed.cookies), expiresAt: renewed.expiresAt };
+            }
+            catch (error) {
+                if (error instanceof Error && /lapsed/i.test(error.message)) {
+                    throw new ProviderError(`${MIMO_PROVIDER_NAME} sign-in has expired; connect the account again`, REAUTH_REQUIRED);
+                }
+                throw error;
+            }
+        },
+    });
+    const adapter = new MimoAdapter({
+        streamIdleTimeoutMs: options.streamIdleTimeoutMs,
+        tokens,
+        ...options.onWarn === undefined ? {} : { onWarn: options.onWarn },
+        ...options.resolveAttachments === undefined ? {} : { resolveAttachments: options.resolveAttachments },
+        hiddenModels: () => options.preferences.hiddenIds(MIMO_PROVIDER_ID),
+        userModels: () => options.preferences.extraIds(MIMO_PROVIDER_ID),
+        fetchFn,
+    });
+    const spec = {
+        id: MIMO_PROVIDER_ID,
+        displayName: MIMO_PROVIDER_NAME,
+        codeUrl: MIMO_CODE_URL,
+        credentialFile: options.credentialFile,
+        // MiMo ships a fixed two-model catalog; there is no discovery endpoint.
+        discovery: false,
+        defaultModel: options.defaultModel ?? MIMO_DEFAULT_MODEL,
+        catalog: () => adapter.catalogEntries(),
+        catalogOwn: () => adapter.ownCatalogEntries(),
+        fallbackContextWindow: MIMO_CONTEXT_WINDOW,
+        discover: () => Promise.resolve(undefined),
+        usage: () => Promise.resolve({ windows: [] }),
+        details: () => [
+            { key: 'provider', value: MIMO_PROVIDER_NAME },
+            { key: 'credentialFile', value: options.credentialFile },
+        ],
+        applyDiscovery: () => { },
+    };
+    const controller = new ProviderController({
+        spec,
+        store,
+        tokens,
+        flow,
+        preferences: options.preferences,
+        ...options.onCatalogChanged === undefined ? {} : { onCatalogChanged: options.onCatalogChanged },
+        ...options.onWarn === undefined ? {} : { onWarn: options.onWarn },
+    });
+    return {
+        id: controller.id,
+        displayName: controller.displayName,
+        credentialFile: controller.credentialFile,
+        adapter,
+        status: () => controller.status(),
+        login: (account) => controller.login(account),
+        cancel: () => controller.cancel(),
+        logout: (account) => controller.logout(account),
+        setDefault: (account) => controller.setDefault(account),
+        refresh: (account) => controller.refresh(account),
+        discover: (force) => controller.discover(force),
+        setModelVisible: (id, visible) => controller.setModelVisible(id, visible),
+        setModelOrder: (ids) => controller.setModelOrder(ids),
+        addModel: (id) => controller.addModel(id),
+        removeModel: (id) => controller.removeModel(id),
+        usage: (force) => controller.usage(force),
+        reload: () => controller.reload(),
+    };
+}

package/lib/providers/mimo.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The Xiaomi MiMo wire adapter serving the `mimo` route.
+ *
+ * Model requests are chat completions at the MiMo server's `/route`, carrying the
+ * session cookies the sign-on set — not a bearer token. Two models ship: MiMo Pro
+ * and MiMo Flash. The open platform's Token Plan spends its own `tp-` key at a
+ * separate endpoint; that fallback lives beside the account-level stream here.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/mimo
+ */
+import { LlmAdapter, type GenerateOptions, type LlmModelInfo, type LlmProviderInfo, type LlmResolvedModelInfo, type StreamChunk } from '@deepseek-ai/dsh-llm';
+import { type FetchFn } from '../http.js';
+import type { TokenManager } from '../auth/tokens.js';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+/** The `mimo` provider route key. */
+export declare const MIMO_PROVIDER_ID = "mimo";
+/** Human name for the route and its cards. */
+export declare const MIMO_PROVIDER_NAME = "Xiaomi MiMo";
+/** Where the Settings page sends someone to get an account. */
+export declare const MIMO_CODE_URL = "https://platform.xiaomimimo.com";
+/** MiMo context window shared by Pro and Flash. */
+export declare const MIMO_CONTEXT_WINDOW = 1000000;
+/** The output ceiling MiMo advertises. */
+export declare const MIMO_DEFAULT_MAX_TOKENS = 128000;
+/** The model the picker preselects. */
+export declare const MIMO_DEFAULT_MODEL = "mimo-pro";
+/** One signed-in MiMo account, as stored. */
+export interface MimoSession {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt: number;
+    accountId?: string;
+    email?: string;
+    /** The MiMo server base this account signs on at. */
+    apiBase: string;
+    /** The durable Xiaomi credential (JSON), used to re-sign-on. */
+    mimoCreds: string;
+    /** The live session cookies (JSON), sent as the Cookie header. */
+    mimoCookies: string;
+    /** The account's region. */
+    region?: string;
+}
+/** Validate one stored value as a MiMo session, or undefined when it is not one. */
+export declare function parseMimoSession(value: unknown): MimoSession | undefined;
+/** One catalog row. */
+interface MimoModelEntry {
+    id: string;
+    name: string;
+    description: string;
+    contextWindow: number;
+}
+/** The two models the MiMo app serves. */
+export declare const MIMO_MODELS: readonly MimoModelEntry[];
+/** Constructor dependencies for {@link MimoAdapter}. */
+export interface MimoAdapterOptions {
+    /** MiMo server base; `<base>/route/chat/completions` is the endpoint. */
+    apiBase?: string;
+    streamIdleTimeoutMs: number;
+    tokens: TokenManager<MimoSession>;
+    onWarn?: (message: string) => void;
+    resolveAttachments?: () => AttachmentStore | undefined;
+    hiddenModels?: () => Promise<ReadonlySet<string>>;
+    userModels?: () => Promise<readonly string[]>;
+    fetchFn?: FetchFn;
+}
+/** The MiMo wire adapter serving the `mimo` route. */
+export declare class MimoAdapter extends LlmAdapter {
+    private readonly options;
+    private readonly fetchFn;
+    constructor(options: MimoAdapterOptions);
+    providerInfo(provider: string): LlmProviderInfo;
+    listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
+    private hidden;
+    resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    providerRetryPolicy(): undefined;
+    /** The catalog the Settings list reads: every shipped model. */
+    catalogEntries(): readonly {
+        id: string;
+        name: string;
+        contextWindow: number;
+    }[];
+    /** The ids the route itself serves, without hand-added extras. */
+    ownCatalogEntries(): readonly MimoModelEntry[];
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /**
+     * The session cookies as one Cookie header, in a steady order.
+     *
+     * MiMo is a cookie session, not a bearer: the wire credential is the cookie
+     * header built from the stored session's cookie record.
+     */
+    private cookieHeader;
+    private requestBody;
+    private toChatMessage;
+    private readStream;
+}
+export {};