dsh-connect-trae 2.4.0 → 2.5.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 2.5.0 (2026-10-01)
+
+> **国际版（AI 区域）三条用户可见故障的修复**，全部来自 [issue #19](https://github.com/dingminhua/dsh-connect-trae/issues/19) 的报告与
+> 在真实 SG 凭据上的逐条实测（取证过程见 `docs/ISSUE19_DIAGNOSIS.md`，档位接口探索见 `docs/INTL_PAID_TIER_PROBE.md`）。
+
+### Features
+
+- **国际版模型目录改为读取全部组并集——此前只读 `solo_agent_remote` 一个组，另外 9 个模型从未出现**（issue #19 症状一）：
+  - Trae 的 remote `/models` 答复**按 function 分组**，且组间不是互替关系：实测 `solo_agent` 组 19 个模型、`solo_agent_remote` 组 10 个。旧代码请求 `solo_agent_remote,solo_work_remote` 后**只遍历 preferred 一个组**，报告人 Trae IDE 里能看到、插件里却没有的 `GPT-6-Astra`、`GPT-5.6-Sol/Terra/Luna`、`GPT-5.5`、`GLM-5.2` 等**恰好全部在没读的 `solo_agent` 组里**。
+  - 现在 `TRAE_REMOTE_DIRECTORY_FUNCTIONS` 按区域声明要请求的组（AI 区域三个全取），**每个返回的组都并入目录**，同一模型先出现者胜、只发一次。请求一个网关不认识的组是无害的（未知组名被忽略而非拒绝）。
+  - **发现面变宽，调用面反而收窄**：目录 union 让模型「可见」，但模型**只能通过列出它的那个 function 调用**。实测 `get_detail_param` 对 `solo_agent` 有求必应地返回 43 条，而 `llm_utils_chat` 对**所有**以 `function: "solo_agent"` 发出的模型一律回 `code 4011`——所以 wire 函数表 `TRAE_DIRECTORY_FUNCTIONS.ai` 从 `['solo_agent','solo_work_remote','solo_work_lite']` 改为 `['solo_work_remote','solo_work_lite','solo_agent_remote']`：让目录可见的新模型仍通过真正可调用的 function 去调，`solo_agent_remote` 放最后，使两个 function 都列出的模型保持无 Remote 门禁的 IDE function。CN 区域未重新测量，维持原列表不变（union 会保留网关返回的任何组）。
+
+### Bug Fixes
+
+- **国际版订阅状态显示错误——Pro 会员被显示为「暂无有效套餐」**（issue #19 症状二）：
+  - 卡片的判据只有 `has_package`，但那个字段回答的是「是否存在套餐权益对象」，不是「账号处于什么档位」——付费会员可以持有档位而没有套餐行，报告人的账号正是如此。
+  - Trae 同时返回的**权威档位字段** `user_pay_identity` / `user_pay_identity_str`（实测免费账号为 `0` / `"Free"`）此前在插件源码里**零引用**，被直接丢弃。
+  - 现在 `payStatus()` 完整保留两个档位字段（缺失时省略，不伪造），卡片判定改为 `has_package ∪ 档位非 Free`，并把档位名渲染进套餐行：「已有有效套餐 · Pro」/「暂无有效套餐 · Free」——免费用户看到**为什么**没有套餐，而不是只看到一个布尔。
+  - **只有精确的 `Free`（大小写不敏感）算免费**：未知或未来的档位名按付费处理。把付费会员错标成免费，比把免费账号显示成未知档位，是伤害更大的那个错误。
+- **订阅门禁错误被吞成「Stream ended without finish_reason」**（issue #19 症状三）：
+  - **现象**：免费/低档位账号选中需订阅的模型（如 `GPT-6-Sol`），得到的是一句像网络故障的报错，且会被重试多次。Trae 实际返回的是 **HTTP 200** + `event:error {"code":1005,"extra":"{\"plan\":N}"}`（`extra` 是 wire 上的 JSON **字符串**，订阅门禁只体现在 `extra.plan`）。
+  - **根因**：旧实现把上游答复原样以 200 转发，中途 `controller.error()` 截断流——HTTP 头已按 200 发出，`code 1005` 与 `plan` 在 HTTP 边界处丢失，pi-ai 只看到「流没给 finish_reason 就断了」，按传输故障处理。
+  - **修法**：`bridgeTraeSoloStreamOrFail` 在转发前**窥探流头**——任何输出开始之前的拒绝被翻译成真实的错误结果：`1005` → `402 hard_credit`（携带 plan 与「需要付费档」的文案，`hard_credit` 是让客户端停止而非重试的语义，402 是如实的状态码），`4011` / `4001` / 未知码 → `400 client`。code、plan、以及 Trae 那句与 code 相矛盾的原文（如 4011 自称"rate limit"）**全部保留在 message 里**。
+  - 输出已开始后到来的拒绝（拒绝打断正在进行的回答）：流以翻译后的可读错误终止，而不是裸截断。
+  - **窥探不伤健康流**：被窥探消费的头部字节逐字节重放；队列/进度/输出等任何 Trae 自有事件即触发直通，缓冲不超过首个事件。排队事件、分片工具调用等既有行为不变。
+  - **顺带登记两个此前不认识的错误码**（`grep` 证实源码与测试均零命中）：`1005` = 订阅门禁（档位不够，`extra.plan` 指明所需档位）；`4011` = 该 function 不提供此模型（其自报文案声称 rate limit，具有误导性）。已知的 `4001` = `config_name` 不被该 function 接受，语义不变。
+
+### Tests
+
+- **全仓 373 → 392（+19），含 5 次变异验证全部被抓**：
+  - `tests/solo-bridge.spec.ts` **+11**：`describeTraeFailure` 文案 5 例（1005 带 plan、4011 用 hint 而把误导原文降级为 detail、未知码回退、无 code 事件不虚构后缀、已解包的 extra 对象也能读 plan）；`bridgeTraeSoloStreamOrFail` 策略 5 例（1005→402 `hard_credit`、4011→400 `client`、无名事件经错误码带识别、健康流含排队事件直通且头部重放逐字节不丢、输出先行后拒绝的流中场景以可读 message 终止）；`TraeSoloBridge` 端到端 1 例（完整链路上订阅门禁成为错误结果而非被截断的 200 流）。其中「流中拒绝」用分块流构造：单块 body 会被窥探一起解码，无法测到该路径。
+  - `tests/card-subscription.spec.tsx` **新文件 5 例**：渲染真实卡片断言档位行——Pro 从档位单独判定、无档位时套餐行仍工作、Free 命名而非只报布尔、试用窗口优先于档位文案，及 `traePlanIsPaid` 判据表（只有精确 Free 算免费，未知档位按付费）。一例说明：无档位字符串时 badge 与 value 渲染同一裸标签，`getByText` 会命中多个元素，须用 `getAllByText`——这例测试在上一会话中断前正以多元素匹配失败，本次接续修复。
+  - `tests/usage.spec.ts` **+2**：档位字段与 `has_package` 分开保留；上游不带档位时省略而非伪造。
+  - `tests/solo-remote.spec.ts` **+1**、`tests/solo.spec.ts` 改写既有断言：目录 union 行为、AI 区域 function 顺序（`solo_agent` 必须绝迹）。
+  - **变异验证**（确认测试有约束力，5 次全部被抓）：① 分类忽略 1005 → 2 例失败；② plan 提取禁用 → 4 例失败；③ 窥探失效（打回旧行为，即本次要修的 bug）→ 4 例失败；④ 档位恒判免费 → 2 例失败；⑤ union 退回单组 → 3 例失败。恢复后 45 文件 392 例全绿。
+
+### Docs
+
+- `docs/ISSUE19_DIAGNOSIS.md`（随 2.4.0 后的 `009d9a7` 提交）：三个症状的完整取证——remote 目录两组的差集与报告人 IDE 的模型逐一吻合、`user_pay_identity_str` 零引用的 grep 证据、以真实上游字节喂给 bridge 复现「截断的 200」。
+- `docs/INTL_PAID_TIER_PROBE.md`（`d76800d`）：付费账号是否有专属接口的探索结论——**没有**，免费/付费同端点同目录，差别在调用时授权；含 `1005` / `4011` 的对照实验记录。
+
 ## 2.4.0 (2026-09-29)
 
 > **包含仍未发布的 2.3.2。** 2.3.2 的 peer 范围修复（`>=0.1.7-rc.1 <0.2.0-0` → `<0.3.0-0`，见下一节）

package/lib/client.js

@@ -140,6 +140,21 @@ window.__ModuleLoader__.load({
 				enabled
 			});
 		}
+		/**
+		* Whether Trae's plan identity says this account is on a paying plan.
+		*
+		* `has_package` alone is NOT that question — it reports whether a package
+		* entitlement row exists, and a member can be on a plan without one (issue
+		* #19: a Pro account rendered as "No active package"). Trae spells the plan in
+		* `user_pay_identity_str`, so this reads that field, and only the exact word
+		* `Free` counts as free: an unknown or future tier name is treated as paid,
+		* because claiming "Free" for a tier we simply do not recognise is the more
+		* damaging of the two errors.
+		*/
+		function traePlanIsPaid(payIdentityStr) {
+			const tier = payIdentityStr?.trim();
+			return tier !== void 0 && tier !== "" && !/^free$/i.test(tier);
+		}
 		//#endregion
 		//#region src/client/icon.ts
 		/**
@@ -355,6 +370,24 @@ window.__ModuleLoader__.load({
 			if (value >= 1e3 && value % 1e3 === 0) return `${value / 1e3}K`;
 			return formatNumber(value);
 		}
+		/**
+		* The subscription row's verdict.
+		*
+		* Two independent things can entitle an international account: a package row
+		* (`has_package`) and a plan identity (`user_pay_identity_str`). Reading only
+		* the first is what rendered a Pro member as "No active package" in issue #19,
+		* so either one counts. The tier string is carried separately so the row can
+		* name the plan instead of just asserting a boolean.
+		*/
+		function payVerdict(payStatus) {
+			const tier = payStatus.payIdentityStr?.trim();
+			const paid = payStatus.hasPackage || traePlanIsPaid(payStatus.payIdentityStr);
+			return {
+				paid,
+				...tier === void 0 || tier === "" ? {} : { tier },
+				label: paid ? "row.subscribed" : "row.noPackage"
+			};
+		}
 		function dotStyle(status) {
 			return { background: status === "signed-in" ? "var(--dsw-alias-state-success-primary, #22a06b)" : status === "error" ? "var(--dsw-alias-state-error-primary, #d92d20)" : "var(--dsw-alias-label-dimmed, #9aa0a6)" };
 		}
@@ -680,6 +713,8 @@ window.__ModuleLoader__.load({
 			* message — it never sends one by itself.
 			*/
 			const rowImageIsAutomatic = (model) => model.multimodal === true;
+			/** The subscription row's verdict for the current account, when it has one. */
+			const payPlan = status.status === "signed-in" && status.payStatus !== void 0 ? payVerdict(status.payStatus) : void 0;
 			const activeContextBudgets = draft?.contextBudgets ?? savedContextBudgets;
 			const dirty = draft !== void 0;
 			/** Apply an edit to the ACTIVE tab's draft, seeding it from the current view. */
@@ -905,7 +940,7 @@ window.__ModuleLoader__.load({
 								})
 							}) : null,
 							status.status === "signed-in" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
-								status.payStatus === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								status.payStatus === void 0 || payPlan === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 									className: "dsm-trae-usage-list",
 									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 										className: "dsm-trae-usage-stats dsm-trae-usage-stats-two",
@@ -918,13 +953,13 @@ window.__ModuleLoader__.load({
 														className: "dsm-trae-usage-stat-label",
 														children: t("row.subscriptionLabel")
 													}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-														className: `dsm-trae-usage-stat-badge ${status.payStatus.hasPackage ? "dsm-trae-usage-stat-badge-on" : "dsm-trae-usage-stat-badge-off"}`,
-														children: t(status.payStatus.hasPackage ? "row.subscribed" : "row.noPackage")
+														className: `dsm-trae-usage-stat-badge ${payPlan.paid ? "dsm-trae-usage-stat-badge-on" : "dsm-trae-usage-stat-badge-off"}`,
+														children: t(payPlan.label)
 													})]
 												}),
 												/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 													className: "dsm-trae-usage-stat-value dsm-trae-usage-stat-value-general",
-													children: status.payStatus.inTrial && status.payStatus.trialEndTimeMs > 0 ? t("row.trialUntil", { date: formatDateTime(status.payStatus.trialEndTimeMs) }) : t(status.payStatus.hasPackage ? "row.subscribed" : "row.noPackage")
+													children: status.payStatus.inTrial && status.payStatus.trialEndTimeMs > 0 ? t("row.trialUntil", { date: formatDateTime(status.payStatus.trialEndTimeMs) }) : [t(payPlan.label), payPlan.tier].filter(Boolean).join(" · ")
 												}),
 												/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 													className: "dsm-trae-usage-stat-hint",

package/lib/index.d.ts

@@ -1326,6 +1326,19 @@ interface TraePayStatus {
   enableSoloBuilder: boolean;
   enableSoloCoder: boolean;
   enableSoloWeb: boolean;
+  /**
+   * The account's plan identity (`user_pay_identity`), Trae's authoritative
+   * tier number: `0` is Free. Measured 2026-10-01 on a live SG community
+   * account, which reported `0` / `"Free"`.
+   *
+   * This is a DIFFERENT question from {@link hasPackage}, which asks whether a
+   * package/entitlement object exists. A paying member can hold a plan
+   * identity without any package row, which is why issue #19 saw "No active
+   * package" on a Pro account — the card only ever read `has_package`.
+   */
+  payIdentity?: number;
+  /** The plan identity as Trae spells it (`user_pay_identity_str`), e.g. `Free`. */
+  payIdentityStr?: string;
   /** The fission (referral) program window and cap, when exposed. */
   fission?: {
     startTimeMs: number;
@@ -1695,6 +1708,10 @@ interface TraeWebPayStatus {
   enableSoloBuilder: boolean;
   enableSoloCoder: boolean;
   enableSoloWeb: boolean;
+  /** Trae's authoritative tier number (`user_pay_identity`); `0` means Free. */
+  payIdentity?: number;
+  /** Trae's authoritative tier label (`user_pay_identity_str`), e.g. `Free`. */
+  payIdentityStr?: string;
   fission?: {
     startTimeMs: number;
     expireTimeMs: number;

package/lib/index.js

@@ -1942,7 +1942,7 @@ function applyReasoningEffort(body, effort, capability) {
 //#region src/solo.ts
 const TRAE_SOLO_FUNCTION = "solo_work_lite";
 /**
-* Directory functions to union per region, in priority order.
+* `llm_utils_chat` functions to union per region, in priority order.
 *
 * Trae spreads its callable roster across several SOLO-mode functions, and a
 * model is only usable through the one that lists it: `glm-5.3` is absent from
@@ -1950,14 +1950,32 @@ const TRAE_SOLO_FUNCTION = "solo_work_lite";
 * calling it through the former answers `4001 param is invalid`, through the
 * latter streams normally). Rather than betting on a single function, the
 * directory unions them; the first function to provide a config wins, so the
-* order below decides which wire name a model is called with.
+* order below decides which wire name AND which function a model is called with.
+*
+* THIS LIST IS NOT "directory functions" — it is the set of functions
+* `llm_utils_chat` actually accepts, because ownership here is what the chat
+* call replays. `solo_agent` is deliberately ABSENT (measured 2026-10-01 on a
+* live SG credential, issue #19): it is a Remote-agent roster function, not a
+* chat function. Every model sent with `function: "solo_agent"` — `gpt-5.4`,
+* `gpt-5.6-sol`, `gpt-6-astra`, `glm-5.2`, `kimi-k2.7-code` — answered
+* `event:error {"code":4011}` (message says "rate limit", it is really "not
+* served here"), while the same model with the same body answered normally
+* under `solo_work_remote` / `solo_work_lite` / `solo_agent_remote`.
+*
+* Note `get_detail_param` DOES answer `solo_agent` with a 43-entry list, so
+* asking it looks helpful while making 8 of the 10 exposed ai-region models
+* uncallable: it won precedence and stamped its own name onto configs it
+* cannot serve. `solo_agent_remote` is the chat-callable half of that roster
+* (it answers `minimax-m3`, `gemini-3.1-pro`, … that no `solo_work_*` lists)
+* and therefore takes the last slot — after the two IDE functions that serve
+* their shared configs without the Remote plan gate.
 */
 const TRAE_DIRECTORY_FUNCTIONS = {
 	cn: ["solo_work_remote", TRAE_SOLO_FUNCTION],
 	ai: [
-		"solo_agent",
 		"solo_work_remote",
-		TRAE_SOLO_FUNCTION
+		TRAE_SOLO_FUNCTION,
+		"solo_agent_remote"
 	]
 };
 const TRAE_SOLO_CHAT_PATH = "/api/agent/v3/llm_utils_chat";
@@ -2304,6 +2322,75 @@ function decodeTraeEvent(event) {
 }
 //#endregion
 //#region src/solo-bridge.ts
+/**
+* What Trae's in-stream error codes mean. Measured 2026-10-01 on a live SG
+* credential (issue #19), by sending the same body to several functions:
+*
+*  - `1005` — the model needs a paid plan. Trae answers HTTP 200 with
+*    `event:error {"code":1005,"message":"","extra":"{\"plan\":1}"}`, so the
+*    gate is only visible in `extra.plan`; `gpt-6-sol` returned it under both
+*    `solo_work_remote` and `solo_agent_remote` on a free account.
+*  - `4011` — the function the request named does not serve that model. Its
+*    message claims "exceeded the rate limit", which is misleading: the same
+*    model answers normally when sent under `solo_work_remote`.
+*  - `4001` — `config_name` is not one this function serves.
+*/
+const TRAE_ERROR_HINTS = {
+	1005: "Trae requires a paid plan for this model; the current account's plan does not cover it",
+	4001: "Trae does not serve this model under the SOLO function the request used (config_name rejected)",
+	4011: "Trae refused this model under the SOLO function the request used"
+};
+/** `extra` is a JSON *string* on the wire; unwrap it to read `plan`. */
+function traeErrorPlan(extra) {
+	let value = extra;
+	if (typeof value === "string") try {
+		value = JSON.parse(value);
+	} catch {
+		return;
+	}
+	if (typeof value !== "object" || value === null) return void 0;
+	const plan = value["plan"];
+	return typeof plan === "number" ? plan : void 0;
+}
+/** A readable message for an in-stream Trae failure, with its code preserved. */
+function describeTraeFailure(failure) {
+	const plan = traeErrorPlan(failure.extra);
+	const parts = [
+		failure.code === void 0 ? "Trae refused the request" : TRAE_ERROR_HINTS[failure.code] ?? "Trae refused the request",
+		...plan === void 0 ? [] : [`plan ${plan}`],
+		...failure.code === void 0 ? [] : [`Trae code ${failure.code}`]
+	];
+	const detail = failure.message.trim();
+	return detail === "" ? parts.join(" · ") : `${parts.join(" · ")} · upstream: ${detail}`;
+}
+/**
+* HTTP status + error kind for an in-stream failure, so the loopback shim can
+* answer with a real error instead of a truncated 200 stream.
+*
+* `1005` is a subscription gate: 402 is what makes clients stop rather than
+* retry, and it is truthful. Everything else is a client-side rejection.
+*/
+function classifyTraeFailure(failure) {
+	return failure.code === 1005 ? {
+		status: 402,
+		kind: "hard_credit"
+	} : {
+		status: 400,
+		kind: "client"
+	};
+}
+/** Recognise an in-stream failure event, or return undefined for anything else. */
+function traeFailureOf(decoded) {
+	if (decoded.type !== "unknown") return void 0;
+	const payload = decoded.data;
+	const code = typeof payload?.["code"] === "number" ? payload["code"] : void 0;
+	if (decoded.event !== "error" && !(code !== void 0 && code >= 4e3)) return void 0;
+	return {
+		...code === void 0 ? {} : { code },
+		message: typeof payload?.["message"] === "string" ? payload["message"] : "",
+		...payload?.["extra"] === void 0 ? {} : { extra: payload["extra"] }
+	};
+}
 function normalizeToolCalls(value) {
 	if (!Array.isArray(value)) return [];
 	const calls = [];
@@ -2328,6 +2415,10 @@ function normalizeToolCalls(value) {
 function bridgeTraeSoloStream(response, model) {
 	const source = response.body;
 	if (source === null) return new Response(null, { status: 502 });
+	return bridgeTraeSource(source, model);
+}
+/** {@link bridgeTraeSoloStream} over an already-opened byte stream. */
+function bridgeTraeSource(source, model) {
 	const id = `chatcmpl-${randomUUID().replaceAll("-", "").slice(0, 24)}`;
 	const created = Math.floor(Date.now() / 1e3);
 	const decoder = new TextDecoder();
@@ -2356,9 +2447,8 @@ function bridgeTraeSoloStream(response, model) {
 			const consume = (event) => {
 				const decoded = decodeTraeEvent(event);
 				if (decoded.type === "unknown") {
-					const payload = decoded.data;
-					const code = typeof payload?.["code"] === "number" ? payload["code"] : void 0;
-					if (decoded.event === "error" || code !== void 0 && code >= 4e3) upstreamError = new Error(typeof payload?.["message"] === "string" && payload["message"] !== "" ? payload["message"] : `Trae upstream error (code ${code ?? "?"})`);
+					const failure = traeFailureOf(decoded);
+					if (failure !== void 0) upstreamError = new Error(describeTraeFailure(failure));
 					return;
 				}
 				if (decoded.type === "delta") {
@@ -2428,6 +2518,123 @@ function bridgeTraeSoloStream(response, model) {
 		headers: { "Content-Type": "text/event-stream" }
 	});
 }
+/**
+* How far {@link openTraeSource} reads before giving up on finding a failure.
+* Trae opens a real answer with small `metadata` / `timing_cost` events, so a
+* healthy stream is recognised well inside these bounds; they exist only so a
+* pathological stream cannot stall the response headers.
+*/
+const PEEK_MAX_CHUNKS = 64;
+const PEEK_MAX_BYTES = 262144;
+/** Replay the bytes the peek consumed, then drain the rest of the upstream. */
+function replayTraeSource(buffered, reader, ended) {
+	let index = 0;
+	return new ReadableStream({
+		async pull(controller) {
+			const chunk = buffered[index];
+			if (chunk !== void 0) {
+				index += 1;
+				controller.enqueue(chunk);
+				return;
+			}
+			if (ended) {
+				controller.close();
+				return;
+			}
+			const next = await reader.read();
+			if (next.done) {
+				controller.close();
+				return;
+			}
+			controller.enqueue(next.value);
+		},
+		async cancel(reason) {
+			await reader.cancel(reason).catch(() => {});
+		}
+	});
+}
+/**
+* Open the upstream answer, failing fast when Trae refuses BEFORE producing any
+* output.
+*
+* This exists because Trae reports authorisation and subscription failures
+* inside a **200** SSE body. Relaying that as a 200 and aborting mid-stream
+* (what this bridge used to do) loses the code at the HTTP boundary: pi-ai only
+* sees a truncated stream and reports `Stream ended without finish_reason`,
+* which reads as a network fault and is retried five times — the exact symptom
+* in issue #19. Peeking until the first real output lets a refusal become a
+* normal error response with its code and plan intact.
+*
+* The peek is limited to the head of the stream and replayed verbatim, so a
+* healthy answer keeps streaming with no buffering beyond the first event.
+*/
+async function openTraeSource(response) {
+	const body = response.body;
+	if (body === null) return {
+		ok: false,
+		status: 502,
+		kind: "server",
+		message: "Trae upstream returned no response body"
+	};
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const sse = new SseDecoder();
+	const buffered = [];
+	let bytes = 0;
+	let ended = false;
+	try {
+		while (buffered.length < PEEK_MAX_CHUNKS && bytes < PEEK_MAX_BYTES) {
+			const next = await reader.read();
+			if (next.done) {
+				ended = true;
+				break;
+			}
+			buffered.push(next.value);
+			bytes += next.value.byteLength;
+			let answered = false;
+			for (const event of sse.push(decoder.decode(next.value, { stream: true }))) {
+				const decoded = decodeTraeEvent(event);
+				const failure = traeFailureOf(decoded);
+				if (failure !== void 0) {
+					await reader.cancel().catch(() => {});
+					return {
+						ok: false,
+						...classifyTraeFailure(failure),
+						message: describeTraeFailure(failure)
+					};
+				}
+				if (decoded.type !== "unknown") answered = true;
+			}
+			if (answered) break;
+		}
+	} catch (error) {
+		reader.releaseLock();
+		return {
+			ok: false,
+			status: 0,
+			kind: "server",
+			message: `transport error: ${String(error)}`
+		};
+	}
+	return {
+		ok: true,
+		source: replayTraeSource(buffered, reader, ended)
+	};
+}
+/**
+* Bridge an upstream answer, turning an early refusal into a real error result.
+*
+* The sibling {@link bridgeTraeSoloStream} stays synchronous and always answers
+* 200; it is the primitive, and this is the policy the bridge class uses.
+*/
+async function bridgeTraeSoloStreamOrFail(response, model) {
+	const opened = await openTraeSource(response);
+	if (!opened.ok) return opened;
+	return {
+		ok: true,
+		response: bridgeTraeSource(opened.source, model)
+	};
+}
 /** Native SOLO client wrapper used by the loopback OpenAI adapter. */
 var TraeSoloBridge = class {
 	upstream;
@@ -2475,10 +2682,7 @@ var TraeSoloBridge = class {
 		}
 		const result = await this.upstream.chatStream(prepared, signal);
 		if (!result.ok) return result;
-		return {
-			ok: true,
-			response: bridgeTraeSoloStream(result.response, model)
-		};
+		return await bridgeTraeSoloStreamOrFail(result.response, model);
 	}
 };
 //#endregion
@@ -2541,6 +2745,38 @@ function parseTraeRemoteModel(value) {
 //#region src/solo-remote.ts
 const TRAE_SOLO_REMOTE_BASE = "https://solo.trae.cn/api/remote/v1";
 /**
+* Remote-directory functions to ask for, per region.
+*
+* The remote `/models` answer is **grouped by function** and the groups are not
+* interchangeable (measured 2026-10-01, issue #19):
+*
+* ```
+* solo_agent        : 19 models   ← superset; also the ONLY source of
+*                                   gpt-6-astra / gpt-5.6-sol|terra|luna /
+*                                   glm-5.2 / gpt-5.5 / Seed-2.1-Turbo
+* solo_agent_remote : 10 models   ← what this client used to read, and all it
+*                                   read: the preferred group only
+* ```
+*
+* `solo_agent` ⊇ `solo_agent_remote`, so reading just the latter hid nine
+* models that the Trae IDE does show — exactly what the reporter saw. Both
+* groups are therefore requested, and every returned group is unioned.
+*
+* Asking for a function the gateway does not serve is harmless: unknown names
+* are ignored rather than rejected (`solo_work_lite` returns no group, and the
+* request still answers HTTP 200). The CN list is left as it was — the CN
+* rosters were not re-measured here, and the union keeps whichever groups come
+* back.
+*/
+const TRAE_REMOTE_DIRECTORY_FUNCTIONS = {
+	cn: ["solo_agent_remote", "solo_work_remote"],
+	ai: [
+		"solo_agent",
+		"solo_agent_remote",
+		"solo_work_remote"
+	]
+};
+/**
 * Region-scoped request dressing. The CN portal is `solo.trae.cn` with the
 * CN locale headers; the international directory lives on the shared
 * `coresg-normal.trae.ai` gateway and was verified (2026-09-15) with the
@@ -2590,16 +2826,16 @@ var TraeSoloRemoteCatalogClient = class {
 		const region = regionOfCredential(await this.options.credential());
 		const base = this.baseUrl ?? REGION_GATEWAYS[region].remote;
 		const headers = await this.headers(region);
-		const response = await this.fetchImpl(`${base}/models?functions=solo_agent_remote,solo_work_remote`, {
+		const functions = TRAE_REMOTE_DIRECTORY_FUNCTIONS[region].join(",");
+		const response = await this.fetchImpl(`${base}/models?functions=${functions}`, {
 			headers,
 			signal: signal ?? AbortSignal.timeout(3e4)
 		});
 		if (!response.ok) throw new Error(`SOLO remote models returned HTTP ${response.status}`);
 		const groups = (await response.json()).data?.list ?? [];
-		const preferred = groups.find((group) => group.function === "solo_agent_remote") ?? groups[0];
 		const seen = /* @__PURE__ */ new Set();
 		const models = [];
-		for (const raw of preferred?.models ?? []) {
+		for (const group of groups) for (const raw of group.models ?? []) {
 			const model = parseTraeRemoteModel(raw);
 			if (model === void 0 || seen.has(model.id)) continue;
 			seen.add(model.id);
@@ -3285,6 +3521,8 @@ var TraeUsageClient = class {
 		const fissionStart = asNumber(payload["solo_fission_start_time"]);
 		const fissionExpire = asNumber(payload["solo_fission_expire_time"]);
 		const fissionMax = asNumber(payload["solo_fission_max_usage"]);
+		const payIdentity = asNumber(payload["user_pay_identity"]);
+		const payIdentityStr = typeof payload["user_pay_identity_str"] === "string" && payload["user_pay_identity_str"].trim() !== "" ? payload["user_pay_identity_str"].trim() : void 0;
 		return {
 			isDollarUsageBilling: flag("is_dollar_usage_billing"),
 			hasPackage: flag("has_package"),
@@ -3295,6 +3533,8 @@ var TraeUsageClient = class {
 			enableSoloBuilder: flag("enable_solo_builder"),
 			enableSoloCoder: flag("enable_solo_coder"),
 			enableSoloWeb: flag("enable_solo_web"),
+			...payIdentity === void 0 ? {} : { payIdentity },
+			...payIdentityStr === void 0 ? {} : { payIdentityStr },
 			...fissionStart === void 0 || fissionExpire === void 0 || fissionMax === void 0 ? {} : { fission: {
 				startTimeMs: fissionStart,
 				expireTimeMs: fissionExpire,

package/package.json

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