dsh-multi-router 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。版本号从 `0.1` 起以功能迭代为主，接口在 `1.0` 前可能变化。
 
+## 0.6.2
+
+- 修复旧用户升级后缺少新预制路由：启用或热加载时自动补齐 Qwen3.8-Max、Qwen3.8-Flash 与 Hy4 Preview，更新后直接出现在路由列表与模型选择器，无需手动补齐或重启。
+- 记录已处理的预配置；重复启用不重复写入，用户改名、隐藏、改规则及旧预设的删除选择保留。新增预设处理后再次删除，不会在下一次启动恢复。
+- 预配置处理记录随配置迁移；合并保留两端记录。升级写入使用现有文件锁与原子保存，损坏配置不自动重置。
+
+## 0.6.1
+
+- 保留三家模型的默认 / 最大上下文和可选档位，原始模型、预制路由及动态免费模型默认最大，不再统一限制 200K；旧隐式默认自动迁移，显式自定义预算保留。
+- 模型设置集中管理名称、上下文预算、图片开关和默认推理档位；免费模型逐项选择预算。原始模型与路由独立设置，随配置导入导出。
+- 路由跳过容量不足的账号，不截断会话或静默降低容量；Qoder 每次请求使用能容纳预算的真实档位，并发选择不污染共享目录。
+- 增加 Qwen3.8-Max、Qwen3.8-Flash 预配置，使用已核对的 Trae / Qoder 模型 ID；补齐预配置不覆盖已有路由。
+- 增加 Hy4 Preview 预配置，精确绑定 WorkBuddy 的 `hy4-preview`；容量与推理模式跟随该渠道目录，支持多个 WorkBuddy 账号切换。
+- 增加手动短请求连通性测试，有超时、间隔与错误流检查，不自动发送容量探测。显示最大输出与完整推理模式，只有声明支持的模型提供图片与关闭思考选项。
+- 对比 dingminhua 的 WorkBuddy / Trae 插件并记录设计取舍，更新模型设置的合成数据截图。
+
 ## 0.6.0
 
 - 新增左侧底部 Token 用量概览，展示今日与累计 Token，点击直达插件详情；默认显示，可在版本号旁关闭并保存到配置。仅读取本机缓存统计，每分钟更新，隐藏窗口暂停，不额外查询供应商。

package/README.md

@@ -6,11 +6,11 @@
 
 一个插件内置 WorkBuddy、Trae、Qoder 的认证、模型发现和聊天传输，提供三家的多账号池及集中路由。运行不依赖原来三个 DSH 插件；三家代码随安装包一起打包。基于 MIT 上游，固定版本见 `upstream-lock.json`，许可见 `THIRD_PARTY_NOTICES.md`。
 
-版本：0.6.0。适配 DSH Desktop / Web 0.2.0-rc.2，Node.js ^22.19.0 或 >=24。
+版本：0.6.2。适配 DSH Desktop / Web 0.2.0-rc.2，Node.js ^22.19.0 或 >=24。
 
 ## 在 DSH 里管理
 
-打开 **插件 → dsh-multi-router 的配置页**。默认进入总览，八个页签：
+打开 **插件 → dsh-multi-router 的配置页**。默认进入总览，九个页签：
 
 - **总览与用量**：今日/累计请求与 Token、近 7 日趋势、最近请求、三家平台余额与刷新时间。平台余额后台每 5 分钟查询，面板每分钟读取本机缓存，隐藏页面暂停轮询，可关闭自动刷新；手动刷新平台用量会立即查询。
 - **Token 明细**：每次上游调用的时间、渠道、账号、路由、实际模型、输入/输出/总 Token 和结果；支持今日、近 3 日、近 7 日、近 30 日及自定义日期范围（北京时间自然日），并按账号、路由、结果筛选，每页 50 条。缓存输入和推理输出在平台返回时展示，不重复计入总量。默认滚动保留最近 30 × 24 小时，可设置 1–365 天，并随配置迁移。同时展示模型用时、工具调用用时、首 Token 平均（TTFT）和输出速度（TPS），可展开单次性能。DSH 步骤采用会话统计相同口径；TPS 按有效输出 Token / 解码秒数加权计算。性能汇总只包含成功调用，随当前筛选变化；旧记录缺少的分项显示「—」。
@@ -18,8 +18,8 @@
 - **积分签到**：按账号设置每日启动签到或定时签到（北京时间），保留每日执行记录、领取意图与设备限制，避免重复请求。
 - **API 服务**：默认关闭，按需提供 OpenAI 兼容的模型列表和聊天接口，支持流式 / 普通 JSON、工具调用与推理参数；复用现有账号池及路由，Key 独立管理，API 用量可在 Token 明细按来源筛选。
 - **插件更新**：仅检查用户安装的 GitHub / npm 插件，包含停用插件；每 24 小时自动检查，在 DSH 任意页面弹窗提醒新版本。同一更新点击关闭或「稍后处理」后不重复提醒，更高版本 / 新提交再次提醒。可在弹窗查看并手动更新；不自动安装。检查失败不冒充发现新版本，内置组件不检查、不展示。
-- **模型管理**：原始模型默认隐藏，只展示统一路由；提供所有渠道「全部展示」「全部隐藏（仅路由）」，作用于现有和以后发现的模型。可搜索、获取真实模型目录，修改显示名与单模型展示开关，每家独立保存。
-- **路由规则**：Free 免费路由排在首位，显示各账号当前免费模型与目录检查时间，支持立即检查。列表显示路由名称、切换策略和目标；新建/编辑打开二级弹窗。「添加模型预配置」可逐个添加或补齐全部三家预配置，不覆盖已有同 ID 路由。模型可从下拉列表选择，候选 ID 和上下文长度放在高级选项中。
+- **模型管理**：原始模型默认隐藏，只展示统一路由；提供所有渠道「全部展示」「全部隐藏（仅路由）」，作用于现有和以后发现的模型。可搜索、获取真实模型目录，修改显示名与单模型展示开关，每家独立保存。显示实际上下文、最大上下文、输出上限和完整推理档位；「设置」可调整上下文预算、图片输入及默认推理等级，「测试」手动发送短请求检查连通性（正常计费，不代表满上下文测试）。
+- **路由规则**：Free 免费路由排在首位，显示各账号当前免费模型与目录检查时间，支持立即检查。列表显示路由名称、切换策略和目标；新建/编辑打开二级弹窗。「添加模型预配置」可逐个添加或补齐全部预配置（Qwen3.8-Max / Flash 连接已核对的 Trae、Qoder 渠道），不覆盖已有同 ID 路由。模型可从下拉列表选择，上下文默认采用目标渠道已发现的最大容量，支持手动设置较小预算；候选 ID 放在高级选项中。
 
 - **配置迁移**：导入 / 导出设置，或使用密码加密迁移账号登录凭证。
 
@@ -31,8 +31,20 @@
 
 隐藏只影响模型选择器，已有会话及路由仍可使用隐藏模型；停用账号会将其从新请求的候选池中排除。移出账号池保留独立凭证文件，且禁止移除仍被路由明确绑定的账号。
 
+### 上下文设置
+
+原始模型、预制路由及动态免费模型默认采用各渠道已声明的最大上下文，保留手动调低预算的选择。原始模型在「模型管理 → 设置」调整；普通路由在「编辑路由 → 上下文容量」调整；免费模型在「管理免费模型」逐项调整。旧版隐式 200K 默认会迁移为最大容量，显式自定义预算保留。
+
+路由只切换到能够容纳当前预算的渠道，不截断历史、不静默降低容量。Qoder 请求同步选择真实的上下文档位，且不同并发路由互不影响。最大窗口来自渠道目录，账号额度、限流或请求体限制仍可能影响实际可用长度；短请求测试不验证满窗口。
+
+原始模型设置和路由预算独立保存。上下文、图片、默认推理及免费模型设置均随配置迁移。
+
+两个参考插件的源码对比与本次处理方式见 [参考对比](docs/reference-comparison.md)。
+
 ### 界面预览
 
+![模型上下文和能力设置（v0.6.1，合成数据，无真实账号）](https://raw.githubusercontent.com/AndroidSix/dsh-multi-router/main/docs/screenshots/model-context.jpg)
+
 以下主要页面已更新为 **v0.5.9 实际面板 + 合成演示数据**。账号名称已替换，不包含真实手机号、邮箱、身份 ID、设备标识、登录凭证或会话内容；余额、用量和性能均为演示数值。
 
 | 总览与用量 | Token 明细与调用性能 |
@@ -300,9 +312,9 @@ node lib/cli.js remove --id wb1
 
 `modelVisibility` 按供应商保存新发现模型的展示默认值，省略时为 false。单模型 `visible` 优先；批量操作同时更新渠道默认值和已有单模型覆盖项，保留模型名称和路由配置。完整配置导入 / 导出也保留该默认值。
 
-## 三家模型预配置（0.3.5）
+## 模型预配置
 
-新增 Free 自动免费路由，并保留以下七种国内渠道共有模型路由。每条默认 WorkBuddy → Trae → Qoder，使用该渠道全部启用账号，临期优先开启，200K 上下文 / 32K 最大输出。Flash 仍采用用户已允许的三家 Flash 兼容切换；其他预配置精确绑定对应版本，不混用 GLM FlashX 等变体。目录或账号权限变化可能使目标暂不可用，预配置弹窗显示当前已发现可用渠道数。
+Free 自动免费路由排在首位，以下普通预配置按表中渠道顺序切换，使用该渠道全部启用账号，默认临期优先、目录声明的最大上下文 / 32K 最大输出。Flash 仍采用用户已允许的三家 Flash 兼容切换；其他预配置精确绑定对应版本，不混用 GLM FlashX 等变体。空白渠道不参与该路由。目录或账号权限变化可能使目标暂不可用，预配置弹窗显示当前已发现可用渠道数。
 
 | 路由调用 ID | WorkBuddy 目标 ID | Trae 目标 ID | Qoder 目标 ID |
 | --- | --- | --- | --- |
@@ -313,9 +325,14 @@ node lib/cli.js remove --id wb1
 | kimi-k3 | kimi-k3-1 | kimi-k3 | kmodel_latest |
 | kimi-k2.8-preview | kimi-k2.8-preview | kimi-k2.8-preview | kmodel |
 | minimax-m2.7 | minimax-m2.7 | minimax-m2.7 | mmodel |
+| qwen3.8-max | — | qwen3.8-max | qmodel_38max |
+| qwen3.8-flash | — | qwen3.8-flash | qfmodel |
+| hy4-preview | hy4-preview | — | — |
 
 路由内部 ID 是 DSH 查找路由所需的标识，由插件维护；用户在面板只配置路由名称。目标模型 ID 决定实际调用哪个模型。上表为预配置的稳定内部标识，新建路由自动生成独立标识。GLM-5.2 已移出预配置，原始渠道模型不受影响。
 
+从 v0.6.2 起，升级后的首次启用或热加载自动补齐新引入的预配置，无需重启或手动点击。首次迁移补齐 Qwen3.8-Max / Flash 与 Hy4 Preview，已有同 ID 路由的名称、显隐和规则保持原样，旧预设中已移除的路由不会恢复。已处理的预设会记录在配置中，此后主动删除也不会在启动时恢复；需要恢复时可在「添加预配置」手动添加。记录随配置导入导出迁移。
+
 ## Free 动态免费模型（0.3.6）
 
 预配置内置 free 管理组，名称「Free · 动态免费模型」，排在预配置与路由管理列表首位。按确切的渠道与模型 ID 自动创建各模型的免费路由，DSH 模型列表分别展示「Free · 模型名 · 渠道」，排在普通预配置前。同一渠道同一模型的多个免费账号归为一个路由，不按展示名称模糊合并版本，也不把不同模型混为一个池。原 free 内部标识仅为旧会话保留，默认不在选择器展示。

package/THIRD_PARTY_NOTICES.md

@@ -11,6 +11,10 @@
 - 使用或再分发本项目时，你必须**同时**遵守本项目 [`LICENSE`](./LICENSE) 与下列三个上游项目的 MIT 许可要求。
 - 上游项目的维护、更新与可用性不由本项目负责。
 
+## 设计参考（未包含代码）
+
+模型管理交互参考 [dingminhua/dsh-connect-workbuddy](https://github.com/dingminhua/dsh-connect-workbuddy) 与 [dingminhua/dsh-connect-trae](https://github.com/dingminhua/dsh-connect-trae) 的上下文预算、能力展示和测试反馈设计。本次管理界面与上下文路由逻辑由本项目独立实现，未复制这两个参考项目的新源码；核对的 commit 和差异见 [参考对比](docs/reference-comparison.md)。内置的 Trae 固定版本及其许可仍按下文履行。
+
 ## 本地集成改动 / Local Integration Changes
 
 - WorkBuddy 的共享适配器额外透传集成后 provider 目录中**显式声明**的 Minimal 推理模式；WorkBuddy 原有的模型发现逻辑与 provider 专有的档位词表未作改动。

package/cordis.patch.yml

@@ -1,3 +1,3 @@
 - insert:
-    - id: llm-multi-router-v2-0.6.0
-      name: ./lib/host-v0.6.0.js
+    - id: llm-multi-router-v2-0.6.2
+      name: ./lib/host-v0.6.2.js

package/lib/accounts.js

@@ -4,11 +4,11 @@ import {
   localAccountKey,
   normalizeLocalAccountKey,
   readPortableCredential
-} from "./chunk-JUOESKAK.js";
+} from "./chunk-KGVTRS5K.js";
 import "./chunk-OK2T2UAZ.js";
 import "./chunk-TEZ2FMEO.js";
 import "./chunk-S5KMFAQM.js";
-import "./chunk-WVNY4LSL.js";
+import "./chunk-5R3IOPSF.js";
 export {
   discoverLocalAccounts,
   importAccount,

package/lib/api-service.js

@@ -1,10 +1,10 @@
 import {
   ApiService
-} from "./chunk-SNEZMYNU.js";
+} from "./chunk-Q34JSMGN.js";
 import "./chunk-4V52V5GO.js";
 import "./chunk-DNQPZMPF.js";
-import "./chunk-ROZINFTV.js";
-import "./chunk-WVNY4LSL.js";
+import "./chunk-5KYJADJ4.js";
+import "./chunk-5R3IOPSF.js";
 export {
   ApiService
 };

package/lib/{chunk-LLDJVBTQ.js → chunk-3O3L3526.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-DNQPZMPF.js";
 import {
   RouteError
-} from "./chunk-ROZINFTV.js";
+} from "./chunk-5KYJADJ4.js";
 import {
   REASONING_EFFORTS
-} from "./chunk-WVNY4LSL.js";
+} from "./chunk-5R3IOPSF.js";
 
 // src/shim.mjs
 import { createServer } from "node:http";
@@ -117,4 +117,4 @@ function createShim(router, { modelPrefix = "" } = {}) {
 export {
   createShim
 };
-//# sourceMappingURL=chunk-LLDJVBTQ.js.map
+//# sourceMappingURL=chunk-3O3L3526.js.map

package/lib/{chunk-OCMOMSB4.js → chunk-4EO5V6FW.js}

@@ -6,44 +6,45 @@ import {
   refreshWorkBuddyCheckinCredential,
   supportsCheckin,
   workbuddyToken
-} from "./chunk-NSKCFVHP.js";
+} from "./chunk-74WQLVJO.js";
 import {
   discoverLocalAccounts,
   importAccount,
   localAccountKey,
   normalizeLocalAccountKey,
   readPortableCredential
-} from "./chunk-JUOESKAK.js";
+} from "./chunk-KGVTRS5K.js";
 import {
   modelWithCurrentPromotion
 } from "./chunk-TEZ2FMEO.js";
 import {
   ApiService
-} from "./chunk-SNEZMYNU.js";
+} from "./chunk-Q34JSMGN.js";
 import {
   hostIsLoopback
 } from "./chunk-DNQPZMPF.js";
 import {
   Telemetry,
-  matchModel
-} from "./chunk-ROZINFTV.js";
+  contextInfo,
+  matchModel,
+  resolveContext
+} from "./chunk-5KYJADJ4.js";
 import {
   PROVIDERS,
   PROVIDER_NAMES,
   ROUTE_PRESETS,
   beijingDay,
   isFreeModel,
-  reasoningModes,
   routeReasoning,
   validateConfig,
   writePrivateJson
-} from "./chunk-WVNY4LSL.js";
+} from "./chunk-5R3IOPSF.js";
 
 // src/manager.mjs
 import { createHash, randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
 
 // package.json
-var version = "0.6.0";
+var version = "0.6.2";
 
 // src/manager.mjs
 import { readFile as readFile4, mkdir as mkdir2, mkdtemp as mkdtemp2, rm as rm3 } from "node:fs/promises";
@@ -105,14 +106,14 @@ var derive = promisify(scrypt);
 var FORMAT = "dsh-multi-router";
 var MAX_BYTES = 512 * 1024;
 var pick = (value, keys) => Object.fromEntries(keys.filter((k) => Object.hasOwn(value ?? {}, k)).map((k) => [k, value[k]]));
-var options = ["cooldownMs", "requestTimeoutMs", "catalogTtlMs", "retryServerErrors", "modelVisibility", "usageRetentionDays", "checkinSchedule", "sidebarUsage"];
+var options = ["cooldownMs", "requestTimeoutMs", "catalogTtlMs", "retryServerErrors", "modelVisibility", "usageRetentionDays", "checkinSchedule", "sidebarUsage", "seenRoutePresets"];
 function settings(config) {
   return {
     ...pick(config, options),
-    models: Object.fromEntries(Object.entries(config.models ?? {}).map(([p, rows]) => [p, Object.fromEntries(Object.entries(rows).map(([id, pref]) => [id, pick(pref, ["name", "visible"])]))])),
+    models: Object.fromEntries(Object.entries(config.models ?? {}).map(([p, rows]) => [p, Object.fromEntries(Object.entries(rows).map(([id, pref]) => [id, pick(pref, ["name", "visible", "contextWindow", "supportsImages", "reasoningEffort"])]))])),
     accounts: config.accounts.map((a) => pick(a, ["id", "provider", "name", "enabled", "autoCheckin"])),
     routes: Object.fromEntries(Object.entries(config.routes).map(([id, r]) => [id, {
-      ...pick(r, ["name", "visible", "strategy", "contextWindow", "maxTokens", "preferExpiringCredits", "expiringWithinDays", "freeOnly", "freeModels"]),
+      ...pick(r, ["name", "visible", "strategy", "contextMode", "contextWindow", "maxTokens", "preferExpiringCredits", "expiringWithinDays", "freeOnly", "freeModels"]),
       targets: r.targets.map((t) => pick(t, ["provider", "account", "model", "models", "weight", "tokenBudget", "creditBudget"]))
     }]))
   };
@@ -230,6 +231,7 @@ async function prepareMigration(manager, raw, portable, mode) {
     const next = mode === "replace" ? { ...portable.config, accounts: imported } : {
       ...raw,
       ...pick(portable.config, options),
+      ...raw.seenRoutePresets || portable.config.seenRoutePresets ? { seenRoutePresets: [.../* @__PURE__ */ new Set([...raw.seenRoutePresets ?? [], ...portable.config.seenRoutePresets ?? []])] } : {},
       accounts: [...raw.accounts.map((a) => imported.find((b) => b.id === a.id) ?? a), ...imported.filter((a) => !raw.accounts.some((b) => b.id === a.id))],
       routes: { ...raw.routes, ...portable.config.routes },
       models: Object.fromEntries([.../* @__PURE__ */ new Set([...Object.keys(raw.models ?? {}), ...Object.keys(portable.config.models)])].map((p) => [p, { ...raw.models?.[p], ...portable.config.models[p] }]))
@@ -1033,8 +1035,8 @@ function modelInfo(row) {
   return {
     id: row.id,
     name: row.name || row.id,
-    contextWindow: finite(row.contextWindow, 2e5),
-    maxTokens: Math.min(finite(row.maxTokens, 32e3), finite(row.contextWindow, 2e5)),
+    ...contextInfo(row),
+    maxTokens: Math.min(finite(row.maxTokens, 32e3), contextInfo(row).maxContextWindow),
     supportsImages: row.supportsImages === true || row.multimodal === true || row.input?.includes("image") === true,
     ...reasoning ? { reasoning } : {},
     ...billing ? { billing } : {},
@@ -1085,7 +1087,7 @@ var Manager = class {
       for (const account of this.config.accounts) {
         const item = saved[account.id];
         if (item?.credentialFile === account.credentialFile && Array.isArray(item.models)) {
-          this.catalogs.set(account.id, { ...item, models: item.models.filter((m) => typeof m.id === "string" && m.id.length > 0).map(modelInfo) });
+          this.catalogs.set(account.id, { ...item, ...item.contextVersion !== 1 ? { fetchedAt: 0 } : {}, models: item.models.filter((m) => typeof m.id === "string" && m.id.length > 0).map(modelInfo) });
         }
       }
     } catch {
@@ -1284,16 +1286,25 @@ var Manager = class {
         const id = `free_${createHash("sha256").update(JSON.stringify([parentId, account.provider, model.id])).digest("hex").slice(0, 24)}`;
         if (!groups.has(id)) groups.set(id, { id, models: [], targets: [], accountNames: [], modelName: model.name, provider: account.provider, modelId: model.id });
         const group = groups.get(id);
-        group.models.push({ model, provider: account.provider });
+        group.models.push({ model, provider: account.provider, accountId: account.id });
         group.targets.push({ provider: account.provider, account: account.id, model: model.id });
         group.accountNames.push(account.name ?? account.id);
       }
     }
     return [...groups.values()].map(({ models, ...group }) => {
-      const preference = row.freeModels?.[group.id] ?? {}, reasoning = routeReasoning(models);
+      const preference = row.freeModels?.[group.id] ?? {};
+      const context = resolveContext(models.map((s) => s.model), preference.contextWindow ?? (row.contextMode === "custom" ? row.contextWindow : null), row.contextWindow);
+      const eligible = models.filter((s) => contextInfo(s.model).maxContextWindow >= context.contextWindow);
+      const eligibleAccountIds = eligible.map((s) => s.accountId);
+      const reasoning = routeReasoning(eligible);
       const selected = preference.reasoningEffort;
       return {
         ...group,
+        ...context,
+        eligibleAccountIds,
+        targets: group.targets.filter((t) => eligibleAccountIds.includes(t.account)),
+        accountNames: group.accountNames.filter((_, i) => eligibleAccountIds.includes(models[i].accountId)),
+        enforceContext: true,
         parentId,
         dynamicFree: true,
         freeOnly: true,
@@ -1306,9 +1317,8 @@ var Manager = class {
         effortUnavailable: !!selected && !reasoning?.supportedEfforts.includes(selected),
         visible: row.visible !== false && preference.visible !== false,
         selected: preference.visible !== false,
-        supportsImages: models.every(({ model }) => model.supportsImages),
-        contextWindow: Math.min(row.contextWindow, ...models.map(({ model }) => model.contextWindow)),
-        maxTokens: Math.min(row.maxTokens, ...models.map(({ model }) => model.maxTokens), ...models.map(({ model }) => model.contextWindow))
+        supportsImages: eligible.every(({ model }) => model.supportsImages),
+        maxTokens: Math.min(row.maxTokens, context.contextWindow, ...eligible.map(({ model }) => model.maxTokens))
       };
     });
   }
@@ -1323,7 +1333,7 @@ var Manager = class {
   publish() {
     this.telemetry.configure(this.config.usageRetentionDays);
     this.revision = revisionOf(this.raw);
-    const routes = { ...this.config.routes };
+    const routes = Object.fromEntries(this.routeModels().map((row) => [row.id, row]));
     for (const model of this.adapterModels().filter((m) => m.dynamicFree)) routes[model.id] = model;
     for (const provider of PROVIDERS) for (const model of this.providerModels(provider)) {
       routes[`${provider}::${model.id}`] = { ...model, targets: [{ provider, model: model.id }] };
@@ -1335,23 +1345,30 @@ var Manager = class {
     const rows = /* @__PURE__ */ new Map();
     for (const account of this.config.accounts.filter((a) => a.provider === provider && a.enabled !== false)) {
       for (const model of this.catalogs.get(account.id)?.models ?? []) {
-        const old = rows.get(model.id);
-        rows.set(model.id, old ? {
-          ...old,
-          contextWindow: Math.min(old.contextWindow, model.contextWindow),
-          maxTokens: Math.min(old.maxTokens, model.maxTokens),
-          supportsImages: old.supportsImages && model.supportsImages,
-          reasoning: routeReasoning([{ model: old, provider }, { model, provider }])
-        } : {
-          ...model,
-          ...reasoningModes(model, provider).length ? { reasoning: routeReasoning([{ model, provider }]) } : {}
-        });
+        if (!rows.has(model.id)) rows.set(model.id, []);
+        rows.get(model.id).push(model);
       }
     }
-    return [...rows.values()].map((model) => ({
-      ...model,
-      name: this.config.models[provider]?.[model.id]?.name ?? model.name
-    }));
+    return [...rows.values()].map((models) => {
+      const model = models[0], preference = this.config.models[provider]?.[model.id] ?? {};
+      const context = resolveContext(models, preference.contextWindow);
+      const eligible = models.filter((m) => contextInfo(m).maxContextWindow >= context.contextWindow);
+      const reasoning = routeReasoning(eligible.map((model2) => ({ model: model2, provider })));
+      const selected = preference.reasoningEffort;
+      return {
+        ...model,
+        ...context,
+        enforceContext: true,
+        name: preference.name ?? model.name,
+        reasoning,
+        supportsImages: preference.supportsImages !== false && eligible.every((m) => m.supportsImages),
+        imageCapable: eligible.every((m) => m.supportsImages),
+        ...selected && reasoning?.supportedEfforts.includes(selected) ? { reasoningEffort: selected } : {},
+        configuredEffort: selected ?? null,
+        effortUnavailable: !!selected && !reasoning?.supportedEfforts.includes(selected),
+        maxTokens: Math.min(context.contextWindow, ...eligible.map((m) => m.maxTokens))
+      };
+    });
   }
   hiddenModels(provider) {
     return this.providerModels(provider).filter((m) => !this.modelVisible(provider, m.id)).map((m) => m.id);
@@ -1365,14 +1382,19 @@ var Manager = class {
       const sources = effectiveTargets.flatMap((target) => this.config.accounts.filter((a) => a.enabled !== false && a.provider === target.provider && (!target.account || target.account === a.id)).flatMap((a) => {
         const catalog = this.catalogs.get(a.id)?.models ?? [];
         const models2 = target.models ? target.models.map((model) => catalog.find((m) => m.id === model)).filter(Boolean) : [matchModel(id, target, catalog)].filter(Boolean);
-        return models2.map((model) => ({ model, provider: a.provider }));
+        return models2.map((model) => ({ model, provider: a.provider, accountId: a.id }));
       }));
-      const models = sources.map((s) => s.model), reasoning = routeReasoning(sources);
+      const context = resolveContext(sources.map((s) => s.model), row.contextMode === "custom" ? row.contextWindow : null, row.contextWindow);
+      const eligible = sources.filter((s) => contextInfo(s.model).maxContextWindow >= context.contextWindow);
+      const models = eligible.map((s) => s.model), reasoning = routeReasoning(eligible);
       return {
         ...row,
+        ...context,
+        enforceContext: true,
         supportsImages: models.length > 0 && models.every((m) => m.supportsImages),
         reasoning,
-        ...row.freeOnly && models.length ? { contextWindow: Math.min(row.contextWindow, ...models.map((m) => m.contextWindow)), maxTokens: Math.min(row.maxTokens, ...models.map((m) => m.maxTokens), ...models.map((m) => m.contextWindow)) } : {},
+        eligibleAccountIds: [...new Set(eligible.map((s) => s.accountId))],
+        maxTokens: Math.min(row.maxTokens, context.contextWindow, ...models.map((m) => m.maxTokens)),
         id,
         name: row.name ?? id,
         expiringStatus: { ...this.telemetry.data.expiringRounds[id] },
@@ -1394,7 +1416,7 @@ var Manager = class {
         const client = await this.router.client(account);
         const models = (await client.models(AbortSignal.timeout(6e4), !!force)).map(modelInfo);
         if (this.closed || !this.config.accounts.some((a) => a.id === account.id && a.credentialFile === account.credentialFile)) return;
-        this.catalogs.set(account.id, { credentialFile: account.credentialFile, fetchedAt: Date.now(), pricingVersion: 1, models });
+        this.catalogs.set(account.id, { credentialFile: account.credentialFile, fetchedAt: Date.now(), pricingVersion: 1, contextVersion: 1, models });
         this.catalogErrors.delete(account.id);
         await withFileLock3(this.catalogFile, () => writePrivateJson(this.catalogFile, Object.fromEntries(this.catalogs)));
       } catch (error) {
@@ -1451,6 +1473,7 @@ var Manager = class {
       presets: Object.entries(ROUTE_PRESETS).map(([id, route]) => ({
         id,
         ...structuredClone(route),
+        providerCount: route.targets.length,
         added: Object.hasOwn(this.config.routes, id),
         availableProviders: [...new Set(route.targets.filter((t) => route.freeOnly ? this.config.accounts.some((a) => a.enabled !== false && a.provider === t.provider && this.freeModels(a).length) : matchModel(id, t, this.providerModels(t.provider))).map((t) => t.provider))]
       })),
@@ -1466,6 +1489,63 @@ var Manager = class {
   }
   async action(input) {
     if (!input || typeof input !== "object" || Array.isArray(input)) bad("\u8BF7\u6C42\u683C\u5F0F\u65E0\u6548");
+    if (input.action === "model.test") {
+      const model = this.providerModels(input.provider).find((m) => m.id === input.id);
+      if (!model) bad("\u8BF7\u5148\u5237\u65B0\u5E76\u9009\u62E9\u5DF2\u53D1\u73B0\u7684\u6A21\u578B");
+      if (this.modelTestFlight || Date.now() - (this.modelTestAt ?? 0) < 1e4) bad("\u8BF7\u7B49\u5F85\u5F53\u524D\u6D4B\u8BD5\u5B8C\u6210\uFF0C\u6D4B\u8BD5\u95F4\u9694\u81F3\u5C11 10 \u79D2");
+      this.modelTestFlight = true;
+      this.modelTestAt = Date.now();
+      this.modelTestAbort = new AbortController();
+      const started = performance.now();
+      let modelTest;
+      try {
+        const { response } = await this.router.chat(
+          {
+            model: `${input.provider}::${input.id}`,
+            stream: true,
+            messages: [{ role: "system", content: "Answer briefly." }, { role: "user", content: "Reply with OK." }],
+            max_tokens: 16
+          },
+          AbortSignal.any([this.modelTestAbort.signal, AbortSignal.timeout(45e3)])
+        );
+        const reader = response.body.getReader();
+        let size = 0, text = "";
+        const decoder = new TextDecoder();
+        try {
+          for (; ; ) {
+            const chunk = await reader.read();
+            if (chunk.done) break;
+            size += chunk.value.byteLength;
+            if (size > 1024 * 1024) throw Error("probe_response_too_large");
+            text += decoder.decode(chunk.value, { stream: true });
+          }
+          text += decoder.decode();
+          let answered = false;
+          for (const line of text.split(/\r?\n/).filter((l) => l.startsWith("data:"))) {
+            if (line.slice(5).trim() === "[DONE]") continue;
+            const payload = JSON.parse(line.slice(5));
+            if (payload.error || payload.choices?.some((c) => c.finish_reason === "error")) throw Error("probe_stream_failed");
+            answered ||= payload.choices?.some((c) => c.delta?.content || c.delta?.reasoning_content || c.delta?.tool_calls?.length) ?? false;
+          }
+          if (!answered || !/^data:\s*\[DONE\]\s*$/m.test(text)) throw Error("probe_incomplete");
+        } finally {
+          await reader.cancel().catch(() => {
+          });
+          reader.releaseLock();
+        }
+        modelTest = { ok: true, elapsedMs: Math.round(performance.now() - started) };
+      } catch (error) {
+        modelTest = {
+          ok: false,
+          status: Number(error.status) || 502,
+          hint: error.hint || "\u6D4B\u8BD5\u672A\u901A\u8FC7\uFF0C\u8BF7\u67E5\u770B\u8D26\u53F7\u72B6\u6001\uFF1B\u4E0D\u4F1A\u81EA\u52A8\u91CD\u8BD5\u3002"
+        };
+      } finally {
+        this.modelTestFlight = false;
+        this.modelTestAbort = void 0;
+      }
+      return { ...this.state(), modelTest };
+    }
     if (input.action?.startsWith("api.")) {
       let result;
       try {
@@ -1769,22 +1849,27 @@ var Manager = class {
           }
         } else if (input.action === "model.update") {
           if (!PROVIDERS.includes(input.provider) || typeof input.id !== "string" || !input.id || input.id.length > 256) bad("\u6A21\u578B\u65E0\u6548");
+          const model = this.providerModels(input.provider).find((m) => m.id === input.id);
+          if (input.contextWindow != null && (!Number.isSafeInteger(input.contextWindow) || input.contextWindow <= 0 || !model || input.contextWindow > model.maxContextWindow)) bad("\u4E0A\u4E0B\u6587\u9884\u7B97\u4E0D\u80FD\u8D85\u8FC7\u8BE5\u6E20\u9053\u6A21\u578B\u7684\u6700\u5927\u5BB9\u91CF");
+          if (input.supportsImages === true && !model?.imageCapable) bad("\u8BE5\u6A21\u578B\u672A\u58F0\u660E\u56FE\u7247\u8F93\u5165\u80FD\u529B");
+          if (input.reasoningEffort != null && !model?.reasoning?.supportedEfforts.includes(input.reasoningEffort)) bad("\u6B64\u6A21\u578B\u4E0D\u652F\u6301\u6240\u9009\u63A8\u7406\u7B49\u7EA7");
           raw.models = { ...raw.models, [input.provider]: {
             ...raw.models?.[input.provider],
             [input.id]: {
               ...raw.models?.[input.provider]?.[input.id],
-              ...input.name !== void 0 ? { name: input.name } : {},
-              ...input.visible !== void 0 ? { visible: input.visible } : {}
+              ...Object.fromEntries(["name", "visible", "contextWindow", "supportsImages", "reasoningEffort"].filter((k) => input[k] !== void 0).map((k) => [k, input[k]]))
             }
           } };
         } else if (input.action === "free.model.update") {
           const parent = raw.routes[input.parentId];
           if (!parent?.freeOnly || !this.freeRoutes(input.parentId, this.config.routes[input.parentId]).some((m) => m.id === input.id)) bad("\u514D\u8D39\u6A21\u578B\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u9875\u9762");
           const model = this.freeRoutes(input.parentId, this.config.routes[input.parentId]).find((m) => m.id === input.id);
+          if (input.contextWindow != null && (!Number.isSafeInteger(input.contextWindow) || input.contextWindow <= 0 || input.contextWindow > model.maxContextWindow)) bad("\u4E0A\u4E0B\u6587\u9884\u7B97\u4E0D\u80FD\u8D85\u8FC7\u8BE5\u514D\u8D39\u6A21\u578B\u7684\u6700\u5927\u5BB9\u91CF");
           if (input.reasoningEffort !== void 0 && input.reasoningEffort !== null && !model.reasoning?.supportedEfforts.includes(input.reasoningEffort)) bad("\u6B64\u514D\u8D39\u6A21\u578B\u4E0D\u652F\u6301\u6240\u9009\u63A8\u7406\u7B49\u7EA7");
           parent.freeModels = { ...parent.freeModels, [input.id]: {
             ...parent.freeModels?.[input.id],
             ...input.visible !== void 0 ? { visible: input.visible } : {},
+            ...input.contextWindow !== void 0 ? { contextWindow: input.contextWindow } : {},
             ...input.reasoningEffort !== void 0 ? { reasoningEffort: input.reasoningEffort } : {}
           } };
         } else if (input.action === "route.save") {
@@ -1804,6 +1889,7 @@ var Manager = class {
           if (["tokens", "credits"].includes(strategy)) await this.telemetry.advance(input.id, this.router.candidates(input.id), JSON.stringify({ strategy, targets: route.targets }));
         } else if (input.action === "route.remove") {
           if (!Object.hasOwn(raw.routes, input.id)) bad("\u8DEF\u7531\u4E0D\u5B58\u5728");
+          if (Object.hasOwn(ROUTE_PRESETS, input.id)) raw.seenRoutePresets = [.../* @__PURE__ */ new Set([...raw.seenRoutePresets ?? [], input.id])];
           delete raw.routes[input.id];
         } else if (input.action === "preset.add") {
           const id = input.id ?? "deepseek-v4.1-flash";
@@ -1941,4 +2027,4 @@ export {
   Manager,
   managementHandler
 };
-//# sourceMappingURL=chunk-OCMOMSB4.js.map
+//# sourceMappingURL=chunk-4EO5V6FW.js.map