dsh-connect-trae 4.0.1 → 4.2.0

package/lib/index.js

@@ -235,12 +235,15 @@ function mergeTraeModelSources(remote, wire) {
 	for (const model of remote) {
 		const wireModel = wireById.get(displayKey(model.id)) ?? wireByName.get(displayKey(model.name));
 		const creditMultiplier = wireModel?.creditMultiplier ?? model.creditMultiplier;
+		const wireFunction = wireModel?.function ?? model.function;
+		const activityDiscount = wireModel?.activityDiscount ?? model.activityDiscount;
 		result.push({
 			id: model.id,
 			name: model.name,
 			...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
 			...model.maxContextWindow === void 0 ? {} : { maxContextWindow: model.maxContextWindow },
 			...creditMultiplier === void 0 ? {} : { creditMultiplier },
+			...activityDiscount === void 0 ? {} : { activityDiscount },
 			input: ["text"],
 			...wireModel?.maxTokens === void 0 ? {} : { maxTokens: wireModel.maxTokens },
 			...model.multimodal === void 0 ? {} : { multimodal: model.multimodal },
@@ -250,12 +253,45 @@ function mergeTraeModelSources(remote, wire) {
 				reasoningEfforts: Object.fromEntries(model.reasoning.supported.map((effort) => [effort, effort === "low" ? "light" : effort === "xhigh" ? "extra_high" : "high"]))
 			},
 			...wireModel !== void 0 && wireModel.id !== "" && wireModel.id !== model.id ? { wireConfigName: wireModel.id } : {},
-			...wireModel?.function === void 0 ? {} : { wireFunction: wireModel.function }
+			...wireFunction === void 0 ? {} : { wireFunction }
 		});
 	}
 	return result;
 }
 /**
+* Demote a NON-chat `wireFunction` to "no function", keeping the row.
+*
+* A row pinned to an IDE/Remote-agent roster — `solo_agent`, `builder_v3` — is
+* not callable through `llm_utils_chat` by THAT function: asking answers
+* 4011/4001 (measured 2026-10-01, issue #19). Dropping the row is not the fix,
+* though, and was a regression: a model can carry a non-chat function for a
+* reason that says nothing about its chat availability. The directory lists
+* `gpt-5.5`, `gpt-5.6-*`, `gpt-6-astra`, `glm-5.2`, `kimi-k2.7-code`,
+* `Dola-Seed-2.0-Code` and `deepseek-v4-flash-0731` under `solo_agent` ALONE
+* (docs/ISSUE19_DIAGNOSIS.md), yet the same models answer normally under
+* `solo_work_remote` / `solo_work_lite` / `solo_agent_remote` — they are
+* exactly the models issue #19's fix was opened to expose. Dropping them
+* re-hid the whole set on the restricted networks this fallback targets, where
+* the wire roster is empty and the directory group is the only attribution.
+*
+* Keeping the row with the function CLEARED preserves both facts: the model
+* stays visible (issue #19), and the bridge sends the region's DEFAULT chat
+* function instead of one that is guaranteed to refuse. That is the pre-change
+* behaviour for these rows — a genuinely unreachable model still fails with a
+* readable upstream message rather than a silent absence.
+*
+* `chatFunctions` must be the region's own `TRAE_DIRECTORY_FUNCTIONS` list —
+* the functions `llm_utils_chat` accepts. Callers should log the demoted rows:
+* "which function did it lose, and why" deserves an answer.
+*/
+function withChatCallableFunctions(rows, chatFunctions) {
+	return rows.map((model) => {
+		if (model.wireFunction === void 0 || chatFunctions.includes(model.wireFunction)) return model;
+		const { wireFunction: _demoted, ...withoutFunction } = model;
+		return withoutFunction;
+	});
+}
+/**
 * Apply the saved local budget. Trae advertises two windows per model (dev and
 * Max), so the budget may only switch a model to its own advertised Max value —
 * never to a fabricated number. Everything else keeps the dev window.
@@ -276,7 +312,9 @@ function discoveredCatalog(models) {
 		...model.maxContextWindow === void 0 ? {} : { maxContextWindow: model.maxContextWindow },
 		input: ["text"],
 		...model.creditMultiplier === void 0 ? {} : { creditMultiplier: model.creditMultiplier },
+		...model.activityDiscount === void 0 ? {} : { activityDiscount: model.activityDiscount },
 		...model.multimodal === void 0 ? {} : { multimodal: model.multimodal },
+		...model.function === void 0 ? {} : { wireFunction: model.function },
 		reasoningSupported: model.reasoningSupported,
 		...model.reasoning === void 0 ? {} : {
 			reasoning: model.reasoning,
@@ -3703,6 +3741,97 @@ function traeEndpoint(baseUrl, path) {
 	return `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
 }
 //#endregion
+//#region src/promo.ts
+function record$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function percent(value) {
+	const parsed = finite(value);
+	return parsed !== void 0 && parsed > 0 && parsed < 100 ? parsed : void 0;
+}
+function ratePair(raw) {
+	const entry = record$1(raw);
+	if (entry === void 0) return {};
+	const beforeRate = finite(entry["before_consumption_rate"]);
+	const rate = finite(entry["consumption_rate"]) ?? finite(entry["after_consumption_rate"]);
+	const discountPercent = percent(entry["discount"]);
+	return {
+		...beforeRate === void 0 || beforeRate <= 0 ? {} : { beforeRate },
+		...rate === void 0 || rate <= 0 ? {} : { rate },
+		...discountPercent === void 0 ? {} : { discountPercent }
+	};
+}
+function windows(raw) {
+	const list = Array.isArray(raw) ? raw : [];
+	const parsed = [];
+	for (const item of list) {
+		const entry = record$1(item);
+		if (entry === void 0) continue;
+		const weekdays = Array.isArray(entry["weekdays"]) ? entry["weekdays"].filter((day) => Number.isInteger(day) && day >= 1 && day <= 7) : [];
+		const startMinute = finite(entry["start_minute"]);
+		const endMinute = finite(entry["end_minute"]);
+		if (weekdays.length === 0 || startMinute === void 0 || endMinute === void 0) continue;
+		if (startMinute < 0 || startMinute > 1439 || endMinute < 1 || endMinute > 1440) continue;
+		if (startMinute >= endMinute) continue;
+		parsed.push({
+			weekdays,
+			startMinute,
+			endMinute
+		});
+	}
+	return parsed;
+}
+/**
+* Parse one `activity_discount` document.
+*
+* `value` may be the already-parsed object (both call sites hand us the parent
+* object) or the raw JSON string; anything without `enable: true` reads as "no
+* promotion" rather than as a rule we might later misjudge.
+*/
+function parseTraeActivityDiscount(value) {
+	let source = value;
+	if (typeof source === "string") {
+		if (source === "") return void 0;
+		try {
+			source = JSON.parse(source);
+		} catch {
+			return;
+		}
+	}
+	const raw = record$1(source);
+	if (raw === void 0 || raw["enable"] !== true) return void 0;
+	const data = record$1(raw["data"]);
+	if (data === void 0) return void 0;
+	const subKey = typeof raw["subKey"] === "string" && raw["subKey"] !== "" ? raw["subKey"] : void 0;
+	const currentRaw = record$1(data["current"]);
+	const currentType = typeof currentRaw?.["discount_type"] === "string" ? currentRaw["discount_type"] : void 0;
+	const current = currentRaw === void 0 ? void 0 : {
+		...ratePair(currentRaw),
+		...currentType === void 0 ? {} : { discountType: currentType }
+	};
+	const memberRaw = data["member"];
+	const member = record$1(memberRaw) === void 0 ? void 0 : ratePair(memberRaw);
+	const subsidyRaw = data["subsidy"];
+	const subsidy = record$1(subsidyRaw) === void 0 ? void 0 : ratePair(subsidyRaw);
+	const offPeakRaw = record$1(data["off_peak"]);
+	const offPeak = offPeakRaw === void 0 ? void 0 : {
+		...ratePair(offPeakRaw),
+		...typeof offPeakRaw["time_zone"] === "string" && offPeakRaw["time_zone"] !== "" ? { timeZone: offPeakRaw["time_zone"] } : {},
+		windows: windows(offPeakRaw["time_windows"])
+	};
+	const parsed = {
+		...subKey === void 0 ? {} : { subKey },
+		...current === void 0 ? {} : { current },
+		...member === void 0 ? {} : { member },
+		...offPeak === void 0 ? {} : { offPeak },
+		...subsidy === void 0 ? {} : { subsidy }
+	};
+	return parsed.current === void 0 && parsed.member === void 0 && parsed.offPeak === void 0 && parsed.subsidy === void 0 ? void 0 : parsed;
+}
+//#endregion
 //#region src/reasoning.ts
 const TRAE_REASONING_EFFORTS = [
 	"minimal",
@@ -3870,6 +3999,29 @@ function prepareSoloBody(source, defaultModel = "glm-5.2", functionName) {
 	return JSON.stringify(body);
 }
 /**
+* Parse this row's `display_contact_config` document.
+*
+* It is a *string* holding a second JSON document, and three different readers
+* (the credit multiplier, the promotion rule, and whatever upstream adds next)
+* need it — so it is decoded once here rather than three times.
+*/
+function wireContactConfig(config) {
+	const raw = config["display_contact_config"];
+	if (typeof raw !== "string" || raw === "") return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+	return parsed;
+}
+/** The promotion rule from `display_contact_config`, when the row carries one. */
+function wireActivityDiscount(config) {
+	return parseTraeActivityDiscount(wireContactConfig(config)?.["activity_discount"]);
+}
+/**
 * Read the effective credit multiplier from a `get_detail_param` row.
 *
 * The rate the Trae IDE renders lives in `display_contact_config` — a *string*
@@ -3885,15 +4037,8 @@ function prepareSoloBody(source, defaultModel = "glm-5.2", functionName) {
 * field keep their bare name — parsed-but-absent, never fabricated.
 */
 function wireCreditMultiplier(config) {
-	const raw = config["display_contact_config"];
-	if (typeof raw !== "string" || raw === "") return void 0;
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return;
-	}
-	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const parsed = wireContactConfig(config);
+	if (parsed === void 0) return void 0;
 	const consumption = parsed["consumption_rate"];
 	if (typeof consumption !== "object" || consumption === null) return void 0;
 	const entry = consumption;
@@ -4001,6 +4146,7 @@ var TraeSoloUpstreamClient = class {
 				...detail
 			});
 			const creditMultiplier = wireCreditMultiplier(config);
+			const activityDiscount = wireActivityDiscount(config);
 			if (byId.has(id)) continue;
 			byId.set(id, {
 				id,
@@ -4009,6 +4155,7 @@ var TraeSoloUpstreamClient = class {
 				...maxTokens === void 0 ? {} : { maxTokens },
 				...reasoning === void 0 ? {} : { reasoning },
 				...creditMultiplier === void 0 ? {} : { creditMultiplier },
+				...activityDiscount === void 0 ? {} : { activityDiscount },
 				function: directoryFunction
 			});
 		}
@@ -4702,8 +4849,9 @@ var TraeSoloBridge = class {
 			if (typeof input["model"] === "string" && input["model"] !== "") model = input["model"];
 			const entryKey = model.trim().toLowerCase();
 			const entry = this.catalog?.current().find((item) => item.id === model || item.id.trim().toLowerCase() === entryKey);
-			const fromCatalog = entry?.wireConfigName === void 0 ? void 0 : {
-				configName: entry.wireConfigName,
+			const catalogConfigName = entry?.wireConfigName;
+			const fromCatalog = entry === void 0 || catalogConfigName === void 0 && entry.wireFunction === void 0 ? void 0 : {
+				configName: catalogConfigName ?? entry.id,
 				...entry.wireFunction === void 0 ? {} : { function: entry.wireFunction }
 			};
 			const fromResolver = this.wireResolver?.(model) ?? this.wireResolver?.(entry?.name ?? "");
@@ -4718,11 +4866,28 @@ var TraeSoloBridge = class {
 			* directory, so borrowing its function is safe exactly when both sources
 			* agree on the wire config_name; a disagreement means the resolver found
 			* a different row and its function would be wrong.
+			*
+			* The MIRROR case is equally load-bearing and is the reason the row's own
+			* id is not accepted as its wire spelling: a row that carries only the
+			* FUNCTION (`wireConfigName` absent) has no config_name of its own, and
+			* its display id is the wrong-cased spelling of the wire name in exactly
+			* the cases issue #38 is about. The resolver's config_name is then the
+			* only correct one, so it must win for the NAME while the row keeps
+			* winning for the FUNCTION.
 			*/
 			const sameWireConfig = fromCatalog !== void 0 && fromResolver !== void 0 && fromCatalog.configName.toLowerCase() === fromResolver.configName.toLowerCase();
+			/**
+			* Whether the catalog row knows its own wire `config_name` (as opposed to
+			* only carrying the display id plus a function). Only such a row may
+			* decide the name on its own.
+			*/
+			const catalogKnowsConfigName = catalogConfigName !== void 0;
 			const target = fromCatalog !== void 0 && fromCatalog.function === void 0 && sameWireConfig && fromResolver !== void 0 ? {
 				configName: fromCatalog.configName,
 				...fromResolver.function === void 0 ? {} : { function: fromResolver.function }
+			} : fromCatalog !== void 0 && !catalogKnowsConfigName && fromResolver !== void 0 ? {
+				configName: fromResolver.configName,
+				...fromCatalog.function === void 0 ? {} : { function: fromCatalog.function }
 			} : fromCatalog ?? fromResolver;
 			/**
 			* Last line of defence: the discovered row's own id.
@@ -4786,8 +4951,15 @@ const EFFORT_MAP = {
 	high: "high",
 	extra_high: "xhigh"
 };
-/** Parse only capabilities explicitly advertised by Trae's remote model API. */
-function parseTraeRemoteModel(value) {
+/**
+* Parse only capabilities explicitly advertised by Trae's remote model API.
+*
+* @param groupFunction The `data.list[].function` of the group this raw row
+* was read from; attached verbatim so downstream can replay the model's own
+* function instead of the `llm_utils_chat` default (see
+* {@link TraeDiscoveredModel.function}).
+*/
+function parseTraeRemoteModel(value, groupFunction) {
 	const raw = record(value);
 	if (raw === void 0 || typeof raw.name !== "string" || raw.name === "") return void 0;
 	const context = record(raw.context_window_tokens);
@@ -4798,6 +4970,7 @@ function parseTraeRemoteModel(value) {
 	const consumptionData = record(consumption?.["data"]);
 	const creditMultiplier = consumption?.["enable"] === true ? finitePositive(consumptionData?.["rate"]) : void 0;
 	const reasoningSupported = record(features?.["reasoning"])?.["enable"] === true;
+	const activityDiscount = parseTraeActivityDiscount(features?.["activity_discount"]);
 	const reasoningConfig = record(raw.reasoning_effort_config);
 	const supported = (Array.isArray(reasoningConfig?.["options"]) ? reasoningConfig["options"] : []).flatMap((option) => {
 		if (typeof option !== "string") return [];
@@ -4814,11 +4987,13 @@ function parseTraeRemoteModel(value) {
 		...dev === void 0 ? {} : { contextWindow: dev },
 		...max === void 0 ? {} : { maxContextWindow: max },
 		...creditMultiplier === void 0 ? {} : { creditMultiplier },
+		...activityDiscount === void 0 ? {} : { activityDiscount },
 		reasoningSupported,
 		...supported.length === 0 ? {} : { reasoning: {
 			supported,
 			...defaultEffort === void 0 ? {} : { defaultEffort }
-		} }
+		} },
+		...groupFunction === void 0 || groupFunction === "" ? {} : { function: groupFunction }
 	};
 }
 //#endregion
@@ -4885,8 +5060,24 @@ const TRAE_REMOTE_DIRECTORY_FUNCTIONS = {
 	]
 };
 /**
-* Of two rows for the SAME model id, the one that advertises the stronger
-* capacity (issue #23).
+* Backup bases for the model directory, in try order after the official base.
+*
+* In restricted (proxy-sandboxed) networks the official catalog host
+* `solo.trae.cn` is behind a CONNECT rejection while the region's chat gateway
+* stays reachable — and that gateway serves the SAME `/api/remote/v1/models`
+* endpoint with an identical response shape (verified against
+* `https://trae-api-cn.mchost.guru/api/remote/v1` 2026-10-20; `chat` already
+* carries `/api/remote/v1`'s parent in {@link REGION_GATEWAYS}). The backup is
+* therefore derived from the region's chat base, mirrored on the remote path;
+* `ai` shares a single host for chat and remote, so it yields no candidate and
+* keeps its single-host behavior. An explicit `baseUrl` disables the chain.
+*/
+function traeSoloRemoteFallbackBases(region, officialBase) {
+	const backupBase = `${REGION_GATEWAYS[region].chat}/api/remote/v1`;
+	return backupBase === officialBase ? [] : [backupBase];
+}
+/**
+* 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
 * per group, with the group order varying between calls. Keeping the strongest
@@ -4894,6 +5085,9 @@ const TRAE_REMOTE_DIRECTORY_FUNCTIONS = {
 * LEXICOGRAPHIC and must be applied all the way down, or ordering leaks back in
 * at the next field:
 *
+*  0. the kept row must also carry the promotional rule, which the groups
+*     disagree about — the rule is copied onto the capacity winner, and of two
+*     rules the one that can say more wins (see the comment in the body);
 *  1. a row with a Max tier beats one without (`maxContextWindow` is only set
 *     when the group reported `max_mode: true` with a positive max);
 *  2. two Max rows: the larger max wins;
@@ -4911,6 +5105,52 @@ const TRAE_REMOTE_DIRECTORY_FUNCTIONS = {
 */
 function preferStrongerRow(candidate, incumbent) {
 	if (incumbent === void 0) return candidate;
+	const winner = strongerCapacityRow(candidate, incumbent);
+	const rule = richerRule(candidate.activityDiscount, incumbent.activityDiscount);
+	if (rule === void 0 || rule === winner.activityDiscount) return winner;
+	return {
+		...winner,
+		activityDiscount: rule
+	};
+}
+/**
+* Step 0's tie-break: of two rules for the same model id, the one that can say
+* more about this moment. Every parsed rule already passed `enable: true` (see
+* parseTraeActivityDiscount), so the ranking is: an upstream "right now"
+* discount first, then the rule covering more clock. Two rules that rank EQUAL
+* are compared by their canonical content, so the answer depends on the rule
+* documents and never on which group the gateway answered first (issue #23).
+*/
+function richerRule(candidate, incumbent) {
+	if (candidate === void 0) return incumbent;
+	if (incumbent === void 0) return candidate;
+	const score = (rule) => {
+		return (rule.current !== void 0 && (rule.current.discountType ?? "none") !== "none" ? 1 : 0) * 1e3 + (rule.offPeak?.windows.length ?? 0);
+	};
+	const candidateScore = score(candidate);
+	const incumbentScore = score(incumbent);
+	if (candidateScore !== incumbentScore) return candidateScore > incumbentScore ? candidate : incumbent;
+	return canonicalRule(candidate) < canonicalRule(incumbent) ? candidate : incumbent;
+}
+/**
+* Content-only identity for two rules that scored the same.
+*
+* The score cannot distinguish, say, two `current: none` rules with two windows
+* each in different hours — and keeping "whichever arrived first" would let the
+* gateway's group order decide whether tonight's badge appears. Key order is
+* normalised (the objects are ours, but a caller may hand us a literal), so
+* equal documents compare equal and the incumbent is kept unchanged.
+*/
+function canonicalRule(rule) {
+	const canonical = (value) => {
+		if (Array.isArray(value)) return value.map((item) => canonical(item));
+		if (typeof value !== "object" || value === null) return value;
+		return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => [key, canonical(item)]));
+	};
+	return JSON.stringify(canonical(rule));
+}
+/** Steps 1–4 of the documented order: the row advertising the stronger capacity. */
+function strongerCapacityRow(candidate, incumbent) {
 	const candidateMax = candidate.maxContextWindow;
 	const incumbentMax = incumbent.maxContextWindow;
 	if (candidateMax !== void 0 && incumbentMax === void 0) return candidate;
@@ -4942,10 +5182,39 @@ function remoteDressing(region) {
 * This deliberately has no chat/session method: the Remote session protocol
 * only exposes a final answer and cannot preserve DSH's structured tool loop.
 */
-var TraeSoloRemoteCatalogClient = class {
+var TraeSoloRemoteCatalogClient = class TraeSoloRemoteCatalogClient {
 	options;
 	fetchImpl;
 	baseUrl;
+	/**
+	* The last base that answered the directory with a NON-EMPTY catalog in this
+	* process.
+	*
+	* A proxy-blocked network pays the failing official attempt on EVERY refresh
+	* otherwise, so a backup that has served the catalog is tried first on later
+	* refreshes. Putting the official base "second" is NOT enough to re-probe it:
+	* the loop returns on the first success, so a backup that keeps answering
+	* means the official base is never asked again. The official host is
+	* therefore re-probed on a COOLDOWN instead (see {@link OFFICIAL_RETRY_MS}):
+	* while the cooldown runs the backup is used and the official host is
+	* skipped; when it expires the official host is tried FIRST again, so a
+	* healed network takes over within one cooldown window rather than never.
+	*/
+	lastSuccessfulBase;
+	/**
+	* When the official base may be probed again after a transport/5xx failure,
+	* as epoch milliseconds (0 = probe it on the next refresh).
+	*/
+	officialRetryAtMs = 0;
+	/**
+	* How long a failing official host is skipped before it is re-probed.
+	*
+	* Long enough that a blocked network stops paying the failing attempt on
+	* every refresh (the point of the fallback), short enough that a healed
+	* network takes over without a restart. Each probe costs one connect timeout
+	* (30 s) in the worst case, so 5 minutes bounds that to ~1 attempt per 5 min.
+	*/
+	static OFFICIAL_RETRY_MS = 3e5;
 	constructor(options) {
 		this.options = options;
 		this.fetchImpl = options.fetchImpl ?? fetch;
@@ -4966,24 +5235,183 @@ var TraeSoloRemoteCatalogClient = class {
 	}
 	async fetchModels(signal) {
 		const region = regionOfCredential(await this.options.credential());
-		const base = this.baseUrl ?? REGION_GATEWAYS[region].remote;
+		const officialBase = this.baseUrl ?? REGION_GATEWAYS[region].remote;
 		const headers = await this.headers(region);
 		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 ?? [];
+		let lastError;
+		let emptyError;
+		for (const base of this.candidateBases(region, officialBase)) {
+			let response;
+			try {
+				response = await this.fetchImpl(`${base}/models?functions=${functions}`, {
+					headers,
+					signal: signal ?? AbortSignal.timeout(3e4)
+				});
+			} catch (error) {
+				if (signal?.aborted) throw error;
+				if (base === officialBase) this.officialRetryAtMs = Date.now() + TraeSoloRemoteCatalogClient.OFFICIAL_RETRY_MS;
+				lastError = error;
+				continue;
+			}
+			if (!response.ok) {
+				if (response.status < 500) throw new Error(`SOLO remote models returned HTTP ${response.status}`);
+				if (base === officialBase) this.officialRetryAtMs = Date.now() + TraeSoloRemoteCatalogClient.OFFICIAL_RETRY_MS;
+				lastError = /* @__PURE__ */ new Error(`SOLO remote models returned HTTP ${response.status}`);
+				continue;
+			}
+			const json = await response.json();
+			const models = this.collectModels(region, json.data?.list ?? []);
+			if (models.length === 0) {
+				emptyError = /* @__PURE__ */ new Error("SOLO remote models response contained no models");
+				lastError = emptyError;
+				continue;
+			}
+			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;
+		}
+		if (emptyError !== void 0) throw emptyError;
+		throw lastError instanceof Error ? lastError : new Error(String(lastError));
+	}
+	/**
+	* Bases to try for one refresh, in order.
+	*
+	* While the official host is in its post-failure cooldown the backup hosts go
+	* first and the official base is kept LAST as a final chance (so a still-down
+	* backup does not fail the whole refresh while the official host happens to
+	* be reachable). Once the cooldown expires the official base is first again:
+	* that is what lets a healed network take over — the loop returns on the
+	* first success, so simply placing the official base second never re-probes
+	* it while a backup keeps answering.
+	*/
+	candidateBases(region, officialBase) {
+		if (this.baseUrl !== void 0) return [officialBase];
+		const fallbacks = traeSoloRemoteFallbackBases(region, officialBase);
+		if (this.officialRetryAtMs <= Date.now()) return [officialBase, ...fallbacks];
+		const remembered = this.lastSuccessfulBase;
+		return [
+			...remembered === void 0 ? [] : [remembered],
+			...fallbacks.filter((base) => base !== remembered),
+			officialBase
+		];
+	}
+	/**
+	* Union every returned group into one deduplicated list, attributing each
+	* model to the CHAT function the directory listed it under.
+	*
+	* Each group is a roster the gateway is willing to serve; a model listed by
+	* any of them is a model the IDE can offer, and the wire join downstream (see
+	* mergeTraeModelSources) is what decides whether it is actually callable.
+	* Restricting this to `solo_agent_remote` dropped the nine models issue #19
+	* was opened about.
+	*
+	* FUNCTION ATTRIBUTION (2026-10-20): a group is the authoritative statement
+	* of which SOLO function a model belongs to — the accepted `config_name` is
+	* isolated per function (glm-5.3 answers `solo_work_remote` and 4001s under
+	* `solo_work_lite`). The wire join prefers its own `get_detail_param`
+	* function and falls back to this one when the roster says nothing, which
+	* restricted networks often do (measured: an empty `config_info_list` for
+	* every chat function but `chat_v3`).
+	*
+	* ONLY CHAT-CAPABLE GROUPS ARE ATTRIBUTED. `solo_agent` and `builder_v3` are
+	* IDE/Remote-agent rosters: asking `llm_utils_chat` with either answers
+	* 4011/4001 (measured 2026-10-01 on a live credential, issue #19). A model
+	* that appears ONLY there is still not uncallable, though — the SAME models
+	* answered normally under `solo_work_remote` / `solo_work_lite` /
+	* `solo_agent_remote` (measured the same day, see `TRAE_DIRECTORY_FUNCTIONS`
+	* in solo.ts), and the default function is what has always reached them:
+	* they are exactly the nine models issue #19's fix exposes (`gpt-5.5`,
+	* `gpt-5.6-*`, `gpt-6-astra`, `glm-5.2`, `kimi-k2.7-code`,
+	* `Dola-Seed-2.0-Code`, `deepseek-v4-flash-0731` — docs/ISSUE19_DIAGNOSIS.md).
+	* Stamping `solo_agent` onto such a row makes every call 4011; DROPPING it
+	* undoes issue #19 for exactly the restricted-network users this fallback
+	* exists for. It therefore keeps NO function, the bridge falls back to the
+	* default chat function exactly as before this change, and a refusal (if the
+	* model really is unreachable) comes back as a readable upstream message
+	* instead of a silent absence.
+	*
+	* CHAT GROUPS ARE WALKED IN `TRAE_DIRECTORY_FUNCTIONS` ORDER, not in the
+	* request's `functions=` order. That list is the measured precedence of which
+	* function serves a shared config, and it is the order the wire roster itself
+	* collects in (`solo.ts`) — walking a different order would attribute the
+	* same model differently depending on whether the roster answered, and the
+	* difference is not cosmetic: `solo_agent_remote` sits after the two
+	* `solo_work_*` functions because it is behind the Remote plan gate, so
+	* preferring it can turn a free-tier model into a `1005 requires a paid
+	* plan` refusal.
+	*
+	* A model appears in SEVERAL groups and the groups disagree about its
+	* capacity, so dedupe keeps the MOST CAPABLE row rather than the first one
+	* (issue #23). "First wins" assumed the group order was stable; measured
+	* 2026-10-05 on a live CN credential it is not — five calls returned five
+	* different orders — so the published window became a coin flip:
+	* `Doubao-Seed-2.1-Pro` came back as `116000`/no-Max (`builder_v3`), or
+	* `256000`/no-Max (`solo_work_*`), or `256000`/`1000000` (`chat_v3`,
+	* `solo_agent*`) depending on which group answered first. The Max tier is
+	* the one users enable in the IDE, and `applyContextBudgets` can only raise
+	* a window to `maxContextWindow` — so losing that field silently capped
+	* every configured 1M model at 256K or less, and DSH compressed far earlier
+	* than the chosen budget implied.
+	*
+	* Ordering rule: a row advertising a Max tier beats one that does not, a
+	* larger Max wins over a smaller one, and with no Max on either side the
+	* wider dev window wins. Every row for one id carries the same
+	* `multimodal` / `reasoning` / credit facts (verified the same day), so
+	* choosing on capacity loses no capability. The result no longer depends on
+	* the gateway's group order — and the FUNCTION does not either: the winning
+	* row's capacity may come from a later group, but the separately-tracked
+	* attribution is re-asserted on it.
+	*/
+	collectModels(region, groups) {
 		const byId = /* @__PURE__ */ new Map();
-		for (const group of groups) for (const raw of group.models ?? []) {
-			const model = parseTraeRemoteModel(raw);
-			if (model === void 0) continue;
-			byId.set(model.id, preferStrongerRow(model, byId.get(model.id)));
+		const attributedFunction = /* @__PURE__ */ new Map();
+		/**
+		* The function a row may be stamped with: only a CHAT function. A non-chat
+		* roster is not "the function this model belongs to" in any sense the chat
+		* route can use (see the method note above), so it is not recorded at all.
+		*/
+		const chatFunctions = new Set(TRAE_DIRECTORY_FUNCTIONS[region]);
+		const attribution = (groupFunction) => groupFunction !== void 0 && chatFunctions.has(groupFunction) ? groupFunction : void 0;
+		const addGroup = (groupFunction, raws) => {
+			const fn = attribution(groupFunction);
+			for (const raw of raws) {
+				const model = parseTraeRemoteModel(raw, fn);
+				if (model === void 0) continue;
+				if (fn !== void 0 && !attributedFunction.has(model.id)) attributedFunction.set(model.id, fn);
+				byId.set(model.id, preferStrongerRow(model, byId.get(model.id)));
+			}
+		};
+		/**
+		* Every group the gateway sent, bucketed BY FUNCTION NAME and kept as a
+		* LIST.
+		*
+		* A name→group `Map` would keep only the LAST group of a name and silently
+		* drop the models of every earlier one: nothing documents that the gateway
+		* sends a function at most once, and the pre-change code unioned every
+		* element of `data.list`, so a repeated name lost real models. Bucketing
+		* keeps that union while the walk below still imposes a deterministic
+		* order.
+		*/
+		const byFunction = /* @__PURE__ */ new Map();
+		for (const group of groups) {
+			const key = group.function ?? "";
+			const bucket = byFunction.get(key);
+			if (bucket === void 0) byFunction.set(key, [group]);
+			else bucket.push(group);
 		}
-		const models = [...byId.values()];
-		if (models.length === 0) throw new Error("SOLO remote models response contained no models");
-		return models;
+		for (const name of TRAE_DIRECTORY_FUNCTIONS[region]) for (const group of byFunction.get(name) ?? []) addGroup(name, group.models ?? []);
+		for (const [name, bucket] of byFunction) {
+			if (chatFunctions.has(name)) continue;
+			for (const group of bucket) addGroup(name, group.models ?? []);
+		}
+		return [...byId.values()].map((model) => {
+			const fn = attributedFunction.get(model.id);
+			return fn === void 0 || fn === model.function ? model : {
+				...model,
+				function: fn
+			};
+		});
 	}
 };
 //#endregion
@@ -8490,7 +8918,8 @@ const modelConfig = z.object({
 	creditMultiplier: z.number(),
 	wireFunction: z.string(),
 	wireConfigName: z.string(),
-	multimodal: z.boolean()
+	multimodal: z.boolean(),
+	activityDiscount: z.any()
 });
 /**
 * One panel's saved state. Panels are keyed `cn | enterprise | ai` — see
@@ -8756,7 +9185,10 @@ function apply(ctx, config) {
 			...panel === "enterprise" ? { route: "enterprise" } : {},
 			log: (message, detail) => ctx.logger.warn(message, detail)
 		});
-		const remoteCatalog = new TraeSoloRemoteCatalogClient({ credential: () => store.resolve() });
+		const remoteCatalog = new TraeSoloRemoteCatalogClient({
+			credential: () => store.resolve(),
+			log: (message, detail) => ctx.logger.warn(message, detail)
+		});
 		const wireResolver = (displayId) => wire.byId.get(displayId) ?? wire.byName.get(displayId.trim().toLowerCase());
 		/**
 		* One client + bridge per provider id.
@@ -8909,18 +9341,24 @@ function apply(ctx, config) {
 			},
 			discoverModels: async (signal) => {
 				const merged = mergeTraeModelSources(await withDirectoryRetry(() => remoteCatalog.fetchModels(signal)), await solo.fetchModels(signal));
-				wire.callableKeys.clear();
+				const callable = withChatCallableFunctions(merged, TRAE_DIRECTORY_FUNCTIONS[region]);
+				const chatFunctions = TRAE_DIRECTORY_FUNCTIONS[region];
 				for (const model of merged) {
+					if (model.wireFunction === void 0 || chatFunctions.includes(model.wireFunction)) continue;
+					ctx.logger.warn(`model directory row is pinned to a non-chat function and will be called through the default chat function instead: ${model.id} (pinned to function ${model.wireFunction})`);
+				}
+				wire.callableKeys.clear();
+				for (const model of callable) {
 					wire.callableKeys.add(model.id.trim().toLowerCase());
 					wire.callableKeys.add(model.name.trim().toLowerCase());
 				}
-				wire.resolved = merged.length > 0;
-				const wireTargets = wireTargetsOf(merged);
+				wire.resolved = callable.length > 0;
+				const wireTargets = wireTargetsOf(callable);
 				wire.byId = wireTargets.byId;
 				wire.byName = wireTargets.byName;
 				latestDiscovery.length = 0;
-				latestDiscovery.push(...merged);
-				return merged;
+				latestDiscovery.push(...callable);
+				return callable;
 			},
 			/**
 			* One-click availability test. The ids come from the card, so each one is