@tnnevol/dsh-zcode 0.0.0-stage → 6.0.0

package/lib/index.js

@@ -0,0 +1,1544 @@
+import { t as ZCodeAuthService } from "./auth-BrDmmPY2.js";
+import { _ as ZCODE_USER_AGENT, d as ZCODE_FAMILIES, f as ZCODE_FAMILY_LABELS, g as ZCODE_PROVIDER_NAME, h as ZCODE_PROVIDER, i as ZCODE_ANTHROPIC_BASE_URLS, l as ZCODE_CLIENT_VERSION, m as ZCODE_ORIGIN, r as ZCODE_ANTHROPIC_BASE_URL, t as DEFAULT_ZCODE_ENDPOINT_PLAN, u as ZCODE_ENDPOINT_PLAN_LABELS } from "./identity-DE3rOYuE.js";
+import { _ as findModel, b as selectableModels, c as thinkingLevelMapOf, d as ZCodeConsoleClient, f as ZCodeConsoleError, g as ZCODE_REASONING_LEVELS, h as zcodeSourceHeaders, i as ZCodeCatalogService, l as toBalanceEntries, m as zcodeModelHeaders, n as ZCODE_FALLBACK_CONTEXT_WINDOW, o as mergeBalanceEntries, p as zcodeMessagesUrl, r as ZCODE_FALLBACK_MAX_TOKENS, s as modelIdsFromBalances, t as ZCODE_BUILTIN_MODEL_IDS, u as toModel, v as modelIdOfCapability, y as normalizeModelId } from "./catalog-Br2Bp6dD.js";
+import { a as ZCODE_ROUTES, i as trustedRequest, n as ZCODE_ORIGIN_NOT_TRUSTED, o as ZCODE_ROUTE_PREFIX, r as registerZCodeRoutes, t as ZCODE_CATALOG_UNAVAILABLE } from "./routes-vzWlp-oN.js";
+import { mkdir, readFile, rm, stat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { createProvider } from "@earendil-works/pi-ai";
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { LlmAdapter, LlmError, ReasoningEffortId, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+//#region ../../packages/dsh-plugin-kit/lib/index.js
+/** group + other 的读/写/执行位（0o077）。 */
+const GROUP_OTHER_BITS = 63;
+/** 属主读位（0o400）。 */
+const OWNER_READ_BIT = 256;
+/**
+* 从 `stat` 结果判定凭据文件可用性（纯函数）。
+*
+* 判定条件 = 「group/other 位为空**且**属主可读」。既有拒绝语义不回退：
+* `644` 等放宽权限的文件继续被拒绝；本条件只在其上补充属主可读位——
+* `0000`（属主也不可读）不再被当作「安全且可读」放行。
+*
+* Windows 没有 POSIX mode，判定在调用方跳过（与上游行为一致）：本函数仍按
+* 位运算给出结论，但 Windows 的 `mode` 不承载 POSIX 语义，调用方应以
+* `process.platform === 'win32'` 为准跳过判定、直接视为可用。
+* @param facts - `stat` 结果（至少含 `mode`）。
+* @returns 三态结论。
+*/
+function assessCredentialMode(facts) {
+	if ((facts.mode & GROUP_OTHER_BITS) !== 0) return "unusable";
+	if ((facts.mode & OWNER_READ_BIT) === 0) return "unusable";
+	return "usable";
+}
+/**
+* 便捷封装：stat 一个凭据文件并给出三态结论。
+* @param stat - 与 `fs.promises.stat` 同形的读取函数（便于测试注入）。
+* @param path - 凭据文件路径。
+* @returns 三态结论；stat 失败且 errno 为 ENOENT 时为 `absent`，其他失败
+*   上抛——非 ENOENT 的读取失败必须暴露（与上游 `isENOENT` 立场一致）。
+*/
+async function assessCredentialFile(stat, path) {
+	try {
+		return assessCredentialMode(await stat(path));
+	} catch (error) {
+		if (error?.code === "ENOENT") return "absent";
+		throw error;
+	}
+}
+/**
+* 生成「属主不可读」场景的可诊断错误信息。
+*
+* 与上游对权限过宽的既有文案同构（`... is readable beyond its owner (mode
+* 644); run "chmod 600 ..."`），补充属主不可读的分支。信息只含路径与权限位，
+* 不含凭据内容。
+* @param path - 凭据文件路径。
+* @param mode - 当前权限位。
+* @param context - 出错场景前缀（如 `codebuddy-auth` / `credentials-local`）。
+* @returns 可直接 throw / 上报的错误。
+*/
+function ownerUnreadableError(path, mode, context) {
+	const octal = (mode & 511).toString(8).padStart(3, "0");
+	return /* @__PURE__ */ new Error(`${context}: ${path} is not readable by its owner (mode ${octal}); run "chmod 600 ${path}" before starting again`);
+}
+//#endregion
+//#region src/host/credentials.ts
+/**
+* ZCode 凭据的宿主侧持久化。
+*
+* 只由本插件读写：账号 JWT 与家族 access token 落在一个属主可读的文件里
+* （0600，目录 0700），并通过 `@tnnevol/dsh-plugin-kit` 的共享判定拒绝 group/other
+* 位被放宽或被写成不可读的旧文件。浏览器侧永远拿不到凭据内容。
+*
+* @module dsh-zcode/credentials
+*/
+/** 凭据文件名（位于 DSH home 下）。 */
+const ZCODE_AUTH_FILENAME = ".dsh-zcode-auth.json";
+const AUTH_FORMAT_VERSION = 1;
+const ALLOWED_KEYS = /* @__PURE__ */ new Set([
+	"version",
+	"family",
+	"zcodeJwt",
+	"accessToken",
+	"refreshToken",
+	"expiresAt",
+	"userId",
+	"email",
+	"name",
+	"avatar"
+]);
+function isENOENT(error) {
+	return error?.code === "ENOENT";
+}
+/** 解析落盘文档；任何不认识的字段都视为格式漂移，直接拒绝而不是忽略。 */
+function parseDocument(text, filename) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch {
+		throw new Error(`zcode-auth: ${filename} 不是合法 JSON`);
+	}
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`zcode-auth: ${filename} 必须是对象`);
+	const document = value;
+	if (document.version !== AUTH_FORMAT_VERSION) throw new Error(`zcode-auth: ${filename} 的格式版本 ${String(document.version)} 不受支持`);
+	const raw = document.credential;
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new Error(`zcode-auth: ${filename} 缺少 credential 对象`);
+	const credential = raw;
+	for (const key of Object.keys(credential)) if (!ALLOWED_KEYS.has(key)) throw new Error(`zcode-auth: ${filename} 含未知字段 ${key}`);
+	if (credential.family !== "bigmodel" && credential.family !== "zai") throw new Error(`zcode-auth: ${filename} 的 family 必须是 bigmodel 或 zai`);
+	if (typeof credential.zcodeJwt !== "string" || credential.zcodeJwt.length === 0) throw new Error(`zcode-auth: ${filename} 的 zcodeJwt 必须是非空字符串`);
+	for (const optional of [
+		"accessToken",
+		"refreshToken",
+		"userId",
+		"email",
+		"name",
+		"avatar"
+	]) {
+		const field = credential[optional];
+		if (field !== void 0 && typeof field !== "string") throw new Error(`zcode-auth: ${filename} 的 ${optional} 必须是字符串`);
+	}
+	const expiresAt = credential.expiresAt;
+	if (expiresAt !== void 0 && (typeof expiresAt !== "number" || !Number.isFinite(expiresAt) || expiresAt <= 0)) throw new Error(`zcode-auth: ${filename} 的 expiresAt 必须是正数`);
+	return {
+		version: AUTH_FORMAT_VERSION,
+		credential
+	};
+}
+/** 凭据文件路径。 */
+function zcodeAuthPath(dshHome) {
+	return resolve(join(resolveDshHome(dshHome), ZCODE_AUTH_FILENAME));
+}
+/** 校验属主权限；Windows 无 POSIX mode，跳过。 */
+async function assertOwnerOnly(filename) {
+	if (process.platform === "win32") return;
+	if (await assessCredentialFile((target) => stat(target), filename) !== "unusable") return;
+	const mode = (await stat(filename)).mode;
+	throw ownerUnreadableError(filename, mode, "zcode-auth");
+}
+/** 文件落盘的账号凭据存储。 */
+var ZCodeCredentialStore = class {
+	filename;
+	constructor(filename = zcodeAuthPath()) {
+		this.filename = resolve(filename);
+	}
+	/** 读取当前凭据；不存在时返回 undefined。 */
+	async read() {
+		await assertOwnerOnly(this.filename);
+		let text;
+		try {
+			text = await readFile(this.filename, "utf8");
+		} catch (error) {
+			if (isENOENT(error)) return void 0;
+			throw error;
+		}
+		return structuredClone(parseDocument(text, this.filename).credential);
+	}
+	/** 覆盖写入凭据（原子写 + 文件锁）。 */
+	async write(credential) {
+		await mkdir(dirname(this.filename), {
+			recursive: true,
+			mode: 448
+		});
+		return withFileLock(this.filename, async () => {
+			const candidate = parseDocument(JSON.stringify({
+				version: AUTH_FORMAT_VERSION,
+				credential
+			}), this.filename);
+			await writeFileAtomic(this.filename, `${JSON.stringify(candidate, null, 2)}\n`, {
+				mode: 384,
+				dirMode: 448
+			});
+			return structuredClone(candidate.credential);
+		});
+	}
+	/** 删除凭据；不存在时静默成功。 */
+	async delete() {
+		await mkdir(dirname(this.filename), {
+			recursive: true,
+			mode: 448
+		});
+		await withFileLock(this.filename, () => rm(this.filename, { force: true }));
+	}
+};
+//#endregion
+//#region src/contracts/preferences.ts
+/**
+* 插件偏好设置契约。
+*
+* 与参考插件不同，这里**没有**「推理端点策略」：ZCode 只有一个 Start Plan
+* 端点，没有按量与套餐之分。留着的两个字段都是纯展示/刷新策略，因此按插件
+* UI 规范第 2 档，用详情页自定义区块承载并持久化到插件自己的文件。
+*
+* @module dsh-zcode/preferences-contract
+*/
+const DEFAULT_ZCODE_PREFERENCES = {
+	usageVisibility: "auto",
+	refreshMinutes: 15,
+	hiddenModels: [],
+	endpointPlan: DEFAULT_ZCODE_ENDPOINT_PLAN
+};
+/** 合法刷新间隔范围（分钟）；下限 1 避免把额度接口打成轮询。 */
+const ZCODE_REFRESH_MINUTES = {
+	min: 0,
+	max: 240
+};
+/** 规范化任意输入；非法字段回落到默认值，绝不抛给调用方。 */
+function normalizePreferences(value) {
+	const source = value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+	const visibility = source.usageVisibility;
+	const usageVisibility = visibility === "always" || visibility === "off" || visibility === "auto" ? visibility : DEFAULT_ZCODE_PREFERENCES.usageVisibility;
+	const rawMinutes = source.refreshMinutes;
+	const refreshMinutes = typeof rawMinutes === "number" && Number.isFinite(rawMinutes) ? Math.max(ZCODE_REFRESH_MINUTES.min, Math.min(ZCODE_REFRESH_MINUTES.max, Math.round(rawMinutes))) : DEFAULT_ZCODE_PREFERENCES.refreshMinutes;
+	const hiddenModels = Array.isArray(source.hiddenModels) ? [...new Set(source.hiddenModels.filter((id) => typeof id === "string" && id.length > 0 && id.length <= 200))] : [];
+	const rawPlan = source.endpointPlan;
+	return {
+		usageVisibility,
+		refreshMinutes,
+		hiddenModels,
+		endpointPlan: rawPlan === "ultra" || rawPlan === "start-plan" ? rawPlan : DEFAULT_ZCODE_PREFERENCES.endpointPlan
+	};
+}
+//#endregion
+//#region src/host/preferences.ts
+/**
+* 插件偏好的宿主侧持久化。
+*
+* 与凭据分开存放：偏好不是秘密，但也只由插件自己读写；损坏或字段漂移时
+* 回落到默认值，避免一个坏文件让详情页整块不可用。
+*
+* @module dsh-zcode/preferences
+*/
+/** 偏好文件名（位于 DSH home 下）。 */
+const ZCODE_PREFERENCES_FILENAME = ".dsh-zcode-preferences.json";
+/** 偏好文件路径。 */
+function zcodePreferencesPath(dshHome) {
+	return resolve(join(resolveDshHome(dshHome), ZCODE_PREFERENCES_FILENAME));
+}
+/** 文件落盘的偏好存储。 */
+var ZCodePreferencesStore = class {
+	filename;
+	constructor(filename = zcodePreferencesPath()) {
+		this.filename = resolve(filename);
+	}
+	/** 读取偏好；文件缺失或内容不可解析时返回默认值。 */
+	async read() {
+		let text;
+		try {
+			text = await readFile(this.filename, "utf8");
+		} catch {
+			return DEFAULT_ZCODE_PREFERENCES;
+		}
+		try {
+			return normalizePreferences(JSON.parse(text));
+		} catch {
+			return DEFAULT_ZCODE_PREFERENCES;
+		}
+	}
+	/** 合并写入偏好；返回落盘后的完整值。 */
+	async write(patch) {
+		const next = normalizePreferences({
+			...await this.read(),
+			...patch !== null && typeof patch === "object" && !Array.isArray(patch) ? patch : {}
+		});
+		await mkdir(dirname(this.filename), {
+			recursive: true,
+			mode: 448
+		});
+		await writeFileAtomic(this.filename, `${JSON.stringify(next, null, 2)}\n`, {
+			mode: 384,
+			dirMode: 448
+		});
+		return next;
+	}
+};
+//#endregion
+//#region src/host/start-plan-prefix.ts
+/**
+* Start Plan 端点的准入前缀。
+*
+* 实测结论（2026-10-25，抓包 + 逐项二分）：`/api/v1/zcode-plan/anthropic`
+* 会在网关侧校验 `system` 是否为官方 agent 原文——两段内容必须逐字一致，
+* `system[0]` 少一个字母都会被判 `3012`；`system[1]` 必须作为完整前缀出现，
+* 其后可以继续追加内容。除此之外请求头只需要三个，工具声明、metadata、
+* device_id 与各类 `x-zcode-*` 头都与放行无关。
+*
+* 这两段文字是 ZCode 官方 agent 的系统提示词。插件把它们作为**前缀**放在
+* 自己构造的 system 之前，以满足该校验；DSH 自己的指令接在其后。
+* 上游若改动提示词，这里会失配并退回 `3012`，届时需要重新采集。
+*
+* @module dsh-zcode/start-plan-prefix
+*/
+/** 第一段：固定 42 字符的 agent 身份行，必须逐字一致。 */
+const START_PLAN_PREFIX_HEAD = "You are ZCode, an interactive coding agent";
+/**
+* 第二段：官方 agent 的行为提示词，必须作为完整前缀出现。
+*
+* 只做前缀匹配，因此可以在它之后追加插件自己的约束。
+*/
+const START_PLAN_PREFIX_BODY = "\nYou are an interactive ZCode agent that helps users with software engineering tasks.\n\nIMPORTANT: Assist with authorized security testing, defensive security, CTF challenges, and educational contexts. Refuse requests for destructive techniques, DoS attacks, mass targeting, supply chain compromise, or detection evasion for malicious purposes. Dual-use security tools (C2 frameworks, credential testing, exploit development) require clear authorization context: pentesting engagements, CTF competitions, security research, or defensive use cases.\n\n# Harness\n- Text you output outside of tool use is displayed to the user as Github-flavored markdown in a terminal.\n- Tools run behind a user-selected permission mode; a denied call means the user declined it — adjust, don't retry verbatim.\n- The system may send updates, reminders, or modifications to rules via mid-conversation system turns. These are system-controlled, unlike function results. Hooks may intercept tool calls; treat hook output as user feedback.\n- Prefer the dedicated file/search tools over shell commands when one fits. Independent tool calls can run in parallel in one response.\n- Reference code as `file_path:line_number` — it's clickable.";
+/** 注入到 system 最前面的两段前缀。 */
+function startPlanSystemPrefix() {
+	return [{
+		type: "text",
+		text: START_PLAN_PREFIX_HEAD
+	}, {
+		type: "text",
+		text: START_PLAN_PREFIX_BODY
+	}];
+}
+//#endregion
+//#region src/host/http/messages-client.ts
+/** 限流退避：与官方客户端同一曲线（2s 起、上限 60s、带抖动）。 */
+const RATE_LIMIT_BASE_MS = 2e3;
+const RATE_LIMIT_MAX_MS = 6e4;
+/** 单次请求最多尝试几轮（含首次）。 */
+const RATE_LIMIT_MAX_ATTEMPTS = 5;
+/**
+* 官方限流/繁忙类业务码。
+*
+* 依据上游 `docs/start-plan-provider-business-errors.md`：
+* - `3008`/`3009`/`3010` 是**并发上限**（系统繁忙），不是配额问题；
+* - `1005` 是配额耗尽，模型层**不可重试**；
+* - `3007` 是安全校验拒绝，重试没有意义。
+* 把这些混成一个「429 就重试」会让配额耗尽的用户白等，也会掩盖安全校验失败。
+*/
+const CONCURRENCY_LIMIT_CODES = [
+	"3008",
+	"3009",
+	"3010"
+];
+const QUOTA_EXHAUSTED_CODES = ["1005"];
+const SECURITY_REJECT_CODES = ["3007"];
+const RETRYABLE_RATE_LIMIT_CODES = [
+	"rate_limit_reached_error",
+	"rate_limit_error",
+	"overloaded_error"
+];
+/** 把上游 usage 投影成 DSH 计数（字段互斥）。 */
+function toUsage(raw) {
+	const value = raw ?? {};
+	const num = (key) => {
+		const field = value[key];
+		return typeof field === "number" && Number.isFinite(field) ? field : void 0;
+	};
+	const cacheRead = num("cache_read_input_tokens") ?? num("cacheReadInputTokens");
+	const cacheWrite = num("cache_creation_input_tokens") ?? num("cacheCreationInputTokens");
+	return {
+		inputTokens: num("input_tokens") ?? num("inputTokens") ?? 0,
+		outputTokens: num("output_tokens") ?? num("outputTokens") ?? 0,
+		...cacheRead === void 0 ? {} : { cacheReadTokens: cacheRead },
+		...cacheWrite === void 0 ? {} : { cacheWriteTokens: cacheWrite }
+	};
+}
+/** 组装请求体：把 DSH system 接在官方前缀之后，并补齐官方附加字段。 */
+function buildMessagesBody(request, prefix) {
+	const second = request.system === void 0 || request.system.trim() === "" ? prefix.body : `${prefix.body}\n\n${request.system}`;
+	const thinkingEnabled = request.thinking !== false;
+	return {
+		model: request.model,
+		max_tokens: request.maxTokens,
+		stream: true,
+		system: [{
+			type: "text",
+			text: prefix.head,
+			cache_control: { type: "ephemeral" }
+		}, {
+			type: "text",
+			text: second,
+			cache_control: { type: "ephemeral" }
+		}],
+		messages: request.messages,
+		...request.tools === void 0 || request.tools.length === 0 ? {} : { tools: request.tools },
+		tool_choice: { type: "auto" },
+		metadata: { user_id: JSON.stringify({
+			device_id: request.deviceId,
+			account_uuid: "",
+			session_id: normalizeTaskId(request.sessionId, request.deviceId)
+		}) },
+		...thinkingEnabled ? { thinking: { type: "enabled" } } : {},
+		...thinkingEnabled ? { output_config: { effort: request.effort ?? "max" } } : {},
+		...request.temperature === void 0 ? {} : { temperature: request.temperature }
+	};
+}
+/**
+* 计算第 `attempt` 次限流重试的等待时间。
+*
+* 上游给了 `Retry-After` 就听它的（这是唯一能真正避开限流的信号）；没给则按
+* 2s→4s→8s… 指数退避并加抖动——多个请求同时重试仍会撞车，抖动用来错开。
+*/
+function rateLimitDelayMs(attempt, retryAfterSeconds) {
+	if (retryAfterSeconds !== void 0 && Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0) return Math.min(RATE_LIMIT_MAX_MS, Math.round(retryAfterSeconds * 1e3));
+	const raw = Math.min(RATE_LIMIT_MAX_MS, RATE_LIMIT_BASE_MS * 2 ** (attempt - 1));
+	return Math.round(raw * (.5 + .5 * Math.random()));
+}
+/**
+* 这次限流是否值得重试。
+*
+* 官方把限流分两类：瞬时的（`rate_limit_reached_error` / `overloaded_error`）可以退避
+* 重试；额度耗尽类的（`organization_spend_limit_exceeded` 等）重试多少次都没用，
+* 必须直接失败让用户处理。混为一谈会让额度用尽的用户白等五轮。
+*/
+function isRetryableRateLimit(status, businessCode) {
+	if (businessCode !== void 0 && (QUOTA_EXHAUSTED_CODES.includes(businessCode) || SECURITY_REJECT_CODES.includes(businessCode))) return false;
+	if (businessCode !== void 0 && CONCURRENCY_LIMIT_CODES.includes(businessCode)) return true;
+	if (status !== 429 && status !== 503) return false;
+	if (businessCode === void 0) return true;
+	if (RETRYABLE_RATE_LIMIT_CODES.includes(businessCode)) return true;
+	return false;
+}
+/** 可被 signal 打断的等待。 */
+async function sleep(ms, signal) {
+	await new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("ZCode: 请求已取消"));
+		};
+		if (signal?.aborted === true) {
+			clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("ZCode: 请求已取消"));
+			return;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/** 把失败翻译成用户能据以行动的一句话。 */
+function describeFailure(status, text, businessCode) {
+	if (businessCode !== void 0 && QUOTA_EXHAUSTED_CODES.includes(businessCode)) return "ZCode 额度已用尽（1005）：请等待额度重置或升级账户，重试不会恢复。";
+	if (businessCode !== void 0 && SECURITY_REJECT_CODES.includes(businessCode)) return "ZCode 拒绝了本次请求（3007，安全校验）：请检查账号状态后重试。";
+	if (status === 429 || status === 503 || businessCode !== void 0 && CONCURRENCY_LIMIT_CODES.includes(businessCode)) return "当前系统繁忙（ZCode 并发上限）：已自动重试仍未通过，请稍后再试或升级账户。";
+	return `ZCode 请求失败（HTTP ${String(status)}）：${text.slice(0, 300)}`;
+}
+/** 从响应体里尽力取出业务码（上游各端点字段名不统一）。 */
+function businessCodeOf(text) {
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const record = parsed;
+		const inner = typeof record.error === "object" && record.error !== null ? record.error : record;
+		for (const key of [
+			"code",
+			"type",
+			"error_code",
+			"provider_error_code"
+		]) {
+			const value = inner[key];
+			if (typeof value === "string" && value !== "") return value;
+			if (typeof value === "number") return String(value);
+		}
+		return;
+	} catch {
+		return;
+	}
+}
+/** 解析一条 SSE `data:` 载荷；无法识别时返回 undefined。 */
+function parseEvent(payload) {
+	let value;
+	try {
+		value = JSON.parse(payload);
+	} catch {
+		return;
+	}
+	if (typeof value !== "object" || value === null) return void 0;
+	const event = value;
+	switch (event.type) {
+		case "message_start": {
+			const message = event.message ?? {};
+			return {
+				kind: "message-start",
+				model: typeof message.model === "string" ? message.model : "",
+				...message.usage === void 0 ? {} : { usage: toUsage(message.usage) }
+			};
+		}
+		case "content_block_start": {
+			const block = event.content_block ?? {};
+			const index = Number(event.index ?? 0);
+			const blockType = block.type;
+			if (blockType === "tool_use") return {
+				kind: "block-start",
+				index,
+				blockType: "tool_use",
+				...typeof block.id === "string" ? { id: block.id } : {},
+				...typeof block.name === "string" ? { name: block.name } : {}
+			};
+			if (blockType === "thinking" || blockType === "redacted_thinking") return {
+				kind: "block-start",
+				index,
+				blockType: "thinking"
+			};
+			return {
+				kind: "block-start",
+				index,
+				blockType: "text"
+			};
+		}
+		case "content_block_delta": {
+			const delta = event.delta ?? {};
+			const index = Number(event.index ?? 0);
+			switch (delta.type) {
+				case "text_delta": return {
+					kind: "text-delta",
+					index,
+					text: String(delta.text ?? "")
+				};
+				case "thinking_delta": return {
+					kind: "thinking-delta",
+					index,
+					text: String(delta.thinking ?? "")
+				};
+				case "signature_delta": return {
+					kind: "signature-delta",
+					index,
+					signature: String(delta.signature ?? "")
+				};
+				case "input_json_delta": return {
+					kind: "tool-delta",
+					index,
+					id: "",
+					argumentsDelta: String(delta.partial_json ?? "")
+				};
+				default: return;
+			}
+		}
+		case "content_block_stop": return {
+			kind: "block-stop",
+			index: Number(event.index ?? 0)
+		};
+		case "message_delta": {
+			const delta = event.delta ?? {};
+			return {
+				kind: "message-delta",
+				stopReason: typeof delta.stop_reason === "string" ? delta.stop_reason : "end_turn",
+				...event.usage === void 0 ? {} : { usage: toUsage(event.usage) }
+			};
+		}
+		case "error": {
+			const error = event.error ?? {};
+			return {
+				kind: "error",
+				message: typeof error.message === "string" ? error.message : "上游返回错误",
+				...typeof error.type === "string" ? { errorType: error.type } : {}
+			};
+		}
+		default: return;
+	}
+}
+/**
+* 发出请求并按行解析流。
+*
+* 用 `for await` 逐块读，遇到 `data:` 行就解析；`[DONE]` 与空行跳过。
+*/
+async function* streamMessages(request, prefix, fetchImpl = fetch) {
+	const body = JSON.stringify(buildMessagesBody(request, prefix));
+	const headers = {
+		"content-type": "application/json",
+		"anthropic-version": "2023-06-01",
+		authorization: `Bearer ${request.apiKey}`,
+		"x-api-key": request.apiKey,
+		...request.extraHeaders
+	};
+	const url = `${request.baseUrl.replace(/\/+$/u, "")}/v1/messages`;
+	let response;
+	for (let attempt = 1;; attempt += 1) {
+		response = await fetchImpl(url, {
+			method: "POST",
+			headers,
+			body,
+			...request.signal === void 0 ? {} : { signal: request.signal }
+		});
+		if (response.ok) break;
+		const text = await response.text().catch(() => "");
+		if (text.includes("3012")) throw new Error("ZCode 网关拒绝了本次请求（3012）：Start Plan 端点会校验请求里的系统提示词，当前前缀可能已与上游版本不一致，需要重新采集官方提示词。");
+		const businessCode = businessCodeOf(text);
+		if (!(attempt < RATE_LIMIT_MAX_ATTEMPTS && isRetryableRateLimit(response.status, businessCode))) throw new Error(describeFailure(response.status, text, businessCode));
+		const retryAfter = Number(response.headers.get("retry-after") ?? NaN);
+		const delayMs = rateLimitDelayMs(attempt, Number.isFinite(retryAfter) ? retryAfter : void 0);
+		request.onRateLimit?.({
+			attempt,
+			status: response.status,
+			businessCode,
+			delayMs
+		});
+		await sleep(delayMs, request.signal);
+	}
+	if (response.body === null) throw new Error("ZCode 响应缺少可读流");
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const lines = buffer.split("\n");
+		buffer = lines.pop() ?? "";
+		for (const line of lines) {
+			if (!line.startsWith("data:")) continue;
+			const payload = line.slice(5).trim();
+			if (payload === "" || payload === "[DONE]") continue;
+			const event = parseEvent(payload);
+			if (event !== void 0) yield event;
+		}
+	}
+}
+/**
+* 把会话标识规范成上游要求的长度（6–64 字符）。
+*
+* 上游会校验请求任务 ID 的长度，过短的标识直接返回 1204/1214；这里用设备
+* 标识补齐而不是拒绝请求——标识本身只是让网关把请求关联到同一次会话。
+*/
+function normalizeTaskId(sessionId, fallback) {
+	const raw = (sessionId ?? fallback).trim();
+	const seed = raw === "" ? fallback.trim() : raw;
+	if (seed.length >= 6 && seed.length <= 64) return seed;
+	if (seed.length > 64) return seed.slice(0, 64);
+	const padded = `${seed}${fallback}`.replace(/[^\w-]/gu, "");
+	return padded.length >= 6 ? padded.slice(0, 64) : `sess-${padded.padEnd(6, "0")}`;
+}
+//#endregion
+//#region src/host/http/translate.ts
+/** 从消息里取出纯文本（system 消息或拼接用）。 */
+function messageText(message) {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+/** 取出首条 system 消息的文本；没有则返回 undefined。 */
+function leadingSystem(messages) {
+	const first = messages[0];
+	if (first === void 0 || first.role !== "system") return void 0;
+	const text = messageText(first);
+	return text.trim() === "" ? void 0 : text;
+}
+/**
+* 把 DSH 消息转换成 Anthropic 消息数组。
+*
+* - system 消息由调用方单独放进 `system` 字段，这里跳过；
+* - `tool-call` 块转成 `tool_use`；
+* - 工具结果消息转成带 `tool_result` 块的 user 消息（Anthropic 要求如此）；
+* - 图片块转成 base64 image 块（由调用方提供读取字节的能力）。
+*/
+async function toAnthropicMessages(messages, readImage) {
+	const result = [];
+	for (const message of messages) {
+		if (message.role === "system" || message.role === "developer") continue;
+		if (message.role === "tool") {
+			const block = {
+				type: "tool_result",
+				tool_use_id: String(message.toolCallId),
+				content: messageText(message),
+				...message.isError === true ? { is_error: true } : {}
+			};
+			const last = result.at(-1);
+			if (last !== void 0 && last.role === "user" && isToolResultOnly(last)) last.content.push(block);
+			else result.push({
+				role: "user",
+				content: [block]
+			});
+			continue;
+		}
+		const content = typeof message.content === "string" ? [{
+			type: "text",
+			text: message.content
+		}] : message.content;
+		const blocks = [];
+		for (const item of content) switch (item.type) {
+			case "text":
+				if (item.text !== "") blocks.push({
+					type: "text",
+					text: item.text
+				});
+				break;
+			case "reasoning": break;
+			case "tool-call":
+				blocks.push({
+					type: "tool_use",
+					id: String(item.id),
+					name: item.name,
+					input: parseArguments(item.arguments)
+				});
+				break;
+			case "image": {
+				const image = readImage === void 0 ? void 0 : await readImage(item);
+				if (image !== void 0) blocks.push({
+					type: "image",
+					source: {
+						type: "base64",
+						media_type: image.mediaType,
+						data: image.data
+					}
+				});
+				break;
+			}
+		}
+		if (blocks.length === 0) continue;
+		result.push({
+			role: message.role === "assistant" ? "assistant" : "user",
+			content: blocks
+		});
+	}
+	return result;
+}
+/** 工具参数是模型产出的 JSON 字符串；解析失败时给空对象而不是让请求失败。 */
+function parseArguments(raw) {
+	const text = raw.trim();
+	if (text === "") return {};
+	try {
+		return JSON.parse(text);
+	} catch {
+		return {};
+	}
+}
+/** 这条 user 消息是否只承载工具结果（可继续追加）。 */
+function isToolResultOnly(message) {
+	return message.content.every((block) => typeof block === "object" && block !== null && block.type === "tool_result");
+}
+/** DSH 工具声明 → Anthropic tools。 */
+function toAnthropicTools(tools) {
+	if (tools === void 0 || tools.length === 0) return void 0;
+	return tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		input_schema: tool.parameters
+	}));
+}
+/** DSH 思考等级 → Anthropic `output_config.effort`。 */
+function toEffort(level, map) {
+	if (level !== void 0 && map !== void 0) {
+		const mapped = map[level];
+		if (typeof mapped === "string") return mapped;
+	}
+	switch (level) {
+		case "off":
+		case "minimal":
+		case "low": return "low";
+		case "medium":
+		case "high": return "high";
+		case "xhigh":
+		case "max": return "max";
+		default: return "max";
+	}
+}
+//#endregion
+//#region src/host/http/adapter.ts
+/**
+* `dsh-zcode` 的 HTTP 执行通道：自行收发 Anthropic Messages。
+*
+* 为什么不用 pi-ai：网关要求 `system` 是官方 agent 的**两段独立文本块**，而
+* pi-ai 会把 system 拼成单块且没有可用的改写点（详见 `messages-client.ts`）。
+* 这条通道自己组装请求，因此能精确满足该要求。
+*
+* 模型元数据（上下文窗口、思考等级、模态）仍由同一目录快照提供，与 HTTP
+* 通道之外的部分保持一致。
+*
+* @module dsh-zcode/http/adapter
+*/
+/** 自行发送的适配器。 */
+var ZCodeHttpAdapter = class extends LlmAdapter {
+	options;
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: ZCODE_PROVIDER_NAME
+		};
+	}
+	async listModels(provider) {
+		return this.options.models().map((model) => ({
+			provider,
+			id: model.id,
+			name: model.name,
+			...model.inputModalities === void 0 ? {} : { inputModalities: [...model.inputModalities] }
+		}));
+	}
+	async resolveModel(provider, model) {
+		const found = this.options.models().find((candidate) => candidate.id === model);
+		if (found === void 0) throw new LlmError(`dsh-zcode: 未知模型 "${model}"`, "UNKNOWN_MODEL");
+		return {
+			provider,
+			id: found.id,
+			name: found.name,
+			context: { contextWindow: found.contextWindow },
+			defaultMaxTokens: found.maxTokens,
+			...found.inputModalities === void 0 ? {} : { inputModalities: [...found.inputModalities] },
+			...found.reasoning && found.efforts !== void 0 ? { reasoning: {
+				efforts: found.efforts.map((effort) => ({ ...effort })),
+				...found.efforts.length === 0 ? {} : { defaultEffort: found.efforts[found.efforts.length - 1].id }
+			} } : {}
+		};
+	}
+	async *stream(options) {
+		const model = this.options.models().find((candidate) => candidate.id === options.model);
+		if (model === void 0) throw new LlmError(`dsh-zcode: 未知模型 "${options.model}"`, "UNKNOWN_MODEL");
+		const apiKey = await this.options.apiKey();
+		if (apiKey === void 0 || apiKey.length === 0) throw new LlmError("ZCode 凭据不可用：请先在插件详情页登录 ZCode 账号", "MISSING_CREDENTIAL");
+		const plan = this.options.baseUrl().includes("/ultra/") ? "ultra" : "start-plan";
+		const request = {
+			baseUrl: this.options.baseUrl(),
+			apiKey,
+			model: model.id,
+			maxTokens: options.maxTokens ?? model.maxTokens,
+			system: options.system ?? leadingSystem(options.messages),
+			messages: await toAnthropicMessages(options.messages, this.options.readImage),
+			tools: toAnthropicTools(options.tools),
+			effort: toEffort(resolveEffort(options.reasoningEffort, model), model.thinkingLevelMap),
+			thinking: model.reasoning,
+			deviceId: this.options.deviceId(),
+			...options.sessionId === void 0 ? {} : { sessionId: String(options.sessionId) },
+			...options.temperature === void 0 ? {} : { temperature: options.temperature },
+			...options.signal === void 0 ? {} : { signal: options.signal },
+			...this.options.headers === void 0 ? {} : { extraHeaders: this.options.headers() },
+			onRateLimit: (info) => {
+				this.options.logger?.warn(`dsh-zcode: 触发限流（HTTP ${String(info.status)}${info.businessCode === void 0 ? "" : `, ${info.businessCode}`}），第 ${String(info.attempt)} 次重试前等待 ${String(Math.round(info.delayMs / 1e3))} 秒`);
+			}
+		};
+		const prefix = plan === "start-plan" ? {
+			head: START_PLAN_PREFIX_HEAD,
+			body: START_PLAN_PREFIX_BODY
+		} : {
+			head: "",
+			body: ""
+		};
+		const blocks = /* @__PURE__ */ new Map();
+		let usage = {
+			inputTokens: 0,
+			outputTokens: 0
+		};
+		let stopReason = "end_turn";
+		try {
+			for await (const event of streamMessages(request, prefix, this.options.fetchImpl)) switch (event.kind) {
+				case "message-start":
+					if (event.usage !== void 0) usage = mergeUsage(usage, event.usage);
+					break;
+				case "block-start":
+					blocks.set(event.index, {
+						blockType: event.blockType,
+						...event.id === void 0 ? {} : { id: event.id },
+						...event.name === void 0 ? {} : { name: event.name },
+						text: [],
+						arguments: []
+					});
+					if (event.blockType === "thinking") yield {
+						type: "block-start",
+						index: event.index,
+						blockType: "reasoning"
+					};
+					else if (event.blockType === "text") yield {
+						type: "block-start",
+						index: event.index,
+						blockType: "text"
+					};
+					break;
+				case "text-delta":
+					if (event.text !== "") {
+						blocks.get(event.index)?.text.push(event.text);
+						yield {
+							type: "text-delta",
+							index: event.index,
+							text: event.text
+						};
+					}
+					break;
+				case "thinking-delta":
+					if (event.text !== "") {
+						blocks.get(event.index)?.text.push(event.text);
+						yield {
+							type: "reasoning-delta",
+							index: event.index,
+							text: event.text
+						};
+					}
+					break;
+				case "signature-delta": {
+					const state = blocks.get(event.index);
+					if (state !== void 0) state.signature = `${state.signature ?? ""}${event.signature}`;
+					break;
+				}
+				case "tool-delta": {
+					const state = blocks.get(event.index);
+					if (state !== void 0) state.arguments.push(event.argumentsDelta);
+					const id = state?.id ?? `tool-${String(event.index)}`;
+					yield {
+						type: "tool-call-delta",
+						index: event.index,
+						id,
+						...state?.name === void 0 ? {} : { name: state.name },
+						argumentsDelta: event.argumentsDelta
+					};
+					break;
+				}
+				case "block-stop": {
+					const state = blocks.get(event.index);
+					if (state === void 0) break;
+					if (state.blockType === "text") yield {
+						type: "block-end",
+						index: event.index,
+						block: {
+							type: "text",
+							text: state.text.join("")
+						}
+					};
+					else if (state.blockType === "thinking") yield {
+						type: "block-end",
+						index: event.index,
+						block: {
+							type: "reasoning",
+							text: state.text.join("")
+						}
+					};
+					else if (state.blockType === "tool_use" && state.id !== void 0) yield {
+						type: "block-end",
+						index: event.index,
+						block: {
+							type: "tool-call",
+							id: state.id,
+							name: state.name ?? "",
+							arguments: state.arguments.join("")
+						}
+					};
+					break;
+				}
+				case "message-delta":
+					stopReason = event.stopReason;
+					if (event.usage !== void 0) usage = mergeUsage(usage, event.usage);
+					break;
+				case "error":
+					yield {
+						type: "finish",
+						reason: {
+							kind: "error",
+							failure: {
+								message: `ZCode: ${event.message}`,
+								code: "PROVIDER"
+							}
+						}
+					};
+					return;
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (options.signal?.aborted === true) {
+				yield {
+					type: "finish",
+					reason: {
+						kind: "aborted",
+						failure: {
+							message: "ZCode: 请求已取消",
+							code: "ABORTED"
+						}
+					}
+				};
+				return;
+			}
+			this.options.logger?.warn(`zcode: 请求失败 ${message}`);
+			yield {
+				type: "finish",
+				reason: {
+					kind: "error",
+					failure: {
+						message,
+						code: "PROVIDER"
+					}
+				}
+			};
+			return;
+		}
+		yield {
+			type: "usage",
+			usage
+		};
+		const blockReplay = [...blocks.entries()].sort(([a], [b]) => a - b).map(([, state]) => state.signature === void 0 ? null : { signature: state.signature });
+		yield {
+			type: "finish",
+			reason: stopReason === "tool_use" ? { kind: "tool-calls" } : stopReason === "max_tokens" ? { kind: "max-tokens" } : { kind: "stop" },
+			...blockReplay.some((entry) => entry !== null) ? { replayState: {
+				response: { stopReason },
+				blocks: blockReplay
+			} } : {}
+		};
+	}
+	/** 端点策略（诊断用）。 */
+	planOf(baseUrl) {
+		return baseUrl.includes("/ultra/") ? "ultra" : "start-plan";
+	}
+};
+/**
+* 把调用方传入的思考等级收敛到该模型真正可用的档位。
+*
+* 历史会话可能保存了上一版目录里存在、现在被过滤掉的等级（例如上游只支持
+* low/high/max 时，旧值 `xhigh` 已不在候选里）。此时直接透传会让请求带上
+* 一个语义不明的档位，界面也会把它当作显示名原样展示，因此回退到默认档。
+*/
+function resolveEffort(requested, model) {
+	if (requested === void 0) return void 0;
+	const efforts = model.efforts;
+	if (efforts === void 0 || efforts.length === 0) return requested;
+	const available = efforts.map((effort) => String(effort.id));
+	if (available.includes(requested)) return requested;
+	return available[available.length - 1];
+}
+/** 合并两次 usage：上游在 message_start 与 message_delta 各报一部分。 */
+function mergeUsage(base, next) {
+	return {
+		inputTokens: Math.max(base.inputTokens, next.inputTokens),
+		outputTokens: Math.max(base.outputTokens, next.outputTokens),
+		...next.cacheReadTokens === void 0 && base.cacheReadTokens === void 0 ? {} : { cacheReadTokens: next.cacheReadTokens ?? base.cacheReadTokens },
+		...next.cacheWriteTokens === void 0 && base.cacheWriteTokens === void 0 ? {} : { cacheWriteTokens: next.cacheWriteTokens ?? base.cacheWriteTokens }
+	};
+}
+/**
+* 把一个 DSH 思考等级 id 与显示名组成适配器可用的选项。
+*
+* 用官方的品牌构造函数而不是断言，避免手写 `as` 绕过类型约束。
+*/
+function reasoningEffort(id, name) {
+	return {
+		id: ReasoningEffortId(id),
+		name
+	};
+}
+//#endregion
+//#region src/host/provider.ts
+/** 流空闲上限：思考型模型的长停顿不应被误判断流。 */
+const ZCODE_STREAM_IDLE_TIMEOUT_MS = 3e5;
+/** 每个请求的 base64 图片总负载上限（与 DSH 默认一致）。 */
+const ZCODE_MAX_REQUEST_IMAGE_BYTES = 20971520;
+/** 每张请求图片的像素预算（2048 × 2048）。 */
+const ZCODE_REQUEST_IMAGE_PIXEL_BUDGET = 4194304;
+/** 每张请求图片的编码后字节目标。 */
+const ZCODE_REQUEST_IMAGE_MAX_BYTES = 1048576;
+/**
+* 把目录条目投影为 pi-ai 模型。
+*
+* @param model - 目录条目。
+* @param baseURL - 覆盖端点（端点策略决定，见 `ZCodeEndpointPlan`）。
+*/
+function toPiModel(model, baseURL) {
+	return {
+		id: model.id,
+		name: model.name,
+		api: model.api,
+		provider: ZCODE_PROVIDER,
+		baseUrl: baseURL ?? model.baseURL,
+		input: [...model.input],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		reasoning: model.reasoning,
+		contextWindow: model.contextWindow,
+		maxTokens: model.maxTokens,
+		type: "chat",
+		...model.reasoning ? { compat: { forceAdaptiveThinking: true } } : {},
+		...model.thinkingLevelMap === void 0 ? {} : { thinkingLevelMap: { ...model.thinkingLevelMap } }
+	};
+}
+/**
+* 给推理请求补 `authorization` 头。
+*
+* `PiAiAdapter` 把 `resolveApiKey` 的结果写成 `x-api-key`；ZCode 网关的
+* Anthropic 兼容层同时读 `authorization`，官方客户端两者都发。这里在流入口
+* 统一补上，避免只带一个头被网关当成不完整客户端。
+*
+* 必须是同步改写：`stream` / `streamSimple` 的返回类型是直接可迭代的事件流，
+* 不是 Promise；把入口改成 async 会破坏调用方的同步取流契约。
+*/
+function withAuthorizationHeader(streams) {
+	const decorate = (model, options) => {
+		const token = options?.apiKey;
+		if (token === void 0 || token.length === 0) return model;
+		const current = model.headers;
+		return {
+			...model,
+			headers: {
+				...current,
+				authorization: `Bearer ${token}`
+			}
+		};
+	};
+	return {
+		...streams,
+		stream: (model, context, options) => streams.stream(decorate(model, options), context, options),
+		streamSimple: (model, context, options) => streams.streamSimple(decorate(model, options), context, options)
+	};
+}
+/** Anthropic Messages 实现；当前只有这一族。 */
+function zcodeApis() {
+	return { "anthropic-messages": withAuthorizationHeader(anthropicMessagesApi()) };
+}
+function providerAuth(resolveToken) {
+	return { apiKey: {
+		name: "ZCode 账号凭据",
+		async resolve() {
+			const key = await resolveToken();
+			if (key === void 0 || key.length === 0) return void 0;
+			return {
+				auth: { apiKey: key },
+				source: "ZCode 账号登录"
+			};
+		}
+	} };
+}
+/** 构建 provider。 */
+function createZCodeProvider(models, resolveToken, baseURL) {
+	return createProvider({
+		id: ZCODE_PROVIDER,
+		name: ZCODE_PROVIDER_NAME,
+		auth: providerAuth(resolveToken),
+		models: models.map((model) => toPiModel(model, baseURL)),
+		api: zcodeApis()
+	});
+}
+/** 构建供应商 profile。 */
+function createZCodeProfile(models, resolveToken, headers = {}, baseURL) {
+	return {
+		provider: ZCODE_PROVIDER,
+		displayName: ZCODE_PROVIDER_NAME,
+		streamIdleTimeoutMs: ZCODE_STREAM_IDLE_TIMEOUT_MS,
+		maxRequestImageBytes: ZCODE_MAX_REQUEST_IMAGE_BYTES,
+		requestImagePixelBudget: ZCODE_REQUEST_IMAGE_PIXEL_BUDGET,
+		requestImageMaxBytes: ZCODE_REQUEST_IMAGE_MAX_BYTES,
+		retryPolicy: resolveRetryPolicy(void 0, "dsh-zcode retryPolicy"),
+		configuredMaxTokens: /* @__PURE__ */ new Map(),
+		headers: { ...headers },
+		piProvider: createZCodeProvider(models, resolveToken, baseURL),
+		modelErrors: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* 注册并持有唯一的 `dsh-zcode` 路由。
+*
+* 路由被其他适配器占用时记录原因并保持未注册状态，由详情页把冲突说明展示
+* 给用户，而不是让整个插件失效。
+*/
+var ZCodeProviderRuntime = class {
+	options;
+	snapshot = /* @__PURE__ */ new Map();
+	/** HTTP 通道：同时是模型元数据的唯一来源。 */
+	/** 执行通道：自行收发 Anthropic Messages（满足网关对 system 分块的要求）。 */
+	adapter;
+	registration;
+	registered = false;
+	error;
+	currentModels = [];
+	endpointPlan = DEFAULT_ZCODE_ENDPOINT_PLAN;
+	constructor(options) {
+		this.options = options;
+		this.adapter = new ZCodeHttpAdapter({
+			models: () => this.currentModels.map((model) => ({
+				id: model.id,
+				name: model.name,
+				contextWindow: model.contextWindow,
+				maxTokens: model.maxTokens,
+				reasoning: model.reasoning,
+				inputModalities: model.input,
+				...model.thinkingLevelMap === void 0 ? {} : {
+					efforts: reasoningEffortsOf(model.thinkingLevelMap),
+					thinkingLevelMap: model.thinkingLevelMap
+				}
+			})),
+			baseUrl: () => ZCODE_ANTHROPIC_BASE_URLS[this.endpointPlan],
+			apiKey: () => this.options.resolveToken(this.endpointPlan),
+			deviceId: () => this.options.deviceMid(),
+			headers: () => zcodeSourceHeaders(this.options.deviceMid()),
+			readImage: async (block) => {
+				const attachments = this.options.resolveAttachments();
+				if (attachments === void 0) return void 0;
+				try {
+					const stored = await attachments.readImage(block.attachment);
+					return {
+						mediaType: block.attachment.mediaType,
+						data: Buffer.from(stored.data).toString("base64")
+					};
+				} catch (error) {
+					this.options.logger.warn(`dsh-zcode: 读取图片附件失败，已跳过：${error instanceof Error ? error.message : String(error)}`);
+					return;
+				}
+			},
+			logger: this.options.logger
+		});
+	}
+	/** 当前目录模型。 */
+	models() {
+		return this.currentModels;
+	}
+	/** 路由注册状态。 */
+	routeStatus() {
+		return [{
+			id: ZCODE_PROVIDER,
+			name: ZCODE_PROVIDER_NAME,
+			registered: this.registered,
+			...this.error === void 0 ? {} : { error: this.error },
+			modelCount: this.currentModels.length,
+			endpointPlan: this.endpointPlan
+		}];
+	}
+	/** 在插件 fiber 上注册路由。 */
+	register(ctx) {
+		ctx.effect(() => {
+			this.registered = false;
+			this.error = void 0;
+			try {
+				this.registration = ctx.llm.registerAdapter([ZCODE_PROVIDER], this.adapter);
+				this.registered = true;
+			} catch (registerError) {
+				this.error = registerError instanceof Error ? registerError.message : String(registerError);
+				this.options.logger.warn(`dsh-zcode: 无法注册 ${ZCODE_PROVIDER} 路由：${this.error}`);
+			}
+			return () => {
+				this.registration?.();
+				this.registration = void 0;
+				this.registered = false;
+			};
+		}, "dsh-zcode: LLM 路由");
+	}
+	/** 当前端点策略。 */
+	plan() {
+		return this.endpointPlan;
+	}
+	/**
+	* 用新目录与端点策略重建 profile；下一次 LLM 操作即可见。
+	*
+	* 端点策略决定 baseURL 与凭据类型，两者必须一起换：只换端点不换凭据会直接
+	* 401（`ultra` 不接受账号 JWT）。
+	*/
+	update(models, plan = this.endpointPlan) {
+		this.currentModels = models;
+		this.endpointPlan = plan;
+	}
+};
+/**
+* 需要把 Start Plan 的官方提示词前缀注入到请求里。
+*
+* 落点说明：宿主在 `adapterStream` 里做的是
+*   `const call = await adapter.prepareCall(...); dispatch = (o) => call.stream(o)`
+* 也就是说 `prepareCall` 返回的 `stream` 就是最终取流入口。因此包装它即可
+* 影响真正的请求，不需要改上游包、也不需要自己发 HTTP。
+*
+* 之所以不能只重写 `stream()`：设置了 `prepared` 的调用路径不会经过它。
+*/
+/**
+* 选择器里的档位顺序（从弱到强）与显示名。
+*
+* 这是 DSH 的通用档位词表，不是上游词表：一个上游等级可能对应多个档位
+* （例如上游 `low` 同时承接 `minimal` 与 `low`）。
+*/
+const REASONING_EFFORT_LADDER = [
+	{
+		id: "minimal",
+		name: "Minimal"
+	},
+	{
+		id: "low",
+		name: "Low"
+	},
+	{
+		id: "medium",
+		name: "Medium"
+	},
+	{
+		id: "high",
+		name: "High"
+	},
+	{
+		id: "xhigh",
+		name: "Extra High"
+	},
+	{
+		id: "max",
+		name: "Max"
+	}
+];
+/**
+* 把目录的思考等级映射转成选择器可用的档位。
+*
+* 两条规则都是必需的：
+* 1. 映射为 `null` 的等级上游不支持，剔除；否则选中即被拒。
+* 2. **多个档位映射到同一上游值时只保留最强的一档**。DSH 的通用档位词表比
+*    上游更细（`minimal`/`low`、`medium`/`high`、`xhigh`/`max` 常落在同一个上游
+*    值上），把它们全列出来会让用户以为选到了不同强度，实际发出去的请求字节
+*    完全相同——这是「看着能调、其实没调」的假象。
+*
+* 代价：若宿主配置里存着被合并掉的旧值（如 `xhigh`），它会找不到对应项而原样
+* 显示内部 id。请求侧由 `resolveEffort` 兜底到合法档位，不会发错。
+*/
+function reasoningEffortsOf(map) {
+	const supported = REASONING_EFFORT_LADDER.filter((level) => {
+		return typeof map[level.id] === "string";
+	});
+	const claimed = /* @__PURE__ */ new Set();
+	const kept = /* @__PURE__ */ new Set();
+	for (const level of [...supported].reverse()) {
+		const upstream = map[level.id];
+		if (typeof upstream !== "string" || claimed.has(upstream)) continue;
+		claimed.add(upstream);
+		kept.add(level.id);
+	}
+	return supported.filter((level) => kept.has(level.id)).map((level) => reasoningEffort(level.id, level.name));
+}
+//#endregion
+//#region src/contracts/usage.ts
+/** 剩余百分比。 */
+function remainingPercent(window) {
+	return Math.max(0, Math.min(100, 100 - window.percent));
+}
+/** 距离重置的毫秒数；无效或缺失时间返回 undefined。 */
+function resetAfterMs(window, now = Date.now()) {
+	if (window.resetsAt === void 0) return void 0;
+	const at = Date.parse(window.resetsAt);
+	if (!Number.isFinite(at)) return void 0;
+	return Math.max(0, at - now);
+}
+/**
+* 把上游额度换算成百分比。
+*
+* 上游给的是整数 token 单位，可能为 0（活动额度未发放）；此时按 0% 处理而不是
+* 制造 NaN 或 Infinity——界面上「0 / 0」比「NaN%」可读得多。
+*/
+function usagePercent(used, total) {
+	if (!Number.isFinite(used) || !Number.isFinite(total) || total <= 0) return 0;
+	return Math.max(0, Math.min(100, used / total * 100));
+}
+//#endregion
+//#region src/host/usage.ts
+const DEFAULT_CACHE_MS = 6e4;
+/** 额度服务。 */
+var ZCodeUsageService = class {
+	cached;
+	inflight;
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	get now() {
+		return this.options.now?.() ?? Date.now();
+	}
+	/** 失效缓存，强制下次读取走网络。 */
+	invalidate() {
+		this.cached = void 0;
+	}
+	/** 读取额度；`force` 为 true 时跳过缓存。 */
+	async read(force = false) {
+		const cacheMs = this.options.cacheMs ?? DEFAULT_CACHE_MS;
+		if (!force && this.cached !== void 0 && this.now - this.cached.at < cacheMs) return this.cached.result;
+		this.inflight ??= this.load().finally(() => {
+			this.inflight = void 0;
+		});
+		return this.inflight;
+	}
+	async load() {
+		const token = await this.options.resolveToken();
+		if (token === void 0) {
+			const result = {
+				ok: false,
+				reason: "not-signed-in",
+				message: "尚未登录 ZCode 账号"
+			};
+			this.cached = {
+				result,
+				at: this.now
+			};
+			return result;
+		}
+		try {
+			const snapshot = await this.options.client.balance(token);
+			const windows = mergeBalanceEntries(toBalanceEntries(snapshot.balances)).map((entry) => {
+				const percent = usagePercent(entry.usedUnits, entry.totalUnits);
+				return {
+					label: entry.showName,
+					...entry.capability === void 0 ? {} : { capability: entry.capability },
+					totalUnits: entry.totalUnits,
+					usedUnits: entry.usedUnits,
+					remainingUnits: entry.remainingUnits,
+					percent,
+					...entry.period === void 0 ? {} : { period: entry.period },
+					...entry.periodEnd === void 0 ? entry.expiresAt === void 0 ? {} : { resetsAt: new Date(entry.expiresAt).toISOString() } : { resetsAt: new Date(entry.periodEnd).toISOString() },
+					exhausted: entry.remainingUnits <= 0
+				};
+			});
+			const family = await this.options.resolveFamily?.();
+			const result = {
+				ok: true,
+				usage: {
+					plans: snapshot.plans.map((plan) => ({
+						planId: plan.planId,
+						...plan.name === void 0 ? {} : { name: plan.name },
+						...plan.endsAt === void 0 ? {} : { endsAt: plan.endsAt }
+					})),
+					windows,
+					fetchedAt: this.now,
+					...family === void 0 ? {} : { family }
+				}
+			};
+			this.cached = {
+				result,
+				at: this.now
+			};
+			return result;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.options.logger?.warn("dsh-zcode: 读取额度失败", error);
+			const result = {
+				ok: false,
+				reason: "request-failed",
+				message
+			};
+			this.cached = {
+				result,
+				at: this.now
+			};
+			return result;
+		}
+	}
+};
+//#endregion
+//#region src/index.ts
+/** 稳定的宿主插件名。 */
+const name = "dsh-zcode-plugin";
+/**
+* 模型层是硬依赖；Web 路由是可选增强。
+*
+* headless / tui 一类的 profile 没有 `webServer`，插件仍应提供服务；
+* 详情页与同源路由通过 `ctx.inject(['webServer'], …)` 只在 Web 装配下注册。
+* 否则插件会停在 pending，模型路由也不会注册（表现为 `NO_ADAPTER`）。
+*/
+const inject = ["llm"];
+/** 定时刷新的最短间隔（毫秒）；偏好里的 0 表示关闭。 */
+const MIN_REFRESH_INTERVAL_MS = 6e4;
+function apply(ctx) {
+	const credentials = new ZCodeCredentialStore();
+	const preferences = new ZCodePreferencesStore();
+	const client = new ZCodeConsoleClient();
+	let refresh = async () => {};
+	/**
+	* 桌面授权码流程的回调地址。
+	*
+	* 桌面端用 `zcode://oauth/callback` 自定义协议接回调；插件在浏览器里注册不了
+	* 自定义协议，因此回调到插件自己的同源路由，由宿主侧拿 code 换取凭据。
+	* 地址在装配时才能确定（依赖实际监听端口与代理头），所以按需解析。
+	*/
+	const callbackBaseUrl = () => {
+		const configured = process.env.DSH_ZCODE_CALLBACK_URL?.trim() ?? "";
+		return configured === "" ? void 0 : configured;
+	};
+	const auth = new ZCodeAuthService({
+		store: credentials,
+		client,
+		onCredentialChange: () => {
+			refresh(true);
+		},
+		logger: ctx.logger,
+		callbackBaseUrl
+	});
+	const catalog = new ZCodeCatalogService({
+		client,
+		resolveToken: () => auth.zcodeJwt(),
+		resolveFamily: async () => (await auth.credential())?.family,
+		logger: ctx.logger
+	});
+	const runtime = new ZCodeProviderRuntime({
+		resolveToken: async (plan) => plan === "ultra" ? auth.accessToken() : auth.zcodeJwt(),
+		deviceMid: () => client.deviceMid(),
+		resolveAttachments: () => ctx.get("attachments"),
+		logger: ctx.logger
+	});
+	runtime.register(ctx);
+	const usage = new ZCodeUsageService({
+		client,
+		resolveToken: () => auth.zcodeJwt(),
+		resolveFamily: async () => (await auth.credential())?.family,
+		logger: ctx.logger
+	});
+	/** 把目录快照投影成 provider 模型，按「隐藏模型」过滤并按端点策略重建。 */
+	const applyCatalog = async () => {
+		const snapshot = catalog.snapshot();
+		if (snapshot === void 0) return;
+		const prefs = await preferences.read();
+		const hidden = new Set(prefs.hiddenModels);
+		runtime.update(snapshot.models.filter((model) => !hidden.has(model.id)), prefs.endpointPlan);
+	};
+	refresh = async (force) => {
+		usage.invalidate();
+		await (force ? catalog.refresh() : catalog.refreshIfStale());
+		await applyCatalog();
+	};
+	let timer;
+	/** 按偏好重建定时器；偏好变化或首次启动时调用。 */
+	const schedule = async () => {
+		if (timer !== void 0) {
+			clearInterval(timer);
+			timer = void 0;
+		}
+		const prefs = await preferences.read();
+		if (prefs.refreshMinutes <= 0) return;
+		const interval = Math.max(MIN_REFRESH_INTERVAL_MS, prefs.refreshMinutes * 6e4);
+		timer = setInterval(() => {
+			refresh(false).catch(() => void 0);
+		}, interval);
+		timer.unref?.();
+	};
+	ctx.effect(() => {
+		(async () => {
+			try {
+				runtime.update(ZCODE_BUILTIN_MODEL_IDS.map((id) => toModel({
+					id,
+					family: "bigmodel"
+				})), (await preferences.read()).endpointPlan);
+				await refresh(false);
+				await applyCatalog();
+				await schedule();
+			} catch (error) {
+				ctx.logger.warn("dsh-zcode: 初始化模型目录失败", error);
+			}
+		})();
+		return () => {
+			if (timer !== void 0) clearInterval(timer);
+			timer = void 0;
+		};
+	}, "dsh-zcode: 目录与额度刷新");
+	ctx.inject(["webServer"], (scoped) => {
+		registerZCodeRoutes(scoped, {
+			auth,
+			usage,
+			catalog,
+			preferences,
+			refresh,
+			preferencesChanged: async () => {
+				await applyCatalog();
+				await schedule();
+			},
+			routes: () => runtime.routeStatus()
+		});
+	});
+}
+//#endregion
+export { DEFAULT_ZCODE_ENDPOINT_PLAN, DEFAULT_ZCODE_PREFERENCES, START_PLAN_PREFIX_BODY, START_PLAN_PREFIX_HEAD, ZCODE_ANTHROPIC_BASE_URL, ZCODE_ANTHROPIC_BASE_URLS, ZCODE_AUTH_FILENAME, ZCODE_BUILTIN_MODEL_IDS, ZCODE_CATALOG_UNAVAILABLE, ZCODE_CLIENT_VERSION, ZCODE_ENDPOINT_PLAN_LABELS, ZCODE_FALLBACK_CONTEXT_WINDOW, ZCODE_FALLBACK_MAX_TOKENS, ZCODE_FAMILIES, ZCODE_FAMILY_LABELS, ZCODE_ORIGIN, ZCODE_ORIGIN_NOT_TRUSTED, ZCODE_PREFERENCES_FILENAME, ZCODE_PROVIDER, ZCODE_PROVIDER_NAME, ZCODE_REASONING_LEVELS, ZCODE_REFRESH_MINUTES, ZCODE_ROUTES, ZCODE_ROUTE_PREFIX, ZCODE_USER_AGENT, ZCodeAuthService, ZCodeCatalogService, ZCodeConsoleClient, ZCodeConsoleError, ZCodeCredentialStore, ZCodeHttpAdapter, ZCodePreferencesStore, ZCodeProviderRuntime, ZCodeUsageService, apply, buildMessagesBody, createZCodeProfile, createZCodeProvider, findModel, inject, leadingSystem, messageText, modelIdOfCapability, modelIdsFromBalances, name, normalizeModelId, normalizePreferences, parseEvent, registerZCodeRoutes, remainingPercent, resetAfterMs, selectableModels, startPlanSystemPrefix, streamMessages, thinkingLevelMapOf, toAnthropicMessages, toAnthropicTools, toBalanceEntries, toEffort, toModel, toPiModel, toUsage, trustedRequest, usagePercent, zcodeAuthPath, zcodeMessagesUrl, zcodeModelHeaders, zcodePreferencesPath, zcodeSourceHeaders };