dsh-plugin-subscription-oauth 0.16.3 → 0.17.1

package/README.dev.md

@@ -70,7 +70,7 @@ quota, which is read per subscription period and per model's free allowance.
 | --- | --- |
 | `ctx.llm` | the `kimi`, `grok`, `antigravity`, `glm` and `auto` provider routes (models, reasoning efforts, streaming) |
 | Settings | a **Subscriptions** section: one card per provider — sign in, sign out, default account, token refresh, plan quota, model catalog, manage dialog |
-| Model picker | each provider's own models, plus **`auto` as its own route** spanning them — Kimi ships `kimi-for-coding`, `k3`, `k3[1m]`, `k3-256k`; Grok seeds `grok-4.6`, `grok-4.5` and adds whatever its live catalog reports; Antigravity lists the agent-callable subset of what its endpoint reports (`fetchAvailableModels`), filtering out tabs, commit-message and transcription surfaces; GLM ships the `glm-5.3` family (`glm-5.3`, `glm-5.3-flash`, `glm-5.2`, `glm-5.1`, `glm-5`) and adds whatever its coding host lists |
+| Model picker | each provider's own models, plus **`auto` as its own route** spanning them. Membership comes from the provider's own model list, read once and cached as that route's table (`~/.dsh/plugins/kimi-oauth/model-catalog.json`), so the picker never spends a request and a release or retirement server-side needs no plugin update. Kimi serves `kimi-for-coding`, `k3` (1M) and `k3-256k`; Grok adds whatever its live catalog reports on top of `grok-4.6`/`grok-4.5`; Antigravity lists the agent-callable subset of what its endpoint reports (`fetchAvailableModels`), filtering out tabs, commit-message and transcription surfaces; GLM adds whatever its coding host lists on top of the `glm-5.3` family |
 
 Credentials live at `~/.dsh/plugins/kimi-oauth/auth.json` (mode `0600`,
 written atomically, one section per provider). The directory keeps the name this

package/README.md

@@ -13,12 +13,12 @@ Sign in once per provider from **Settings → Subscriptions** and that provider'
 
 | Provider | What you get | Sign-in |
 | --- | --- | --- |
-| **Kimi Code** | `kimi-for-coding`, `k3`, `k3[1m]`, `k3-256k` + live catalog | OAuth device flow (show code, confirm in browser) |
-| **Grok (X Premium)** | `grok-4.7`, `grok-4.6`, … + live catalog, **⚡ lightspeed** fast variant | Browser OAuth (auto-redirect) |
-| **Google Antigravity** | Claude Sonnet/Opus, Gemini Flash, GPT-OSS, with reasoning tiers | Google account OAuth |
-| **GLM (BigModel)** | `glm-5.3`, `glm-5.3-flash`, `glm-5.2`, `glm-5.1`, `glm-5` | ZCode browser sign-in (polled) |
-| **Volcengine Ark** | Ark coding models + live catalog | Volcengine SSO |
-| **Xiaomi MiMo** | MiMo Pro, MiMo Flash | Xiaomi account (QR / password) |
+| **Kimi Code** | `kimi-for-coding`, `k3` (1M), `k3-256k` — read from the endpoint's own model list | OAuth device flow (show code, confirm in browser) |
+| **Grok (X Premium)** | whatever the account's own model list reports (e.g. `grok-4.7`), **⚡ lightspeed** fast variant | Browser OAuth (auto-redirect) |
+| **Google Antigravity** | Claude Sonnet/Opus, Gemini Flash, GPT-OSS, with reasoning tiers — read from the account's own list | Google account OAuth |
+| **GLM (BigModel)** | whatever the coding host lists (e.g. `glm-5.3`, `glm-5.3-flash`) | ZCode browser sign-in (polled) |
+| **Volcengine Ark** | the plan's own coding models | Volcengine SSO |
+| **Xiaomi MiMo** | MiMo's own model list, with the app's two-model set as the fallback | Xiaomi account (QR / password) |
 | **WorkBuddy (国内版)** | Hy, GLM, Kimi, DeepSeek, MiniMax models | Browser OAuth (Tencent) |
 
 Every provider also feeds the **`auto`** route, which spans them all: pick `auto` and the harness walks your enabled models in order until one answers.
@@ -28,6 +28,7 @@ Every provider also feeds the **`auto`** route, which spans them all: pick `auto
 - **One sign-in per provider** — no API keys to find, paste, or rotate. The plugin runs the provider's own OAuth/device flow and keeps the token on disk (`~/.dsh/plugins/kimi-oauth/auth.json`, mode `0600`).
 - **Live plan usage** — the Settings card and the composer chip show each account's remaining quota (Kimi's 5-hour / weekly windows + credit, Grok's weekly credit, Antigravity's Gemini + Claude buckets, GLM/Ark/MiMo/WorkBuddy credits), with a meter and reset time.
 - **Model picker integration** — each provider's models appear in the session picker with context windows and reasoning tiers; hide or re-order them per provider.
+- **Catalogs come from the provider, not from this build** — every route reads its own model list once and caches it as the provider's table, so a model released, renamed or retired server-side shows up (or disappears) without a plugin update. Signing in and the Settings **refresh models** action are what re-read it; browsing the picker never spends a request.
 - **⚡ Fast / lightspeed variants** — for models that have one (e.g. Grok 4.7 → `grok-4.7-build-fast`), a bolt button beside the model selector switches to the fast variant; it reads as a reasoning rung so the base model always stays selectable.
 - **Cross-account pool** — sign in to several accounts on one provider; the plugin draws on the next account when one's allowance runs out.
 - **Auto fallback** — `auto` moves to the next enabled model when a provider refuses the preferred one (renamed, rate-limited, out of quota), and stops falling back once a stream has started.

package/README.zh.dev.md

@@ -56,7 +56,7 @@ Antigravity 的流程是 Google 的桌面 OAuth 客户端（`accounts.google.com
 | --- | --- |
 | `ctx.llm` | `kimi`、`grok`、`antigravity`、`glm` 和 `auto` 提供方路由（模型、推理强度、流式输出） |
 | Settings | 一个 **Subscriptions** 区域：每个提供方一张卡片——登录、退出登录、默认账户、令牌刷新、套餐配额、模型目录、管理对话框 |
-| 模型选择器 | 每个提供方自己的模型，外加**作为独立路由的 `auto`**，横跨它们——Kimi 提供 `kimi-for-coding`、`k3`、`k3[1m]`、`k3-256k`；Grok 内置 `grok-4.6`、`grok-4.5`，并加入其实时目录所报告的任何模型；Antigravity 列出其端点所报告内容（`fetchAvailableModels`）中可供 agent 调用的子集，过滤掉 tabs、commit-message 和 transcription 相关层面；GLM 提供 `glm-5.3` 系列（`glm-5.3`、`glm-5.3-flash`、`glm-5.2`、`glm-5.1`、`glm-5`），并加入其编码主机所列出的一切 |
+| 模型选择器 | 每个提供方自己的模型，外加**作为独立路由的 `auto`**，横跨它们。成员资格来自提供方自己的模型列表：每个路由只读取一次并缓存为该路由的目录（`~/.dsh/plugins/kimi-oauth/model-catalog.json`），因此选择器不会发出请求，服务端新增或下线模型也无需插件更新。Kimi 提供 `kimi-for-coding`、`k3`（1M）与 `k3-256k`；Grok 在 `grok-4.6`、`grok-4.5` 之上加入其实时目录所报告的任何模型；Antigravity 列出其端点所报告内容（`fetchAvailableModels`）中可供 agent 调用的子集，过滤掉 tabs、commit-message 和 transcription 相关层面；GLM 在 `glm-5.3` 系列之上加入其编码主机所列出的一切 |
 
 凭证存放在 `~/.dsh/plugins/kimi-oauth/auth.json`（模式 `0600`，原子写入，每个提供方
 一个区段）。该目录保留了本插件在只服务 Kimi Code 时所用的名称：它保存着**活跃的

package/README.zh.md

@@ -13,12 +13,12 @@
 
 | 服务 | 可用模型 | 登录方式 |
 | --- | --- | --- |
-| **Kimi Code** | `kimi-for-coding`、`k3`、`k3[1m]`、`k3-256k` + 实时目录 | OAuth 设备流（显示代码，浏览器确认） |
-| **Grok (X Premium)** | `grok-4.7`、`grok-4.6`… + 实时目录，**⚡ lightspeed** 快速变体 | 浏览器 OAuth（自动回调） |
-| **Google Antigravity** | Claude Sonnet/Opus、Gemini Flash、GPT-OSS，带推理档 | Google 账号 OAuth |
-| **GLM (BigModel)** | `glm-5.3`、`glm-5.3-flash`、`glm-5.2`、`glm-5.1`、`glm-5` | ZCode 浏览器登录（轮询） |
-| **Volcengine Ark** | Ark 编程模型 + 实时目录 | 火山引擎 SSO |
-| **Xiaomi MiMo** | MiMo Pro、MiMo Flash | 小米账号（扫码 / 密码） |
+| **Kimi Code** | `kimi-for-coding`、`k3`（1M）、`k3-256k` —— 直接来自端点自己的模型列表 | OAuth 设备流（显示代码，浏览器确认） |
+| **Grok (X Premium)** | 账号自己的模型列表所报告的一切（如 `grok-4.7`），**⚡ lightspeed** 快速变体 | 浏览器 OAuth（自动回调） |
+| **Google Antigravity** | Claude Sonnet/Opus、Gemini Flash、GPT-OSS，带推理档 —— 来自账号自己的列表 | Google 账号 OAuth |
+| **GLM (BigModel)** | 编码主机列出的一切（如 `glm-5.3`、`glm-5.3-flash`） | ZCode 浏览器登录（轮询） |
+| **Volcengine Ark** | 套餐自己的编程模型 | 火山引擎 SSO |
+| **Xiaomi MiMo** | MiMo 自己的模型列表，读取失败时回退到应用内置的两个模型 | 小米账号（扫码 / 密码） |
 | **WorkBuddy (国内版)** | Hy、GLM、Kimi、DeepSeek、MiniMax 模型 | 浏览器 OAuth（腾讯） |
 
 每个服务也会汇入 **`auto`** 路由，它横跨全部：选 `auto`，harness 会按顺序尝试你已启用的模型，直到有响应。
@@ -28,6 +28,7 @@
 - **每个服务登录一次** —— 无需找、贴、轮换 API Key。插件运行服务自己的 OAuth/设备流，令牌保存在磁盘（`~/.dsh/plugins/kimi-oauth/auth.json`，权限 `0600`）。
 - **实时套餐额度** —— 设置卡片和输入框 chip 显示每个账号的剩余额度（Kimi 的 5 小时 / 每周窗口 + 额度，Grok 每周额度，Antigravity 的 Gemini + Claude 分组，GLM/Ark/MiMo/WorkBuddy 的额度），带进度条和重置时间。
 - **模型选择器集成** —— 每个服务的模型带上下文窗口和推理档出现在选择器里；可按服务隐藏或排序。
+- **模型目录来自服务本身，而不是本插件** —— 每个路由只读取一次服务自己的模型列表，并把它缓存为该路由的目录，因此服务端新增、改名或下线的模型无需插件更新即可出现（或消失）。重新读取的时机是登录成功和设置页的**刷新模型**；浏览选择器不会发出任何请求。
 - **⚡ 快速 / lightspeed 变体** —— 对有快速变体的模型（如 Grok 4.7 → `grok-4.7-build-fast`），模型选择器旁的闪电按钮一键切换；它作为推理档实现，基础模型始终可选。
 - **多账号池** —— 一个服务可登录多个账号；某账号额度用尽时自动切到下一个。
 - **Auto 回退** —— `auto` 在首选模型被拒（改名、限流、额度尽）时改用下一个已启用模型，且流开始后不再回退。

package/lib/client/FastModeButton.d.ts

@@ -23,7 +23,6 @@ import type { SessionStandardProps } from '@deepseek-ai/dsh-client-ui-slots';
 import type { SubscriptionsCall } from './subscriptions-rpc.js';
 /** Injected props the button is registered with. */
 export interface FastModeButtonInjected {
-    /** The plugin's own RPC caller, for the one `model-variants` read. */
     call: SubscriptionsCall;
     /** Whether the provider is one this plugin serves. */
     isOwnProvider: (provider: string) => boolean;

package/lib/client/FastModeButton.js

@@ -22,6 +22,15 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { useEffect, useState } from 'react';
 import { providerOf } from './UsageChip.js';
 import { fastModeCss } from './styles.js';
+/**
+ * How many times a *loading* route is re-asked, and how long between attempts.
+ *
+ * The route answers `pending` while it has not read its listing, which is the only case
+ * worth asking again: a route that has read its listing and reports no variant means the
+ * model truly has none, and the button stays absent without further reads.
+ */
+const VARIANT_READ_ATTEMPTS = 6;
+const VARIANT_READ_INTERVAL_MS = 1_000;
 /**
  * The quick-mode control, for the composer's row of standard controls.
  *
@@ -43,17 +52,45 @@ export function FastModeButton({ call, isOwnProvider, modelDirectory, useProject
             return;
         }
         let live = true;
-        void call('model-variants', { provider, id: model })
-            .then((result) => {
-            if (!live)
-                return;
-            // The rung is the provider's own word (xAI `lightspeed`, Kimi `highspeed`), so
-            // the picker reads a name the model's own docs use, not a generic "Fast".
-            setPair(result?.fast === undefined ? undefined : { rung: result.fastRung ?? 'fast' });
-        })
-            .catch(() => { if (live)
-            setPair(undefined); });
-        return () => { live = false; };
+        let timer;
+        // A variant is derived from the route's model listing, which is read asynchronously and
+        // may still be in flight when the composer mounts (a cold start, or the first run after
+        // an update). The route says so with `pending`, and only then is it worth asking again:
+        // a route that has read its listing and names no variant has answered for good.
+        let attempts = 0;
+        const ask = () => {
+            attempts += 1;
+            void call('model-variants', { provider, id: model })
+                .then((result) => {
+                if (!live)
+                    return;
+                if (result?.fast !== undefined) {
+                    // The rung is the provider's own word (xAI `lightspeed`, Kimi `highspeed`), so
+                    // the picker reads a name the model's own docs use, not a generic "Fast".
+                    setPair({ rung: result.fastRung ?? 'fast' });
+                    return;
+                }
+                setPair(undefined);
+                // Still reading its listing: ask again, up to the cap, then accept the answer.
+                if (result?.pending === true && attempts < VARIANT_READ_ATTEMPTS) {
+                    timer = setTimeout(ask, VARIANT_READ_INTERVAL_MS);
+                }
+            })
+                .catch(() => {
+                // A read that failed outright is worth one more try, on the same budget.
+                if (!live)
+                    return;
+                setPair(undefined);
+                if (attempts < VARIANT_READ_ATTEMPTS)
+                    timer = setTimeout(ask, VARIANT_READ_INTERVAL_MS);
+            });
+        };
+        ask();
+        return () => {
+            live = false;
+            if (timer !== undefined)
+                clearTimeout(timer);
+        };
     }, [provider, model, isOwnProvider, call]);
     // A switch that landed clears the reason, so the marker follows the truth on screen.
     useEffect(() => { setFailure(undefined); }, [model]);

package/lib/client.js

@@ -3061,6 +3061,15 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 //#endregion
 //#region src/client/FastModeButton.tsx
 /**
+* How many times a *loading* route is re-asked, and how long between attempts.
+*
+* The route answers `pending` while it has not read its listing, which is the only case
+* worth asking again: a route that has read its listing and reports no variant means the
+* model truly has none, and the button stays absent without further reads.
+*/
+const VARIANT_READ_ATTEMPTS = 6;
+const VARIANT_READ_INTERVAL_MS = 1e3;
+/**
 * The quick-mode control, for the composer's row of standard controls.
 *
 * @param props - injected RPC caller, directory, and the session standard kit.
@@ -3079,17 +3088,31 @@ function FastModeButton({ call, isOwnProvider, modelDirectory, useProjection })
 			return;
 		}
 		let live = true;
-		call("model-variants", {
-			provider,
-			id: model
-		}).then((result) => {
-			if (!live) return;
-			setPair(result?.fast === void 0 ? void 0 : { rung: result.fastRung ?? "fast" });
-		}).catch(() => {
-			if (live) setPair(void 0);
-		});
+		let timer;
+		let attempts = 0;
+		const ask = () => {
+			attempts += 1;
+			call("model-variants", {
+				provider,
+				id: model
+			}).then((result) => {
+				if (!live) return;
+				if (result?.fast !== void 0) {
+					setPair({ rung: result.fastRung ?? "fast" });
+					return;
+				}
+				setPair(void 0);
+				if (result?.pending === true && attempts < VARIANT_READ_ATTEMPTS) timer = setTimeout(ask, VARIANT_READ_INTERVAL_MS);
+			}).catch(() => {
+				if (!live) return;
+				setPair(void 0);
+				if (attempts < VARIANT_READ_ATTEMPTS) timer = setTimeout(ask, VARIANT_READ_INTERVAL_MS);
+			});
+		};
+		ask();
 		return () => {
 			live = false;
+			if (timer !== void 0) clearTimeout(timer);
 		};
 	}, [
 		provider,