dsh-codearts 0.0.0-stage → 0.2.1

package/lib/index.mjs

@@ -0,0 +1,1320 @@
+import { _ as CodeArtsAccountStore, a as SNAP_HOST, b as codeartsAuthPath, c as fetchCallerIdentity, d as maxTokensCeilingFor, f as prepareChatBody, g as isBenefitModel, h as filterEnabledModels, i as refreshCatalog, l as fetchModels, m as FALLBACK_CODEARTS_MODELS, n as codeartsUsagePath, o as canonicalModel, p as CodeArtsCatalog, r as discoverModels, s as chatStream, t as CodeArtsUsageTracker, u as isConcurrencyCap, v as CodeArtsCredentialStore, x as startLogin, y as codeartsAccountsPath } from "./usage-ClRZWUS4.mjs";
+import z from "@deepseek-ai/schemastery";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+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 * as settingsModule from "@deepseek-ai/dsh-settings";
+/**
+* 撞到上游并发上限后，多久内优先不选这个账号。
+*
+* 这不是冷却：账号本身没坏，只是它的会话槽位暂时满了（约 52 秒才释放）。
+* 所以只是一个「倾向」——池里还有别的账号就先换一个；全都这样时照样会选它，
+* 因为排队等它总比直接失败强。
+*/
+const CAPPED_HINT_MS = 3e4;
+var CodeArtsAccountPool = class {
+	accounts = /* @__PURE__ */ new Map();
+	maxConcurrent;
+	now;
+	constructor(ids, options = {}) {
+		this.maxConcurrent = options.maxConcurrent ?? 2;
+		this.now = options.now ?? (() => Date.now());
+		this.sync(ids);
+	}
+	/** 让池与账号文档对齐：新增的进来，删掉的出去。已有账号的运行时状态保留。 */
+	sync(ids) {
+		const wanted = new Set(ids);
+		for (const id of [...this.accounts.keys()]) if (!wanted.has(id)) this.accounts.delete(id);
+		for (const id of ids) {
+			if (this.accounts.has(id)) continue;
+			this.accounts.set(id, {
+				id,
+				activeConcurrent: 0,
+				maxConcurrent: this.maxConcurrent,
+				coolUntil: 0,
+				cappedUntil: 0,
+				disabled: false,
+				lastUsed: 0,
+				errorCount: 0
+			});
+		}
+	}
+	list() {
+		return [...this.accounts.values()];
+	}
+	get(id) {
+		return this.accounts.get(id);
+	}
+	/** 账号本身可用（没被禁用、不在冷却中）。 */
+	healthy(id) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return false;
+		return !account.disabled && this.now() >= account.coolUntil;
+	}
+	/** 现在就能接活的账号（健康 + 本地还有空槽位），按「最久未用」排序。 */
+	available(exclude) {
+		const now = this.now();
+		return this.list().filter((a) => !a.disabled && now >= a.coolUntil && !exclude.has(a.id) && a.activeConcurrent < a.maxConcurrent).sort((a, b) => a.lastUsed - b.lastUsed);
+	}
+	/**
+	* 选一个账号。
+	*
+	* 优先挑没人撞上限的（`cappedUntil` 已过的）；如果全都撞了，就退回其中任意
+	* 一个 —— 排它的队总比直接失败强。都没得选（全禁用/全在冷却）时返回 undefined。
+	*/
+	pick(exclude = /* @__PURE__ */ new Set()) {
+		const candidates = this.available(exclude);
+		if (candidates.length === 0) return void 0;
+		const now = this.now();
+		const notCapped = candidates.filter((a) => now >= a.cappedUntil);
+		return (notCapped.length > 0 ? notCapped[0] : candidates[0]).id;
+	}
+	/** 占一个本地槽位。占用失败（已满/不存在）返回 false。 */
+	acquire(id) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return false;
+		if (account.activeConcurrent >= account.maxConcurrent) return false;
+		account.activeConcurrent += 1;
+		account.lastUsed = this.now();
+		return true;
+	}
+	/** 释放槽位；重复释放不会把计数压到负数。 */
+	release(id) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return;
+		if (account.activeConcurrent > 0) account.activeConcurrent -= 1;
+	}
+	/**
+	* 撞到上游并发上限。
+	*
+	* **不冷却账号** —— 账号没坏，只是会话槽位暂时满了（约 52 秒释放）。冷却会
+	* 让它在一分钟内彻底不可用，反而把后续请求也一起误伤（Go 参考里也是这么
+	* 处理的）。这里只记一个「优先避开」的提示，好让并发的请求先去用别的账号。
+	*/
+	noteConcurrencyCap(id) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return;
+		account.cappedUntil = this.now() + CAPPED_HINT_MS;
+	}
+	/** 凭据失效等硬错误：直接停用，等用户重新登录。 */
+	disable(id, reason) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return;
+		account.disabled = true;
+		account.lastError = reason;
+	}
+	/** 上游 5xx / 软限流：短时冷却。 */
+	cooldown(id, ms, reason) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return;
+		account.coolUntil = this.now() + ms;
+		account.lastError = reason;
+	}
+	/** 累计错误；达到阈值就冷却。 */
+	noteError(id, threshold, cooldownMs, reason) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return;
+		account.errorCount += 1;
+		account.lastError = reason;
+		if (threshold > 0 && account.errorCount >= threshold) account.coolUntil = this.now() + cooldownMs;
+	}
+	/** 一次成功：清掉错误计数与冷却。 */
+	noteSuccess(id) {
+		const account = this.accounts.get(id);
+		if (account === void 0) return;
+		account.errorCount = 0;
+		account.coolUntil = 0;
+		account.lastError = void 0;
+	}
+	/** 有没有任何账号可用（含被撞上限提示的）。 */
+	hasUsable() {
+		const now = this.now();
+		return this.list().some((a) => !a.disabled && now >= a.coolUntil);
+	}
+};
+//#endregion
+//#region src/adapter.ts
+/**
+* The `codearts` pi-ai provider.
+*
+* One loopback-backed adapter registered into the Harness LLM seam, assembled
+* from the same public `dsh-llm-pi-ai` extension points dsh-codebuddy-cli uses.
+* The shim does the CodeArts wire translation; this file only describes the
+* models and points pi-ai at the shim's OpenAI-compatible endpoint.
+*
+* MVP simplifications vs dsh-codebuddy-cli:
+*   - no billing rate in the model name (CodeArts has no balance API)
+*   - no per-model reasoning ladder (models are surfaced as plain chat models)
+*
+* @module dsh-codearts/adapter
+*/
+/** Provider route this bundle owns. Keep in sync with cordis.patch.yml. */
+const CODEARTS_PROVIDER = "codearts";
+/**
+* Provider idle ceiling while one stream read is outstanding.
+*
+* 90s 而不是常见的 300s：华为免费推理后端实测会流中途停摆（吐几个 token 后
+* 长时间静默），300s 意味着用户要在"等待"里干等 5 分钟才进入自动重试。
+* 90s 足够容忍首 token 冷启动与推理间隙，又能让 DSH 的重试策略
+* （maxRetries=5, TIMEOUT 可重试）更快接管。
+*/
+const CODEARTS_STREAM_IDLE_TIMEOUT_MS = 9e4;
+/** No per-token pricing is knowable for a subscription quota; report zero. */
+const NO_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+};
+const REQUEST_IMAGE_BUDGETS = {
+	maxRequestImageBytes: 20971520,
+	requestImagePixelBudget: 4194304,
+	requestImageMaxBytes: 1048576
+};
+/** Inert pi-ai auth plane: the codearts route authenticates only via the shim secret. */
+const INERT_AUTH = {
+	credentials: {
+		async read() {},
+		async list() {
+			return [];
+		},
+		async modify() {
+			throw new Error("dsh-codearts: the codearts route has no pi-ai credential lifecycle");
+		},
+		async delete() {}
+	},
+	authContext: {
+		async env() {},
+		async fileExists() {
+			return false;
+		}
+	}
+};
+/** Build one pi-ai model descriptor pointing at the loopback shim. */
+function toPiModel(info, baseUrl) {
+	return {
+		id: info.id,
+		name: info.name,
+		api: "openai-completions",
+		provider: CODEARTS_PROVIDER,
+		baseUrl,
+		input: info.supportsImages === true ? ["text", "image"] : ["text"],
+		reasoning: false,
+		cost: NO_COST,
+		contextWindow: info.contextWindow,
+		maxTokens: info.maxTokens
+	};
+}
+function createCodeArtsAdapter(options) {
+	const { shim, catalog, enabledModels, resolveAttachments } = options;
+	const buildModels = () => {
+		const baseUrl = `${shim.baseUrl()}/v1`;
+		return catalog.current().map((info) => toPiModel(info, baseUrl));
+	};
+	const provider = {
+		...createProvider({
+			id: CODEARTS_PROVIDER,
+			name: "CodeArts",
+			auth: { apiKey: {
+				name: "CodeArts token",
+				async resolve({ credential }) {
+					const apiKey = credential?.key;
+					return apiKey === void 0 || apiKey.length === 0 ? void 0 : {
+						auth: { apiKey },
+						source: "CodeArts"
+					};
+				}
+			} },
+			models: buildModels(),
+			api: openAICompletionsApi()
+		}),
+		getModels: () => buildModels()
+	};
+	const profile = {
+		provider: CODEARTS_PROVIDER,
+		displayName: "CodeArts",
+		streamIdleTimeoutMs: CODEARTS_STREAM_IDLE_TIMEOUT_MS,
+		retryPolicy: resolveRetryPolicy(void 0, "dsh-codearts retryPolicy"),
+		configuredMaxTokens: /* @__PURE__ */ new Map(),
+		modelErrors: /* @__PURE__ */ new Map(),
+		...REQUEST_IMAGE_BUDGETS,
+		piProvider: provider
+	};
+	let profiles = /* @__PURE__ */ new Map([[CODEARTS_PROVIDER, profile]]);
+	return {
+		adapter: new CodeArtsPiAiAdapter(catalog, enabledModels, {
+			profiles: () => profiles,
+			auth: INERT_AUTH,
+			resolveApiKey: async () => shim.token(),
+			...resolveAttachments === void 0 ? {} : { resolveAttachments }
+		}),
+		invalidate: () => {
+			profiles = /* @__PURE__ */ new Map([[CODEARTS_PROVIDER, profile]]);
+		}
+	};
+}
+/**
+* Adapter that narrows the *offered* model surface to the enabled allowlist
+* (dispatch stays whole). Mirrors dsh-codebuddy-cli's CodeBuddyPiAiAdapter.
+*/
+var CodeArtsPiAiAdapter = class extends PiAiAdapter {
+	catalog;
+	enabledModels;
+	constructor(catalog, enabledModels, options) {
+		super(options);
+		this.catalog = catalog;
+		this.enabledModels = enabledModels;
+	}
+	async listModels(provider) {
+		const models = await super.listModels(provider);
+		const allowed = filterEnabledModels(this.catalog.current(), this.enabledModels?.());
+		const catalogIds = new Set(this.catalog.current().map((entry) => entry.id));
+		const allowedIds = new Set(allowed.map((entry) => entry.id));
+		return models.filter((model) => !catalogIds.has(model.id) || allowedIds.has(model.id));
+	}
+	async resolveModel(provider, model, signal) {
+		return super.resolveModel(provider, model, signal);
+	}
+};
+//#endregion
+//#region src/loopback.ts
+/**
+* Shared loopback gates for the plugin's local HTTP surfaces: the loopback
+* shim and the same-origin web-status route. Both are only ever meant to be
+* addressed through the machine's loopback interface.
+*
+* The 127.0.0.1 bind alone is not a trust boundary (any local process or a
+* DNS-rebinding page can reach 127.0.0.1), so both surfaces also check the
+* Host and Origin headers.
+*
+* @module dsh-codearts/loopback
+*/
+/**
+* Loopback hostnames a local plugin surface may be addressed by.
+*
+* `0.0.0.0` and `::` are deliberately absent: they are wildcard *bind*
+* addresses, not loopback identities, and accepting them in a Host header
+* would let a request that never went through the loopback interface pass.
+*/
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"[::1]"
+]);
+/** Strip the optional :port from a Host header value, IPv6-bracket aware. */
+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 && !hostname.slice(0, colon).includes(":") && /^\d+$/.test(hostname.slice(colon + 1))) hostname = hostname.slice(0, colon);
+	return hostname;
+}
+/**
+* The request's Host header must name the loopback interface. A DNS-rebinding
+* page (attacker domain re-resolved to 127.0.0.1) sends its own domain in
+* Host, so this check drops those before any routing happens.
+*/
+function hostIsLoopback(host) {
+	if (host === void 0 || host.trim() === "") return false;
+	return LOOPBACK_HOSTS.has(hostnameOfHost(host));
+}
+/**
+* A browser-sent Origin (present header) must be loopback. Non-browser
+* clients (the plugin's own fetch calls) send no Origin at all and pass.
+*/
+function originIsLoopback(origin) {
+	if (origin === void 0 || origin.trim() === "") return true;
+	try {
+		const { hostname } = new URL(origin);
+		return LOOPBACK_HOSTS.has(hostname) || hostname === "::1";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/shim.ts
+/**
+* Loopback OpenAI-compatible endpoint for CodeArts.
+*
+* DSH's pi-ai provider points here. The shim validates the loopback + shared
+* secret, resolves the pasted `cloud_dragon_token`, and forwards the request
+* to CodeArts' `/api/v2/chat/completions` — whose SSE chunk shape is already
+* OpenAI-compatible, so we pipe the upstream stream straight through.
+*
+* Inbound hardening (copied from dsh-codebuddy-cli): bind 127.0.0.1 only,
+* require a loopback Host header, a loopback Origin, and the per-process
+* shared secret as `Authorization: Bearer`. Any local attacker hitting the
+* port still cannot forge the secret.
+*
+* @module dsh-codearts/shim
+*/
+const REQUEST_BODY_LIMIT = 67108864;
+const KIND_STATUS = {
+	hard_credit: 402,
+	soft_rate: 429,
+	session_dead: 401,
+	not_found: 502,
+	server: 502,
+	client: 400
+};
+function isJsonContentType(req) {
+	const type = req.headers["content-type"];
+	return typeof type === "string" && type.trim().toLowerCase().startsWith("application/json");
+}
+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 writeOpenAIError(res, status, kind, message) {
+	writeJson(res, status, { error: {
+		message,
+		type: kind,
+		code: kind
+	} });
+}
+function readBody$1(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > REQUEST_BODY_LIMIT) {
+				reject(/* @__PURE__ */ new Error("request body too large"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks)));
+		req.on("error", reject);
+	});
+}
+/** 一次请求最多试几个账号（与 Go 参考的 MaxRotate 一致）。 */
+const MAX_ROTATE = 3;
+/**
+* 所有账号都撞上并发上限时，回落到「在同一账号上原地重发」的预算。
+*
+* 2026-09-30 实测：一个上游会话要 ~52s 才被释放，而且**中途打断并不减免** ——
+* 只跑了 98ms 就中止的请求，同样占满一个名额 52s。所以用户「打断 → 马上重问」
+* 时等的就是这个 52s。池里有别的账号时下面会直接换号（不用等）；这条是最后一根
+* 稻草，必须盖过 52s，否则用户看到的不是「稍等一下」而是直接失败。
+*
+* 上限受 pi-ai 的 90s idle 超时约束：等待期间我们发不出任何内容，超过 90s 用户
+* 看到的就是超时。75s 给 52s 留了余量，也还在 90s 之内。
+*/
+const CAP_WAIT_LIMIT = 75e3;
+const CAP_RETRY_GAP = 3e3;
+/** 上游 5xx 后短时冷却该账号。 */
+const SERVER_COOLDOWN_MS = 3e4;
+/** 零散错误累计到阈值后冷却该账号。 */
+const ERROR_COOLDOWN_MS = 6e4;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* 在**同一个账号**上重发，直到不再撞上限或预算耗尽。
+*
+* 只在没有别的账号可选时使用 —— 等 52s 是最后手段，能换号就换号。
+* 命中上限不甩给 pi-ai：429 会被重试 5 次，每次再去要一个会话，越试越满。
+*/
+async function openStream(credential, prepared, signal) {
+	const until = Date.now() + CAP_WAIT_LIMIT;
+	for (;;) {
+		const result = await chatStream(credential, prepared, signal);
+		if (result.ok) return result;
+		if (!(isConcurrencyCap(result) && !signal.aborted && Date.now() + CAP_RETRY_GAP <= until)) return result;
+		await sleep(CAP_RETRY_GAP);
+	}
+}
+function createCodeArtsShim(options) {
+	const { store, catalog } = options;
+	const logger = options.logger;
+	const usage = options.usage;
+	const pool = options.pool ?? new CodeArtsAccountPool([]);
+	const SHARED_SECRET = randomBytes(32).toString("base64url");
+	function bearerOk(req) {
+		const header = req.headers.authorization;
+		if (typeof header !== "string") return false;
+		const match = /^Bearer\s+(.+)$/i.exec(header.trim());
+		if (match === null) return false;
+		const presented = match[1];
+		const a = Buffer.from(presented);
+		const b = Buffer.from(SHARED_SECRET);
+		if (a.length !== b.length) return false;
+		return timingSafeEqual(a, b);
+	}
+	const server = createServer((req, res) => {
+		handle(req, res);
+	});
+	const ready = new Promise((resolve, reject) => {
+		server.once("listening", () => resolve());
+		server.once("error", reject);
+	});
+	server.listen(0, "127.0.0.1");
+	const baseUrl = () => {
+		const address = server.address();
+		if (address === null || typeof address === "string") throw new Error("codearts shim has no listening address");
+		return `http://127.0.0.1:${address.port}`;
+	};
+	async function handle(req, res) {
+		try {
+			if (!hostIsLoopback(req.headers.host)) {
+				writeOpenAIError(res, 403, "host_not_allowed", "Host header must name the loopback interface");
+				return;
+			}
+			if (!originIsLoopback(req.headers.origin)) {
+				writeOpenAIError(res, 403, "origin_not_allowed", "Origin must be a loopback origin");
+				return;
+			}
+			if (!bearerOk(req)) {
+				writeOpenAIError(res, 401, "unauthorized", "missing or invalid Authorization bearer");
+				return;
+			}
+			const url = req.url ?? "/";
+			if (req.method === "GET" && (url === "/healthz" || url === "/healthz/")) {
+				writeJson(res, 200, { ok: true });
+				return;
+			}
+			if (req.method === "GET" && (url === "/v1/models" || url === "/v1/models/")) {
+				writeJson(res, 200, {
+					object: "list",
+					data: catalog.current().map((model) => ({
+						id: model.id,
+						object: "model",
+						created: 0,
+						owned_by: "codearts"
+					}))
+				});
+				return;
+			}
+			if (req.method === "POST" && (url === "/v1/chat/completions" || url === "/v1/chat/completions/")) {
+				await chatCompletions(req, res);
+				return;
+			}
+			writeOpenAIError(res, 404, "not_found", `no such route: ${req.method} ${url}`);
+		} catch (error) {
+			if (!res.headersSent) writeOpenAIError(res, 500, "internal", String(error));
+			else res.end();
+		}
+	}
+	async function chatCompletions(req, res) {
+		if (!isJsonContentType(req)) {
+			writeOpenAIError(res, 415, "unsupported_media_type", "Content-Type must be application/json");
+			return;
+		}
+		const raw = (await readBody$1(req)).toString("utf8");
+		const prepared = prepareChatBody(raw);
+		const controller = new AbortController();
+		res.on("close", () => {
+			if (!res.writableEnded) controller.abort();
+		});
+		let ids;
+		try {
+			ids = await store.ids();
+		} catch (error) {
+			writeOpenAIError(res, 401, "not_signed_in", String(error));
+			return;
+		}
+		if (ids.length === 0) {
+			writeOpenAIError(res, 401, "not_signed_in", "no CodeArts account stored; sign in from the CodeArts settings card");
+			return;
+		}
+		pool.sync(ids);
+		const tried = /* @__PURE__ */ new Set();
+		let cappedAccount;
+		let lastKind;
+		let lastStatus = 0;
+		let lastMessage = "";
+		for (let attempt = 0; attempt < MAX_ROTATE; attempt += 1) {
+			const id = pool.pick(tried);
+			if (id === void 0) break;
+			tried.add(id);
+			if (!pool.acquire(id)) continue;
+			try {
+				const credential = await store.resolve(id);
+				if (credential === void 0) {
+					pool.disable(id, "no credential");
+					continue;
+				}
+				const result = await chatStream(credential, prepared, controller.signal);
+				if (controller.signal.aborted) {
+					if (result.ok) await result.stream.cancel().catch(() => {});
+					return;
+				}
+				if (result.ok) {
+					pool.noteSuccess(id);
+					await pipeToResponse(res, result.stream, controller.signal, {
+						accountId: id,
+						model: prepared.model
+					});
+					return;
+				}
+				lastKind = result.kind;
+				lastStatus = result.status;
+				lastMessage = result.message;
+				if (isConcurrencyCap(result)) {
+					pool.noteConcurrencyCap(id);
+					cappedAccount = id;
+					continue;
+				}
+				if (result.kind === "session_dead") {
+					pool.disable(id, result.message);
+					continue;
+				}
+				if (result.kind === "server" || result.kind === "soft_rate") {
+					pool.cooldown(id, SERVER_COOLDOWN_MS, result.message);
+					break;
+				}
+				pool.noteError(id, 3, ERROR_COOLDOWN_MS, result.message);
+				break;
+			} finally {
+				pool.release(id);
+			}
+		}
+		if (controller.signal.aborted) return;
+		if (cappedAccount !== void 0) {
+			if (pool.acquire(cappedAccount)) try {
+				const credential = await store.resolve(cappedAccount);
+				if (credential !== void 0) {
+					const result = await openStream(credential, prepared, controller.signal);
+					if (controller.signal.aborted) {
+						if (result.ok) await result.stream.cancel().catch(() => {});
+						return;
+					}
+					if (result.ok) {
+						pool.noteSuccess(cappedAccount);
+						await pipeToResponse(res, result.stream, controller.signal, {
+							accountId: cappedAccount,
+							model: prepared.model
+						});
+						return;
+					}
+					lastKind = result.kind;
+					lastStatus = result.status;
+					lastMessage = result.message;
+				}
+			} finally {
+				pool.release(cappedAccount);
+			}
+		}
+		if (lastKind === void 0) {
+			writeOpenAIError(res, 429, "soft_rate", "codearts 当前没有可用账号（全部被禁用或冷却中），请稍后重试");
+			return;
+		}
+		writeOpenAIError(res, KIND_STATUS[lastKind], lastKind, `codearts upstream ${lastKind} (http ${lastStatus}): ${lastMessage.slice(0, 400)}`);
+	}
+	/** 把上游 SSE 按事件边界转发给 DSH，直到流结束或被中止。 */
+	async function pipeToResponse(res, stream, signal, attribution) {
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			"Connection": "keep-alive",
+			"X-Accel-Buffering": "no"
+		});
+		const reader = stream.getReader();
+		const decoder = new TextDecoder();
+		let buf = "";
+		if (usage !== void 0 && attribution !== void 0) usage.noteRequest(attribution.accountId, attribution.model);
+		let sawDone = false;
+		const finish = () => {
+			if (!res.writable || res.writableEnded) return;
+			res.end(sawDone ? void 0 : "data: [DONE]\n\n");
+		};
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) {
+					finish();
+					return;
+				}
+				buf += decoder.decode(value, { stream: true });
+				let idx;
+				while ((idx = buf.indexOf("\n\n")) >= 0) {
+					const frame = buf.slice(0, idx);
+					buf = buf.slice(idx + 2);
+					if (!frame) continue;
+					if (frame.trim() === "data: [DONE]") sawDone = true;
+					if (usage !== void 0 && attribution !== void 0 && frame.includes("\"usage\"")) recordFrameUsage(frame, attribution);
+					if (res.writable) res.write(frame + "\n\n");
+				}
+			}
+		} catch (error) {
+			if (!signal.aborted) logger?.warn("dsh-codearts: upstream stream failed mid-flight", error);
+			finish();
+		}
+	}
+	/** 从一帧 SSE 文本里取 usage 计入账本（解析失败就算了，不能影响转发）。 */
+	function recordFrameUsage(frame, attribution) {
+		if (usage === void 0) return;
+		for (const line of frame.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed.startsWith("data:")) continue;
+			const payload = trimmed.slice(5).trim();
+			if (payload === "" || payload === "[DONE]") continue;
+			try {
+				const parsed = JSON.parse(payload);
+				if (parsed.usage !== void 0 && parsed.usage !== null) usage.noteUsage(attribution.accountId, attribution.model, parsed.usage);
+			} catch {}
+		}
+	}
+	return {
+		ready,
+		baseUrl,
+		token: () => SHARED_SECRET,
+		close: () => new Promise((resolve, reject) => {
+			server.close(() => resolve());
+			server.closeAllConnections();
+			server.once("error", reject);
+		})
+	};
+}
+//#endregion
+//#region src/web-status.ts
+/** 登录后问身份的超时：它是「顺手做对」，不能拖住登录落库。 */
+const IDENTITY_TIMEOUT_MS = 8e3;
+/** Route paths (same-origin under the DSH web origin). */
+const CODEARTS_STATUS_PATH = "/api/codearts/status";
+const CODEARTS_MODELS_PATH = "/api/codearts/models";
+const CODEARTS_MODELS_SELECTION_PATH = "/api/codearts/enabled-models";
+const CODEARTS_TOKEN_PATH = "/api/codearts/token";
+const CODEARTS_LOGIN_PATH = "/api/codearts/login";
+const CODEARTS_LOGIN_STATUS_PATH = "/api/codearts/login/status";
+/** 删除某个账号：DELETE /api/codearts/accounts?id=<accountId> */
+const CODEARTS_ACCOUNTS_PATH = "/api/codearts/accounts";
+/**
+* 由完整目录 + 已存 enabled 计算 selection。
+* - enabled 为空/未存 => 全部勾选（restricted=false）
+* - enabled 为非空列表 => 仅勾选其中的（restricted=true），缺的按未勾选
+* 福利模型用 catalog 的 benefit 标记（这里靠 model.free 字段，由调用方注入）。
+*/
+function selectionOf(models, enabled, writable) {
+	const allowed = new Set(enabled ?? []);
+	const restricted = enabled !== void 0 && enabled.length > 0;
+	return {
+		choices: models.map((m) => ({
+			id: m.id,
+			name: m.name,
+			free: m.free,
+			enabled: restricted ? allowed.has(m.id) : true
+		})),
+		restricted,
+		writable
+	};
+}
+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);
+}
+function loopbackRequest(req) {
+	return hostIsLoopback(req.headers.host) && originIsLoopback(req.headers.origin);
+}
+function safeMessage(error) {
+	return (error instanceof Error ? error.message : String(error)).slice(0, 500);
+}
+function readBody(req, limit = 1 << 20) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > limit) {
+				reject(/* @__PURE__ */ new Error("request body too large"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+/** Build the status document (no token material crosses to the browser). */
+/**
+* 登录后立刻问一次身份（有超时，失败返回 null）。
+*
+* 这一步是「尽量做对」而不是必须：拿不到身份也要能把账号存下来，只是会退回
+* 「每次登录各自成一条」的旧行为。
+*/
+async function probeIdentity(token) {
+	const credential = {
+		token: token.securityToken,
+		accessKeyId: token.accessKeyId,
+		secretAccessKey: token.secretAccessKey,
+		securityToken: token.securityToken
+	};
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), IDENTITY_TIMEOUT_MS);
+	timer.unref?.();
+	try {
+		return await fetchCallerIdentity(credential, controller.signal);
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** 账号还能用吗（没被标 stale、也没过期）。 */
+function accountUsable(summary) {
+	if (summary.stale) return false;
+	if (typeof summary.expiration !== "string") return true;
+	const at = Date.parse(summary.expiration);
+	return !Number.isFinite(at) || at > Date.now();
+}
+/** 池状态 -> 卡片能直接渲染的槽位信息。 */
+function slotsOf(deps) {
+	const runtime = deps.pool?.() ?? [];
+	const now = Date.now();
+	return runtime.map((account) => {
+		const state = account.disabled ? "disabled" : now < account.coolUntil ? "cooling" : now < account.cappedUntil ? "capped" : "ok";
+		const detail = state === "capped" ? `upstream session cap hit; avoiding it for ~${Math.ceil((account.cappedUntil - now) / 1e3)}s` : state === "cooling" ? `cooling down for ~${Math.ceil((account.coolUntil - now) / 1e3)}s` : state === "disabled" ? account.lastError ?? "disabled" : void 0;
+		return {
+			id: account.id,
+			active: account.activeConcurrent,
+			max: account.maxConcurrent,
+			state,
+			...detail === void 0 ? {} : { detail }
+		};
+	});
+}
+/** 用量账本 -> 卡片文档；没有账本（未注入）时给一份空壳，卡片就不会瞎显示。 */
+function usageOf(deps) {
+	const snapshot = deps.usage?.();
+	const noTotals = {
+		requests: 0,
+		promptTokens: 0,
+		completionTokens: 0,
+		totalTokens: 0
+	};
+	return {
+		today: snapshot?.today ?? noTotals,
+		allTime: snapshot?.allTime ?? noTotals,
+		byModelToday: snapshot?.byModelToday ?? [],
+		days: snapshot?.days ?? 0,
+		...snapshot?.lastAt === void 0 ? {} : { lastAt: snapshot.lastAt },
+		slots: slotsOf(deps)
+	};
+}
+async function buildStatus(deps) {
+	const models = deps.models().map((m) => ({
+		id: m.id,
+		name: m.name
+	}));
+	const accounts = await deps.store.list();
+	const cred = await deps.store.current();
+	const usage = usageOf(deps);
+	if (accounts.length === 0 || cred === void 0) return {
+		status: "signed-out",
+		models,
+		accounts,
+		usage
+	};
+	return {
+		status: accounts.some(accountUsable) ? "signed-in" : "expired",
+		...cred.label === void 0 ? {} : { label: cred.label },
+		...cred.storedAt === void 0 ? {} : { storedAt: cred.storedAt },
+		models,
+		accounts,
+		usage
+	};
+}
+/** GET /api/codearts/status */
+function statusHandler(deps) {
+	return async (req, res) => {
+		if (req.method !== "GET") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!loopbackRequest(req)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		try {
+			json(res, 200, await buildStatus(deps));
+		} catch (error) {
+			json(res, 500, { error: safeMessage(error) });
+		}
+	};
+}
+/** GET /api/codearts/models — currently offered model ids (honours allowlist). */
+function modelsHandler(deps) {
+	return async (req, res) => {
+		if (req.method !== "GET") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!loopbackRequest(req)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		json(res, 200, { models: filterEnabledModels(deps.models(), deps.enabledModels?.()).map((m) => ({
+			id: m.id,
+			name: m.name
+		})) });
+	};
+}
+/**
+* GET/POST /api/codearts/enabled-models — 模型勾选的读写。
+* GET 返回 selection（choices + restricted + writable）；POST 接收 {enabledModels}
+* 写入 settings（全选时传空数组表示"全部"）。与 codebuddy 的 /plugins/<id>/enabled-models 对齐。
+*/
+function modelsSelectionHandler(deps) {
+	return async (req, res) => {
+		if (!loopbackRequest(req)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		if (req.method === "GET") {
+			const all = deps.models().map((m) => ({
+				id: m.id,
+				name: m.name,
+				free: isBenefitModel(m.id)
+			}));
+			const writable = deps.setEnabledModels !== void 0;
+			json(res, 200, { selection: selectionOf(all, deps.enabledModels?.(), writable) });
+			return;
+		}
+		if (req.method === "POST") {
+			if (!deps.setEnabledModels) {
+				json(res, 403, { error: "selection-not-writable" });
+				return;
+			}
+			const type = req.headers["content-type"];
+			if (typeof type !== "string" || !type.trim().toLowerCase().startsWith("application/json")) {
+				json(res, 415, { error: "content-type must be application/json" });
+				return;
+			}
+			try {
+				const body = JSON.parse(await readBody(req));
+				if (!Array.isArray(body.enabledModels) || !body.enabledModels.every((x) => typeof x === "string")) {
+					json(res, 400, { error: "expected {\"enabledModels\": string[]}" });
+					return;
+				}
+				if (!await deps.setEnabledModels(body.enabledModels)) {
+					json(res, 403, { error: "selection-not-writable" });
+					return;
+				}
+				json(res, 200, { selection: selectionOf(deps.models().map((m) => ({
+					id: m.id,
+					name: m.name,
+					free: isBenefitModel(m.id)
+				})), deps.enabledModels?.(), true) });
+			} catch (error) {
+				json(res, 500, { error: safeMessage(error) });
+			}
+			return;
+		}
+		json(res, 405, { error: "method not allowed" });
+	};
+}
+/** POST /api/codearts/token { token, label? } — store a pasted token. */
+function tokenPostHandler(deps) {
+	return async (req, res) => {
+		if (req.method !== "POST") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!loopbackRequest(req)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		const type = req.headers["content-type"];
+		if (typeof type !== "string" || !type.trim().toLowerCase().startsWith("application/json")) {
+			json(res, 415, { error: "content-type must be application/json" });
+			return;
+		}
+		try {
+			const body = JSON.parse(await readBody(req));
+			const token = typeof body?.token === "string" ? body.token.trim() : "";
+			if (token === "") {
+				json(res, 400, { error: "expected {\"token\": string}" });
+				return;
+			}
+			const label = typeof body?.label === "string" && body.label.trim() !== "" ? body.label.trim() : void 0;
+			await deps.store.set(token, label);
+			json(res, 200, await buildStatus(deps));
+		} catch (error) {
+			json(res, 500, { error: safeMessage(error) });
+		}
+	};
+}
+/** DELETE /api/codearts/token — forget the stored token. */
+function tokenDeleteHandler(deps) {
+	return async (req, res) => {
+		if (req.method !== "DELETE") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!hostIsLoopback(req.headers.host) || !originIsLoopback(req.headers.origin)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		try {
+			await deps.store.clear();
+			json(res, 200, await buildStatus(deps));
+		} catch (error) {
+			json(res, 500, { error: safeMessage(error) });
+		}
+	};
+}
+/**
+* DELETE /api/codearts/accounts?id=<accountId> — 删掉一个账号。
+*
+* id 必须显式给：多账号下「删掉当前那个」是歧义的。改状态的路由，所以和
+* /token 一样走 Host + Origin 双校验。
+*/
+function accountsHandler(deps) {
+	return async (req, res) => {
+		if (req.method !== "DELETE") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!loopbackRequest(req)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		const id = (new URL(req.url ?? "", "http://localhost").searchParams.get("id") ?? "").trim();
+		if (id === "") {
+			json(res, 400, { error: "expected ?id=<accountId>" });
+			return;
+		}
+		try {
+			await deps.store.remove(id);
+			json(res, 200, await buildStatus(deps));
+		} catch (error) {
+			json(res, 500, { error: safeMessage(error) });
+		}
+	};
+}
+/** Mount the status / models / token routes. */
+function registerCodeArtsStatusRoute(ctx, deps) {
+	ctx.effect(() => {
+		const activeLogins = /* @__PURE__ */ new Map();
+		/** 已结束登录的终态，供迟到的轮询读取。被读一次即删。 */
+		const recentLogins = /* @__PURE__ */ new Map();
+		const disposeStatus = ctx.webServer.register({
+			kind: "exact",
+			path: CODEARTS_STATUS_PATH,
+			handler: statusHandler(deps)
+		});
+		const disposeModels = ctx.webServer.register({
+			kind: "exact",
+			path: CODEARTS_MODELS_PATH,
+			handler: modelsHandler(deps)
+		});
+		const disposeModelsSelection = ctx.webServer.register({
+			kind: "exact",
+			path: CODEARTS_MODELS_SELECTION_PATH,
+			handler: modelsSelectionHandler(deps)
+		});
+		const disposeToken = ctx.webServer.register({
+			kind: "exact",
+			path: CODEARTS_TOKEN_PATH,
+			handler: tokenHandler(deps)
+		});
+		const disposeLoginStart = ctx.webServer.register({
+			kind: "exact",
+			path: CODEARTS_LOGIN_PATH,
+			handler: loginStartHandler(deps, activeLogins, recentLogins)
+		});
+		const disposeLoginStatus = ctx.webServer.register({
+			kind: "exact",
+			path: CODEARTS_LOGIN_STATUS_PATH,
+			handler: loginPollHandler(deps, activeLogins, recentLogins)
+		});
+		const disposeAccounts = ctx.webServer.register({
+			kind: "exact",
+			path: CODEARTS_ACCOUNTS_PATH,
+			handler: accountsHandler(deps)
+		});
+		return () => {
+			disposeStatus();
+			disposeModels();
+			disposeModelsSelection();
+			disposeToken();
+			disposeLoginStart();
+			disposeLoginStatus();
+			disposeAccounts();
+			for (const s of activeLogins.values()) s.close();
+			activeLogins.clear();
+		};
+	}, "dsh-codearts: Web status route");
+}
+/** /api/codearts/token — 一个席位按方法分派（POST 写入，DELETE 清除）。 */
+function tokenHandler(deps) {
+	const post = tokenPostHandler(deps);
+	const remove = tokenDeleteHandler(deps);
+	return (req, res) => req.method === "DELETE" ? remove(req, res) : post(req, res);
+}
+/** 记一次登录终态；超出容量就丢最旧的，别让这个表无限长。 */
+function recordLoginOutcome(recent, url, outcome) {
+	if (recent.size >= 20 && !recent.has(url)) {
+		const oldest = recent.keys().next().value;
+		if (oldest !== void 0) recent.delete(oldest);
+	}
+	recent.set(url, outcome);
+}
+/** POST /api/codearts/login — 启动本地 OAuth 回调，返回授权 URL。 */
+function loginStartHandler(deps, active, recent) {
+	return async (req, res) => {
+		if (req.method !== "POST") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!hostIsLoopback(req.headers.host) || !originIsLoopback(req.headers.origin)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		try {
+			const session = await startLogin();
+			active.set(session.url, session);
+			session.promise.then(async (token) => {
+				active.delete(session.url);
+				try {
+					const identity = await probeIdentity(token);
+					const id = await deps.store.upsertFromOAuth(token, void 0, identity ?? void 0);
+					if (identity !== null && id !== identity.userId) await deps.store.adoptIdentity(id, identity);
+					recordLoginOutcome(recent, session.url, "done");
+				} catch {
+					recordLoginOutcome(recent, session.url, "error");
+				}
+			}, () => {
+				active.delete(session.url);
+				recordLoginOutcome(recent, session.url, "error");
+			});
+			const timer = setTimeout(() => {
+				session.close();
+				if (active.delete(session.url)) recordLoginOutcome(recent, session.url, "error");
+			}, 3e5);
+			session.promise.finally(() => clearTimeout(timer)).catch(() => {});
+			json(res, 200, {
+				url: session.url,
+				port: session.port
+			});
+		} catch (error) {
+			json(res, 500, { error: safeMessage(error) });
+		}
+	};
+}
+/** GET /api/codearts/login/status — 轮询登录结果。 */
+function loginPollHandler(_deps, active, recent) {
+	return async (req, res) => {
+		if (req.method !== "GET") {
+			json(res, 405, { error: "method not allowed" });
+			return;
+		}
+		if (!hostIsLoopback(req.headers.host) || !originIsLoopback(req.headers.origin)) {
+			json(res, 403, { error: "request-not-trusted" });
+			return;
+		}
+		const key = new URL(req.url ?? "", "http://localhost").searchParams.get("url") ?? "";
+		if (active.has(key)) {
+			json(res, 200, { status: "pending" });
+			return;
+		}
+		const outcome = recent.get(key);
+		if (outcome !== void 0) {
+			recent.delete(key);
+			json(res, 200, { status: outcome });
+			return;
+		}
+		json(res, 200, { status: "idle" });
+	};
+}
+//#endregion
+//#region src/settings-compat.ts
+const compatModule = settingsModule;
+function plainSettingsSchema(schema) {
+	const clone = structuredClone(schema.toJSON());
+	for (const node of Object.values(clone.refs ?? {})) if (node !== null && typeof node === "object" && node.meta !== void 0) delete node.meta.volatile;
+	return z(clone);
+}
+function entryNamespaceOf(ctx) {
+	const compat = ctx;
+	const entry = compat.fiber?.entry;
+	const candidates = [
+		entry?.options?.id,
+		entry?.id,
+		compat.loader?.locate?.(compat.fiber)
+	];
+	for (const candidate of candidates) if (typeof candidate === "string" && candidate !== "") return candidate;
+}
+function resolveSettingsNamespaceCompat(ctx, provider, fallback) {
+	if (compatModule.installSettingsSection !== void 0) return fallback;
+	const candidate = provider;
+	if (candidate.installSection !== void 0) return fallback;
+	if (candidate.configure !== void 0) return entryNamespaceOf(ctx) ?? fallback;
+	return fallback;
+}
+function installSettingsSectionCompat(ctx, ns, schema, entry, hooks) {
+	const legacyInstaller = compatModule.installSettingsSection;
+	if (legacyInstaller !== void 0) {
+		legacyInstaller(ctx, ns, plainSettingsSchema(schema), entry, hooks);
+		return;
+	}
+	ctx.inject(["settings"], (sctx) => {
+		const provider = sctx.get("settings");
+		if (provider === void 0) return;
+		if (provider.installSection !== void 0) {
+			provider.installSection(ctx, ns, plainSettingsSchema(schema), entry, hooks);
+			return;
+		}
+		if (provider.configure === void 0) throw new TypeError("dsh-settings exposes neither installSection nor configure");
+		sctx.effect(() => {
+			const dispose = provider.configure?.({ auto: false }, ctx.fiber);
+			return typeof dispose === "function" ? dispose : () => {};
+		});
+		const namespace = entryNamespaceOf(ctx);
+		if (namespace !== void 0) {
+			const refresh = () => {
+				const descriptor = provider.describe?.().find((entry) => String(entry.ns) === namespace);
+				if (descriptor?.value !== void 0) hooks.setSource?.(() => descriptor.value);
+				hooks.onChange();
+			};
+			const settingsEvents = sctx;
+			sctx.effect(() => settingsEvents.on("settings/document-updated", (updated) => {
+				if (String(updated) === namespace) refresh();
+			}));
+		}
+	});
+}
+//#endregion
+//#region src/index.ts
+/** Stable Cordis plugin name. */
+const name = "llm-codearts";
+/** The llm service is required before the provider can register. */
+const inject = ["llm"];
+/** Settings namespace owning the configuration card. */
+const CODEARTS_SETTINGS_NS = "codearts";
+function unwrapVolatileValue(value) {
+	if (typeof value === "object" && value !== null && typeof value.get === "function") return value.get();
+	return value;
+}
+function unwrapConfig(value) {
+	if (typeof value !== "object" || value === null) return {};
+	const out = {};
+	for (const [key, field] of Object.entries(value)) out[key] = unwrapVolatileValue(field);
+	return out;
+}
+const Config = z.object({ enabledModels: z.array(z.string()).description("Model ids offered in the model pickers (empty means every model)").volatile() });
+function settingsCompatNamespace(ctx) {
+	return resolveSettingsNamespaceCompat(ctx, ctx.get("settings"), CODEARTS_SETTINGS_NS);
+}
+function apply(ctx, rawConfig) {
+	const config = unwrapConfig(rawConfig);
+	const accountsPath = codeartsAccountsPath();
+	const store = new CodeArtsAccountStore(accountsPath);
+	const pool = new CodeArtsAccountPool([]);
+	const catalog = new CodeArtsCatalog();
+	const usage = new CodeArtsUsageTracker({ path: codeartsUsagePath() });
+	let current = () => config;
+	const enabledModels = () => current().enabledModels;
+	const setEnabledModels = async (ids) => {
+		const settings = ctx.get("settings");
+		if (settings === void 0) return false;
+		await settings.update(settingsCompatNamespace(ctx), { enabledModels: [...ids] });
+		return true;
+	};
+	ctx.inject(["webServer"], (webCtx) => registerCodeArtsStatusRoute(webCtx, {
+		store,
+		models: () => catalog.current(),
+		enabledModels,
+		setEnabledModels,
+		pool: () => pool.list(),
+		usage: () => usage.snapshot()
+	}));
+	installSettingsSectionCompat(ctx, CODEARTS_SETTINGS_NS, Config, config, {
+		setSource(source) {
+			current = () => unwrapConfig(source());
+		},
+		onChange() {}
+	});
+	let stopped = false;
+	ctx.effect(() => () => {
+		stopped = true;
+		usage.flush().catch(() => {});
+		shim.close().catch(() => {});
+	});
+	const CATALOG_REFRESH_MS = 36e5;
+	const abort = new AbortController();
+	const discover = async () => {
+		if (stopped) return;
+		try {
+			const outcome = await refreshCatalog(store, catalog, abort.signal);
+			if (outcome === void 0 || stopped) return;
+			if (outcome.anySucceeded) {
+				const free = outcome.models.filter((model) => model.benefit === true).length;
+				ctx.logger.debug(`dsh-codearts: model discovery refreshed the catalog (${outcome.models.length} models, ${free} benefit)`);
+			} else ctx.logger.warn("dsh-codearts: model discovery found nothing usable; keeping the current catalog", outcome.accounts.flatMap((account) => account.errors));
+		} catch (error) {
+			ctx.logger.debug("dsh-codearts: model discovery failed; keeping the current catalog", error);
+		}
+	};
+	ctx.effect(() => {
+		const timer = setInterval(() => void discover(), CATALOG_REFRESH_MS);
+		timer.unref?.();
+		return () => {
+			abort.abort();
+			clearInterval(timer);
+		};
+	});
+	const shim = createCodeArtsShim({
+		store,
+		catalog,
+		pool,
+		usage,
+		logger: ctx.logger
+	});
+	usage.load().catch(() => {});
+	shim.ready.then(() => {
+		if (stopped) return;
+		discover();
+		const codearts = createCodeArtsAdapter({
+			shim,
+			catalog,
+			enabledModels,
+			resolveAttachments: () => ctx.get("attachments")
+		});
+		let releaseAdapter;
+		let releaseDirectory;
+		try {
+			releaseAdapter = ctx.llm.registerAdapter([CODEARTS_PROVIDER], codearts.adapter);
+			releaseDirectory = ctx.llm.registerConfigurableProviders([{
+				provider: CODEARTS_PROVIDER,
+				displayName: "CodeArts",
+				settingsNs: settingsCompatNamespace(ctx),
+				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-codearts: loopback shim failed to start; provider not registered", error);
+	});
+}
+//#endregion
+export { CODEARTS_PROVIDER, CODEARTS_SETTINGS_NS, CodeArtsAccountPool, CodeArtsAccountStore, CodeArtsCatalog, CodeArtsCredentialStore, CodeArtsUsageTracker, Config, FALLBACK_CODEARTS_MODELS, SNAP_HOST, apply, canonicalModel, chatStream, codeartsAccountsPath, codeartsAuthPath, codeartsUsagePath, createCodeArtsAdapter, createCodeArtsShim, discoverModels, fetchModels, filterEnabledModels, inject, maxTokensCeilingFor, name, prepareChatBody, refreshCatalog };