dsh-connect-trae 4.15.0 → 4.16.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 4.16.0 (2026-11-08)
+
+### 模型标签槽：按宿主的声明注册，为 `keyed` 做好准备
+
+`conversation.input.model.label` 的 kind 写在宿主包里（`ui-model-selection`）。
+在它改口之前是 `single`：只有一格，三家连接器只能按 `-101` / `-102` / `-105`
+互相压价。目标形态是 `keyed`——每个 `options.key` 自成一格，宿主按 `provider.id`
+派发 `{ entryKey }`，没人贡献的 provider 落回宿主自己的 fallback。
+
+**本版做的是一件插件侧唯一该做的事：注册几条跟着宿主声明的 kind 走。**
+
+- 新增 `src/client/model-label-seat.ts`：运行时读 `ctx.slots.spec(key)?.kind`，
+  `keyed` 就为 `trae` / `trae-enterprise` / `trae-global` 各注册一格，其余情况
+  （含读不到）保持历史上的单条。**一个构建同时服务两条宿主线**，宿主改口那天
+  不需要重新发版。
+- `registerSlotEntry` 现在接受「多个 disposer」，并把它们合成一个按**反序**释放的
+  组合 disposer：注册是一条命，拆开释放会留下「某几格还占着、兄弟格已消失」的半死状态。
+
+**为什么不能只改宿主。** 两个方向都会**静默**失败，而本仓库的注册路径把一个
+try/catch 包在回调里（issue #74 的修复），于是它们都变成一行 `console.error`：
+
+| 情况 | 结果 |
+| --- | --- |
+| keyed 的两条打到 `single` 宿主 | 第二条抛 `already has a registration`，第一条已落地 → 半注册 |
+| 无 key 的一条打到 `keyed` 宿主 | 抛 `keyed slot … requires options.key` → 标签消失 |
+
+`keyed` **强制要求 `key`**，这是上游提案里没写的第一道陷阱：**此前已发布**的本族每个
+版本都注册一条无 key 的条目，只改宿主声明会让它们一起失效（本版之后的新构建会跟着
+声明走，所以受影响的是「已经装在用户机器上」的那些版本）。第二道陷阱见下一节。
+
+**改声明不够：宿主还必须传 `entryKey`。** 复核实机产物
+（`ui-model-selection@0.2.2-rc.1`）发现，渲染该槽只有一个调用点，第三个参数只有
+`fallback`、**没有 `entryKey`**；而 keyed 分支是
+`find(e => e.options.key === opts?.entryKey)`——`undefined` 匹配不到任何条目，于是
+**每一行**都落到 fallback。本插件的注册会成功、回调也跑、无异常无日志，只是组件再也
+不被调用。上游的最小改动是**两处**：声明 + 调用点补 `{ entryKey: provider.id }`。
+
+`MODEL_LABEL_PRIORITY = -102` 不改。keyed 下它不再决定可见性，只剩「同一格内谁先」；
+三家之间不再有压制关系——停战靠的是换槽的基数，不是再压一次价。
+
+外来行分支保留：keyed 下运行时走不到，但一个构建要同时服务两种宿主，而 `single`
+宿主上它就是整行文字。它同时也是最便宜的哨兵——自己的行若走进那一支，说明 `key` 写错了。
+
 ## 4.15.0 (2026-11-08)
 
 ### 新增：模型选择器里的胶囊，改成「谁都能显示」

package/lib/client.js

@@ -9554,6 +9554,17 @@ ${u} ${p}-pool .sw input:checked+.sw-track::after{transform:translateX(16px)}
 		*
 		* @module dsh-connect-trae/client/TraeModelLabel
 		*/
+		/**
+		* Every provider id this plugin owns, in panel order.
+		*
+		* Exported because on a `keyed` host the label seat is one registration PER
+		* provider id — the registration side needs the same list the component uses to
+		* decide "is this row mine", and a second literal would drift from
+		* `providerOfPanel`. Derived rather than typed out: `trae-enterprise` is the id
+		* most easily forgotten, and forgetting it means that panel's rows silently fall
+		* through to the host's plain fallback.
+		*/
+		const TRAE_MODEL_LABEL_PROVIDERS = TRAE_PANELS.map(providerOfPanel);
 		/** How long a fetched snapshot is trusted, in milliseconds. */
 		const CACHE_MS = 6e4;
 		/** How often a mounted label re-reads the clock, in milliseconds. */
@@ -9825,6 +9836,17 @@ ${u} ${p}-pool .sw input:checked+.sw-track::after{transform:translateX(16px)}
 		* host's own presentation — catalog name plus that model's optional badge — for
 		* any provider that is not ours.
 		*
+		* WHAT CHANGES WHEN THE HOST KEYS THE SLOT — and why the number stays. On a host
+		* that declares this slot `keyed`, the seat is registered once per provider id
+		* (`./model-label-seat.ts`), each `key` is its own cell, and priority stops
+		* deciding WHO IS VISIBLE: qoder's `-101` and workbuddy's `-105` no longer share
+		* a cell with this `-102`, so none of the three can shadow another and the
+		* armistice below stops being a race. Priority keeps exactly one meaning inside
+		* a cell — the tie-breaker between two registrations claiming the SAME provider
+		* id, where an equal value throws and the lowest renders. The value is therefore
+		* kept as this plugin's rank for its own rows, not as a bid in an auction that
+		* no longer happens.
+		*
 		* WHY A DISTINCT PRIORITY IS NOT ENOUGH ON ITS OWN. It removes the cross-plugin
 		* collision, but issue #74's error was a SECOND registration of THIS plugin
 		* against its own first one (the report's stack shows
@@ -9833,7 +9855,9 @@ ${u} ${p}-pool .sw input:checked+.sw-track::after{transform:translateX(16px)}
 		* slot's declaration lifetime collapses and re-declares, so a callback that
 		* registers unconditionally double-registers. `index.tsx` therefore also
 		* disposes its previous entry before every attempt. Priority alone would have
-		* made the throw rarer and harder to read, not absent.
+		* made the throw rarer and harder to read, not absent. (On a `keyed` host the
+		* same rule applies per key: re-registering one provider's seat twice at one
+		* priority throws just as loudly.)
 		*/
 		const MODEL_LABEL_PRIORITY = -102;
 		/** The four tones the host understands, as a lookup for narrowing. */
@@ -10030,6 +10054,114 @@ ${u} ${p}-pool .sw input:checked+.sw-track::after{transform:translateX(16px)}
 			});
 		}
 		//#endregion
+		//#region src/client/model-label-seat.ts
+		/**
+		* Read the declared kind of a slot, or `undefined` when it cannot be read.
+		*
+		* `spec()` is the documented read-only accessor (`SlotRegistry.spec`), present
+		* on 0.1.7 and on 0.2.2. It is also the only way to learn the kind: the
+		* declaration lives in the host package, and a plugin's own `SlotMap`
+		* augmentation says what this plugin HOPES the slot is, not what the running
+		* host declared.
+		*
+		* Anything unexpected — no `spec` method on an older line, a throw from a
+		* service that is not ready, a kind this build does not know — returns
+		* `undefined`, and the caller falls back to the single-cell shape. That is the
+		* conservative direction: it is what every released version of this plugin
+		* already does.
+		*
+		* @param slots - The `slots` service (typed loosely: the accessor is optional).
+		* @param key - The slot key to inspect.
+		* @returns The declared kind, or `undefined`.
+		*/
+		function declaredSlotKind(slots, key) {
+			const face = slots;
+			if (face === void 0 || typeof face.spec !== "function") return void 0;
+			let spec;
+			try {
+				spec = face.spec(key);
+			} catch {
+				return;
+			}
+			const kind = spec?.kind;
+			if (kind === "single" || kind === "list" || kind === "keyed" || kind === "chain") return kind;
+		}
+		/**
+		* The registrations this plugin should make for the model-label seat.
+		*
+		* `keyed` yields ONE seat per provider id: each is its own cell, each renders
+		* only the rows whose owner props carry that provider id, and a provider this
+		* plugin does not own falls through to the owner's own fallback (the catalog
+		* name, plus that model's `badge` on hosts that have one).
+		*
+		* Every other kind — including `undefined`, i.e. a host that cannot be
+		* inspected — yields the single historical seat. That is not a degraded mode:
+		* it is what `single` requires, and on a not-yet-declared slot it is what the
+		* inject callback is about to find.
+		*
+		* An empty provider list under `keyed` would silently disable the label, so it
+		* falls back to the single seat instead: a wrong-shaped registration that still
+		* draws something beats a correct-shaped registration that draws nothing.
+		*
+		* @param params - Slot key, declared kind, this plugin's provider ids, priority.
+		* @returns One or more `register()` option objects, in registration order.
+		*/
+		function modelLabelSeats(params) {
+			const { name, kind, providerIds, priority } = params;
+			if (kind === "list" || kind === "chain") return [];
+			if (kind === "keyed" && providerIds.length > 0) return providerIds.map((id) => ({
+				name,
+				key: id,
+				priority
+			}));
+			return [{
+				name,
+				priority
+			}];
+		}
+		/**
+		* Claim every planned seat, atomically, and hand back ONE disposer.
+		*
+		* WHY ATOMIC. The seat list is 2-3 entries on a `keyed` host, and `register()`
+		* can throw on any ONE of them — a rival plugin claiming the same provider id at
+		* the same priority, or the declaration collapsing mid-loop. A plain `.map()`
+		* would then leave the earlier seats landed on the ledger with their disposers
+		* unreachable (they were only ever held by the array that the throw discarded),
+		* which is worse than failing outright: the component stays mounted, the caller
+		* believes registration failed, and nothing will ever release those cells. On a
+		* `single` host it also means the identity keeps a live entry that the next
+		* `inject` re-run cannot displace without a priority clash.
+		*
+		* So a partial failure is rolled back in reverse order before the error is
+		* rethrown, exactly as if it had never been attempted. The rethrow is important:
+		* each caller already has a catch that logs, and swallowing here would hide the
+		* refusal from the diagnostics that exist to explain it.
+		*
+		* A disposal that itself throws must not mask the original error, hence the
+		* inner catch — the registry treats a second dispose as a no-op, and a broken
+		* one must not turn one failure into a crash.
+		*
+		* @param seats - The plan from {@link modelLabelSeats}, in registration order.
+		* @param register - Claims one seat and returns its disposer.
+		* @returns One disposer that releases every seat, in reverse registration order.
+		*/
+		function registerModelLabelSeats(seats, register) {
+			const claimed = [];
+			try {
+				for (const seat of seats) claimed.push(register(seat));
+			} catch (error) {
+				for (const dispose of [...claimed].reverse()) try {
+					dispose();
+				} catch {}
+				throw error;
+			}
+			return () => {
+				for (const dispose of [...claimed].reverse()) try {
+					dispose();
+				} catch {}
+			};
+		}
+		//#endregion
 		//#region src/client/index.tsx
 		/** Stable browser-plugin name. */
 		const name = "dsh-connect-trae-client";
@@ -10081,10 +10213,19 @@ ${u} ${p}-pool .sw input:checked+.sw-track::after{transform:translateX(16px)}
 		* the same priority. That refusal is OUR fault and we can fix it rather than
 		* report it, so each run releases whatever this identity already holds.
 		*
+		* ONE DISPOSER PER CALL, HOWEVER MANY ENTRIES IT OWNS. A `keyed` host makes this
+		* plugin claim one cell per provider id (see `./model-label-seat.ts`), and those
+		* cells must live and die together — a partial teardown would leave a cell
+		* occupied by a component whose siblings are gone, visible as some rows
+		* decorated and others not. Folding them into one disposer is
+		* `registerModelLabelSeats`'s job, so the contract here stays the simple one:
+		* whatever `register` returns is the whole ownership of this identity, and
+		* `SlotHold` keeps exactly one.
+		*
 		* @param ctx - The applying plugin's context (module scope has none).
 		* @param identity - Stable key for this seat.
 		* @param slotKey - The host slot to register into.
-		* @param register - Performs the registration, returning its disposer.
+		* @param register - Performs the registration(s), returning ONE disposer for all.
 		* @param describe - Names the seat in the failure log.
 		*/
 		function registerSlotEntry(ctx, identity, slotKey, register, describe) {
@@ -10349,16 +10490,31 @@ ${u} ${p}-pool .sw input:checked+.sw-track::after{transform:translateX(16px)}
 				* non-interactive inline content such as a coloured name or badge" while the
 				* picker keeps owning clicks, focus and check marks.
 				*
+				* HOW MANY SEATS, AND WHY THAT IS READ AT MOUNT. On a `single` host this slot
+				* holds ONE cell: a second registration at the same priority throws, a second
+				* registration at any other priority is silently discarded, and whoever holds
+				* the cell must draw EVERY provider's rows. On a `keyed` host each
+				* `options.key` is its own cell, so one seat per provider id gives this
+				* plugin exactly its own rows and leaves every other provider to the owner's
+				* own fallback. Which shape is legal is the HOST's declaration, so the kind
+				* is read from `ctx.slots.spec(...)` at mount and the seat list is derived
+				* from it (`./model-label-seat.ts`). One build serves both lines.
+				*
 				* Registered unconditionally: the component renders the plain name for a
 				* provider that is not ours, so there is nothing to gate on. Its own
 				* try/catch keeps a host that does not serve this slot from taking the card
 				* down with it.
 				*/
 				const registerModelLabel = () => {
-					registerSlotEntry(ctx, "conversation.input.model.label", "conversation.input.model.label", () => ctx.slots.register({
-						name: "conversation.input.model.label",
-						priority: MODEL_LABEL_PRIORITY
-					}, TraeModelLabel), "model label slot");
+					registerSlotEntry(ctx, "conversation.input.model.label", "conversation.input.model.label", () => {
+						const registry = ctx.slots;
+						return registerModelLabelSeats(modelLabelSeats({
+							name: "conversation.input.model.label",
+							kind: declaredSlotKind(ctx.slots, "conversation.input.model.label"),
+							providerIds: TRAE_MODEL_LABEL_PROVIDERS,
+							priority: MODEL_LABEL_PRIORITY
+						}), (seat) => registry.register(seat, TraeModelLabel));
+					}, "model label slot");
 				};
 				registerModelLabel();
 				/**

package/package.json

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