dsh-connect-trae 2.4.0 → 2.7.0

package/lib/index.js

@@ -185,12 +185,22 @@ function displayKey(name) {
 * multiplier, reasoning and multimodal flags. `wire` (from `get_detail_param`)
 * supplies the real `llm_utils_chat` `config_name` — the only id the chat
 * endpoint actually accepts — plus the authoritative post-discount credit
-* multiplier when `display_contact_config` carries one. A remote row is only
-* callable when it maps to a wire `config_name`, so a remote row with no wire
-* match is DROPPED (it would otherwise be sent as an invalid `config_name` and
-* rejected with 4001 "param is invalid"). Verified 2026-08-30: the Remote
-* directory advertises `Doubao-Seed-Code` and `glm-5.3`, neither of which is a
-* current `config_name`; both fail every request, so they must not be exposed.
+* multiplier when `display_contact_config` carries one.
+*
+* A remote row with no wire match is STILL KEPT (decision 2026-10-02, issue
+* #19). It previously was dropped, on the reasoning that a row with no
+* `config_name` is sent as an invalid one and rejected with 4001. That
+* reasoning holds only for the accounts and functions we can measure, and
+* measuring is the problem: whether a roster contains a model is ACCOUNT-
+* SCOPED, so "no wire entry on a free account" cannot prove a paying account
+* cannot call it. Dropping on that evidence silently denied those users models
+* their own Trae IDE offers. The row therefore ships, and its call fails
+* honestly: the bridge now translates the in-stream refusal into a readable
+* error (`4001` → "Trae does not serve this model under the SOLO function the
+* request used", `4011` → "Trae refused this model under the SOLO function the
+* request used"), so a user who picks an unusable model is told why instead of
+* seeing nothing. This reverses the 2026-08-30 note about `Doubao-Seed-Code`,
+* which later turned out to be callable under `chat_v3`.
 *
 * Credit multiplier precedence: the wire's `display_contact_config` rate wins
 * whenever present (it is the post-discount figure the Trae IDE renders — the
@@ -217,8 +227,7 @@ function mergeTraeModelSources(remote, wire) {
 	const result = [];
 	for (const model of remote) {
 		const wireModel = wireById.get(displayKey(model.id)) ?? wireByName.get(displayKey(model.name));
-		if (wireModel === void 0) continue;
-		const creditMultiplier = wireModel.creditMultiplier ?? model.creditMultiplier;
+		const creditMultiplier = wireModel?.creditMultiplier ?? model.creditMultiplier;
 		result.push({
 			id: model.id,
 			name: model.name,
@@ -232,8 +241,8 @@ function mergeTraeModelSources(remote, wire) {
 				reasoning: model.reasoning,
 				reasoningEfforts: Object.fromEntries(model.reasoning.supported.map((effort) => [effort, effort === "low" ? "light" : effort === "xhigh" ? "extra_high" : "high"]))
 			},
-			...wireModel.id !== "" && wireModel.id !== model.id ? { wireConfigName: wireModel.id } : {},
-			...wireModel.function === void 0 ? {} : { wireFunction: wireModel.function }
+			...wireModel !== void 0 && wireModel.id !== "" && wireModel.id !== model.id ? { wireConfigName: wireModel.id } : {},
+			...wireModel?.function === void 0 ? {} : { wireFunction: wireModel.function }
 		});
 	}
 	return result;
@@ -1942,7 +1951,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 +1959,69 @@ 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.
+*
+* `chat_v3` is the widest chat roster of all (measured 2026-10-01 on live
+* credentials, issue #19 follow-up): its `get_detail_param` answers 40
+* config_names on `ai` — more than any other function except `solo_agent` (43,
+* which cannot serve chat). It lists models NO other chat function names, and
+* it is joined LAST so it only fills gaps: a config two functions list keeps
+* the earlier function, so no precedence is disturbed. The ai models it unlocks
+* were each verified callable end-to-end through the plugin's own
+* `prepareSoloBody` envelope:
+*
+*   ai (+6): kimi-k2.7-code, deepseek-v4-flash-0731, deepseek-v3.2,
+*            gemini-3-flash-premium, gemini_2.5_flash_premium, Dola-Seed-2.0-Code
+*
+* CN joins `chat_v3` and `solo_coder` too (2026-10-02). Both are callable there
+* — verified per model through `prepareSoloBody`, calling each model under a
+* function whose roster names it: `glm-5` / `glm-5.1` / `qwen-3.5` and
+* `deepseek-v4-pro` / `deepseek-v4-flash` under `solo_coder`, and
+* `doubao-seed-2.0-code` under `solo_coder` / `solo_work_remote` /
+* `solo_work_lite`. An earlier note here claimed those three answered `4001`
+* "under every function" — that was a measurement error, not an upstream
+* refusal: the probe had called them by display id while the chat endpoint needs
+* the config_name its owning function returned.
+*
+* This also corrects an older note that `Doubao-Seed-Code` "has no config_name
+* and must stay hidden" (docs/MODEL_MANAGEMENT_DESIGN.md): it does have one,
+* under `chat_v3`.
+*
+* A model in NO chat function's roster is still left to the merge: it ships
+* with no wire target and its call fails with a readable upstream message
+* rather than being hidden (see mergeTraeModelSources).
 */
 const TRAE_DIRECTORY_FUNCTIONS = {
-	cn: ["solo_work_remote", TRAE_SOLO_FUNCTION],
+	cn: [
+		"solo_work_remote",
+		TRAE_SOLO_FUNCTION,
+		"solo_agent_remote",
+		"chat_v3",
+		"solo_coder"
+	],
 	ai: [
-		"solo_agent",
 		"solo_work_remote",
-		TRAE_SOLO_FUNCTION
+		TRAE_SOLO_FUNCTION,
+		"solo_agent_remote",
+		"chat_v3"
 	]
 };
 const TRAE_SOLO_CHAT_PATH = "/api/agent/v3/llm_utils_chat";
@@ -2304,6 +2368,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 +2461,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 +2493,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 +2564,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 +2728,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 +2791,66 @@ 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_remote` returns no group on
+* `ai`, and the request still answers HTTP 200).
+*
+* `chat_v3` was added on 2026-10-01 (issue #19 follow-up) because it carries
+* three ai-region models that appear in NO other group — `deepseek-v3.2`,
+* `gemini-3-flash-premium`, `gemini_2.5_flash_premium` — and those three are
+* callable through it (see TRAE_DIRECTORY_FUNCTIONS in solo.ts).
+*
+* Both regions now ask the SAME group list (2026-10-02). CN previously asked
+* only `solo_agent_remote` + `solo_work_remote`, which left its `solo_coder`
+* group (12 models) unread — the same shape of miss as the ai one. Every group
+* below was measured to exist on both gateways; a region that does not serve a
+* name simply returns no group for it, which the union tolerates. Reading costs
+* one query and the merge no longer discards rows for lacking a wire match (see
+* mergeTraeModelSources), so an unread group is a model silently missing from
+* the user's own list — the failure this list exists to prevent.
+*
+* `builder_v3` is included for the same reason even though neither region's
+* current wire lists name it: its rows are real directory entries, and whether
+* a paying account can call one is not something this client can determine.
+*/
+const TRAE_REMOTE_DIRECTORY_FUNCTIONS = {
+	cn: [
+		"solo_agent",
+		"solo_agent_remote",
+		"solo_work_remote",
+		"solo_work_lite",
+		"chat_v3",
+		"solo_coder",
+		"builder_v3"
+	],
+	ai: [
+		"solo_agent",
+		"solo_agent_remote",
+		"solo_work_remote",
+		"solo_work_lite",
+		"chat_v3",
+		"solo_coder",
+		"builder_v3"
+	]
+};
+/**
 * 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 +2900,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);
@@ -3145,6 +3455,165 @@ var TraeDelegatingUpstreamClient = class {
 	}
 };
 //#endregion
+//#region src/model-probe.ts
+/**
+* How long one probe may take. Trae answers a one-word prompt in a few seconds;
+* beyond this the answer is not worth waiting for and is reported as unknown.
+*/
+const TRAE_PROBE_TIMEOUT_MS = 3e4;
+/** Upstream error codes the probe recognises, and what they mean. */
+const GATE_CODES = /* @__PURE__ */ new Set([1005]);
+const UNSUPPORTED_CODES = /* @__PURE__ */ new Set([4001, 4011]);
+/** Pull `Trae code N` out of an already-translated failure message. */
+function codeOf(message) {
+	const match = /Trae code (\d+)/u.exec(message);
+	return match === null ? void 0 : Number(match[1]);
+}
+/**
+* Classify a failure that arrived as a thrown stream error rather than a
+* returned result.
+*
+* The bridge errors the stream (instead of returning a result) when a refusal
+* interrupts an answer that had already started; its message is the same
+* translated text, so a named code is still decisive. Anything without a
+* recognised code — an abort, a socket reset, a proxy — stays `unknown`.
+*/
+function classifyProbeError(message) {
+	if (codeOf(message) !== void 0) {
+		const classified = classifyProbeResult({
+			ok: false,
+			status: 0,
+			kind: "client",
+			message
+		}, false);
+		if (classified.verdict !== "unknown") return classified;
+	}
+	return {
+		verdict: "unknown",
+		detail: message === "" ? "the stream failed without a message" : `stream failed: ${message}`
+	};
+}
+/**
+* Classify a completed upstream call.
+*
+* `result` is what `TraeSoloBridge.chatStream` returned, so a refusal that
+* arrived inside a 200 body has already been turned into a real error result
+* (and its code translated into `message`) by the bridge — this function only
+* has to read it back.
+*/
+function classifyProbeResult(result, outputSeen) {
+	if (result.ok) return outputSeen ? {
+		verdict: "available",
+		detail: "upstream answered"
+	} : {
+		verdict: "unknown",
+		detail: "the stream ended without any output"
+	};
+	const message = result.message.trim() === "" ? `HTTP ${result.status}` : result.message;
+	if (result.kind === "authentication" || result.status === 401 || result.status === 403) return {
+		verdict: "auth",
+		detail: message
+	};
+	if (result.kind === "soft_rate" || result.status === 429) return {
+		verdict: "rate_limited",
+		detail: message
+	};
+	const code = codeOf(message);
+	if (code !== void 0 && GATE_CODES.has(code)) return {
+		verdict: "gated",
+		detail: message
+	};
+	if (code !== void 0 && UNSUPPORTED_CODES.has(code)) return {
+		verdict: "unsupported",
+		detail: message
+	};
+	if (result.kind === "client" && result.status >= 400 && result.status < 500) return {
+		verdict: "unsupported",
+		detail: message
+	};
+	return {
+		verdict: "unknown",
+		detail: message
+	};
+}
+/** Read a probe response without letting a large or endless body stall. */
+async function readProbeOutput(response) {
+	try {
+		const text = await response.text();
+		return { output: /"content"\s*:\s*"[^"]/u.test(text) || /"tool_calls"/u.test(text) };
+	} catch (error) {
+		return {
+			output: false,
+			error: error instanceof Error ? error : new Error(String(error))
+		};
+	}
+}
+/** The minimal chat call one probe makes. */
+function probeBody(model) {
+	return JSON.stringify({
+		model,
+		messages: [{
+			role: "user",
+			content: "ping"
+		}]
+	});
+}
+/**
+* Probe one model through the bridge the plugin actually chats with, so the
+* recorded verdict describes the user's real path (same wire resolution, same
+* function stamping, same error translation).
+*/
+async function probeOneModel(chat, id, timeoutMs = TRAE_PROBE_TIMEOUT_MS) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		const result = await chat(probeBody(id), controller.signal);
+		if (!result.ok) return {
+			id,
+			...classifyProbeResult(result, false)
+		};
+		const { output, error } = await readProbeOutput(result.response);
+		if (error !== void 0) return {
+			id,
+			...classifyProbeError(error.message)
+		};
+		return {
+			id,
+			...classifyProbeResult(result, output)
+		};
+	} catch (error) {
+		if (controller.signal.aborted) return {
+			id,
+			verdict: "unknown",
+			detail: `no answer within ${Math.round(timeoutMs / 1e3)}s`
+		};
+		return {
+			id,
+			...classifyProbeError(error instanceof Error ? error.message : String(error))
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Probe a list of models ONE AT A TIME.
+*
+* Sequential on purpose: Trae throttles bursts, and a burst of parallel probes
+* would manufacture the very `rate_limited`/`unknown` verdicts this feature
+* must avoid. An authentication failure stops the run — every later probe would
+* fail the same way, and spending calls to learn that again is waste.
+*/
+async function probeModelsSequentially(chat, ids, onResult) {
+	const results = [];
+	for (const [index, id] of ids.entries()) {
+		const result = await probeOneModel(chat, id);
+		results.push(result);
+		onResult?.(result, index);
+		if (result.verdict === "auth") break;
+	}
+	return results;
+}
+//#endregion
 //#region src/usage.ts
 /**
 * Read-only Trae usage/credits client.
@@ -3285,6 +3754,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 +3766,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,
@@ -3404,6 +3877,13 @@ var TraeUsageClient = class {
 const TRAE_USAGE_PATH = "/plugins/dsh-connect-trae/usage";
 /** Plugin-owned live model refresh endpoint. */
 const TRAE_MODELS_REFRESH_PATH = "/plugins/dsh-connect-trae/models/refresh";
+/**
+* Plugin-owned availability probe: POST the model ids to test, get one verdict
+* per model. Unlike every read-only sibling this route SPENDS quota — a real
+* (minimal) chat call per model — so it is user-initiated only, and the card
+* labels the button as consuming a small amount.
+*/
+const TRAE_MODELS_TEST_PATH = "/plugins/dsh-connect-trae/models/test";
 /** Plugin-owned local account rescan endpoint. */
 const TRAE_ACCOUNTS_REFRESH_PATH = "/plugins/dsh-connect-trae/accounts/refresh";
 /**
@@ -3568,6 +4048,39 @@ function json(res, status, body) {
 	});
 	res.end(payload);
 }
+/**
+* Read the ids to test from a POST body.
+*
+* Only ids present in the region's live catalog are accepted downstream (see
+* index.ts), so this reader only has to produce a bounded, string-only list.
+*/
+async function readModelTestBody(req) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = chunk;
+		size += buffer.byteLength;
+		if (size > 65536) throw new Error("request body too large");
+		chunks.push(buffer);
+	}
+	const text = Buffer.concat(chunks).toString("utf8").trim();
+	if (text === "") return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new Error("invalid JSON body");
+	}
+	const raw = typeof parsed === "object" && parsed !== null ? parsed["ids"] : void 0;
+	if (!Array.isArray(raw)) throw new Error("body must carry an ids array");
+	const ids = [];
+	for (const value of raw) {
+		if (typeof value !== "string") continue;
+		const id = value.trim();
+		if (id !== "" && !ids.includes(id)) ids.push(id);
+	}
+	return ids;
+}
 /** Loopback browser origins only; other devices are refused until trusted origins exist. */
 function loopbackOrigin(req) {
 	const origin = req.headers.origin;
@@ -3750,6 +4263,40 @@ function registerTraeUsageRoute(ctx, deps) {
 			}
 		});
 		/**
+		* One-click availability test for the enabled models.
+		*
+		* This ROUTE COSTS QUOTA: each tested model gets a real, minimal chat call.
+		* Every other plugin surface is read-only, so the guards here are tighter
+		* than a GET's — POST only, loopback origin only, and the id list is taken
+		* from the request body and validated against the region's live catalog, so
+		* a caller cannot spend calls on arbitrary upstream config names. The count
+		* is capped for the same reason.
+		*/
+		const disposeModelsTest = ctx.webServer.register({
+			kind: "exact",
+			path: TRAE_MODELS_TEST_PATH,
+			handler: async (req, res) => {
+				if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+				if (!loopbackOrigin(req)) return json(res, 403, { error: "origin-not-trusted" });
+				if (deps.probeModels === void 0) return json(res, 503, { error: "model test unavailable" });
+				const region = requestRegion(req, res);
+				if (region === void 0) return;
+				let ids;
+				try {
+					ids = await readModelTestBody(req);
+				} catch (error) {
+					return json(res, 400, { error: safeMessage(error) });
+				}
+				if (ids.length === 0) return json(res, 400, { error: "no models to test" });
+				if (ids.length > 64) return json(res, 400, { error: `too many models (limit ${String(64)})` });
+				try {
+					json(res, 200, await deps.probeModels(region, ids));
+				} catch (error) {
+					json(res, 500, { error: safeMessage(error) });
+				}
+			}
+		});
+		/**
 		* Daily check-in claim — the ONLY route in this plugin that mutates
 		* upstream account state, so it is guarded more tightly than its siblings:
 		* POST only, loopback origin only, and the status read runs FIRST so a day
@@ -3815,6 +4362,7 @@ function registerTraeUsageRoute(ctx, deps) {
 		return () => {
 			disposeCheckin();
 			disposeRefresh();
+			disposeModelsTest();
 			disposeAccounts();
 			disposeUsage();
 		};
@@ -4332,6 +4880,32 @@ function apply(ctx, config) {
 				}
 				return merged;
 			},
+			/**
+			* One-click availability test. The ids come from the card, so each one is
+			* checked against THIS region's live catalog first: a caller must not be
+			* able to spend quota probing arbitrary upstream config names, and a row the
+			* region does not know is reported as skipped rather than silently dropped.
+			*
+			* The probe goes through `upstream` — the same bridge real chats use — so
+			* wire resolution, function stamping and error translation all match what
+			* the user gets when they actually send a message.
+			*/
+			probeModels: async (ids) => {
+				const known = /* @__PURE__ */ new Set();
+				for (const model of [...catalog.current(), ...displayModels(current(), region)]) {
+					known.add(model.id.trim().toLowerCase());
+					known.add(model.name.trim().toLowerCase());
+				}
+				const testable = [];
+				const skipped = [];
+				for (const id of ids) if (known.has(id.trim().toLowerCase())) testable.push(id);
+				else skipped.push(id);
+				const results = await probeModelsSequentially((body, signal) => upstream.chatStream(body, signal), testable);
+				return skipped.length === 0 ? { results } : {
+					results,
+					skipped
+				};
+			},
 			invalidateAdapter: () => {},
 			rawDiagnostic: () => rawDiagnostic()
 		};
@@ -4343,6 +4917,7 @@ function apply(ctx, config) {
 		enabledModelIds: (region) => regionStateOf(current(), region).enabledModelIds ?? [],
 		regionEnabled: (region) => regionEnabled(current(), region),
 		discoverModels: (region, signal) => stacks[region].discoverModels(signal),
+		probeModels: (region, ids) => stacks[region].probeModels(ids),
 		rawDiagnostic: (region) => stacks[region].rawDiagnostic()
 	}));
 	/**
@@ -4487,4 +5062,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { Config, FALLBACK_TRAE_MODELS, FALLBACK_TRAE_MODELS_AI, REGION_GATEWAYS, SseDecoder, TRAE_AI_PROVIDER, TRAE_CHECKIN_PATH, TRAE_CN_AGENT_TASK_PATH, TRAE_CN_TITLE_PATH, TRAE_MODEL_DETAIL_FUNCTIONS, TRAE_MODEL_DETAIL_PATH, TRAE_PAY_BASE, TRAE_PROVIDER, TRAE_PROVIDERS, TRAE_PROVIDER_DISPLAY_NAMES, TRAE_RAW_CHAT_V1_PATH, TRAE_RAW_CHAT_V2_PATH, TRAE_REASONING_EFFORTS, TRAE_REGIONS, TRAE_REGION_PARAM, TRAE_SETTINGS_NS, TRAE_SOLO_CHAT_PATH, TRAE_SOLO_FUNCTION, TRAE_SOLO_MODELS_PATH, TRAE_SOLO_REMOTE_BASE, TRAE_STATE_DB_FILENAME, TRAE_STREAM_IDLE_TIMEOUT_MS, TRAE_USAGE_PATH, TRAE_VERSION_CODE_FALLBACK, TraeCatalog, TraeCredentialStore, TraeDelegatingUpstreamClient, TraeFallbackUpstreamClient, TraeGatedUpstreamClient, TraeRawCapabilityController, TraeRawCapabilityState, TraeRawChatUpstreamClient, TraeSoloBridge, TraeSoloRemoteCatalogClient, TraeSoloUpstreamClient, TraeUsageClient, UnconfiguredTraeUpstreamClient, apply, applyContextBudgets, applyImageSelection, applyReasoningEffort, asVolatile, bridgeTraeSoloStream, buildTraeAgentTaskBody, buildTraeCnHeaders, buildTraeFusionRawChatEnvelope, buildTraeModelDetailRequest, buildTraeRawChatDraft, buildTraeRawChatRuntimeConfig, classifyTraeRawChatFailure, createTraeAdapter, createTraeRawGateway, createTraeShim, decodeRawChatChunk, decodeTraeEvent, decryptTraeStorageValue, deriveCatalog, describeIdShape, describeNameShape, discoveredCatalog, fallbackModelsFor, hashTraeRawChatArg, identityHeaders, inject, legacyTraeOwnAuthPath, maskUserPath, mergeTraeModelSources, name, nextRegionEnabled, nextRegionSlots, normalizeTraeCredential, normalizeTraeVersionCode, parseObservedModelConfig, parseReasoningCapability, parseTraeAuthValue, parseTraeCachedModel, parseTraeModelExtraConfigLogLine, parseTraeRawChatBehaviorConfig, parseTraeRemoteModel, parseTraeStorageDocument, pickTraeStorageIdentity, prepareSoloBody, probeTraeRawChatCapability, rawCapabilityDiagnostic, rawCapabilityFingerprint, readTraeCachedModel, readTraeCliIdentity, readTraeIdentity, refreshTraeCredential, regionEnabled, regionEnabledOf, regionOfCredential, regionOfEdition, regionOfHost, regionOfTraeProvider, regionOfTraeStatusUrl, regionOfUserRegion, regionStateOf, registerTraeUsageRoute, resolveTraeIdentity, resolveTraeRawRuntime, sanitizeCatalog, settingsNamespaceOf, traeEndpoint, traeInputModalities, traeModelDisplayName, traeOwnAuthPath, traeRawChatExtraInfo, traeStateDatabaseCandidates, traeStorageCandidates, traeWebUsage, traeWindowsAppNames, unwrapVolatile, unwrapVolatileDeep, withTraeRegion };
+export { Config, FALLBACK_TRAE_MODELS, FALLBACK_TRAE_MODELS_AI, REGION_GATEWAYS, SseDecoder, TRAE_AI_PROVIDER, TRAE_CHECKIN_PATH, TRAE_CN_AGENT_TASK_PATH, TRAE_CN_TITLE_PATH, TRAE_MODELS_TEST_PATH, TRAE_MODEL_DETAIL_FUNCTIONS, TRAE_MODEL_DETAIL_PATH, TRAE_PAY_BASE, TRAE_PROBE_TIMEOUT_MS, TRAE_PROVIDER, TRAE_PROVIDERS, TRAE_PROVIDER_DISPLAY_NAMES, TRAE_RAW_CHAT_V1_PATH, TRAE_RAW_CHAT_V2_PATH, TRAE_REASONING_EFFORTS, TRAE_REGIONS, TRAE_REGION_PARAM, TRAE_SETTINGS_NS, TRAE_SOLO_CHAT_PATH, TRAE_SOLO_FUNCTION, TRAE_SOLO_MODELS_PATH, TRAE_SOLO_REMOTE_BASE, TRAE_STATE_DB_FILENAME, TRAE_STREAM_IDLE_TIMEOUT_MS, TRAE_USAGE_PATH, TRAE_VERSION_CODE_FALLBACK, TraeCatalog, TraeCredentialStore, TraeDelegatingUpstreamClient, TraeFallbackUpstreamClient, TraeGatedUpstreamClient, TraeRawCapabilityController, TraeRawCapabilityState, TraeRawChatUpstreamClient, TraeSoloBridge, TraeSoloRemoteCatalogClient, TraeSoloUpstreamClient, TraeUsageClient, UnconfiguredTraeUpstreamClient, apply, applyContextBudgets, applyImageSelection, applyReasoningEffort, asVolatile, bridgeTraeSoloStream, buildTraeAgentTaskBody, buildTraeCnHeaders, buildTraeFusionRawChatEnvelope, buildTraeModelDetailRequest, buildTraeRawChatDraft, buildTraeRawChatRuntimeConfig, classifyProbeError, classifyProbeResult, classifyTraeRawChatFailure, createTraeAdapter, createTraeRawGateway, createTraeShim, decodeRawChatChunk, decodeTraeEvent, decryptTraeStorageValue, deriveCatalog, describeIdShape, describeNameShape, discoveredCatalog, fallbackModelsFor, hashTraeRawChatArg, identityHeaders, inject, legacyTraeOwnAuthPath, maskUserPath, mergeTraeModelSources, name, nextRegionEnabled, nextRegionSlots, normalizeTraeCredential, normalizeTraeVersionCode, parseObservedModelConfig, parseReasoningCapability, parseTraeAuthValue, parseTraeCachedModel, parseTraeModelExtraConfigLogLine, parseTraeRawChatBehaviorConfig, parseTraeRemoteModel, parseTraeStorageDocument, pickTraeStorageIdentity, prepareSoloBody, probeBody, probeModelsSequentially, probeOneModel, probeTraeRawChatCapability, rawCapabilityDiagnostic, rawCapabilityFingerprint, readTraeCachedModel, readTraeCliIdentity, readTraeIdentity, refreshTraeCredential, regionEnabled, regionEnabledOf, regionOfCredential, regionOfEdition, regionOfHost, regionOfTraeProvider, regionOfTraeStatusUrl, regionOfUserRegion, regionStateOf, registerTraeUsageRoute, resolveTraeIdentity, resolveTraeRawRuntime, sanitizeCatalog, settingsNamespaceOf, traeEndpoint, traeInputModalities, traeModelDisplayName, traeOwnAuthPath, traeRawChatExtraInfo, traeStateDatabaseCandidates, traeStorageCandidates, traeWebUsage, traeWindowsAppNames, unwrapVolatile, unwrapVolatileDeep, withTraeRegion };