dsh-llm-codebuddy-power 1.0.0

package/lib/index.js

@@ -0,0 +1,3957 @@
+import { gzipSync } from "node:zlib";
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, ToolCallId, contentHasImage, isContextWindowExceededError, isQuotaExceededError } from "@deepseek-ai/dsh-llm";
+import { randomBytes, randomUUID } from "node:crypto";
+import { promises } from "node:fs";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
+import { dirname } from "node:path";
+import { EventSourceParserStream } from "eventsource-parser/stream";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { spawn } from "node:child_process";
+import z from "@deepseek-ai/schemastery";
+//#region lib/types/constants.js
+/**
+* CodeBuddy 服务的固定事实。
+*
+* 这些是协议常量而非用户配置:endpoint 同时承载 OAuth 握手与模型目录,
+* 版本字符串则是服务期望插件客户端用于表明自身身份的内容。
+*
+* @module dsh-llm-codebuddy-power/constants
+*/
+/** 本插件在 `ctx.llm` 上注册的 provider 路由。 */
+const CODEBUDDY_PROVIDER = "codebuddy";
+/** 在模型选择器与设置界面中展示的显示名。 */
+const CODEBUDDY_DISPLAY_NAME = "CodeBuddy";
+/** CodeBuddy 服务根地址;认证握手与 `/v3/config` 都在此处。 */
+const CODEBUDDY_ENDPOINT = "https://copilot.tencent.com";
+/**
+* 兼容 OpenAI 的对话基础地址。只有对话 wire 路由兼容;`/v3/config` 处的
+* 模型目录并不兼容,这就是本插件自带目录读取器、而不使用 OpenAI
+* `GET /models` 列表的原因。
+*/
+const CODEBUDDY_CHAT_BASE = `${CODEBUDDY_ENDPOINT}/v2`;
+/** 在对话与模型目录请求中上报的 IDE 版本,与官方 CodeBuddy CN 4.11.3 客户端一致。 */
+const CODEBUDDY_IDE_VERSION = "4.11.3";
+/** 官方 IDE 的产品段名称,用于拼接后的 `User-Agent`。 */
+const CODEBUDDY_PRODUCT_NAME = "CodeBuddy";
+/**
+* 官方 IDE 主进程 auth/billing 客户端发送的 User-Agent。
+*
+* 登录与计量请求在 `main.js` 中使用裸 axios 实例(没有拦截器链),因此携带
+* 的是 axios 默认 UA,而不是 CustomFetch 平面使用的 IDE 身份 UA。
+* 实测抓包:`/v2/plugin/auth/*` 与 `/v2/billing/meter/*` 都发送 `axios/1.15.0`。
+*/
+const CODEBUDDY_AXIOS_USER_AGENT = "axios/1.15.0";
+/**
+* 目录完全未描述的模型所假定的上下文容量。
+*
+* 这是约定值,不是 CodeBuddy 提供的数字:服务按模型披露 `maxAllowedSize`,
+* 不提供可回退的全局默认值。因此已列出的模型绝不会按此定尺寸——隐去容量的
+* 条目会直接从头列表中丢弃。它只适用于目录未列出、却被显式指名的 id,
+* 此时必须有假定值才能解析出路由。
+*/
+const DEFAULT_CONTEXT_WINDOW = 128e3;
+/** 未列出模型所假定的输出上限;同上的约定值。 */
+const DEFAULT_MAX_TOKENS = 8192;
+/** 有一次流读取尚未完成时,provider 的默认最大空闲时间。 */
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+/**
+* 单张请求图片在 base64 膨胀前的编码字节目标。
+*
+* 这是本插件对请求图片的唯一硬性约束:源图未超过它就不做任何转换。取值与
+* 官方 CodeBuddy IDE 的拖放路径一致(`TARGET_SIZE_MB = 1`)。
+*/
+const REQUEST_IMAGE_MAX_BYTES = 1024 * 1024;
+/**
+* 源图超过字节目标时逐档收紧的长边档位。
+*
+* 档位取自官方 CodeBuddy IDE 拖放路径的 `COMPRESS_ATTEMPTS`(1920、1440、1080)。
+* 需要逐档重试是因为附件服务的编码阶梯只降质量、不再降尺寸,单靠一档无法保证
+* 落到字节目标。
+*/
+const REQUEST_IMAGE_DIMENSION_LADDER = [
+	1920,
+	1440,
+	1080
+];
+/** 浏览器登录流程等待用户完成的时长,单位 ms。 */
+const LOGIN_TIMEOUT_MS = 600 * 1e3;
+/** 等待浏览器登录完成时的轮询间隔,单位 ms。 */
+const LOGIN_POLL_INTERVAL_MS = 1e3;
+/** 含义为“浏览器登录尚未完成”的服务码。 */
+const AUTH_PENDING_CODE = 11217;
+//#endregion
+//#region lib/types/codebuddy.js
+/**
+* CodeBuddy 控制面客户端:浏览器 OAuth 握手、令牌刷新,
+* 以及非 OpenAI 模型目录。
+*
+* 这里的每次调用都以 `{code, msg, data}` 信封而非仅 HTTP 状态码
+* 表达结果,因此返回 200 却带有非零 `code` 即为失败,并
+* 按失败上报。本模块只负责传输:不持有状态,也不做
+* 策略决策,因此登录流程、适配器与 CLI 得以共用
+* 同一份实现。
+*
+* @module dsh-llm-codebuddy-power/codebuddy
+*/
+/**
+* 官方 CodeBuddy CN 4.11.3 客户端在其 CustomFetch 面(chat、catalog)上
+* 发送的组合 IDE `User-Agent`。实测抓包为 `CodeBuddyIDE/4.11.3 CodeBuddy/4.11.3`。
+* @returns IDE user-agent 字符串。
+*/
+function ideUserAgent() {
+	return `CodeBuddyIDE/${CODEBUDDY_IDE_VERSION} ${CODEBUDDY_PRODUCT_NAME}/${CODEBUDDY_IDE_VERSION}`;
+}
+/**
+* 官方 IDE 主进程的认证/计费客户端发送的 `User-Agent`。
+*
+* `main.js` 在一个裸 axios 实例上发起登录与计量请求(无拦截器
+* 链),因此它们携带 axios 默认 UA —— 实测在 `/v2/plugin/auth/*` 与
+* `/v2/billing/meter/*` 上抓到的值为 `axios/1.15.0`。
+* @returns axios user-agent 字符串。
+*/
+function axiosUserAgent() {
+	return CODEBUDDY_AXIOS_USER_AGENT;
+}
+/**
+* 登录握手与计量共用的 axios 面请求头:
+* axios 默认的 `Accept` 与 `User-Agent`,外加每次调用各自的头。
+*
+* 在官方 IDE 中这两个面运行在同一个裸 axios 客户端上,
+* 因此尽管各自的额外头不同,帧结构仍相同。
+* @param extra - 请求专属头(`X-No-*`、`Authorization` 等)。
+* @returns 请求头。
+*/
+function axiosRequestHeaders(extra) {
+	return {
+		"Accept": "application/json, text/plain, */*",
+		"User-Agent": axiosUserAgent(),
+		...extra
+	};
+}
+function delay(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(/* @__PURE__ */ new Error("aborted"));
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* 发起一次浏览器登录握手。
+* @param signal - 可选取消。
+* @returns 握手状态,以及用户必须打开的 URL。
+* @throws Error 服务拒绝或返回不可用的响应体时。
+*/
+async function requestAuthState(signal) {
+	const response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/plugin/auth/state?platform=ide`, {
+		method: "POST",
+		headers: axiosRequestHeaders({
+			"Content-Type": "application/x-www-form-urlencoded",
+			"X-No-Authorization": "true",
+			"X-No-User-Id": "true",
+			"X-No-Enterprise-Id": "true"
+		}),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) throw new Error(`CodeBuddy auth state request failed (HTTP ${response.status})`);
+	const body = await response.json();
+	if (body.code !== 0 || body.data === void 0) throw new Error(`CodeBuddy auth state request failed: ${body.code} - ${body.msg}`);
+	return body.data;
+}
+/**
+* 轮询,直到用户在浏览器中完成登录。
+*
+* 服务用 code {@link AUTH_PENDING_CODE} 表示“尚未完成”,
+* 它是唯一让循环继续的 code;其他任何 code 都是已决结果,循环
+* 就此结束。传输错误同样结束循环,因为状态可能已被消耗的
+* 握手不得静默重试。
+* @param state - 来自 {@link requestAuthState} 的握手 id。
+* @param signal - 可选取消。
+* @returns 签发的令牌;登录失败或超时时为 `undefined`。
+*/
+async function pollAuthToken(state, signal) {
+	const deadline = Date.now() + LOGIN_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		await delay(LOGIN_POLL_INTERVAL_MS, signal);
+		let response;
+		try {
+			response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/plugin/auth/token?state=${encodeURIComponent(state)}`, {
+				method: "GET",
+				headers: axiosRequestHeaders({ "X-No-Authorization": "true" }),
+				...signal === void 0 ? {} : { signal }
+			});
+		} catch {
+			return;
+		}
+		if (!response.ok) continue;
+		const body = await response.json();
+		if (body.code === 11217) continue;
+		if (body.code !== 0) return void 0;
+		return body.data;
+	}
+}
+/**
+* 读取已登录账号,其 uid 与企业 id 会成为之后每个请求的必需
+* 请求头。
+* @param state - 令牌所对应的握手 id。
+* @param accessToken - 刚签发的 access token。
+* @param domain - 令牌所对应的租户 domain。
+* @returns 账号信息。
+* @throws Error 服务拒绝或返回不可用的响应体时。
+*/
+async function getLoginAccount(state, accessToken, domain) {
+	const response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/plugin/login/account?state=${encodeURIComponent(state)}`, {
+		method: "GET",
+		headers: axiosRequestHeaders({
+			"Authorization": `Bearer ${accessToken}`,
+			"X-No-User-Id": "true",
+			"X-No-Enterprise-Id": "true",
+			"X-Domain": domain
+		})
+	});
+	if (!response.ok) throw new Error(`CodeBuddy login account request failed (HTTP ${response.status})`);
+	const body = await response.json();
+	if (body.code !== 0 || body.data === void 0) throw new Error(`CodeBuddy login account request failed: ${body.code} - ${body.msg}`);
+	return normalizeAccount(body.data);
+}
+/**
+* 归一化账号,使空字符串字段等同于缺失。
+*
+* 对于租户未披露的字段,CodeBuddy 的账号响应会返回空字符串
+* (而非省略)→ 例如企业账号会带有 `uin: ""`。整条下游链路(storage、
+* auth 状态、设置 UI)只把 `undefined` 当作“不存在”,因此空字符
+* 串会渲染出一行空内容。在此统一裁剪一次即可覆盖所有消费者,
+* 无需各自重复判断。
+* @param account - 来自 wire 的原始账号。
+* @returns 删除可选字符串字段为空值后的账号。
+*/
+function normalizeAccount(account) {
+	const pick = (value) => value === void 0 || value.length === 0 ? void 0 : value;
+	return {
+		uid: account.uid,
+		nickname: account.nickname,
+		...pick(account.uin) === void 0 ? {} : { uin: account.uin },
+		...pick(account.enterpriseId) === void 0 ? {} : { enterpriseId: account.enterpriseId },
+		...pick(account.enterpriseName) === void 0 ? {} : { enterpriseName: account.enterpriseName },
+		...pick(account.enterpriseUserName) === void 0 ? {} : { enterpriseUserName: account.enterpriseUserName },
+		...pick(account.departmentFullName) === void 0 ? {} : { departmentFullName: account.departmentFullName }
+	};
+}
+/**
+* 用 refresh token 换取新的 access token。
+* @param identity - 当前身份,包含正被替换的 access token。
+* @param refreshToken - 要使用的 refresh token。
+* @returns 新令牌;刷新被拒绝时为 `undefined`。
+*/
+async function refreshAccessToken(identity, refreshToken) {
+	const headers = axiosRequestHeaders({
+		"Authorization": `Bearer ${identity.accessToken}`,
+		"X-Domain": identity.domain,
+		"X-User-Id": identity.uid,
+		"X-Refresh-Token": refreshToken,
+		"X-Auth-Refresh-Source": "plugin"
+	});
+	if (identity.enterpriseId !== void 0) headers["X-Enterprise-Id"] = identity.enterpriseId;
+	let response;
+	try {
+		response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/plugin/auth/token/refresh`, {
+			method: "POST",
+			headers
+		});
+	} catch {
+		return;
+	}
+	if (!response.ok) return void 0;
+	const body = await response.json();
+	if (body.code !== 0 || body.data === void 0) return void 0;
+	return body.data;
+}
+/**
+* 一个新的无连字符 uuid;CodeBuddy 各面用作请求 id 与
+* 会话 id 的紧凑形式。
+* @returns 32 个十六进制字符的 id。
+*/
+function compactUuid() {
+	return randomUUID().replace(/-/g, "");
+}
+/**
+* 一个新的 trace id:32 个小写十六进制字符,即官方客户端的
+* OpenTelemetry span 为 `x-trace-id` / `x-b3-traceid` 生成的形态
+* (16 个随机字节的十六进制)。
+* @returns 32 个十六进制字符的 trace id。
+*/
+function traceId() {
+	return randomBytes(16).toString("hex");
+}
+/**
+* 一个新的 span id:16 个小写十六进制字符,即官方客户端的
+* OpenTelemetry span 为 `x-b3-spanid` / 父 id 生成的形态
+* (8 个随机字节的十六进制)。
+* @returns 16 个十六进制字符的 span id。
+*/
+function spanId() {
+	return randomBytes(8).toString("hex");
+}
+/**
+* 每个 CustomFetch 面请求(chat、catalog)都携带的共享客户端身份
+* 头,与官方 IDE 4.11.3 的抓包一致:
+* IDE user-agent、SaaS 产品标记、XMLHttpRequest 来源,以及
+* 每个请求一个新生成的紧凑 `X-Request-ID`。
+*
+* CodeBuddy 的安全策略会拒绝任何它不认作自家客户端的 User-Agent
+* (实测:带 harness 标识的 User-Agent 会被以 HTTP 400 / code 11128
+* 拒绝)。提供方自身的产品身份是唯一被接受的载体,因此本函数是
+* chat 与 catalog 两条传输上该身份的唯一来源。
+* @returns 共享身份头,其中 request id 为新生成。
+*/
+function clientIdentityHeaders() {
+	return {
+		"User-Agent": ideUserAgent(),
+		"X-Product": "SaaS",
+		"X-Requested-With": "XMLHttpRequest",
+		"X-Request-ID": compactUuid()
+	};
+}
+/**
+* 一次 chat 请求的 b3 / X-B3 trace 头,外加 CustomFetch 面同步
+* 的原始 trace id 头。所有 id 每次调用都重新生成,
+* 与官方客户端的每请求 span 一致。
+* @returns trace 头,其中 trace/span id 为新生成。
+*/
+function traceHeaders() {
+	const trace = traceId();
+	const span = spanId();
+	const parent = spanId();
+	return {
+		"X-Trace-ID": trace,
+		"X-B3-TraceId": trace,
+		"X-B3-SpanId": span,
+		"X-B3-ParentSpanId": parent,
+		"X-B3-Sampled": "1",
+		"b3": `${trace}-${span}-1-${parent}`,
+		"X-Request-Trace-Id": randomUUID()
+	};
+}
+/**
+* 通过 CodeBuddy 的图像模型生成图像。
+*
+* 复刻官方 IDE 的 `ImageGenTool` wire 调用(`POST
+* /v2/images/generations`,模型 `hunyuan-image-alpha`),并发送完整的
+* IDE 身份头,从而让计费控制台按给定的会话 id 将调用方
+* 记为 IDE 客户端。服务收取的 credits 通过 `usage.credit` 带出。
+* @param identityHeaders - 已认证的身份头(`requestIdentity`)。
+* @param model - 文生图模型 id,例如 `hunyuan-image-alpha`。
+* @param args - 生成提示词与选项。
+* @param conversationIds - 为本次请求生成的会话/轮次/消息 id
+*   (`X-Conversation-ID`、`X-Conversation-Request-ID`、
+*   `X-Conversation-Message-ID`)。
+* @param signal - 可选取消。
+* @returns 生成的图像与计费的 credits。
+* @throws Error 服务拒绝或返回不可用的响应体时。
+*/
+async function generateImage(identityHeaders, model, args, conversationIds, signal) {
+	const body = {
+		model,
+		prompt: args.prompt,
+		size: args.size ?? "1024x1024",
+		response_format: "b64_json"
+	};
+	if (args.n !== void 0) body.n = args.n;
+	if (args.quality !== void 0) body.quality = args.quality;
+	if (args.style !== void 0) body.style = args.style;
+	const headers = {
+		...identityHeaders,
+		...clientIdentityHeaders(),
+		"X-Request-ID": conversationIds.requestId,
+		"Content-Type": "application/json",
+		"X-Agent-Intent": "craft",
+		"X-Conversation-ID": conversationIds.conversationId,
+		"X-Conversation-Request-ID": conversationIds.requestId,
+		"X-Conversation-Message-ID": conversationIds.messageId,
+		"X-Env-ID": "production",
+		"X-IDE-Type": "CodeBuddyIDE",
+		"X-IDE-Name": "CodeBuddyIDE",
+		"X-IDE-Version": CODEBUDDY_IDE_VERSION,
+		"X-Product-Version": CODEBUDDY_IDE_VERSION,
+		"X-Model-ID": model,
+		...traceHeaders(),
+		"Accept": "application/json, text/plain, */*"
+	};
+	const response = await fetch(`${CODEBUDDY_ENDPOINT}/v2/images/generations`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(body),
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) throw new Error(`CodeBuddy image generation failed (HTTP ${response.status})`);
+	const envelope = await response.json();
+	if (envelope.code !== 0 || envelope.data === void 0) throw new Error(`CodeBuddy image generation failed: ${envelope.code ?? "unknown"} - ${envelope.msg ?? "empty data"}`);
+	return {
+		images: (envelope.data.data ?? []).map((image) => ({
+			...image.url === void 0 ? {} : { url: image.url },
+			...image.b64_json === void 0 ? {} : { b64_json: image.b64_json }
+		})),
+		usedCredits: envelope.data.usage?.credit ?? 0
+	};
+}
+/**
+* 读取 CodeBuddy 模型目录。
+*
+* 这是该服务中非 OpenAI 兼容的那一半,也是本插件无法被通用
+* OpenAI 兼容路由取代的原因:该响应会披露每个模型的能力标记与
+* 尺寸,而 `GET /models` 列表不会。
+* @param identityHeaders - 已认证的身份头,由会话构建一次
+*   (`requestIdentity()`),使 chat 与目录共用同一套。
+* @param signal - 可选取消。
+* @returns 目录。
+* @throws Error 服务拒绝或返回不可用的响应体时。
+*/
+async function getConfig(identityHeaders, signal) {
+	const headers = {
+		...identityHeaders,
+		...clientIdentityHeaders(),
+		"Accept": "application/json"
+	};
+	const response = await fetch(`${CODEBUDDY_ENDPOINT}/v3/config`, {
+		method: "GET",
+		headers,
+		...signal === void 0 ? {} : { signal }
+	});
+	if (!response.ok) throw new Error(`CodeBuddy config request failed (HTTP ${response.status})`);
+	const body = await response.json();
+	if (body.code !== 0 || body.data === void 0) throw new Error(`CodeBuddy config request failed: ${body.code} - ${body.msg}`);
+	return body.data;
+}
+//#endregion
+//#region lib/types/usage.js
+/**
+* CodeBuddy 配额/用量计量器:获取并解析剩余额度。
+*
+* CodeBuddy 对计费面的拆分方式与 gproxy 参考实现相同:企业租户回应
+* `get-enterprise-user-usage`(单个 limit/credit 对),而个人账户回应
+* `get-user-resource`(每个生效套餐一个窗口)。两种结构除了每个 CodeBuddy
+* 请求都携带的认证头之外没有任何共同点,因此传输与解析路径只在已登录账户是否
+* 披露了 `enterpriseId` 这一点上分叉一次。
+*
+* 每个进入 Web 客户端的值都是普通 number/string,因此这里返回的
+* {@link UsageSnapshot} 是自有数据 → 不会有活的会话对象逃出本模块。
+*
+* @module dsh-llm-codebuddy-power/usage
+*/
+/**
+* 每个 CodeBuddy 计量请求携带的认证头。
+*
+* 与官方 IDE 主进程的计量调用(`main.js` 中的 `getPersonalUsage`)一致:
+* 在裸 axios 客户端上运行,请求只发送 `Authorization` + `X-User-Id` 以及
+* axios 自身的帧头 — 不含 `X-Domain`/`X-Enterprise-Id`/`X-Tenant-Id`/
+* `X-Department-Info`。这一点已针对 `/v2/billing/meter/get-user-resource`
+* 做过线上验证(抓包恰好显示 `Accept`、`Content-Type`、`Authorization`、
+* `X-User-Id`、`User-Agent: axios/1.15.0`)。
+* @param identity - 已登录的身份。
+* @returns 请求头。
+*/
+function meterHeaders(identity) {
+	return axiosRequestHeaders({
+		"Content-Type": "application/json",
+		"Authorization": `Bearer ${identity.accessToken}`,
+		"X-User-Id": identity.uid
+	});
+}
+/** 读取一个可能以数字或数字字符串形式到达的数值字段。 */
+function number(value, key) {
+	if (value === null || typeof value !== "object") return void 0;
+	const raw = value[key];
+	if (typeof raw === "number") return Number.isFinite(raw) ? raw : void 0;
+	if (typeof raw === "string") {
+		const parsed = Number(raw);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+}
+/** 读取一个非空字符串字段。 */
+function string(value, key) {
+	if (value === null || typeof value !== "object") return void 0;
+	const raw = value[key];
+	return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+/** 沿一条对象键链穿过 JSON 值,返回叶子值或 undefined。 */
+function pointer(value, path) {
+	let current = value;
+	for (const key of path) {
+		if (current === null || typeof current !== "object") return void 0;
+		current = current[key];
+	}
+	return current;
+}
+/**
+* 把 Unix 时间戳按本地时区格式化为 `YYYY-MM-DD HH:mm:ss`,即个人计量面
+* 为其 `SlicePeriod*` 边界所期望的形式。
+*
+* gproxy 参考实现按 UTC 格式化;只要两个边界采用同一约定,CodeBuddy 服务
+* 都接受,而本地格式化与 IDE 客户端发送的一致,因此这次读取更不容易落在
+* 服务端自身预期之外。
+* @param timestamp - Unix 秒。
+* @returns 格式化后的时间戳。
+*/
+function formatTime(timestamp) {
+	const date = /* @__PURE__ */ new Date(timestamp * 1e3);
+	const pad = (n) => n < 10 ? `0${n}` : String(n);
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+* 归一化个人套餐的重置时间戳。
+*
+* CodeBuddy 把套餐的 `CycleEndTime` 上报为其最后一个有效日的结束时刻
+* (`23:59:59`)。这读起来像是“午夜前重置”,但配额实际在次日 `00:00:00`
+* 重置,因此当该值以 `23:59:59` 结尾时,显示值向后一天顺延一秒。其他任何值
+* 原样通过,无法解析的时间戳按原样返回而不是丢弃(有这个数字总比没有好)。
+* @param raw - `CycleEndTime` 字符串,`YYYY-MM-DD HH:mm:ss`。
+* @returns 归一化后的时间戳字符串。
+*/
+function normalizeResetTime(raw) {
+	if (!raw.endsWith("23:59:59")) return raw;
+	const date = new Date(raw.replace(" ", "T"));
+	if (Number.isNaN(date.getTime())) return raw;
+	date.setSeconds(date.getSeconds() + 1);
+	const pad = (n) => n < 10 ? `0${n}` : String(n);
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+* 判断某个套餐显示名是否表示一次性赠送额度。
+*
+* CodeBuddy 的个人计量面把推荐/裂变额度命名为“裂变包”,未来任何促销都可能
+* 带有“赠送”;其他一切(试用/可续期主套餐、企业行)都视为主池。显示名是
+* 计量面暴露的唯一区分依据,因此两种写法都会被匹配。
+* @param name - 窗口的显示名。
+* @returns 赠送套餐名返回 true。
+*/
+function isGiftName(name) {
+	return /裂变|赠送/.test(name);
+}
+/**
+* 把有可用容量的窗口聚合成一个池(used/limit 求和)。
+* 容量未披露或非正数的窗口会退出 — 它们仍留在 `windows` 中。
+* @param windows - 候选窗口。
+* @returns 该池,或当没有可用容量的窗口匹配时不返回。
+*/
+function poolOf(windows) {
+	let used = 0;
+	let limit = 0;
+	for (const window of windows) {
+		if (window.used === void 0 || window.limit === void 0 || window.limit <= 0) continue;
+		used += window.used;
+		limit += window.limit;
+	}
+	if (limit <= 0) return void 0;
+	return {
+		used,
+		limit
+	};
+}
+/** 有效的赠送窗口:仍有上限且尚未完全耗尽。 */
+function liveGiftWindows(windows) {
+	return windows.filter((window) => window.used !== void 0 && window.limit !== void 0 && window.limit > 0 && window.used < window.limit);
+}
+/**
+* 构建个人快照的主池/赠送池划分,以及提示框的赠送明细(最早过期的有效赠送
+* 在前,最多 5 个)。
+* @param windows - 已解析的窗口。
+* @returns 该划分,仅当对应池有可用 limit 时才包含 `main`/`gift`。
+*/
+function splitPools(windows) {
+	const mainWindows = [];
+	const giftWindows = [];
+	for (const window of windows) if (isGiftName(window.name)) giftWindows.push(window);
+	else mainWindows.push(window);
+	const main = poolOf(mainWindows);
+	const live = liveGiftWindows(giftWindows);
+	const giftPool = poolOf(live);
+	if (giftPool === void 0) return { ...main === void 0 ? {} : { main } };
+	const soonest = live.toSorted((a, b) => {
+		if (a.resetsAt !== void 0 && b.resetsAt !== void 0) return a.resetsAt.localeCompare(b.resetsAt);
+		if (a.resetsAt !== void 0) return -1;
+		return b.resetsAt === void 0 ? 0 : 1;
+	}).slice(0, 5);
+	return {
+		...main === void 0 ? {} : { main },
+		gift: {
+			used: giftPool.used,
+			limit: giftPool.limit,
+			soonest
+		}
+	};
+}
+/**
+* 解析个人账户的 `get-user-resource` 响应。
+*
+* 视请求经过的网关而定,accounts 数组可能位于多个指针根之下;会按顺序逐一
+* 尝试,以找到的第一个数组为准。每个账户贡献一个以其套餐命名的
+* {@link UsageWindow}(披露了显示名时用显示名,否则用套餐代码),其中 `used`
+* 由 `limit - remaining` 推导(因此超过上限的剩余值会被钳制为零已用,而不是
+* 负数)。
+* @param accounts - 定位到的 accounts 数组。
+* @returns 组装好的快照。
+*/
+function personalUsage(accounts) {
+	const windows = accounts.map((resource, index) => {
+		const limit = number(resource, "CycleCapacitySizePrecise") ?? 0;
+		const left = number(resource, "CycleCapacityRemainPrecise") ?? 0;
+		const used = Math.max(limit - left, 0);
+		const name = string(resource, "PackageName") ?? string(resource, "PackageCode") ?? string(resource, "ResourceId") ?? `resource_${index}`;
+		const rawReset = string(resource, "CycleEndTime");
+		const resetsAt = rawReset === void 0 ? void 0 : normalizeResetTime(rawReset);
+		if (limit <= 0) return {
+			name,
+			...resetsAt === void 0 ? {} : { resetsAt }
+		};
+		return {
+			name,
+			used,
+			limit,
+			...resetsAt === void 0 ? {} : { resetsAt }
+		};
+	});
+	const split = splitPools(windows);
+	const first = windows[0];
+	return {
+		windows,
+		...first?.resetsAt === void 0 ? {} : { primaryResetsAt: first.resetsAt },
+		...split.main === void 0 ? {} : { main: split.main },
+		...split.gift === void 0 ? {} : { gift: split.gift }
+	};
+}
+/**
+* 解析企业租户的 `get-enterprise-user-usage` 响应。
+*
+* 企业计费面在 `data` 下(网关未包装时则在根上)上报单个 `limitNum`/`credit`
+* 对,因此只构建一个窗口。
+* @param data - 承载这些数字的 data 对象。
+* @returns 组装好的快照,或未披露任何 limit 时为 `undefined`。
+*/
+function enterpriseUsage(data) {
+	const limit = number(data, "limitNum");
+	if (limit === void 0) return void 0;
+	const used = number(data, "credit") ?? 0;
+	const reset = string(data, "cycleResetTime");
+	const window = {
+		name: "enterprise",
+		used,
+		limit,
+		...reset === void 0 ? {} : { resetsAt: reset }
+	};
+	const main = poolOf([window]);
+	return {
+		windows: [window],
+		...reset === void 0 ? {} : { primaryResetsAt: reset },
+		...main === void 0 ? {} : { main }
+	};
+}
+/**
+* 把一次计量响应解析为快照。
+*
+* gproxy 参考实现会在其已被观察到使用的每个指针根下尝试个人 `Accounts`
+* 数组,只有在没有任何数组匹配时才回退到企业单窗口解析 → 与发出的请求路径
+* 无关。沿用这一顺序,可以让恰好携带 `enterpriseId` 的个人账户(或反之)
+* 按它实际回应的结构解析,而不是按其凭据暗示的结构解析。
+* @param raw - 已解析的响应体。
+* @returns 组装好的快照,或响应体不含任何可解析内容时为 `undefined`。
+*/
+function parseUsage(raw) {
+	for (const path of [
+		[
+			"data",
+			"Response",
+			"Data",
+			"Accounts"
+		],
+		[
+			"data",
+			"data",
+			"Response",
+			"Data",
+			"Accounts"
+		],
+		[
+			"Response",
+			"Data",
+			"Accounts"
+		]
+	]) {
+		const candidate = pointer(raw, path);
+		if (Array.isArray(candidate)) return personalUsage(candidate);
+		if (candidate === null) return { windows: [] };
+	}
+	return enterpriseUsage(pointer(raw, ["data", "data"]) ?? pointer(raw, ["data"]) ?? raw);
+}
+/**
+* 向计量端点 POST 并解析响应,所有失败模式都退化为 `undefined` 而不抛出。
+*
+* 用量是设置界面上的参考性读取,因此传输故障、非 2xx 状态、无法解析的响应体
+* 或服务端非零 `code` 都意味着“不显示用量” → 绝不会出现坏掉的侧边栏底部。
+* @param identity - 已登录的身份,由会话刷新。
+* @param path - {@link CODEBUDDY_ENDPOINT} 下的计量路径。
+* @param body - JSON 请求体。
+* @param signal - 可选的取消信号。
+* @returns 已解析的快照,或计费面不可达、回应了不可用响应体时为
+*   `undefined`。
+*/
+async function postMeter(identity, path, body, signal) {
+	let response;
+	try {
+		response = await fetch(`${CODEBUDDY_ENDPOINT}${path}`, {
+			method: "POST",
+			headers: meterHeaders(identity),
+			body,
+			...signal === void 0 ? {} : { signal }
+		});
+	} catch {
+		return;
+	}
+	if (!response.ok) return void 0;
+	let raw;
+	try {
+		raw = await response.json();
+	} catch {
+		return;
+	}
+	const envelope = raw;
+	if (envelope !== null && typeof envelope === "object" && envelope.code !== void 0 && envelope.code !== 0) return;
+	return parseUsage(raw);
+}
+/**
+* 获取个人账户的用量:每个生效套餐一个窗口。
+*
+* 请求体与官方 IDE 的 `getPersonalUsage` 完全一致(线上抓取):
+* `PageNumber:1, PageSize:100, ProductCode:"p_tcaca", Status:[0,3]`
+* 以及从当前时刻起 101 年的 `PackageEndTimeRange` 窗口 — 起点是“现在”,
+* 终点是 101 年后,依据 `main.js`(`s = new Date`,
+* `n = s + 101*365*24*60*60*1000`)。
+* @param identity - 已登录的身份,由会话刷新。
+* @param signal - 可选的取消信号。
+* @returns 已解析的快照,或计费面不可达时为 `undefined`。
+*/
+async function fetchPersonalUsage(identity, signal) {
+	const now = /* @__PURE__ */ new Date();
+	const end = new Date(now.getTime() + 101 * 365 * 24 * 60 * 60 * 1e3);
+	return postMeter(identity, "/v2/billing/meter/get-user-resource", JSON.stringify({
+		PageNumber: 1,
+		PageSize: 100,
+		ProductCode: "p_tcaca",
+		Status: [0, 3],
+		PackageEndTimeRangeBegin: formatTime(now.getTime() / 1e3),
+		PackageEndTimeRangeEnd: formatTime(end.getTime() / 1e3)
+	}), signal);
+}
+/**
+* 获取企业租户的用量:单个 `limitNum`/`credit` 对。
+*
+* 企业计费面接受空请求体并在 `data` 下回应,因此该请求就是一次带认证的 POST。
+* @param identity - 已登录的身份,由会话刷新。
+* @param signal - 可选的取消信号。
+* @returns 已解析的快照,或计费面不可达时为 `undefined`。
+*/
+async function fetchEnterpriseUsage(identity, signal) {
+	return postMeter(identity, "/v2/billing/meter/get-enterprise-user-usage", "{}", signal);
+}
+/**
+* 获取并解析 CodeBuddy 用量快照,按账户类型分叉。
+*
+* 视已登录身份是否披露了 `enterpriseId`,委托给 {@link fetchPersonalUsage}
+* 或 {@link fetchEnterpriseUsage}。所有失败模式都解析为 `undefined` 而不抛出;
+* 是否重试由调用方决定。
+* @param identity - 已登录的身份,由会话刷新。
+* @param signal - 可选的取消信号。
+* @returns 已解析的快照,或计费面不可达、回应了不可用响应体时为
+*   `undefined`。
+*/
+async function fetchUsage(identity, signal) {
+	return identity.enterpriseId !== void 0 ? fetchEnterpriseUsage(identity, signal) : fetchPersonalUsage(identity, signal);
+}
+//#endregion
+//#region lib/types/atomic-file.js
+/**
+* 插件自有 JSON 文件的写入底座:原子替换 + 按路径串行化。
+*
+* 三个存储(账号、会话选择、每轮积分)都是读-改-写的文件。原子替换让
+* 残缺内容永远不会留在磁盘上被当成一份读不出的记录;按路径排队让并发写入
+* 串行执行 —— 后一次读得到前一次的结果,而不是各自基于同一份旧内容覆盖对方。
+* 集中在这里,使三个存储不会各自实现一遍,也不会各自漏掉队列。
+*
+* @module dsh-llm-codebuddy-power/atomic-file
+*/
+/** 每个文件一条写队列,保存当前队尾。 */
+const queues = /* @__PURE__ */ new Map();
+/**
+* 排队一次针对某文件的写:前一次写完成后才开始执行。
+*
+* 队尾保存的是已消化失败的 promise —— 它的拒绝无人 await,留着会变成未处理的
+* rejection;调用方从返回的 promise 收到同一个失败。
+* @param path - 被写的文件。
+* @param write - 实际写入;在同一路径的写之间串行执行。
+* @returns 本次写入的结果;失败时以该失败拒绝。
+*/
+function queueWrite(path, write) {
+	const next = (queues.get(path) ?? Promise.resolve()).then(write);
+	const settled = next.then(() => void 0, () => void 0);
+	queues.set(path, settled);
+	settled.then(() => {
+		if (queues.get(path) === settled) queues.delete(path);
+	});
+	return next;
+}
+/**
+* 以原子替换写入一个文件,并在支持的文件系统上收紧为仅属主可读。
+*
+* 先写同目录下的临时文件再改名:改名在同一文件系统内是原子的,因此读到的
+* 要么是旧内容要么是新内容,不会是写了一半的内容。
+*
+* 内容是调用方给的字符串而不是由本函数序列化:`JSON.stringify` 的默认输出是一个
+* 字节的重复都没有的紧凑格式,可读性全靠调用方自己插入的换行 —— 需要控制"哪里换行"
+* 的存储因此各自决定格式(见 `session-store.ts` 的逐轮一行)。
+* @param path - 目标文件。
+* @param content - 要写入的完整内容。
+*/
+async function writeFileAtomic(path, content) {
+	await promises.mkdir(dirname(path), { recursive: true });
+	const temp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		await promises.writeFile(temp, content, {
+			encoding: "utf-8",
+			mode: 384
+		});
+		await promises.rename(temp, path);
+	} catch (error) {
+		await promises.unlink(temp).catch(() => {});
+		throw error;
+	}
+	await promises.chmod(path, 384).catch(() => {});
+}
+/**
+* 以原子替换写入一个 JSON 文件,缩进两格。
+*
+* 缩进是给需要肉眼排查的凭据文件用的(`storage.ts` 的 refresh token 与过期时间),
+* 不是通用默认值:批量记录类文件改用 {@link writeFileAtomic} 自己排版。
+* @param path - 目标文件。
+* @param value - 要序列化的值。
+*/
+async function writeJsonAtomic(path, value) {
+	await writeFileAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+//#endregion
+//#region lib/types/session-store.js
+/**
+* 插件自有的会话信息持久化:按会话一个文件,存该会话选用的账号、用过的账号表与
+* 每轮消耗的积分。
+*
+* 这三件事都是"这个会话自己的事实",因此放在同一个文件里
+* (`$DSH_HOME/data/plugins/llm-codebuddy-power/sessions/<会话id>.json`):读一次
+* 就拿到它们,也不会出现两份记录各自指向不同账号。文件是纯增量记录 —— 缺文件等价于
+* "没选过账号、没有积分"。写入是读-改-写的原子替换,并经 [atomic-file.ts](./atomic-file.ts)
+* 按路径串行化:一轮里画图与聊天会各自累加一次积分,分开读-改-写会丢掉其中一次。
+*
+* 文件只增不删:会话被销毁(一次性子代理跑完即如此)不等于用户删除了会话。
+*
+* **账号在表里存一次,每轮记录只引用它的序号**:同一个账号会在几十轮里反复出现,逐轮
+* 内联昵称是同一份事实的重复副本 —— 实测这让文件大了近一倍。键是文件内部自己编的序号
+* 而不是 uid 的任何截断:一个只在本文件里做引用的键不必携带 uid 的信息,截断反而会
+* 让两个同前缀的账号共用一条记录(把历史轮次张冠李戴),而序号不可能重复。
+*
+* 排版也在这里决定:`credits` 每条一行、`accounts` 每条一行,其余保持缩进。逐条一行
+* 让追加一轮只改动两行,而整个文件一行虽然更小,却让文件不可读、改动无法辨别。
+*
+* @module dsh-llm-codebuddy-power/session-store
+*/
+/** 空信息:文件缺失、损坏或字段不合法时的结果。 */
+function emptyInfo() {
+	return {
+		accounts: {},
+		credits: {}
+	};
+}
+/** 会话信息文件路径:`$DSH_HOME/data/plugins/llm-codebuddy-power/sessions/<会话id>.json`。
+*  插件数据统一放 `data/plugins/<插件名(不带dsh-前缀)>/` 下,`data` 是规范的数据目录。 */
+function sessionInfoPath(sessionId) {
+	return dshHomePath("data", "plugins", "llm-codebuddy-power", "sessions", `${sessionId}.json`);
+}
+/**
+* 账号在账号表里的序号。
+*
+* 序号从 0 起、按首次用到该账号的顺序分配,并保留在表里 —— 记录引用的是序号,因此
+* 序号不能随表内增删而改变,否则已有轮次会指向别的账号。
+* @param table - 当前的账号表。
+* @param uid - 要引用的账号 uid。
+* @returns 该账号的序号;从未用过时是下一个未占用的序号。
+*/
+function accountKeyFor(table, uid) {
+	for (const [key, ref] of Object.entries(table)) if (ref.uid === uid) return key;
+	let next = 0;
+	for (const key of Object.keys(table)) {
+		const n = Number(key);
+		if (Number.isSafeInteger(n) && n >= next) next = n + 1;
+	}
+	return String(next);
+}
+/** 文件读出的账号是否合法(两个事实都得在)。 */
+function isAccountRef(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const ref = value;
+	return typeof ref.uid === "string" && ref.uid.length > 0 && typeof ref.nick === "string" && ref.nick.length > 0;
+}
+/**
+* 文件读出的记录是否合法。
+*
+* `accounts` 与 `credit` 同为必填:一条记录说不出这一轮用的是哪个账号,悬停提示就会
+* 缺一行,那与"没有这条记录"没有区别,因此不完整即整条丢弃。引用还必须能在同一份
+* 文件的账号表里解析到 —— 一个悬空引用渲染不出账号,与缺字段是同一种残缺。
+* 插件尚未发布,磁盘上不存在按旧格式写下的文件,故不保留渐进读取。
+* @param value - 文件里的一条轮次记录。
+* @param table - 同一份文件的账号表。
+* @returns 该记录是否可用。
+*/
+function isCreditRecord(value, table) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return typeof record.credit === "number" && Number.isFinite(record.credit) && Array.isArray(record.accounts) && record.accounts.length > 0 && record.accounts.every((key) => typeof key === "string" && isAccountRef(table[key]));
+}
+/**
+* 读取一个会话的信息。
+* @param sessionId - dsh 会话 id。
+* @returns 该会话选用的账号、用过的账号表与积分记录;缺文件或损坏时返回空信息。
+*/
+async function loadSessionInfo(sessionId) {
+	try {
+		const parsed = JSON.parse(await promises.readFile(sessionInfoPath(sessionId), "utf-8"));
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return emptyInfo();
+		const record = parsed;
+		const accounts = {};
+		const rawAccounts = record.accounts;
+		if (typeof rawAccounts === "object" && rawAccounts !== null) {
+			for (const [key, value] of Object.entries(rawAccounts)) if (isAccountRef(value)) accounts[key] = value;
+		}
+		const credits = {};
+		const rawCredits = record.credits;
+		if (typeof rawCredits === "object" && rawCredits !== null) {
+			for (const [turn, value] of Object.entries(rawCredits)) if (isCreditRecord(value, accounts)) credits[turn] = value;
+		}
+		const uid = typeof record.uid === "string" && record.uid.length > 0 ? record.uid : void 0;
+		return {
+			...uid === void 0 ? {} : { uid },
+			accounts,
+			credits
+		};
+	} catch {
+		return emptyInfo();
+	}
+}
+/**
+* 把一份信息渲染成文件内容。
+*
+* 逐条一行而不是缩进展开:条目本身是单行记录,缩进只增加字节而不增加可读性。账号表与
+* 轮次记录各自一行,于是新增一轮只改动两行(diff 可读),而文件整体仍然紧凑。
+* @param info - 要渲染的信息。
+* @returns 完整的文件内容,以换行结尾。
+*/
+function renderSessionInfo(info) {
+	const lines = [];
+	if (info.uid !== void 0) lines.push(`  "uid": ${JSON.stringify(info.uid)},`);
+	const accounts = Object.entries(info.accounts);
+	if (accounts.length === 0) lines.push("  \"accounts\": {},");
+	else {
+		lines.push("  \"accounts\": {");
+		accounts.forEach(([key, ref], index) => {
+			lines.push(`    ${JSON.stringify(key)}: ${JSON.stringify(ref)}${index === accounts.length - 1 ? "" : ","}`);
+		});
+		lines.push("  },");
+	}
+	const credits = Object.entries(info.credits);
+	if (credits.length === 0) lines.push("  \"credits\": {}");
+	else {
+		lines.push("  \"credits\": {");
+		credits.forEach(([turn, record], index) => {
+			lines.push(`    ${JSON.stringify(turn)}: ${JSON.stringify(record)}${index === credits.length - 1 ? "" : ","}`);
+		});
+		lines.push("  }");
+	}
+	return `{\n${lines.join("\n")}\n}\n`;
+}
+/**
+* 读-改-写一个会话的信息(原子替换,文件不存在则新建)。
+*
+* 读发生在队列内部,因此排队中的后一次改动看得到前一次的结果,而不是各自基于同一份
+* 旧内容。文件此刻不可读时按空信息起手,与 {@link loadSessionInfo} 对同一情况的判断一致。
+* @param sessionId - dsh 会话 id。
+* @param change - 由当前信息算出新信息;不得就地修改传入值。
+*/
+async function updateSessionInfo(sessionId, change) {
+	const path = sessionInfoPath(sessionId);
+	await queueWrite(path, async () => {
+		await writeFileAtomic(path, renderSessionInfo(change(await loadSessionInfo(sessionId))));
+	});
+}
+//#endregion
+//#region lib/types/storage.js
+/**
+* 持久化 OAuth 账号存储,磁盘上仅属主可读。
+*
+* 存储位于 harness home 的规范数据目录
+* (`$DSH_HOME/data/plugins/llm-codebuddy-power/`,通过 harness 所用的同一个
+* `@deepseek-ai/dsh-home-paths` 解析),而不放在插件包内,因此重装不会让
+* 用户退出登录。写入经 [atomic-file.ts](./atomic-file.ts) 做原子替换并按路径串行化:
+* 多个账号的令牌刷新、设置页的增删与 CLI 的调用都在改同一份文件,不串行化时
+* 两个并发写入会各自基于自己读到的旧内容覆盖对方。残缺文件会让用户手里只有
+* 一份读不出的凭据,还无法与“从未登录过”区分开。
+*
+* @module dsh-llm-codebuddy-power/storage
+*/
+/** 空存储:读取不到任何可用内容时的结果。 */
+function emptyStorage() {
+	return { accounts: [] };
+}
+/**
+* 凭据文件的绝对路径。
+*
+* 通过 `@deepseek-ai/dsh-home-paths` 解析,以跟随 harness 自身的 home 优先级
+* (配置路径 > `$DSH_HOME` > `~/.dsh`),绝不会分叉到另行计算的 home。
+* `DSH_CODEBUDDY_AUTH_FILE` 保留作为测试与迁移用的显式逃生口。
+* @returns 绝对凭据路径,优先遵循环境变量覆盖。
+*/
+function getStoragePath() {
+	const override = process.env.DSH_CODEBUDDY_AUTH_FILE;
+	if (override !== void 0 && override.length > 0) return override;
+	return dshHomePath("data", "plugins", "llm-codebuddy-power", "codebuddy-auth.json");
+}
+/**
+* 路径是否仅其属主可读。
+*
+* 与 `@deepseek-ai/dsh-credentials-local` 在加载自己的凭据文档前所做的仅属主
+* 检查一致:只要 group 或 other 的读/写位被置上,即视为文件已暴露,检查
+* 失败。Windows 没有 POSIX 模式,因此在 Windows 上跳过该检查——防护强度
+* 取决于创建与替换 API 所表达的内容,与 dsh-credentials-local 相同。
+* @param path - 凭据文件路径。
+* @returns 文件不存在(尚无可保护内容)或以仅属主权限存在时返回 true;
+*   文件存在且已暴露时返回 false。
+*/
+async function isOwnerOnly(path) {
+	if (process.platform === "win32") return true;
+	let mode;
+	try {
+		mode = (await promises.stat(path)).mode;
+	} catch {
+		return true;
+	}
+	return (mode & 63) === 0;
+}
+/** 账号条目是否携带了成对的令牌、uid 与刷新令牌的到期时刻。 */
+function isAccountEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const entry = value;
+	return typeof entry.auth?.accessToken === "string" && typeof entry.auth.refreshToken === "string" && typeof entry.auth.refreshExpiresAt === "number" && Number.isFinite(entry.auth.refreshExpiresAt) && typeof entry.account?.uid === "string";
+}
+/**
+* 丢弃取值为空字符串的账号字符串字段,把它们当作不存在。
+*
+* 在 `normalizeAccount` 之前写入的较旧凭据可能从 wire 带来 `uin: ""`
+* (以及其他取值为空的可选字符串);这里把它们裁掉,使下游每个消费方的
+* `=== undefined` 判断都成立,而无需各自再加空字符串防护。
+* @param account - 解析后的账号字段。
+* @returns 已移除取值为空的可选字段的账号。
+*/
+function trimEmptyAccountFields(account) {
+	const pick = (v) => v === void 0 || v.length === 0 ? void 0 : v;
+	return {
+		uid: account.uid,
+		nickname: account.nickname,
+		...pick(account.uin) === void 0 ? {} : { uin: account.uin },
+		...pick(account.enterpriseId) === void 0 ? {} : { enterpriseId: account.enterpriseId },
+		...pick(account.enterpriseName) === void 0 ? {} : { enterpriseName: account.enterpriseName },
+		...pick(account.enterpriseUserName) === void 0 ? {} : { enterpriseUserName: account.enterpriseUserName },
+		...pick(account.departmentFullName) === void 0 ? {} : { departmentFullName: account.departmentFullName }
+	};
+}
+/**
+* 把解析出的 JSON 归一化为账号集合。
+*
+* 同时接受当前形态与仅有一个账号的旧形态(顶层 `auth` + `account`):旧文件
+* 迁移成单元素列表,并让那个账号成为默认账号,于是升级不会改变用户下一次
+* 请求用的是谁。`defaultUid` 与 `lastUid` 指向已不存在的账号时丢弃——它们只是
+* 指针,留着会让“有没有默认账号”与实际情况相反。
+* @param parsed - 解析出的 JSON 值。
+* @returns 归一化后的账号集合。
+*/
+function normalizeStorage(parsed) {
+	if (typeof parsed !== "object" || parsed === null) return emptyStorage();
+	const record = parsed;
+	if (Array.isArray(record.accounts)) {
+		const accounts = record.accounts.filter(isAccountEntry).map((entry) => ({
+			auth: entry.auth,
+			account: trimEmptyAccountFields(entry.account)
+		}));
+		const pick = (value) => {
+			if (typeof value !== "string") return void 0;
+			return accounts.some((a) => a.account.uid === value) ? value : void 0;
+		};
+		const defaultUid = pick(record.defaultUid);
+		const lastUid = pick(record.lastUid);
+		return {
+			accounts,
+			...defaultUid === void 0 ? {} : { defaultUid },
+			...lastUid === void 0 ? {} : { lastUid }
+		};
+	}
+	if (!isAccountEntry(record)) return emptyStorage();
+	return {
+		accounts: [{
+			auth: record.auth,
+			account: trimEmptyAccountFields(record.account)
+		}],
+		defaultUid: record.account.uid
+	};
+}
+/**
+* 读取已存储的账号集合。
+*
+* 在读取任何字节之前先检查文件模式:主机上其他用户可读的凭据会被当作不存在
+* 而不是拿来使用,因此丢失仅属主模式的文件(手动 chmod 出错、从别处拷贝)
+* 绝不会被加载。当作不存在也能自愈——下次登录会用 `0o600` 重写该文件。
+* @returns 账号集合;没有可用内容时为空集合。文件缺失、文件损坏与权限不安全
+*   刻意给出相同答案:都表示“此处没有可安全用于认证的东西”,而登录流程是
+*   每一种情况的修复方式。
+*/
+async function loadStorage() {
+	const path = getStoragePath();
+	try {
+		if (!await isOwnerOnly(path)) return emptyStorage();
+		const raw = await promises.readFile(path, "utf-8");
+		return normalizeStorage(JSON.parse(raw));
+	} catch {
+		return emptyStorage();
+	}
+}
+/**
+* 读-改-写账号集合。
+*
+* 读发生在队列内部,因此排队中的后一次改动看得到前一次的结果,而不是各自
+* 基于同一份旧内容。文件此刻无法安全读取时按空集合起手,与 {@link loadStorage}
+* 对同一情况的判断一致。
+* @param change - 由当前集合算出新集合;不得就地修改传入值。
+*/
+async function updateStorage(change) {
+	const path = getStoragePath();
+	await queueWrite(path, async () => {
+		await writeJsonAtomic(path, change(await loadStorage()));
+	});
+}
+/**
+* 插入一个账号,或替换同 uid 账号的凭据。
+*
+* 同 uid 视为重新登录同一个账号:令牌被替换而不是追加成第二个条目,否则
+* 设置页会出现两个同名徽章,退出其中一个还会留下另一个。
+* @param entry - 刚登录得到的账号。
+*/
+async function upsertAccount(entry) {
+	await updateStorage((current) => {
+		const uid = entry.account.uid;
+		const accounts = current.accounts.some((a) => a.account.uid === uid) ? current.accounts.map((a) => a.account.uid === uid ? entry : a) : [...current.accounts, entry];
+		const defaultUid = current.defaultUid ?? (current.accounts.length === 0 ? uid : void 0);
+		return {
+			accounts,
+			...defaultUid === void 0 ? {} : { defaultUid },
+			...current.lastUid === void 0 ? {} : { lastUid: current.lastUid }
+		};
+	});
+}
+/**
+* 按给定顺序重排账号。
+*
+* 先按传入顺序取已知账号,再把没被提到的账号按原有相对顺序追加在后:因此落点算错、
+* 漏传某个 uid 或传入未知 uid 都不会让账号丢失或重复 —— 拖拽结果与磁盘之间只有这一处
+* 取舍,写错就是把用户已登录的账号弄丢。重复的 uid 只取第一次出现。
+* @param uids - 目标顺序上的账号 uid。
+*/
+async function reorderAccounts(uids) {
+	await updateStorage((current) => {
+		const pending = new Map(current.accounts.map((account) => [account.account.uid, account]));
+		const ordered = [];
+		for (const uid of uids) {
+			const account = pending.get(uid);
+			if (account === void 0) continue;
+			pending.delete(uid);
+			ordered.push(account);
+		}
+		for (const account of current.accounts) {
+			if (!pending.has(account.account.uid)) continue;
+			pending.delete(account.account.uid);
+			ordered.push(account);
+		}
+		return {
+			...current,
+			accounts: ordered
+		};
+	});
+}
+/**
+* 移除若干账号,并清掉指向它们的默认账号与“最后一次手动切换”的账号。
+* @param uids - 要移除的账号 uid。
+*/
+async function removeAccounts(uids) {
+	const removed = new Set(uids);
+	await updateStorage((current) => {
+		const accounts = current.accounts.filter((a) => !removed.has(a.account.uid));
+		const gone = (uid) => uid !== void 0 && removed.has(uid) ? void 0 : uid;
+		const defaultUid = gone(current.defaultUid);
+		const lastUid = gone(current.lastUid);
+		return {
+			accounts,
+			...defaultUid === void 0 ? {} : { defaultUid },
+			...lastUid === void 0 ? {} : { lastUid }
+		};
+	});
+}
+/**
+* 指定或取消默认账号。
+* @param uid - 默认账号的 uid;传 `undefined` 取消默认账号。
+*/
+async function setDefaultAccount(uid) {
+	await updateStorage((current) => {
+		const next = {
+			accounts: current.accounts,
+			...current.lastUid === void 0 ? {} : { lastUid: current.lastUid }
+		};
+		if (uid !== void 0 && current.accounts.some((a) => a.account.uid === uid)) next.defaultUid = uid;
+		return next;
+	});
+}
+/**
+* 记下最后一次被手动切换到的账号(没有默认账号时作为兜底)。
+* @param uid - 被切换到的账号 uid。
+*/
+async function setLastAccount(uid) {
+	await updateStorage((current) => ({
+		...current,
+		lastUid: uid
+	}));
+}
+/**
+* 凭据文件的不透明新鲜度令牌:文件每次被重写或删除时它都会变化,因此内存中
+* 的会话能察觉另一个进程(CLI)执行的登录与登出,而不必在什么都没变时
+* 每次调用都重新读取。
+* @returns 一个令牌;没有凭据文件时返回 `undefined`。
+*/
+async function storageFreshness() {
+	let stat;
+	try {
+		stat = await promises.stat(getStoragePath());
+	} catch {
+		return;
+	}
+	return `${stat.mtimeMs}:${stat.size}`;
+}
+//#endregion
+//#region lib/types/session.js
+/**
+* 已登录会话:按账号解析身份、token 新鲜度与缓存的模型目录。
+*
+* 一个对象同时持有它们,因为它们共享同一种故障模式 → token 过期会导致
+* 目录不可读 → 也因为它们都必须在构建请求之前解析完成。刷新是单飞的,而且是
+* **按账号**单飞:适配器每次流式调用解析一次身份,若不按账号分开,两个账号的
+* 并发调用会互相取到对方的刷新结果,其中一个的 token 永远停留过期。
+*
+* 账号由会话决定:某个会话显式选了账号就用它,否则顺延到派生它的会话(子代理、
+* fork)、默认账号、最后一次手动切换的账号,最后落到列表第一个。目录与计量快照
+* 也按账号分别缓存,因为不同账号的可用模型与额度本就可以不同。
+*
+* @module dsh-llm-codebuddy-power/session
+*/
+/** 提前这么久刷新,而不是正好在记录的过期时刻刷新。 */
+const REFRESH_SKEW_MS = 6e4;
+/**
+* 读到的目录在被再次向服务查询之前复用多久。与官方 CLI 的
+* `PRODUCT_CONFIGURATION_CACHE_TIMEOUT`(48e4 ms)对齐。
+*/
+const CATALOG_TTL_MS = 480 * 1e3;
+/**
+* 计量快照在被再次向真实 CodeBuddy 用量平面查询之前服务多久。浏览器以
+* 短得多的间隔轮询宿主;这个 TTL 就是让那些轮询不落到计量 API 上的那一层。
+*/
+const METER_TTL_MS = 60 * 1e3;
+/** 未登录任何账号时抛出;消息中携带补救方法。 */
+var NotLoggedInError = class extends Error {
+	constructor(detail) {
+		super(detail);
+		this.name = "NotLoggedInError";
+	}
+};
+/**
+* 把一条文件记录里的账号引用按账号表展开。
+*
+* 引用解析不到时返回 `undefined` 而不是抛错:读取路径已经保证不会发生(校验时表已建好),
+* 这里只是让"残缺记录不交给界面"这条规则不依赖上游。
+* @param record - 文件里的一条轮次记录。
+* @param table - 同一份文件的账号表。
+* @returns 展开后的记录;有引用解析不到时为 `undefined`。
+*/
+function resolveCreditRecord(record, table) {
+	const accounts = [];
+	for (const key of record.accounts) {
+		const ref = table[key];
+		if (ref === void 0) return void 0;
+		accounts.push({
+			nickname: ref.nick,
+			uid: ref.uid
+		});
+	}
+	return {
+		credit: record.credit,
+		accounts
+	};
+}
+/**
+* 由 dsh 会话身份推导请求头所需的会话 id。
+*
+* 官方只在请求头里认紧凑 uuid(无 `session-` 前缀、无连字符),而 Web GUI 的会话
+* id 正是 `session-<uuid>`:去掉前缀与连字符后恰好 32 位,因此会话 id 可以直接
+* 换算得到,不必另铸一个随机值 —— 后者一旦承载它的内存状态被丢弃(会话销毁后
+* 又恢复),同一个会话就会换一个 id。
+*
+* 取**最后一个** `session-` 之后的部分,而不是去掉开头那一个:会话 id 还有
+* `<agent-id>-session-<uuid>` 形态,从开头截取会把 agent 名混进结果,产生非
+* 十六进制字符。超过 32 位截断,不足则在**前面**补 `0`,使非 uuid 形态(如计数器式
+* `session-<n>`)也得到定长的合法值;在前面补而不是在后面补,是因为数字只有在
+* 右对齐时才互不重合 —— 在后面补会让 `session-1` 与 `session-10` 得到同一个值。
+* @param sessionId - dsh 会话身份。
+* @returns 32 位紧凑 uuid。
+*/
+function compactConversationId(sessionId) {
+	const at = sessionId.lastIndexOf("session-");
+	const compact = (at === -1 ? sessionId : sessionId.slice(at + 8)).replace(/-/g, "");
+	return compact.length >= 32 ? compact.slice(0, 32) : compact.padStart(32, "0");
+}
+/** 账号状态投影:丢掉取值为空的可选字段,使调用方的 `=== undefined` 判断成立。 */
+function accountInfo(entry) {
+	const a = entry.account;
+	return {
+		uid: a.uid,
+		nickname: a.nickname,
+		loginExpiresAt: entry.auth.refreshExpiresAt,
+		...a.uin === void 0 ? {} : { uin: a.uin },
+		...a.enterpriseId === void 0 ? {} : { enterpriseId: a.enterpriseId },
+		...a.enterpriseName === void 0 ? {} : { enterpriseName: a.enterpriseName },
+		...a.enterpriseUserName === void 0 ? {} : { enterpriseUserName: a.enterpriseUserName },
+		...a.departmentFullName === void 0 ? {} : { departmentFullName: a.departmentFullName }
+	};
+}
+/**
+* 持有单个插件实例的已存账号、每个会话选用的账号与它们的缓存。
+*
+* 内存中没有凭据时会从磁盘重新读取,这正是
+* `dsh plugin --profile web codebuddy-power` 能在不重启的情况下
+* 让*运行中*的 harness 登录的原因。
+*/
+var CodeBuddySession = class {
+	logger;
+	onModelsChanged;
+	storage;
+	/** 内存中 `storage` 所读自的凭据文件的新鲜度标记。 */
+	storageKey;
+	/**
+	* {@link storageKey} 是否足以代表 {@link storage}。
+	*
+	* `undefined` 的新鲜度有两种含义 —— 文件真的不存在,或这一次 `fs.stat` 失败(Windows
+	* 上并发替换文件时会短暂如此)—— 所以它不能单独用来判断“没变”。把它当成“没变”而
+	* `storage` 恰好是空的,账号列表就会被读成空、界面显示“未登录”,而磁盘上凭据完好。
+	*/
+	storageMemoValid = false;
+	/** 上一次加载时账号集合的 uid 列表,用来判断集合本身有没有变。 */
+	storageUids = "";
+	/** 按账号 uid 单飞的令牌刷新。 */
+	refreshing = /* @__PURE__ */ new Map();
+	/** 按账号 uid 缓存的目录;合并目录由它派生,因此它的增删决定合并目录的内容。 */
+	catalogs = /* @__PURE__ */ new Map();
+	/**
+	* 模型 id → 模型,由 {@link catalogs} 派生的并集索引,同 id 保留先到的那份。
+	*
+	* 集合只由**带会话身份的**读取填充(聊天请求、模型面板),并供拿不到会话身份的
+	* 调用方({@link knownModel}、`listModels`)查询:那些调用方无法知道该用哪个账号
+	* 的目录,主动读取只能落在默认账号上 —— 而当前会话用的可能正是另一个账号。
+	*/
+	knownCatalog = /* @__PURE__ */ new Map();
+	/** 按账号 uid 单飞的目录读取。 */
+	catalogReads = /* @__PURE__ */ new Map();
+	/** 按账号 uid 缓存的计量快照;在 {@link METER_TTL_MS} 内直接返回,不访问该平面。 */
+	usageCache = /* @__PURE__ */ new Map();
+	/** 活动会话,以 dsh 会话 id 为键;在 `session/disposed` 时清理。 */
+	tracks = /* @__PURE__ */ new Map();
+	/**
+	* 已读出的会话信息(选用的账号 + 每轮积分),按会话 id。
+	*
+	* 单独于 {@link tracks}:账号选择要在还没有任何回合的会话上就能读到(新建会话后
+	* 立刻切账号,第一条消息就得用它),而 `tracks` 只在 `turn/start` 时才有条目。
+	*/
+	infos = /* @__PURE__ */ new Map();
+	/** 正在从文件读取的会话信息,避免并发重复读。 */
+	infoReads = /* @__PURE__ */ new Map();
+	constructor(logger, onModelsChanged) {
+		this.logger = logger;
+		this.onModelsChanged = onModelsChanged;
+	}
+	/**
+	* 在首次见到某会话时以及每个新轮次,为该会话铸出当前轮的请求 id。轮请求 id
+	* 在 harness 打开一个该会话尚未被观察到的轮次时铸出,因此一个用户
+	* 提示词内的所有模型调用都共享它,即使在运行中途插入了提示词。
+	* @param sessionId - dsh 会话身份。
+	* @param turn - harness 刚打开的轮次。
+	* @param parentSessionId - 该会话派生自的会话(子代理、fork),没有时为 `undefined`。
+	*/
+	observeTurn(sessionId, turn, parentSessionId) {
+		const current = this.tracks.get(sessionId);
+		if (current === void 0) {
+			this.tracks.set(sessionId, {
+				turn,
+				turnRequestId: compactUuid(),
+				credits: /* @__PURE__ */ new Map(),
+				...parentSessionId === void 0 ? {} : { parent: parentSessionId }
+			});
+			return;
+		}
+		if (parentSessionId !== void 0) current.parent = parentSessionId;
+		if (current.turn === turn) return;
+		current.turn = turn;
+		current.turnRequestId = compactUuid();
+	}
+	/**
+	* 在 harness 销毁某会话时丢弃它被跟踪的回合状态与已读出的会话信息,使这两个 map
+	* 不会无界增长。磁盘上的会话信息不随之删除:该事件表示会话对象被销毁,而不是用户
+	* 删除了会话 —— 一次性子代理跑完就会触发它。
+	* @param sessionId - dsh 会话身份。
+	*/
+	forget(sessionId) {
+		this.tracks.delete(sessionId);
+		this.infos.delete(sessionId);
+	}
+	/**
+	* 某会话对应的 CodeBuddy 会话 id。由 dsh 会话身份推导,不依赖跟踪状态:
+	* 同一会话在任何时刻、任何进程里都得到同一个值。
+	* @param sessionId - dsh 会话身份。
+	* @returns 32 位紧凑 uuid。
+	*/
+	conversationIdOf(sessionId) {
+		return compactConversationId(sessionId);
+	}
+	/**
+	* 某会话当前轮的请求 id;该会话尚未被观察到时为 `undefined`。
+	* @param sessionId - dsh 会话身份。
+	* @returns 该轮的请求 id;未被观察到的会话为 `undefined`。
+	*/
+	turnRequestIdOf(sessionId) {
+		return this.tracks.get(sessionId)?.turnRequestId;
+	}
+	/**
+	* 读出某会话的信息(选用的账号 + 每轮积分),进程内缓存一次。
+	*
+	* 首读才碰磁盘:账号解析在每次请求上发生,而一个会话的账号选择不会在运行期间被
+	* 别的进程改动(只有本进程写它),因此缓存到会话被销毁即可。
+	* @param sessionId - dsh 会话身份。
+	* @returns 该会话的信息;文件缺失时为“未选账号、无积分”。
+	*/
+	async infoOf(sessionId) {
+		const cached = this.infos.get(sessionId);
+		if (cached !== void 0) return cached;
+		let pending = this.infoReads.get(sessionId);
+		if (pending === void 0) {
+			pending = loadSessionInfo(sessionId).finally(() => {
+				if (this.infoReads.get(sessionId) === pending) this.infoReads.delete(sessionId);
+			});
+			this.infoReads.set(sessionId, pending);
+		}
+		const info = await pending;
+		this.infos.set(sessionId, info);
+		return info;
+	}
+	/**
+	* 把一次 CodeBuddy 请求的扣分累加到会话当前轮。聊天请求与画图工具都
+	* 调用:一轮内两者都可能发生(顺序不定),扣分相加。记录合并到插件自有的
+	* 会话信息文件(fire-and-forget),重启后仍可读。模型不存——dsh 用量自带。
+	*
+	* 账号一并记录,且只在首次使用时追加(按完整 uid 判定是否已记过):扣分与"哪个账号
+	* 扣的"必须在同一时刻取自同一个事实,悬停时再查当前账号会把一轮里切换过账号的情况说错。
+	*
+	* 序号在落盘的读-改-写内部才分配:它取决于该文件当前的账号表,而那张表只有在队列里
+	* 读到文件之后才知道。内存里因此存解析好的账号(昵称 + 完整 uid),文件里存序号 —— 两者
+	* 形状不同是有意的,文件只该存一次账号,而每次查询都回表解析会让悬停这条热路径多一层查找。
+	* @param sessionId - dsh 会话 id。
+	* @param credit - 本次请求扣的积分。
+	* @param account - 发起本次请求的账号。
+	*/
+	recordCredit(sessionId, credit, account) {
+		const track = this.tracks.get(sessionId);
+		if (track === void 0) return;
+		const turn = track.turn;
+		const existing = track.credits.get(turn);
+		const accounts = existing?.accounts ?? [];
+		const known = accounts.some((entry) => entry.uid === account.uid);
+		const merged = {
+			credit: (existing?.credit ?? 0) + credit,
+			accounts: known ? accounts : [...accounts, {
+				nickname: account.nickname,
+				uid: account.uid
+			}]
+		};
+		track.credits.set(turn, merged);
+		updateSessionInfo(sessionId, (info) => {
+			const table = { ...info.accounts };
+			const keys = merged.accounts.map((entry) => {
+				const key = accountKeyFor(table, entry.uid);
+				table[key] = {
+					uid: entry.uid,
+					nick: entry.nickname
+				};
+				return key;
+			});
+			return {
+				...info,
+				accounts: table,
+				credits: {
+					...info.credits,
+					[String(turn)]: {
+						credit: merged.credit,
+						accounts: keys
+					}
+				}
+			};
+		}).catch((error) => {
+			this.logger?.warn(`dsh-codebuddy: could not persist turn credits: ${String(error)}`);
+		});
+	}
+	/**
+	* 某会话某一轮的积分。内存未命中时回退到会话信息文件(重启恢复),
+	* 并回填缓存。
+	* @param sessionId - dsh 会话身份。
+	* @param turn - 轮次号。
+	* @returns 该记录;该轮没有上报任何积分时为 `undefined`。
+	*/
+	async creditOf(sessionId, turn) {
+		const memory = this.tracks.get(sessionId)?.credits.get(turn);
+		if (memory !== void 0) return memory;
+		const info = await this.infoOf(sessionId);
+		const track = this.tracks.get(sessionId);
+		for (const [key, record] of Object.entries(info.credits)) {
+			const n = Number(key);
+			if (!Number.isSafeInteger(n)) continue;
+			const resolved = resolveCreditRecord(record, info.accounts);
+			if (resolved !== void 0) track?.credits.set(n, resolved);
+		}
+		const record = info.credits[String(turn)];
+		return record === void 0 ? void 0 : resolveCreditRecord(record, info.accounts);
+	}
+	/**
+	* 遗忘内存中的账号与按账号缓存的数值,并广播这次变化。
+	*
+	* 刻意不动 {@link catalogs} 与由它派生的 {@link knownCatalog}:目录内容
+	* (模型、促销、档位)不随凭据或按模型的覆写变化(覆写每次解析都从磁盘重读,
+	* 见 `model-enrich.ts` 的 `loadOverrides`),而清掉它们会把官方列表的并集一起
+	* 打空 —— 本方法也被改覆写与 401 失效调用,那时别的账号已并进来的模型不该消失。
+	* 账号真的增删时由 {@link forgetDepartedAccounts} 按 uid 精确丢弃。
+	*/
+	invalidate() {
+		this.storage = void 0;
+		this.storageMemoValid = false;
+		this.refreshing.clear();
+		this.catalogReads.clear();
+		this.usageCache.clear();
+		this.onModelsChanged?.();
+	}
+	/**
+	* 由当前缓存的各账号目录重建合并目录。
+	*
+	* 账号退出后的处理必须是"重建"而不是"清空":清空会让官方列表塌回默认账号,
+	* 而其余仍登录账号的目录本来就在手上 —— 继续并着才是"退出后重新合并当前已有的
+	* 列表"。重建同时确定性地解决同 id 的归属:只剩下仍在的账号参与竞争。
+	*/
+	reindexKnownCatalog() {
+		this.knownCatalog.clear();
+		for (const catalog of this.catalogs.values()) for (const model of catalog.models) if (!this.knownCatalog.has(model.id)) this.knownCatalog.set(model.id, model);
+	}
+	/**
+	* 丢弃已不在账号集合里的账号的缓存与计量快照,并重建合并目录。
+	*
+	* 按成员判定而不是按文件指纹:指纹会被 {@link invalidate} 置空(改一次覆写也走
+	* 那条路),按指纹清空并集会让别的账号的模型凭空消失;而按成员判定是幂等的 ——
+	* 同一个账号仍在时什么都不丢,重复调用也不会多清一次。
+	*/
+	forgetDepartedAccounts() {
+		const stored = new Set((this.storage?.accounts ?? []).map((entry) => entry.account.uid));
+		let departed = false;
+		for (const uid of [...this.catalogs.keys()]) {
+			if (stored.has(uid)) continue;
+			this.catalogs.delete(uid);
+			departed = true;
+		}
+		for (const uid of [...this.usageCache.keys()]) if (!stored.has(uid)) this.usageCache.delete(uid);
+		if (departed) this.reindexKnownCatalog();
+	}
+	/**
+	* 只要凭据文件自上次读取以来发生了变化就重新读取,使另一个进程
+	* (CLI)执行的登录或登出能在不重启的情况下到达运行中的 harness:已持有的
+	* `storage` 不能比被重写或删除的凭据文件活得更久。
+	*
+	* 重读之后只有**账号集合本身**变了才算一次账号变更,判据是 uid 列表而不是文件
+	* 指纹:指纹每次写文件都变,于是每刷新一次令牌(另一个进程的 `--status` 也会)
+	* 或每记一次“最后切换的账号”都会被当成账号变更,从而丢掉按账号缓存的计量快照并
+	* 广播一次模型变更 —— 那些都不是账号增删。真的增删时才会丢弃已退出账号的缓存并
+	* 重建合并目录:退出一个账号后官方列表应当继续并着其余账号已读到的目录,而不是
+	* 塌回默认账号一个。
+	*/
+	async refreshIfChanged() {
+		const storageKey = await storageFreshness();
+		if (this.storageMemoValid && storageKey !== void 0 && storageKey === this.storageKey) return;
+		this.storageKey = storageKey;
+		this.storage = await loadStorage();
+		this.storageMemoValid = this.storage.accounts.length > 0;
+		const uids = this.storage.accounts.map((account) => account.account.uid).sort().join("\0");
+		if (uids === this.storageUids) return;
+		this.storageUids = uids;
+		this.forgetDepartedAccounts();
+		this.onModelsChanged?.();
+	}
+	/** 账号条目,按 uid 查。 */
+	accountEntry(uid) {
+		return uid === void 0 ? void 0 : this.storage?.accounts.find((a) => a.account.uid === uid);
+	}
+	/**
+	* 该会话自身及其派生祖先显式选用的账号,由近及远。读取某个会话的信息可能要碰盘,
+	* 因此本方法是异步的。
+	*
+	* 走到祖先是因为子代理与 fork 出来的会话在界面上没有自己的账号按钮:它们若不
+	* 沿用父会话,就会静默改用默认账号,把一次派发记到另一个账号头上。
+	*/
+	async accountChain(sessionId) {
+		const chain = [];
+		const seen = /* @__PURE__ */ new Set();
+		let current = sessionId;
+		while (current !== void 0 && !seen.has(current)) {
+			seen.add(current);
+			const uid = (await this.infoOf(current)).uid;
+			if (uid !== void 0) chain.push(uid);
+			current = this.tracks.get(current)?.parent;
+		}
+		return chain;
+	}
+	/**
+	* 该会话此刻生效的账号 uid。
+	*
+	* 顺序:会话(或其派生祖先)显式选用的账号 → 默认账号 → 最后一次手动切换的
+	* 账号 → 列表第一个。指向已退出账号的选择会被跳过,而不是当成“没有账号”;
+	* 全部落空时返回 `undefined`,调用方据此报未登录。
+	*/
+	async accountUidFor(sessionId) {
+		if (sessionId !== void 0) {
+			for (const uid of await this.accountChain(sessionId)) if (this.accountEntry(uid) !== void 0) return uid;
+		}
+		for (const fallback of [this.storage?.defaultUid, this.storage?.lastUid]) if (this.accountEntry(fallback) !== void 0) return fallback;
+		return this.storage?.accounts[0]?.account.uid;
+	}
+	identityOf(entry) {
+		return {
+			accessToken: entry.auth.accessToken,
+			domain: entry.auth.domain,
+			uid: entry.account.uid,
+			...entry.account.enterpriseId === void 0 ? {} : { enterpriseId: entry.account.enterpriseId },
+			...entry.account.departmentFullName === void 0 ? {} : { departmentFullName: entry.account.departmentFullName }
+		};
+	}
+	/** 把刷新后的账号写回内存,并尽力落盘(写不进去也不影响本进程继续使用)。 */
+	async persist(entry) {
+		const accounts = this.storage?.accounts;
+		if (accounts !== void 0) {
+			const at = accounts.findIndex((a) => a.account.uid === entry.account.uid);
+			if (at !== -1) accounts[at] = entry;
+		}
+		try {
+			await updateStorage((current) => ({
+				...current,
+				accounts: current.accounts.map((a) => a.account.uid === entry.account.uid ? entry : a)
+			}));
+		} catch (error) {
+			this.logger?.warn("dsh-codebuddy: refreshed the session but could not persist it");
+			this.logger?.warn(error);
+		}
+	}
+	/**
+	* 已存账号条目,在首次使用、失效之后以及文件被外部改动时从磁盘读取。
+	* @param sessionId - 用哪个会话的账号;会话未选用时按默认账号解析。
+	* @throws NotLoggedInError 未存有任何凭据时。
+	*/
+	async require(sessionId) {
+		await this.refreshIfChanged();
+		const entry = this.accountEntry(await this.accountUidFor(sessionId));
+		if (entry === void 0) throw new NotLoggedInError("CodeBuddy is not signed in. Run `dsh plugin --profile web codebuddy-power` to sign in through your browser; no API key is required.");
+		return entry;
+	}
+	/**
+	* 某账号可用的身份,在访问 token 到达或临近过期时刷新它。同一账号的并发
+	* 调用者共享同一次刷新;不同账号各刷各的。
+	* @param entry - 要解析的账号条目。
+	* @returns 用于认证请求的身份。
+	* @throws NotLoggedInError 刷新 token 本身已过期、只能重新在浏览器登录时。
+	*/
+	async identityFor(entry) {
+		const now = Date.now();
+		if (now < entry.auth.expiresAt - REFRESH_SKEW_MS) return this.identityOf(entry);
+		if (now >= entry.auth.refreshExpiresAt) throw new NotLoggedInError(`The CodeBuddy session for ${entry.account.nickname} has expired. Run \`dsh plugin --profile web codebuddy-power\` to sign in again through your browser.`);
+		const uid = entry.account.uid;
+		let pending = this.refreshing.get(uid);
+		if (pending === void 0) {
+			pending = this.refresh(entry).finally(() => {
+				if (this.refreshing.get(uid) === pending) this.refreshing.delete(uid);
+			});
+			this.refreshing.set(uid, pending);
+		}
+		return pending;
+	}
+	async refresh(entry) {
+		const refreshed = await refreshAccessToken(this.identityOf(entry), entry.auth.refreshToken);
+		if (refreshed === void 0) throw new NotLoggedInError(`Refreshing the CodeBuddy session for ${entry.account.nickname} failed. Run \`dsh plugin --profile web codebuddy-power\` to sign in again through your browser.`);
+		const next = {
+			auth: {
+				accessToken: refreshed.accessToken,
+				expiresAt: Date.now() + refreshed.expiresIn * 1e3,
+				refreshToken: refreshed.refreshToken,
+				refreshExpiresAt: Date.now() + refreshed.refreshExpiresIn * 1e3,
+				domain: refreshed.domain
+			},
+			account: entry.account
+		};
+		await this.persist(next);
+		return this.identityOf(next);
+	}
+	/** 由身份构建每个已认证 CodeBuddy 请求都携带的请求头。 */
+	headersFrom(identity) {
+		const headers = {
+			"Authorization": `Bearer ${identity.accessToken}`,
+			"X-Domain": identity.domain,
+			"X-User-Id": identity.uid
+		};
+		if (identity.enterpriseId !== void 0) {
+			headers["X-Enterprise-Id"] = identity.enterpriseId;
+			headers["X-Tenant-Id"] = identity.enterpriseId;
+		}
+		if (identity.departmentFullName !== void 0) headers["X-Department-Info"] = identity.departmentFullName;
+		return headers;
+	}
+	/**
+	* 每个已认证 CodeBuddy 请求都携带的请求头,以及这些头属于哪个账号。
+	*
+	* 两者在**同一次**身份解析中一起给出:分开解析会有两次账号选择,而账号是每次请求
+	* 解析的(用户可在同一步里切换),两次解析可能落到不同账号上 —— 那样记进这一轮的
+	* 账号名就与实际发出去的请求不符。缩写由落盘侧按同一规则算出,故此处给出完整账号。
+	* @param sessionId - 请求所属的会话;决定用哪个账号,缺省时用默认账号。
+	* @returns 身份请求头与发起该请求的账号。
+	*/
+	async requestIdentity(sessionId) {
+		const entry = await this.require(sessionId);
+		return {
+			headers: this.headersFrom(await this.identityFor(entry)),
+			account: {
+				uid: entry.account.uid,
+				nickname: entry.account.nickname
+			}
+		};
+	}
+	/**
+	* 是否存在凭据,但不要求必须有。
+	* @returns 已存账号可读取且可用时为 true。
+	*/
+	async isLoggedIn() {
+		await this.refreshIfChanged();
+		return (this.storage?.accounts.length ?? 0) > 0;
+	}
+	/**
+	* 已存账号及其默认账号,供设置页与会话切换按钮展示。
+	* @returns 账号列表(顺序与磁盘一致)与默认账号 uid;未登录时列表为空。
+	*/
+	async accountList() {
+		await this.refreshIfChanged();
+		return {
+			accounts: (this.storage?.accounts ?? []).map(accountInfo),
+			...this.storage?.defaultUid === void 0 ? {} : { defaultUid: this.storage.defaultUid }
+		};
+	}
+	/**
+	* 某会话此刻生效的账号 uid。
+	* @param sessionId - dsh 会话身份;缺省时用默认账号。
+	* @returns 账号 uid;一个账号也没有时为 `undefined`。
+	*/
+	async activeUid(sessionId) {
+		await this.refreshIfChanged();
+		return this.accountUidFor(sessionId);
+	}
+	/**
+	* 把某会话的账号切换为指定账号,并把它记为最后一次手动切换的账号。
+	* @param sessionId - dsh 会话身份。
+	* @param uid - 要使用的账号 uid。
+	* @returns 该 uid 是已存账号时为 true;否则不做任何改动并返回 false。
+	*/
+	async activate(sessionId, uid) {
+		await this.refreshIfChanged();
+		if (this.accountEntry(uid) === void 0) return false;
+		const info = await this.infoOf(sessionId);
+		await updateSessionInfo(sessionId, (current) => ({
+			...current,
+			uid
+		}));
+		this.infos.set(sessionId, {
+			...info,
+			uid
+		});
+		await setLastAccount(uid);
+		return true;
+	}
+	/**
+	* CodeBuddy 模型目录,短暂缓存,并在并发读取者之间共享。
+	* @param signal - 底层读取的可选取消信号。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @returns 目录中的模型,按服务自身的顺序。
+	*/
+	async models(signal, sessionId) {
+		return (await this.catalogData(signal, sessionId)).models;
+	}
+	/**
+	* 目录及其推广与档位,在同一个 TTL 下按账号一起缓存,并按账号单飞,使列表与
+	* 面板富化共享同一次读取。
+	* @param signal - 底层读取的可选取消信号。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @returns 模型、推广与档位。
+	*/
+	async catalogData(signal, sessionId) {
+		await this.refreshIfChanged();
+		const uid = await this.accountUidFor(sessionId);
+		if (uid === void 0) throw new NotLoggedInError("CodeBuddy is not signed in. Run `dsh plugin --profile web codebuddy-power` to sign in through your browser; no API key is required.");
+		const cached = this.catalogs.get(uid);
+		if (cached !== void 0 && Date.now() - cached.readAt < CATALOG_TTL_MS) return cached;
+		let pending = this.catalogReads.get(uid);
+		if (pending === void 0) {
+			pending = this.readCatalog(uid, signal).finally(() => {
+				if (this.catalogReads.get(uid) === pending) this.catalogReads.delete(uid);
+			});
+			this.catalogReads.set(uid, pending);
+		}
+		return pending;
+	}
+	async readCatalog(uid, signal) {
+		const entry = this.accountEntry(uid);
+		if (entry === void 0) throw new NotLoggedInError(`The CodeBuddy account ${uid} is no longer stored.`);
+		const config = await getConfig(this.headersFrom(await this.identityFor(entry)), signal);
+		const models = config.models.filter((model) => typeof model.id === "string" && model.id.length > 0);
+		const catalog = {
+			models,
+			promotions: config.modelPromotions ?? [],
+			tiers: config.modelTiers
+		};
+		if (this.accountEntry(uid) === void 0) return catalog;
+		this.catalogs.set(uid, {
+			...catalog,
+			readAt: Date.now()
+		});
+		let grown = false;
+		for (const model of models) {
+			if (this.knownCatalog.has(model.id)) continue;
+			this.knownCatalog.set(model.id, model);
+			grown = true;
+		}
+		if (grown) this.onModelsChanged?.();
+		return catalog;
+	}
+	/**
+	* 从各账号已读到的目录的并集里查一个模型,**不发起任何请求**。
+	*
+	* 供拿不到会话身份的调用方使用(适配器的 `resolveModel`):它无法知道该用哪个
+	* 账号的目录,主动读取只能落在默认账号上,而当前会话用的可能正是另一个账号 ——
+	* 那会把一个账号独有的模型解析成保守的默认能力(上下文窗口、输出上限、图片输入
+	* 全部按最保守处理)。并集由带会话身份的读取填充,因此这个查询零成本、也不改变
+	* "谁在读目录"这件事。
+	* @param modelId - 模型 id。
+	* @returns 该模型;尚无任何账号读到过它时为 `undefined`。
+	*/
+	knownModel(modelId) {
+		return this.knownCatalog.get(modelId);
+	}
+	/**
+	* 各账号已读到的目录并集里的全部模型。
+	*
+	* 与 {@link knownModel} 同为只读查询:官方模型列表按它取数,因此它既包含默认
+	* 账号的模型(冷启动那一次读取必然先做),也包含其他账号在会话里读过之后并进来
+	* 的模型。顺序按各账号目录并入的先后,而非任何排序 —— 官方列表自行决定呈现顺序。
+	* @returns 并集里的模型。
+	*/
+	knownModels() {
+		return [...this.knownCatalog.values()];
+	}
+	/**
+	* 目录及其推广/档位;读不到时返回空值 —— 供面板使用的
+	* {@link catalogData} 建议性读取孪生体。
+	* @param signal - 可选取消信号。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @returns 目录与活动,或空列表。
+	*/
+	async catalogDataOrEmpty(signal, sessionId) {
+		try {
+			return await this.catalogData(signal, sessionId);
+		} catch (error) {
+			if (error instanceof NotLoggedInError) return {
+				models: [],
+				promotions: [],
+				tiers: void 0
+			};
+			this.logger?.warn("dsh-codebuddy: could not read the model catalog");
+			this.logger?.warn(error);
+			return {
+				models: [],
+				promotions: [],
+				tiers: void 0
+			};
+		}
+	}
+	/**
+	* 目录;读不到时返回空列表。
+	*
+	* 列出模型是设置页上的浏览动作,所以失败必须降级为“没有可显示的内容”,
+	* 而不是让页面崩掉。请求路径直接使用 {@link models} 并保留真实失败。
+	* @param signal - 可选取消信号。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @returns 目录,或空列表。
+	*/
+	async modelsOrEmpty(signal, sessionId) {
+		try {
+			return await this.models(signal, sessionId);
+		} catch (error) {
+			if (error instanceof NotLoggedInError) return [];
+			this.logger?.warn("dsh-codebuddy: could not read the model catalog");
+			this.logger?.warn(error);
+			return [];
+		}
+	}
+	/**
+	* CodeBuddy 用量/配额快照;读不到时为 `undefined`。
+	*
+	* 用量是界面上的建议性读取,所以计量故障必须降级为“没有可显示的
+	* 内容”而不是向外传播:{@link NotLoggedInError} 表现为未登录状态,
+	* 其他每种失败(传输、解析、刷新过期)都在一条警告之后解析为
+	* `undefined`。身份通过与聊天请求相同的按账号单飞刷新解析,所以并发的计量
+	* 读取绝不会消耗两次刷新 token。
+	* @param sessionId - 用哪个会话的账号;缺省时用默认账号。
+	* @param signal - 可选取消信号。
+	* @returns 该快照;未存有任何凭据或计量平面不可达时为 `undefined`。
+	*/
+	async usage(sessionId, signal) {
+		await this.refreshIfChanged();
+		const entry = this.accountEntry(await this.accountUidFor(sessionId));
+		if (entry === void 0) return void 0;
+		const uid = entry.account.uid;
+		const cached = this.usageCache.get(uid);
+		if (cached !== void 0 && Date.now() - cached.readAt < METER_TTL_MS) return cached.snapshot;
+		let identity;
+		try {
+			identity = await this.identityFor(entry);
+		} catch (error) {
+			if (error instanceof NotLoggedInError) return void 0;
+			this.logger?.warn("dsh-codebuddy: could not resolve identity for usage read");
+			this.logger?.warn(error);
+			return;
+		}
+		const snapshot = await fetchUsage(identity, signal);
+		if (snapshot !== void 0) {
+			this.usageCache.set(uid, {
+				snapshot,
+				readAt: Date.now()
+			});
+			return snapshot;
+		}
+		return cached?.snapshot;
+	}
+};
+/**
+* 把 SSE 字节流解析为 data 载荷。
+* @param stream - 原始 SSE 字节分块;读取可能在任何位置断开。
+* @param onComment - 传输活动回调;注释不会进入载荷流。
+* @returns 按到达顺序的各个载荷,`[DONE]` 在最后。
+* @throws LlmError 流在未出现 `[DONE]` 就结束时抛出 `STREAM_CLOSED`。
+*/
+async function* parseSse(stream, onComment) {
+	const events = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream(onComment === void 0 ? {} : { onComment }));
+	for await (const { data } of events) {
+		yield data;
+		if (data === "[DONE]") return;
+	}
+	throw new LlmError("CodeBuddy SSE stream ended without [DONE]", "STREAM_CLOSED");
+}
+//#endregion
+//#region lib/types/serialize.js
+/**
+* 把 harness 消息序列化为 CodeBuddy(OpenAI 兼容)chat 请求。
+*
+* 用户文本被拼接,助手文本成为 `content`,工具调用成为
+* `tool_calls`,每个工具结果成为其自身的 `role: 'tool'` 消息 →
+* harness 把工具结果放在用户消息内部,而这条 wire 路由
+* 不接受这种形式。对于支持图像的模型,图像以 OpenAI 兼容的
+* `image_url` 部件(`data:<type>;base64,...`)出现在用户或工具 content
+* 数组中,与官方 CLI 的发送方式完全一致。工具结果的图只对 `read_image`
+* 这类"看图"工具发送,生成图工具的结果仍走纯文本信封。
+*
+* @module dsh-llm-codebuddy-power/serialize
+*/
+/** 拼接一条消息中的文本块。 */
+function flattenText(blocks) {
+	return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+/** 在 wire 上承载一个请求图像的内联 base64 data URL。 */
+function imageDataUrl(version) {
+	return `data:${version.mediaType};base64,${Buffer.from(version.data).toString("base64")}`;
+}
+/**
+* 在任何文本扁平化可能静默丢弃图像内容之前先拒绝它。
+* @param blocks - 消息内容。
+* @param supportsImages - 所选模型是否声明支持图像输入。
+*/
+function assertSupportedContent(blocks, supportsImages) {
+	if (!supportsImages && contentHasImage(blocks)) throw new LlmError("The selected CodeBuddy model does not accept image content.", "UNSUPPORTED_CONTENT");
+}
+/**
+* 序列化一条用户消息中非工具结果的块。纯文本内容保持紧凑的
+* 字符串 wire 形式;含图像的内容变为 OpenAI 兼容的
+* 部件数组,并保持块顺序。
+* @param blocks - 消息中非工具结果的块。
+* @param images - 请求中每个图像已解析的请求版本。
+* @returns 用户角色的 wire 内容。
+*/
+function userContent(blocks, images) {
+	if (!contentHasImage(blocks)) return flattenText(blocks);
+	const parts = [];
+	let text = "";
+	const flush = () => {
+		if (text.length === 0) return;
+		parts.push({
+			type: "text",
+			text
+		});
+		text = "";
+	};
+	for (const block of blocks) {
+		if (block.type === "text") {
+			text += block.text;
+			continue;
+		}
+		if (block.type !== "image") continue;
+		const version = images.get(block.attachment.attachmentId);
+		if (version === void 0) throw new LlmError(`CodeBuddy request image ${block.attachment.attachmentId} was not prepared.`, "INVALID_REQUEST");
+		flush();
+		parts.push({
+			type: "image_url",
+			image_url: { url: imageDataUrl(version) }
+		});
+	}
+	flush();
+	return parts;
+}
+/** 序列化一个助手轮次:文本、重放的 reasoning 与工具调用。 */
+function serializeAssistant(message) {
+	const text = flattenText(message.content);
+	const reasoning = message.content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
+	const toolCalls = message.content.filter((block) => block.type === "tool-call").map((block) => ({
+		id: block.id,
+		type: "function",
+		function: {
+			name: block.name,
+			arguments: block.arguments
+		}
+	}));
+	return {
+		role: "assistant",
+		content: text,
+		...toolCalls.length > 0 && reasoning.length > 0 ? { reasoning_content: reasoning } : {},
+		...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+	};
+}
+/**
+* 按顺序序列化整个对话。
+* @param messages - harness 会话。
+* @param supportsImages - 所选模型是否声明支持图像输入。
+* @param images - 请求中每个图像已解析的请求版本。
+* @returns wire 消息,每个工具结果展开为独立条目。
+*/
+function serializeMessages(messages, supportsImages, images = /* @__PURE__ */ new Map()) {
+	const wire = [];
+	const toolNames = collectToolNames(messages);
+	for (const message of messages) {
+		assertSupportedContent(message.content, supportsImages);
+		if (message.role === "system") {
+			wire.push({
+				role: "system",
+				content: flattenText(message.content)
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			wire.push(serializeAssistant(message));
+			continue;
+		}
+		const toolResults = message.content.filter((block) => block.type === "tool-result");
+		const content = userContent(message.content.filter((block) => block.type !== "tool-result"), images);
+		if (content.length > 0 || toolResults.length === 0) wire.push({
+			role: "user",
+			content
+		});
+		for (const result of toolResults) {
+			const text = flattenText(result.content);
+			const imageBlocks = result.content.filter((block) => block.type === "image");
+			if (!(supportsImages && imageBlocks.length > 0 && toolNames.get(result.toolCallId) === READ_IMAGE_TOOL)) {
+				wire.push({
+					role: "tool",
+					tool_call_id: result.toolCallId,
+					content: text.length === 0 ? "(no output)" : text
+				});
+				continue;
+			}
+			const parts = [];
+			if (text.length > 0) parts.push({
+				type: "text",
+				text
+			});
+			for (const block of imageBlocks) {
+				const version = images.get(block.attachment.attachmentId);
+				if (version === void 0) throw new LlmError(`CodeBuddy request image ${block.attachment.attachmentId} was not prepared.`, "INVALID_REQUEST");
+				parts.push({
+					type: "image_url",
+					image_url: { url: imageDataUrl(version) }
+				});
+			}
+			wire.push({
+				role: "tool",
+				tool_call_id: result.toolCallId,
+				content: parts
+			});
+		}
+	}
+	return wire;
+}
+/** 产出需要模型看到的图的那个工具:`read_image`。 */
+const READ_IMAGE_TOOL = "read_image";
+/**
+* 建立 toolCallId → 工具名 的索引。
+*
+* tool 结果自身只带 `toolCallId`,而"这张图该不该发给模型"取决于产出它的工具,
+* 因此需要回到助手轮次的 tool-call 块里查名字。
+* @param messages - harness 会话。
+* @returns 每个工具调用 id 对应的工具名。
+*/
+function collectToolNames(messages) {
+	const names = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const block of message.content) if (block.type === "tool-call") names.set(block.id, block.name);
+	}
+	return names;
+}
+/**
+* 构建 chat-completions 请求体。始终流式并上报 usage;
+* 缺省的选项被省略而非以 null 发送,以便应用
+* 提供方自身的默认值。
+* @param options - 组装好的 harness 请求。
+* @param supportsImages - 所选模型是否声明支持图像输入。
+* @param images - 请求中每个图像已解析的请求版本。
+* @returns 请求体。
+*/
+function serializeRequest(options, supportsImages, images = /* @__PURE__ */ new Map()) {
+	const messages = [];
+	if (options.system !== void 0) messages.push({
+		role: "system",
+		content: options.system
+	});
+	messages.push(...serializeMessages(options.messages, supportsImages, images));
+	const tools = options.tools?.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}
+	}));
+	return {
+		model: options.model,
+		messages,
+		stream: true,
+		stream_options: { include_usage: true },
+		...tools !== void 0 && tools.length > 0 ? { tools } : {},
+		...options.temperature === void 0 ? {} : { temperature: options.temperature },
+		...options.maxTokens === void 0 ? {} : { max_tokens: options.maxTokens },
+		...options.stop === void 0 ? {} : { stop: options.stop },
+		...options.reasoningEffort === void 0 ? {} : { reasoning_effort: options.reasoningEffort }
+	};
+}
+//#endregion
+//#region lib/types/translate.js
+/**
+* 把 CodeBuddy SSE 负载转换成 harness 的 `StreamChunk` 协议。
+*
+* 文本、推理和工具调用索引各持有一个打开的块,索引按首次出现的顺序分配。
+* `block-end`、`usage` 和 `finish` 全部推迟到 `[DONE]` 哨兵:正是这一点满足了
+* 协议的两项硬性义务——usage 严格早于 finish,且 finish 之后没有任何内容
+* ——对发送尾部 usage-only 块的 provider 也是如此。
+*
+* @module dsh-llm-codebuddy-power/translate
+*/
+/** 返回属性 schema 是否刻意接受任意 JSON 值。 */
+function acceptsAnyJsonValue(schema) {
+	if (schema === true) return true;
+	if (schema === null || typeof schema !== "object" || Array.isArray(schema)) return false;
+	const record = schema;
+	return !("type" in record) && !("$ref" in record) && !("const" in record) && !("enum" in record) && !("allOf" in record) && !("anyOf" in record) && !("oneOf" in record) && !("not" in record);
+}
+/** 解码 CodeBuddy 以 JSON 字符串形式发出的单个 object/array 值。 */
+function decodeNestedComposite(value) {
+	if (typeof value !== "string") return value;
+	const text = value.trim();
+	if (!(text.startsWith("{") && text.endsWith("}")) && !(text.startsWith("[") && text.endsWith("]"))) return value;
+	try {
+		const decoded = JSON.parse(text);
+		return decoded !== null && typeof decoded === "object" ? decoded : value;
+	} catch {
+		return value;
+	}
+}
+/**
+* 修复 CodeBuddy 对未受约束 Tool 字段偶发的双重编码。
+*
+* 没有 `type` 的属性 schema 是合法 JSON Schema,表示其值可以是任意 JSON
+* 类型。CodeBuddy 仍可能把为这种字段选定的 object 或 array 渲染成 JSON
+* 字符串。只解码这一种形态;有类型和其他约束的字段、标量字符串以及格式
+* 错误的 JSON 一律逐字节保持原样。
+*/
+function normalizeToolArguments(name, argumentsText, tools) {
+	const properties = tools.find((candidate) => candidate.name === name)?.parameters?.properties;
+	if (properties === void 0) return argumentsText;
+	let args;
+	try {
+		args = JSON.parse(argumentsText);
+	} catch {
+		return argumentsText;
+	}
+	if (args === null || typeof args !== "object" || Array.isArray(args)) return argumentsText;
+	const record = args;
+	let changed = false;
+	for (const [key, schema] of Object.entries(properties)) {
+		if (!acceptsAnyJsonValue(schema) || !(key in record)) continue;
+		const decoded = decodeNestedComposite(record[key]);
+		if (decoded !== record[key]) {
+			record[key] = decoded;
+			changed = true;
+		}
+	}
+	return changed ? JSON.stringify(record) : argumentsText;
+}
+/**
+* 把 wire 的 `finish_reason` 取值映射到 harness 的取值。
+* @param reason - wire 的取值。
+* @returns 映射后的原因;任何无法识别的值都会变成 error finish,并以大写后的
+*   wire 取值作为其 code,这样新出现的 provider 原因会以自身形式暴露,而不是
+*   被静默报告为正常停止。
+*/
+function mapFinishReason(reason) {
+	switch (reason) {
+		case "stop": return { kind: "stop" };
+		case "tool_calls": return { kind: "tool-calls" };
+		case "length": return { kind: "max-tokens" };
+		default: return {
+			kind: "error",
+			failure: {
+				message: `model stopped: ${reason}`,
+				code: reason.toUpperCase()
+			}
+		};
+	}
+}
+/**
+* 把 wire 的 usage 映射到 harness 的互斥计数。
+*
+* CodeBuddy 的 `prompt_tokens` 是 OpenAI 兼容语义,含缓存命中
+* (`prompt_tokens = 缓存命中 + 未缓存输入`);harness 的 TokenUsage 约定是
+* 互斥计数,所以缓存命中从 `inputTokens` 里减掉。`totalTokens` 用 wire 的
+* 原始 prompt+completion 之和(与官方 DeepSeek adapter 一致),仅当
+* prompt/completion 都是合法计数时才给出。
+* @param usage - wire 的 usage 块。
+* @returns 互斥 token 计数;合法时含完整的聚合总数。
+*/
+function mapUsage(usage) {
+	const cacheRead = usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens;
+	const reasoning = usage.completion_tokens_details?.reasoning_tokens;
+	const prompt = usage.prompt_tokens ?? 0;
+	const completion = usage.completion_tokens ?? 0;
+	const combined = prompt + completion;
+	const hasExactTotal = Number.isSafeInteger(prompt) && prompt >= 0 && Number.isSafeInteger(completion) && completion >= 0 && Number.isSafeInteger(combined);
+	return {
+		inputTokens: Math.max(0, prompt - (cacheRead ?? 0)),
+		outputTokens: completion,
+		...hasExactTotal ? { totalTokens: combined } : {},
+		...cacheRead === void 0 ? {} : { cacheReadTokens: cacheRead },
+		...reasoning === void 0 ? {} : { reasoningTokens: reasoning }
+	};
+}
+/** 为一个打开的块组装最终的内容块。 */
+function closeBlock(block, tools) {
+	switch (block.kind) {
+		case "text": return {
+			type: "text",
+			text: block.text
+		};
+		case "reasoning": return {
+			type: "reasoning",
+			text: block.text
+		};
+		case "tool-call": return {
+			type: "tool-call",
+			id: ToolCallId(block.callId ?? ""),
+			name: block.name ?? "",
+			arguments: normalizeToolArguments(block.name ?? "", block.text, tools)
+		};
+	}
+}
+/**
+* 消费以 `[DONE]` 结尾的 SSE 负载并产出 harness 块。
+* @param payloads - 来自 `parseSse` 的负载。
+* @param tools - 用于修复 CodeBuddy wire 参数的原始 Tool schema。
+* @param sink - 可选出参,调用方通过它观察不随 harness 块协议传递的附带数据
+*   (例如服务扣减的 credits)。
+* @returns 到达时即产出的增量,块结束、usage 和 finish 在 `[DONE]` 时刷出。
+* @throws LlmError 在 JSON 无法解析时抛 `MALFORMED_RESPONSE`,在负载源未出现
+*   哨兵就结束时抛 `STREAM_CLOSED`。
+*/
+async function* translate(payloads, tools = [], sink) {
+	let nextIndex = 0;
+	let textBlock;
+	let reasoningBlock;
+	const toolBlocks = /* @__PURE__ */ new Map();
+	const order = [];
+	let pendingFinish;
+	let pendingUsage;
+	const open = (kind) => {
+		const block = {
+			index: nextIndex++,
+			kind,
+			text: ""
+		};
+		order.push(block);
+		return block;
+	};
+	for await (const payload of payloads) {
+		if (payload === "[DONE]") {
+			for (const block of order) yield {
+				type: "block-end",
+				index: block.index,
+				block: closeBlock(block, tools)
+			};
+			if (pendingUsage !== void 0) yield {
+				type: "usage",
+				usage: pendingUsage
+			};
+			const reason = pendingFinish ?? { kind: "stop" };
+			yield {
+				type: "finish",
+				reason: reason.kind === "stop" && order.length === 0 ? {
+					kind: "error",
+					failure: {
+						message: "model returned a completed response with no content",
+						code: EMPTY_RESPONSE_CODE
+					}
+				} : reason
+			};
+			return;
+		}
+		let chunk;
+		try {
+			chunk = JSON.parse(payload);
+		} catch {
+			throw new LlmError(`malformed CodeBuddy SSE payload: ${payload.slice(0, 120)}`, "MALFORMED_RESPONSE");
+		}
+		for (const choice of chunk.choices ?? []) {
+			const delta = choice.delta;
+			const reasoning = delta?.reasoning_content ?? delta?.reasoning;
+			if (typeof reasoning === "string" && reasoning.length > 0) {
+				if (reasoningBlock === void 0) {
+					reasoningBlock = open("reasoning");
+					yield {
+						type: "block-start",
+						index: reasoningBlock.index,
+						blockType: "reasoning"
+					};
+				}
+				reasoningBlock.text += reasoning;
+				yield {
+					type: "reasoning-delta",
+					index: reasoningBlock.index,
+					text: reasoning
+				};
+			}
+			const content = delta?.content;
+			if (typeof content === "string" && content.length > 0) {
+				if (textBlock === void 0) {
+					textBlock = open("text");
+					yield {
+						type: "block-start",
+						index: textBlock.index,
+						blockType: "text"
+					};
+				}
+				textBlock.text += content;
+				yield {
+					type: "text-delta",
+					index: textBlock.index,
+					text: content
+				};
+			}
+			for (const call of delta?.tool_calls ?? []) {
+				let block = toolBlocks.get(call.index);
+				if (block === void 0) {
+					block = open("tool-call");
+					toolBlocks.set(call.index, block);
+					yield {
+						type: "block-start",
+						index: block.index,
+						blockType: "tool-call"
+					};
+				}
+				if (call.id !== void 0 && call.id.length > 0) block.callId = call.id;
+				const name = call.function?.name;
+				if (name !== void 0 && name.length > 0) block.name = name;
+				const fragment = call.function?.arguments ?? "";
+				block.text += fragment;
+				yield {
+					type: "tool-call-delta",
+					index: block.index,
+					id: ToolCallId(block.callId ?? ""),
+					...block.name === void 0 ? {} : { name: block.name },
+					argumentsDelta: fragment
+				};
+			}
+			if (typeof choice.finish_reason === "string") pendingFinish = mapFinishReason(choice.finish_reason);
+		}
+		if (chunk.usage !== void 0 && chunk.usage !== null) {
+			pendingUsage = mapUsage(chunk.usage);
+			if (sink !== void 0 && chunk.usage.credit !== void 0) sink.credit = chunk.usage.credit;
+		}
+	}
+	throw new LlmError("CodeBuddy SSE payload stream ended without [DONE]", "STREAM_CLOSED");
+}
+//#endregion
+//#region lib/types/types.js
+/**
+* 本插件读取的 wire 结构,分属两套互不相关的协议。
+*
+* CodeBuddy 控制平面(`/v2/plugin/auth/*`、`/v3/config`)把每个回复包在
+* `{code, msg, requestId, data}` 中,且不兼容 OpenAI——这正是本插件存在、
+* 而不使用普通 OpenAI 兼容路由的原因。对话平面(`/v2/chat/completions`)
+* 兼容 OpenAI,其 chunk 结构即常见结构。
+*
+* @module dsh-llm-codebuddy-power/types
+*/
+/**
+* 目录是否披露了 harness 所需的容量。
+*
+* harness 要求它提供的每个模型都有正的 `contextWindow` 与输出上限,而
+* CodeBuddy 对非对话模型的条目(补全、改写/跳转、图片生成)两者都不给。
+* 为这些条目编造数字会把不可用的模型以猜测的尺寸放进选择器,因此调用方
+* 改为丢弃它们。放在这里、紧邻 wire 类型,使列表与解析路径不会对哪些条目
+* 可提供产生分歧。
+* @param model - 一个目录条目。
+* @returns 两个容量都存在且为正时返回 true。
+*/
+function hasDisclosedCapacity(model) {
+	return model.maxAllowedSize !== void 0 && model.maxAllowedSize > 0 && model.maxOutputTokens !== void 0 && model.maxOutputTokens > 0;
+}
+/**
+* 插件有意不提供的模型 id,即使目录把它们描述为完全支持对话。
+*
+* CodeBuddy 的目录会列出并非真实模型的默认/别名条目:它们的请求在用量记录
+* 中会落成另一个模型(`default` 别名解析为 `deepseek-v4-flash`),而选择器
+* 会把它显示为独立选项,因此提供它们会误导用户。被屏蔽的 id 只在列表中
+* 滤除;显式指名的 id 仍会走通(服务以 "The requested model is not
+* available" 拒绝),与选择器隐藏服务无法提供选项的做法一致。
+*/
+const BLOCKED_MODEL_IDS = new Set(["default", "codewise-default-model-v2"]);
+/**
+* 某个目录条目 id 是否在屏蔽列表中。
+* @param id - 目录条目 id。
+* @returns 插件不得提供该模型时返回 true。
+*/
+function isBlockedModelId(id) {
+	return BLOCKED_MODEL_IDS.has(id);
+}
+//#endregion
+//#region lib/types/adapter.js
+/**
+* `CodeBuddyAdapter`:针对 CodeBuddy 的 OpenAI 兼容聊天路由使用 fetch + SSE,
+* 身份与模型目录则从 OAuth 会话解析。
+*
+* 这一区分很重要:聊天面兼容 OpenAI,而目录面并不兼容,因此模型信息取自 CodeBuddy
+* 自己的 `/v3/config` 响应——每个模型的工具调用、推理、图像与尺寸事实都出自那里。
+* 本类中不存在任何 API key;每个请求都由会话刷新的、浏览器签发的 bearer token 授权。
+*
+* @module dsh-llm-codebuddy-power/adapter
+*/
+/** 在 `retry-after` 响应头携带可用延迟时,把它解析为毫秒。 */
+function providerRetryAfterMs(value) {
+	if (value === null) return void 0;
+	if (/^\d+$/.test(value)) {
+		const delay = Number(value) * 1e3;
+		return Number.isFinite(delay) && delay > 0 ? delay : void 0;
+	}
+	const delay = Date.parse(value) - Date.now();
+	return Number.isFinite(delay) && delay > 0 ? delay : void 0;
+}
+function requestId(headers) {
+	const value = headers.get("x-request-id") ?? headers.get("x-requestid");
+	return value === null || value.length === 0 ? void 0 : ProviderRequestId(value);
+}
+/** 收集单条消息内容中的全部图像引用,包括工具结果内的引用。 */
+function collectImageRefs(content, refs) {
+	for (const block of content) if (block.type === "image") refs.set(block.attachment.attachmentId, block.attachment);
+	else if (block.type === "tool-result") collectImageRefs(block.content, refs);
+}
+/**
+* 把"长边不超过 longEdge"折算为该图的总像素预算。
+*
+* 请求投影只接受总像素上限(`ImageRequestPolicy.maxPixels`),没有长边字段,
+* 而总像素无法约束长边:8000×460 仅 368 万像素,长边却达 8000。投影按
+* `sqrt(maxPixels / (width * height))` 等比缩放,因此令
+* `maxPixels = longEdge² × (短边 / 长边)` 时缩放系数恰为 `longEdge / 长边`,
+* 结果正好把长边压到该档。
+*
+* 长边本就在档内时返回原图总像素。这**不是**防放大所必需的:投影自身以
+* `min(1, …)` 截断缩放系数,且长边 ≤ longEdge 时恒有
+* `longEdge² × (短边/长边) ≥ 原面积`,故照公式给值也不会被放大。返回原图
+* 面积的作用是让**预算值在各档之间重复**,从而被逐档重试的去重跳过,避免
+* 对同一尺寸重复编码。
+*
+* 宽高由会话格式的载荷校验强制为正整数(`payload-validation.ts` 的
+* `imageAttachmentValue`),故此处不做防御检查。
+* @param width - 原图宽度(像素)。
+* @param height - 原图高度(像素)。
+* @param longEdge - 本档的长边上限(像素)。
+* @returns 该图在该档下的 `maxPixels` 取值,恒为正整数。
+*/
+function pixelBudgetForLongEdge(width, height, longEdge) {
+	const source = Math.max(width, height);
+	if (source <= longEdge) return width * height;
+	const scale = longEdge / source;
+	return Math.max(1, Math.round(width * scale)) * Math.max(1, Math.round(height * scale));
+}
+/**
+* 解析一张图的请求版本:源图未超字节目标时原样复用,超过时才逐档收紧长边。
+*
+* 未超目标的一支不做任何转换:`maxPixels` 取原图总像素,投影因此不缩放,附件
+* 服务命中其直通分支返回原始字节,既不重编码也不写请求缓存 —— 降到 1920 会
+* 白白丢掉分辨率与画质,而模型侧的约束只有字节目标。
+*
+* 超过目标的一支才逐档收紧长边。附件服务的编码阶梯只降质量、不降尺寸,单靠
+* 一档无法保证落到字节目标,故需要换更小的长边重来;预算相同的档位会被跳过。
+* @param ref - 持久化附件引用。
+* @param attachments - 已挂载的附件服务。
+* @param signal - 本次生成的取消信号。
+* @returns 首个达标(或最小)的请求版本。
+*/
+async function requestImageVersion(ref, attachments, signal) {
+	const maxBytes = REQUEST_IMAGE_MAX_BYTES;
+	if (ref.bytes <= maxBytes) return attachments.readImageRequest(ref, {
+		maxPixels: ref.width * ref.height,
+		maxBytes
+	}, signal);
+	const tried = /* @__PURE__ */ new Set();
+	let smallest;
+	for (const longEdge of REQUEST_IMAGE_DIMENSION_LADDER) {
+		const maxPixels = pixelBudgetForLongEdge(ref.width, ref.height, longEdge);
+		if (tried.has(maxPixels)) continue;
+		tried.add(maxPixels);
+		const version = await attachments.readImageRequest(ref, {
+			maxPixels,
+			maxBytes
+		}, signal);
+		if (version.bytes <= maxBytes) return version;
+		if (smallest === void 0 || version.bytes < smallest.bytes) smallest = version;
+	}
+	return smallest;
+}
+/**
+* 在所选模型接受图像输入时,解析会话所携带每张图像的请求版本。持久化 harness 以引用
+* 方式附加;请求字节由附件服务按逐图的像素与字节预算派生,与官方 DeepSeek 适配器
+* 的准备方式一致。
+* @param messages - 等待序列化的 harness 消息。
+* @param attachments - 持久化附件服务;未挂载时为 undefined。
+* @param signal - 本次生成的取消信号。
+* @returns 以附件 id 为键的请求版本;会话不携带图像时为空 Map。
+*/
+async function prepareRequestImages(messages, attachments, signal) {
+	const refs = /* @__PURE__ */ new Map();
+	for (const message of messages) collectImageRefs(message.content, refs);
+	if (refs.size === 0) return /* @__PURE__ */ new Map();
+	if (attachments === void 0) throw new LlmError("CodeBuddy image input requires the durable attachment service.", "UNSUPPORTED_CONTENT");
+	const ordered = [...refs.values()];
+	const versions = await Promise.all(ordered.map((ref) => requestImageVersion(ref, attachments, signal)));
+	return new Map(ordered.map((ref, index) => [ref.attachmentId, versions[index]]));
+}
+/**
+* 把 HTTP 状态码映射为稳定的 harness 错误码。
+* @param status - 非 2xx 的状态码。
+* @param error - 可读取时,已解析的 provider 错误体。
+* @returns 归一化后的错误码。
+*/
+function httpErrorCode(status, error) {
+	if (status === 401 || status === 403) return "AUTH";
+	const detail = [
+		error?.code,
+		error?.type,
+		error?.message
+	].filter(Boolean).join(" ");
+	if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE;
+	if (status === 429) return "RATE_LIMIT";
+	if (status === 400) {
+		if (isContextWindowExceededError(detail)) return CONTEXT_WINDOW_EXCEEDED_CODE;
+		return "INVALID_REQUEST";
+	}
+	if (status >= 500) return "SERVER";
+	return `HTTP_${status}`;
+}
+/**
+* 把目录中的模型投影为 harness 的 model-info 结构。
+*
+* 名称保持目录中的原始名称——不带 👀 标记或积分倍率:那些属于插件自己的模型面板,
+* 而不是官方选择器。
+*/
+function modelInfo(provider, model) {
+	return {
+		provider,
+		id: model.id,
+		name: model.name,
+		inputModalities: model.supportsImages === true ? ["text", "image"] : ["text"]
+	};
+}
+/** CodeBuddy effort 词表中各取值的可读名称。 */
+const EFFORT_NAMES = {
+	low: "Low",
+	medium: "Medium",
+	high: "High",
+	xhigh: "Extra high",
+	max: "Max"
+};
+/**
+* 把 CodeBuddy 公开的思考等级转换为 harness 的推理元数据;目录未给出任何可选值时
+* 返回 `undefined`。
+*
+* 这些等级作为不透明 id 原样传递,而不映射到固定刻度:它们正是聊天 endpoint 接受的
+* `reasoning_effort` 取值,因此 CodeBuddy 之后新增的等级无需在此改动代码。无法识别的
+* id 仍会依据自身拼写得到可读名称。
+*
+* 以下三种情况返回 `undefined` 而不是部分值,因为 harness 会把它们一律判为
+* INVALID_MODEL_REASONING,而被拒绝的目录比缺失的能力更糟:
+*   - 完全没有 reasoning 块;
+*   - 有 reasoning 块但没有 `supportedEfforts`(`auto` 会声明一个生效的 `effort`
+*     却没有列表,用户无从选择);
+*   - 列表为空,或去重后为空。
+*/
+function reasoningInfo(model) {
+	const supported = model.reasoning?.supportedEfforts;
+	if (supported === void 0) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const efforts = [];
+	for (const raw of supported) {
+		const id = typeof raw === "string" ? raw.trim() : "";
+		if (id.length === 0 || seen.has(id)) continue;
+		seen.add(id);
+		efforts.push({
+			id: ReasoningEffortId(id),
+			name: EFFORT_NAMES[id] ?? id
+		});
+	}
+	if (efforts.length === 0) return void 0;
+	const candidate = model.reasoning?.defaultEffort ?? model.reasoning?.effort;
+	const defaultEffort = candidate !== void 0 && seen.has(candidate) ? ReasoningEffortId(candidate) : void 0;
+	return {
+		efforts,
+		...defaultEffort === void 0 ? {} : { defaultEffort }
+	};
+}
+/**
+* CodeBuddy 适配器。单个实例服务于唯一的 `codebuddy` 路由,
+* 以及该路由目录报告的全部模型。
+*/
+var CodeBuddyAdapter = class extends LlmAdapter {
+	config;
+	constructor(config) {
+		super();
+		this.config = config;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: CODEBUDDY_DISPLAY_NAME
+		};
+	}
+	async listModels(provider) {
+		await this.config.session.modelsOrEmpty();
+		return this.config.session.knownModels().filter((model) => hasDisclosedCapacity(model) && !isBlockedModelId(model.id)).map((model) => modelInfo(provider, model));
+	}
+	async resolveModel(provider, model, signal) {
+		const connection = this.config.options();
+		const overrides = this.config.resolveOverrides === void 0 ? void 0 : await this.config.resolveOverrides(model);
+		const entry = this.config.session.knownModel(model) ?? (await this.config.session.modelsOrEmpty(signal)).find((candidate) => candidate.id === model);
+		if (entry === void 0) return {
+			provider,
+			id: model,
+			name: model,
+			inputModalities: ["text"],
+			context: { contextWindow: overrides?.contextWindow ?? connection.defaultContextWindow },
+			defaultMaxTokens: overrides?.maxOutputTokens ?? connection.defaultMaxTokens
+		};
+		const reasoning = reasoningInfo(entry);
+		return {
+			...modelInfo(provider, entry),
+			context: { contextWindow: overrides?.contextWindow ?? (entry.maxAllowedSize !== void 0 && entry.maxAllowedSize > 0 ? entry.maxAllowedSize : connection.defaultContextWindow) },
+			defaultMaxTokens: overrides?.maxOutputTokens ?? (entry.maxOutputTokens !== void 0 && entry.maxOutputTokens > 0 ? entry.maxOutputTokens : connection.defaultMaxTokens),
+			...reasoning === void 0 ? {} : { reasoning }
+		};
+	}
+	async *stream(options) {
+		const connection = this.config.options();
+		const sessionId = options.sessionId === void 0 ? void 0 : String(options.sessionId);
+		let identity;
+		try {
+			identity = await this.config.session.requestIdentity(sessionId);
+		} catch (error) {
+			if (error instanceof NotLoggedInError) throw new LlmError(error.message, "MISSING_CREDENTIAL", { cause: error });
+			throw error;
+		}
+		const entry = (await this.config.session.modelsOrEmpty(options.signal, sessionId)).find((candidate) => candidate.id === options.model);
+		const supportsImages = entry?.supportsImages === true;
+		if (options.tools !== void 0 && options.tools.length > 0 && entry?.supportsToolCall === false) throw new LlmError(`CodeBuddy model "${options.model}" does not support tool calls`, "UNSUPPORTED_OPTION");
+		const body = serializeRequest(options, supportsImages, supportsImages ? await prepareRequestImages(options.messages, this.config.resolveAttachments(), options.signal) : /* @__PURE__ */ new Map());
+		const payload = gzipSync(Buffer.from(JSON.stringify(body), "utf8"));
+		const messageId = compactUuid();
+		const conversationId = options.sessionId === void 0 ? compactUuid() : this.config.session.conversationIdOf(String(options.sessionId));
+		const conversationRequestId = options.sessionId === void 0 ? compactUuid() : this.config.session.turnRequestIdOf(String(options.sessionId)) ?? compactUuid();
+		let response;
+		try {
+			const requestTrace = traceHeaders();
+			const monitorPrepare = String(Date.now());
+			const requestHeaders = {
+				...identity.headers,
+				...clientIdentityHeaders(),
+				"X-Request-ID": conversationRequestId,
+				"content-type": "application/json;charset=UTF-8",
+				"content-encoding": "gzip",
+				"accept": "*/*",
+				"accept-language": "*",
+				"User-Agent": ideUserAgent(),
+				"X-Agent-Intent": "craft",
+				"X-Conversation-ID": conversationId,
+				"X-Conversation-Request-ID": conversationRequestId,
+				"X-Conversation-Message-ID": messageId,
+				"X-Env-ID": "production",
+				"X-IDE-Type": "CodeBuddyIDE",
+				"X-IDE-Name": "CodeBuddyIDE",
+				"X-IDE-Version": CODEBUDDY_IDE_VERSION,
+				"X-Product-Version": CODEBUDDY_IDE_VERSION,
+				"X-Model-ID": options.model,
+				"X-Requested-With": "XMLHttpRequest",
+				...requestTrace,
+				"monitor_promptpreparestarttime": monitorPrepare,
+				"monitor_httpsendtime": String(Date.now())
+			};
+			response = await fetch(`${connection.baseURL}/chat/completions`, {
+				method: "POST",
+				headers: requestHeaders,
+				body: payload,
+				...options.signal === void 0 ? {} : { signal: options.signal }
+			});
+		} catch (error) {
+			if (options.signal?.aborted) throw new LlmError("CodeBuddy request aborted by caller", "ABORTED", { cause: error });
+			throw new LlmError(`CodeBuddy request to ${connection.baseURL} failed`, "TRANSPORT", { cause: error });
+		}
+		if (!response.ok) {
+			let message = `CodeBuddy API error (HTTP ${response.status})`;
+			let providerError;
+			try {
+				const parsed = await response.json();
+				providerError = parsed.error;
+				if (providerError?.message !== void 0 && providerError.message.length > 0) message = providerError.message;
+				else if (parsed.msg !== void 0 && parsed.msg.length > 0) message = `${parsed.displayMsg?.en ?? parsed.msg} (HTTP ${response.status})`;
+			} catch {}
+			if (response.status === 401 || response.status === 403) this.config.session.invalidate();
+			const delay = providerRetryAfterMs(response.headers.get("retry-after"));
+			const id = requestId(response.headers);
+			throw new LlmError(message, httpErrorCode(response.status, providerError), {
+				status: response.status,
+				...delay === void 0 ? {} : { providerRetryAfterMs: delay },
+				...id === void 0 ? {} : { requestId: id }
+			});
+		}
+		if (response.body === null) throw new LlmError("CodeBuddy API returned no response body", "EMPTY_RESPONSE");
+		const creditSink = {};
+		try {
+			yield* translate(parseSse(response.body), options.tools, creditSink);
+		} finally {
+			if (creditSink.credit !== void 0 && options.sessionId !== void 0) this.config.session.recordCredit(String(options.sessionId), creditSink.credit, identity.account);
+		}
+	}
+};
+//#endregion
+//#region lib/types/image-tool.js
+/**
+* codebuddy-draw 工具:调用 CodeBuddy 文生图模型生成图片,通过标准附件服务
+* 持久化,并在对话中内联展示。
+*
+* 与官方 IDE 的 image_gen 工具一致:聊天模型用提示词调用它,请求携带全套 IDE
+* 身份头(后台计费按 IDE 客户端与会话请求 id 记录)。生成的字节走
+* attachments.saveImage 提交到标准附件仓库(content-addressed、归一化、
+* 回放安全),轨迹/详情按标准 ImageBlock 渲染;对话卡片由浏览器半的
+* DrawToolCard 经 uiConversation.imageUrl 标准附件通道读取展示。
+*
+* @module dsh-llm-codebuddy-power/image-tool
+*/
+/** 工具名;注册前检查唯一性。 */
+const CODEBUDDY_DRAW_TOOL = "codebuddy-draw";
+/** 文生图模型 id(后台计费记录为会话模型)。 */
+const TEXT_TO_IMAGE_MODEL = "hunyuan-image-alpha";
+/** 图片下方标注实际扣分的文本;也告诉模型图已显示在对话里,无需复述或重试。 */
+function formatDrawEnvelope(value) {
+	return `Generated ${value.images.length} image${value.images.length === 1 ? "" : "s"} and displayed ${value.images.length === 1 ? "it" : "them"} in the conversation; ${value.usedCredits} CodeBuddy credits spent (x5.00 billing multiplier). You do not need to describe the image content; just confirm to the user that it was generated.`;
+}
+/**
+* 注册 codebuddy-draw 工具。
+* @param ctx - 注册作用域;执行时使用 session 与 attachments。
+* @param session - 已登录的 CodeBuddy 会话(身份头 + 会话 id)。
+* @param attachments - 图片持久化所用的标准附件仓库。
+*/
+function applyImageTool(ctx, session, attachments) {
+	if (ctx.tools.get("codebuddy-draw") !== void 0) throw new Error(`tool "${CODEBUDDY_DRAW_TOOL}" is already registered; refusing to shadow it`);
+	ctx.tools.register(defineTool({
+		name: CODEBUDDY_DRAW_TOOL,
+		description: "Generate an image from a text prompt using CodeBuddy's text-to-image model (Hunyuan Image Alpha). Use when the user asks to generate, create, or draw an image; the generated image renders inline in the chat. Provide a detailed prompt describing the desired image.",
+		parameters: {
+			prompt: {
+				type: "string",
+				required: true,
+				description: "Text description of the image to generate."
+			},
+			size: {
+				type: "string",
+				enum: [
+					"1024x1024",
+					"1024x1536",
+					"1536x1024"
+				],
+				description: "Output size; defaults to 1024x1024."
+			},
+			quality: {
+				type: "string",
+				enum: [
+					"low",
+					"medium",
+					"high"
+				],
+				description: "Quality hint."
+			},
+			style: {
+				type: "string",
+				description: "Style hint, passed through to the model."
+			},
+			n: {
+				type: "integer",
+				description: "Number of images; defaults to 1."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					prompt: {
+						type: "string",
+						required: true
+					},
+					usedCredits: {
+						type: "number",
+						required: true
+					},
+					images: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								attachmentId: {
+									type: "string",
+									required: true
+								},
+								mediaType: {
+									type: "string",
+									required: true
+								},
+								bytes: {
+									type: "integer",
+									required: true
+								},
+								width: {
+									type: "integer",
+									required: true
+								},
+								height: {
+									type: "integer",
+									required: true
+								}
+							}
+						}
+					}
+				}
+			},
+			render: (_args, value) => [...value.images.map((image) => ({
+				type: "image",
+				attachment: image
+			})), {
+				type: "text",
+				text: formatDrawEnvelope(value)
+			}],
+			presentationMeta: (_args, value) => ({
+				kind: "codebuddy-draw",
+				prompt: value.prompt,
+				usedCredits: value.usedCredits
+			})
+		},
+		isConcurrencySafe: () => false,
+		async execute(args, exec) {
+			const provider = exec.agent?.session.requestHeader()?.config.provider;
+			if (provider !== void 0 && provider !== "codebuddy") throw new Error(`codebuddy-draw charges CodeBuddy credits, so only a CodeBuddy model may call it; the current agent uses provider "${provider}"`);
+			const agentSessionId = exec.agent?.session.id;
+			const sessionId = agentSessionId === void 0 ? void 0 : String(agentSessionId);
+			const identity = await session.requestIdentity(sessionId);
+			const conversationId = sessionId === void 0 ? compactUuid() : session.conversationIdOf(sessionId);
+			const requestId = sessionId === void 0 ? compactUuid() : session.turnRequestIdOf(sessionId) ?? compactUuid();
+			const messageId = compactUuid();
+			const generated = await generateImage(identity.headers, TEXT_TO_IMAGE_MODEL, args, {
+				conversationId,
+				requestId,
+				messageId
+			}, exec.signal);
+			const images = [];
+			for (const image of generated.images) {
+				if (image.url === void 0 && image.b64_json === void 0) continue;
+				const data = image.b64_json !== void 0 ? Buffer.from(image.b64_json, "base64") : await downloadImage(image.url, exec.signal);
+				images.push(await attachments.saveImage({
+					data,
+					mediaType: "image/png"
+				}));
+			}
+			if (images.length === 0) throw new Error("image generation returned no usable image data");
+			if (sessionId !== void 0 && generated.usedCredits > 0) session.recordCredit(sessionId, generated.usedCredits, identity.account);
+			return {
+				images,
+				usedCredits: generated.usedCredits,
+				prompt: args.prompt
+			};
+		}
+	}));
+}
+/** 从签名对象 URL 下载生成的图片字节。 */
+async function downloadImage(url, signal) {
+	const response = await fetch(url, { ...signal === void 0 ? {} : { signal } });
+	if (!response.ok) throw new Error(`image download failed (HTTP ${response.status})`);
+	return Buffer.from(await response.arrayBuffer());
+}
+//#endregion
+//#region lib/types/rpc-route.js
+/**
+* 本插件私有浏览器 RPC 通道的物理 HTTP 路由持有者。
+*
+* `connection.rpc.handle()` 无法在功能插件中使用:它在 Connection 服务自身的
+* Context 下注册路由,而该 Context 的 fiber 从未声明 `webServer`,因此注册会抛出
+* `cannot get property "webServer" without inject`,通道永远无法挂载,浏览器调用
+* 随后落到 SPA 回退(HTTP 405)。本模块改为在同时声明这两个服务的 inject fork 中,
+* 把前缀路由直接注册到 `webServer` 上,复现 Connection 桥本应提供的同一传输契约:
+* 先做浏览器认证,然后接收 JSON `client-request` 信封、返回 `server-response` 信封。
+*
+* @module dsh-llm-codebuddy-power/rpc-route
+*/
+/** 单个已缓冲请求体的上限;这些信封只携带很小的 JSON 载荷。 */
+const MAX_REQUEST_BODY_BYTES = 1024 * 1024;
+/** 单个 endpoint 路径段允许的字符(与 Connection 通道文法一致)。 */
+const ENDPOINT_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+/** 信封在尚未读出 id 前就已畸形时回显的 rpcId。 */
+const INVALID_REQUEST_RPC_ID = "invalid-request";
+/**
+* 把一个私有 RPC 通道挂载为 Web 前缀路由。
+*
+* 该路由由下方的 inject fork 持有,因此卸载本插件的 fiber 时会将其移除。
+* 不含 `webServer` 的 profile(headless)不会解析出该 fork,也就不会挂载路由。
+* @param ctx - 插件自身的 Context,用于创建持有路由的 inject fork。
+* @param channel - 绝对通道前缀,例如 `/codebuddy`。
+* @param handler - 已解码的 endpoint 处理器,返回 RPC 结果信封。
+*/
+function mountPrivateChannel(ctx, channel, handler) {
+	ctx.inject(["connection", "webServer"], (rpcCtx) => {
+		rpcCtx.effect(() => rpcCtx.webServer.register({
+			kind: "prefix",
+			path: channel,
+			handler: (req, res) => serveChannel(rpcCtx, channel, handler, req, res)
+		}), `dsh-llm-codebuddy-power: ${channel} rpc channel`);
+	});
+}
+/** 通道之下某个请求路径对应的 endpoint 名称,不存在时为 undefined。 */
+function endpointOf(channel, pathname) {
+	if (!pathname.startsWith(`${channel}/`)) return void 0;
+	const endpoint = pathname.slice(channel.length + 1);
+	if (endpoint.split("/").some((segment) => segment === "" || segment === "." || segment === ".." || !ENDPOINT_SEGMENT_PATTERN.test(segment))) return;
+	return endpoint;
+}
+/**
+* 在通道上完成一次请求的认证、解码、分发与应答。
+* @param rpcCtx - 提供 `connection` 与 `webServer` 的 inject fork Context。
+* @param channel - 本路由持有的通道前缀。
+* @param handler - 已解码的 endpoint 处理器。
+* @param req - 到来的 HTTP 请求。
+* @param res - 本路由在整个生命周期内持有的响应。
+*/
+async function serveChannel(rpcCtx, channel, handler, req, res) {
+	const rejection = rpcCtx.connection.requestRejection(req);
+	if (rejection !== void 0) {
+		res.writeHead(rejection);
+		res.end(rejection === 401 ? "unauthorized" : "forbidden");
+		return;
+	}
+	const endpoint = endpointOf(channel, new URL(req.url ?? "/", "http://dsh.internal").pathname);
+	if (req.method !== "POST" || endpoint === void 0) {
+		res.writeHead(404);
+		res.end("not found");
+		return;
+	}
+	if (req.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") {
+		res.writeHead(415);
+		res.end("content type must be application/json");
+		return;
+	}
+	const body = await readBody(req);
+	if (body === void 0) {
+		res.writeHead(413);
+		res.end("body too large");
+		return;
+	}
+	let envelope;
+	try {
+		envelope = JSON.parse(body);
+	} catch {
+		res.writeHead(400);
+		res.end("body is not JSON");
+		return;
+	}
+	const message = parseEnvelope(envelope);
+	if (message === void 0) {
+		writeJson(res, 200, serverResponse(INVALID_REQUEST_RPC_ID, {
+			ok: false,
+			error: {
+				code: "gateway/bad-request",
+				message: "invalid client-request message",
+				details: {}
+			}
+		}));
+		return;
+	}
+	if (message.method !== endpoint) {
+		writeJson(res, 200, serverResponse(message.rpcId, {
+			ok: false,
+			error: {
+				code: "gateway/bad-request",
+				message: `method ${JSON.stringify(message.method)} does not match endpoint ${JSON.stringify(endpoint)}`,
+				details: {}
+			}
+		}));
+		return;
+	}
+	try {
+		const controller = new AbortController();
+		res.on("close", () => {
+			controller.abort();
+		});
+		const result = await handler(endpoint, message.payload, controller.signal);
+		writeJson(res, 200, serverResponse(message.rpcId, result));
+	} catch (error) {
+		res.writeHead(500);
+		res.end(`handler failure: ${String(error)}`);
+	}
+}
+/** 读取一个请求体;超过 {@link MAX_REQUEST_BODY_BYTES} 时返回 undefined。 */
+async function readBody(req) {
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		total += buffer.byteLength;
+		if (total > MAX_REQUEST_BODY_BYTES) {
+			req.destroy();
+			return;
+		}
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks).toString("utf-8");
+}
+/** 解码信封;未携带必需字段时返回 undefined。 */
+function parseEnvelope(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const record = value;
+	if (record.type !== "client-request") return void 0;
+	if (typeof record.rpcId !== "string" || typeof record.method !== "string") return void 0;
+	return {
+		rpcId: record.rpcId,
+		method: record.method,
+		payload: record.payload
+	};
+}
+/** 构建回传给浏览器的 `server-response` 信封。 */
+function serverResponse(rpcId, result) {
+	return {
+		type: "server-response",
+		rpcId,
+		result
+	};
+}
+/** 以给定状态码写回一个 JSON 响应。 */
+function writeJson(res, status, value) {
+	const body = Buffer.from(JSON.stringify(value), "utf-8");
+	res.writeHead(status, {
+		"content-type": "application/json",
+		"content-length": String(body.byteLength)
+	});
+	res.end(body);
+}
+//#endregion
+//#region lib/types/login.js
+/**
+* 浏览器 OAuth 登录流程,从发起到凭据落盘。
+*
+* 全程不索取 API key:握手生成一个 `state`,用户在普通浏览器中
+* 登录,然后依据该 state 从服务轮询取出令牌。用户需要做的
+* 只是在一个登录页面上点击完成。
+*
+* @module dsh-llm-codebuddy-power/login
+*/
+/**
+* 由刚签发的令牌与账号信息构建一个可持久化的账号条目。
+*
+* CLI 流程与 Web 认证服务共用,以免两者在存储结构上
+* 产生分歧:两者写入的都是这个对象。
+* @param token - 浏览器登录完成后签发的令牌。
+* @param account - 令牌所对应的已登录账号。
+* @returns 要持久化的账号条目。
+*/
+function buildAccount(token, account) {
+	return {
+		auth: {
+			accessToken: token.accessToken,
+			expiresAt: Date.now() + token.expiresIn * 1e3,
+			refreshToken: token.refreshToken,
+			refreshExpiresAt: Date.now() + token.refreshExpiresIn * 1e3,
+			domain: token.domain
+		},
+		account: {
+			uid: account.uid,
+			nickname: account.nickname,
+			...account.uin === void 0 ? {} : { uin: account.uin },
+			...account.enterpriseId === void 0 ? {} : { enterpriseId: account.enterpriseId },
+			...account.enterpriseName === void 0 ? {} : { enterpriseName: account.enterpriseName },
+			...account.enterpriseUserName === void 0 ? {} : { enterpriseUserName: account.enterpriseUserName },
+			...account.departmentFullName === void 0 ? {} : { departmentFullName: account.departmentFullName }
+		}
+	};
+}
+/**
+* 尽力在用户的默认浏览器中打开 URL。
+*
+* 失败被刻意设为静默:URL 已经打印出来,因此无头或受限
+* 环境仍有可用的前进路径,否则 spawn 错误会被
+* 读作登录失败。
+*/
+function openInBrowser(url) {
+	let command;
+	let args;
+	if (process.platform === "win32") {
+		command = "rundll32";
+		args = ["url.dll,FileProtocolHandler", url];
+	} else {
+		command = process.platform === "darwin" ? "open" : "xdg-open";
+		args = [url];
+	}
+	try {
+		const child = spawn(command, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+/**
+* 运行完整的浏览器登录流程。
+* @param hooks - 用户交互钩子。
+* @param signal - 可选取消。
+* @returns 已追加到账号列表的账号与已登录昵称。
+* @throws Error 握手失败、用户未及时完成,或
+*   账号无法读取时。
+*/
+async function login(hooks = {}, signal) {
+	const state = await requestAuthState(signal);
+	hooks.onUrl?.(state.authUrl);
+	if (hooks.openBrowser !== false) openInBrowser(state.authUrl);
+	const token = await pollAuthToken(state.state, signal);
+	if (token === void 0) throw new Error("CodeBuddy sign-in did not complete (it was refused, or it timed out).");
+	const account = await getLoginAccount(state.state, token.accessToken, token.domain);
+	const entry = buildAccount(token, account);
+	await upsertAccount(entry);
+	return {
+		account: entry,
+		nickname: account.nickname
+	};
+}
+//#endregion
+//#region lib/types/model-enrich.js
+/**
+* 客户端模型面板的模型增强：推广/等级解析、按模型的覆盖值存储，以及
+* RPC 安全的目录投影。
+*
+* 推广是 CodeBuddy 的定时活动（徽章 + 悬浮提示 + 可选折扣）；等级是订阅档位
+* 徽章（"订阅优先"）。二者都是提示性的展示数据：主机解析展示事实，客户端负责
+* 渲染。覆盖值让用户按模型限制上下文窗口 / 最大输出 token，统一存储在
+* `$DSH_HOME/data/plugins/llm-codebuddy-power/`。
+*
+* @module dsh-llm-codebuddy-power/model-enrich
+*/
+/** 覆盖值文件的绝对路径。 */
+function overridesPath() {
+	return dshHomePath("data", "plugins", "llm-codebuddy-power", "model-overrides.json");
+}
+/** 加载覆盖值表；文件缺失或损坏时按空表处理（丢失用户限制是安全的）。 */
+async function loadOverrides() {
+	try {
+		const raw = await promises.readFile(overridesPath(), "utf-8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+		const table = {};
+		for (const [id, value] of Object.entries(parsed)) {
+			if (typeof value !== "object" || value === null) continue;
+			const entry = value;
+			table[id] = {
+				...typeof entry.contextWindow === "number" && Number.isFinite(entry.contextWindow) && entry.contextWindow > 0 ? { contextWindow: entry.contextWindow } : {},
+				...typeof entry.maxOutputTokens === "number" && Number.isFinite(entry.maxOutputTokens) && entry.maxOutputTokens > 0 ? { maxOutputTokens: entry.maxOutputTokens } : {}
+			};
+		}
+		return table;
+	} catch {
+		return {};
+	}
+}
+/** 原子地持久化整张覆盖值表（读-改-写由调用方负责）。 */
+async function saveOverrides(table) {
+	const path = overridesPath();
+	await promises.mkdir(dirname(path), { recursive: true });
+	const temp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
+	try {
+		await promises.writeFile(temp, JSON.stringify(table, null, 2), {
+			encoding: "utf-8",
+			mode: 384
+		});
+		await promises.rename(temp, path);
+	} catch (error) {
+		await promises.unlink(temp).catch(() => {});
+		throw error;
+	}
+}
+/**
+* 判断某个推广当前是否生效：已启用、处于绝对有效期内，且声明了每日时段时
+* 落在匹配的每日时段内（考虑时区）。
+* @param promotion - 待判定的推广活动。
+* @param now - 判定时刻，epoch 毫秒。
+* @returns 活动当前生效时为 true。
+*/
+function isPromotionActive(promotion, now = Date.now()) {
+	if (promotion.enabled === false) return false;
+	const schedule = promotion.schedule;
+	if (schedule === void 0) return true;
+	if (schedule.validFrom !== void 0 && Date.parse(schedule.validFrom) > now) return false;
+	if (schedule.validUntil !== void 0 && Date.parse(schedule.validUntil) <= now) return false;
+	if (schedule.daily === void 0 || schedule.daily.length === 0) return true;
+	const offsetMs = tzOffsetMs(schedule.timezone, now);
+	const local = new Date(now + offsetMs);
+	const minutes = local.getUTCHours() * 60 + local.getUTCMinutes();
+	for (const window of schedule.daily) {
+		const start = parseHhMm(window.start);
+		const end = parseHhMm(window.end);
+		if (start === void 0 || end === void 0) continue;
+		if (start <= end && minutes >= start && minutes < end) return true;
+		if (start > end && (minutes >= start || minutes < end)) return true;
+	}
+	return false;
+}
+/** IANA 时区 → 某一时刻相对 UTC 的毫秒偏移；查找失败时回退到 UTC。 */
+function tzOffsetMs(timezone, at) {
+	if (timezone === void 0) return 0;
+	try {
+		const formatter = new Intl.DateTimeFormat("en-US", {
+			timeZone: timezone,
+			hour12: false,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit"
+		});
+		const parts = Object.fromEntries(formatter.formatToParts(new Date(at)).map((p) => [p.type, p.value]));
+		const y = Number(parts.year);
+		const mo = Number(parts.month) - 1;
+		const d = Number(parts.day);
+		const h = Number(parts.hour) === 24 ? 0 : Number(parts.hour);
+		const mi = Number(parts.minute);
+		const s = Number(parts.second);
+		return Date.UTC(y, mo, d, h, mi, s) - (at - at % 1e3);
+	} catch {
+		return 0;
+	}
+}
+/** 把 "HH:MM" 解析为自午夜起的分钟数，无法解析时为 undefined。 */
+function parseHhMm(value) {
+	if (value === void 0) return void 0;
+	const match = /^(\d{1,2}):(\d{2})$/.exec(value);
+	if (match === null) return void 0;
+	const hours = Number(match[1]);
+	const minutes = Number(match[2]);
+	if (hours > 23 || minutes > 59) return void 0;
+	return hours * 60 + minutes;
+}
+/**
+* 把倍率标签归一化为"x 在前"的写法。
+*
+* 服务端自身不一致:模型目录给的标价是 `x0.79`,`discount` 给的折后值是
+* `0.50x`/`0x`。两种写法并列时(原价划掉 + 折后价)看起来像两个不同量纲的
+* 数字,所以统一为 `x0.79`/`x0.50`/`x0`。
+* @param value - 服务端给的倍率标签。
+* @returns 归一化后的标签;无法识别时原样返回。
+*/
+function normalizeMultiplier(value) {
+	const trimmed = value.trim();
+	const trailingX = /^([0-9]+(?:\.[0-9]+)?)x$/i.exec(trimmed);
+	return trailingX === null ? trimmed : `x${trailingX[1]}`;
+}
+/**
+* 解析某个模型最终胜出的生效推广：在 `modelIds` 覆盖该模型且当前生效的活动
+* 中，优先级最高者胜出（CodeBuddy 自身的选择规则）。只投影展示事实。
+* @param promotions - 全部推广活动。
+* @param modelId - 待解析的模型。
+* @returns 胜出活动的展示事实，没有时为 undefined。
+*/
+function promotionFor(promotions, modelId, now = Date.now()) {
+	let winner;
+	for (const promotion of promotions) {
+		if (promotion.modelIds === void 0 || !promotion.modelIds.includes(modelId)) continue;
+		if (!isPromotionActive(promotion, now)) continue;
+		const { label, color } = promotion.badge ?? {};
+		if (label === void 0 || color === void 0) continue;
+		const priority = promotion.priority ?? 0;
+		if (winner !== void 0 && winner.priority >= priority) continue;
+		const { textZh, textEn } = promotion.hover ?? {};
+		const action = promotion.hover?.action;
+		winner = {
+			priority,
+			view: {
+				label,
+				color,
+				...promotion.discount?.discountedCredits === void 0 ? {} : { discountedCredits: normalizeMultiplier(promotion.discount.discountedCredits) },
+				...promotion.discount?.displayMode === void 0 ? {} : { displayMode: promotion.discount.displayMode },
+				...textZh === void 0 ? {} : { textZh },
+				...textEn === void 0 ? {} : { textEn },
+				...action === void 0 ? {} : { action: {
+					...action.type === void 0 ? {} : { type: action.type },
+					...action.labelZh === void 0 ? {} : { labelZh: action.labelZh },
+					...action.labelEn === void 0 ? {} : { labelEn: action.labelEn }
+				} }
+			}
+		};
+	}
+	return winner?.view;
+}
+/**
+* 解析挂在某个模型上的等级徽章。
+* @param tiers - 全部模型等级。
+* @param modelId - 待解析的模型。
+* @returns 首个匹配等级的展示事实，没有时为 undefined。
+*/
+function tierFor(tiers, modelId) {
+	if (tiers === void 0) return void 0;
+	for (const tier of tiers) {
+		if (tier.enabled === false) continue;
+		if (tier.modelIds === void 0 || !tier.modelIds.includes(modelId)) continue;
+		const { label } = tier.badge ?? {};
+		if (label === void 0) continue;
+		return {
+			label,
+			...tier.hover?.textZh === void 0 ? {} : { textZh: tier.hover.textZh },
+			...tier.hover?.textEn === void 0 ? {} : { textEn: tier.hover.textEn },
+			...tier.hover?.action === void 0 ? {} : { action: {
+				...tier.hover.action.type === void 0 ? {} : { type: tier.hover.action.type },
+				...tier.hover.action.labelZh === void 0 ? {} : { labelZh: tier.hover.action.labelZh },
+				...tier.hover.action.labelEn === void 0 ? {} : { labelEn: tier.hover.action.labelEn }
+			} }
+		};
+	}
+}
+/**
+* 把目录模型及其推广/等级事实投影为可安全下发给客户端的增强行。
+* 提供 `withOverrides` 时应用按模型的用户限制。
+* @param model - 目录模型。
+* @param promotions - 全部推广活动（按模型逐个解析）。
+* @param tiers - 全部模型等级。
+* @param withOverrides - 按模型的用户限制，没有时为 undefined。
+* @returns 增强后的行。
+*/
+function enrichModel(model, promotions, tiers, withOverrides) {
+	const promotion = promotionFor(promotions, model.id);
+	const tier = tierFor(tiers, model.id);
+	const contextWindow = withOverrides?.contextWindow ?? model.maxAllowedSize;
+	const maxOutputTokens = withOverrides?.maxOutputTokens ?? model.maxOutputTokens;
+	return {
+		id: model.id,
+		name: model.name,
+		...model.credits === void 0 ? {} : { credits: normalizeMultiplier(model.credits) },
+		...promotion === void 0 ? {} : { promotion },
+		...tier === void 0 ? {} : { tier },
+		...model.supportsImages === void 0 ? {} : { supportsImages: model.supportsImages },
+		...model.supportsReasoning === void 0 ? {} : { supportsReasoning: model.supportsReasoning },
+		...model.supportsToolCall === void 0 ? {} : { supportsToolCall: model.supportsToolCall },
+		...contextWindow === void 0 ? {} : { contextWindow },
+		...maxOutputTokens === void 0 ? {} : { maxOutputTokens },
+		...model.maxAllowedSize === void 0 ? {} : { contextWindowCap: model.maxAllowedSize },
+		...model.maxOutputTokens === void 0 ? {} : { maxOutputTokensCap: model.maxOutputTokens },
+		...model.descriptionZh === void 0 ? {} : { descriptionZh: model.descriptionZh },
+		...model.descriptionEn === void 0 ? {} : { descriptionEn: model.descriptionEn }
+	};
+}
+//#endregion
+//#region lib/types/auth-service.js
+/**
+* 通过私有 RPC 通道暴露给 Web 客户端的宿主侧 OAuth 服务。
+*
+* 浏览器登录是长时操作(要等待用户完成登录),因此拆成两个 RPC endpoint:
+* `startLogin` 生成握手并返回用户必须打开的 URL,`pollLogin` 检查该握手是否已完成;
+* 一次完成的登录会**追加**一个账号,而不是取代已有的。`accounts`、`activate`、
+* `setDefault`、`logout` 是设置页与会话账号按钮其余时间驱动的读写组合。
+*
+* @module dsh-llm-codebuddy-power/auth-service
+*/
+/** 客户端调用认证服务所用的 RPC 通道。 */
+const CODEBUDDY_AUTH_CHANNEL = "/codebuddy";
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function err(code, message) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message,
+			details: {}
+		}
+	};
+}
+/** 从 RPC payload 中读一个字符串字段;缺失或类型不符时返回空字符串。 */
+function stringField(payload, key) {
+	if (typeof payload !== "object" || payload === null) return "";
+	const value = payload[key];
+	return typeof value === "string" ? value : "";
+}
+/** 从 RPC payload 中读一个非空字符串数组字段;缺失或类型不符时返回空数组。 */
+function stringListField(payload, key) {
+	if (typeof payload !== "object" || payload === null) return [];
+	const value = payload[key];
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string" && item.length > 0);
+}
+/** uid 在提示框里显示的位数。 */
+const CREDIT_UID_DISPLAY_CHARS = 8;
+/**
+* 把一条轮次记录投影为发给客户端的结构。
+*
+* uid 在**呈现边界**才截断:存储与解析都保留完整值,截断只影响这一个提示行。把它放在
+* 这里而不是存储层,是因为存储层丢掉的信息无法再恢复,而显示层的取舍可以随时改。
+* @param record - 已按账号表展开的轮次记录。
+* @returns 对客户端安全的投影。
+*/
+function projectCreditRecord(record) {
+	return {
+		credit: record.credit,
+		accounts: record.accounts.map((account) => ({
+			nickname: account.nickname,
+			uidPrefix: account.uid.slice(0, CREDIT_UID_DISPLAY_CHARS)
+		}))
+	};
+}
+/**
+* 把一个自有数据的 {@link UsageWindow} 投影为客户端收到的 RPC 安全结构,
+* 仅在可选字段存在时才展开它们。
+* @param window - 计量窗口。
+* @returns 对客户端安全的投影结果。
+*/
+function projectWindow(window) {
+	return {
+		name: window.name,
+		...window.used === void 0 ? {} : { used: window.used },
+		...window.limit === void 0 ? {} : { limit: window.limit },
+		...window.resetsAt === void 0 ? {} : { resetsAt: window.resetsAt }
+	};
+}
+/**
+* CodeBuddy 认证 RPC 服务。
+*
+* 握手由 `startLogin` 发起,由 `pollLogin` 轮询至完成,其账号由适配器的
+* `CodeBuddySession` 在下一个请求中取用 → 因此通过 UI 完成的登录无需重启
+* 即可到达运行中的 harness。`logout` 移除指定账号并使会话缓存失效。
+*/
+var CodeBuddyAuthService = class {
+	session;
+	/** 按 state id 索引的进行中握手。 */
+	pending = /* @__PURE__ */ new Map();
+	constructor(ctx, session) {
+		this.session = session;
+		mountPrivateChannel(ctx, CODEBUDDY_AUTH_CHANNEL, (endpoint, payload, signal) => this.dispatch(endpoint, payload, signal));
+	}
+	/** 把一次 RPC endpoint 调用路由到对应的处理器。 */
+	async dispatch(endpoint, payload, _signal) {
+		switch (endpoint) {
+			case "accounts": return ok(await this.accounts());
+			case "startLogin": return ok(await this.startLogin());
+			case "pollLogin": return ok(await this.pollLogin(stringField(payload, "state")));
+			case "cancelLogin": return this.cancelLogin(stringField(payload, "state")) ? ok(void 0) : err("bad-request", "a login handshake id is required");
+			case "sessionAccount": return ok(await this.sessionAccount(stringField(payload, "sessionId")));
+			case "activate": return await this.activate(stringField(payload, "sessionId"), stringField(payload, "uid")) ? ok(void 0) : err("unknown-account", "the requested account is not stored");
+			case "setDefault": {
+				const uid = stringField(payload, "uid");
+				return await this.setDefault(uid.length === 0 ? void 0 : uid) ? ok(void 0) : err("unknown-account", "the requested account is not stored");
+			}
+			case "logout":
+				await this.logout(stringListField(payload, "uids"));
+				return ok(void 0);
+			case "reorder":
+				await this.reorder(stringListField(payload, "uids"));
+				return ok(void 0);
+			case "usage": return ok(await this.usage(stringField(payload, "sessionId")));
+			case "creditOf": {
+				const sessionId = stringField(payload, "sessionId");
+				const turn = typeof payload === "object" && payload !== null && "turn" in payload && typeof payload.turn === "number" ? payload.turn : NaN;
+				if (Number.isNaN(turn)) return ok(void 0);
+				const record = await this.session?.creditOf(sessionId, turn);
+				return ok(record === void 0 ? void 0 : projectCreditRecord(record));
+			}
+			case "models": return ok(await this.enrichedModels(stringField(payload, "sessionId")));
+			case "setOverride":
+				await this.setOverride(stringField(payload, "modelId"), payload);
+				return ok(void 0);
+			default: return err("not-found", `unknown auth endpoint: ${endpoint}`);
+		}
+	}
+	/**
+	* 读取已存账号及其默认账号,不要求必须存在。
+	* @returns 账号集合;未存任何内容时为空列表。
+	*/
+	async accounts() {
+		if (this.session === void 0) return { accounts: [] };
+		return this.session.accountList();
+	}
+	/**
+	* 发起一次浏览器登录握手。
+	* @returns 用户必须打开的 URL。
+	*/
+	async startLogin() {
+		const handshake = await requestAuthState();
+		const controller = new AbortController();
+		const pending = {
+			state: handshake.state,
+			promise: this.runLogin(handshake.state, controller.signal),
+			controller
+		};
+		this.pending.set(handshake.state, pending);
+		pending.promise.finally(() => {
+			if (this.pending.get(handshake.state) === pending) this.pending.delete(handshake.state);
+		});
+		return {
+			authUrl: handshake.authUrl,
+			state: handshake.state
+		};
+	}
+	/**
+	* 检查已发起的握手是否完成。
+	* @param state - 来自 `startLogin` 的握手 id。
+	* @returns 登录是否完成、账号是否已持久化。
+	*/
+	async pollLogin(state) {
+		const pending = this.pending.get(state);
+		if (pending === void 0) return { done: false };
+		const entry = await pending.promise;
+		return {
+			done: entry !== void 0,
+			...entry === void 0 ? {} : { nickname: entry.account.nickname }
+		};
+	}
+	/**
+	* 某会话此刻生效的账号。
+	* @param sessionId - dsh 会话身份;为空时按未选定处理。
+	* @returns 该会话的账号 uid;没有账号时缺省。
+	*/
+	async sessionAccount(sessionId) {
+		if (sessionId.length === 0) return {};
+		const uid = await this.session?.activeUid(sessionId);
+		return uid === void 0 ? {} : { uid };
+	}
+	/**
+	* 把某会话的账号切换为指定账号。
+	* @param sessionId - dsh 会话身份。
+	* @param uid - 目标账号 uid。
+	* @returns 该账号已存时为 true。
+	*/
+	async activate(sessionId, uid) {
+		if (sessionId.length === 0 || uid.length === 0) return false;
+		return this.session?.activate(sessionId, uid) ?? false;
+	}
+	/**
+	* 放弃一次进行中的登录握手。
+	*
+	* 中止底层的令牌轮询并丢弃该握手:用户点了取消之后,客户端不再轮询,而宿主也不该
+	* 继续占着一个十分钟的轮询循环。未知或已完成的 state 视作已经结束,返回 true ——
+	* 取消是幂等的收尾动作,没有"已经取消过"这种失败。
+	* @param state - 来自 `startLogin` 的握手 id。
+	* @returns 该握手是否已被放弃(未知 state 同样是 true)。
+	*/
+	cancelLogin(state) {
+		if (state.length === 0) return false;
+		const pending = this.pending.get(state);
+		if (pending === void 0) return true;
+		pending.controller.abort();
+		this.pending.delete(state);
+		return true;
+	}
+	/**
+	* 指定或取消默认账号。
+	* @param uid - 默认账号 uid;`undefined` 表示取消默认账号。
+	* @returns 指定时该账号已存、或取消成功时为 true。
+	*/
+	async setDefault(uid) {
+		if (uid !== void 0) {
+			if (!(await this.accounts()).accounts.some((account) => account.uid === uid)) return false;
+		}
+		await setDefaultAccount(uid);
+		this.session?.invalidate();
+		return true;
+	}
+	/**
+	* 移除若干账号。
+	* @param uids - 要移除的账号 uid。
+	*/
+	async logout(uids) {
+		if (uids.length === 0) return;
+		await removeAccounts(uids);
+		this.session?.invalidate();
+	}
+	/**
+	* 按给定顺序重排账号。
+	*
+	* 顺序即展示顺序,也是没有默认账号、也没有手动切换记录时的兜底账号,因此这里真的
+	* 改变"用谁"。重排会让输入区控件组读到的账号集合顺序变化,故同样使会话缓存失效。
+	* @param uids - 目标顺序上的账号 uid。
+	*/
+	async reorder(uids) {
+		if (uids.length === 0) return;
+		await reorderAccounts(uids);
+		this.session?.invalidate();
+	}
+	/**
+	* 为界面读取某会话账号的 CodeBuddy 用量快照。
+	*
+	* 委托给会话完成:会话会在读取计量前解析刷新后的身份,且计量服务不可用时不会抛错。
+	* 没有账号时按 `loggedIn: false` 上报,让客户端隐藏该呈现,
+	* 而不是渲染出坏掉的进度条。
+	* @param sessionId - dsh 会话身份。
+	* @returns 用量投影;没有账号时返回未登录结构。
+	*/
+	async usage(sessionId) {
+		const snapshot = await this.session?.usage(sessionId);
+		if (snapshot === void 0) return { loggedIn: false };
+		const main = snapshot.main === void 0 ? void 0 : {
+			used: snapshot.main.used,
+			limit: snapshot.main.limit
+		};
+		const gift = snapshot.gift === void 0 ? void 0 : {
+			used: snapshot.gift.used,
+			limit: snapshot.gift.limit,
+			soonest: snapshot.gift.soonest.map(projectWindow)
+		};
+		return {
+			loggedIn: true,
+			...snapshot.primaryResetsAt === void 0 ? {} : { primaryResetsAt: snapshot.primaryResetsAt },
+			...main === void 0 ? {} : { main },
+			...gift === void 0 ? {} : { gift }
+		};
+	}
+	/**
+	* 把一次握手推进到持久化的账号。
+	*
+	* 复用 `buildAccount`,使落盘结构与 CLI 登录完全一致。
+	* 任何失败都返回 `undefined`,让客户端的轮询得到 `done: false`,
+	* 从而可以从 `startLogin` 重试。
+	*/
+	async runLogin(state, signal) {
+		try {
+			const token = await pollAuthToken(state, signal);
+			if (token === void 0) return void 0;
+			const entry = buildAccount(token, await getLoginAccount(state, token.accessToken, token.domain));
+			await upsertAccount(entry);
+			this.session?.invalidate();
+			return entry;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* 供客户端面板使用的增强版 CodeBuddy 目录:应用了促销/等级展示信息与覆盖配置的模型。
+	* @param sessionId - 用哪个会话的账号读目录;为空时用默认账号。
+	* @returns 增强结果;会话不可用或该账号没有目录时为空行。
+	*/
+	async enrichedModels(sessionId) {
+		if (this.session === void 0) return { models: [] };
+		const store = await loadOverrides();
+		const catalog = await this.session.catalogDataOrEmpty(void 0, sessionId.length === 0 ? void 0 : sessionId);
+		return { models: catalog.models.filter(hasDisclosedCapacity).filter((model) => !isBlockedModelId(model.id)).map((model) => enrichModel(model, catalog.promotions, catalog.tiers, store[model.id])) };
+	}
+	/**
+	* 插入或更新(或清除)单个模型的用户覆盖配置,并持久化整张表。
+	* @param modelId - 模型 id。
+	* @param payload - `{ contextWindow?, maxOutputTokens? }`;显式缺省或非正数的字段
+	*   会清除对应的上限。
+	*/
+	async setOverride(modelId, payload) {
+		if (modelId.length === 0) return;
+		const table = await loadOverrides();
+		const raw = typeof payload === "object" && payload !== null ? payload : {};
+		const positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+		const contextWindow = positive(raw.contextWindow);
+		const maxOutputTokens = positive(raw.maxOutputTokens);
+		const next = {
+			...contextWindow === void 0 ? {} : { contextWindow },
+			...maxOutputTokens === void 0 ? {} : { maxOutputTokens }
+		};
+		if (Object.keys(next).length === 0) {
+			const rest = {};
+			for (const id of Object.keys(table)) if (id !== modelId) rest[id] = table[id];
+			await saveOverrides(rest);
+			this.session?.invalidate();
+			return;
+		}
+		table[modelId] = next;
+		await saveOverrides(table);
+		this.session?.invalidate();
+	}
+};
+//#endregion
+//#region lib/types/prefs.js
+/**
+* CodeBuddy 界面偏好的命名空间契约,Host 与 Client 两面共享。
+*
+* 这些偏好是**插件自己的设置命名空间**里的一段:`Config` 提供部署级 base,
+* 用户在 Web 设置页的写入落在 harness 的用户设置文档里,因此换浏览器、重启
+* harness 后仍然生效 —— 其中「极简模式画图工具」还会被宿主读取来决定
+* `codebuddy-draw` 对模型是否可见,存在浏览器里会让同一次部署因浏览器而异。
+*
+* 本文件必须保持零依赖:两面都会编译它,而 Client 面若因此引入 schemastery
+* 就会把它打进浏览器产物(校验 schema 是宿主面的事,见 `./settings.ts`)。
+*
+* @module dsh-llm-codebuddy-power/prefs
+*/
+/** 本插件拥有的设置命名空间,与插件名一致。 */
+const CODEBUDDY_SETTINGS_NAMESPACE = "llm-codebuddy-power";
+/** 未覆盖任何一层时使用的偏好默认值。 */
+const DEFAULT_CODEBUDDY_SETTINGS = {
+	showUsage: true,
+	dangerPct: 90,
+	drawToolInMinimal: false
+};
+//#endregion
+//#region lib/types/settings.js
+/**
+* 本插件设置命名空间的宿主 schema。
+*
+* 校验只在宿主发生:浏览器面若也引入 schemastery,它会连同校验器一起被打进
+* `lib/client.js`,而客户端本来就把服务端返回的数据当作已校验结果接收。因此
+* schema 只在此文件出现,浏览器面经 `./prefs.ts` 取同一份类型与默认值。
+*
+* 字段的默认值一律取自 `DEFAULT_CODEBUDDY_SETTINGS`,不在此重复字面量 ——
+* 两处各写一份时,改了一处就会出现「宿主默认 90、界面显示 80」这种只有用户
+* 看得见的偏差。
+*
+* @module dsh-llm-codebuddy-power/settings
+*/
+/** 用户设置文档中本插件命名空间的 schema。 */
+const CodeBuddySettingsSchema = z.object({
+	showUsage: z.boolean().default(DEFAULT_CODEBUDDY_SETTINGS.showUsage),
+	dangerPct: z.number().step(1).min(1).max(100).default(DEFAULT_CODEBUDDY_SETTINGS.dangerPct),
+	drawToolInMinimal: z.boolean().default(DEFAULT_CODEBUDDY_SETTINGS.drawToolInMinimal)
+});
+//#endregion
+//#region lib/types/index.js
+/**
+* DeepSeek Harness 的 Tencent CodeBuddy provider 插件。
+*
+* 在 `ctx.llm` 上注册一条 `codebuddy` 路由,由浏览器 OAuth 登录而非 API key
+* 授权,并提供 CodeBuddy 自己的(非 OpenAI)目录端点所报告的模型。
+*
+* 通过 Web 设置 → CodeBuddy 页面登录,或在终端执行
+* `dsh plugin --profile web codebuddy-power`。无需 API key,运行中的 harness
+* 无需重启即可取得该凭据。
+*
+* @module dsh-llm-codebuddy-power
+*/
+/** Cordis 插件名。 */
+const name = "llm-codebuddy-power";
+/**
+* 本插件的激活服务。`llm` 承载适配器路由,`tools` 接受文生图工具注册,
+* `agents` 用于极简模式会话中按 agent 限制画图工具可见性。生成图片经
+* 标准附件通道(attachments.saveImage + uiConversation.imageUrl)持久化与
+* 展示,工具注册在附件服务挂载后(`ctx.inject(['attachments'])`)。
+*/
+const inject = [
+	"llm",
+	"tools",
+	"agents"
+];
+/**
+* 校验并补全原始配置。
+*
+* 编程式构造可以绕过任何 schema,因此边界在此判定,坏值在加载时就带字段名
+* 失败,而不是等到请求中途。
+* @param config - 原始入口配置。
+* @returns 解析出的连接事实。
+*/
+function resolveConnectionOptions(config = {}) {
+	const positiveInteger = (value, field, fallback) => {
+		if (value === void 0) return fallback;
+		if (!Number.isInteger(value) || value <= 0) throw new Error(`dsh-llm-codebuddy-power: ${field} must be a positive integer`);
+		return value;
+	};
+	const streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? 3e5;
+	if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0) throw new Error("dsh-llm-codebuddy-power: streamIdleTimeoutMs must be a positive finite number");
+	const baseURL = config.baseURL ?? CODEBUDDY_CHAT_BASE;
+	if (baseURL.length === 0) throw new Error("dsh-llm-codebuddy-power: baseURL must not be empty");
+	return {
+		baseURL: baseURL.replace(/\/+$/, ""),
+		defaultContextWindow: positiveInteger(config.defaultContextWindow, "defaultContextWindow", DEFAULT_CONTEXT_WINDOW),
+		defaultMaxTokens: positiveInteger(config.defaultMaxTokens, "defaultMaxTokens", DEFAULT_MAX_TOKENS),
+		streamIdleTimeoutMs
+	};
+}
+/**
+* 解析界面偏好的部署级 base 层。用户设置文档中的写入覆盖它。
+*
+* 与 {@link resolveConnectionOptions} 同理,编程式构造可以绕过任何 schema,
+* 因此坏值在此判定并在加载时失败。
+* @param config - 原始入口配置。
+* @returns 设置命名空间的 base 值。
+*/
+function resolvePrefsBase(config = {}) {
+	const dangerPct = config.dangerPct ?? DEFAULT_CODEBUDDY_SETTINGS.dangerPct;
+	if (!Number.isInteger(dangerPct) || dangerPct < 1 || dangerPct > 100) throw new Error(`dsh-llm-codebuddy-power: dangerPct must be an integer within 1..100`);
+	return {
+		showUsage: config.showUsage ?? DEFAULT_CODEBUDDY_SETTINGS.showUsage,
+		dangerPct,
+		drawToolInMinimal: config.drawToolInMinimal ?? DEFAULT_CODEBUDDY_SETTINGS.drawToolInMinimal
+	};
+}
+/** 挂载插件:解析配置,然后注册路由。 */
+function apply(ctx, config = {}) {
+	const resolved = resolveConnectionOptions(config);
+	const prefsBase = resolvePrefsBase(config);
+	let prefsSource = () => prefsBase;
+	ctx.inject(["settings"], (settingsCtx) => {
+		settingsCtx.settings.installSection(ctx, CODEBUDDY_SETTINGS_NAMESPACE, CodeBuddySettingsSchema, prefsBase, {
+			setSource: (current) => {
+				prefsSource = current;
+			},
+			onChange: () => {}
+		});
+	});
+	const session = new CodeBuddySession(ctx.logger, () => {
+		ctx.emit("llm/adapters-updated");
+	});
+	const adapter = new CodeBuddyAdapter({
+		session,
+		options: () => resolved,
+		resolveAttachments: () => ctx.get("attachments"),
+		resolveOverrides: async (modelId) => {
+			return (await loadOverrides())[modelId];
+		}
+	});
+	ctx.llm.registerAdapter([CODEBUDDY_PROVIDER], adapter);
+	new CodeBuddyAuthService(ctx, session);
+	ctx.inject(["attachments"], (imageCtx) => {
+		const attachments = imageCtx.get("attachments");
+		if (attachments === void 0) return;
+		applyImageTool(imageCtx, session, attachments);
+	});
+	const restrictedAgents = /* @__PURE__ */ new Set();
+	const restrictMinimal = (agent) => {
+		if (prefsSource().drawToolInMinimal || restrictedAgents.has(agent.id)) return;
+		if (ctx.get("agentPresets")?.composedPreset(agent.ctx) !== "minimal") return;
+		try {
+			agent.ctx.tools.restrict({ deny: [CODEBUDDY_DRAW_TOOL] });
+			restrictedAgents.add(agent.id);
+		} catch (error) {
+			ctx.logger.warn(`dsh-codebuddy: could not restrict draw tool for minimal agent: ${String(error)}`);
+		}
+	};
+	ctx.on("agent/created", ({ agent }) => {
+		restrictMinimal(agent);
+	}, { global: true });
+	ctx.on("session/event", (observed, event) => {
+		if (event.type !== "agent-preset/selected") return;
+		const data = event.data;
+		if ((typeof data?.agentPreset === "string" ? data.agentPreset : "") !== "minimal") return;
+		const agent = ctx.agents.get(observed.id);
+		if (agent === void 0) return;
+		restrictMinimal(agent);
+	}, { global: true });
+	const onSessionEvent = (observed, event) => {
+		if (event.type !== "turn/start") return;
+		const parent = observed.header.parentSession;
+		session.observeTurn(String(observed.id), event.data.turn, parent === void 0 ? void 0 : String(parent));
+	};
+	ctx.on("session/event", onSessionEvent, { global: true });
+	const onSessionDisposed = (observed) => {
+		session.forget(String(observed.id));
+	};
+	ctx.on("session/disposed", onSessionDisposed, { global: true });
+	session.isLoggedIn().then((loggedIn) => {
+		if (loggedIn) return;
+		ctx.logger.info("llm-codebuddy-power: no CodeBuddy session stored; sign in through the Settings → CodeBuddy page, or run `dsh plugin --profile web codebuddy-power` (no API key needed).");
+	}).catch(() => {});
+}
+//#endregion
+export { AUTH_PENDING_CODE, BLOCKED_MODEL_IDS, CODEBUDDY_AUTH_CHANNEL, CODEBUDDY_AXIOS_USER_AGENT, CODEBUDDY_CHAT_BASE, CODEBUDDY_DISPLAY_NAME, CODEBUDDY_ENDPOINT, CODEBUDDY_IDE_VERSION, CODEBUDDY_PRODUCT_NAME, CODEBUDDY_PROVIDER, CodeBuddyAdapter, CodeBuddyAuthService, CodeBuddySession, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, LOGIN_POLL_INTERVAL_MS, LOGIN_TIMEOUT_MS, NotLoggedInError, REQUEST_IMAGE_DIMENSION_LADDER, REQUEST_IMAGE_MAX_BYTES, apply, fetchEnterpriseUsage, fetchPersonalUsage, fetchUsage, getStoragePath, hasDisclosedCapacity, httpErrorCode, inject, isBlockedModelId, loadSessionInfo, loadStorage, login, name, parseUsage, removeAccounts, resolveConnectionOptions, resolvePrefsBase, setDefaultAccount, setLastAccount, updateSessionInfo, updateStorage, upsertAccount };