dsh-connect-trae 4.5.0 → 4.5.2

package/CHANGELOG.md

@@ -1,5 +1,89 @@
 # Changelog
 
+## 4.5.2 (2026-10-25)
+
+> **思考档位不再被吞，也不再被谎报。** 插件原先只认识三档，未知档位一律按 `high`
+> 发出去——用户选 Max、实际收到 high，无报错也无日志。这一版把词表与 Trae 客户端
+> 对齐（`low / medium / high / extra_high / max`），并把「不认识的档位」从谎报改成
+> 丢弃，让上游用它自己的默认值。
+>
+> 词表变宽，**声称没变**：能选哪些档位仍然只取决于上游为该模型实际下发的
+> `options`，所以今天只发三档的模型不会凭空多出 Max。
+
+### 修复
+
+- **思考档位词表配平，未知档位不再静默降档成 high**（#60）。
+  - **三处吞档位**：解析侧 `EFFORT_MAP` / `TRAE_REASONING_EFFORTS` 缺 `medium` 与
+    `max`；`toPiModel` 的 `thinkingLevelMap` 把 `minimal / medium / max` 硬编码成
+    `null`；反向映射写成三元链
+    `effort === 'low' ? 'light' : effort === 'xhigh' ? 'extra_high' : 'high'`。
+  - **最坏的是第三处**：任何未预期档位都被映射成 `high` 发给上游。Trae 客户端自己
+    认识五档（`reasoning_effort.{low,medium,high,extra_high,max}`），并按 agent model
+    灰度下发，所以上游哪天发 `max`，用户选 Max 就会被静默降成 high。**静默降档比
+    不给选择器更坏**——它给出一个便宜了、但用户没要的答案。
+  - **改法**：反向映射抽成 `WIRE_EFFORT_MAP` 查表 + `wireEffortsOf()`，三处调用点
+    统一走它（报告人点到两处，第三处在 wire 行提升的分支里，一起改才不会有同一份
+    目录两种行为）。查不到即**丢弃**，而不是猜一个默认值。
+  - **实测**（2026-10-25，本机 CN 凭据，98 行目录）：当前 `options` 只有
+    `["light","high"]`、`["high","extra_high"]`、`["light","high","extra_high"]`
+    三种，`max` 尚未下发——所以这是「今天就备好、明天才用上」，不是伪造档位。
+  - 测试：新增 10 例（词表、丢弃未知档位、既有三档逐字不变、`discoveredCatalog`
+    同步、不伪造档位、`thinkingLevelMap` 按模型而非硬编码）。三处均做变异验证：
+    恢复旧映射 → 5 例红；恢复硬编码 `null` → 1 例红；去掉解析侧新键 → 1 例红。
+  - 贡献者：[@ahian-lee](https://github.com/ahian-lee)（issue #60，附诊断与补丁）。
+
+### 文档
+
+- **卡片模型栏写明「上下文预算只影响 DSH 侧」**（#60 的顺带问题）。
+  - 每行显示的是 Trae 自己公布的最大窗口，而下面的预算单选只写 DSH 的本地预算；
+    请求体里既没有窗口字段、也没有 `max_mode`，所以把预算提到 1M 并不会让上游按
+    1M 服务。原先的标签读起来像「已经放开到 1M」。
+  - 上游是否接受 `v2_max_mode_enabled` 这类字段**尚未取证**，所以这次不动请求体
+    （乱加字段可能让每次请求 400），只把事实说出来：常驻说明，不用悬停提示。
+
+## 4.5.1 (2026-10-25)
+
+> **只在租户池上架的模型不再隐形。** 插件的模型目录只问了 `solo.trae.cn` 一处，
+> 而它并不发布租户池的完整名单——`DeepSeek-V4.1-Flash-1017` 就在其中。这一版把
+> `console.enterprise.trae.cn` 的目录**并入**主目录，两个池的模型都保留。
+>
+> 成因不是合并层丢行，而是**读错了 host**：目录基址循环在第一个答非空的 host 就
+> `return`，而主目录总会答——所以只在租户池上架的模型，即便拿着租户凭据也永远看不到
+> （#46）。
+
+### 修复
+
+- **模型目录并入租户池，只在租户侧上架的模型不再隐形**（#46）。
+  - **实测**（2026-10-24，真实 CN 租户凭据）：`solo.trae.cn` 答 36 个 id、**没有**
+    `DeepSeek-V4.1-Flash-1017`；`console.enterprise.trae.cn` 答 24 个、**有**。
+    4.4.7 与 4.5.0 表现一致，所以升级修不了。
+  - **并集而非替换**：两侧没有一方包含另一方——主目录的 36 个里有 **19** 个不在租户
+    应答中，其中就包括 `deepseek-v4.1-flash`。换 host 等于用 1 个模型换掉 19 个。
+  - **也不能做成兜底候选**：基址循环在第一个答非空的 host 就返回，而主目录总会答，
+    候选恰好在唯一会出错的情形下被跳过。因此额外 host 单独读取后再并入
+    （`TraeSoloRemoteCatalogOptions.unionBaseUrls`）。
+  - **冲突保留主目录的拼写**，按不区分大小写比较。这里不能用 `preferStrongerRow`
+    打擂台：`deriveCatalog` 用 `enabled.has(model.id)` **精确匹配**，改名会让用户
+    已存进 `enabledModelIds` 的那一项静默失配、模型从选择里消失。
+  - **逐 host 尽力而为**：传输失败、非 2xx、响应体读不出、应答为空，都记日志后跳过，
+    只有调用方 abort 才向上抛。某个额外 host 坏掉，损失的是它的模型，而不是整份目录。
+  - **门控按凭据、不按面板**：只登录租户账号的机器，在 Trae（消费端）面板下
+    `store.resolve()` 依然会返回租户凭据（`offered()` 是「藏光了就回退」），所以按
+    面板判会漏掉这类用户。现在判「解析出的凭据 `tenantId` 非空」，个人凭据在发出请求
+    前就跳过。
+  - **`unionRegion` 挡住跨区域请求**：`DSH_TRAE_TENANT_IN_CONSUMER` 是环境变量、不分
+    区域，原先国际版面板也会挂上 CN 租户 host（用 SG 凭据实测确实发出、拿 401 后被
+    跳过）。现在区域不符即跳过。
+  - **额外 host 有负缓存**：`discoverModels()` 不传 signal、超时回落到 30 秒，原先企业
+    host 不可达时每次刷新都要多等。失败后与主 host 同款冷却 5 分钟。
+  - **它不是别名**：用插件自己的 bridge 驱动真实网关，两个 id 派往不同后端
+    （`DeepSeek-V4.1-Flash-1017` → `deepseek-v4.1-flash-economic-ark`，
+    `DeepSeek-V4.1-Flash` → `deepseek-v4.1-flash-ark`）。
+  - 测试：`tests/solo-remote.spec.ts` 新增 8 例，覆盖并集、仅大小写不同的冲突、
+    额外 host 不可达/被拒/应答为空、个人凭据跳过、跨区域跳过、冷却、已经是主 host 时
+    不重复请求，以及未配置 `unionBaseUrls` 时行为与改动前完全一致。
+  - 贡献者：[@yuantao313](https://github.com/yuantao313)（PR #59）。
+
 ## 4.5.0 (2026-10-24)
 
 > **宽窗模型多一个 500K 上下文中间档。** Trae 每个模型公布两个窗口——默认（dev）档和

package/lib/client.js

@@ -5659,6 +5659,7 @@ window.__ModuleLoader__.load({
 																	}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("fieldset", {
 																		className: "dsm-trae-context-budget",
 																		"aria-label": t("row.contextBudget"),
+																		title: t("row.contextBudgetHint"),
 																		children: contextBudgetOptions(model).map((option) => {
 																			const selectable = model.maxContextWindow !== void 0;
 																			const checked = (activeContextBudgets[model.id] ?? model.contextWindow) === option;
@@ -5726,6 +5727,10 @@ window.__ModuleLoader__.load({
 													})
 												]
 											}),
+											/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+												className: "dsm-trae-model-capability-note",
+												children: t("row.contextBudgetHint")
+											}),
 											/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 												className: "dsm-trae-model-capability-note",
 												children: t("row.modelCapabilityPending")
@@ -6898,6 +6903,7 @@ window.__ModuleLoader__.load({
 			"row.veilSaving": "Saving changes…",
 			"row.modelContext": "Max context {context}",
 			"row.contextBudget": "DSH context budget",
+			"row.contextBudgetHint": "Affects the DSH-side context budget only. The plugin does not send a window or Max-mode field upstream, so this does not change the window Trae serves the request with.",
 			"row.modelOutput": "Output {output}",
 			"row.modelImage": "Image",
 			"row.modelImageAuto": "Enabled automatically: Trae marks this model multimodal.",
@@ -7277,6 +7283,7 @@ window.__ModuleLoader__.load({
 			"row.veilSaving": "正在保存更改…",
 			"row.modelContext": "最大上下文 {context}",
 			"row.contextBudget": "DSH 上下文预算",
+			"row.contextBudgetHint": "只影响 DSH 侧的上下文预算。插件不会向上游发送窗口或 Max 模式字段，所以这不会改变 Trae 实际服务这次请求所用的窗口。",
 			"row.modelOutput": "最大输出 {output}",
 			"row.modelImage": "图片",
 			"row.modelImageAuto": "已自动开启：Trae 把该模型标为多模态。",

package/lib/index.d.ts

@@ -44,7 +44,23 @@ interface TraeActivityDiscount {
 }
 //#endregion
 //#region src/reasoning.d.ts
-declare const TRAE_REASONING_EFFORTS: readonly ["minimal", "low", "medium", "high", "xhigh"];
+/**
+ * The DSH thinking levels this plugin can carry, in ascending order.
+ *
+ * `max` is the fifth level Trae's own client advertises — its bundle ships the
+ * i18n keys `trae-chat-core.model.reasoning_effort.{low,medium,high,extra_high,max}`
+ * and `ai.model.reasoning_effort.{low,medium,high,xhigh,max}`, and publishes the
+ * per-model list from a remote config (`AI.agent.model.reasoning_effort_level_by_agent_model_v2`).
+ * Leaving it out of this list meant a level the vendor could start serving was
+ * filtered away at PARSE time, before anything downstream could decide (issue
+ * #60). Listing it does not fabricate the level: `supported` is still built
+ * only from what the upstream response actually contains, so a model that does
+ * not advertise `max` never offers it.
+ *
+ * `minimal` is kept for the same reason in reverse — it is a DSH level, so the
+ * type must be able to represent it even though no CN model has advertised it.
+ */
+declare const TRAE_REASONING_EFFORTS: readonly ["minimal", "low", "medium", "high", "xhigh", "max"];
 type TraeReasoningEffort = typeof TRAE_REASONING_EFFORTS[number];
 interface TraeReasoningCapability {
   supported: readonly TraeReasoningEffort[];
@@ -3486,6 +3502,51 @@ interface TraeSoloRemoteCatalogOptions {
    * of official-host-first.
    */
   log?: (message: string, detail?: unknown) => void;
+  /**
+   * Extra directory hosts whose rows are UNIONED into the primary answer.
+   *
+   * The base loop below stops at the FIRST host that answers non-empty. That is
+   * the right rule for a FALLBACK chain (one host, mirrored), but it cannot
+   * express "these hosts serve DIFFERENT pools" — and the primary host
+   * answering successfully is exactly the case where another host's models
+   * stay invisible. So these hosts are read SEPARATELY and merged, never added
+   * as another candidate base: a candidate is skipped precisely when the
+   * primary succeeds, which is always in the scenario that fails today.
+   *
+   * Measured 2026-10-24 on a live CN tenant credential:
+   * `solo.trae.cn` (the primary) answered 36 ids and does NOT list
+   * `DeepSeek-V4.1-Flash-1017`, while `console.enterprise.trae.cn` answered 24
+   * and DOES list it (issue #46). Neither host is a superset of the other: 19
+   * of the primary's ids are absent from the tenant answer, so REPLACING the
+   * primary would trade one missing model for nineteen — a union is the only
+   * shape that loses nothing.
+   *
+   * The primary answer wins every id collision, compared case-insensitively, and
+   * a colliding extra row is dropped rather than capacity-competed: a
+   * `preferStrongerRow` contest could rename a model the user has already saved
+   * in `enabledModelIds` (`deriveCatalog` matches those ids EXACTLY), silently
+   * dropping the model out of the selection.
+   *
+   * An extra host is asked ONLY when the credential being used can call that
+   * pool at all (`region` must match the host, and a tenant host additionally
+   * requires a tenant credential). The gate lives here rather than at the
+   * construction site because the deciding fact — "is this credential a tenant
+   * one?" — only exists once `credential()` has resolved, which is per refresh.
+   * Gating on the PANEL instead missed the case that matters: a consumer store
+   * does not hard-exclude tenant accounts (`auth.ts`'s `offered()` backs off
+   * when its filter would hide everything), so a machine whose only login is a
+   * tenant account resolves a tenant credential under the Trae panel too.
+   */
+  unionBaseUrls?: readonly string[];
+  /**
+   * Region an extra host serves. An `ai` credential never asks a `cn` host.
+   *
+   * `unionBaseUrls` used to be ungated by region, so a `DSH_TRAE_TENANT_IN_CONSUMER`
+   * machine on the international panel issued the CN tenant request on every
+   * refresh — a 401 the union skipped, but one wasted request and one warn log
+   * per refresh (measured with an SG credential 2026-10-24).
+   */
+  unionRegion?: TraeRegion;
 }
 /**
  * Read-only model catalog client for the SOLO Web API.
@@ -3526,9 +3587,42 @@ declare class TraeSoloRemoteCatalogClient {
    * (30 s) in the worst case, so 5 minutes bounds that to ~1 attempt per 5 min.
    */
   private static readonly OFFICIAL_RETRY_MS;
+  /**
+   * When each extra union host may be asked again after it failed, as epoch
+   * milliseconds. Absent = ask it on the next refresh.
+   *
+   * The official host has {@link OFFICIAL_RETRY_MS} because a blocked network
+   * would otherwise pay its failing connect on every refresh; an extra host has
+   * the same problem and, since discovery (`discoverModels()`) passes no signal,
+   * the same 30 s ceiling. A tenant host that is unreachable from this network
+   * would therefore stall every refresh for up to 30 s. Same cooldown, same
+   * reasoning — an unhelpful host is skipped for a while instead of retried
+   * immediately.
+   */
+  private readonly extraRetryAtMs;
+  private readonly unionBaseUrls;
+  private readonly unionRegion;
   constructor(options: TraeSoloRemoteCatalogOptions);
   private headers;
   fetchModels(signal?: AbortSignal): Promise<TraeDiscoveredModel[]>;
+  /**
+   * Union the extra directory hosts' rows into the primary answer (issue #46).
+   *
+   * The base loop above returns on the FIRST host that answers non-empty, which
+   * is correct for a FALLBACK chain but cannot express "these hosts serve
+   * different pools" — the primary host answering is exactly the case where the
+   * extra host's models would stay invisible forever. Hence a separate read and
+   * a merge, not another candidate base (see `unionBaseUrls`).
+   *
+   * Every extra host is BEST-EFFORT: transport failure, non-2xx, an unreadable
+   * body and an empty answer are each logged and skipped. Only an aborted
+   * `signal` propagates — that is the caller cancelling, not a host being
+   * unhelpful. Failing here must never fail a refresh the primary host already
+   * satisfied, which is why a broken extra host costs models, not the catalog.
+   * A failure also puts that host on {@link extraRetryAtMs} so a network that
+   * cannot reach it stops paying its connect timeout on every refresh.
+   */
+  private unionWithExtraHosts;
   /**
    * Bases to try for one refresh, in order.
    *

package/lib/index.js

@@ -282,6 +282,53 @@ function displayKey(name) {
 	return name.trim().toLowerCase();
 }
 /**
+* DSH thinking level -> the `reasoning_effort` name Trae's wire accepts.
+*
+* The INVERSE of `EFFORT_MAP` in `model-metadata.ts`, and it must stay an exact
+* mirror of it: a level this table does not name has no wire spelling, so it is
+* DROPPED rather than guessed (issue #60).
+*
+* The previous form was a ternary chain ending in a bare `'high'`:
+*
+*     effort === 'low' ? 'light' : effort === 'xhigh' ? 'extra_high' : 'high'
+*
+* so EVERY unnamed level was sent as `high`. That is not a harmless default: it
+* is a silent downgrade. Trae's own vocabulary carries five levels
+* (`low / medium / high / extra_high / max`, verified in the client bundle's
+* `reasoning_effort` i18n keys), and its remote config publishes the list per
+* model (`AI.agent.model.reasoning_effort_level_by_agent_model_v2`). The day
+* upstream starts advertising `max`, a user picking Max would have sent `high`
+* — no error, no log, and a cheaper answer than the one they asked for. A
+* dropped field lets the upstream apply its own default, which is at least the
+* model's real behaviour instead of a wrong claim about it.
+*
+* Measured 2026-10-25 on a live CN credential (98 directory rows): options are
+* `["light","high"]`, `["high","extra_high"]`, `["light","high","extra_high"]`
+* or absent — `max` is not published YET, which is exactly why this must not
+* wait for it to be.
+*/
+const WIRE_EFFORT_MAP = {
+	low: "light",
+	medium: "medium",
+	high: "high",
+	xhigh: "extra_high",
+	max: "max"
+};
+/**
+* Map a model's advertised levels to their wire names, dropping unnamed ones.
+*
+* `flatMap` rather than `map` + a placeholder: an unmappable level must not
+* produce an entry at all, because every consumer reads "is there a value here"
+* as "may this level be sent" (see `thinkingLevelMap` in `adapter.ts` and the
+* `delete input['reasoning_effort']` fallback in `solo-bridge.ts`).
+*/
+function wireEffortsOf(supported) {
+	return Object.fromEntries(supported.flatMap((effort) => {
+		const wire = WIRE_EFFORT_MAP[effort];
+		return wire === void 0 ? [] : [[effort, wire]];
+	}));
+}
+/**
 * Merge the two Trae model sources into one authoritative catalog.
 *
 * `remote` (the solo.trae.cn `/models` directory) is the authoritative model
@@ -360,7 +407,7 @@ function mergeTraeModelSources(remote, wire) {
 			reasoningSupported: model.reasoningSupported,
 			...model.reasoning === void 0 ? {} : {
 				reasoning: model.reasoning,
-				reasoningEfforts: Object.fromEntries(model.reasoning.supported.map((effort) => [effort, effort === "low" ? "light" : effort === "xhigh" ? "extra_high" : "high"]))
+				reasoningEfforts: wireEffortsOf(model.reasoning.supported)
 			},
 			...wireModel !== void 0 && wireModel.id !== "" && wireModel.id !== model.id ? { wireConfigName: wireModel.id } : {},
 			...wireFunction === void 0 ? {} : { wireFunction }
@@ -433,7 +480,7 @@ function mergeTraeModelSources(remote, wire) {
 					supported: [...wireModel.reasoning.supported],
 					...wireModel.reasoning.defaultEffort === void 0 ? {} : { defaultEffort: wireModel.reasoning.defaultEffort }
 				},
-				reasoningEfforts: Object.fromEntries(wireModel.reasoning.supported.map((effort) => [effort, effort === "low" ? "light" : effort === "xhigh" ? "extra_high" : "high"]))
+				reasoningEfforts: wireEffortsOf(wireModel.reasoning.supported)
 			},
 			...wireModel.function === void 0 ? {} : { wireFunction: wireModel.function }
 		});
@@ -507,7 +554,7 @@ function discoveredCatalog(models) {
 		reasoningSupported: model.reasoningSupported,
 		...model.reasoning === void 0 ? {} : {
 			reasoning: model.reasoning,
-			reasoningEfforts: Object.fromEntries(model.reasoning.supported.map((effort) => [effort, effort === "low" ? "light" : effort === "xhigh" ? "extra_high" : "high"]))
+			reasoningEfforts: wireEffortsOf(model.reasoning.supported)
 		}
 	});
 	return result;
@@ -836,14 +883,28 @@ function toPiModel(info, baseUrl, providerId, withRate = true) {
 			cacheWrite: 0
 		},
 		reasoning: info.reasoningEfforts !== void 0,
-		...info.reasoningEfforts === void 0 ? {} : { thinkingLevelMap: {
+		...info.reasoningEfforts === void 0 ? {} : { 
+		/**
+		* Which DSH levels this model may be asked for, and under which wire name.
+		*
+		* Every level is read from the model's OWN advertised capability, never
+		* hardcoded. `minimal / medium / max` used to be pinned to `null`, so a
+		* level the upstream published could not be selected even after it was
+		* parsed — the second of the three places issue #60 reported. `null`
+		* still means "not offered", which is what a model that does not
+		* advertise the level reports: nothing here fabricates a level.
+		*
+		* `off` stays `null` deliberately: Trae's wire has no "no reasoning"
+		* spelling, so an explicit off is not something this provider can send.
+		*/
+thinkingLevelMap: {
 			off: null,
-			minimal: null,
+			minimal: info.reasoningEfforts.minimal ?? null,
 			low: info.reasoningEfforts.low ?? null,
-			medium: null,
+			medium: info.reasoningEfforts.medium ?? null,
 			high: info.reasoningEfforts.high ?? null,
 			xhigh: info.reasoningEfforts.xhigh ?? null,
-			max: null
+			max: info.reasoningEfforts.max ?? null
 		} },
 		...info.contextWindow === void 0 ? {} : { contextWindow: info.contextWindow },
 		...info.maxTokens === void 0 ? {} : { maxTokens: info.maxTokens },
@@ -4752,12 +4813,29 @@ function parseTraeActivityDiscount(value) {
 }
 //#endregion
 //#region src/reasoning.ts
+/**
+* The DSH thinking levels this plugin can carry, in ascending order.
+*
+* `max` is the fifth level Trae's own client advertises — its bundle ships the
+* i18n keys `trae-chat-core.model.reasoning_effort.{low,medium,high,extra_high,max}`
+* and `ai.model.reasoning_effort.{low,medium,high,xhigh,max}`, and publishes the
+* per-model list from a remote config (`AI.agent.model.reasoning_effort_level_by_agent_model_v2`).
+* Leaving it out of this list meant a level the vendor could start serving was
+* filtered away at PARSE time, before anything downstream could decide (issue
+* #60). Listing it does not fabricate the level: `supported` is still built
+* only from what the upstream response actually contains, so a model that does
+* not advertise `max` never offers it.
+*
+* `minimal` is kept for the same reason in reverse — it is a DSH level, so the
+* type must be able to represent it even though no CN model has advertised it.
+*/
 const TRAE_REASONING_EFFORTS = [
 	"minimal",
 	"low",
 	"medium",
 	"high",
-	"xhigh"
+	"xhigh",
+	"max"
 ];
 function parseReasoningCapability(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
@@ -5863,10 +5941,31 @@ function parseFeatures(value) {
 		return;
 	}
 }
+/**
+* Trae's wire effort name -> the DSH thinking level.
+*
+* The FORWARD half of the mapping; `WIRE_EFFORT_MAP` in `catalog.ts` is its
+* exact inverse. Both halves must name the same levels, or a level survives one
+* direction and vanishes in the other.
+*
+* `medium` and `max` are here because Trae's own client advertises them
+* (`reasoning_effort.{low,medium,high,extra_high,max}` in its i18n bundle) and
+* publishes the per-model list remotely — so the day upstream starts sending
+* either, the parser must not filter it away before anything can use it (issue
+* #60). Measured 2026-10-25 on a live CN credential, the published options were
+* only `light / high / extra_high`; these entries are therefore inert today and
+* ready tomorrow, not a claim that the levels are served now.
+*
+* An unknown name is deliberately ABSENT rather than defaulted: `parse` drops
+* it, and the reverse map drops it too, so an unrecognised level can never be
+* reported to the user or sent upstream under a name the vendor never said.
+*/
 const EFFORT_MAP = {
 	light: "low",
+	medium: "medium",
 	high: "high",
-	extra_high: "xhigh"
+	extra_high: "xhigh",
+	max: "max"
 };
 /**
 * Parse only capabilities explicitly advertised by Trae's remote model API.
@@ -6025,6 +6124,17 @@ function traeSoloRemoteFallbackBases(region, officialBase) {
 	return backupBase === officialBase ? [] : [backupBase];
 }
 /**
+* Case-folded identity for a directory id.
+*
+* A local copy of `catalog.ts`'s private `displayKey`: the two hosts of the
+* union spell the same model differently (they disagree on at least 3 ids), and
+* ids that differ only by case MUST be treated as the same model — otherwise a
+* union would list one model twice under two spellings.
+*/
+function directoryKey(id) {
+	return id.trim().toLowerCase();
+}
+/**
 * Of two rows for the SAME model id, the one the catalog should keep.
 *
 * The gateway groups its directory by function and reports a model's capacity
@@ -6163,10 +6273,27 @@ var TraeSoloRemoteCatalogClient = class TraeSoloRemoteCatalogClient {
 	* (30 s) in the worst case, so 5 minutes bounds that to ~1 attempt per 5 min.
 	*/
 	static OFFICIAL_RETRY_MS = 3e5;
+	/**
+	* When each extra union host may be asked again after it failed, as epoch
+	* milliseconds. Absent = ask it on the next refresh.
+	*
+	* The official host has {@link OFFICIAL_RETRY_MS} because a blocked network
+	* would otherwise pay its failing connect on every refresh; an extra host has
+	* the same problem and, since discovery (`discoverModels()`) passes no signal,
+	* the same 30 s ceiling. A tenant host that is unreachable from this network
+	* would therefore stall every refresh for up to 30 s. Same cooldown, same
+	* reasoning — an unhelpful host is skipped for a while instead of retried
+	* immediately.
+	*/
+	extraRetryAtMs = /* @__PURE__ */ new Map();
+	unionBaseUrls;
+	unionRegion;
 	constructor(options) {
 		this.options = options;
 		this.fetchImpl = options.fetchImpl ?? fetch;
 		this.baseUrl = options.baseUrl;
+		this.unionBaseUrls = options.unionBaseUrls ?? [];
+		this.unionRegion = options.unionRegion;
 	}
 	async headers(region) {
 		const credential = await this.options.credential();
@@ -6182,7 +6309,8 @@ var TraeSoloRemoteCatalogClient = class TraeSoloRemoteCatalogClient {
 		};
 	}
 	async fetchModels(signal) {
-		const region = regionOfCredential(await this.options.credential());
+		const credential = await this.options.credential();
+		const region = regionOfCredential(credential);
 		const officialBase = this.baseUrl ?? REGION_GATEWAYS[region].remote;
 		const headers = await this.headers(region);
 		const functions = TRAE_REMOTE_DIRECTORY_FUNCTIONS[region].join(",");
@@ -6217,12 +6345,88 @@ var TraeSoloRemoteCatalogClient = class TraeSoloRemoteCatalogClient {
 			if (base !== officialBase) this.options.log?.(this.lastSuccessfulBase === base ? `model directory served by the remembered fallback host ${base}; the official host (${officialBase}) is re-probed every ${TraeSoloRemoteCatalogClient.OFFICIAL_RETRY_MS / 6e4} minutes` : `model directory served by fallback host ${base}; the official host (${officialBase}) failed this refresh`, { officialBase });
 			else this.officialRetryAtMs = 0;
 			this.lastSuccessfulBase = base;
-			return models;
+			return await this.unionWithExtraHosts(region, credential, headers, models, signal);
 		}
 		if (emptyError !== void 0) throw emptyError;
 		throw lastError instanceof Error ? lastError : new Error(String(lastError));
 	}
 	/**
+	* Union the extra directory hosts' rows into the primary answer (issue #46).
+	*
+	* The base loop above returns on the FIRST host that answers non-empty, which
+	* is correct for a FALLBACK chain but cannot express "these hosts serve
+	* different pools" — the primary host answering is exactly the case where the
+	* extra host's models would stay invisible forever. Hence a separate read and
+	* a merge, not another candidate base (see `unionBaseUrls`).
+	*
+	* Every extra host is BEST-EFFORT: transport failure, non-2xx, an unreadable
+	* body and an empty answer are each logged and skipped. Only an aborted
+	* `signal` propagates — that is the caller cancelling, not a host being
+	* unhelpful. Failing here must never fail a refresh the primary host already
+	* satisfied, which is why a broken extra host costs models, not the catalog.
+	* A failure also puts that host on {@link extraRetryAtMs} so a network that
+	* cannot reach it stops paying its connect timeout on every refresh.
+	*/
+	async unionWithExtraHosts(region, credential, headers, primary, signal) {
+		if (this.unionBaseUrls.length === 0) return primary;
+		if (this.unionRegion !== void 0 && this.unionRegion !== region) return primary;
+		if (!isEnterpriseAccount(credential)) return primary;
+		const functions = TRAE_REMOTE_DIRECTORY_FUNCTIONS[region].join(",");
+		const byKey = /* @__PURE__ */ new Map();
+		for (const model of primary) byKey.set(directoryKey(model.id), model);
+		for (const base of this.unionBaseUrls) {
+			if (base === this.lastSuccessfulBase) continue;
+			if ((this.extraRetryAtMs.get(base) ?? 0) > Date.now()) continue;
+			let response;
+			try {
+				response = await this.fetchImpl(`${base}/models?functions=${functions}`, {
+					headers,
+					signal: signal ?? AbortSignal.timeout(3e4)
+				});
+			} catch (error) {
+				if (signal?.aborted) throw error;
+				this.extraRetryAtMs.set(base, Date.now() + TraeSoloRemoteCatalogClient.OFFICIAL_RETRY_MS);
+				this.options.log?.(`model directory union host ${base} was unreachable; its models are missing from this refresh`, {
+					base,
+					error: String(error)
+				});
+				continue;
+			}
+			if (!response.ok) {
+				this.extraRetryAtMs.set(base, Date.now() + TraeSoloRemoteCatalogClient.OFFICIAL_RETRY_MS);
+				this.options.log?.(`model directory union host ${base} answered HTTP ${response.status}; its models are missing from this refresh`, { base });
+				continue;
+			}
+			let extra;
+			try {
+				const json = await response.json();
+				extra = this.collectModels(region, json.data?.list ?? []);
+			} catch (error) {
+				this.extraRetryAtMs.set(base, Date.now() + TraeSoloRemoteCatalogClient.OFFICIAL_RETRY_MS);
+				this.options.log?.(`model directory union host ${base} answered a body that could not be read; its models are missing from this refresh`, {
+					base,
+					error: String(error)
+				});
+				continue;
+			}
+			this.extraRetryAtMs.delete(base);
+			let added = 0;
+			for (const model of extra) {
+				const key = directoryKey(model.id);
+				if (byKey.has(key)) continue;
+				byKey.set(key, model);
+				added += 1;
+			}
+			const collided = extra.length - added;
+			this.options.log?.(`model directory union host ${base} contributed ${added} model(s) the primary directory did not list${collided > 0 ? ` (${collided} collided and kept the primary spelling)` : ""}`, {
+				base,
+				served: extra.length,
+				added
+			});
+		}
+		return [...byKey.values()];
+	}
+	/**
 	* Bases to try for one refresh, in order.
 	*
 	* While the official host is in its post-failure cooldown the backup hosts go
@@ -10030,7 +10234,57 @@ function apply(ctx, config) {
 		});
 		const remoteCatalog = new TraeSoloRemoteCatalogClient({
 			credential: () => store.resolve(),
-			log: (message, detail) => ctx.logger.warn(message, detail)
+			log: (message, detail) => ctx.logger.warn(message, detail),
+			/**
+			* The TENANT directory, UNIONED into the consumer one (issue #46).
+			*
+			* This is the "reads both pools" half of the routing note below, which
+			* was intent without an implementation: only the consumer host was ever
+			* asked. The `Solo` client above is routed, but THIS one is not — and
+			* `solo.trae.cn`, the primary it lands on, does not publish every model a
+			* tenant credential can call.
+			*
+			* Measured 2026-10-24 on the reporter's live CN tenant credential:
+			* `solo.trae.cn` answered 36 ids with no `DeepSeek-V4.1-Flash-1017`;
+			* `console.enterprise.trae.cn` answered 24 that include it, and the
+			* gateway really dispatching a distinct backend for it
+			* (`deepseek-v4.1-flash-economic-ark`, vs `deepseek-v4.1-flash-ark` for
+			* the plain id) is how issue #46's report was confirmed.
+			*
+			* UNION, never replace, and never a fallback candidate. The primary is
+			* the richer host — 19 of its ids are absent from the tenant answer,
+			* including the `deepseek-v4.1-flash` the reporter has saved — so
+			* replacing it would trade one missing model for nineteen. And a
+			* candidate base cannot work at all: the base loop returns on the first
+			* host that answers, and the primary always answers.
+			*
+			* Gated on a tenant pool being bindable here (an enterprise panel, or a
+			* consumer panel under `DSH_TRAE_TENANT_IN_CONSUMER`). A personal
+			* consumer account has nothing to gain from the tenant host, so it is not
+			* made to pay the extra request.
+			*
+			* The fix is not about 1017 specifically: the tenant host is a second
+			* pool, and every model it alone serves was invisible for the same
+			* reason. Verified against the live hosts: 0 rows lost, 0 duplicated.
+			*
+			* The client decides WHEN to ask it, not this construction site: the
+			* deciding fact is whether the credential being resolved is a tenant one,
+			* which does not exist until `credential()` runs. Gating on the panel here
+			* missed the reporters most likely to hit #46 in the first place — a
+			* consumer store does not hard-exclude tenant accounts (`auth.ts`'s
+			* `offered()` backs off when the filter would hide everything), so a
+			* machine whose only login is a tenant account resolves one under the
+			* Trae panel too, and an enterprise-panel-only gate never opened the
+			* union for it. `unionRegion` additionally keeps an `ai` credential from
+			* asking a `cn` host, which the old `DSH_TRAE_TENANT_IN_CONSUMER` gate on
+			* its own did not.
+			*
+			* Providing the host unconditionally is therefore safe: a personal
+			* credential and an `ai` credential both skip it before any request is
+			* made, so neither pays for a pool it cannot use.
+			*/
+			unionBaseUrls: [`${TRAE_ENTERPRISE_HOST}/api/remote/v1`],
+			unionRegion: "cn"
 		});
 		/**
 		* The IDE's own roster: which models the vendor's picker shows, per
@@ -10059,7 +10313,10 @@ function apply(ctx, config) {
 		* gateway and stamps the `session_id` it requires. The discovery client
 		* below stays UNROUTED on purpose — it owns the roster/probe path and, for
 		* a tenant credential, reads both pools so the shared catalogue keeps every
-		* model either one serves.
+		* model either one serves. That second pool is supplied by `unionBaseUrls`
+		* at the catalog client above, which is what makes this paragraph true;
+		* routing THIS client instead would have read one pool and dropped the
+		* other (see the note there, and issue #46).
 		*/
 		/**
 		* Latest successful discovery for this panel, mutated by discoverModels

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-connect-trae",
   "displayName": "DSH Connect Trae",
   "description": "把本机登录的 Trae 模型接入 DeepSeek Harness：国内版与国际版双供应商并行，提供用量/积分概览与每日签到领取。",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "author": "dingminhua",
   "copyright": "Copyright (c) 2026 LaoDing",
   "license": "MIT",