dsh-connect-trae 1.0.0

package/lib/index.js

@@ -0,0 +1,3118 @@
+import z from "@deepseek-ai/schemastery";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { createProvider } from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
+import { readFile, rm, stat } from "node:fs/promises";
+import { createDecipheriv, createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { dirname, join } from "node:path";
+import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { cpus, homedir, release } from "node:os";
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/adapter.ts
+const TRAE_PROVIDER = "trae";
+const TRAE_STREAM_IDLE_TIMEOUT_MS = 3e5;
+const INERT_AUTH = {
+	credentials: {
+		async read() {},
+		async list() {
+			return [];
+		},
+		async modify() {
+			throw new Error("dsh-connect-trae has no pi-ai credential lifecycle");
+		},
+		async delete() {}
+	},
+	authContext: {
+		async env() {},
+		async fileExists() {
+			return false;
+		}
+	}
+};
+const REQUEST_IMAGE_BUDGETS = {
+	maxRequestImageBytes: 20971520,
+	requestImagePixelBudget: 4194304,
+	requestImageMaxBytes: 1048576
+};
+function toPiModel(info, baseUrl) {
+	return {
+		id: info.id,
+		name: info.name,
+		api: "openai-completions",
+		provider: TRAE_PROVIDER,
+		baseUrl,
+		input: [...info.input ?? ["text"]],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		reasoning: info.reasoningEfforts !== void 0,
+		...info.reasoningEfforts === void 0 ? {} : { thinkingLevelMap: {
+			off: null,
+			minimal: null,
+			low: info.reasoningEfforts.low ?? null,
+			medium: null,
+			high: info.reasoningEfforts.high ?? null,
+			xhigh: info.reasoningEfforts.xhigh ?? null,
+			max: null
+		} },
+		...info.contextWindow === void 0 ? {} : { contextWindow: info.contextWindow },
+		...info.maxTokens === void 0 ? {} : { maxTokens: info.maxTokens },
+		compat: { supportsReasoningEffort: info.reasoningEfforts !== void 0 }
+	};
+}
+function createTraeAdapter(options) {
+	const buildModels = () => options.catalog.current().map((info) => toPiModel(info, `${options.shim.baseUrl()}/v1`));
+	const provider = {
+		...createProvider({
+			id: TRAE_PROVIDER,
+			name: "Trae",
+			auth: { apiKey: {
+				name: "Trae loopback secret",
+				async resolve({ credential }) {
+					const apiKey = credential?.key;
+					return apiKey === void 0 || apiKey.length === 0 ? void 0 : {
+						auth: { apiKey },
+						source: "Trae loopback"
+					};
+				}
+			} },
+			models: buildModels(),
+			api: openAICompletionsApi()
+		}),
+		getModels: () => buildModels()
+	};
+	const profile = {
+		provider: TRAE_PROVIDER,
+		displayName: "Trae",
+		streamIdleTimeoutMs: TRAE_STREAM_IDLE_TIMEOUT_MS,
+		retryPolicy: resolveRetryPolicy(void 0, "dsh-connect-trae retryPolicy"),
+		configuredMaxTokens: /* @__PURE__ */ new Map(),
+		...REQUEST_IMAGE_BUDGETS,
+		piProvider: provider
+	};
+	let profiles = /* @__PURE__ */ new Map([[TRAE_PROVIDER, profile]]);
+	return {
+		adapter: new PiAiAdapter({
+			profiles: () => profiles,
+			auth: INERT_AUTH,
+			resolveApiKey: async () => options.shim.token(),
+			...options.resolveAttachments === void 0 ? {} : { resolveAttachments: options.resolveAttachments }
+		}),
+		invalidate() {
+			profiles = /* @__PURE__ */ new Map([[TRAE_PROVIDER, profile]]);
+		}
+	};
+}
+//#endregion
+//#region src/decrypt.ts
+const TRAE_AUTH_STORAGE_KEY = "iCubeAuthInfo://icube.cloudide";
+const SALT_A = Uint8Array.from([
+	82,
+	9,
+	106,
+	213,
+	48,
+	54,
+	165,
+	56,
+	191,
+	64,
+	163,
+	158,
+	129,
+	243,
+	215,
+	251,
+	124,
+	227,
+	57,
+	130,
+	155,
+	47,
+	255,
+	135,
+	52,
+	142,
+	67,
+	68,
+	196,
+	222,
+	233,
+	203,
+	84,
+	123,
+	148,
+	50,
+	166,
+	194,
+	35,
+	61,
+	238,
+	76,
+	149,
+	11,
+	66,
+	250,
+	195,
+	78,
+	8,
+	46,
+	161,
+	102,
+	40,
+	217,
+	36,
+	178,
+	118,
+	91,
+	162,
+	73,
+	109,
+	139,
+	209,
+	37
+]);
+const SALT_B = Uint8Array.from([
+	31,
+	221,
+	168,
+	51,
+	136,
+	7,
+	199,
+	49,
+	177,
+	18,
+	16,
+	89,
+	39,
+	128,
+	236,
+	95,
+	96,
+	81,
+	127,
+	169,
+	25,
+	181,
+	74,
+	13,
+	45,
+	229,
+	122,
+	159,
+	147,
+	201,
+	156,
+	239,
+	160,
+	224,
+	59,
+	77,
+	174,
+	42,
+	245,
+	176,
+	200,
+	235,
+	187,
+	60,
+	131,
+	83,
+	153,
+	97,
+	23,
+	43,
+	4,
+	126,
+	186,
+	119,
+	214,
+	38,
+	225,
+	105,
+	20,
+	99,
+	85,
+	33,
+	12,
+	125
+]);
+const SALT_C = Uint8Array.from([
+	191,
+	192,
+	216,
+	250,
+	122,
+	246,
+	220,
+	97,
+	31,
+	254,
+	98,
+	27,
+	8,
+	72,
+	71,
+	176,
+	135,
+	99,
+	96,
+	18,
+	127,
+	101,
+	203,
+	104,
+	211,
+	102,
+	191,
+	125,
+	37,
+	72,
+	150,
+	156,
+	51,
+	229,
+	121,
+	35,
+	17,
+	153,
+	141,
+	177,
+	110,
+	131,
+	150,
+	128,
+	172,
+	255,
+	254,
+	6,
+	18,
+	140,
+	55,
+	62,
+	236,
+	249,
+	135,
+	64,
+	135,
+	12,
+	117,
+	4,
+	89,
+	149,
+	168,
+	209
+]);
+const SALT_D = Uint8Array.from([
+	246,
+	204,
+	26,
+	232,
+	232,
+	70,
+	129,
+	109,
+	223,
+	146,
+	169,
+	242,
+	23,
+	241,
+	105,
+	145,
+	50,
+	196,
+	165,
+	42,
+	254,
+	120,
+	3,
+	54,
+	244,
+	207,
+	209,
+	85,
+	53,
+	6,
+	138,
+	106,
+	175,
+	148,
+	31,
+	204,
+	186,
+	186,
+	165,
+	182,
+	87,
+	142,
+	49,
+	10,
+	39,
+	110,
+	26,
+	154,
+	86,
+	56,
+	173,
+	125,
+	18,
+	64,
+	198,
+	225,
+	99,
+	99,
+	83,
+	82,
+	191,
+	134,
+	76,
+	170
+]);
+function xor(a, b) {
+	return Buffer.from(a.map((value, index) => value ^ (b[index] ?? 0)));
+}
+function encryptionType(header) {
+	if (header.equals(Buffer.from([
+		116,
+		99,
+		5,
+		16,
+		0,
+		0
+	]))) return "aes";
+	if (header.equals(Buffer.from([
+		18,
+		57,
+		32,
+		32,
+		2,
+		3
+	]))) return "aes-private";
+	throw new Error("unsupported Trae auth encryption header");
+}
+function decryptTraeStorageValue(encoded) {
+	const buffer = Buffer.from(encoded, "base64");
+	if (buffer.length <= 102) throw new Error("Trae auth ciphertext is too short");
+	const type = encryptionType(buffer.subarray(0, 6));
+	const random = buffer.subarray(6, 38);
+	const encrypted = buffer.subarray(38);
+	const salt = type === "aes-private" ? xor(SALT_C, SALT_D) : xor(SALT_A, SALT_B);
+	const first = createHash("sha512").update(random).digest();
+	const derived = createHash("sha512").update(Buffer.concat([first, salt])).digest();
+	const decipher = createDecipheriv("aes-128-cbc", derived.subarray(0, 16), derived.subarray(16, 32));
+	const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+	if (decrypted.length < 64) throw new Error("Trae auth plaintext is too short");
+	const expected = decrypted.subarray(0, 64);
+	const plaintext = decrypted.subarray(64);
+	const actual = createHash("sha512").update(plaintext).digest();
+	if (!expected.equals(actual)) throw new Error("Trae auth integrity check failed");
+	return plaintext.toString("utf8");
+}
+function parseTraeAuthValue(value) {
+	const trimmed = value.trim();
+	if (trimmed === "") throw new Error("Trae auth value is empty");
+	const plaintext = trimmed.startsWith("{") ? trimmed : decryptTraeStorageValue(trimmed);
+	return JSON.parse(plaintext);
+}
+function parseTraeStorageDocument(text) {
+	const parsed = JSON.parse(text);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("Trae storage document must be an object");
+	const value = parsed[TRAE_AUTH_STORAGE_KEY];
+	if (typeof value !== "string") throw new Error(`Trae storage document has no ${TRAE_AUTH_STORAGE_KEY}`);
+	return parseTraeAuthValue(value);
+}
+//#endregion
+//#region src/paths.ts
+const APP_NAMES = {
+	cn: "Trae CN",
+	sg: "Trae",
+	solo: "TRAE SOLO CN",
+	"solo-sg": "TRAE SOLO"
+};
+function traeStorageCandidates(platform = process.platform, home = homedir(), env = process.env) {
+	const result = [];
+	for (const edition of [
+		"cn",
+		"sg",
+		"solo",
+		"solo-sg"
+	]) {
+		const app = APP_NAMES[edition];
+		let roots;
+		if (platform === "darwin") roots = [join(home, "Library", "Application Support")];
+		else if (platform === "win32") roots = [env.APPDATA, join(home, "AppData", "Roaming")].filter((value, index, all) => typeof value === "string" && value !== "" && all.indexOf(value) === index);
+		else if (platform === "linux") roots = [env.XDG_CONFIG_HOME || join(home, ".config")];
+		else roots = [];
+		for (const root of roots) result.push({
+			edition,
+			path: join(root, app, "User", "globalStorage", "storage.json")
+		});
+	}
+	return result;
+}
+//#endregion
+//#region src/auth.ts
+const OWN_VERSION = 1;
+const TRAE_AUTH_FILENAME = ".trae-auth.json";
+function traeOwnAuthPath() {
+	return join(resolveDshHome(), TRAE_AUTH_FILENAME);
+}
+function optionalString(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function timeToMs(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return value > 0xe8d4a51000 ? value : value * 1e3;
+	if (typeof value !== "string" || value.trim() === "") return void 0;
+	const numeric = Number(value);
+	if (Number.isFinite(numeric) && numeric > 0) return numeric > 0xe8d4a51000 ? numeric : numeric * 1e3;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeTraeCredential(raw, edition, source) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+	const value = raw;
+	const accessToken = optionalString(value["token"]) ?? optionalString(value["accessToken"]);
+	if (accessToken === void 0) return void 0;
+	const expiresAtMs = timeToMs(value["expiredAt"] ?? value["expiresAt"]) ?? 0;
+	const refreshExpiresAtMs = timeToMs(value["refreshExpiredAt"] ?? value["refreshExpiresAt"]);
+	const refreshToken = optionalString(value["refreshToken"]);
+	const accountName = optionalString((typeof value["account"] === "object" && value["account"] !== null && !Array.isArray(value["account"]) ? value["account"] : void 0)?.["username"]);
+	return {
+		accessToken,
+		...refreshToken === void 0 ? {} : { refreshToken },
+		userId: optionalString(value["userId"]) ?? "",
+		...accountName === void 0 ? {} : { accountName },
+		host: optionalString(value["host"]) ?? "",
+		expiresAtMs,
+		...refreshExpiresAtMs === void 0 ? {} : { refreshExpiresAtMs },
+		edition,
+		source
+	};
+}
+function traeAccountId(credential) {
+	const stable = `${credential.edition}\0${credential.userId || credential.accountName || "unknown"}`;
+	return createHash("sha256").update(stable).digest("hex").slice(0, 24);
+}
+function parseOwn(text) {
+	try {
+		const document = JSON.parse(text);
+		if (document.version !== OWN_VERSION || typeof document.credential !== "object" || document.credential === null) return void 0;
+		const stored = document.credential;
+		const edition = stored["edition"];
+		if (edition !== "cn" && edition !== "sg" && edition !== "solo" && edition !== "solo-sg") return void 0;
+		return normalizeTraeCredential({
+			token: stored["accessToken"],
+			refreshToken: stored["refreshToken"],
+			userId: stored["userId"],
+			host: stored["host"],
+			account: stored["accountName"] === void 0 ? void 0 : { username: stored["accountName"] },
+			expiredAt: stored["expiresAtMs"],
+			refreshExpiredAt: stored["refreshExpiresAtMs"]
+		}, edition, "dsh");
+	} catch {
+		return;
+	}
+}
+var TraeCredentialStore = class {
+	storagePathOverride;
+	edition;
+	accountId;
+	preferIds = [];
+	ownPath;
+	refresh;
+	refreshMarginMs;
+	inflight;
+	constructor(options) {
+		this.storagePathOverride = options.storagePath;
+		this.edition = options.edition ?? "auto";
+		this.accountId = options.accountId;
+		this.ownPath = options.ownPath ?? traeOwnAuthPath();
+		this.refresh = options.refresh;
+		this.refreshMarginMs = options.refreshMarginMs ?? 3e5;
+	}
+	setSource(storagePath, edition = "auto", accountId) {
+		this.storagePathOverride = storagePath;
+		this.edition = edition;
+		this.accountId = accountId;
+		this.inflight = void 0;
+	}
+	selectAccount(accountId) {
+		this.accountId = accountId;
+		this.inflight = void 0;
+	}
+	/**
+	* Preferred account ordering used when no account is explicitly selected.
+	* The connector can only bill the `llm_utils_chat` channel against general
+	* credits, so accounts with zero general credits should not become the
+	* default or they fail with 4008 / empty responses.
+	*/
+	setPreferAccountIds(ids) {
+		this.preferIds = [...ids];
+		this.inflight = void 0;
+	}
+	candidates() {
+		if (this.storagePathOverride !== void 0) return [{
+			edition: this.edition === "auto" ? "cn" : this.edition,
+			path: this.storagePathOverride
+		}];
+		const all = traeStorageCandidates();
+		return this.edition === "auto" ? all.filter((candidate) => candidate.edition === "cn" || candidate.edition === "solo") : all.filter((candidate) => candidate.edition === this.edition && (candidate.edition === "cn" || candidate.edition === "solo"));
+	}
+	/** First credential matching the preferred ordering, else the first live one. */
+	preferred(credentials) {
+		if (credentials.length === 0) return void 0;
+		for (const id of this.preferIds) {
+			const match = credentials.find((credential) => traeAccountId(credential) === id);
+			if (match !== void 0) return match;
+		}
+		return credentials[0];
+	}
+	async accounts() {
+		const credentials = await this.readAll();
+		const selectedExists = this.accountId !== void 0 && credentials.some((credential) => traeAccountId(credential) === this.accountId);
+		const defaultSelected = this.preferred(credentials);
+		return credentials.map((credential) => ({
+			id: traeAccountId(credential),
+			accountName: credential.accountName ?? (credential.userId || `${credential.edition} account`),
+			edition: credential.edition,
+			source: credential.source,
+			tokenExpiresAtMs: credential.expiresAtMs,
+			selected: selectedExists ? traeAccountId(credential) === this.accountId : credential === defaultSelected
+		}));
+	}
+	async current() {
+		const credentials = await this.readAll();
+		if (this.accountId === void 0) return this.preferred(credentials);
+		return credentials.find((credential) => traeAccountId(credential) === this.accountId) ?? this.preferred(credentials);
+	}
+	async resolve() {
+		const credential = await this.current();
+		if (credential === void 0) throw new Error(`trae: no signed-in account found (${this.candidates().map((item) => item.path).join(" or ")})`);
+		if (credential.expiresAtMs > Date.now() + this.refreshMarginMs) return credential;
+		this.inflight ??= this.refreshNow(credential).finally(() => {
+			this.inflight = void 0;
+		});
+		return this.inflight;
+	}
+	async status() {
+		try {
+			const value = await this.current();
+			return value === void 0 ? { state: "signed-out" } : {
+				state: "signed-in",
+				edition: value.edition,
+				expiresAtMs: value.expiresAtMs,
+				source: value.source
+			};
+		} catch {
+			return { state: "signed-out" };
+		}
+	}
+	async desktopFilePresent() {
+		for (const candidate of this.candidates()) try {
+			if ((await stat(candidate.path)).isFile()) return true;
+		} catch {}
+		return false;
+	}
+	async logout() {
+		await rm(this.ownPath, { force: true });
+		await rm(`${this.ownPath}.lock`, { force: true });
+	}
+	async readAll() {
+		const desktop = await this.readDesktopAll();
+		const own = await this.readOwn();
+		const cnOwn = own?.edition === "cn" || own?.edition === "solo" ? own : void 0;
+		if (cnOwn === void 0 || desktop.some((credential) => traeAccountId(credential) === traeAccountId(cnOwn))) return desktop;
+		return [...desktop, cnOwn];
+	}
+	async readDesktopAll() {
+		const credentials = [];
+		for (const candidate of this.candidates()) try {
+			const credential = normalizeTraeCredential(parseTraeStorageDocument(await readFile(candidate.path, "utf8")), candidate.edition, "desktop");
+			if (credential !== void 0 && !credentials.some((existing) => traeAccountId(existing) === traeAccountId(credential))) credentials.push(credential);
+		} catch {
+			continue;
+		}
+		return credentials;
+	}
+	async readOwn() {
+		try {
+			return parseOwn(await readFile(this.ownPath, "utf8"));
+		} catch {
+			return;
+		}
+	}
+	async refreshNow(credential) {
+		if (credential.refreshToken === void 0 || credential.refreshExpiresAtMs !== void 0 && credential.refreshExpiresAtMs <= Date.now()) {
+			if (credential.expiresAtMs > Date.now() + 3e4) return credential;
+			throw new Error("trae: access token expired and no valid refresh token is available; sign in again in Trae");
+		}
+		try {
+			const outcome = await this.refresh(credential);
+			const refreshed = {
+				...credential,
+				accessToken: outcome.accessToken,
+				...outcome.refreshToken === void 0 ? {} : { refreshToken: outcome.refreshToken },
+				expiresAtMs: outcome.expiresAtMs,
+				...outcome.refreshExpiresAtMs === void 0 ? {} : { refreshExpiresAtMs: outcome.refreshExpiresAtMs },
+				...outcome.host === void 0 ? {} : { host: outcome.host },
+				source: "dsh"
+			};
+			await withFileLock(this.ownPath, async () => {
+				await writeFileAtomic(this.ownPath, `${JSON.stringify({
+					version: OWN_VERSION,
+					credential: refreshed
+				}, null, 2)}\n`, {
+					mode: 384,
+					dirMode: 448
+				});
+			});
+			return refreshed;
+		} catch (error) {
+			if (credential.expiresAtMs > Date.now() + 3e4) return credential;
+			throw new Error(`trae: token refresh failed and access token is expired (${String(error)}); sign in again in Trae`);
+		}
+	}
+};
+//#endregion
+//#region src/catalog.ts
+/** Bootstrap catalog: identity only where current Trae metadata has not been fetched yet. */
+const FALLBACK_TRAE_MODELS = [
+	{
+		id: "auto",
+		name: "Auto"
+	},
+	{
+		id: "DeepSeek-V4-Flash",
+		name: "DeepSeek-V4-Flash"
+	},
+	{
+		id: "DeepSeek-V4-Pro",
+		name: "DeepSeek-V4-Pro"
+	},
+	{
+		id: "Doubao-Seed-Code",
+		name: "Doubao-Seed-Code",
+		input: ["text", "image"]
+	},
+	{
+		id: "kimi-k2.6",
+		name: "Kimi-K2.6",
+		input: ["text", "image"]
+	}
+];
+/** Convert verified Trae API metadata into normal models and optional 1M variants. */
+function discoveredCatalog(models, enabled1m = /* @__PURE__ */ new Set()) {
+	const result = [];
+	for (const model of models) {
+		const common = {
+			input: model.multimodal ? ["text", "image"] : ["text"],
+			...model.creditMultiplier === void 0 ? {} : { creditMultiplier: model.creditMultiplier },
+			reasoningSupported: model.reasoningSupported,
+			...model.reasoning === void 0 ? {} : {
+				reasoning: model.reasoning,
+				reasoningEfforts: Object.fromEntries(model.reasoning.supported.map((effort) => [effort, effort === "low" ? "light" : effort === "xhigh" ? "extra_high" : "high"]))
+			}
+		};
+		result.push({
+			id: model.id,
+			name: model.name,
+			...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
+			...model.maxContextWindow === void 0 ? {} : { maxContextWindow: model.maxContextWindow },
+			...common
+		});
+		if (model.maxContextWindow !== void 0 && enabled1m.has(model.id)) result.push({
+			id: `${model.id}@1m`,
+			name: `${model.name} 1M`,
+			contextWindow: model.maxContextWindow,
+			baseModelId: model.id,
+			maxContext: true,
+			...common
+		});
+	}
+	return result;
+}
+/**
+* Derive the runtime catalog from the last refreshed Trae directory plus the
+* user's explicit selection. Ordinary models whose `id` (Trae `name`) is
+* enabled survive; each 1M-capable enabled model produces a `@1m` variant.
+* This is the single source of truth for what DSH actually exposes, so saving
+* only the selection is enough to rebuild it after a restart.
+*/
+function deriveCatalog(catalog, enabled, enabled1m) {
+	const result = [];
+	for (const model of catalog) {
+		if (!enabled.has(model.id)) continue;
+		result.push(model);
+		if (enabled1m.has(model.id) && model.maxContextWindow !== void 0) result.push({
+			id: `${model.id}@1m`,
+			name: `${model.name} 1M`,
+			contextWindow: model.maxContextWindow,
+			baseModelId: model.id,
+			maxContext: true,
+			...model.input === void 0 ? {} : { input: [...model.input] },
+			...model.creditMultiplier === void 0 ? {} : { creditMultiplier: model.creditMultiplier },
+			...model.reasoningSupported === void 0 ? {} : { reasoningSupported: model.reasoningSupported },
+			...model.reasoning === void 0 ? {} : { reasoning: model.reasoning },
+			...model.reasoningEfforts === void 0 ? {} : { reasoningEfforts: model.reasoningEfforts }
+		});
+	}
+	return result;
+}
+var TraeCatalog = class {
+	models = FALLBACK_TRAE_MODELS;
+	current() {
+		return this.models;
+	}
+	set(models) {
+		if (models.length === 0) throw new Error("trae model catalog cannot be empty");
+		this.models = models.map((model) => ({
+			...model,
+			...model.input === void 0 ? {} : { input: [...model.input] }
+		}));
+	}
+};
+//#endregion
+//#region src/refresh.ts
+const CLIENT_ID_BY_EDITION = {
+	cn: "ono9krqynydwx5",
+	solo: "ono9krqynydwx5"
+};
+function normalizeHost(host) {
+	const value = host.trim();
+	if (value === "") throw new Error("Trae refresh host is missing");
+	return value.replace(/\/$/, "");
+}
+/** Refresh only editions whose client contract is currently evidenced. */
+async function refreshTraeCredential(credential, signal) {
+	const clientId = CLIENT_ID_BY_EDITION[credential.edition];
+	if (clientId === void 0) throw new Error(`Trae ${credential.edition} refresh contract is not verified`);
+	if (credential.refreshToken === void 0) throw new Error("Trae refresh token is missing");
+	const response = await fetch(`${normalizeHost(credential.host)}/cloudide/api/v3/trae/oauth/ExchangeToken`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			ClientID: clientId,
+			RefreshToken: credential.refreshToken,
+			ClientSecret: "-",
+			UserID: credential.userId
+		}),
+		signal: signal ?? AbortSignal.timeout(3e4)
+	});
+	if (!response.ok) throw new Error(`Trae token refresh failed (http ${response.status})`);
+	const result = (await response.json()).Result;
+	const accessToken = typeof result?.["Token"] === "string" ? result["Token"] : "";
+	if (accessToken === "") throw new Error("Trae token refresh returned no token");
+	const expiry = result?.["TokenExpireAt"];
+	const expiresAtMs = typeof expiry === "number" ? expiry : typeof expiry === "string" ? Date.parse(expiry) : NaN;
+	if (!Number.isFinite(expiresAtMs)) throw new Error("Trae token refresh returned an invalid expiry");
+	const refreshToken = typeof result?.["RefreshToken"] === "string" && result["RefreshToken"] !== "" ? result["RefreshToken"] : void 0;
+	return {
+		accessToken,
+		...refreshToken === void 0 ? {} : { refreshToken },
+		expiresAtMs
+	};
+}
+//#endregion
+//#region src/identity.ts
+function nonEmpty(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function deviceCenterId(storage) {
+	const prefix = "iCubeAuthInfo://icube-dc:";
+	const ids = Object.keys(storage).filter((key) => key.startsWith(prefix)).map((key) => key.slice(25)).filter(Boolean);
+	return ids.length === 1 ? ids[0] : void 0;
+}
+/** Read stable identity from Trae-owned files without generating impersonated IDs. */
+async function readTraeIdentity(candidate) {
+	const storage = JSON.parse(await readFile(candidate.path, "utf8"));
+	const appRoot = dirname(dirname(dirname(candidate.path)));
+	const machineFile = nonEmpty(await readFile(join(appRoot, "machineid"), "utf8").catch(() => ""));
+	const telemetryMachine = nonEmpty(storage["telemetry.machineId"]);
+	const devDevice = nonEmpty(storage["telemetry.devDeviceId"]);
+	const dcDevice = deviceCenterId(storage);
+	const machineId = telemetryMachine ?? machineFile;
+	if (machineId === void 0) throw new Error(`Trae ${candidate.edition} has no stable machine identity`);
+	const deviceId = dcDevice ?? devDevice ?? createHash("sha256").update(machineId).digest("hex").slice(0, 32);
+	const buildVersion = nonEmpty(storage["iCubeLastVersion"]);
+	const productPaths = candidate.edition === "cn" || candidate.edition === "solo" ? [candidate.edition === "cn" ? "/Applications/Trae CN.app/Contents/Resources/app/product.json" : "/Applications/TRAE SOLO CN.app/Contents/Resources/app/product.json"] : [];
+	let product = {};
+	for (const path of productPaths) try {
+		product = JSON.parse(await readFile(path, "utf8"));
+		break;
+	} catch {}
+	const appVersion = nonEmpty(product["appVersion"]);
+	const deviceBrand = process.platform === "darwin" ? nonEmpty(process.env["TRAE_DEVICE_BRAND"]) : void 0;
+	const deviceCpu = cpus()[0]?.model.split(" ")[0];
+	const osVersion = `${process.platform === "darwin" ? "macOS" : process.platform} ${release()}`;
+	return {
+		edition: candidate.edition,
+		machineId,
+		deviceId,
+		...appVersion === void 0 ? {} : { appVersion },
+		...buildVersion === void 0 ? {} : { buildVersion },
+		...deviceBrand === void 0 ? {} : { deviceBrand },
+		...deviceCpu === void 0 ? {} : { deviceCpu },
+		osVersion,
+		platform: process.platform
+	};
+}
+/** Headers derived from actual persisted identity, never a new random identity per request. */
+function identityHeaders(identity) {
+	return {
+		"x-machine-id": identity.machineId,
+		"x-device-id": identity.deviceId,
+		"x-device-type": identity.platform === "darwin" ? "mac" : identity.platform === "win32" ? "windows" : identity.platform,
+		...identity.deviceBrand === void 0 ? {} : { "x-device-brand": identity.deviceBrand },
+		...identity.deviceCpu === void 0 ? {} : { "x-device-cpu": identity.deviceCpu },
+		...identity.osVersion === void 0 ? {} : { "x-os-version": identity.osVersion },
+		...identity.appVersion === void 0 ? {} : {
+			"x-app-version": identity.appVersion,
+			"x-ide-version": identity.appVersion
+		},
+		...identity.buildVersion === void 0 ? {} : {
+			"x-app-version-code": identity.buildVersion,
+			"x-ide-version-code": identity.buildVersion
+		},
+		"x-ide-version-type": "stable"
+	};
+}
+//#endregion
+//#region src/shim.ts
+const BODY_LIMIT = 67108864;
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"[::1]"
+]);
+const STATUS_BY_KIND = {
+	authentication: 401,
+	hard_credit: 402,
+	soft_rate: 429,
+	not_found: 502,
+	server: 502,
+	client: 400,
+	unconfigured: 503
+};
+function hostnameOfHost(host) {
+	let hostname = host.trim().toLowerCase();
+	if (hostname.startsWith("[")) {
+		const end = hostname.indexOf("]");
+		return end === -1 ? hostname : hostname.slice(0, end + 1);
+	}
+	const colon = hostname.lastIndexOf(":");
+	if (colon !== -1 && /^\d+$/.test(hostname.slice(colon + 1))) hostname = hostname.slice(0, colon);
+	return hostname;
+}
+function hostIsLoopback(host) {
+	return host !== void 0 && host.trim() !== "" && LOOPBACK_HOSTS.has(hostnameOfHost(host));
+}
+function originIsLoopback(origin) {
+	if (origin === void 0 || origin.trim() === "") return true;
+	try {
+		const hostname = new URL(origin).hostname;
+		return LOOPBACK_HOSTS.has(hostname) || hostname === "::1";
+	} catch {
+		return false;
+	}
+}
+function writeJson(res, status, body) {
+	const payload = JSON.stringify(body);
+	res.writeHead(status, {
+		"Content-Type": "application/json",
+		"Content-Length": Buffer.byteLength(payload)
+	});
+	res.end(payload);
+}
+function writeError(res, status, kind, message) {
+	writeJson(res, status, { error: {
+		message,
+		type: kind,
+		code: kind
+	} });
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > BODY_LIMIT) {
+				reject(/* @__PURE__ */ new Error("request body too large"));
+				req.destroy();
+			} else chunks.push(chunk);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+function createTraeShim(options) {
+	const secret = randomBytes(32).toString("base64url");
+	const sockets = /* @__PURE__ */ new Set();
+	const server = createServer((req, res) => {
+		handle(req, res);
+	});
+	server.on("connection", (socket) => {
+		sockets.add(socket);
+		socket.once("close", () => sockets.delete(socket));
+	});
+	const ready = new Promise((resolve, reject) => {
+		server.once("listening", resolve);
+		server.once("error", reject);
+	});
+	server.listen(0, "127.0.0.1");
+	function bearerOk(req) {
+		const match = typeof req.headers.authorization === "string" ? /^Bearer\s+(.+)$/i.exec(req.headers.authorization.trim()) : null;
+		if (match === null) return false;
+		const actual = Buffer.from(match[1] ?? "");
+		const expected = Buffer.from(secret);
+		return actual.length === expected.length && timingSafeEqual(actual, expected);
+	}
+	async function handle(req, res) {
+		try {
+			if (!hostIsLoopback(req.headers.host)) return writeError(res, 403, "host_not_allowed", "Host must be loopback");
+			if (!originIsLoopback(req.headers.origin)) return writeError(res, 403, "origin_not_allowed", "Origin must be loopback");
+			if (!bearerOk(req)) return writeError(res, 401, "unauthorized", "Missing or invalid bearer");
+			const url = req.url ?? "/";
+			if (req.method === "GET" && (url === "/healthz" || url === "/healthz/")) return writeJson(res, 200, { ok: true });
+			if (req.method === "GET" && (url === "/v1/models" || url === "/v1/models/")) return writeJson(res, 200, {
+				object: "list",
+				data: options.catalog.current().map((model) => ({
+					id: model.id,
+					object: "model",
+					created: 0,
+					owned_by: "trae"
+				}))
+			});
+			if (req.method === "POST" && (url === "/v1/chat/completions" || url === "/v1/chat/completions/")) {
+				if (typeof req.headers["content-type"] !== "string" || !req.headers["content-type"].toLowerCase().startsWith("application/json")) return writeError(res, 415, "unsupported_media_type", "Content-Type must be application/json");
+				const raw = (await readBody(req)).toString("utf8");
+				try {
+					JSON.parse(raw);
+				} catch {
+					return writeError(res, 400, "invalid_json", "Request body must be valid JSON");
+				}
+				const parsed = JSON.parse(raw);
+				options.logger?.warn("dsh-connect-trae: chat request received", {
+					model: parsed.model,
+					messages: Array.isArray(parsed.messages) ? parsed.messages.map((message) => typeof message === "object" && message !== null ? message["role"] ?? "?" : "?") : "(none)",
+					toolCount: Array.isArray(parsed.tools) ? parsed.tools.length : 0,
+					maxTokens: parsed.max_tokens,
+					reasoningEffort: parsed.reasoning_effort,
+					temperature: parsed.temperature,
+					bodyBytes: raw.length
+				});
+				const controller = new AbortController();
+				const abort = () => controller.abort();
+				req.once("aborted", abort);
+				req.socket.once("close", abort);
+				const result = await options.client.chatStream(raw, controller.signal);
+				if (!result.ok) return writeError(res, STATUS_BY_KIND[result.kind], result.kind, result.message);
+				res.writeHead(200, {
+					"Content-Type": "text/event-stream",
+					"Cache-Control": "no-cache",
+					"Connection": "keep-alive",
+					"X-Accel-Buffering": "no"
+				});
+				const body = Readable.fromWeb(result.response.body);
+				body.on("error", (error) => {
+					const record = error instanceof Error ? {
+						name: error.name,
+						message: error.message,
+						cause: error.cause ? String(error.cause) : void 0
+					} : String(error);
+					options.logger?.warn("dsh-connect-trae: upstream stream failed", record);
+					if (!res.writableEnded) res.end();
+				});
+				body.pipe(res);
+				return;
+			}
+			writeError(res, 404, "not_found", `No such route: ${req.method} ${url}`);
+		} catch (error) {
+			options.logger?.error("dsh-connect-trae: shim request failed", error);
+			if (!res.headersSent) writeError(res, 500, "internal", "Internal shim error");
+			else if (!res.writableEnded) res.end();
+		}
+	}
+	return {
+		ready,
+		baseUrl() {
+			const address = server.address();
+			if (address === null || typeof address === "string") throw new Error("trae shim is not listening");
+			return `http://127.0.0.1:${address.port}`;
+		},
+		token: () => secret,
+		close: () => new Promise((resolve, reject) => {
+			for (const socket of sockets) socket.destroy();
+			server.close((error) => error === void 0 ? resolve() : reject(error));
+		})
+	};
+}
+//#endregion
+//#region src/protocol.ts
+const TRAE_CN_AGENT_TASK_PATH = "/api/agent/v3/create_agent_task";
+const TRAE_CN_TITLE_PATH = "/api/agent/v3/llm_utils_chat";
+/**
+* Evidence-bounded body draft. It is intentionally pure and offline; the
+* network client remains disabled until a controlled request validates it.
+*/
+function buildTraeAgentTaskBody(messages, model, options = {}) {
+	if (messages.length === 0) throw new Error("Trae agent task requires at least one message");
+	const requestId = options.requestId ?? randomUUID();
+	const sessionId = options.sessionId ?? requestId;
+	return {
+		messages: messages.map((message) => ({
+			role: message.role,
+			content: [{
+				type: "text",
+				text: message.content
+			}]
+		})),
+		model,
+		function: "inline_chat",
+		stream: true,
+		request_id: requestId,
+		session_id: sessionId,
+		...options.maxTokens === void 0 ? {} : { max_tokens: options.maxTokens }
+	};
+}
+/**
+* Numeric version code sent when the persisted build version is not a plain
+* integer. The upstream binds `x-app-version-code` / `x-ide-version-code` as a
+* number: Trae stores `iCubeLastVersion` as a dotted build string (observed
+* `2.3.76922` on TRAE SOLO CN 0.1.56), which the server rejects with
+* `4001 ... expr_path=app_version_code, cause=parameter type does not match
+* binding data`. Verified 2026-08-29: with a numeric code the same request
+* returns HTTP 200 + `text/event-stream` on
+* `/api/agent/v3/llm_utils_chat` (`solo_work_lite`).
+*
+* Only the *format* of this field is normalised. Machine, device and app
+* version stay exactly as persisted — nothing here impersonates a device.
+*/
+const TRAE_VERSION_CODE_FALLBACK = "20260716";
+/** Keep a purely numeric build version; fall back when it cannot bind. */
+function normalizeTraeVersionCode(buildVersion) {
+	if (buildVersion === void 0 || buildVersion.trim() === "") return TRAE_VERSION_CODE_FALLBACK;
+	const trimmed = buildVersion.trim();
+	return /^\d+$/.test(trimmed) ? trimmed : TRAE_VERSION_CODE_FALLBACK;
+}
+function buildTraeCnHeaders(credential, identity, options = {}) {
+	if (credential.edition !== "cn" && credential.edition !== "solo") throw new Error(`Trae ${credential.edition} request contract is not verified`);
+	const requestId = options.requestId ?? randomUUID();
+	const traceId = requestId.replaceAll("-", "").slice(0, 32);
+	const profile = options.profile ?? "agent-task";
+	const common = {
+		"Authorization": `Cloud-IDE-JWT ${credential.accessToken}`,
+		"X-Ide-Token": credential.accessToken,
+		"x-plugin-channel": "icube-ai",
+		"User-Agent": `Trae/${identity.appVersion ?? identity.buildVersion ?? "unknown"}`,
+		"x-app-id": options.appId ?? "6eefa01c-1036-4c7e-9ca5-d891f63bfcd8",
+		...identityHeaders(identity),
+		"x-app-version-code": normalizeTraeVersionCode(identity.buildVersion),
+		"x-ide-version-code": normalizeTraeVersionCode(identity.buildVersion),
+		"x-custom-trace-id": traceId,
+		"x-flow-traceparent": `04-${traceId}-${traceId.slice(0, 16)}-01`,
+		"request-traffic-type": "prod",
+		"Content-Type": "application/json"
+	};
+	if (profile === "native-curl") return {
+		"Content-Type": "application/json",
+		"request-traffic-type": "prod",
+		"x-app-id": options.appId ?? "6eefa01c-1036-4c7e-9ca5-d891f63bfcd8",
+		...identityHeaders(identity),
+		"x-custom-trace-id": traceId,
+		"x-flow-traceparent": `04-${traceId}-${traceId.slice(0, 16)}-01`,
+		"X-Ide-Token": credential.accessToken
+	};
+	if (profile === "model-detail") return {
+		...common,
+		"Accept": "application/json"
+	};
+	if (profile === "raw-chat") return {
+		...common,
+		"Accept": "text/event-stream"
+	};
+	return {
+		...common,
+		"X-Cloudide-Token": credential.accessToken,
+		"x-uid": credential.userId,
+		"x-request-id": requestId,
+		"x-trae-request-id": requestId,
+		"Accept": "text/event-stream"
+	};
+}
+function traeEndpoint(baseUrl, path) {
+	return `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+}
+//#endregion
+//#region src/reasoning.ts
+const TRAE_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+function parseReasoningCapability(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	const supported = (Array.isArray(record["reasoning_effort_options"]) ? record["reasoning_effort_options"] : []).filter((item) => typeof item === "string" && TRAE_REASONING_EFFORTS.includes(item));
+	const rawDefault = record["default_reasoning_effort"];
+	const defaultEffort = typeof rawDefault === "string" && supported.includes(rawDefault) ? rawDefault : void 0;
+	if (supported.length === 0 && defaultEffort === void 0) return void 0;
+	return {
+		supported,
+		...defaultEffort === void 0 ? {} : { defaultEffort }
+	};
+}
+/** Add effort only when the selected model advertises that exact value. */
+function applyReasoningEffort(body, effort, capability) {
+	if (effort === void 0) return body;
+	if (capability === void 0 || !capability.supported.includes(effort)) throw new Error(`Trae model does not advertise reasoning effort ${effort}`);
+	return {
+		...body,
+		reasoning_effort: effort
+	};
+}
+//#endregion
+//#region src/solo.ts
+const TRAE_SOLO_FUNCTION = "solo_work_lite";
+const TRAE_SOLO_CHAT_PATH = "/api/agent/v3/llm_utils_chat";
+const TRAE_SOLO_MODELS_PATH = "/api/ide/v1/get_detail_param";
+function classify$1(status) {
+	if (status === 401 || status === 403) return "authentication";
+	if (status === 402) return "hard_credit";
+	if (status === 429) return "soft_rate";
+	if (status === 404) return "not_found";
+	if (status >= 500) return "server";
+	return "client";
+}
+function prepareSoloBody(source, defaultModel = "glm-5.2") {
+	const body = JSON.parse(source);
+	const model = typeof body["model"] === "string" && body["model"].trim() !== "" ? body["model"].trim() : defaultModel;
+	body["model"] = model;
+	body["config_name"] = model;
+	body["function"] = TRAE_SOLO_FUNCTION;
+	body["stream"] = true;
+	if (Array.isArray(body["messages"])) for (const raw of body["messages"]) {
+		if (typeof raw !== "object" || raw === null) continue;
+		const message = raw;
+		if (message["role"] === "developer") message["role"] = "system";
+		if (typeof message["content"] === "string") message["content"] = [{
+			type: "text",
+			text: message["content"]
+		}];
+		if (message["role"] === "assistant" && Array.isArray(message["tool_calls"])) for (const rawCall of message["tool_calls"]) {
+			if (typeof rawCall !== "object" || rawCall === null) continue;
+			const call = rawCall;
+			if (typeof call["function"] === "object" && call["function"] !== null) {
+				call["function_call"] = call["function"];
+				delete call["function"];
+			}
+		}
+		if (message["role"] === "tool") {
+			message["role"] = "tool";
+			if (typeof message["tool_call_id"] !== "string" || message["tool_call_id"] === "") throw new Error("Trae SOLO tool message requires tool_call_id");
+		}
+	}
+	if (Array.isArray(body["tools"])) for (const raw of body["tools"]) {
+		if (typeof raw !== "object" || raw === null) continue;
+		const fn = raw["function"];
+		if (typeof fn !== "object" || fn === null) continue;
+		const record = fn;
+		if (typeof record["parameters"] === "object" && record["parameters"] !== null) record["parameters"] = JSON.stringify(record["parameters"]);
+	}
+	return JSON.stringify(body);
+}
+var TraeSoloUpstreamClient = class {
+	options;
+	fetchImpl;
+	constructor(options) {
+		this.options = options;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+	}
+	async fetchModels(signal) {
+		const [credential, identity] = await Promise.all([this.options.credential(), this.options.identity()]);
+		const response = await this.fetchImpl(traeEndpoint(this.options.baseUrl ?? credential.host, TRAE_SOLO_MODELS_PATH), {
+			method: "POST",
+			headers: {
+				...buildTraeCnHeaders(credential, identity),
+				Accept: "application/json"
+			},
+			body: JSON.stringify({
+				function: TRAE_SOLO_FUNCTION,
+				config_names: null,
+				need_prompt: false,
+				current_config_info: null,
+				poly_prompt: true,
+				mode_type: null,
+				agent_type: null
+			}),
+			signal: signal ?? AbortSignal.timeout(3e4)
+		});
+		if (!response.ok) throw new Error(`Trae SOLO models returned HTTP ${response.status}`);
+		const document = await response.json();
+		const list = Array.isArray(document["config_info_list"]) ? document["config_info_list"] : [];
+		const models = [];
+		for (const raw of list) {
+			if (typeof raw !== "object" || raw === null) continue;
+			const config = raw;
+			const id = typeof config["config_name"] === "string" ? config["config_name"] : "";
+			if (id === "") continue;
+			const display = typeof config["display_config"] === "object" && config["display_config"] !== null ? config["display_config"] : {};
+			const details = Array.isArray(config["model_detail_list"]) ? config["model_detail_list"] : [];
+			const detail = typeof details[0] === "object" && details[0] !== null ? details[0] : {};
+			const contextWindow = typeof detail["max_input_tokens"] === "number" ? detail["max_input_tokens"] : typeof config["max_input_tokens"] === "number" ? config["max_input_tokens"] : void 0;
+			const maxTokens = typeof detail["max_output_tokens"] === "number" ? detail["max_output_tokens"] : typeof config["max_output_tokens"] === "number" ? config["max_output_tokens"] : void 0;
+			const reasoning = parseReasoningCapability({
+				...config,
+				...detail
+			});
+			models.push({
+				id,
+				name: typeof display["display_name"] === "string" && display["display_name"] !== "" ? display["display_name"] : id,
+				...contextWindow === void 0 ? {} : { contextWindow },
+				...maxTokens === void 0 ? {} : { maxTokens },
+				...reasoning === void 0 ? {} : { reasoning }
+			});
+		}
+		if (models.length === 0) throw new Error("Trae SOLO models response contained no models");
+		return models;
+	}
+	async chatStream(bodyJson, signal) {
+		let prepared;
+		try {
+			prepared = prepareSoloBody(bodyJson);
+		} catch {
+			return {
+				ok: false,
+				status: 400,
+				kind: "client",
+				message: "invalid JSON request"
+			};
+		}
+		const [credential, identity] = await Promise.all([this.options.credential(), this.options.identity()]);
+		const headers = buildTraeCnHeaders(credential, identity);
+		let response;
+		try {
+			response = await this.fetchImpl(traeEndpoint(this.options.baseUrl ?? credential.host, TRAE_SOLO_CHAT_PATH), {
+				method: "POST",
+				headers,
+				body: prepared,
+				signal: signal ?? AbortSignal.timeout(12e4)
+			});
+		} catch (error) {
+			return {
+				ok: false,
+				status: 0,
+				kind: "server",
+				message: `transport error: ${String(error)}`
+			};
+		}
+		if (response.ok) return {
+			ok: true,
+			response
+		};
+		const text = (await response.text()).slice(0, 1024);
+		return {
+			ok: false,
+			status: response.status,
+			kind: classify$1(response.status),
+			message: text || `Trae SOLO returned HTTP ${response.status}`
+		};
+	}
+};
+//#endregion
+//#region src/sse.ts
+/** Incremental SSE decoder supporting CRLF, chunk splits and multi-line data. */
+var SseDecoder = class {
+	buffer = "";
+	event;
+	id;
+	retry;
+	data = [];
+	push(chunk) {
+		this.buffer += chunk;
+		const events = [];
+		while (true) {
+			const match = /\r?\n/.exec(this.buffer);
+			if (match === null || match.index === void 0) break;
+			const line = this.buffer.slice(0, match.index);
+			this.buffer = this.buffer.slice(match.index + match[0].length);
+			const emitted = this.consumeLine(line);
+			if (emitted !== void 0) events.push(emitted);
+		}
+		return events;
+	}
+	finish() {
+		const events = [];
+		if (this.buffer !== "") {
+			const emitted = this.consumeLine(this.buffer);
+			this.buffer = "";
+			if (emitted !== void 0) events.push(emitted);
+		}
+		const final = this.dispatch();
+		if (final !== void 0) events.push(final);
+		return events;
+	}
+	consumeLine(line) {
+		if (line === "") return this.dispatch();
+		if (line.startsWith(":")) return void 0;
+		const colon = line.indexOf(":");
+		const field = colon === -1 ? line : line.slice(0, colon);
+		let value = colon === -1 ? "" : line.slice(colon + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		if (field === "event") this.event = value;
+		else if (field === "data") this.data.push(value);
+		else if (field === "id" && !value.includes("\0")) this.id = value;
+		else if (field === "retry" && /^\d+$/.test(value)) this.retry = Number(value);
+	}
+	dispatch() {
+		if (this.data.length === 0) {
+			this.event = void 0;
+			this.retry = void 0;
+			return;
+		}
+		const result = {
+			...this.event === void 0 || this.event === "" ? {} : { event: this.event },
+			data: this.data.join("\n"),
+			...this.id === void 0 ? {} : { id: this.id },
+			...this.retry === void 0 ? {} : { retry: this.retry }
+		};
+		this.event = void 0;
+		this.retry = void 0;
+		this.data = [];
+		return result;
+	}
+};
+function decodeTraeEvent(event) {
+	if (event.data === "[DONE]") return {
+		type: "done",
+		finishReason: "stop"
+	};
+	let payload;
+	try {
+		payload = JSON.parse(event.data);
+	} catch {
+		return {
+			type: "unknown",
+			...event.event === void 0 ? {} : { event: event.event },
+			data: event.data
+		};
+	}
+	const record = typeof payload === "object" && payload !== null && !Array.isArray(payload) ? payload : {};
+	if (event.event === "request_wait_in_queue") return {
+		type: "queue",
+		...typeof record["position"] === "number" ? { position: record["position"] } : {}
+	};
+	if (event.event === "progress_notice") return {
+		type: "progress",
+		notice: payload
+	};
+	if (event.event === "token_usage") return {
+		type: "usage",
+		...typeof record["prompt_tokens"] === "number" ? { inputTokens: record["prompt_tokens"] } : {},
+		...typeof record["completion_tokens"] === "number" ? { outputTokens: record["completion_tokens"] } : {},
+		...typeof record["total_tokens"] === "number" ? { totalTokens: record["total_tokens"] } : {},
+		...typeof record["reasoning_tokens"] === "number" ? { reasoningTokens: record["reasoning_tokens"] } : {}
+	};
+	if (event.event === "done" || typeof record["finish_reason"] === "string" && record["response"] === void 0) return {
+		type: "done",
+		finishReason: typeof record["finish_reason"] === "string" ? record["finish_reason"] : "stop"
+	};
+	if (event.event === "output" || record["response"] !== void 0 || record["reasoning_content"] !== void 0) return {
+		type: "delta",
+		text: typeof record["response"] === "string" ? record["response"] : "",
+		...typeof record["reasoning_content"] === "string" ? { reasoning: record["reasoning_content"] } : {},
+		...record["tool_calls"] === void 0 || record["tool_calls"] === null ? {} : { toolCalls: record["tool_calls"] }
+	};
+	return {
+		type: "unknown",
+		...event.event === void 0 ? {} : { event: event.event },
+		data: payload
+	};
+}
+//#endregion
+//#region src/solo-bridge.ts
+function normalizeToolCalls(value) {
+	if (!Array.isArray(value)) return [];
+	const calls = [];
+	for (const raw of value) {
+		if (typeof raw !== "object" || raw === null) continue;
+		const record = raw;
+		const rawFunction = typeof record["function_call"] === "object" && record["function_call"] !== null ? record["function_call"] : typeof record["function"] === "object" && record["function"] !== null ? record["function"] : {};
+		const fn = {
+			...typeof rawFunction["name"] === "string" ? { name: rawFunction["name"] } : {},
+			...typeof rawFunction["arguments"] === "string" ? { arguments: rawFunction["arguments"] } : {}
+		};
+		calls.push({
+			index: typeof record["index"] === "number" ? record["index"] : calls.length,
+			...typeof record["id"] === "string" ? { id: record["id"] } : {},
+			...record["type"] === "function" ? { type: "function" } : {},
+			...Object.keys(fn).length === 0 ? {} : { function: fn }
+		});
+	}
+	return calls;
+}
+/** Convert Trae's named SSE events into OpenAI chat-completion SSE chunks. */
+function bridgeTraeSoloStream(response, model) {
+	const source = response.body;
+	if (source === null) return new Response(null, { status: 502 });
+	const id = `chatcmpl-${randomUUID().replaceAll("-", "").slice(0, 24)}`;
+	const created = Math.floor(Date.now() / 1e3);
+	const decoder = new TextDecoder();
+	const encoder = new TextEncoder();
+	const sse = new SseDecoder();
+	let sawToolCalls = false;
+	let emittedDone = false;
+	let upstreamError;
+	let usage;
+	const chunk = (delta, finishReason = null) => encoder.encode(`data: ${JSON.stringify({
+		id,
+		object: "chat.completion.chunk",
+		created,
+		model,
+		choices: [{
+			index: 0,
+			delta,
+			finish_reason: finishReason
+		}],
+		...usage === void 0 ? {} : { usage }
+	})}\n\n`);
+	const stream = new ReadableStream({
+		async start(controller) {
+			const reader = source.getReader();
+			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 ?? "?"})`);
+					return;
+				}
+				if (decoded.type === "delta") {
+					const delta = {};
+					if (decoded.text !== "") delta["content"] = decoded.text;
+					if (decoded.reasoning !== void 0 && decoded.reasoning !== "") delta["reasoning_content"] = decoded.reasoning;
+					const toolCalls = normalizeToolCalls(decoded.toolCalls);
+					if (toolCalls.length > 0) {
+						sawToolCalls = true;
+						delta["tool_calls"] = toolCalls;
+					}
+					if (Object.keys(delta).length > 0) controller.enqueue(chunk(delta));
+				} else if (decoded.type === "usage") usage = {
+					...decoded.inputTokens === void 0 ? {} : { prompt_tokens: decoded.inputTokens },
+					...decoded.outputTokens === void 0 ? {} : { completion_tokens: decoded.outputTokens },
+					...decoded.totalTokens === void 0 ? {} : { total_tokens: decoded.totalTokens }
+				};
+				else if (decoded.type === "done" && !emittedDone) {
+					emittedDone = true;
+					if (upstreamError !== void 0) {
+						controller.error(upstreamError);
+						return;
+					}
+					controller.enqueue(chunk({}, sawToolCalls ? "tool_calls" : decoded.finishReason));
+				}
+			};
+			try {
+				while (true) {
+					const next = await reader.read();
+					if (next.done) break;
+					for (const event of sse.push(decoder.decode(next.value, { stream: true }))) consume(event);
+				}
+				for (const event of sse.finish()) consume(event);
+				if (upstreamError !== void 0 && !emittedDone) {
+					controller.error(upstreamError);
+					return;
+				}
+				if (!emittedDone) controller.enqueue(chunk({}, sawToolCalls ? "tool_calls" : "stop"));
+				controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+				controller.close();
+			} catch (error) {
+				controller.error(error);
+			} finally {
+				reader.releaseLock();
+			}
+		},
+		cancel(reason) {
+			return source.cancel(reason);
+		}
+	});
+	return new Response(stream, {
+		status: 200,
+		headers: { "Content-Type": "text/event-stream" }
+	});
+}
+/** Native SOLO client wrapper used by the loopback OpenAI adapter. */
+var TraeSoloBridge = class {
+	upstream;
+	constructor(upstream) {
+		this.upstream = upstream;
+	}
+	async chatStream(bodyJson, signal) {
+		let model = "glm-5.2";
+		try {
+			const input = JSON.parse(bodyJson);
+			if (typeof input["model"] === "string" && input["model"] !== "") model = input["model"].endsWith("@1m") ? input["model"].slice(0, -3) : input["model"];
+		} catch {
+			return {
+				ok: false,
+				status: 400,
+				kind: "client",
+				message: "invalid JSON request"
+			};
+		}
+		const result = await this.upstream.chatStream(bodyJson, signal);
+		if (!result.ok) return result;
+		return {
+			ok: true,
+			response: bridgeTraeSoloStream(result.response, model)
+		};
+	}
+};
+//#endregion
+//#region src/model-metadata.ts
+function finitePositive(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function parseFeatures(value) {
+	if (typeof value !== "string" || value === "") return void 0;
+	try {
+		return record(JSON.parse(value));
+	} catch {
+		return;
+	}
+}
+const EFFORT_MAP = {
+	light: "low",
+	high: "high",
+	extra_high: "xhigh"
+};
+/** Parse only capabilities explicitly advertised by Trae's remote model API. */
+function parseTraeRemoteModel(value) {
+	const raw = record(value);
+	if (raw === void 0 || typeof raw.name !== "string" || raw.name === "") return void 0;
+	const context = record(raw.context_window_tokens);
+	const dev = finitePositive(context?.["dev"]);
+	const max = raw.max_mode === true ? finitePositive(context?.["max"]) : void 0;
+	const features = parseFeatures(raw.features);
+	const consumption = record(features?.["consumption_rate"]);
+	const consumptionData = record(consumption?.["data"]);
+	const creditMultiplier = consumption?.["enable"] === true ? finitePositive(consumptionData?.["rate"]) : void 0;
+	const reasoningSupported = record(features?.["reasoning"])?.["enable"] === true;
+	const reasoningConfig = record(raw.reasoning_effort_config);
+	const supported = (Array.isArray(reasoningConfig?.["options"]) ? reasoningConfig["options"] : []).flatMap((option) => {
+		if (typeof option !== "string") return [];
+		const effort = EFFORT_MAP[option];
+		return effort === void 0 ? [] : [effort];
+	});
+	const rawDefault = reasoningConfig?.["default_level"];
+	const mappedDefault = typeof rawDefault === "string" ? EFFORT_MAP[rawDefault] : void 0;
+	const defaultEffort = mappedDefault !== void 0 && supported.includes(mappedDefault) ? mappedDefault : void 0;
+	return {
+		id: raw.name,
+		name: typeof raw.display_name === "string" && raw.display_name !== "" ? raw.display_name : raw.name,
+		multimodal: raw.multimodal === true,
+		...dev === void 0 ? {} : { contextWindow: dev },
+		...max === void 0 ? {} : { maxContextWindow: max },
+		...creditMultiplier === void 0 ? {} : { creditMultiplier },
+		reasoningSupported,
+		...supported.length === 0 ? {} : { reasoning: {
+			supported,
+			...defaultEffort === void 0 ? {} : { defaultEffort }
+		} }
+	};
+}
+//#endregion
+//#region src/solo-remote.ts
+const TRAE_SOLO_REMOTE_BASE = "https://solo.trae.cn/api/remote/v1";
+const TRAE_SOLO_REMOTE_MODELS = [
+	{
+		name: "DeepSeek-V4-Flash",
+		displayName: "DeepSeek-V4-Flash",
+		multimodal: false
+	},
+	{
+		name: "DeepSeek-V4-Pro",
+		displayName: "DeepSeek-V4-Pro",
+		multimodal: false
+	},
+	{
+		name: "Doubao_1_6",
+		displayName: "Doubao-Seed-Code",
+		multimodal: true
+	},
+	{
+		name: "Doubao-Seed-2.0-Code",
+		displayName: "Doubao-Seed-2.0-Code",
+		multimodal: true
+	},
+	{
+		name: "kimi-k2.6",
+		displayName: "Kimi-K2.6",
+		multimodal: true
+	},
+	{
+		name: "kimi-k2.5",
+		displayName: "Kimi-K2.5",
+		multimodal: true
+	},
+	{
+		name: "qwen-3.6-plus",
+		displayName: "Qwen3.6-Plus",
+		multimodal: true
+	},
+	{
+		name: "qwen-3.5",
+		displayName: "Qwen3.5",
+		multimodal: true
+	},
+	{
+		name: "glm-5.1",
+		displayName: "GLM-5.1",
+		multimodal: false
+	},
+	{
+		name: "glm-5",
+		displayName: "GLM-5",
+		multimodal: false
+	},
+	{
+		name: "glm-5v-turbo",
+		displayName: "GLM-5V-Turbo",
+		multimodal: true
+	},
+	{
+		name: "minimax-m2.7",
+		displayName: "MiniMax-M2.7",
+		multimodal: false
+	},
+	{
+		name: "minimax-m2.5",
+		displayName: "MiniMax-M2.5",
+		multimodal: false
+	}
+];
+/**
+* Preserve DSH's complete text conversation in the one query accepted by the
+* SOLO Remote create-session endpoint. System instructions (including DSH's
+* workspace/cwd context), assistant history, tool-result text and the newest
+* user request stay ordered instead of collapsing to the last user message.
+*/
+function serializeTraeConversation(messages) {
+	if (messages.length === 1 && messages[0]?.role === "user") return messages[0].content;
+	return messages.map((message) => `<dsh-message role="${message.role}">\n${message.content}\n</dsh-message>`).join("\n\n");
+}
+function decodeUserId(token) {
+	try {
+		return JSON.parse(Buffer.from(token.split(".")[1] ?? "", "base64").toString("utf8")).data?.id ?? "0";
+	} catch {
+		return "0";
+	}
+}
+function generateWebId() {
+	return String(Math.floor(Math.random() * 9e15) + 0x38d7ea4c68000);
+}
+function buildCommonParams(userId, webId, sessionId) {
+	return JSON.stringify({
+		language: "zh-cn",
+		app_language: "en",
+		quality: "stable",
+		app_version: "1.0.0.1300",
+		user_identity: "Free",
+		is_freshman: "0",
+		scope: "marscode",
+		tenant: "marscode",
+		region: "CN",
+		aiRegion: "CN",
+		solo_chat_mode: "code",
+		is_privacy_mode: 1,
+		privacy_mode: "on",
+		...sessionId === void 0 ? {} : { biz_session_id: sessionId },
+		web_id: webId,
+		biz_user_id: userId,
+		user_unique_id: userId
+	});
+}
+function extractContent(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed)) return parsed.filter((c) => typeof c === "object" && c !== null && c.type === "text").map((c) => c.text_content ?? "").join("");
+		if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.messages)) {
+			const parts = [];
+			for (const msg of parsed.messages) {
+				if (typeof msg !== "object" || msg === null) continue;
+				const pi = msg.plan_item;
+				if (typeof pi !== "object" || pi === null) continue;
+				const tc = pi.tool_call_info;
+				if (typeof tc !== "object" || tc === null) continue;
+				const tool = tc;
+				if (tool.name === "finish" && tool.params?.summary) parts.push(tool.params.summary);
+				else if (tool.result?.data?.summary && tool.name !== "finish") parts.push(tool.result.data.summary);
+			}
+			return parts.join("\n\n");
+		}
+	} catch {}
+	return raw;
+}
+var TraeSoloRemoteClient = class {
+	options;
+	fetchImpl;
+	baseUrl;
+	pollIntervalMs;
+	timeoutMs;
+	constructor(options) {
+		this.options = options;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.baseUrl = options.baseUrl ?? "https://solo.trae.cn/api/remote/v1";
+		this.pollIntervalMs = options.pollIntervalMs ?? 2e3;
+		this.timeoutMs = options.timeoutMs ?? 12e4;
+	}
+	async headers() {
+		return {
+			"Authorization": `Cloud-IDE-JWT ${(await this.options.credential()).accessToken}`,
+			"Content-Type": "application/json",
+			"x-trae-client-type": "web",
+			"x-trae-user-timezone": "Asia/Shanghai",
+			"x-preferenced-language": "zh-cn",
+			"Referer": "https://solo.trae.cn/",
+			"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+		};
+	}
+	async chat(messages, model, signal) {
+		const headers = await this.headers();
+		const token = (await this.options.credential()).accessToken;
+		const userId = decodeUserId(token);
+		const webId = generateWebId();
+		const modelInfo = TRAE_SOLO_REMOTE_MODELS.find((m) => m.name.toLowerCase() === model.toLowerCase()) ?? {
+			name: model,
+			displayName: model,
+			multimodal: false
+		};
+		const conversation = serializeTraeConversation(messages);
+		const body = {
+			mode: "code",
+			environment_id: "default",
+			env: "remote",
+			auto_create_project: false,
+			origin: "web",
+			initial_message: {
+				chat_session_id: "",
+				content: [],
+				query: JSON.stringify([{
+					type: "text",
+					data: { content: conversation }
+				}]),
+				model_name: modelInfo.name,
+				agent_type: "solo_agent_remote",
+				model_selection_strategy: "manual",
+				custom_model: {
+					name: modelInfo.name,
+					multimodal: modelInfo.multimodal,
+					is_default: false,
+					display_name: modelInfo.displayName,
+					config_name: modelInfo.name,
+					config_source: 1,
+					provider: "",
+					ak: "",
+					sk: "",
+					base_url: "",
+					auth_type: 0,
+					use_remote_service: true
+				},
+				common_params: buildCommonParams(userId, webId)
+			}
+		};
+		const createResponse = await this.fetchImpl(`${this.baseUrl}/chat_sessions`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+			signal: signal ?? AbortSignal.timeout(3e4)
+		});
+		const createJson = await createResponse.json();
+		if (!createResponse.ok || createJson.code !== 0 || !createJson.data?.chat_session_id) throw new Error(`SOLO remote session creation failed (http ${createResponse.status}): ${createJson.message ?? "unknown error"}`);
+		const sessionId = createJson.data.chat_session_id;
+		const start = Date.now();
+		while (Date.now() - start < this.timeoutMs) {
+			if (signal?.aborted) throw new Error("SOLO remote polling aborted");
+			await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+			const messageResponse = await this.fetchImpl(`${this.baseUrl}/chat_sessions/${sessionId}/messages?page_size=50`, {
+				headers,
+				...signal === void 0 ? {} : { signal }
+			});
+			if (!messageResponse.ok) continue;
+			const assistant = ((await messageResponse.json()).data?.items ?? []).find((item) => item.role === "assistant");
+			if (assistant && assistant.status !== "in_progress" && assistant.status !== "failed") return {
+				content: extractContent(assistant.content ?? ""),
+				sessionId
+			};
+			if (assistant?.status === "failed") throw new Error("SOLO remote assistant message failed");
+		}
+		throw new Error("SOLO remote polling timed out");
+	}
+	async fetchModels(signal) {
+		const headers = await this.headers();
+		const response = await this.fetchImpl(`${this.baseUrl}/models?functions=solo_agent_remote,solo_work_remote`, {
+			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 ?? []) {
+			const model = parseTraeRemoteModel(raw);
+			if (model === void 0 || seen.has(model.id)) continue;
+			seen.add(model.id);
+			models.push(model);
+		}
+		return models;
+	}
+};
+//#endregion
+//#region src/raw-chat.ts
+const TRAE_RAW_CHAT_V2_PATH = "/api/ide/v2/llm_raw_chat";
+const TRAE_RAW_CHAT_V1_PATH = "/api/ide/v1/llm_raw_chat";
+/**
+* Evidence-bounded OpenAI-like draft inferred from Trae's LLMRaw* DTO symbols.
+* Pure/offline only: the upstream remains disabled until one controlled probe.
+*/
+function buildTraeRawChatDraft(input) {
+	if (input.model.trim() === "") throw new Error("Trae raw chat requires a model");
+	if (input.messages.length === 0) throw new Error("Trae raw chat requires messages");
+	return {
+		model: input.model,
+		messages: structuredClone([...input.messages]),
+		stream: true,
+		...input.tools === void 0 || input.tools.length === 0 ? {} : { tools: structuredClone([...input.tools]) },
+		...input.maxTokens === void 0 ? {} : { max_tokens: input.maxTokens },
+		...input.temperature === void 0 ? {} : { temperature: input.temperature },
+		...input.reasoningEffort === void 0 ? {} : { reasoning_effort: input.reasoningEffort },
+		...input.extraInfo === void 0 ? {} : { extra_info: structuredClone(input.extraInfo) }
+	};
+}
+/** Decode OpenAI-like raw-chat chunks while preserving unknown structures. */
+function decodeRawChatChunk(value) {
+	if (value === "[DONE]") return [{
+		type: "done",
+		finishReason: "stop"
+	}];
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return [{
+		type: "unknown",
+		value
+	}];
+	const record = value;
+	const result = [];
+	const choices = Array.isArray(record["choices"]) ? record["choices"] : [];
+	for (const rawChoice of choices) {
+		if (typeof rawChoice !== "object" || rawChoice === null) continue;
+		const choice = rawChoice;
+		const delta = typeof choice["delta"] === "object" && choice["delta"] !== null ? choice["delta"] : {};
+		if (typeof delta["reasoning_content"] === "string" && delta["reasoning_content"] !== "") result.push({
+			type: "reasoning",
+			text: delta["reasoning_content"]
+		});
+		if (typeof delta["content"] === "string" && delta["content"] !== "") result.push({
+			type: "text",
+			text: delta["content"]
+		});
+		if (Array.isArray(delta["tool_calls"])) for (const rawTool of delta["tool_calls"]) {
+			if (typeof rawTool !== "object" || rawTool === null) continue;
+			const tool = rawTool;
+			const fn = typeof tool["function"] === "object" && tool["function"] !== null ? tool["function"] : {};
+			result.push({
+				type: "tool-call",
+				index: typeof tool["index"] === "number" ? tool["index"] : 0,
+				...typeof tool["id"] === "string" ? { id: tool["id"] } : {},
+				...typeof fn["name"] === "string" ? { name: fn["name"] } : {},
+				...typeof fn["arguments"] === "string" ? { arguments: fn["arguments"] } : {}
+			});
+		}
+		if (typeof choice["finish_reason"] === "string" && choice["finish_reason"] !== "") result.push({
+			type: "done",
+			finishReason: choice["finish_reason"]
+		});
+	}
+	if (typeof record["usage"] === "object" && record["usage"] !== null) {
+		const usage = record["usage"];
+		result.push({
+			type: "usage",
+			...typeof usage["prompt_tokens"] === "number" ? { inputTokens: usage["prompt_tokens"] } : {},
+			...typeof usage["completion_tokens"] === "number" ? { outputTokens: usage["completion_tokens"] } : {},
+			...typeof usage["total_tokens"] === "number" ? { totalTokens: usage["total_tokens"] } : {}
+		});
+	}
+	return result.length === 0 ? [{
+		type: "unknown",
+		value
+	}] : result;
+}
+//#endregion
+//#region src/raw-runtime-config.ts
+/** Merge safe current-cache facts with observed behavior flags; no network credentials enter this object. */
+function traeRawChatExtraInfo(config) {
+	return {
+		...config.nativeFunctionCall === void 0 ? {} : { native_function_call: config.nativeFunctionCall },
+		...config.useV2Process === void 0 ? {} : { use_v2_process: config.useV2Process },
+		...config.maxModeEnabled === void 0 ? {} : { v2_max_mode_enabled: config.maxModeEnabled },
+		...config.maxToolcallChars === void 0 ? {} : { v3_max_toolcall_chars: config.maxToolcallChars },
+		...config.streamThrottleEnabled === void 0 ? {} : { v3_stream_throttle_enabled: config.streamThrottleEnabled }
+	};
+}
+function buildTraeRawChatRuntimeConfig(modelName, cached, behavior = {}) {
+	return {
+		configName: modelName,
+		modelName,
+		...cached?.promptMaxTokens === void 0 ? {} : { promptMaxTokens: cached.promptMaxTokens },
+		...cached?.maxTokens === void 0 ? {} : { maxTokens: cached.maxTokens },
+		...cached?.maxTurn === void 0 ? {} : { maxTurn: cached.maxTurn },
+		...cached?.multimodal === void 0 ? {} : { multimodal: cached.multimodal },
+		...cached?.customConfig === void 0 ? {} : { customConfig: structuredClone(cached.customConfig) },
+		...behavior.nativeFunctionCall === void 0 ? {} : { nativeFunctionCall: behavior.nativeFunctionCall },
+		...behavior.passBackReasoning === void 0 ? {} : { passBackReasoning: behavior.passBackReasoning },
+		...behavior.useV2Process === void 0 ? {} : { useV2Process: behavior.useV2Process },
+		...behavior.maxModeEnabled === void 0 ? {} : { maxModeEnabled: behavior.maxModeEnabled },
+		...behavior.maxToolcallChars === void 0 ? {} : { maxToolcallChars: behavior.maxToolcallChars },
+		...behavior.streamThrottleEnabled === void 0 ? {} : { streamThrottleEnabled: behavior.streamThrottleEnabled }
+	};
+}
+//#endregion
+//#region src/raw-upstream.ts
+function classifyTraeRawChatFailure(message) {
+	const text = message.trim();
+	if (text === "") return "empty";
+	if (text.startsWith("{") || text.startsWith("[")) return "json";
+	if (/permission|forbidden|unauthorized|auth/i.test(text)) return "permission";
+	if (/model|config_name|config name/i.test(text)) return "model";
+	if (/schema|field|parameter|invalid|missing|required|parse/i.test(text)) return "schema";
+	if (/^Trae Raw Chat returned HTTP \d{3}$/i.test(text)) return "generic-http";
+	return "other";
+}
+function errorKind(status) {
+	if (status === 401 || status === 403) return "authentication";
+	if (status === 402) return "hard_credit";
+	if (status === 429) return "soft_rate";
+	if (status === 404) return "not_found";
+	if (status >= 500) return "server";
+	return "client";
+}
+/**
+* Evidence-gated Raw Chat client. It is fully testable through injected fetch,
+* but production callers must not construct it without verified config values.
+*/
+var TraeRawChatUpstreamClient = class {
+	options;
+	fetchImpl;
+	constructor(options) {
+		this.options = options;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		if (options.config.configName.trim() === "") throw new Error("Trae Raw Chat configName must be evidence-backed and non-empty");
+	}
+	async chatStream(bodyJson, signal) {
+		let input;
+		try {
+			input = JSON.parse(bodyJson);
+		} catch {
+			return {
+				ok: false,
+				status: 400,
+				kind: "client",
+				message: "invalid JSON request"
+			};
+		}
+		if (!Array.isArray(input.messages) || input.messages.length === 0) return {
+			ok: false,
+			status: 400,
+			kind: "client",
+			message: "messages are required"
+		};
+		const [credential, identity] = await Promise.all([this.options.credential(), this.options.identity()]);
+		const headers = buildTraeCnHeaders(credential, identity, {
+			requestId: crypto.randomUUID(),
+			profile: "raw-chat"
+		});
+		const runtime = this.options.config.runtime;
+		const runtimeExtra = runtime === void 0 ? {} : traeRawChatExtraInfo(runtime);
+		const body = {
+			...buildTraeRawChatDraft({
+				model: this.options.config.model,
+				messages: input.messages,
+				...input.tools === void 0 ? {} : { tools: input.tools },
+				...input.max_tokens === void 0 ? {} : { maxTokens: input.max_tokens },
+				...input.temperature === void 0 ? {} : { temperature: input.temperature },
+				...input.reasoning_effort === void 0 ? {} : { reasoningEffort: input.reasoning_effort },
+				...Object.keys(runtimeExtra).length === 0 && this.options.config.extraInfo === void 0 ? {} : { extraInfo: {
+					...runtimeExtra,
+					...this.options.config.extraInfo
+				} }
+			}),
+			config_name: this.options.config.configName,
+			...this.options.config.promptSet === void 0 ? {} : { prompt_set: this.options.config.promptSet },
+			...this.options.config.abVersion === void 0 ? {} : { ab_version: this.options.config.abVersion },
+			pass_back_reasoning: runtime?.passBackReasoning ?? this.options.config.passBackReasoning
+		};
+		let response;
+		try {
+			response = await this.fetchImpl(traeEndpoint(this.options.baseUrl ?? credential.host, TRAE_RAW_CHAT_V2_PATH), {
+				method: "POST",
+				headers,
+				body: JSON.stringify(body),
+				signal: signal ?? AbortSignal.timeout(3e4)
+			});
+		} catch (error) {
+			return {
+				ok: false,
+				status: 0,
+				kind: "server",
+				message: `transport error: ${String(error)}`
+			};
+		}
+		if (response.ok) return {
+			ok: true,
+			response
+		};
+		const text = (await response.text()).slice(0, 1024);
+		return {
+			ok: false,
+			status: response.status,
+			kind: errorKind(response.status),
+			message: text || `Trae Raw Chat returned HTTP ${response.status}`
+		};
+	}
+};
+//#endregion
+//#region src/raw-capability.ts
+/** One short non-tool request decides whether Raw Chat may become primary. */
+async function probeTraeRawChatCapability(client, signal) {
+	const body = JSON.stringify({
+		model: "qwen-3.7-plus",
+		messages: [{
+			role: "user",
+			content: "Reply with exactly: OK"
+		}],
+		max_tokens: 8,
+		temperature: 0
+	});
+	const result = await client.chatStream(body, signal);
+	if (result.ok) {
+		const contentType = result.response.headers.get("content-type");
+		await result.response.body?.cancel().catch(() => {});
+		return {
+			available: true,
+			contentType
+		};
+	}
+	return {
+		available: false,
+		reason: result.kind === "authentication" ? "authentication" : result.kind === "hard_credit" ? "credit" : result.kind === "soft_rate" ? "rate" : result.status === 400 || result.status === 404 || result.status === 415 || result.kind === "unconfigured" ? "protocol" : result.kind === "server" && result.status === 0 ? "transport" : "server",
+		status: result.status
+	};
+}
+//#endregion
+//#region src/raw-capability-state.ts
+/** In-memory capability state; success/failure expires and config changes invalidate it. */
+var TraeRawCapabilityState = class {
+	ttlMs;
+	snapshot = {};
+	constructor(ttlMs = 18e5) {
+		this.ttlMs = ttlMs;
+	}
+	current(fingerprint, now = Date.now()) {
+		const value = this.snapshot;
+		if (value.capability === void 0 || value.checkedAtMs === void 0 || value.fingerprint !== fingerprint) return void 0;
+		return now - value.checkedAtMs <= this.ttlMs ? value.capability : void 0;
+	}
+	record(fingerprint, capability, now = Date.now()) {
+		this.snapshot = {
+			fingerprint,
+			capability,
+			checkedAtMs: now
+		};
+	}
+	inspect() {
+		return { ...this.snapshot };
+	}
+	invalidate() {
+		this.snapshot = {};
+	}
+};
+//#endregion
+//#region src/raw-capability-controller.ts
+/** Explicitly-triggered, single-flight Raw Chat capability checks. */
+var TraeRawCapabilityController = class {
+	options;
+	state;
+	enabled;
+	inflight;
+	constructor(options) {
+		this.options = options;
+		this.state = options.state ?? new TraeRawCapabilityState();
+		this.enabled = options.enabled ?? false;
+	}
+	current(fingerprint) {
+		return this.enabled ? this.state.current(fingerprint) : void 0;
+	}
+	setEnabled(enabled) {
+		if (this.enabled !== enabled) this.state.invalidate();
+		this.enabled = enabled;
+	}
+	inspect() {
+		return this.state.inspect();
+	}
+	isEnabled() {
+		return this.enabled;
+	}
+	invalidate() {
+		this.state.invalidate();
+	}
+	probe(fingerprint, signal) {
+		if (!this.enabled) return Promise.resolve({
+			available: false,
+			reason: "protocol",
+			status: 0
+		});
+		const cached = this.state.current(fingerprint);
+		if (cached !== void 0) return Promise.resolve(cached);
+		this.inflight ??= probeTraeRawChatCapability(this.options.client, signal).then((result) => {
+			this.state.record(fingerprint, result);
+			return result;
+		}).finally(() => {
+			this.inflight = void 0;
+		});
+		return this.inflight;
+	}
+};
+//#endregion
+//#region src/raw-fingerprint.ts
+/** Stable non-secret fingerprint for capability-cache invalidation. */
+function rawCapabilityFingerprint(input) {
+	const stable = JSON.stringify({
+		endpoint: input.endpoint,
+		edition: input.edition,
+		appVersion: input.identity.appVersion ?? "",
+		buildVersion: input.identity.buildVersion ?? "",
+		runtime: input.runtime
+	});
+	return createHash("sha256").update(stable).digest("hex");
+}
+//#endregion
+//#region src/raw-diagnostic.ts
+/** Project capability facts to a redacted, user-safe status. */
+function rawCapabilityDiagnostic(enabled, capability, checkedAtMs) {
+	if (!enabled) return { state: "disabled" };
+	if (capability === void 0) return { state: "unchecked" };
+	if (capability.available) return {
+		state: "available",
+		...checkedAtMs === void 0 ? {} : { checkedAtMs }
+	};
+	return {
+		state: capability.reason === "protocol" ? "protocol-gated" : capability.reason,
+		status: capability.status,
+		...checkedAtMs === void 0 ? {} : { checkedAtMs }
+	};
+}
+//#endregion
+//#region src/fallback-upstream.ts
+/**
+* Raw Chat first, SOLO Remote second. Fallback is intentionally narrow:
+* only definitive pre-stream schema/route incompatibilities may retry the same
+* user request. Authentication, credit, rate, cancellation, transport/server
+* failures, and every successful Response are never replayed.
+*/
+var TraeFallbackUpstreamClient = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async chatStream(bodyJson, signal) {
+		const primary = await this.options.primary.chatStream(bodyJson, signal);
+		if (primary.ok) return primary;
+		if (!this.canFallback(primary, signal)) return primary;
+		this.options.onFallback?.(primary);
+		return this.options.fallback.chatStream(bodyJson, signal);
+	}
+	canFallback(result, signal) {
+		if (signal?.aborted === true) return false;
+		if (result.kind === "authentication" || result.kind === "hard_credit" || result.kind === "soft_rate") return false;
+		return result.status === 400 || result.status === 404 || result.status === 415 || result.kind === "unconfigured";
+	}
+};
+//#endregion
+//#region src/gated-upstream.ts
+/** Select Raw Chat only after a successful capability probe; SOLO is the safe default. */
+var TraeGatedUpstreamClient = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	chatStream(bodyJson, signal) {
+		if (this.options.capability()?.available !== true) return this.options.solo.chatStream(bodyJson, signal);
+		return new TraeFallbackUpstreamClient({
+			primary: this.options.raw,
+			fallback: this.options.solo,
+			...this.options.onFallback === void 0 ? {} : { onFallback: this.options.onFallback }
+		}).chatStream(bodyJson, signal);
+	}
+};
+//#endregion
+//#region src/raw-gateway.ts
+/** Assemble the opt-in capability state and safe Raw→SOLO routing. */
+function createTraeRawGateway(options) {
+	const fingerprint = () => rawCapabilityFingerprint(options);
+	const controller = new TraeRawCapabilityController({
+		client: options.raw,
+		enabled: options.enabled ?? false
+	});
+	return {
+		upstream: new TraeGatedUpstreamClient({
+			raw: options.raw,
+			solo: options.solo,
+			capability: () => controller.current(fingerprint())
+		}),
+		probe: (signal) => controller.probe(fingerprint(), signal),
+		diagnostic: () => {
+			const snapshot = controller.inspect();
+			return rawCapabilityDiagnostic(controller.isEnabled(), snapshot.capability, snapshot.checkedAtMs);
+		},
+		invalidate: () => controller.invalidate()
+	};
+}
+//#endregion
+//#region src/model-cache.ts
+const execFileAsync = promisify(execFile);
+function positive$1(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+/** Parse a safe subset of one cached model entry; credentials and endpoints are intentionally omitted. */
+function parseTraeCachedModel(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const raw = value;
+	if (typeof raw["name"] !== "string" || raw["name"] === "") return void 0;
+	let customConfig;
+	if (typeof raw["custom_config"] === "string" && raw["custom_config"] !== "") try {
+		const parsed = JSON.parse(raw["custom_config"]);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) customConfig = parsed;
+	} catch {}
+	const promptMaxTokens = positive$1(raw["prompt_max_tokens"]);
+	const maxTokens = positive$1(raw["max_tokens"]);
+	const maxTurn = positive$1(raw["max_turn"]);
+	return {
+		name: raw["name"],
+		...customConfig === void 0 ? {} : { customConfig },
+		...promptMaxTokens === void 0 ? {} : { promptMaxTokens },
+		...maxTokens === void 0 ? {} : { maxTokens },
+		...maxTurn === void 0 ? {} : { maxTurn },
+		...typeof raw["multimodal"] === "boolean" ? { multimodal: raw["multimodal"] } : {},
+		...typeof raw["model_type"] === "string" ? { modelType: raw["model_type"] } : {}
+	};
+}
+/** Read Trae's own current user's model map via sqlite3 without exposing secrets. */
+async function readTraeCachedModel(functionName, modelName, userId) {
+	const database = join(homedir(), "Library", "Application Support", "Trae CN", "User", "globalStorage", "state.vscdb");
+	const key = `${userId}_AI.agent.model.model_list_map`;
+	const sql = `select value from ItemTable where key=${JSON.stringify(key)} limit 1;`;
+	const { stdout } = await execFileAsync("sqlite3", [database, sql], { maxBuffer: 8388608 });
+	const document = JSON.parse(stdout);
+	return parseTraeCachedModel((Array.isArray(document[functionName]) ? document[functionName] : []).find((item) => typeof item === "object" && item !== null && item.name === modelName));
+}
+//#endregion
+//#region src/raw-resolver.ts
+/** Resolve current desktop identity and safe cached model config for capability probing. */
+async function resolveTraeRawRuntime(store, modelName) {
+	const credential = await store.resolve();
+	const candidate = store.candidates().find((item) => item.edition === credential.edition);
+	if (candidate === void 0) throw new Error(`no Trae ${credential.edition} storage candidate for Raw Chat identity`);
+	const identity = await readTraeIdentity(candidate);
+	const cached = credential.edition === "cn" ? await readTraeCachedModel("solo_agent", modelName, credential.userId).catch(() => void 0) : void 0;
+	return {
+		identity,
+		runtime: buildTraeRawChatRuntimeConfig(modelName, cached, {
+			passBackReasoning: true,
+			nativeFunctionCall: cached?.customConfig?.["native_function_call"] === true,
+			useV2Process: cached?.customConfig?.["use_v2_process"] === true
+		})
+	};
+}
+//#endregion
+//#region src/delegating-upstream.ts
+/** Stable shim dependency whose delegate can be replaced after async setup. */
+var TraeDelegatingUpstreamClient = class {
+	delegate;
+	constructor(delegate) {
+		this.delegate = delegate;
+	}
+	replace(delegate) {
+		this.delegate = delegate;
+	}
+	chatStream(bodyJson, signal) {
+		return this.delegate.chatStream(bodyJson, signal);
+	}
+};
+//#endregion
+//#region src/usage.ts
+/**
+* Read-only Trae usage/credits client.
+*
+* Sources the verified `api.trae.cn` pay/ug endpoints (see
+* `docs/USAGE_API_RESEARCH.md`). All queries are read-only and do not consume
+* Trae credits. The per-session consumption detail table is deliberately not
+* included: the endpoint returns no rows for the current account, so we only
+* expose what is actually retrievable.
+*/
+const TRAE_PAY_BASE = "https://api.trae.cn";
+function asNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseUsageSnapshot(payload) {
+	const summaryRaw = payload["usage_summary"];
+	const summary = {
+		totalAmount: asNumber(summaryRaw?.["total_amount"]) ?? 0,
+		consumedAmount: asNumber(summaryRaw?.["consumed_amount"]) ?? 0,
+		consumptionRatio: asNumber(summaryRaw?.["consumption_ratio"]) ?? 0
+	};
+	const trial = payload["trial_status"];
+	const packs = [];
+	const rawPacks = Array.isArray(payload["user_entitlement_pack_list"]) ? payload["user_entitlement_pack_list"] : [];
+	for (const raw of rawPacks) {
+		if (typeof raw !== "object" || raw === null) continue;
+		const pack = raw;
+		const base = pack["entitlement_base_info"];
+		const quota = base?.["quota"];
+		const usage = pack["usage"];
+		const packageQuota = ((base?.["product_extra"])?.["package_extra"])?.["quota"];
+		const creditsLimit = asNumber(packageQuota?.["credits_limit"]) ?? asNumber(quota?.["credits_limit"]);
+		const consumedCredits = asNumber(usage?.["credits_amount"]);
+		const availableEndpoint = asNumber(base?.["available_endpoint"]);
+		packs.push({
+			displayDesc: typeof pack["display_desc"] === "string" ? pack["display_desc"] : "",
+			entitlementId: typeof base?.["entitlement_id"] === "string" ? base["entitlement_id"] : "",
+			endTimeMs: asNumber(base?.["end_time"]) ?? 0,
+			currency: asNumber(base?.["currency"]) ?? 0,
+			...availableEndpoint === void 0 ? {} : { availableEndpoint },
+			...creditsLimit === void 0 ? {} : { creditsLimit },
+			...consumedCredits === void 0 ? {} : { consumedCredits }
+		});
+	}
+	return {
+		isCreditsBilling: payload["is_credits_billing"] === true,
+		isDollarUsageBilling: payload["is_dollar_usage_billing"] === true,
+		isPayFreshman: payload["is_pay_freshman"] === true,
+		inTrial: trial?.["is_in_trial"] === true,
+		trialEndTimeMs: asNumber(trial?.["trial_end_time"]) ?? 0,
+		summary,
+		packs
+	};
+}
+/**
+* A read-only client for the verified Trae usage/credits endpoints.
+* All methods are safe to call from a plugin and never mutate account state.
+*/
+var TraeUsageClient = class {
+	options;
+	fetchImpl;
+	baseUrl;
+	timeoutMs;
+	constructor(options) {
+		this.options = options;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.baseUrl = options.baseUrl ?? "https://api.trae.cn";
+		this.timeoutMs = options.timeoutMs ?? 3e4;
+	}
+	async authedHeaders() {
+		const credential = await this.options.credential();
+		if (credential === void 0 || credential.accessToken === "") throw new Error("Trae credential is not available; cannot query usage");
+		return {
+			"Authorization": `Cloud-IDE-JWT ${credential.accessToken}`,
+			"Content-Type": "application/json",
+			"User-Agent": "Mozilla/5.0",
+			"Origin": "https://www.trae.cn",
+			"Referer": "https://www.trae.cn/"
+		};
+	}
+	async post(path, data, signal) {
+		const headers = await this.authedHeaders();
+		const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(data),
+			signal: signal ?? AbortSignal.timeout(this.timeoutMs)
+		});
+		if (!response.ok) throw new Error(`Trae usage endpoint ${path} returned HTTP ${response.status}`);
+		return await response.json();
+	}
+	/** Total entitlements / credits and per-pack breakdown. */
+	async snapshot(signal) {
+		return parseUsageSnapshot(await this.post("/trae/api/v2/pay/web_user_ent_usage", { require_usage: true }, signal));
+	}
+	/** Daily check-in status. */
+	async checkinStatus(signal) {
+		const payload = await this.post("/trae/api/v2/ug/checkin_credits/status", {}, signal);
+		return {
+			checkedIn: payload["checked_in"] === true,
+			credits: asNumber(payload["credits"]) ?? 0,
+			enabled: payload["enable"] !== false
+		};
+	}
+	/** Rewards / activity rules. */
+	async activities(signal) {
+		const payload = await this.post("/trae/api/v2/ug/activity/info", {}, signal);
+		const rawActivities = Array.isArray(payload["commercial_activities"]) ? payload["commercial_activities"] : [];
+		const activities = [];
+		for (const raw of rawActivities) {
+			if (typeof raw !== "object" || raw === null) continue;
+			const rule = raw;
+			activities.push({
+				activityId: typeof rule["activity_id"] === "string" ? rule["activity_id"] : "",
+				enabled: rule["Enabled"] === true,
+				activityType: asNumber(rule["activity_type"]) ?? 0,
+				startTimeMs: asNumber(rule["start_time_ms"]) ?? 0,
+				endTimeMs: asNumber(rule["end_time_ms"]) ?? 0,
+				...rule["work_extra"] === void 0 ? {} : { workExtra: rule["work_extra"] }
+			});
+		}
+		return activities;
+	}
+	/** Convenience: snapshot + check-in + activities in one call (best-effort, non-fatal on missing). */
+	async view(signal) {
+		const [snapshot, checkin, activities] = await Promise.all([
+			this.snapshot(signal),
+			this.checkinStatus(signal),
+			this.activities(signal)
+		]);
+		return {
+			snapshot,
+			checkin,
+			activities
+		};
+	}
+};
+//#endregion
+//#region src/status-paths.ts
+/**
+* Node-free constants and types shared by the Host and browser halves.
+* Mirrors the `dsh-workbuddy-connect` status-route pattern so the plugin card
+* stays consistent with that project's external presentation.
+*/
+/** Plugin-owned usage endpoint consumed by its browser half. */
+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 local account rescan endpoint. */
+const TRAE_ACCOUNTS_REFRESH_PATH = "/plugins/dsh-connect-trae/accounts/refresh";
+//#endregion
+//#region src/web-status.ts
+/** Redact token-like content before it crosses to the browser. */
+function safeMessage(error) {
+	return (error instanceof Error ? error.message : String(error)).replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[redacted token]").replace(/(\b(?:code|token|refresh_token|access_token)=)[^&\s]+/giu, "$1[redacted]").slice(0, 500);
+}
+function json(res, status, body) {
+	const payload = JSON.stringify(body);
+	res.writeHead(status, {
+		"Content-Type": "application/json",
+		"Content-Length": Buffer.byteLength(payload)
+	});
+	res.end(payload);
+}
+/** Loopback browser origins only; other devices are refused until trusted origins exist. */
+function loopbackOrigin(req) {
+	const origin = req.headers.origin;
+	if (origin === void 0) return true;
+	try {
+		const { hostname } = new URL(origin);
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+	} catch {
+		return false;
+	}
+}
+/** Map the credit snapshot to the card's compact credit document. */
+function toCredits(snapshot) {
+	const { totalAmount, consumedAmount } = snapshot.summary;
+	const credit = (value) => Math.round(value * 1e4) / 1e4;
+	const accounts = snapshot.packs.map((pack) => ({
+		displayDesc: pack.displayDesc,
+		remain: credit(Math.max(0, (pack.creditsLimit ?? 0) - (pack.consumedCredits ?? 0))),
+		size: pack.creditsLimit ?? 0
+	}));
+	const remaining = (endpoint) => snapshot.packs.filter((pack) => pack.availableEndpoint === endpoint).reduce((sum, pack) => credit(sum + Math.max(0, (pack.creditsLimit ?? 0) - (pack.consumedCredits ?? 0))), 0);
+	return {
+		total: totalAmount,
+		consumed: consumedAmount,
+		available: totalAmount - consumedAmount,
+		workAvailable: remaining(1),
+		generalAvailable: remaining(0),
+		accounts
+	};
+}
+/**
+* Assemble the card's usage document. Sign-in state is read-only; credit is a
+* live billing answer whose failure degrades to `creditsError` rather than
+* failing the whole document.
+*/
+async function traeWebUsage(deps) {
+	const accounts = await deps.store.accounts();
+	if ((await deps.store.status()).state !== "signed-in") return {
+		status: "signed-out",
+		accounts
+	};
+	let credential;
+	try {
+		credential = await deps.store.resolve();
+	} catch (error) {
+		return {
+			status: "signed-out",
+			accounts,
+			message: safeMessage(error)
+		};
+	}
+	const account = {
+		accountId: accounts.find((item) => item.selected)?.id ?? "",
+		accountName: credential.accountName ?? credential.userId,
+		tokenExpiresAtMs: credential.expiresAtMs,
+		accounts,
+		models: deps.displayModels().map((model) => ({
+			...model,
+			...model.input === void 0 ? {} : { input: [...model.input] }
+		})),
+		enabledModelIds: [...deps.enabledModelIds()],
+		enabled1mModelIds: [...deps.enabled1mModelIds()],
+		...deps.rawDiagnostic === void 0 ? {} : { rawChat: deps.rawDiagnostic() }
+	};
+	try {
+		const snapshot = await deps.client.snapshot();
+		return {
+			status: "signed-in",
+			...account,
+			credits: toCredits(snapshot)
+		};
+	} catch (error) {
+		return {
+			status: "signed-in",
+			...account,
+			creditsError: safeMessage(error)
+		};
+	}
+}
+/** Mount the GET usage route on an optional webServer context. */
+function registerTraeUsageRoute(ctx, deps) {
+	ctx.effect(() => {
+		const disposeUsage = ctx.webServer.register({
+			kind: "exact",
+			path: TRAE_USAGE_PATH,
+			handler: async (req, res) => {
+				if (req.method !== "GET") {
+					json(res, 405, { error: "method not allowed" });
+					return;
+				}
+				if (!loopbackOrigin(req)) {
+					json(res, 403, { error: "origin-not-trusted" });
+					return;
+				}
+				try {
+					json(res, 200, await traeWebUsage(deps));
+				} catch (error) {
+					json(res, 500, { error: safeMessage(error) });
+				}
+			}
+		});
+		const disposeAccounts = ctx.webServer.register({
+			kind: "exact",
+			path: TRAE_ACCOUNTS_REFRESH_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" });
+				try {
+					json(res, 200, { accounts: await deps.store.accounts() });
+				} catch (error) {
+					json(res, 500, { error: safeMessage(error) });
+				}
+			}
+		});
+		const disposeRefresh = ctx.webServer.register({
+			kind: "exact",
+			path: TRAE_MODELS_REFRESH_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.discoverModels === void 0) return json(res, 503, { error: "model refresh unavailable" });
+				try {
+					json(res, 200, { models: await deps.discoverModels() });
+				} catch (error) {
+					json(res, 500, { error: safeMessage(error) });
+				}
+			}
+		});
+		return () => {
+			disposeRefresh();
+			disposeAccounts();
+			disposeUsage();
+		};
+	}, "dsh-connect-trae: Web usage route");
+}
+//#endregion
+//#region src/model-config.ts
+/**
+* Parse a secret-free CustomModel debug line emitted by Trae. Optional values
+* remain absent when Trae prints None; we must not invent defaults for them.
+*/
+function parseObservedModelConfig(line) {
+	const match = /model_info: CustomModel \{([\s\S]*?)\}\s*(?:trace_id|$)/.exec(line);
+	if (match === null) return void 0;
+	const body = match[1] ?? "";
+	const stringField = (name) => new RegExp(`${name}: "([^"]+)"`).exec(body)?.[1];
+	const optionalField = (name) => new RegExp(`${name}: Some\\("([^"]+)"\\)`).exec(body)?.[1];
+	const configName = stringField("config_name");
+	const modelName = stringField("model_name");
+	if (configName === void 0 || modelName === void 0) return void 0;
+	const promptSet = optionalField("prompt_set");
+	const rawChatFunction = optionalField("raw_chat_function");
+	const abVersion = optionalField("ab_versions");
+	return {
+		configName,
+		modelName,
+		...promptSet === void 0 ? {} : { promptSet },
+		...rawChatFunction === void 0 ? {} : { rawChatFunction },
+		...abVersion === void 0 ? {} : { abVersion }
+	};
+}
+//#endregion
+//#region src/model-extra-config.ts
+function positive(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+/** Parse only Raw Chat behavior switches observed in Trae's model_extra_config. */
+function parseTraeRawChatBehaviorConfig(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	const raw = value;
+	const maxToolcallChars = positive(raw["v3_max_toolcall_chars"]);
+	return {
+		...typeof raw["pass_back_reasoning"] === "boolean" ? { passBackReasoning: raw["pass_back_reasoning"] } : {},
+		...typeof raw["native_function_call"] === "boolean" ? { nativeFunctionCall: raw["native_function_call"] } : {},
+		...typeof raw["use_v2_process"] === "boolean" ? { useV2Process: raw["use_v2_process"] } : {},
+		...typeof raw["v2_max_mode_enabled"] === "boolean" ? { maxModeEnabled: raw["v2_max_mode_enabled"] } : {},
+		...maxToolcallChars === void 0 ? {} : { maxToolcallChars },
+		...typeof raw["v3_stream_throttle_enabled"] === "boolean" ? { streamThrottleEnabled: raw["v3_stream_throttle_enabled"] } : {}
+	};
+}
+/** Extract the JSON object from one native model_extra_config parse log line. */
+function parseTraeModelExtraConfigLogLine(line) {
+	const at = line.indexOf(", raw: ");
+	if (at === -1) return void 0;
+	const candidate = line.slice(at + 7).trim();
+	try {
+		return parseTraeRawChatBehaviorConfig(JSON.parse(candidate));
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/model-detail.ts
+const TRAE_MODEL_DETAIL_PATH = "/api/ide/v1/batch_get_detail_param";
+const TRAE_MODEL_DETAIL_FUNCTIONS = [
+	"ui_builder_v2",
+	"solo_coder",
+	"chat_v3",
+	"solo_builder",
+	"builder_v3",
+	"builder",
+	"chat",
+	"inline_chat",
+	"git_ai",
+	"custom_agent_generation",
+	"utils",
+	"code_reviewer",
+	"code_review_summary",
+	"solo_agent",
+	"solo_agent_remote",
+	"solo_work_remote",
+	"solo_agent_lite",
+	"solo_work_lite",
+	"solo_design_lite",
+	"solo_design_remote",
+	"multimodal",
+	"system_diagnosis"
+];
+/** Build the exact request shape observed in successful current Trae CN logs. */
+function buildTraeModelDetailRequest(configName = "", custom = false) {
+	return {
+		functions: [...TRAE_MODEL_DETAIL_FUNCTIONS],
+		agent_type: configName === "" ? "" : "solo_agent",
+		current_config_info: {
+			config_name: configName,
+			is_custom_model: custom
+		},
+		mode_type: 0,
+		access_type: 0,
+		ab_force_vids: "",
+		ab_autotest_advanced_mode: 0
+	};
+}
+//#endregion
+//#region src/raw-envelope.ts
+/** Stable JSON hash candidate used by the native DTO's arg/args_hash fields. */
+function hashTraeRawChatArg(arg) {
+	return createHash("sha256").update(JSON.stringify(arg)).digest("hex");
+}
+/**
+* Evidence-bounded fusion envelope candidate. The native DTO exposes exactly
+* arg/args_hash/config_json, but the hash algorithm and config_json contents
+* remain candidates until a live response validates them.
+*/
+function buildTraeFusionRawChatEnvelope(arg, config) {
+	return {
+		arg: structuredClone(arg),
+		args_hash: hashTraeRawChatArg(arg),
+		config_json: JSON.stringify(config)
+	};
+}
+//#endregion
+//#region src/solo-remote-bridge.ts
+function classify(status) {
+	if (status === 401 || status === 403) return "authentication";
+	if (status === 402) return "hard_credit";
+	if (status === 429) return "soft_rate";
+	if (status === 404) return "not_found";
+	if (status >= 500) return "server";
+	return "client";
+}
+/**
+* Bridges the SOLO remote polling-based API into the shim's stream interface.
+* The remote API uses create-session + poll-messages rather than raw SSE,
+* so this bridge converts the final result into a synthetic OpenAI SSE stream.
+*/
+var TraeSoloRemoteBridge = class {
+	remote;
+	constructor(remote) {
+		this.remote = remote;
+	}
+	async chatStream(bodyJson, signal) {
+		let parsed;
+		try {
+			parsed = JSON.parse(bodyJson);
+		} catch {
+			return {
+				ok: false,
+				status: 400,
+				kind: "client",
+				message: "invalid JSON request"
+			};
+		}
+		if (!Array.isArray(parsed.messages) || parsed.messages.length === 0) return {
+			ok: false,
+			status: 400,
+			kind: "client",
+			message: "messages are required"
+		};
+		const messages = parsed.messages.flatMap((message) => {
+			if (typeof message.role !== "string") return [];
+			if (typeof message.content === "string") return [{
+				role: message.role,
+				content: message.content
+			}];
+			if (!Array.isArray(message.content)) return [];
+			const content = message.content.flatMap((part) => {
+				if (typeof part !== "object" || part === null) return [];
+				const item = part;
+				const text = typeof item.text === "string" ? item.text : typeof item.content === "string" ? item.content : void 0;
+				return text === void 0 ? [] : [text];
+			}).join("\n");
+			return content === "" ? [] : [{
+				role: message.role,
+				content
+			}];
+		});
+		if (messages.length === 0) return {
+			ok: false,
+			status: 400,
+			kind: "client",
+			message: "text messages are required"
+		};
+		const model = typeof parsed.model === "string" && parsed.model !== "" ? parsed.model : "DeepSeek-V4-Flash";
+		const upstreamModel = model.endsWith("@1m") ? model.slice(0, -3) : model;
+		try {
+			const chunks = buildOpenAISseChunks((await this.remote.chat(messages, upstreamModel, signal)).content, model);
+			const encoder = new TextEncoder();
+			const stream = new ReadableStream({ start(controller) {
+				for (const chunk of chunks) controller.enqueue(encoder.encode(chunk));
+				controller.close();
+			} });
+			return {
+				ok: true,
+				response: new Response(stream, {
+					status: 200,
+					headers: { "Content-Type": "text/event-stream" }
+				})
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			const status = /timed out/i.test(message) ? 504 : /session creation failed/i.test(message) ? 502 : 502;
+			return {
+				ok: false,
+				status,
+				kind: classify(status),
+				message: message.slice(0, 400)
+			};
+		}
+	}
+};
+function buildOpenAISseChunks(content, model) {
+	const id = `chatcmpl-${randomUUID().replaceAll("-", "").slice(0, 24)}`;
+	const created = Math.floor(Date.now() / 1e3);
+	const chunks = [];
+	if (content !== "") chunks.push(`data: ${JSON.stringify({
+		id,
+		object: "chat.completion.chunk",
+		created,
+		model,
+		choices: [{
+			index: 0,
+			delta: { content },
+			finish_reason: null
+		}]
+	})}\n\n`);
+	chunks.push(`data: ${JSON.stringify({
+		id,
+		object: "chat.completion.chunk",
+		created,
+		model,
+		choices: [{
+			index: 0,
+			delta: {},
+			finish_reason: "stop"
+		}]
+	})}\n\n`);
+	chunks.push("data: [DONE]\n\n");
+	return chunks;
+}
+//#endregion
+//#region src/upstream.ts
+/**
+* Safe first-stage upstream. Real Trae traffic stays disabled until one
+* edition-specific endpoint and wire codec are verified with fixtures.
+*/
+var UnconfiguredTraeUpstreamClient = class {
+	async chatStream(_bodyJson, _signal) {
+		return {
+			ok: false,
+			status: 503,
+			kind: "unconfigured",
+			message: "Trae upstream protocol is not configured; complete offline protocol verification first"
+		};
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "llm-trae";
+const inject = ["llm"];
+const TRAE_SETTINGS_NS = settingsNamespace("trae");
+const modelConfig = z.object({
+	id: z.string().required(),
+	name: z.string().required(),
+	contextWindow: z.number().step(1).min(1),
+	maxTokens: z.number().step(1).min(1),
+	input: z.array(z.union(["text", "image"]))
+});
+const Config = z.object({
+	authFile: z.string().description("Optional Trae storage.json path override"),
+	edition: z.union([
+		"auto",
+		"cn",
+		"sg",
+		"solo",
+		"solo-sg"
+	]).default("auto").description("Trae edition hint"),
+	accountId: z.string().description("Selected local Trae account id (never a token)"),
+	lastCatalog: z.array(modelConfig).description("Last refreshed Trae raw model directory shown by the plugin card"),
+	enabledModelIds: z.array(z.string()).default([]).description("Trae model ids the user enabled"),
+	enabled1mModels: z.array(z.string()).default([]).description("Trae model ids whose 1M variants are enabled"),
+	models: z.array(modelConfig).description("Legacy generated Trae model list")
+});
+function apply(ctx, config) {
+	const catalog = new TraeCatalog();
+	const enabledSet = (value) => new Set(value.enabledModelIds ?? []);
+	const enabled1mSet = (value) => new Set(value.enabled1mModels ?? []);
+	const configuredModels = (value) => {
+		if (value.lastCatalog?.length) return deriveCatalog(value.lastCatalog, enabledSet(value), enabled1mSet(value));
+		return value.models?.length ? value.models : FALLBACK_TRAE_MODELS;
+	};
+	const displayModels = (value) => value.lastCatalog?.length ? value.lastCatalog : value.models?.length ? value.models : FALLBACK_TRAE_MODELS;
+	const store = new TraeCredentialStore({
+		...config.authFile === void 0 ? {} : { storagePath: config.authFile },
+		edition: config.edition ?? "auto",
+		...config.accountId === void 0 ? {} : { accountId: config.accountId },
+		refresh: (credential) => refreshTraeCredential(credential)
+	});
+	const identity = async () => {
+		const candidate = config.authFile === void 0 ? traeStorageCandidates().find((item) => (item.edition === "cn" || item.edition === "solo") && (config.edition === void 0 || config.edition === "auto" || item.edition === config.edition)) : {
+			edition: config.edition === void 0 || config.edition === "auto" ? "solo" : config.edition,
+			path: config.authFile
+		};
+		if (candidate === void 0) throw new Error("Trae storage was not found");
+		return readTraeIdentity(candidate);
+	};
+	const solo = new TraeSoloUpstreamClient({
+		credential: () => store.resolve(),
+		identity,
+		baseUrl: "https://trae-api-cn.mchost.guru"
+	});
+	const remote = new TraeSoloRemoteClient({ credential: () => store.resolve() });
+	const upstream = new TraeSoloBridge(solo);
+	const delegating = new TraeDelegatingUpstreamClient(upstream);
+	const shim = createTraeShim({
+		catalog,
+		client: delegating,
+		logger: ctx.logger
+	});
+	let rawDiagnostic = () => ({ state: "disabled" });
+	(async () => {
+		try {
+			const { identity, runtime } = await resolveTraeRawRuntime(store, "qwen-3.7-plus");
+			const gateway = createTraeRawGateway({
+				raw: new TraeRawChatUpstreamClient({
+					credential: () => store.resolve(),
+					identity: async () => identity,
+					config: {
+						model: runtime.modelName,
+						configName: runtime.configName,
+						passBackReasoning: true,
+						runtime
+					},
+					baseUrl: "https://trae-api-cn.mchost.guru"
+				}),
+				solo: upstream,
+				endpoint: "https://trae-api-cn.mchost.guru/api/ide/v2/llm_raw_chat",
+				edition: identity.edition,
+				identity: {
+					appVersion: identity.appVersion ?? "",
+					buildVersion: identity.buildVersion ?? ""
+				},
+				runtime,
+				enabled: false
+			});
+			delegating.replace(gateway.upstream);
+			rawDiagnostic = () => gateway.diagnostic();
+			ctx.effect(() => () => gateway.invalidate(), "dsh-connect-trae: Raw capability invalidation");
+		} catch (error) {
+			ctx.logger.warn("dsh-connect-trae: Raw gateway unavailable; continuing with native SOLO tool-call channel", error);
+		}
+	})();
+	const selectPreferredGeneralAccount = async () => {
+		try {
+			const accounts = await store.accounts();
+			const scored = [];
+			for (const account of accounts) try {
+				store.selectAccount(account.id);
+				const credential = await store.resolve();
+				const snapshot = await new TraeUsageClient({ credential: async () => credential }).snapshot();
+				const general = Math.round(snapshot.packs.filter((pack) => pack.availableEndpoint === 0).reduce((sum, pack) => sum + Math.max(0, (pack.creditsLimit ?? 0) - (pack.consumedCredits ?? 0)), 0) * 1e4) / 1e4;
+				scored.push({
+					id: account.id,
+					general
+				});
+			} catch (error) {
+				ctx.logger.warn(`dsh-connect-trae: account ${account.id} unavailable for default selection`, error);
+			}
+			scored.sort((a, b) => b.general - a.general);
+			store.setPreferAccountIds(scored.filter((item) => item.general > 0).map((item) => item.id));
+			store.setSource(config.authFile, config.edition ?? "auto", config.accountId);
+		} catch (error) {
+			ctx.logger.warn("dsh-connect-trae: default account selection failed; continuing", error);
+		}
+	};
+	const usageClient = new TraeUsageClient({ credential: () => store.resolve() });
+	let current = () => config;
+	let invalidateAdapter = () => {};
+	const discoverModels = async (signal) => {
+		return discoveredCatalog(await remote.fetchModels(signal), /* @__PURE__ */ new Set());
+	};
+	ctx.inject(["webServer"], (webCtx) => registerTraeUsageRoute(webCtx, {
+		store,
+		client: usageClient,
+		displayModels: () => displayModels(current()),
+		enabledModelIds: () => current().enabledModelIds ?? [],
+		enabled1mModelIds: () => current().enabled1mModels ?? [],
+		discoverModels,
+		rawDiagnostic: () => rawDiagnostic()
+	}));
+	installSettingsSection(ctx, TRAE_SETTINGS_NS, Config, config, {
+		setSource(source) {
+			current = source;
+		},
+		onChange() {
+			const next = current();
+			store.setSource(next.authFile, next.edition ?? "auto", next.accountId);
+			catalog.set(configuredModels(next));
+			invalidateAdapter();
+		}
+	});
+	let stopped = false;
+	ctx.effect(() => () => {
+		stopped = true;
+		shim.close();
+	});
+	shim.ready.then(async () => {
+		if (stopped) return;
+		await selectPreferredGeneralAccount();
+		catalog.set(configuredModels(current()));
+		const trae = createTraeAdapter({
+			shim,
+			catalog,
+			resolveAttachments: () => ctx.get("attachments")
+		});
+		invalidateAdapter = () => {
+			trae.invalidate();
+		};
+		let releaseAdapter;
+		let releaseDirectory;
+		try {
+			releaseAdapter = ctx.llm.registerAdapter([TRAE_PROVIDER], trae.adapter);
+			ctx.llm.registerModelDiscovery(TRAE_SETTINGS_NS, async (request) => {
+				if (request.provider !== "trae") return [];
+				return (await discoverModels(request.signal)).map((model) => ({
+					id: model.id,
+					name: model.name,
+					...model.contextWindow === void 0 ? {} : { contextWindow: model.contextWindow },
+					...model.maxTokens === void 0 ? {} : { maxTokens: model.maxTokens }
+				}));
+			});
+			releaseDirectory = ctx.llm.registerConfigurableProviders([{
+				provider: TRAE_PROVIDER,
+				displayName: "Trae",
+				settingsNs: TRAE_SETTINGS_NS,
+				settingsPath: [],
+				declared: false
+			}]);
+		} finally {
+			if (releaseAdapter === void 0 || releaseDirectory === void 0) {
+				releaseAdapter?.();
+				releaseDirectory?.();
+			}
+		}
+		try {
+			ctx.effect(() => () => {
+				releaseAdapter?.();
+				releaseDirectory?.();
+			});
+		} catch {
+			releaseAdapter?.();
+			releaseDirectory?.();
+		}
+	}).catch((error) => {
+		ctx.logger.error("dsh-connect-trae: loopback shim failed; provider not registered", error);
+	});
+}
+//#endregion
+export { Config, FALLBACK_TRAE_MODELS, SseDecoder, TRAE_CN_AGENT_TASK_PATH, TRAE_CN_TITLE_PATH, TRAE_MODEL_DETAIL_FUNCTIONS, TRAE_MODEL_DETAIL_PATH, TRAE_PAY_BASE, TRAE_PROVIDER, TRAE_RAW_CHAT_V1_PATH, TRAE_RAW_CHAT_V2_PATH, TRAE_REASONING_EFFORTS, TRAE_SETTINGS_NS, TRAE_SOLO_CHAT_PATH, TRAE_SOLO_FUNCTION, TRAE_SOLO_MODELS_PATH, TRAE_SOLO_REMOTE_BASE, TRAE_SOLO_REMOTE_MODELS, TRAE_STREAM_IDLE_TIMEOUT_MS, TRAE_USAGE_PATH, TRAE_VERSION_CODE_FALLBACK, TraeCatalog, TraeCredentialStore, TraeDelegatingUpstreamClient, TraeFallbackUpstreamClient, TraeGatedUpstreamClient, TraeRawCapabilityController, TraeRawCapabilityState, TraeRawChatUpstreamClient, TraeSoloBridge, TraeSoloRemoteBridge, TraeSoloRemoteClient, TraeSoloUpstreamClient, TraeUsageClient, UnconfiguredTraeUpstreamClient, apply, applyReasoningEffort, bridgeTraeSoloStream, buildTraeAgentTaskBody, buildTraeCnHeaders, buildTraeFusionRawChatEnvelope, buildTraeModelDetailRequest, buildTraeRawChatDraft, buildTraeRawChatRuntimeConfig, classifyTraeRawChatFailure, createTraeAdapter, createTraeRawGateway, createTraeShim, decodeRawChatChunk, decodeTraeEvent, decryptTraeStorageValue, discoveredCatalog, hashTraeRawChatArg, identityHeaders, inject, name, normalizeTraeCredential, normalizeTraeVersionCode, parseObservedModelConfig, parseReasoningCapability, parseTraeAuthValue, parseTraeCachedModel, parseTraeModelExtraConfigLogLine, parseTraeRawChatBehaviorConfig, parseTraeRemoteModel, parseTraeStorageDocument, prepareSoloBody, probeTraeRawChatCapability, rawCapabilityDiagnostic, rawCapabilityFingerprint, readTraeCachedModel, readTraeIdentity, refreshTraeCredential, registerTraeUsageRoute, resolveTraeRawRuntime, traeEndpoint, traeOwnAuthPath, traeRawChatExtraInfo, traeStorageCandidates, traeWebUsage };