@chatcode/cco-llm-chatcode-config 0.1.0

package/lib/index.js

@@ -0,0 +1,4873 @@
+import { n as checkChatCodeStartupGate, r as startupGateFailureMessage, t as ChatCodeStartupGateService } from "./startup-gate-BaCbWaKH.js";
+import { createRequire } from "node:module";
+import { Service } from "@deepseek-ai/cordis";
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, IMAGE_OFFLOAD_REQUIRED_CODE, LlmAdapter, LlmError, QUOTA_EXCEEDED_CODE, ReasoningEffortId, RetryPolicySchema, assertUsableApiKey, attributionHeaders, contentHasImage, isContextWindowExceededError, isQuotaExceededError, offloadedImageText, projectOffloadedImages, requestImageHandleText, requiredImageOffload, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
+import { spawn, spawnSync } from "node:child_process";
+import { emitKeypressEvents } from "node:readline";
+import { stdin, stdout } from "node:process";
+import { homedir, userInfo } from "node:os";
+import { mkdir, open, readFile, readdir, rename, unlink } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+import { InMemoryCredentialStore, createModels, createProvider, defaultProviderAuthContext, getSupportedThinkingLevels, isContextOverflow } from "@earendil-works/pi-ai";
+import { credentialKey, credentialRef } from "@deepseek-ai/dsh-credentials";
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import { getOrCreateAnonymousUserId } from "@deepseek-ai/dsh-anonymous-user-id";
+import { DeepSeekAdapter, resolveAdapterOptions } from "@deepseek-ai/dsh-llm-deepseek";
+import { MAX_TIMER_DELAY_MS, idleWatchdog, timeoutOf } from "@deepseek-ai/dsh-timeout";
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
+import z from "@deepseek-ai/schemastery";
+import { builtinProviders, getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { createHash, randomUUID } from "node:crypto";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
+//#region src/update.ts
+/** Self-update for the global ChatCode CLI installation. @module dsh-llm-chatcode-config/update */
+/**
+* The public ChatCode CLI package owns both browser and terminal surfaces.
+*/
+const CHATCODE_CLI_PACKAGES = ["@chatcode/chatcode-cli"];
+/** Bound one npm call so a stalled registry cannot hang the command forever. */
+const VIEW_TIMEOUT_MS = 2e4;
+const LIST_TIMEOUT_MS = 15e3;
+const INSTALL_TIMEOUT_MS = 12e4;
+/** Print one progress line to the terminal while an update runs. */
+function log(message) {
+	process.stdout.write(`[update] ${message}\n`);
+}
+/**
+* Run one npm invocation and capture its exit code and combined output.
+* Registry, auth, and proxy resolution are npm's own business: no registry is
+* forced, so a project's `.npmrc` (mirror, scoped registry, token) applies.
+* @param args - npm arguments after the `npm` command word.
+* @param timeoutMs - bound on the whole invocation.
+*/
+function runNpm(args, timeoutMs, signal) {
+	return new Promise((resolve) => {
+		const win = process.platform === "win32";
+		const stdio = [
+			"ignore",
+			"pipe",
+			"pipe"
+		];
+		let child;
+		if (win) {
+			const spec = args.map((argument) => /\s/.test(argument) ? JSON.stringify(argument) : argument).join(" ");
+			child = spawn(`npm ${spec}`, {
+				shell: true,
+				stdio
+			});
+		} else child = spawn("npm", args, { stdio });
+		let output = "";
+		let done = false;
+		const settle = (code) => {
+			if (done) return;
+			done = true;
+			clearTimeout(timer);
+			if (signal !== void 0) signal.removeEventListener("abort", onAbort);
+			resolve({
+				code,
+				output
+			});
+		};
+		const timer = setTimeout(() => {
+			child.kill();
+		}, timeoutMs);
+		const onAbort = () => {
+			clearTimeout(timer);
+			child.kill();
+		};
+		if (signal !== void 0) {
+			if (signal.aborted) onAbort();
+			else signal.addEventListener("abort", onAbort, { once: true });
+		}
+		const collect = (chunk) => {
+			output += chunk.toString();
+		};
+		child.stdout?.on("data", collect);
+		child.stderr?.on("data", collect);
+		child.on("error", (error) => {
+			output += String(error);
+			settle(-1);
+		});
+		child.on("close", (code) => {
+			settle(code ?? -1);
+		});
+	});
+}
+/** Strip npm's advisory `npm warn` lines from captured combined output. */
+function cleanNpmOutput(output) {
+	return output.split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== "" && !/^npm warn\b/i.test(line)).join("\n");
+}
+/**
+* Turn npm's noisy combined output into one readable failure line. `--json`
+* errors print `{ "error": { "code", "summary", "detail" } }` on stderr,
+* possibly surrounded by `npm error` prose; lift the first brace block and read
+* the summary from it, else fall back to the cleaned raw text.
+*/
+function describeNpmFailure(output, packageName) {
+	const start = output.indexOf("{");
+	const end = output.lastIndexOf("}");
+	if (start !== -1 && end > start) try {
+		const parsed = JSON.parse(output.slice(start, end + 1));
+		const code = typeof parsed.error?.code === "string" ? parsed.error.code : void 0;
+		const summary = typeof parsed.error?.summary === "string" ? parsed.error.summary : void 0;
+		if (code !== void 0 || summary !== void 0) return `${summary ?? code}（${packageName}）`;
+	} catch {}
+	return `${cleanNpmOutput(output) || "npm view 失败"}（${packageName}）`;
+}
+/**
+* Fetch the latest published version of one package through `npm view`, so the
+* same registry, scoped-registry override, and auth token the installer uses
+* also decide what "latest" means.
+*/
+async function fetchLatestVersion(packageName, signal) {
+	const result = await runNpm([
+		"view",
+		packageName,
+		"version",
+		"--json"
+	], VIEW_TIMEOUT_MS, signal);
+	if (result.code !== 0 || result.output.trim() === "") throw new Error(describeNpmFailure(result.output, packageName));
+	const stdout = cleanNpmOutput(result.output);
+	try {
+		const parsed = JSON.parse(stdout);
+		if (typeof parsed === "string" && parsed !== "") return parsed;
+	} catch {}
+	throw new Error(`无法从 registry 解析最新版本（${packageName}）`);
+}
+/** Best-effort read of one installed package version from a co-located install. */
+function resolveCoLocatedVersion(packageName) {
+	try {
+		const manifest = createRequire(import.meta.url)(`${packageName}/package.json`);
+		return typeof manifest.version === "string" ? manifest.version : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Extract the `--json` result from npm's combined output. npm can prefix
+* advisory `npm warn` lines on stderr (e.g. from a pnpm-injected env config),
+* so lift the first brace block and parse just that, not the whole stream.
+*/
+function parseNpmJson(output) {
+	const start = output.indexOf("{");
+	const end = output.lastIndexOf("}");
+	if (start === -1 || end <= start) return void 0;
+	try {
+		return JSON.parse(output.slice(start, end + 1));
+	} catch {
+		return;
+	}
+}
+/** Resolve one installed global package version through npm's own store. */
+async function resolveGlobalVersion(packageName, signal) {
+	const result = await runNpm([
+		"list",
+		"-g",
+		packageName,
+		"--json",
+		"--depth=0"
+	], LIST_TIMEOUT_MS, signal);
+	if (result.output.trim() === "") return void 0;
+	const version = parseNpmJson(result.output)?.dependencies?.[packageName]?.version;
+	return typeof version === "string" ? version : void 0;
+}
+/**
+* Best-effort read of one installed package version; `undefined` when it cannot
+* be resolved. The co-located probe first targets a dev tree, then falls back
+* to npm's view of the global install.
+*/
+async function resolveCurrentVersion(packageName, signal) {
+	return resolveCoLocatedVersion(packageName) ?? await resolveGlobalVersion(packageName, signal);
+}
+/** Run `npm install -g <specs...>`, letting npm pick the registry it would install from. */
+function runNpmInstall(packageSpecs, signal) {
+	return runNpm([
+		"install",
+		"-g",
+		...packageSpecs
+	], INSTALL_TIMEOUT_MS, signal);
+}
+/**
+* Check the latest version and, when newer than the running one, install the
+* public ChatCode CLI package. Progress lines go to `options.onProgress` when given (the
+* interactive surface renders them in a panel), else to stdout — so the
+* `chatcode-cli --update` sync entry point keeps printing as before. Every awaited step
+* honors `options.signal`: an abort kills the in-flight npm child and settles
+* with the `aborted` status.
+*/
+async function runUpdate(options = {}) {
+	const { signal, onProgress } = options;
+	const progress = (line) => {
+		if (onProgress !== void 0) onProgress(line);
+		else log(line);
+	};
+	const aborted = () => signal?.aborted === true ? {
+		status: "aborted",
+		message: "更新已中止"
+	} : void 0;
+	progress(`开始检查更新：${CHATCODE_CLI_PACKAGES.join("、")}`);
+	const updates = [];
+	for (const name of CHATCODE_CLI_PACKAGES) {
+		if (aborted() !== void 0) return aborted();
+		const current = await resolveCurrentVersion(name, signal);
+		if (aborted() !== void 0) return aborted();
+		progress(`当前版本 ${name}：${current ?? "（未安装或未解析）"}`);
+		let latest;
+		try {
+			latest = await fetchLatestVersion(name, signal);
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			progress(`检查 ${name} 最新版本失败：${detail}`);
+			return {
+				status: "error",
+				message: `检查更新失败：${detail}`
+			};
+		}
+		if (aborted() !== void 0) return aborted();
+		progress(`最新版本 ${name}：${latest}`);
+		updates.push({
+			name,
+			current,
+			latest
+		});
+	}
+	if (!updates.some((update) => update.current !== update.latest)) {
+		const summary = updates.map((update) => `${update.name} ${update.latest}`).join("，");
+		progress("ChatCode CLI 已是最新版本，无需更新");
+		return {
+			status: "up-to-date",
+			message: `ChatCode CLI 已是最新版本（${summary}）`
+		};
+	}
+	const packageSpecs = updates.map((update) => `${update.name}@${update.latest}`);
+	progress(`检测到新版本，开始安装：${packageSpecs.join(" ")}`);
+	const result = await runNpmInstall(packageSpecs, signal);
+	if (aborted() !== void 0) return aborted();
+	if (result.code !== 0) {
+		const detail = cleanNpmOutput(result.output) || "未知错误";
+		progress(`安装失败（exit ${result.code}）`);
+		return {
+			status: "error",
+			message: `更新失败：${detail}\n请手动执行：npm install -g ${packageSpecs.join(" ")}`
+		};
+	}
+	progress("安装完成");
+	return {
+		status: "updated",
+		message: `已更新：${updates.map((update) => `${update.name} ${update.current ?? "(未知)"} → ${update.latest}`).join("，")}，请重启 ChatCode CLI 以生效`
+	};
+}
+/** Run one npm invocation synchronously and capture its exit code and output. */
+function syncRunNpm(args, timeoutMs) {
+	const win = process.platform === "win32";
+	const spec = args.map((argument) => /\s/.test(argument) ? JSON.stringify(argument) : argument).join(" ");
+	const result = win ? spawnSync(`npm ${spec}`, {
+		shell: true,
+		encoding: "utf8",
+		timeout: timeoutMs,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	}) : spawnSync("npm", args, {
+		encoding: "utf8",
+		timeout: timeoutMs,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	if (result.error !== void 0) return {
+		code: -1,
+		output: String(result.error)
+	};
+	return {
+		code: result.status ?? -1,
+		output: `${result.stdout ?? ""}${result.stderr ?? ""}`
+	};
+}
+/**
+* Print one progress line without yielding the event loop. On a Windows
+* console `process.stdout.write` still issues the console write immediately
+* (libuv calls WriteConsoleW synchronously), so the bytes are on screen before
+* the caller's hard exit — and because we never yield, the concurrently booting
+* profile stays frozen and cannot print its own logs.
+*/
+function syncLog(message) {
+	process.stdout.write(`[update] ${message}\n`);
+}
+/** Resolve one installed global package version synchronously through npm's store. */
+function resolveGlobalVersionSync(packageName) {
+	const result = syncRunNpm([
+		"list",
+		"-g",
+		packageName,
+		"--json",
+		"--depth=0"
+	], LIST_TIMEOUT_MS);
+	if (result.output.trim() === "") return void 0;
+	const version = parseNpmJson(result.output)?.dependencies?.[packageName]?.version;
+	return typeof version === "string" ? version : void 0;
+}
+/**
+* Synchronous twin of {@link runUpdate} for `chatcode-cli --update`. Blocking the event
+* loop on purpose: the profile's other plugins boot concurrently with this one,
+* and `chatcode-cli --update` must finish — and exit — before any of them can print.
+* The final message is returned, not logged, so the caller writes it once and
+* picks the exit code.
+*/
+function runUpdateSync() {
+	syncLog(`开始检查更新：${CHATCODE_CLI_PACKAGES.join("、")}`);
+	const updates = [];
+	for (const name of CHATCODE_CLI_PACKAGES) {
+		const current = resolveCoLocatedVersion(name) ?? resolveGlobalVersionSync(name);
+		syncLog(`当前版本 ${name}：${current ?? "（未安装或未解析）"}`);
+		const view = syncRunNpm([
+			"view",
+			name,
+			"version",
+			"--json"
+		], VIEW_TIMEOUT_MS);
+		let latest;
+		if (view.code !== 0 || view.output.trim() === "") {
+			const detail = describeNpmFailure(view.output, name);
+			syncLog(`检查 ${name} 最新版本失败：${detail}`);
+			return {
+				status: "error",
+				message: `检查更新失败：${detail}`
+			};
+		}
+		try {
+			const parsed = JSON.parse(cleanNpmOutput(view.output));
+			if (typeof parsed !== "string" || parsed === "") throw new Error("invalid version payload");
+			latest = parsed;
+		} catch {
+			const detail = `无法从 registry 解析最新版本（${name}）`;
+			syncLog(`检查 ${name} 最新版本失败：${detail}`);
+			return {
+				status: "error",
+				message: `检查更新失败：${detail}`
+			};
+		}
+		syncLog(`最新版本 ${name}：${latest}`);
+		updates.push({
+			name,
+			current,
+			latest
+		});
+	}
+	if (!updates.some((update) => update.current !== update.latest)) {
+		const summary = updates.map((update) => `${update.name} ${update.latest}`).join("，");
+		syncLog("ChatCode CLI 已是最新版本，无需更新");
+		return {
+			status: "up-to-date",
+			message: `ChatCode CLI 已是最新版本（${summary}）`
+		};
+	}
+	const packageSpecs = updates.map((update) => `${update.name}@${update.latest}`);
+	syncLog(`检测到新版本，开始安装：${packageSpecs.join(" ")}`);
+	const install = syncRunNpm([
+		"install",
+		"-g",
+		...packageSpecs
+	], INSTALL_TIMEOUT_MS);
+	if (install.code !== 0) {
+		const detail = cleanNpmOutput(install.output) || "未知错误";
+		syncLog(`安装失败（exit ${install.code}）`);
+		return {
+			status: "error",
+			message: `更新失败：${detail}\n请手动执行：npm install -g ${packageSpecs.join(" ")}`
+		};
+	}
+	syncLog("安装完成");
+	return {
+		status: "updated",
+		message: `已更新：${updates.map((update) => `${update.name} ${update.current ?? "(未知)"} → ${update.latest}`).join("，")}，请重启 ChatCode CLI 以生效`
+	};
+}
+//#endregion
+//#region src/version-check.ts
+/**
+* Startup version admission against the CVP version-validate endpoint.
+*
+* Mirrors the `yuanjing-wanma-cli` startup flow: after launch, ask CVP whether
+* the installed ChatCode CLI package is still usable. When the server reports a newer
+* enabled version (status 1) or a disabled current version with a rollback
+* (status -1), present a keyboard dialog and either install the server-selected
+* version or leave the program before the interactive surface mounts.
+* @module dsh-llm-chatcode-config/version-check
+*/
+const ERROR_CODE = 500;
+function validateUrl(cvpChatCodeApiUrl) {
+	const base = cvpChatCodeApiUrl.replace(/\/+$/u, "");
+	return new URL(`${base}/chatcode/api/v1/cli/version/validate`);
+}
+/**
+* Interpret one 200 JSON body. Returns nothing when the server said "valid",
+* "unknown package/version", or errored — every such case leaves startup alone,
+* matching the reference's fail-open behavior.
+*/
+function decide(body) {
+	if (body.code === ERROR_CODE) return void 0;
+	const data = body.data;
+	const payload = data !== null && typeof data === "object" ? data : body;
+	if (typeof payload.version === "string" && payload.version !== "") {
+		if (payload.status === 1) return {
+			action: "upgrade",
+			version: payload.version
+		};
+		if (payload.status === -1) return {
+			action: "rollback",
+			version: payload.version
+		};
+	}
+}
+async function validatePackage(config, packageName, options) {
+	const resolveVersion = options.resolveVersion ?? resolveCurrentVersion;
+	let versionNum;
+	try {
+		versionNum = await resolveVersion(packageName);
+	} catch {
+		return;
+	}
+	if (versionNum === void 0 || versionNum === "") return void 0;
+	const url = validateUrl(config.cvpChatCodeApiUrl);
+	url.searchParams.set("packageName", packageName);
+	url.searchParams.set("versionNum", versionNum);
+	console.log(`[version-check] 开始校验 ${packageName}@${versionNum}`);
+	const request = options.request ?? fetch;
+	let response;
+	try {
+		response = await request(url, { signal: AbortSignal.timeout(options.timeoutMs ?? 1e4) });
+	} catch (err) {
+		console.log(`[version-check] 请求失败 (${packageName}): ${err?.message ?? err}`);
+		return;
+	}
+	if (!response.ok) return void 0;
+	const body = await response.json().catch(() => void 0);
+	if (body === null || typeof body !== "object") return void 0;
+	const wrapped = decide(body);
+	return wrapped === void 0 ? void 0 : {
+		...wrapped,
+		currentVersion: versionNum
+	};
+}
+/**
+* Validate the ChatCode CLI package and collapse results into one decision.
+* A disabled version wins over an available upgrade: an unusable install must
+* be replaced before any forward update matters.
+*/
+async function checkVersions(config, options = {}) {
+	const outcomes = (await Promise.all(CHATCODE_CLI_PACKAGES.map(async (name) => {
+		const outcome = await validatePackage(config, name, options);
+		return outcome === void 0 ? void 0 : {
+			name,
+			action: outcome.action,
+			currentVersion: outcome.currentVersion,
+			targetVersion: outcome.version
+		};
+	}))).filter((entry) => entry !== void 0);
+	const rollbacks = outcomes.filter((entry) => entry.action === "rollback");
+	if (rollbacks.length > 0) return {
+		action: "rollback",
+		packages: rollbacks.map(({ name, currentVersion, targetVersion }) => ({
+			name,
+			currentVersion,
+			targetVersion
+		}))
+	};
+	const upgrades = outcomes.filter((entry) => entry.action === "upgrade");
+	if (upgrades.length > 0) return {
+		action: "upgrade",
+		packages: upgrades.map(({ name, currentVersion, targetVersion }) => ({
+			name,
+			currentVersion,
+			targetVersion
+		}))
+	};
+}
+/** Install the server-selected versions for one decision. */
+async function runDecisionInstall(decision) {
+	const specs = decision.packages.map((pkg) => `${pkg.name}@${pkg.targetVersion}`);
+	const result = await runNpmInstall(specs);
+	if (result.code !== 0) return {
+		ok: false,
+		message: `安装失败：${result.output.trim() || "未知错误"}\n请手动执行：npm install -g ${specs.join(" ")}`
+	};
+	const summary = decision.packages.map((pkg) => `${pkg.name} ${pkg.targetVersion}`).join("、");
+	return {
+		ok: true,
+		message: `已${decision.action === "upgrade" ? "升级" : "更换"}到 ${summary}，请重启 ChatCode CLI 以生效`
+	};
+}
+/** Localize one decision into the terminal dialog copy. */
+function decisionPrompt(decision) {
+	const targets = decision.packages.map((pkg) => `${pkg.name} ${pkg.targetVersion}`).join("、");
+	if (decision.action === "upgrade") return {
+		title: "版本升级提醒",
+		message: `新版本已发布（${targets}），请升级后再使用。`,
+		performLabel: "升级",
+		cancelLabel: "不升级（退出程序）"
+	};
+	return {
+		title: "版本禁用提醒",
+		message: `当前版本已禁用（${decision.packages.map((pkg) => `${pkg.name} ${pkg.currentVersion}`).join("、")}），请更换到（${targets}）后再使用。`,
+		performLabel: "更换",
+		cancelLabel: "不更换（退出程序）"
+	};
+}
+/**
+* Show a two-option keyboard dialog: up/down arrows move the cursor, Enter
+* chooses. Selecting the first option returns `perform`; the second option or
+* Ctrl+C returns `exit`. Without a TTY there is no menu to read, so it fails
+* open to `exit` and the caller leaves startup untouched.
+*/
+function promptVersionAction(prompt) {
+	if (stdin.isTTY !== true) return Promise.resolve("exit");
+	const labels = [prompt.performLabel, prompt.cancelLabel];
+	return new Promise((resolve) => {
+		let selected = 0;
+		let drawn = 0;
+		const computeDrawn = (lines) => {
+			const cols = stdout.columns || 80;
+			return lines.reduce((total, ln) => {
+				if (ln === "") return total + 1;
+				const width = [...ln].reduce((sum, ch) => sum + (/^[\u1100-\u11ff\u2e80-\ua4cf\uf900-\ufaff\uff00-\uffef]/u.test(ch) ? 2 : 1), 0);
+				return total + Math.max(1, Math.ceil(width / cols));
+			}, 0);
+		};
+		const render = () => {
+			const lines = [
+				prompt.title,
+				prompt.message,
+				"",
+				...labels.map((label, index) => index === selected ? `> ${label}` : `  ${label}`)
+			];
+			if (drawn > 0) stdout.write(`\x1b[${drawn}A\x1b[0J`);
+			stdout.write(`${lines.join("\n")}\n`);
+			drawn = computeDrawn(lines);
+		};
+		const finish = (value) => {
+			if (stdin.isTTY === true) stdin.setRawMode(false);
+			stdin.pause();
+			stdin.off("keypress", onKeypress);
+			stdout.write("\n");
+			resolve(value);
+		};
+		const onKeypress = (_chunk, key) => {
+			if (key.ctrl && key.name === "c") {
+				finish("exit");
+				return;
+			}
+			if (key.name === "up") {
+				selected = selected === 0 ? labels.length - 1 : selected - 1;
+				render();
+				return;
+			}
+			if (key.name === "down") {
+				selected = selected === labels.length - 1 ? 0 : selected + 1;
+				render();
+				return;
+			}
+			if (key.name === "return") finish(selected === 0 ? "perform" : "exit");
+		};
+		emitKeypressEvents(stdin);
+		stdin.setRawMode(true);
+		stdin.resume();
+		stdin.on("keypress", onKeypress);
+		render();
+	});
+}
+//#endregion
+//#region vendor/dsh-llm-pi-ai/src/auth.ts
+/**
+* Create private auth storage for adapters whose explicit source owns every credential.
+* @returns an empty in-memory store and provider auth context, independent of ChatCode CLI login records.
+*/
+function isolatedPiAiAuth() {
+	return {
+		credentials: new InMemoryCredentialStore(),
+		authContext: defaultProviderAuthContext()
+	};
+}
+//#endregion
+//#region vendor/dsh-llm-pi-ai/src/replay.ts
+/**
+* Durable pi-ai replay metadata and assistant-history reconstruction.
+*
+* ChatCode CLI content remains the durable source for text and tool calls. This
+* module stores only the provider-native metadata needed to reconstruct a
+* pi-ai assistant message on a later request.
+*
+* @module dsh-llm-pi-ai/replay
+*/
+/** Parse tool-call argument JSON; tolerate model malformations with {}. */
+function parseArguments(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+/** Construct the zero usage value required by historical pi-ai messages. */
+function emptyPiUsage() {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+/**
+* Project a successful pi-ai response into the minimal durable replay state.
+* The per-block half is index-aligned with the streamed blocks (pi-ai content
+* order), so `BlockAssembler` prunes an entry with its block whenever assembly
+* removes one.
+* @param message - completed native pi-ai assistant response.
+* @returns the versioned lossless-JSON replay projection.
+*/
+function toPiReplayState(message) {
+	return {
+		response: {
+			kind: "pi-ai",
+			version: 2,
+			api: message.api,
+			provider: message.provider,
+			model: message.model,
+			...message.responseModel === void 0 ? {} : { responseModel: message.responseModel },
+			...message.responseId === void 0 ? {} : { responseId: message.responseId },
+			stopReason: message.stopReason
+		},
+		blocks: message.content.map((block) => {
+			switch (block.type) {
+				case "text": return {
+					type: "text",
+					...block.textSignature === void 0 ? {} : { textSignature: block.textSignature }
+				};
+				case "thinking": return {
+					type: "reasoning",
+					...block.thinkingSignature === void 0 ? {} : { thinkingSignature: block.thinkingSignature },
+					...block.redacted === void 0 ? {} : { redacted: block.redacted }
+				};
+				case "toolCall": return {
+					type: "tool-call",
+					...block.thoughtSignature === void 0 ? {} : { thoughtSignature: block.thoughtSignature }
+				};
+			}
+		})
+	};
+}
+function invalidReplay(message) {
+	throw new LlmError(`invalid pi-ai replay state: ${message}`, "INVALID_REPLAY_STATE");
+}
+/** Validate the durable adapter-private envelope before it reaches pi-ai. */
+function readReplayState(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return invalidReplay("expected a replay envelope");
+	const envelope = value;
+	const rawResponse = envelope["response"];
+	if (typeof rawResponse !== "object" || rawResponse === null || Array.isArray(rawResponse)) return invalidReplay("expected a response object");
+	const response = rawResponse;
+	if (response["kind"] !== "pi-ai") return invalidReplay("unknown state kind");
+	if (response["version"] !== 2) return invalidReplay(`unsupported version ${String(response["version"])}`);
+	for (const key of [
+		"api",
+		"provider",
+		"model"
+	]) if (typeof response[key] !== "string" || response[key].length === 0) return invalidReplay(`${key} must be a non-empty string`);
+	if (![
+		"stop",
+		"length",
+		"toolUse",
+		"error",
+		"aborted"
+	].includes(String(response["stopReason"]))) return invalidReplay("unknown stopReason");
+	if (response["responseModel"] !== void 0 && typeof response["responseModel"] !== "string") return invalidReplay("responseModel must be a string");
+	if (response["responseId"] !== void 0 && typeof response["responseId"] !== "string") return invalidReplay("responseId must be a string");
+	const blocks = envelope["blocks"];
+	if (!Array.isArray(blocks)) return invalidReplay("blocks must be an array");
+	for (const [index, value] of blocks.entries()) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return invalidReplay(`block ${index} must be an object`);
+		const block = value;
+		if (![
+			"text",
+			"reasoning",
+			"tool-call"
+		].includes(String(block["type"]))) return invalidReplay(`block ${index} has an unknown type`);
+		for (const signature of [
+			"textSignature",
+			"thinkingSignature",
+			"thoughtSignature"
+		]) if (block[signature] !== void 0 && typeof block[signature] !== "string") return invalidReplay(`block ${index} ${signature} must be a string`);
+		if (block["redacted"] !== void 0 && typeof block["redacted"] !== "boolean") return invalidReplay(`block ${index} redacted must be boolean`);
+	}
+	return {
+		response,
+		blocks
+	};
+}
+/** Convert provider-neutral blocks without trusting them as same-model replay. */
+function foreignAssistant(message) {
+	const source = message.source.kind === "model" ? message.source : void 0;
+	const content = [];
+	for (const block of message.content) switch (block.type) {
+		case "text":
+			content.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "reasoning":
+			content.push({
+				type: "thinking",
+				thinking: block.text
+			});
+			break;
+		case "tool-call":
+			content.push({
+				type: "toolCall",
+				id: block.id,
+				name: block.name,
+				arguments: parseArguments(block.arguments)
+			});
+			break;
+		case "image": throw new LlmError("pi-ai chat history cannot represent structured assistant image output", "UNSUPPORTED_CONTENT");
+	}
+	return {
+		role: "assistant",
+		content,
+		api: "dsh-foreign",
+		provider: source?.provider ?? "dsh-foreign",
+		model: source?.model ?? "dsh-foreign",
+		usage: emptyPiUsage(),
+		stopReason: content.some((piece) => piece.type === "toolCall") ? "toolUse" : "stop",
+		timestamp: 0
+	};
+}
+/** Recombine durable ChatCode CLI content with validated pi-ai replay metadata. */
+function replayedAssistant(message, source, rawState) {
+	const state = readReplayState(rawState);
+	if (state.response.provider !== source.provider) return invalidReplay("provider does not match assistant source");
+	if (state.response.model !== source.model) return invalidReplay("model does not match assistant source");
+	if (state.blocks.length !== message.content.length) return invalidReplay("block count does not match assistant content");
+	return {
+		role: "assistant",
+		content: message.content.map((block, index) => {
+			const replay = state.blocks[index];
+			if (replay === void 0 || replay.type !== block.type) return invalidReplay(`block ${index} does not match assistant content`);
+			switch (block.type) {
+				case "text": return {
+					type: "text",
+					text: block.text,
+					...replay.type === "text" && replay.textSignature !== void 0 ? { textSignature: replay.textSignature } : {}
+				};
+				case "reasoning": return {
+					type: "thinking",
+					thinking: block.text,
+					...replay.type === "reasoning" && replay.thinkingSignature !== void 0 ? { thinkingSignature: replay.thinkingSignature } : {},
+					...replay.type === "reasoning" && replay.redacted !== void 0 ? { redacted: replay.redacted } : {}
+				};
+				case "tool-call": return {
+					type: "toolCall",
+					id: block.id,
+					name: block.name,
+					arguments: parseArguments(block.arguments),
+					...replay.type === "tool-call" && replay.thoughtSignature !== void 0 ? { thoughtSignature: replay.thoughtSignature } : {}
+				};
+				/* v8 ignore next -- readReplayState rejects unknown replay tags, so an equal plugin-added ChatCode CLI tag cannot reach this switch */
+				default: return invalidReplay(`block ${index} has an unsupported ChatCode CLI type`);
+			}
+		}),
+		api: state.response.api,
+		provider: state.response.provider,
+		model: state.response.model,
+		...state.response.responseModel === void 0 ? {} : { responseModel: state.response.responseModel },
+		...state.response.responseId === void 0 ? {} : { responseId: state.response.responseId },
+		usage: emptyPiUsage(),
+		stopReason: state.response.stopReason,
+		timestamp: 0
+	};
+}
+/**
+* Convert one durable ChatCode CLI assistant message into pi-ai history.
+*
+* Durable content is the authoritative record; replay metadata only restores
+* native fidelity (ids, signatures). A replay state this build cannot use —
+* another adapter's kind, another version, a malformed value, or metadata that
+* no longer matches the content — therefore degrades the one message to
+* provider-neutral history instead of failing the request.
+* @param message - assistant content with required source and optional adapter-owned replay metadata.
+* @param onDegrade - called with the diagnostic reason when an unusable replay
+*   state falls back to provider-neutral conversion.
+* @returns a native pi-ai assistant message reconstructed from durable content.
+*/
+function toPiAssistant(message, onDegrade) {
+	const source = message.source;
+	if (source.kind !== "model" || source.replayState === void 0) return foreignAssistant(message);
+	try {
+		return replayedAssistant(message, source, source.replayState);
+	} catch (error) {
+		/* v8 ignore next -- replayedAssistant throws only INVALID_REPLAY_STATE LlmErrors; the
+		guard keeps a future non-replay failure loud instead of silently degrading it */
+		if (!(error instanceof LlmError) || error.code !== "INVALID_REPLAY_STATE") throw error;
+		onDegrade?.(error.message);
+		return foreignAssistant(message);
+	}
+}
+//#endregion
+//#region vendor/dsh-llm-pi-ai/src/catalog.ts
+/**
+* Materialization of one provider route's model catalog. The installed pi-ai
+* catalog supplies defaults keyed by model id, and a profile's own model
+* entries override them field by field, so a route naming a catalog provider
+* stays configuration-free while a route pi-ai has never heard of is fully
+* describable from `settings.yaml`.
+*
+* Every pi-ai `Model` field the harness cannot default is required here rather
+* than at request time: an unserviceable route fails while its configuration is
+* being resolved, which is the earliest point that can name the offending key.
+*
+* @module dsh-llm-pi-ai/catalog
+*/
+/**
+* Pricing for a model the installed catalog does not describe. The harness
+* never reads pi-ai's cost metadata — `replay.ts` zeroes it and no consumer
+* reports spend — so this is the absence of a fact, not a configurable rate.
+*/
+const NO_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+};
+/** Every request modality a profile may declare. */
+const MODALITIES = Object.keys({
+	text: true,
+	image: true
+});
+/**
+* One entry's modality list, or `undefined` when it states no answer. Absent
+* and empty mean the same thing — `[]` describes a model that accepts nothing
+* and could serve no request — which is what makes an entry naming a catalog
+* model without declaring modalities keep the catalog's, since the config
+* schema materializes `[]` for an absent array.
+* @param configured - the list a `models` or `modelOverrides` entry supplied.
+* @returns the declared modalities, or `undefined` to ask the next level.
+*/
+function declaredInput(configured) {
+	return configured === void 0 || configured.length === 0 ? void 0 : [...configured];
+}
+/** Every pi-ai thinking level a profile may declare, in escalation order. */
+const THINKING_LEVELS = Object.keys({
+	off: true,
+	minimal: true,
+	low: true,
+	medium: true,
+	high: true,
+	xhigh: true,
+	max: true
+});
+/** Reasoning-dispatch wire formats a profile may name, most-reached first. */
+const SUPPORTED_THINKING_FORMATS = Object.keys({
+	"openai": true,
+	"deepseek": true,
+	"openrouter": true,
+	"together": true,
+	"baseten": true,
+	"zai": true,
+	"qwen": true,
+	"chat-template": true,
+	"qwen-chat-template": true,
+	"string-thinking": true,
+	"ant-ling": true
+});
+/** The output-cap field spellings a profile may name. */
+const MAX_TOKENS_FIELDS = Object.keys({
+	max_completion_tokens: true,
+	max_tokens: true
+});
+/** The prompt-cache marker conventions a profile may name. */
+const CACHE_CONTROL_FORMATS = Object.keys({ anthropic: true });
+/** The request-state placeholders a profile may name. */
+const CHAT_TEMPLATE_VARS = Object.keys({
+	"thinking.enabled": true,
+	"thinking.effort": true
+});
+let providerIndex;
+/**
+* Installed catalog providers by id, constructed once. Each entry owns the API
+* implementations for its own models, which is why a catalog route reuses this
+* provider instead of being rebuilt from parts.
+* @returns the catalog provider index.
+*/
+function catalogProviders() {
+	providerIndex ??= new Map(builtinProviders().map((provider) => [provider.id, provider]));
+	return providerIndex;
+}
+/**
+* The installed catalog provider for one route, when pi-ai ships one.
+* @param provider - provider route key.
+* @returns the catalog provider, or `undefined` for a route pi-ai does not ship.
+*/
+function catalogProvider(provider) {
+	return catalogProviders().get(provider);
+}
+/**
+* The installed catalog models for one route, indexed by model id.
+* @param provider - provider route key.
+* @returns catalog models by id; empty for a route pi-ai does not ship.
+*/
+function catalogModels(provider) {
+	if (!catalogProviders().has(provider)) return /* @__PURE__ */ new Map();
+	const models = getBuiltinModels(provider);
+	return new Map(models.map((model) => [model.id, model]));
+}
+/**
+* Disposition of every `OpenAICompletionsCompat` field. The `Record` key type
+* is a drift gate: a pi-ai upgrade that adds a field fails compilation here
+* until it is classified, so the offer never silently lags the upstream set.
+*/
+const COMPLETIONS_COMPAT_GATE = {
+	supportsStore: "offer",
+	supportsDeveloperRole: "offer",
+	supportsReasoningEffort: "offer",
+	supportsUsageInStreaming: "offer",
+	supportsFinishReason: "offer",
+	maxTokensField: "offer",
+	requiresToolResultName: "offer",
+	requiresAssistantAfterToolResult: "offer",
+	requiresThinkingAsText: "offer",
+	requiresReasoningContentOnAssistantMessages: "offer",
+	thinkingFormat: "offer",
+	chatTemplateKwargs: "offer",
+	chatTemplateArgs: "offer",
+	supportsThinkingTokenBudget: "offer",
+	supportsStrictMode: "offer",
+	cacheControlFormat: "offer",
+	supportsLongCacheRetention: "offer",
+	openRouterRouting: "withhold",
+	vercelGatewayRouting: "withhold",
+	zaiToolStream: "withhold",
+	supportsOpenAIGrammarTools: "withhold",
+	sendSessionAffinityHeaders: "withhold",
+	deferredToolsMode: "withhold",
+	sessionAffinityFormat: "withhold"
+};
+/** Disposition of every `OpenAIResponsesCompat` field; a drift gate like the one above. */
+const RESPONSES_COMPAT_GATE = {
+	supportsDeveloperRole: "offer",
+	supportsStrictMode: "offer",
+	supportsLongCacheRetention: "offer",
+	sessionAffinityFormat: "withhold",
+	supportsOpenAIGrammarTools: "withhold",
+	supportsAdditionalTools: "withhold",
+	supportsToolSearch: "withhold",
+	supportsExplicitPromptCacheMode: "withhold"
+};
+/**
+* The compat gate of every wire protocol a profile may configure.
+*
+* Keyed by protocol, but grouped by pi-ai's compat *type*: the three Responses
+* protocols share `OpenAIResponsesCompat`, so a switch settable on one is
+* settable on all three. Keying by protocol alone would refuse
+* `azure-openai-responses` and `openai-codex-responses` the fields their own
+* models declare.
+*/
+const COMPAT_GATES = {
+	"openai-completions": COMPLETIONS_COMPAT_GATE,
+	"openai-responses": RESPONSES_COMPAT_GATE,
+	"azure-openai-responses": RESPONSES_COMPAT_GATE,
+	"openai-codex-responses": RESPONSES_COMPAT_GATE,
+	"anthropic-messages": {
+		supportsEagerToolInputStreaming: "offer",
+		supportsLongCacheRetention: "offer",
+		supportsCacheControlOnTools: "offer",
+		supportsTemperature: "offer",
+		forceAdaptiveThinking: "offer",
+		allowEmptySignature: "offer",
+		supportsStrictTools: "offer",
+		sendSessionAffinityHeaders: "withhold",
+		supportsToolReferences: "withhold"
+	},
+	"bedrock-converse-stream": { supportsStrictMode: "offer" }
+};
+/**
+* The compat gate of one resolved protocol. A `string` lookup rather than a
+* keyed read: a route's `api` is configuration, so it may name a protocol
+* pi-ai gives no compat type — or none at all.
+* @param api - resolved wire protocol.
+* @returns that protocol's field gate, or `undefined` when it takes no compat.
+*/
+function compatGate(api) {
+	return COMPAT_GATES[api];
+}
+/**
+* The compat entries a profile actually set.
+*
+* schemastery materializes an absent dict as `{}` — the behavior
+* `reasoningEfforts` works around with a union — so every parsed profile
+* carries both template-argument keys whether or not anyone wrote them. An
+* empty one states nothing here: it would send no arguments, which is exactly
+* what leaving the field out does, so absent and empty are the same request
+* and neither may make a route look like it configured a switch. A valueless
+* scalar is the other thing schemastery lets through, and it is refused by
+* {@link assertOfferedCompatFields} before this runs rather than filtered.
+* @param compat - the configured switches, when any.
+* @returns the entries carrying a value, in declaration order.
+*/
+function configuredCompatEntries(compat) {
+	return Object.entries(compat ?? {}).flatMap(([field, value]) => {
+		return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0 ? [] : [[field, value]];
+	});
+}
+/**
+* The protocols offering one compat field, in {@link COMPAT_GATES} order.
+* @param field - configured compat field name.
+* @returns the protocols whose compat takes it; empty when none does, which
+*   is either a withheld field or a name no upstream compat type declares.
+*/
+function compatProtocols(field) {
+	return Object.entries(COMPAT_GATES).flatMap(([api, gate]) => gate[field] === "offer" ? [api] : []);
+}
+/**
+* The compat fields one protocol offers, for a diagnostic that has to show
+* what was available instead of the name that missed.
+* @param api - wire protocol.
+* @returns the offered field names, or an empty list for a protocol taking no compat.
+*/
+function offeredCompatFields(api) {
+	return Object.entries(compatGate(api) ?? {}).flatMap(([field, disposition]) => disposition === "offer" ? [field] : []);
+}
+/**
+* Every offered field name, deduplicated, for the one diagnostic that cannot
+* narrow by protocol: the vocabulary check runs before any protocol resolves,
+* which is what lets it refuse a misspelling on a route whose models would
+* never have reached the protocol that declares the intended field.
+* @returns the offered field names across every protocol, in gate order.
+*/
+function allOfferedCompatFields() {
+	const fields = /* @__PURE__ */ new Set();
+	for (const api of Object.keys(COMPAT_GATES)) for (const field of offeredCompatFields(api)) fields.add(field);
+	return [...fields];
+}
+/**
+* Reject a compat key no protocol offers. Runs before any protocol is
+* resolved, so a withheld field or a misspelling fails even on a route whose
+* models never reach the protocol that would have taken it — the alternative
+* being the silent drop that let an unreadable switch look applied.
+* @param provider - provider route key, for diagnostics.
+* @param site - the configuration site, for diagnostics.
+* @param compat - the configured switches, when any.
+* @throws Error naming the offending key.
+*/
+function assertOfferedCompatFields(provider, site, compat) {
+	for (const [field, value] of Object.entries(compat ?? {})) {
+		if (compatProtocols(field).length === 0) {
+			if (Object.values(COMPAT_GATES).some((gate) => gate[field] !== void 0)) invalid$1(provider, `${site} sets compat "${field}", which is not configurable here: pi-ai's installed catalog sets it for the vendors that need it, so name that provider as the route instead`);
+			invalid$1(provider, `${site} sets compat "${field}", which no wire protocol declares; the configurable switches are ${allOfferedCompatFields().join(", ")}`);
+		}
+		if (value == null) invalid$1(provider, `${site} sets compat "${field}" with no value; give it one, or remove the key to leave the field to the next layer — the installed catalog entry, then pi-ai's own detection`);
+	}
+}
+/** Report a route the deployment cannot serve, naming the settings key at fault. */
+function invalid$1(provider, detail) {
+	throw new Error(`llm-pi-ai: provider "${provider}" ${detail}`);
+}
+/**
+* The one wire protocol a catalog route's shipped models agree on. This is what
+* lets a deployment add a model the installed catalog has not caught up with —
+* a provider's newest release — without restating the protocol its siblings
+* already use. A route whose shipped models disagree (an OpenAI-style catalog
+* spanning Responses and Chat Completions) has no such answer, so a model it
+* does not describe must name its protocol at the route.
+*/
+function sharedCatalogApi(defaults) {
+	const apis = /* @__PURE__ */ new Set();
+	for (const model of defaults.values()) apis.add(model.api);
+	return apis.size === 1 ? [...apis][0] : void 0;
+}
+/**
+* Resolve one model's reasoning capability from its declared efforts.
+*
+* A declared dict translates to pi-ai's `thinkingLevelMap` with every level
+* decided explicitly: declared levels carry their wire spelling, undeclared
+* levels are pinned to `null` (unsupported). Pinning matters because pi-ai's
+* own defaulting is asymmetric — an absent key means "supported" for the five
+* base levels but "unsupported" for `xhigh`/`max` — and a profile author
+* should not need to know that. A declared `off` with no value is the one
+* exception: it stays absent from the map, which pi-ai reads as "supported,
+* send nothing" — the correct dispatch where not thinking is the parameter's
+* absence — while `off` with a value sends that value.
+* @param provider - provider route key, for diagnostics.
+* @param entry - the configured model entry.
+* @param base - the installed catalog entry of the same id, when one exists.
+* @returns the reasoning fields the materialized model carries.
+*/
+function resolveModelReasoning(provider, entry, base) {
+	const efforts = entry.reasoningEfforts;
+	if (efforts === void 0) return { reasoning: base?.reasoning ?? false };
+	if (efforts === false) return { reasoning: false };
+	if (efforts === null || Object.keys(efforts).length === 0) invalid$1(provider, `model "${entry.id}" has an empty reasoningEfforts; declare the offered levels, set false for a non-reasoning model, or omit the field to keep the installed catalog's capability`);
+	const declared = THINKING_LEVELS.flatMap((level) => {
+		const wire = efforts[level];
+		return wire === void 0 ? [] : [[level, wire]];
+	});
+	for (const [level, wire] of declared) if (wire === null) {
+		if (level !== "off") invalid$1(provider, `model "${entry.id}" reasoningEfforts.${level} needs the wire value dispatch should send; only "off" may leave it empty`);
+	} else if (wire.length === 0) invalid$1(provider, `model "${entry.id}" reasoningEfforts.${level} must not be an empty string`);
+	if (!declared.some(([level]) => level !== "off")) invalid$1(provider, `model "${entry.id}" reasoningEfforts offers no level beyond "off"; declare a thinking level, or set reasoningEfforts to false for a non-reasoning model`);
+	const map = {};
+	for (const level of THINKING_LEVELS) {
+		const wire = efforts[level];
+		if (wire === void 0) map[level] = null;
+		else if (wire !== null) map[level] = wire;
+	}
+	return {
+		reasoning: true,
+		thinkingLevelMap: map
+	};
+}
+/**
+* Resolve one model's compat block from the profile's switches.
+*
+* A model switch wins over the route switch field by field; whatever neither
+* sets keeps the installed entry's value, and a field no layer decides falls
+* through to pi-ai's own detection. A model-level switch its protocol does not
+* take fails resolution — about one named model it can only be a mistake —
+* while a route-level one skips past such models, since a route default must
+* stay settable on a route whose models do not all speak one protocol. Every
+* field reaching here is offered by some protocol; {@link
+* assertOfferedCompatFields} has already refused the rest.
+* @param provider - provider route key, for diagnostics.
+* @param entry - the configured model entry.
+* @param route - the route-level switches, when any.
+* @param base - the installed catalog entry of the same id, when one exists.
+* @param api - the model's resolved wire protocol.
+* @returns a `compat` field to spread into the model, or nothing.
+*/
+function resolveModelCompat(provider, entry, route, base, api) {
+	const gate = compatGate(api);
+	const configured = {};
+	for (const [field, value] of configuredCompatEntries(route)) {
+		if (gate?.[field] !== "offer") continue;
+		configured[field] = value;
+	}
+	for (const [field, value] of configuredCompatEntries(entry.compat)) {
+		if (gate?.[field] !== "offer") {
+			const offered = offeredCompatFields(api);
+			invalid$1(provider, `model "${entry.id}" sets compat "${field}", but its api is "${api}", which does not take it; that switch exists on ${compatProtocols(field).join(", ")}, and "${api}" offers ${offered.length === 0 ? "no configurable compat" : offered.join(", ")}`);
+		}
+		configured[field] = value;
+	}
+	if (Object.keys(configured).length === 0) return {};
+	return { compat: {
+		...base?.api === api ? base.compat : void 0,
+		...configured
+	} };
+}
+/**
+* Materialize one route's catalog by merging the installed catalog defaults
+* under the configured entries. A route with no configured `models` serves the
+* installed catalog unchanged, which is what keeps an existing
+* `providers: { deepseek: { apiKeyEnv: … } }` profile working untouched.
+* @param request - the route-level catalog facts.
+* @returns the materialized models and the explicitly configured request caps.
+*/
+function resolveRouteModels(request) {
+	const { provider } = request;
+	const defaults = catalogModels(provider);
+	const providerBaseUrl = catalogProvider(provider)?.baseUrl;
+	const configured = request.models ?? [];
+	const overrides = request.modelOverrides ?? {};
+	for (const [id, override] of Object.entries(overrides)) {
+		if (id.length === 0) invalid$1(provider, "has a modelOverrides entry with an empty model id");
+		if (defaults.size === 0) invalid$1(provider, `sets modelOverrides for "${id}", but the installed catalog does not describe this route; a declared route spells every model out in its models list`);
+		if (configured.length > 0) invalid$1(provider, `sets modelOverrides for "${id}" beside a models list; models already replaces the served catalog, so declare the fields on its entries`);
+		if (!defaults.has(id)) invalid$1(provider, `modelOverrides names "${id}", which the installed catalog does not describe`);
+		if ("id" in override) invalid$1(provider, `modelOverrides entry "${id}" sets "id", which is the dict key`);
+	}
+	const entries = configured.length > 0 ? configured : [...defaults.values()].map((model) => ({
+		id: model.id,
+		...overrides[model.id]
+	}));
+	if (entries.length === 0) invalid$1(provider, "resolves no models; the installed catalog does not describe this route, so its models must be listed in configuration");
+	const routeApi = sharedCatalogApi(defaults);
+	assertOfferedCompatFields(provider, "route", request.compat);
+	for (const entry of entries) assertOfferedCompatFields(provider, `model "${entry.id}"`, entry.compat);
+	const seen = /* @__PURE__ */ new Set();
+	const configuredMaxTokens = /* @__PURE__ */ new Map();
+	const models = entries.map((entry) => {
+		if (entry.id.length === 0) invalid$1(provider, "has a model with an empty id");
+		if (seen.has(entry.id)) invalid$1(provider, `lists model "${entry.id}" more than once`);
+		seen.add(entry.id);
+		const base = defaults.get(entry.id);
+		const api = request.api ?? base?.api ?? routeApi;
+		if (api === void 0) invalid$1(provider, `model "${entry.id}" needs an api; the installed catalog does not describe it, so set the route's api to the wire protocol its endpoint speaks`);
+		const baseUrl = request.baseURL ?? base?.baseUrl ?? providerBaseUrl;
+		if (baseUrl === void 0) invalid$1(provider, `model "${entry.id}" needs a baseURL; the installed catalog does not describe this route`);
+		const contextWindow = entry.contextWindow ?? base?.contextWindow ?? request.defaultContextWindow;
+		if (!Number.isInteger(contextWindow) || contextWindow <= 0) invalid$1(provider, `model "${entry.id}" contextWindow must be a positive integer`);
+		const maxTokens = entry.maxTokens ?? base?.maxTokens ?? request.defaultMaxTokens;
+		if (!Number.isInteger(maxTokens) || maxTokens <= 0) invalid$1(provider, `model "${entry.id}" maxTokens must be a positive integer`);
+		if (entry.maxTokens !== void 0) configuredMaxTokens.set(entry.id, entry.maxTokens);
+		return {
+			...base,
+			id: entry.id,
+			name: entry.name ?? base?.name ?? entry.id,
+			api,
+			provider,
+			baseUrl,
+			input: declaredInput(entry.input) ?? base?.input ?? [...request.defaultInput],
+			cost: base?.cost ?? NO_COST,
+			contextWindow,
+			maxTokens,
+			...resolveModelReasoning(provider, entry, base),
+			...resolveModelCompat(provider, entry, request.compat, base, api)
+		};
+	});
+	for (const [field] of configuredCompatEntries(request.compat)) {
+		const takers = compatProtocols(field);
+		if (models.some((model) => takers.includes(model.api))) continue;
+		invalid$1(provider, `sets compat "${field}", but no model on the route speaks a protocol that takes it; it exists on ${takers.join(", ")}`);
+	}
+	return {
+		models,
+		configuredMaxTokens
+	};
+}
+//#endregion
+//#region vendor/dsh-llm-pi-ai/src/provider.ts
+/**
+* Construction of the pi-ai `Provider` that one configured route registers into
+* the adapter's `Models` collection.
+*
+* Two constructions, one decision: a route the installed catalog ships, whose
+* profile does not override the wire protocol, **reuses that catalog provider**
+* with its models replaced — the catalog provider owns API implementations this
+* package cannot reconstruct (Bedrock loads its Smithy module through a
+* separate entry point), so rebuilding it from parts would silently narrow
+* which providers work. Every other route — one pi-ai has never heard of, or a
+* catalog route pointed at a different protocol — is built by `createProvider`
+* over the protocol table below.
+*
+* Credentials never reach this module's storage: the harness resolves a route's
+* key through `ctx.credentials` before the request enters pi-ai and hands it
+* over as a stream option, which `Models` presents to `resolve()` as the
+* credential key.
+*
+* @module dsh-llm-pi-ai/provider
+*/
+/**
+* Wire protocols a configured route may name, mapped to pi-ai's lazily loaded
+* implementations. Each entry is the factory that pi-ai's matching provider
+* factory uses, so a hand-declared route reaches exactly the implementation a
+* catalog route would.
+*
+* The table is deliberately narrow: the protocols a hand-declared route
+* actually reads, each completely describable with a key, an
+* endpoint, and headers. Bedrock signs with SigV4 over AWS credentials and a
+* region, Vertex needs a project, a location, and application-default
+* credentials, Azure needs provider environment plus an api-version, and Codex
+* authenticates through OAuth — none of which this configuration shape can
+* express, so offering them would hand back a provider that cannot
+* authenticate. The remainder are absent for want of a consumer rather than a
+* blocker: each is one line here once a deployment needs it. Catalog routes
+* still reach every protocol through their own provider; only an explicit
+* override is refused.
+*/
+const PROTOCOLS = {
+	"openai-completions": openAICompletionsApi,
+	"openai-responses": openAIResponsesApi,
+	"anthropic-messages": anthropicMessagesApi
+};
+/**
+* Every wire protocol a configured route may name, most-reached first. The
+* order is the table's and therefore stable; a configuration surface offering
+* a choice presents the first as its default, which is why the protocol a
+* hand-declared gateway most often speaks — and the one endpoint interrogation
+* can read — leads.
+* @returns the supported protocol identifiers.
+*/
+function supportedProtocols() {
+	return Object.keys(PROTOCOLS);
+}
+/**
+* Api-key auth for a route the harness authenticates itself. `Models` calls
+* this after the adapter has already resolved the route's credential, so a
+* missing key here is not this layer's failure: a named-but-unresolvable
+* reference has already failed the request with `MISSING_CREDENTIAL`, and a
+* route naming no credential at all is deliberately unauthenticated. Reporting
+* it as configured hands the decision to the protocol, which is where the
+* requirement actually lives — pi-ai's OpenAI-compatible implementation, for
+* one, still insists on a key or an `Authorization` header of its own.
+* @param name - display name used as the resolution's status label.
+* @returns the api-key auth for a harness-authenticated route.
+*/
+function harnessApiKeyAuth(name) {
+	return {
+		name,
+		resolve: ({ credential }) => Promise.resolve({
+			auth: credential?.key === void 0 ? {} : { apiKey: credential.key },
+			source: name
+		})
+	};
+}
+/**
+* The auth one route resolves its credential through.
+*
+* A catalog route keeps the installed provider's own auth, which is what
+* preserves provider-native ambient discovery for a profile naming no
+* credential. That holds even when the profile repoints the protocol: which
+* environment a provider reads is a property of the provider, not of the wire
+* format its models speak.
+*
+* The single addition covers a catalog provider that offers no api-key method
+* at all. pi-ai resolves a request's `apiKey` override only when the provider
+* declares one (`resolveProviderAuth` checks `provider.auth.apiKey` before
+* honouring the override), so an OAuth-only provider — `openai-codex` is the
+* one the installed catalog ships — would refuse a profile's explicit key with
+* `Provider is not configured` before any request went out. Adding the harness
+* method beside the provider's own restores that route. A keyless profile adds
+* nothing and still reports the honest refusal, because this adapter resolves
+* credentials through its own seam and holds no OAuth store to fall back on.
+* @param spec - the resolved route facts.
+* @param catalog - the installed catalog provider, when pi-ai ships one.
+* @returns the auth to construct this route's provider with.
+*/
+function routeAuth(spec, catalog) {
+	if (catalog === void 0) return { apiKey: harnessApiKeyAuth(spec.displayName) };
+	if (catalog.auth.apiKey !== void 0 || !spec.namesCredential) return catalog.auth;
+	return {
+		...catalog.auth,
+		apiKey: harnessApiKeyAuth(spec.displayName)
+	};
+}
+/**
+* Reuse an installed catalog provider with this route's models and identity.
+* Model dispatch stays with the catalog provider, so its API implementations,
+* compatibility quirks, and ambient credential discovery are preserved exactly.
+* Catalog-owned dynamic refresh is dropped: this route's catalog is the
+* settings document, and a background refresh would contradict it.
+*/
+function reuseCatalogProvider(base, spec) {
+	const baseUrl = spec.baseURL ?? base.baseUrl;
+	return {
+		id: spec.provider,
+		name: spec.displayName,
+		...baseUrl === void 0 ? {} : { baseUrl },
+		auth: routeAuth(spec, base),
+		getModels: () => spec.models,
+		stream: (model, context, options) => base.stream(model, context, options),
+		streamSimple: (model, context, options) => base.streamSimple(model, context, options)
+	};
+}
+/**
+* Build the pi-ai provider for one resolved route.
+* @param spec - the resolved route facts.
+* @returns the provider to register in the adapter's `Models` collection.
+* @throws Error when the route names a wire protocol this build cannot serve.
+*/
+function buildProvider(spec) {
+	const catalog = catalogProvider(spec.provider);
+	if (catalog !== void 0 && spec.api === void 0) return reuseCatalogProvider(catalog, spec);
+	const factory = spec.api === void 0 ? void 0 : PROTOCOLS[spec.api];
+	if (factory === void 0) throw new Error(`llm-pi-ai: provider "${spec.provider}" names api "${spec.api}", which this build cannot serve; supported protocols are ${supportedProtocols().join(", ")}`);
+	return createProvider({
+		id: spec.provider,
+		name: spec.displayName,
+		...spec.baseURL === void 0 ? {} : { baseUrl: spec.baseURL },
+		auth: routeAuth(spec, catalog),
+		models: spec.models,
+		api: factory()
+	});
+}
+//#endregion
+//#region vendor/dsh-llm-pi-ai/src/config.ts
+/** Default maximum idle interval while an adapter stream read is outstanding. */
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+/**
+* Default request-level bound on base64-encoded image payload. Every image in
+* history is re-encoded into every request body, so an unbounded conversation
+* eventually exceeds a provider or gateway request-size cap and the session
+* can never complete another request. The 20MiB default admits fifteen 1MiB
+* request versions after base64 expansion and reserves request capacity for
+* system prompts, history, tools, and JSON.
+* Deployments behind stricter gateways lower it per route.
+*/
+const DEFAULT_MAX_REQUEST_IMAGE_BYTES = 20971520;
+/** Default total-pixel budget preserves the complete 2048px normalized attachment. */
+const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET = 4194304;
+/** Default raw encoded-byte target before inline base64 expansion; the smallest quality-ladder output is used when no quality fits. */
+const DEFAULT_REQUEST_IMAGE_MAX_BYTES = 1048576;
+/** Context capacity assumed for a model neither configuration nor the catalog sizes. */
+const DEFAULT_CONTEXT_WINDOW = 262144;
+/** Output capability assumed for a model neither configuration nor the catalog sizes. */
+const DEFAULT_MAX_TOKENS = 32768;
+/**
+* Modalities assumed for a model neither configuration nor the catalog
+* declares. Text is the floor every supported protocol certainly carries, so
+* this is the absence of a declaration rather than a guess at the endpoint:
+* nothing can interrogate a gateway for its modalities, and the two wrong
+* answers do not cost the same. Under-claiming refuses the image before it is
+* attached, naming the model. Over-claiming admits one the provider then
+* rejects mid-turn, after the message is durable, leaving the session
+* repeating a request that cannot succeed.
+*/
+const DEFAULT_INPUT = ["text"];
+const thinkingBudgets = z.object({
+	minimal: z.number(),
+	low: z.number(),
+	medium: z.number(),
+	high: z.number()
+});
+/**
+* One `chat_template_kwargs` or `chat_template_args` value. The `$var` member
+* is pi-ai's placeholder for a value dispatch fills from the request's
+* thinking state, which makes a template-driven gateway configurable without
+* restating its template.
+*/
+const chatTemplateKwarg = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.const(null),
+	z.object({
+		$var: z.union(CHAT_TEMPLATE_VARS).required(),
+		omitWhenOff: z.boolean()
+	})
+]);
+const compatProfile = z.object({
+	supportsStore: z.boolean(),
+	supportsDeveloperRole: z.boolean(),
+	supportsReasoningEffort: z.boolean(),
+	supportsUsageInStreaming: z.boolean(),
+	supportsFinishReason: z.boolean(),
+	maxTokensField: z.union(MAX_TOKENS_FIELDS),
+	requiresToolResultName: z.boolean(),
+	requiresAssistantAfterToolResult: z.boolean(),
+	requiresThinkingAsText: z.boolean(),
+	requiresReasoningContentOnAssistantMessages: z.boolean(),
+	thinkingFormat: z.union(SUPPORTED_THINKING_FORMATS),
+	chatTemplateKwargs: z.dict(chatTemplateKwarg),
+	chatTemplateArgs: z.dict(chatTemplateKwarg),
+	supportsThinkingTokenBudget: z.boolean(),
+	supportsStrictMode: z.boolean(),
+	cacheControlFormat: z.union(CACHE_CONTROL_FORMATS),
+	supportsLongCacheRetention: z.boolean(),
+	supportsEagerToolInputStreaming: z.boolean(),
+	supportsCacheControlOnTools: z.boolean(),
+	supportsTemperature: z.boolean(),
+	forceAdaptiveThinking: z.boolean(),
+	allowEmptySignature: z.boolean(),
+	supportsStrictTools: z.boolean()
+});
+/**
+* Keys are the offered levels, values their wire spellings. A valueless key
+* (`off:`) survives validation because schemastery passes nullable data
+* through before any member schema runs — `z.const(null)` only controls the
+* error for non-null wrong values and what a configuration UI renders.
+* Only resolution decides which levels may leave the value empty, so the
+* diagnostic can name the route and model. The assertion narrows
+* schemastery's `Dict`, which types every literal key as required; dict
+* validation checks only present keys, so the runtime value is a partial record.
+*/
+const reasoningEfforts = z.dict(z.union([z.string(), z.const(null)]), z.union(THINKING_LEVELS));
+/** The fields a `models` entry and a `modelOverrides` value share; only the id's home differs. */
+const modelFields = {
+	name: z.string(),
+	contextWindow: z.number().step(1).min(1),
+	maxTokens: z.number().step(1).min(1),
+	input: z.array(z.union(MODALITIES)),
+	reasoningEfforts: z.union([z.const(false), reasoningEfforts]),
+	compat: compatProfile
+};
+const modelProfile = z.object({
+	id: z.string().required(),
+	...modelFields
+});
+/** A {@link modelProfile} whose id lives in the `modelOverrides` dict key. */
+const modelOverride = z.object(modelFields);
+const profile = z.object({
+	apiKeyEnv: z.string().role("credential-ref"),
+	displayName: z.string(),
+	api: z.union(supportedProtocols()),
+	baseURL: z.string(),
+	models: z.array(modelProfile),
+	modelOverrides: z.dict(modelOverride),
+	compat: compatProfile,
+	defaultContextWindow: z.number().step(1).min(1).default(DEFAULT_CONTEXT_WINDOW),
+	defaultMaxTokens: z.number().step(1).min(1).default(DEFAULT_MAX_TOKENS),
+	defaultInput: z.array(z.union(MODALITIES)).default([...DEFAULT_INPUT]),
+	headers: z.dict(z.string()),
+	reasoning: z.union(THINKING_LEVELS),
+	reasoningSplit: z.boolean(),
+	thinkingBudgets,
+	cacheRetention: z.union([
+		"none",
+		"short",
+		"long"
+	]),
+	transport: z.union([
+		"sse",
+		"websocket",
+		"websocket-cached",
+		"auto"
+	]),
+	timeoutMs: z.natural(),
+	websocketConnectTimeoutMs: z.natural(),
+	streamIdleTimeoutMs: z.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS).default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+	maxRequestImageBytes: z.number().step(1).min(1).default(DEFAULT_MAX_REQUEST_IMAGE_BYTES),
+	requestImagePixelBudget: z.number().step(1).min(1).default(DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET),
+	requestImageMaxBytes: z.number().step(1).min(1).default(DEFAULT_REQUEST_IMAGE_MAX_BYTES),
+	retryPolicy: RetryPolicySchema
+});
+z.object({ providers: z.dict(profile).default({}) });
+/** Reject removed pre-release profile fields and name their replacements. */
+function rejectRemovedFields(provider, source) {
+	const legacy = source;
+	if ("provider" in legacy) throw new Error(`llm-pi-ai: provider "${provider}" sets "provider", which moved to the providers dict key`);
+	if ("maxRetries" in legacy || "maxRetryDelayMs" in legacy) throw new Error(`llm-pi-ai: provider "${provider}" sets maxRetries or maxRetryDelayMs, which were removed; compose agent recovery with dsh-llm-retry`);
+}
+/**
+* Validate profiles and return a detached route-keyed map suitable for
+* per-request reads. This is the one explicit resolve step, so an omitted dict
+* resolves to the empty (dormant) route set here rather than through a hidden
+* fallback, and each route's models and pi-ai provider are materialized once.
+* @param providers - configured provider profiles keyed by route.
+* @returns validated profiles in configuration order.
+*/
+function resolveProfiles(providers) {
+	if (Array.isArray(providers)) throw new Error("llm-pi-ai: providers is now a dict keyed by provider route, not an array of profiles");
+	const entries = Object.entries(providers ?? {});
+	const resolved = /* @__PURE__ */ new Map();
+	for (const [provider, source] of entries) {
+		rejectRemovedFields(provider, source);
+		if (provider.length === 0) throw new Error("llm-pi-ai: provider names must be non-empty");
+		if (source.baseURL !== void 0 && source.baseURL.length === 0) throw new Error(`llm-pi-ai: provider "${provider}" has an empty baseURL`);
+		if (source.displayName !== void 0 && source.displayName.length === 0) throw new Error(`llm-pi-ai: provider "${provider}" has an empty displayName`);
+		const streamIdleTimeoutMs = source.streamIdleTimeoutMs ?? 3e5;
+		if (!Number.isFinite(streamIdleTimeoutMs) || streamIdleTimeoutMs <= 0 || streamIdleTimeoutMs > MAX_TIMER_DELAY_MS) throw new Error(`llm-pi-ai: provider "${provider}" streamIdleTimeoutMs must be a positive finite number no greater than ${MAX_TIMER_DELAY_MS}`);
+		const maxRequestImageBytes = source.maxRequestImageBytes ?? 20971520;
+		if (!Number.isInteger(maxRequestImageBytes) || maxRequestImageBytes <= 0) throw new Error(`llm-pi-ai: provider "${provider}" maxRequestImageBytes must be a positive integer`);
+		const requestImagePixelBudget = source.requestImagePixelBudget ?? 4194304;
+		if (!Number.isSafeInteger(requestImagePixelBudget) || requestImagePixelBudget <= 0) throw new Error(`llm-pi-ai: provider "${provider}" requestImagePixelBudget must be a positive safe integer`);
+		const requestImageMaxBytes = source.requestImageMaxBytes ?? 1048576;
+		if (!Number.isSafeInteger(requestImageMaxBytes) || requestImageMaxBytes <= 0) throw new Error(`llm-pi-ai: provider "${provider}" requestImageMaxBytes must be a positive safe integer`);
+		const defaultInput = [...source.defaultInput ?? DEFAULT_INPUT];
+		if (defaultInput.length === 0) throw new Error(`llm-pi-ai: provider "${provider}" defaultInput must name at least one modality`);
+		const displayName = source.displayName ?? provider;
+		const catalog = resolveRouteModels({
+			provider,
+			...source.api === void 0 ? {} : { api: source.api },
+			...source.baseURL === void 0 ? {} : { baseURL: source.baseURL },
+			...source.models === void 0 ? {} : { models: source.models },
+			...source.modelOverrides === void 0 ? {} : { modelOverrides: source.modelOverrides },
+			...source.compat === void 0 ? {} : { compat: source.compat },
+			defaultInput,
+			defaultContextWindow: source.defaultContextWindow ?? 262144,
+			defaultMaxTokens: source.defaultMaxTokens ?? 32768
+		});
+		if (source.reasoningSplit !== void 0 && catalog.models.some((model) => model.api !== "openai-completions")) throw new Error(`llm-pi-ai: provider "${provider}" reasoningSplit requires every model to use openai-completions`);
+		const { apiKeyEnv, retryPolicy, models: _models, displayName: _displayName, ...rest } = source;
+		resolved.set(provider, {
+			...rest,
+			provider,
+			displayName,
+			...apiKeyEnv === void 0 ? {} : { apiKeyEnv: credentialRef(apiKeyEnv) },
+			streamIdleTimeoutMs,
+			maxRequestImageBytes,
+			requestImagePixelBudget,
+			requestImageMaxBytes,
+			retryPolicy: resolveRetryPolicy(retryPolicy, `llm-pi-ai: provider "${provider}" retryPolicy`),
+			...rest.headers === void 0 ? {} : { headers: { ...rest.headers } },
+			...rest.thinkingBudgets === void 0 ? {} : { thinkingBudgets: { ...rest.thinkingBudgets } },
+			configuredMaxTokens: catalog.configuredMaxTokens,
+			piProvider: buildProvider({
+				provider,
+				displayName,
+				...source.api === void 0 ? {} : { api: source.api },
+				...source.baseURL === void 0 ? {} : { baseURL: source.baseURL },
+				models: catalog.models,
+				namesCredential: apiKeyEnv !== void 0
+			})
+		});
+	}
+	return resolved;
+}
+//#endregion
+//#region vendor/dsh-llm-pi-ai/src/context.ts
+/**
+* ChatCode CLI request-history conversion into pi-ai's Context vocabulary.
+*
+* @module dsh-llm-pi-ai/context
+*/
+/** Join the text blocks of a harness message. */
+function flattenText(message) {
+	return message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+/** Flatten text recursively inside one tool result. */
+function toolResultText(blocks) {
+	return blocks.map((block) => block.type === "text" ? block.text : block.type === "tool-result" ? toolResultText(block.content) : "").join("");
+}
+/** Reject image roles that pi-ai cannot replay before request-size offloading can replace them. */
+function assertSupportedImageRoles(messages) {
+	for (const message of messages) if (message.role !== "user" && contentHasImage(message.content)) throw new LlmError(`pi-ai cannot represent an image in an in-history ${message.role} message`, "UNSUPPORTED_CONTENT");
+}
+async function userContent(blocks, requestImages, resolveImageAccess) {
+	const content = [];
+	for (const block of blocks) switch (block.type) {
+		case "text":
+			if (block.text.length > 0) content.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "image": {
+			const version = requestImages.get(block.attachment.attachmentId);
+			content.push({
+				type: "text",
+				text: requestImageHandleText(block.attachment, version, resolveImageAccess(block.attachment))
+			});
+			content.push({
+				type: "image",
+				data: Buffer.from(version.data).toString("base64"),
+				mimeType: version.mediaType
+			});
+			break;
+		}
+		case "tool-result": {
+			const nested = await userContent(block.content, requestImages, resolveImageAccess);
+			if (typeof nested === "string") {
+				if (nested.length > 0) content.push({
+					type: "text",
+					text: nested
+				});
+			} else content.push(...nested);
+		}
+	}
+	if (content.every((block) => block.type === "text")) return content.map((block) => block.text).join("");
+	return content;
+}
+function collectImageRefs(blocks, refs) {
+	for (const block of blocks) if (block.type === "image") {
+		if (block.offloaded !== true) refs.set(block.attachment.attachmentId, block.attachment);
+	} else if (block.type === "tool-result") collectImageRefs(block.content, refs);
+}
+async function prepareRequestImages(messages, attachments, budget, signal) {
+	const refs = /* @__PURE__ */ new Map();
+	for (const message of messages) collectImageRefs(message.content, refs);
+	const orderedRefs = [...refs.values()];
+	const prepared = await Promise.all(orderedRefs.map((ref) => attachments.readImageRequest(ref, requestImageTarget(ref, budget), signal)));
+	const versions = /* @__PURE__ */ new Map();
+	for (const [index, ref] of orderedRefs.entries()) versions.set(ref.attachmentId, prepared[index]);
+	return versions;
+}
+function toolsOf(options) {
+	return options.tools?.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters
+	}));
+}
+/** Select the pi-ai system prompt source shared by both conversion paths. */
+function splitSystemPrompt(options) {
+	if (options.system !== void 0) return {
+		systemPrompt: options.system,
+		messages: options.messages
+	};
+	const [first, ...rest] = options.messages;
+	if (first?.role !== "system") return {
+		systemPrompt: void 0,
+		messages: options.messages
+	};
+	const text = flattenText(first);
+	return {
+		systemPrompt: text.length > 0 ? text : void 0,
+		messages: rest
+	};
+}
+/** Assemble the request-level pi-ai context envelope shared by both conversion paths. */
+function piContext(systemPrompt, options, messages) {
+	const tools = toolsOf(options);
+	return {
+		...systemPrompt !== void 0 ? { systemPrompt } : {},
+		messages,
+		...tools !== void 0 && tools.length > 0 ? { tools } : {}
+	};
+}
+function appendAssistant(message, messages, toolNames, onReplayDegrade) {
+	const assistant = toPiAssistant(message, onReplayDegrade);
+	for (const block of assistant.content) if (block.type === "toolCall") toolNames.set(brandString(block.id), block.name);
+	messages.push(assistant);
+}
+function textOnlyContext(options, onReplayDegrade) {
+	assertSupportedImageRoles(options.messages);
+	const split = splitSystemPrompt(options);
+	const toolNames = /* @__PURE__ */ new Map();
+	const messages = [];
+	for (const message of split.messages) {
+		if (contentHasImage(message.content)) throw new LlmError("pi-ai image conversion requires the durable attachment service", "UNSUPPORTED_CONTENT");
+		if (message.role === "system") {
+			messages.push({
+				role: "user",
+				content: flattenText(message),
+				timestamp: 0
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			appendAssistant(message, messages, toolNames, onReplayDegrade);
+			continue;
+		}
+		const text = flattenText(message);
+		const results = message.content.filter((block) => block.type === "tool-result");
+		if (text.length > 0 || results.length === 0) messages.push({
+			role: "user",
+			content: text,
+			timestamp: 0
+		});
+		for (const result of results) messages.push({
+			role: "toolResult",
+			toolCallId: result.toolCallId,
+			toolName: toolNames.get(result.toolCallId) ?? "unknown",
+			content: [{
+				type: "text",
+				text: toolResultText(result.content) || "(no output)"
+			}],
+			isError: result.isError ?? false,
+			timestamp: 0
+		});
+	}
+	return piContext(split.systemPrompt, options, messages);
+}
+/** Deterministic request target for one source under the route budgets. */
+function requestImageTarget(ref, budget) {
+	return {
+		...requestImageDimensions(ref.width, ref.height, budget.maxPixels),
+		maxBytes: budget.maxBytes
+	};
+}
+function toPiContext(options, images, onReplayDegrade) {
+	return images === void 0 ? textOnlyContext(options, onReplayDegrade) : toPiContextWithImages(options, images, onReplayDegrade);
+}
+async function toPiContextWithImages(options, images, onReplayDegrade) {
+	const { attachments, resolveImageAccess, maxRequestImageBytes } = images;
+	const requestImagePolicy = images.requestImagePolicy ?? {
+		maxPixels: 4194304,
+		maxBytes: 1048576
+	};
+	assertSupportedImageRoles(options.messages);
+	const split = splitSystemPrompt(options);
+	const requestImages = await prepareRequestImages(split.messages, attachments, requestImagePolicy, options.signal);
+	if (maxRequestImageBytes !== void 0) {
+		const offloadImages = requiredImageOffload(split.messages, {
+			representation: "base64",
+			maxBytes: maxRequestImageBytes
+		}, (block) => requestImages.get(block.attachment.attachmentId).bytes);
+		if (offloadImages > 0) throw new LlmError(`pi-ai request images exceed the ${maxRequestImageBytes}-byte base64 bound; ${offloadImages} more oldest occurrence(s) must be offloaded.`, IMAGE_OFFLOAD_REQUIRED_CODE, { offloadImages });
+	}
+	const exactMessages = projectOffloadedImages(split.messages, (ref) => offloadedImageText(ref, resolveImageAccess(ref)));
+	const toolNames = /* @__PURE__ */ new Map();
+	const messages = [];
+	for (const message of exactMessages) {
+		if (message.role === "system") {
+			messages.push({
+				role: "user",
+				content: flattenText(message),
+				timestamp: 0
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			appendAssistant(message, messages, toolNames, onReplayDegrade);
+			continue;
+		}
+		const content = await userContent(message.content.filter((block) => block.type !== "tool-result"), requestImages, resolveImageAccess);
+		const results = message.content.filter((block) => block.type === "tool-result");
+		if (content.length > 0 || results.length === 0) messages.push({
+			role: "user",
+			content,
+			timestamp: 0
+		});
+		for (const result of results) {
+			const resultContent = await userContent(result.content, requestImages, resolveImageAccess);
+			messages.push({
+				role: "toolResult",
+				toolCallId: result.toolCallId,
+				toolName: toolNames.get(result.toolCallId) ?? "unknown",
+				content: typeof resultContent === "string" ? [{
+					type: "text",
+					text: resultContent || "(no output)"
+				}] : resultContent,
+				isError: result.isError ?? false,
+				timestamp: 0
+			});
+		}
+	}
+	return piContext(split.systemPrompt, options, messages);
+}
+//#endregion
+//#region vendor/dsh-llm-pi-ai/src/stream.ts
+/**
+* pi-ai assistant event translation into the ChatCode CLI streaming protocol.
+*
+* pi-ai tool-call arguments are parsed objects while ChatCode CLI keeps their
+* raw JSON representation. pi-ai also reports failures as terminal stream
+* events, which this module maps into ChatCode CLI finish chunks.
+*
+* @module dsh-llm-pi-ai/stream
+*/
+/**
+* Map pi-ai usage (reasoning folded into output by pi-ai).
+* @param usage - cumulative usage from the terminal pi-ai event.
+* @returns harness counts with pi-ai's exact total; cache fields appear only
+*   when non-zero (pi-ai reports zeros, not absence).
+*/
+function mapUsage(usage) {
+	return {
+		inputTokens: usage.input,
+		outputTokens: usage.output,
+		totalTokens: usage.totalTokens,
+		...usage.cacheRead > 0 ? { cacheReadTokens: usage.cacheRead } : {},
+		...usage.cacheWrite > 0 ? { cacheWriteTokens: usage.cacheWrite } : {}
+	};
+}
+function classifyPiAiError(message) {
+	if (/\b(?:401|403)\b/.test(message)) return "AUTH";
+	if (isQuotaExceededError(message)) return QUOTA_EXCEEDED_CODE;
+	if (/\b429\b|rate.?limit/i.test(message)) return "RATE_LIMIT";
+	if (/\b413\b|failed to buffer the request body:\s*length limit exceeded|payload too large|request body too large/i.test(message)) return "INVALID_REQUEST";
+	if (/\b400\b|invalid.?request/i.test(message)) return "INVALID_REQUEST";
+	if (/\b5\d\d\b/.test(message)) return "SERVER";
+	if (/\btime(?:d)?\s*out\b|timeout/i.test(message)) return "TIMEOUT";
+	if (/stream ended (?:before|without)\b/i.test(message)) return "TRANSPORT";
+	if (/\b(?:network|connection|socket|fetch)\b|\bECONN[A-Z]+\b/i.test(message) || /\b(?:other side closed|HTTP2 request did not get a response|WebSocket closed unexpectedly)\b/i.test(message) || /\bterminated\b|premature close/i.test(message)) return "TRANSPORT";
+	return "PI_AI_ERROR";
+}
+/**
+* Map a terminal pi-ai event to the harness finish reason.
+* @param message - the assistant message carried by the `done` or `error` event.
+* @param contextWindow - resolved catalog capacity for usage-based overflow detection.
+* @returns the mapped harness reason. Recognized error text, `stop` usage above
+*   `contextWindow`, and zero-output `length` usage that fills the window map
+*   to `CONTEXT_WINDOW_EXCEEDED`; a `stop` with no content blocks maps to an
+*   `EMPTY_RESPONSE` error, while terminal `pending` and `deferred` states map
+*   to non-retryable `PI_AI_ERROR` failures.
+*/
+function mapStopReason(message, contextWindow) {
+	const piAiOverflow = isContextOverflow(message, contextWindow);
+	const harnessOverflow = message.stopReason === "error" && message.errorMessage !== void 0 && isContextWindowExceededError(message.errorMessage);
+	if (piAiOverflow || harnessOverflow) return {
+		kind: "error",
+		failure: {
+			message: message.errorMessage ?? `pi-ai detected context overflow for model "${message.model}"`,
+			code: CONTEXT_WINDOW_EXCEEDED_CODE
+		}
+	};
+	switch (message.stopReason) {
+		case "stop":
+			if (message.content.length === 0) return {
+				kind: "error",
+				failure: {
+					message: `model "${message.model}" returned a completed response with no content`,
+					code: EMPTY_RESPONSE_CODE
+				}
+			};
+			return { kind: "stop" };
+		case "length": return { kind: "max-tokens" };
+		case "toolUse": return { kind: "tool-calls" };
+		case "pending": return {
+			kind: "error",
+			failure: {
+				message: `pi-ai stream for model "${message.model}" ended pending`,
+				code: "PI_AI_ERROR"
+			}
+		};
+		case "deferred": return {
+			kind: "error",
+			failure: {
+				message: `pi-ai deferred response for model "${message.model}" is not supported`,
+				code: "PI_AI_ERROR"
+			}
+		};
+		case "aborted": return {
+			kind: "aborted",
+			failure: {
+				message: message.errorMessage ?? "pi-ai stream aborted",
+				code: "ABORTED"
+			}
+		};
+		case "error": {
+			const text = message.errorMessage ?? "pi-ai stream error";
+			return {
+				kind: "error",
+				failure: {
+					message: text,
+					code: classifyPiAiError(text)
+				}
+			};
+		}
+	}
+}
+/**
+* Translate the pi-ai event stream into StreamChunks. pi-ai never throws
+* mid-stream — failures arrive as `error` events, which become error/aborted
+* `finish` chunks (the harness protocol's other error-delivery style).
+* @param events - one assistant turn's pi-ai event stream.
+* @param contextWindow - resolved catalog capacity for usage-based overflow detection.
+* @param callerSignal - caller cancellation state; an aborted caller makes any
+*   in-band terminal error an aborted finish.
+* @returns the harness chunks, ending with `usage` then `finish`; throws
+*   `LlmError` (`STREAM_CLOSED`) if the source ends without a terminal event.
+*/
+async function* toStreamChunks(events, contextWindow, callerSignal) {
+	const toolIds = /* @__PURE__ */ new Map();
+	for await (const event of events) switch (event.type) {
+		case "start": break;
+		case "text_start":
+			yield {
+				type: "block-start",
+				index: event.contentIndex,
+				blockType: "text"
+			};
+			break;
+		case "text_delta":
+			yield {
+				type: "text-delta",
+				index: event.contentIndex,
+				text: event.delta
+			};
+			break;
+		case "text_end":
+			yield {
+				type: "block-end",
+				index: event.contentIndex,
+				block: {
+					type: "text",
+					text: event.content
+				}
+			};
+			break;
+		case "thinking_start":
+			yield {
+				type: "block-start",
+				index: event.contentIndex,
+				blockType: "reasoning"
+			};
+			break;
+		case "thinking_delta":
+			yield {
+				type: "reasoning-delta",
+				index: event.contentIndex,
+				text: event.delta
+			};
+			break;
+		case "thinking_end":
+			yield {
+				type: "block-end",
+				index: event.contentIndex,
+				block: {
+					type: "reasoning",
+					text: event.content
+				}
+			};
+			break;
+		case "toolcall_start": {
+			const partial = event.partial.content[event.contentIndex];
+			const id = partial?.type === "toolCall" ? partial.id : "";
+			const name = partial?.type === "toolCall" ? partial.name : "";
+			toolIds.set(event.contentIndex, {
+				id,
+				name
+			});
+			yield {
+				type: "block-start",
+				index: event.contentIndex,
+				blockType: "tool-call"
+			};
+			break;
+		}
+		case "toolcall_delta": {
+			const known = toolIds.get(event.contentIndex);
+			yield {
+				type: "tool-call-delta",
+				index: event.contentIndex,
+				id: brandString(known?.id ?? ""),
+				...known?.name !== void 0 && known.name.length > 0 ? { name: known.name } : {},
+				argumentsDelta: event.delta
+			};
+			break;
+		}
+		case "toolcall_end":
+			yield {
+				type: "block-end",
+				index: event.contentIndex,
+				block: {
+					type: "tool-call",
+					id: brandString(event.toolCall.id),
+					name: event.toolCall.name,
+					arguments: JSON.stringify(event.toolCall.arguments)
+				}
+			};
+			break;
+		case "done":
+			yield {
+				type: "usage",
+				usage: mapUsage(event.message.usage)
+			};
+			yield {
+				type: "finish",
+				reason: mapStopReason(event.message, contextWindow),
+				replayState: toPiReplayState(event.message)
+			};
+			return;
+		case "error":
+			yield {
+				type: "usage",
+				usage: mapUsage(event.error.usage)
+			};
+			yield {
+				type: "finish",
+				reason: mapStopReason(callerSignal?.aborted ? {
+					...event.error,
+					stopReason: "aborted"
+				} : event.error, contextWindow)
+			};
+			return;
+	}
+	throw new LlmError("pi-ai event stream ended without done/error", "STREAM_CLOSED");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.147.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region vendor/dsh-llm-pi-ai/src/adapter.ts
+/**
+* Generic pi-ai-backed implementation of the ChatCode CLI LLM seam.
+*
+* Each resolution produces one **immutable** snapshot — the profiles plus a
+* `Models` collection holding the `Provider` each route built — and an
+* operation captures a whole snapshot before its first `await`. A
+* configuration change builds a *new* collection rather than mutating the one
+* in use, because `Models.streamSimple()` is lazy: it resolves the provider
+* when the stream is first consumed, which is after the credential await, so a
+* mutated collection would let a request that started under one configuration
+* finish under another — or fail with a provider that no longer exists. This is
+* what makes the seam's per-step call freeze (`llm.prepareCall()`) hold all the
+* way down: switching models mid-reply takes effect on the next step, never
+* inside the one in flight.
+*
+* A route naming a credential reference still resolves it through the harness
+* seam and passes it as the request's `apiKey` option, which pi-ai treats as
+* the highest-priority auth override — that is what keeps the fail-loud
+* reference semantics. Everything that override does not cover reaches pi-ai
+* through the collection's own auth: the credential store holds the records a
+* login wrote and a refresh rotates, and the auth context answers the ambient
+* questions a provider asks while resolving. Both are stable across snapshots,
+* so a configuration change rebuilds the collection without forgetting who is
+* signed in.
+*
+* @module dsh-llm-pi-ai/adapter
+*/
+/** Copy profile stream knobs into pi-ai's common option vocabulary. */
+function profileOptions(profile, reasoning, apiKey) {
+	const enabledReasoning = reasoning === "off" ? void 0 : reasoning;
+	return {
+		...apiKey === void 0 ? {} : { apiKey },
+		...enabledReasoning === void 0 ? {} : { reasoning: enabledReasoning },
+		...profile.reasoningSplit === void 0 ? {} : { samplingParams: { reasoning_split: profile.reasoningSplit } },
+		...profile.thinkingBudgets === void 0 ? {} : { thinkingBudgets: profile.thinkingBudgets },
+		...profile.cacheRetention === void 0 ? {} : { cacheRetention: profile.cacheRetention },
+		...profile.transport === void 0 ? {} : { transport: profile.transport },
+		...profile.timeoutMs === void 0 ? {} : { timeoutMs: profile.timeoutMs },
+		...profile.websocketConnectTimeoutMs === void 0 ? {} : { websocketConnectTimeoutMs: profile.websocketConnectTimeoutMs },
+		maxRetries: 0
+	};
+}
+/**
+* The profile default this exact model can actually take, for DESCRIBING it.
+* A configured level the model does not support yields none rather than
+* throwing: `resolveModel` builds the model catalog, and a catalog that fails
+* takes its whole provider out of every picker — so one mis-set profile field
+* would hide every model on the route, including the ones that support the
+* level. The request path still refuses, which is where a bad configuration
+* belongs: describing what a model can do must not fail because a deployment
+* asked it for something it cannot.
+* @param model - the resolved model descriptor.
+* @param effort - the profile's configured level, if any.
+* @returns the level when this model supports it, otherwise undefined.
+*/
+function describableReasoningLevel(model, effort) {
+	if (effort === void 0) return void 0;
+	return getSupportedThinkingLevels(model).some((level) => level === effort) ? effort : void 0;
+}
+/** Validate an explicit ChatCode CLI profile effort without invoking pi-ai's clamp. */
+function resolveReasoningLevel(model, effort) {
+	if (effort === void 0) return void 0;
+	if (getSupportedThinkingLevels(model).some((level) => level === effort)) return effort;
+	throw new LlmError(`pi-ai provider "${model.provider}" model "${model.id}" does not support reasoning effort "${effort}"`, "UNSUPPORTED_REASONING_EFFORT");
+}
+/**
+* Selectable reasoning efforts for one model, or nothing at all.
+*
+* A model that carries no reasoning metadata — every hand-declared one, and
+* every catalog model pi-ai marks as non-reasoning — is reported by pi-ai as
+* supporting the single level `off`. Passing that through would offer a control
+* that cannot do what it says: `off` is translated to *omitting* the reasoning
+* option, which for such a model is byte-for-byte the same request as naming no
+* effort — so a provider whose own default is to think would keep thinking with
+* `off` selected. Omitting `reasoning` entirely is the seam's way of saying the
+* capability is unavailable, which leaves the surface offering only the
+* provider's default.
+* @param model - the resolved model descriptor.
+* @param defaultLevel - the profile's configured effort, already validated.
+* @returns the `reasoning` field, or an empty object when none can be offered.
+*/
+function reasoningInfo(model, defaultLevel) {
+	if (!model.reasoning) return {};
+	return { reasoning: {
+		efforts: getSupportedThinkingLevels(model).map((level) => ({
+			id: ReasoningEffortId(level),
+			name: `${level.charAt(0).toUpperCase()}${level.slice(1)}`
+		})),
+		...defaultLevel === void 0 ? {} : { defaultEffort: ReasoningEffortId(defaultLevel) }
+	} };
+}
+/** Merge deployment headers while removing case-insensitive attribution collisions. */
+function requestHeaders(headers, auth) {
+	const attribution = attributionHeaders();
+	const reserved = new Set([...Object.keys(attribution), ...Object.keys(auth ?? {})].map((name) => name.toLowerCase()));
+	return {
+		...Object.fromEntries(Object.entries(headers ?? {}).filter(([name]) => !reserved.has(name.toLowerCase()))),
+		...Object.fromEntries(Object.entries(auth ?? {}).filter(([name]) => !Object.keys(attribution).some((reservedName) => reservedName.toLowerCase() === name.toLowerCase()))),
+		...attribution
+	};
+}
+/**
+* pi-ai-backed multi-provider adapter. Each operation reads the current
+* profiles, so a configuration change reaches the next request without a
+* restart; model descriptors come from the collection those profiles built.
+*/
+var PiAiAdapter = class extends LlmAdapter {
+	config;
+	snapshot;
+	constructor(config) {
+		super();
+		this.config = config;
+	}
+	/**
+	* The snapshot for the current profiles. Resolution memoizes its result, so
+	* an unchanged configuration is recognized by identity; a changed one gets a
+	* brand-new collection, leaving any snapshot an operation already captured
+	* untouched for as long as that operation holds it.
+	*/
+	current() {
+		const profiles = this.config.profiles();
+		if (this.snapshot?.profiles === profiles) return this.snapshot;
+		const models = createModels(this.config.auth);
+		for (const profile of profiles.values()) models.setProvider(profile.piProvider);
+		this.snapshot = {
+			profiles,
+			models
+		};
+		return this.snapshot;
+	}
+	/** The profile for one route within one snapshot, or the not-owned failure. */
+	profileOf(snapshot, provider) {
+		const profile = snapshot.profiles.get(provider);
+		if (profile === void 0) throw new LlmError(`pi-ai adapter does not own provider "${provider}"`, "NO_ADAPTER");
+		return profile;
+	}
+	/** The configured descriptor for one exact route/model pair within one snapshot. */
+	modelOf(snapshot, provider, model) {
+		this.profileOf(snapshot, provider);
+		const resolved = snapshot.models.getModel(provider, model);
+		if (resolved === void 0) throw new LlmError(`pi-ai provider "${provider}" has no configured model "${model}"`, "UNKNOWN_MODEL");
+		return resolved;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: this.current().profiles.get(provider)?.displayName ?? provider
+		};
+	}
+	providerRetryPolicy(provider) {
+		return this.current().profiles.get(provider)?.retryPolicy;
+	}
+	listModels(provider) {
+		return Promise.resolve().then(() => {
+			const snapshot = this.current();
+			this.profileOf(snapshot, provider);
+			return snapshot.models.getModels(provider).map((model) => ({
+				provider,
+				id: model.id,
+				name: model.name,
+				inputModalities: [...model.input]
+			}));
+		});
+	}
+	resolveModel(provider, model, _signal) {
+		return Promise.resolve().then(() => {
+			const snapshot = this.current();
+			return this.modelInfo(snapshot, provider, model);
+		});
+	}
+	modelInfo(snapshot, provider, model) {
+		const profile = this.profileOf(snapshot, provider);
+		const resolvedModel = this.modelOf(snapshot, provider, model);
+		const defaultLevel = describableReasoningLevel(resolvedModel, profile.reasoning);
+		const configuredMaxTokens = profile.configuredMaxTokens.get(model);
+		return {
+			provider,
+			id: model,
+			name: resolvedModel.name,
+			inputModalities: [...resolvedModel.input],
+			context: { contextWindow: resolvedModel.contextWindow },
+			...configuredMaxTokens === void 0 ? {} : { defaultMaxTokens: configuredMaxTokens },
+			...reasoningInfo(resolvedModel, defaultLevel)
+		};
+	}
+	prepareCall(provider, model, _signal) {
+		const snapshot = this.current();
+		return Promise.resolve({
+			model: this.modelInfo(snapshot, provider, model),
+			stream: (options) => this.streamWithSnapshot(options, snapshot)
+		});
+	}
+	stream(options) {
+		return this.streamWithSnapshot(options, this.current());
+	}
+	async *streamWithSnapshot(options, snapshot) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			if (options.stop !== void 0) throw new LlmError("llm-pi-ai does not support GenerateOptions.stop", "UNSUPPORTED_OPTION");
+			const profile = this.profileOf(snapshot, options.provider);
+			const model = this.modelOf(snapshot, options.provider, options.model);
+			const reasoning = resolveReasoningLevel(model, options.reasoningEffort ?? profile.reasoning);
+			const auth = await this.config.resolveAuth(options.provider, profile);
+			const consumer = new AbortController();
+			const upstream = options.signal === void 0 ? consumer.signal : AbortSignal.any([options.signal, consumer.signal]);
+			const streamIdleTimeoutMs = profile.streamIdleTimeoutMs;
+			const watchdog = _usingCtx$1.u(idleWatchdog(upstream, streamIdleTimeoutMs, "LLM_STREAM_IDLE_TIMEOUT"));
+			try {
+				const containsImage = options.messages.some((message) => contentHasImage(message.content));
+				if (containsImage && !model.input.includes("image")) throw new LlmError(`pi-ai model "${model.id}" does not support image input`, "UNSUPPORTED_CONTENT");
+				const attachments = containsImage ? this.config.resolveAttachments?.() : void 0;
+				if (containsImage && attachments === void 0) throw new LlmError("pi-ai image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
+				const onReplayDegrade = (reason) => {
+					this.config.onReplayDegrade?.({
+						provider: options.provider,
+						model: options.model,
+						reason
+					});
+				};
+				const context = attachments === void 0 ? toPiContext(options, void 0, onReplayDegrade) : await toPiContext({
+					...options,
+					signal: watchdog.signal
+				}, {
+					attachments,
+					resolveImageAccess: (ref) => this.config.resolveImageAccess?.(attachments, ref),
+					maxRequestImageBytes: profile.maxRequestImageBytes,
+					requestImagePolicy: {
+						maxPixels: profile.requestImagePixelBudget,
+						maxBytes: profile.requestImageMaxBytes
+					}
+				}, onReplayDegrade);
+				const iterator = toStreamChunks(snapshot.models.streamSimple(model, context, {
+					...profileOptions(profile, reasoning, auth.apiKey),
+					...options.temperature === void 0 ? {} : { temperature: options.temperature },
+					...options.maxTokens === void 0 ? {} : { maxTokens: options.maxTokens },
+					...options.sessionId === void 0 ? {} : { sessionId: String(options.sessionId) },
+					signal: watchdog.signal,
+					headers: requestHeaders(profile.headers, auth.headers)
+				}), model.contextWindow, options.signal)[Symbol.asyncIterator]();
+				let exhausted = false;
+				try {
+					while (true) {
+						const result = await watchdog.next(iterator);
+						const timeout = timeoutOf(watchdog.signal, "LLM_STREAM_IDLE_TIMEOUT");
+						if (timeout !== void 0) throw timeout;
+						if (result.done) {
+							exhausted = true;
+							return;
+						}
+						yield result.value;
+					}
+				} finally {
+					if (!exhausted) {
+						consumer.abort("pi-ai stream consumer stopped");
+						try {
+							await iterator.return(void 0);
+						} catch (_abortedSdkTeardown) {}
+					}
+				}
+			} catch (error) {
+				if (timeoutOf(watchdog.signal, "LLM_STREAM_IDLE_TIMEOUT") !== void 0) throw new LlmError(`pi-ai stream idle timeout after ${streamIdleTimeoutMs}ms`, "TIMEOUT", { cause: error });
+				if (options.signal?.aborted) throw new LlmError("pi-ai request aborted by caller", "ABORTED", { cause: error });
+				throw error;
+			} finally {
+				consumer.abort("pi-ai stream consumer stopped");
+			}
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+};
+//#endregion
+//#region src/adapter.ts
+/** Aggregate imported models while dispatching each private route through its selected adapter. @module dsh-llm-chatcode-config/adapter */
+/** One public provider route containing every imported ChatCode custom model. */
+const CHATCODE_PROVIDER = "chatcode-custom";
+/** Display name for the unified imported-model group. */
+const CHATCODE_PROVIDER_NAME = "自定义模型";
+/** Provider route and selector group for centrally managed Coding Plan models. */
+const CODING_PLAN_PROVIDER = "chatcode-codingplan";
+const CODING_PLAN_PROVIDER_NAME = "内置模型";
+/** Provider route and selector group for opt-in MAAS models. */
+const MAAS_PROVIDER = "chatcode-maas";
+const MAAS_PROVIDER_NAME = "Maas平台";
+const DEEPSEEK_MODEL = /deepseek/i;
+function privateModelKey(route, model) {
+	return `${route}\u0000${model}`;
+}
+function createDeepSeekAdapter(route, profile, model, apiKey) {
+	const protocol = profile.api === "anthropic-messages" ? "messages" : profile.api === "openai-completions" ? "chat-completions" : void 0;
+	if (protocol === void 0 || profile.baseURL === void 0) throw new LlmError(`chatcode-config: DeepSeek model route "${route}" has no supported protocol or base URL`, "INVALID_CHATCODE_CONFIG");
+	const connection = {
+		...resolveAdapterOptions({
+			protocol,
+			baseURL: profile.baseURL,
+			defaultContextWindow: model.contextWindow,
+			maxTokens: model.maxTokens,
+			models: [{
+				id: model.id,
+				name: model.name,
+				contextWindow: model.contextWindow,
+				maxTokens: model.maxTokens,
+				inputModalities: [...model.input]
+			}],
+			streamIdleTimeoutMs: profile.streamIdleTimeoutMs
+		}),
+		retryPolicy: profile.retryPolicy
+	};
+	return new DeepSeekAdapter({
+		options: () => connection,
+		resolveApiKey: () => {
+			if (apiKey === void 0) throw new LlmError(`chatcode-config: no API key for DeepSeek model "${model.id}"`, "MISSING_CREDENTIAL");
+			return Promise.resolve(apiKey);
+		},
+		resolveUserId: () => getOrCreateAnonymousUserId(),
+		prepareExtensions: () => Promise.resolve({
+			fields: {},
+			accept: () => Promise.resolve()
+		})
+	});
+}
+/** A static unified ChatCode catalog with request adapters selected from actual model ids. */
+var ChatCodeAdapter = class extends LlmAdapter {
+	profiles;
+	provider;
+	providerName;
+	piAdapter;
+	deepSeekAdapters = /* @__PURE__ */ new Map();
+	routes = /* @__PURE__ */ new Map();
+	publicModels = /* @__PURE__ */ new Map();
+	constructor(options, profiles, provider = CHATCODE_PROVIDER, providerName = CHATCODE_PROVIDER_NAME, selections, apiKeys = /* @__PURE__ */ new Map()) {
+		super();
+		this.profiles = profiles;
+		this.provider = provider;
+		this.providerName = providerName;
+		this.piAdapter = new PiAiAdapter(options);
+		for (const [route, profile] of profiles) for (const model of profile.piProvider.getModels()) {
+			const selection = [...selections ?? /* @__PURE__ */ new Map()].find(([, target]) => target.route === route && target.model === model.id)?.[0] ?? model.id;
+			if (this.routes.has(selection)) throw new LlmError(`chatcode-config provider has duplicate public model "${selection}"`, "INVALID_CHATCODE_CONFIG");
+			this.routes.set(selection, {
+				selection,
+				route,
+				model: model.id
+			});
+			this.publicModels.set(privateModelKey(route, model.id), selection);
+			if (DEEPSEEK_MODEL.test(model.id)) this.deepSeekAdapters.set(privateModelKey(route, model.id), createDeepSeekAdapter(route, profile, model, apiKeys.get(route)));
+		}
+	}
+	requestAdapter(target) {
+		return this.deepSeekAdapters.get(privateModelKey(target.route, target.model)) ?? this.piAdapter;
+	}
+	/** Reject routes outside the one public provider registered by this adapter. */
+	assertProvider(provider) {
+		if (provider !== this.provider) throw new LlmError(`chatcode-config adapter does not own provider "${provider}"`, "NO_ADAPTER");
+	}
+	/** Resolve the private route for one publicly selected model. */
+	routeOf(provider, model) {
+		this.assertProvider(provider);
+		const target = this.routes.get(model);
+		if (target === void 0) throw new LlmError(`chatcode-config provider has no configured model "${model}"`, "UNKNOWN_MODEL");
+		return target;
+	}
+	validateOutput(options, target) {
+		const ceiling = this.profiles.get(target.route)?.configuredMaxTokens.get(target.model);
+		if (ceiling !== void 0 && options.maxTokens !== void 0 && options.maxTokens > ceiling) throw new LlmError("chatcode-config: maxTokens exceeds the configured model output limit", "UNSUPPORTED_OPTION");
+	}
+	providerInfo(provider) {
+		this.assertProvider(provider);
+		return {
+			id: provider,
+			name: this.providerName
+		};
+	}
+	providerRetryPolicy(_provider) {
+		return this.profiles.values().next().value?.retryPolicy;
+	}
+	async listModels(provider) {
+		this.assertProvider(provider);
+		return (await Promise.all([...this.profiles.keys()].map(async (route) => ({
+			route,
+			models: await this.piAdapter.listModels(route)
+		})))).flatMap(({ route, models }) => models.map((model) => ({
+			...model,
+			id: this.publicModels.get(privateModelKey(route, model.id)) ?? model.id,
+			provider: this.provider
+		})));
+	}
+	async resolveModel(provider, model, signal) {
+		const target = this.routeOf(provider, model);
+		return {
+			...await this.requestAdapter(target).resolveModel(target.route, target.model, signal),
+			id: target.selection,
+			provider: this.provider
+		};
+	}
+	async prepareCall(provider, model, signal) {
+		const target = this.routeOf(provider, model);
+		const prepared = await this.requestAdapter(target).prepareCall(target.route, target.model, signal);
+		return {
+			model: {
+				...prepared.model,
+				id: target.selection,
+				provider: this.provider
+			},
+			stream: (options) => {
+				const preparedTarget = this.routeOf(options.provider, options.model);
+				this.validateOutput(options, preparedTarget);
+				return prepared.stream({
+					...options,
+					provider: preparedTarget.route,
+					model: preparedTarget.model
+				});
+			}
+		};
+	}
+	stream(options) {
+		const target = this.routeOf(options.provider, options.model);
+		this.validateOutput(options, target);
+		return this.requestAdapter(target).stream({
+			...options,
+			provider: target.route,
+			model: target.model
+		});
+	}
+};
+/** Live custom-model adapter whose prepared calls retain their starting settings snapshot. */
+var LiveChatCodeAdapter = class extends LlmAdapter {
+	source;
+	provider;
+	providerName;
+	snapshot;
+	constructor(source, provider = CHATCODE_PROVIDER, providerName = CHATCODE_PROVIDER_NAME) {
+		super();
+		this.source = source;
+		this.provider = provider;
+		this.providerName = providerName;
+	}
+	current() {
+		const source = this.source();
+		if (this.snapshot?.source === source) return this.snapshot.adapter;
+		const adapter = new ChatCodeAdapter({
+			profiles: () => source.profiles,
+			resolveAuth: (route) => {
+				const auth = source.auth.get(route);
+				if (auth === void 0) throw new LlmError("chatcode-config: missing auth for resolved profile", "INVARIANT");
+				return Promise.resolve(auth);
+			},
+			auth: isolatedPiAiAuth()
+		}, source.profiles, this.provider, this.providerName, source.selections, source.apiKeys);
+		this.snapshot = {
+			source,
+			adapter
+		};
+		return adapter;
+	}
+	providerInfo(provider) {
+		return this.current().providerInfo(provider);
+	}
+	providerRetryPolicy(provider) {
+		return this.current().providerRetryPolicy(provider);
+	}
+	listModels(provider) {
+		return this.current().listModels(provider);
+	}
+	resolveModel(provider, model, signal) {
+		return this.current().resolveModel(provider, model, signal);
+	}
+	prepareCall(provider, model, signal) {
+		return this.current().prepareCall(provider, model, signal);
+	}
+	stream(options) {
+		return this.current().stream(options);
+	}
+};
+//#endregion
+//#region src/chatcode-auth.ts
+/** ChatCode session login and its shared, host-only credential record. */
+/** Keep the address stable for grants written by the initial implementation. */
+const CHATCODE_CREDENTIAL_KEY = credentialKey("chatcode-auth", "default");
+/** Process-scoped credential accepted from immutable desktop/terminal launchers. */
+const CHATCODE_CLI_OAUTH_TOKEN = "CHATCODE_CLI_OAUTH_TOKEN";
+const objectOf = (value) => value !== null && typeof value === "object" ? value : {};
+const stringOf = (value) => typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+const finiteTime = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 && value <= 864e13;
+function endpoint(value) {
+	const url = new URL(value);
+	if (url.username || url.password || url.protocol !== "https:" && !(url.protocol === "http:" && [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname))) throw new Error("ChatCode endpoints require HTTPS (HTTP is allowed only on loopback).");
+	return url;
+}
+/** Preserve the configured hash-router query while adding this attempt's UUID. */
+function loginUrlOf(loginUrl, sessionId) {
+	const url = endpoint(loginUrl);
+	if (!url.hash) url.searchParams.set("sessionId", sessionId);
+	else {
+		const hash = url.hash.slice(1);
+		const split = hash.indexOf("?");
+		const route = split < 0 ? hash : hash.slice(0, split);
+		const params = new URLSearchParams(split < 0 ? "" : hash.slice(split + 1));
+		params.set("sessionId", sessionId);
+		url.hash = `${route}?${params.toString()}`;
+	}
+	return url.href;
+}
+/** Decode both the original payload and the concurrency-safe envelope. */
+function grantOf(value) {
+	const envelope = objectOf(value);
+	const candidate = envelope.version === 2 ? objectOf(envelope.grant) : envelope;
+	if (candidate.version !== 1 || !stringOf(candidate.accessToken)) return void 0;
+	for (const field of [
+		"refreshToken",
+		"longToken",
+		"userName",
+		"emailAddress"
+	]) if (candidate[field] !== void 0 && typeof candidate[field] !== "string") return void 0;
+	if (candidate.expiresAtMs !== void 0 && !finiteTime(candidate.expiresAtMs)) return void 0;
+	return {
+		version: 1,
+		accessToken: stringOf(candidate.accessToken),
+		...candidate.refreshToken === void 0 ? {} : { refreshToken: candidate.refreshToken },
+		...candidate.longToken === void 0 ? {} : { longToken: candidate.longToken },
+		...candidate.userName === void 0 ? {} : { userName: candidate.userName },
+		...candidate.emailAddress === void 0 ? {} : { emailAddress: candidate.emailAddress },
+		...candidate.expiresAtMs === void 0 ? {} : { expiresAtMs: candidate.expiresAtMs }
+	};
+}
+function stateOf(record) {
+	const payload = objectOf(record?.kind === "grant" ? record.payload : void 0);
+	const grant = grantOf(payload);
+	const state = {
+		version: 2,
+		...grant ? { grant } : {}
+	};
+	if (payload.version !== 2) return state;
+	const login = objectOf(payload.login);
+	if (typeof login.sessionId === "string" && finiteTime(login.expiresAtMs) && [
+		"pending",
+		"succeeded",
+		"failed",
+		"timed-out",
+		"cancelled"
+	].includes(String(login.state))) state.login = {
+		sessionId: login.sessionId,
+		state: login.state,
+		expiresAtMs: login.expiresAtMs
+	};
+	if ([
+		"valid",
+		"invalid",
+		"unavailable"
+	].includes(String(payload.validation)) && finiteTime(payload.checkedAtMs)) {
+		state.validation = payload.validation;
+		state.checkedAtMs = payload.checkedAtMs;
+	}
+	return state;
+}
+function recordOf(state) {
+	return {
+		kind: "grant",
+		payload: { ...state }
+	};
+}
+function emailOf(value) {
+	const root = objectOf(value);
+	const data = objectOf(root.data);
+	for (const source of [
+		data,
+		objectOf(data.account),
+		root
+	]) for (const key of [
+		"email",
+		"emailAddress",
+		"userEmail",
+		"mail"
+	]) {
+		const email = stringOf(source[key]);
+		if (email && email.length <= 320 && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) return email;
+	}
+}
+function responseGrant(body, previous) {
+	const data = objectOf(objectOf(body).data);
+	const accessToken = stringOf(data.access_token);
+	if (!accessToken) return void 0;
+	const expiresAtMs = typeof data.expires_in === "number" && data.expires_in > 0 ? Date.now() + data.expires_in * 1e3 : void 0;
+	const grant = {
+		version: 1,
+		accessToken
+	};
+	for (const [target, source] of [
+		["refreshToken", "refresh_token"],
+		["longToken", "longToken"],
+		["userName", "userName"]
+	]) {
+		const value = stringOf(data[source]) ?? previous?.[target];
+		if (value) grant[target] = value;
+	}
+	if (finiteTime(expiresAtMs)) grant.expiresAtMs = expiresAtMs;
+	if (previous?.emailAddress) grant.emailAddress = previous.emailAddress;
+	return grant;
+}
+function stale(grant) {
+	return grant.expiresAtMs !== void 0 && grant.expiresAtMs <= Date.now() + 3e4;
+}
+/**
+* Snapshot the desktop grant only from the inherited process environment.
+* Project/user .env files are deliberately excluded: this credential is an
+* explicit property of one host launch, not durable ChatCode CLI configuration.
+*/
+function chatCodeEnvironmentToken(ctx) {
+	return stringOf(launchEnvironmentOf(ctx).getFrom(CHATCODE_CLI_OAUTH_TOKEN, ["process"])?.value);
+}
+/** One protocol owner, shared across Web and TUI through credentials-local's file lock. */
+var ChatCodeAuthService = class extends Service {
+	credentials;
+	options;
+	lifetime = new AbortController();
+	active = /* @__PURE__ */ new Map();
+	failures = /* @__PURE__ */ new Map();
+	tasks = /* @__PURE__ */ new Set();
+	/** A new host process must contact ChatCode once before trusting persisted validation metadata. */
+	startupValidationPending = true;
+	environmentAccessToken;
+	constructor(ctx, credentials, options, environmentAccessToken) {
+		super(ctx, "chatcodeAuth");
+		this.credentials = credentials;
+		this.options = options;
+		this.environmentAccessToken = stringOf(environmentAccessToken);
+		endpoint(options.loginUrl);
+		endpoint(options.apiBaseUrl);
+		ctx.effect(() => async () => {
+			this.lifetime.abort();
+			await Promise.allSettled(this.tasks);
+		}, "chatcode-auth: stop pending requests");
+	}
+	async mutate(fn) {
+		try {
+			return stateOf(await this.credentials.modifyRecord(CHATCODE_CREDENTIAL_KEY, async (record) => {
+				const next = await fn(stateOf(record));
+				return next === void 0 ? void 0 : recordOf(next);
+			}));
+		} catch {
+			throw new Error("ChatCode credential operation failed; check the ChatCode CLI credential store permissions and availability.");
+		}
+	}
+	async ensure(signal, force = false) {
+		const combined = AbortSignal.any([
+			this.lifetime.signal,
+			...signal ? [signal] : [],
+			AbortSignal.timeout(Math.min(2e4, this.options.requestTimeoutMs * 3))
+		]);
+		combined.throwIfAborted();
+		return await this.mutate(async (current) => {
+			combined.throwIfAborted();
+			const grant = current.grant;
+			if (!grant) {
+				this.startupValidationPending = false;
+				return;
+			}
+			if (!force && !this.startupValidationPending) return void 0;
+			let next = grant;
+			let result;
+			try {
+				if (stale(grant)) {
+					const refreshed = await this.refresh(grant, combined);
+					if (refreshed.grant) next = refreshed.grant;
+					result = refreshed.grant ? await this.account(next, combined) : { validation: refreshed.validation };
+				} else {
+					result = await this.account(grant, combined);
+					if (result.validation === "invalid") {
+						const refreshed = await this.refresh(grant, combined);
+						if (refreshed.grant) {
+							next = refreshed.grant;
+							result = await this.account(next, combined);
+						} else result = { validation: refreshed.validation };
+					}
+				}
+			} finally {
+				this.startupValidationPending = false;
+			}
+			if (result.emailAddress) next = {
+				...next,
+				emailAddress: result.emailAddress
+			};
+			signal?.throwIfAborted();
+			this.lifetime.signal.throwIfAborted();
+			return {
+				...current,
+				grant: next,
+				validation: result.validation,
+				checkedAtMs: Date.now()
+			};
+		});
+	}
+	async status(options = {}) {
+		if (this.environmentAccessToken !== void 0) return {
+			required: this.options.requireLogin !== false,
+			configured: true,
+			expired: false,
+			validation: "valid"
+		};
+		const state = await this.ensure(void 0, options.force === true);
+		const grant = state.grant;
+		const login = state.login?.state === "pending" ? this.failures.get(state.login.sessionId) ?? state.login : state.login;
+		return {
+			required: this.options.requireLogin !== false,
+			configured: grant !== void 0,
+			expired: grant?.expiresAtMs !== void 0 && grant.expiresAtMs <= Date.now(),
+			validation: grant ? state.validation ?? "unavailable" : "none",
+			...grant?.expiresAtMs === void 0 ? {} : { expiresAtMs: grant.expiresAtMs },
+			...grant?.userName ? { userName: grant.userName } : {},
+			...grant?.emailAddress ? { emailAddress: grant.emailAddress } : {},
+			...login ? { login: login.state === "pending" && login.expiresAtMs <= Date.now() ? {
+				...login,
+				state: "timed-out"
+			} : login } : {}
+		};
+	}
+	async accessToken(signal) {
+		signal?.throwIfAborted();
+		if (this.environmentAccessToken !== void 0) return this.environmentAccessToken;
+		const state = await this.ensure(signal);
+		signal?.throwIfAborted();
+		return state.validation === "valid" && state.grant && (state.grant.expiresAtMs === void 0 || state.grant.expiresAtMs > Date.now()) ? state.grant.accessToken : void 0;
+	}
+	environmentTokenActive() {
+		return this.environmentAccessToken !== void 0;
+	}
+	async startLogin() {
+		if (this.environmentAccessToken !== void 0) throw new Error("ChatCode authentication is provided by the launch environment.");
+		this.lifetime.signal.throwIfAborted();
+		const sessionId = randomUUID();
+		const url = loginUrlOf(this.options.loginUrl, sessionId);
+		const login = {
+			sessionId,
+			state: "pending",
+			expiresAtMs: Date.now() + this.options.pollTimeoutMs
+		};
+		await this.mutate(async (current) => {
+			this.lifetime.signal.throwIfAborted();
+			for (const controller of this.active.values()) controller.abort();
+			return {
+				...current,
+				login
+			};
+		});
+		this.failures.clear();
+		const controller = new AbortController();
+		this.active.set(sessionId, controller);
+		const signal = AbortSignal.any([
+			controller.signal,
+			this.lifetime.signal,
+			AbortSignal.timeout(this.options.pollTimeoutMs)
+		]);
+		const task = this.pollAndCommit(login, signal).catch(async () => {
+			const state = Date.now() >= login.expiresAtMs ? "timed-out" : signal.aborted ? "cancelled" : "failed";
+			const failed = {
+				...login,
+				state
+			};
+			try {
+				await this.finish(failed);
+			} catch {
+				this.failures.set(sessionId, failed);
+			}
+		}).finally(() => {
+			this.active.delete(sessionId);
+			this.tasks.delete(task);
+		});
+		this.tasks.add(task);
+		return {
+			sessionId,
+			url
+		};
+	}
+	async logout() {
+		if (this.environmentAccessToken !== void 0) return;
+		for (const controller of this.active.values()) controller.abort();
+		await this.mutate(async (current) => ({
+			version: 2,
+			...current.login ? { login: {
+				...current.login,
+				state: "cancelled"
+			} } : {}
+		}));
+		this.failures.clear();
+	}
+	async cancelLogin(sessionId) {
+		this.active.get(sessionId)?.abort();
+		await this.mutate(async (current) => current.login?.sessionId === sessionId && current.login.state === "pending" ? {
+			...current,
+			login: {
+				...current.login,
+				state: "cancelled"
+			}
+		} : void 0);
+	}
+	async waitForLogin(sessionId, signal) {
+		const combined = AbortSignal.any([this.lifetime.signal, ...signal ? [signal] : []]);
+		while (true) {
+			combined.throwIfAborted();
+			const status = await this.status();
+			if (status.login?.sessionId !== sessionId) return "cancelled";
+			if (status.login.state !== "pending") return status.login.state;
+			await setTimeout$1(this.options.pollIntervalMs, void 0, { signal: combined });
+		}
+	}
+	async finish(login) {
+		await this.mutate(async (current) => current.login?.sessionId === login.sessionId && current.login.state === "pending" ? {
+			...current,
+			login
+		} : void 0);
+	}
+	async pollAndCommit(login, signal) {
+		let grant;
+		while (Date.now() < login.expiresAtMs) {
+			signal.throwIfAborted();
+			const current = await this.mutate(async () => void 0);
+			if (current.login?.sessionId !== login.sessionId || current.login.state !== "pending") return;
+			if (!grant) {
+				const response = await this.request(`/caassist-api-lt/caassist/api/account/session/login?${new URLSearchParams({ sessionId: login.sessionId })}`, {
+					method: "GET",
+					signal
+				});
+				if (response?.ok) grant = responseGrant(response.body);
+			}
+			if (grant) {
+				const account = await this.account(grant, signal);
+				if (account.validation === "invalid") throw new Error("ChatCode rejected the login grant.");
+				if (account.validation === "valid") {
+					const validated = {
+						...grant,
+						...account.emailAddress ? { emailAddress: account.emailAddress } : {}
+					};
+					await this.mutate(async (latest) => {
+						signal.throwIfAborted();
+						if (latest.login?.sessionId !== login.sessionId || latest.login.state !== "pending") return void 0;
+						return {
+							version: 2,
+							grant: validated,
+							validation: "valid",
+							checkedAtMs: Date.now(),
+							login: {
+								...login,
+								state: "succeeded"
+							}
+						};
+					});
+					return;
+				}
+			}
+			await setTimeout$1(Math.min(this.options.pollIntervalMs, Math.max(1, login.expiresAtMs - Date.now())), void 0, { signal });
+		}
+		await this.finish({
+			...login,
+			state: "timed-out"
+		});
+	}
+	async account(grant, signal) {
+		const response = await this.request("/caassist-api-lt/caassist/api/account/info", {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${grant.accessToken}`,
+				"content-type": "application/json"
+			},
+			body: "{}",
+			signal
+		});
+		const body = objectOf(response?.body);
+		if (response?.status === 401 || response?.status === 403 || body.code === "76021501") return { validation: "invalid" };
+		if (!response?.ok || !(body.success === true || body.code === "00000000")) return { validation: "unavailable" };
+		const emailAddress = emailOf(body);
+		return {
+			validation: "valid",
+			...emailAddress ? { emailAddress } : {}
+		};
+	}
+	async refresh(current, signal) {
+		const username = current.userName || current.emailAddress;
+		if (!username || !current.longToken) return { validation: "invalid" };
+		const response = await this.request("/caassist-api-lt/caassist/api/account/long/login", {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				username,
+				longToken: current.longToken
+			}),
+			signal
+		});
+		const body = objectOf(response?.body);
+		const grant = response?.ok ? responseGrant(body, current) : void 0;
+		if (grant) return {
+			grant,
+			validation: "unavailable"
+		};
+		return { validation: response?.status === 401 || response?.status === 403 || body.code === "76021501" || body.success === false ? "invalid" : "unavailable" };
+	}
+	async request(path, init) {
+		const signal = AbortSignal.any([
+			this.lifetime.signal,
+			...init.signal ? [init.signal] : [],
+			AbortSignal.timeout(this.options.requestTimeoutMs)
+		]);
+		try {
+			const response = await fetch(new URL(path, this.options.apiBaseUrl), {
+				...init,
+				signal,
+				redirect: "error"
+			});
+			return {
+				ok: response.ok,
+				status: response.status,
+				body: await response.json().catch(() => void 0)
+			};
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+//#region src/config.ts
+/** Mount and settings configuration for ChatCode model sources. @module dsh-llm-chatcode-config/config */
+/** Validate mounting options without exposing control-plane credentials. */
+const Config = z.object({
+	settingsPath: z.string(),
+	customModels: z.array(z.object({
+		model: z.string().required(),
+		apiKey: z.string().required().role("secret"),
+		baseUrl: z.string().required(),
+		description: z.string(),
+		provider: z.union([z.string(), z.const(null)]),
+		protocol: z.string(),
+		contextWindow: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER),
+		maxTokens: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER),
+		maxInputTokens: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER)
+	})).default([]),
+	defaultContextWindow: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER).default(262144),
+	defaultMaxTokens: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER).default(4096),
+	retryPolicy: RetryPolicySchema,
+	auth: z.object({
+		requireLogin: z.boolean().default(true),
+		loginUrl: z.string().default("https://chatcode.chinaunicom.cn/unicode/#/login"),
+		apiBaseUrl: z.string().default("https://chatcode.chinaunicom.cn"),
+		pollIntervalMs: z.number().step(1).min(250).max(6e4).default(1e3),
+		pollTimeoutMs: z.number().step(1).min(1e3).max(72e5).default(36e5),
+		requestTimeoutMs: z.number().step(1).min(1e3).max(6e4).default(5e3)
+	}).default({
+		requireLogin: true,
+		loginUrl: "https://chatcode.chinaunicom.cn/unicode/#/login",
+		apiBaseUrl: "https://chatcode.chinaunicom.cn",
+		pollIntervalMs: 1e3,
+		pollTimeoutMs: 36e5,
+		requestTimeoutMs: 5e3
+	}),
+	cvpChatCodeApiUrl: z.string().default("https://chatcode.chinaunicom.cn/cvp"),
+	startupGate: z.object({
+		token: z.string().role("secret").default(""),
+		timeoutMs: z.number().step(1).min(1e3).max(6e4).default(5e3)
+	}).default({
+		token: "",
+		timeoutMs: 5e3
+	}),
+	reporting: z.object({
+		enabled: z.boolean().default(true),
+		codeSave: z.boolean().default(true),
+		conversationSync: z.boolean().default(true),
+		chatCodeSession: z.boolean().default(true),
+		codeBatchItems: z.number().step(1).min(1).max(500).default(50),
+		codeBatchChars: z.number().step(1).min(1024).max(5242880).default(524288),
+		codeRetryDelayMs: z.number().step(1).min(1e3).max(3e5).default(5e3),
+		codeOutboxDir: z.string().default(""),
+		includeSubagentConversationSync: z.boolean().default(false),
+		modelKindRules: z.array(z.object({
+			provider: z.string(),
+			model: z.string(),
+			kind: z.number().step(1).min(0).max(3).required()
+		})).default([])
+	}).default({
+		enabled: true,
+		codeSave: true,
+		conversationSync: true,
+		chatCodeSession: true,
+		codeBatchItems: 50,
+		codeBatchChars: 524288,
+		codeRetryDelayMs: 5e3,
+		codeOutboxDir: "",
+		includeSubagentConversationSync: false,
+		modelKindRules: []
+	}),
+	codingPlanEndpoint: z.string().default("https://chatcode.chinaunicom.cn/cvp/api/cli/v1/model-runtime-configs"),
+	enableMaas: z.boolean().default(false),
+	maasEndpoint: z.string().default("https://chatcode.chinaunicom.cn/cvp/wanma/api/v1/cli/maas-models"),
+	catalogTimeoutMs: z.number().step(1).min(1).max(6e4).default(1e4)
+});
+//#endregion
+//#region src/managed.ts
+/** Read centrally managed model catalogs without exposing their credentials. @module dsh-llm-chatcode-config/managed */
+/** Resolve the OS account that launched the current DSH host. */
+function currentUserName() {
+	const environmentName = process.env.USERNAME?.trim() || process.env.USER?.trim();
+	if (environmentName !== void 0 && environmentName !== "") return environmentName;
+	try {
+		return userInfo().username.trim();
+	} catch {
+		return "";
+	}
+}
+/** Query fields required by the CodingPlan runtime catalogue. */
+function runtimeQuery(userName = currentUserName()) {
+	return { userEmail: userName };
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function string(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function positive(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+const DIAGNOSTIC_BODY_LIMIT = 16e3;
+const SENSITIVE_FIELD = /(?:api[-_]?key|access[-_]?token|refresh[-_]?token|long[-_]?token|authorization|password|secret)/i;
+/** Render enough of a JSON response to diagnose its shape without logging credentials. */
+function diagnosticBody(value) {
+	try {
+		const rendered = JSON.stringify(value, (key, item) => SENSITIVE_FIELD.test(key) ? "[REDACTED]" : item);
+		if (rendered === void 0) return "<empty>";
+		return rendered.length <= DIAGNOSTIC_BODY_LIMIT ? rendered : `${rendered.slice(0, DIAGNOSTIC_BODY_LIMIT)}...<truncated>`;
+	} catch {
+		return "<unserializable JSON>";
+	}
+}
+function catalogHeaders(authorization, noCache = false) {
+	const accessToken = authorization?.accessToken.trim();
+	if (accessToken !== void 0 && accessToken !== "" && !/[\r\n]/.test(accessToken)) return {
+		Accept: "application/json",
+		...noCache ? { "Cache-Control": "no-cache" } : {},
+		Authorization: `Bearer ${accessToken}`,
+		accessToken
+	};
+	return {
+		Accept: "application/json",
+		...noCache ? { "Cache-Control": "no-cache" } : {}
+	};
+}
+function protocolOf$1(model) {
+	switch (model.protocol?.trim().toLowerCase()) {
+		case "openai": return "openai-completions";
+		case "anthropic": return "anthropic-messages";
+		default: return;
+	}
+}
+/** Accept gateway roots and a complete OpenAI chat-completions URL from the control plane. */
+function endpointOf$1(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return;
+	}
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) return void 0;
+	url.pathname = url.pathname.replace(/\/chat\/completions\/?$/i, "") || "/";
+	return url.href.replace(/\/+$/, "");
+}
+function requestApiKey(apiKey) {
+	if (apiKey === void 0 || apiKey.trim() === "" || /^\*+$/.test(apiKey.trim()) || /[\r\n]/.test(apiKey)) return void 0;
+	return apiKey;
+}
+function requestAuth(protocol, apiKey) {
+	if (apiKey === void 0) return {};
+	return protocol === "anthropic-messages" ? { headers: { Authorization: `Bearer ${apiKey}` } } : { apiKey };
+}
+/** Fetch the supported control-plane response shape and report only generic, non-secret errors. */
+async function fetchRuntimeModels(endpoint, timeoutMs, authorization, diagnostic) {
+	let url;
+	try {
+		url = new URL(endpoint);
+	} catch {
+		throw new LlmError("chatcode-config: managed model endpoint is invalid", "INVALID_CHATCODE_CONFIG");
+	}
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new LlmError("chatcode-config: managed model endpoint must be HTTP(S) without credentials", "INVALID_CHATCODE_CONFIG");
+	for (const [key, value] of Object.entries(runtimeQuery())) url.searchParams.set(key, value);
+	diagnostic?.(`chatcode-config: CodingPlan request GET ${url.href}`);
+	let response;
+	try {
+		response = await fetch(url, {
+			headers: catalogHeaders(authorization),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch (error) {
+		diagnostic?.(`chatcode-config: CodingPlan request failed before a response (${error instanceof Error ? error.message : String(error)})`);
+		throw new LlmError("chatcode-config: managed model catalog is unavailable", "MANAGED_MODEL_CATALOG_UNAVAILABLE");
+	}
+	let body;
+	try {
+		body = await response.json();
+		diagnostic?.(`chatcode-config: CodingPlan response status=${response.status} body=${diagnosticBody(body)}`);
+	} catch {
+		diagnostic?.(`chatcode-config: CodingPlan response status=${response.status} body=<invalid JSON>`);
+		throw new LlmError("chatcode-config: managed model catalog returned invalid JSON", "MANAGED_MODEL_CATALOG_INVALID");
+	}
+	if (!response.ok) throw new LlmError("chatcode-config: managed model catalog request failed", "MANAGED_MODEL_CATALOG_UNAVAILABLE");
+	const top = record(body);
+	const data = top === void 0 ? void 0 : record(top.data);
+	const rows = data === void 0 ? void 0 : data.models;
+	if (top?.code !== "00000000" || !Array.isArray(rows)) throw new LlmError("chatcode-config: managed model catalog returned an invalid response", "MANAGED_MODEL_CATALOG_INVALID");
+	const models = rows.flatMap((row) => {
+		const item = record(row);
+		if (item === void 0) return [];
+		const logicalModelId = string(item.logicalModelId);
+		if (logicalModelId === void 0 || logicalModelId.trim() === "") return [];
+		const parsed = {
+			logicalModelId,
+			displayName: string(item.displayName) ?? logicalModelId
+		};
+		const description = string(item.description);
+		const protocol = string(item.protocol);
+		const provider = string(item.provider);
+		const baseUrl = string(item.baseUrl);
+		const providerModelId = string(item.providerModelId);
+		const apiKey = string(item.apiKey);
+		const maxToken = positive(item.maxToken);
+		const contextWindow = positive(item.contextWindow);
+		if (description !== void 0) parsed.description = description;
+		if (protocol !== void 0) parsed.protocol = protocol;
+		if (provider !== void 0) parsed.provider = provider;
+		if (baseUrl !== void 0) parsed.baseUrl = baseUrl;
+		if (providerModelId !== void 0) parsed.providerModelId = providerModelId;
+		if (apiKey !== void 0) parsed.apiKey = apiKey;
+		if (maxToken !== void 0) parsed.maxToken = maxToken;
+		if (contextWindow !== void 0) parsed.contextWindow = contextWindow;
+		return [parsed];
+	});
+	diagnostic?.(`chatcode-config: CodingPlan parsed ${String(rows.length)} response rows into ${String(models.length)} model records`);
+	return models;
+}
+/** Fetch the public MAAS catalog. It intentionally contains no endpoint or credential fields. */
+async function fetchMaasCatalog(endpoint, timeoutMs, authorization) {
+	let url;
+	try {
+		url = new URL(endpoint);
+	} catch {
+		throw new LlmError("chatcode-config: MAAS model endpoint is invalid", "INVALID_CHATCODE_CONFIG");
+	}
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new LlmError("chatcode-config: MAAS model endpoint must be HTTP(S) without credentials", "INVALID_CHATCODE_CONFIG");
+	let response;
+	try {
+		response = await fetch(url, {
+			headers: catalogHeaders(authorization, true),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch {
+		throw new LlmError("chatcode-config: MAAS model catalog is unavailable", "MANAGED_MODEL_CATALOG_UNAVAILABLE");
+	}
+	if (!response.ok) throw new LlmError("chatcode-config: MAAS model catalog request failed", "MANAGED_MODEL_CATALOG_UNAVAILABLE");
+	let body;
+	try {
+		body = await response.json();
+	} catch {
+		throw new LlmError("chatcode-config: MAAS model catalog returned invalid JSON", "MANAGED_MODEL_CATALOG_INVALID");
+	}
+	const top = record(body);
+	if (top?.code !== 200 || !Array.isArray(top.data)) throw new LlmError("chatcode-config: MAAS model catalog returned an invalid response", "MANAGED_MODEL_CATALOG_INVALID");
+	return top.data.flatMap((row) => {
+		const item = record(row);
+		const id = positive(item?.id);
+		const logicalModelId = string(item?.logicalModelId)?.trim();
+		if (id === void 0 || logicalModelId === void 0 || logicalModelId === "") return [];
+		const parsed = {
+			id,
+			logicalModelId,
+			displayName: string(item?.displayName)?.trim() || logicalModelId
+		};
+		const description = string(item?.description);
+		const protocol = string(item?.protocol);
+		const model = string(item?.model);
+		const maxTokens = positive(item?.maxTokens);
+		const contextWindow = positive(item?.contextWindow);
+		if (description !== void 0) parsed.description = description;
+		if (protocol !== void 0) parsed.protocol = protocol;
+		if (model !== void 0) parsed.model = model;
+		if (maxTokens !== void 0) parsed.maxTokens = maxTokens;
+		if (contextWindow !== void 0) parsed.contextWindow = contextWindow;
+		return [parsed];
+	});
+}
+function maasRuntimeUrl(catalogEndpoint, id) {
+	let url;
+	try {
+		url = new URL(catalogEndpoint);
+	} catch {
+		throw new LlmError("chatcode-config: MAAS model endpoint is invalid", "INVALID_CHATCODE_CONFIG");
+	}
+	const path = url.pathname.replace(/\/+$/, "");
+	if (!path.endsWith("/maas-models")) throw new LlmError("chatcode-config: MAAS endpoint must end with /maas-models", "INVALID_CHATCODE_CONFIG");
+	url.pathname = `${path}/${String(id)}/runtime-config`;
+	url.search = "";
+	return url;
+}
+/** Fetch one selected MAAS model's private runtime configuration. */
+async function fetchMaasRuntime(endpoint, catalog, timeoutMs, authorization) {
+	const url = maasRuntimeUrl(endpoint, catalog.id);
+	let response;
+	try {
+		response = await fetch(url, {
+			headers: catalogHeaders(authorization, true),
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch {
+		throw new LlmError("chatcode-config: MAAS runtime configuration is unavailable", "MANAGED_MODEL_CATALOG_UNAVAILABLE");
+	}
+	if (!response.ok) throw new LlmError("chatcode-config: MAAS runtime configuration request failed", "MANAGED_MODEL_CATALOG_UNAVAILABLE");
+	let body;
+	try {
+		body = await response.json();
+	} catch {
+		throw new LlmError("chatcode-config: MAAS runtime configuration returned invalid JSON", "MANAGED_MODEL_CATALOG_INVALID");
+	}
+	const top = record(body);
+	const data = top === void 0 ? void 0 : record(top.data);
+	const runtimeId = positive(data?.id);
+	if (top?.code !== 200 || data === void 0 || runtimeId !== void 0 && runtimeId !== catalog.id) throw new LlmError("chatcode-config: MAAS runtime configuration returned an invalid response", "MANAGED_MODEL_CATALOG_INVALID");
+	const logicalModelId = string(data.logicalModelId)?.trim() || catalog.logicalModelId;
+	const providerModelId = string(data.model)?.trim() || catalog.model?.trim();
+	const baseUrl = string(data.baseUrl);
+	if (logicalModelId === void 0 || logicalModelId === "" || providerModelId === void 0 || providerModelId === "" || baseUrl === void 0) return void 0;
+	const parsed = {
+		logicalModelId,
+		displayName: string(data.displayName)?.trim() || catalog.displayName,
+		baseUrl,
+		providerModelId
+	};
+	const description = string(data.description) ?? catalog.description;
+	const protocol = string(data.protocol) ?? catalog.protocol;
+	const apiKey = string(data.apiKey);
+	const maxToken = positive(data.maxTokens) ?? catalog.maxTokens;
+	const contextWindow = positive(data.contextWindow) ?? catalog.contextWindow;
+	if (description !== void 0) parsed.description = description;
+	if (protocol !== void 0) parsed.protocol = protocol;
+	if (apiKey !== void 0) parsed.apiKey = apiKey;
+	if (maxToken !== void 0) parsed.maxToken = maxToken;
+	if (contextWindow !== void 0) parsed.contextWindow = contextWindow;
+	return parsed;
+}
+/** Resolve every public MAAS entry through its private runtime endpoint before publishing it as selectable. */
+async function fetchMaasRuntimeModels(endpoint, timeoutMs, authorization) {
+	const catalog = await fetchMaasCatalog(endpoint, timeoutMs, authorization);
+	return (await Promise.all(catalog.map(async (item) => {
+		try {
+			return await fetchMaasRuntime(endpoint, item, timeoutMs, authorization);
+		} catch (error) {
+			if (error instanceof LlmError) return void 0;
+			throw error;
+		}
+	}))).flatMap((model) => model === void 0 ? [] : [model]);
+}
+/** Translate runnable managed entries into detached pi-ai routes. Incomplete public metadata is deliberately not selectable. */
+function resolveManagedSource(models, group, config) {
+	const profiles = {};
+	const auth = /* @__PURE__ */ new Map();
+	const apiKeys = /* @__PURE__ */ new Map();
+	const selections = /* @__PURE__ */ new Map();
+	for (const entry of models) {
+		const protocol = protocolOf$1(entry);
+		const baseURL = entry.baseUrl === void 0 ? void 0 : endpointOf$1(entry.baseUrl);
+		const providerModelId = entry.providerModelId?.trim();
+		if (protocol === void 0 || baseURL === void 0 || providerModelId === void 0 || providerModelId === "") continue;
+		const selection = entry.logicalModelId.trim();
+		if (selection === "" || selections.has(selection)) continue;
+		const route = `managed-${group}-${createHash("sha256").update(JSON.stringify([
+			protocol,
+			baseURL,
+			providerModelId,
+			selection
+		])).digest("hex").slice(0, 20)}`;
+		profiles[route] = {
+			displayName: entry.displayName.trim() || selection,
+			api: protocol,
+			baseURL,
+			models: [{
+				id: providerModelId,
+				name: entry.displayName.trim() || selection,
+				contextWindow: entry.contextWindow ?? entry.maxToken ?? config.defaultContextWindow,
+				maxTokens: entry.maxToken ?? config.defaultMaxTokens
+			}],
+			...protocol === "openai-completions" ? {
+				compat: {
+					maxTokensField: "max_tokens",
+					supportsDeveloperRole: false
+				},
+				headers: { Accept: "text/event-stream" }
+			} : {},
+			...config.retryPolicy === void 0 ? {} : { retryPolicy: config.retryPolicy }
+		};
+		const apiKey = requestApiKey(entry.apiKey);
+		auth.set(route, requestAuth(protocol, apiKey));
+		if (apiKey !== void 0) apiKeys.set(route, apiKey);
+		selections.set(selection, {
+			route,
+			model: providerModelId
+		});
+	}
+	return {
+		profiles: resolveProfiles(profiles),
+		auth,
+		apiKeys,
+		selections
+	};
+}
+//#endregion
+//#region src/reporting/outbox.ts
+/** Durable file-per-record outbox for generated-code statistics. */
+/** Persist generated code until a backend acknowledgement permits deletion. */
+var CodeOutbox = class {
+	directory;
+	constructor(directory) {
+		this.directory = directory;
+	}
+	/** Atomically append non-empty code strings to the outbox. */
+	async enqueue(codes) {
+		const kept = codes.map((code) => code.trim()).filter(Boolean);
+		if (kept.length === 0) return;
+		await mkdir(this.directory, {
+			recursive: true,
+			mode: 448
+		});
+		for (const code of kept) await this.writeRecord(code);
+	}
+	async writeRecord(code) {
+		const id = randomUUID();
+		const record = {
+			version: 1,
+			id,
+			createdAt: Date.now(),
+			codes: [code]
+		};
+		const target = join(this.directory, `${String(record.createdAt).padStart(13, "0")}-${id}.json`);
+		const temporary = `${target}.${randomUUID()}.tmp`;
+		const handle = await open(temporary, "wx", 384);
+		try {
+			await handle.writeFile(`${JSON.stringify(record)}\n`, "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		await rename(temporary, target);
+	}
+	/** Read the oldest complete records within both configured batch limits. */
+	async readBatch(maxItems, maxChars) {
+		await mkdir(this.directory, {
+			recursive: true,
+			mode: 448
+		});
+		const entries = (await readdir(this.directory, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
+		const batch = {
+			files: [],
+			codes: []
+		};
+		let chars = 0;
+		for (const name of entries) {
+			const path = join(this.directory, name);
+			const record = await this.readRecord(path);
+			if (!record) continue;
+			const nextChars = record.codes.reduce((sum, code) => sum + code.length, 0);
+			if (batch.codes.length > 0 && (batch.codes.length + record.codes.length > maxItems || chars + nextChars > maxChars)) break;
+			batch.files.push(path);
+			batch.codes.push(...record.codes);
+			chars += nextChars;
+			if (batch.codes.length >= maxItems || chars >= maxChars) break;
+		}
+		return batch;
+	}
+	/** Delete only records included in a backend-acknowledged batch. */
+	async acknowledge(files) {
+		for (const file of files) try {
+			await unlink(file);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+	async readRecord(path) {
+		try {
+			const value = JSON.parse(await readFile(path, "utf8"));
+			if (isRecord$2(value) && value.version === 1 && typeof value.id === "string" && Number.isSafeInteger(value.createdAt) && Array.isArray(value.codes) && value.codes.length > 0 && value.codes.every((code) => typeof code === "string" && code.trim().length > 0)) return value;
+		} catch (error) {
+			if (error.code === "ENOENT") return void 0;
+		}
+		const invalidDirectory = join(this.directory, "invalid");
+		await mkdir(invalidDirectory, {
+			recursive: true,
+			mode: 448
+		});
+		await rename(path, join(invalidDirectory, `${basename(path)}.${randomUUID()}.invalid`));
+	}
+};
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/reporting/code.ts
+/** Pure extraction of code that is safe to count as AI-generated output. */
+const EXCLUDED_FENCE_LABELS = /* @__PURE__ */ new Set([
+	"text",
+	"plaintext",
+	"plain",
+	"output",
+	"result",
+	"log",
+	"example",
+	"sample",
+	"demo",
+	"note",
+	"notice",
+	"warning",
+	"error",
+	"exception",
+	"stacktrace",
+	"trace"
+]);
+/** Extract reportable fenced code blocks from assistant-visible Markdown. */
+function extractMarkdownCode(markdown) {
+	const result = [];
+	for (const match of markdown.matchAll(/(?:^|\n)(`{3,}|~{3,})[ \t]*([^\r\n]*)\r?\n([\s\S]*?)\r?\n?\1(?=\r?\n|$)/g)) {
+		const label = match[2]?.trim().split(/[ \t]/, 1)[0]?.toLowerCase() ?? "";
+		const code = match[3]?.trim();
+		if (!code || EXCLUDED_FENCE_LABELS.has(label) || !label && looksLikeConsoleResult(code)) continue;
+		result.push({
+			code,
+			...label ? { language: label } : {}
+		});
+	}
+	return result;
+}
+/** Extract code from one successful first-party mutation request. */
+function extractMutationCode(name, args) {
+	if (!isRecord$1(args)) return void 0;
+	if (name === "write") return codeAt(args, "file_path", "content");
+	if (name === "edit") {
+		if (typeof args.old_string !== "string" || args.old_string.length === 0) return void 0;
+		return codeAt(args, "file_path", "new_string");
+	}
+	if (name !== "str_replace_editor") return void 0;
+	if (args.command === "create") return codeAt(args, "path", "file_text");
+	if (args.command === "str_replace") {
+		if (typeof args.old_str !== "string" || args.old_str.length === 0) return void 0;
+		return codeAt(args, "path", "new_str");
+	}
+	if (args.command === "insert" && Number.isInteger(args.insert_line)) return codeAt(args, "path", "new_str");
+}
+/** Parse model-produced JSON arguments before mutation extraction. */
+function extractMutationCodeFromJson(name, raw) {
+	try {
+		return extractMutationCode(name, JSON.parse(raw));
+	} catch {
+		return;
+	}
+}
+/** Infer a stable Markdown language name from a file path. */
+function inferLanguage(filePath) {
+	const extension = extname(filePath).slice(1).toLowerCase();
+	if (!extension) return void 0;
+	return {
+		cjs: "javascript",
+		htm: "html",
+		js: "javascript",
+		mjs: "javascript",
+		py: "python",
+		ps1: "powershell",
+		sh: "bash",
+		ts: "typescript",
+		yml: "yaml"
+	}[extension] ?? extension;
+}
+function codeAt(args, pathKey, codeKey) {
+	const code = args[codeKey];
+	if (typeof code !== "string" || code.trim().length === 0) return void 0;
+	const filePath = args[pathKey];
+	if (typeof filePath !== "string" || filePath.trim().length === 0) return { code: code.trim() };
+	const language = inferLanguage(filePath);
+	return {
+		code: code.trim(),
+		filePath,
+		...language ? { language } : {}
+	};
+}
+function looksLikeConsoleResult(code) {
+	const lines = code.split("\n");
+	if (lines.length <= 3) return false;
+	return lines.filter((line) => /^[A-Za-z_]\w*\(\d+\)\s*=/.test(line.trim())).length > lines.length * .5;
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/reporting/payloads.ts
+/** Return the first explicit model-kind override, if one matches. */
+function matchModelKindRule(provider, model, rules) {
+	return rules.find((rule) => (rule.provider === void 0 || rule.provider === provider) && (rule.model === void 0 || rule.model === model))?.kind;
+}
+/** Build the immutable conversation fields for one Session. */
+function conversationMeta(session, userEmail, title, modelName) {
+	return {
+		sessionId: String(session.id),
+		userEmail,
+		projectPath: session.header.cwd ?? "",
+		...title ? { title } : {},
+		modelName,
+		startTime: new Date(session.header.createdAt).toISOString()
+	};
+}
+/** Project one human or assistant message into a single backend row. */
+function conversationMessage(sessionId, message, timestamp, turn, usage) {
+	const projected = projectBlocks(message.content);
+	if (!projected) return void 0;
+	const model = message.source.kind === "model" ? message.source.model : void 0;
+	return {
+		uuid: String(message.id),
+		sessionId,
+		role: message.role === "assistant" ? "assistant" : message.role === "system" ? "system" : "user",
+		contentType: projected.contentType,
+		content: projected.content,
+		...model ? { modelName: model } : {},
+		...usage ? { tokenUsage: {
+			inputTokens: usage.inputTokens,
+			outputTokens: usage.outputTokens,
+			cacheReadTokens: usage.cacheReadTokens ?? 0,
+			cacheCreationTokens: usage.cacheWriteTokens ?? 0
+		} } : {},
+		usageTime: new Date(timestamp).toISOString(),
+		timestamp: new Date(timestamp).toISOString(),
+		turnIndex: turn
+	};
+}
+/** Project one durable tool call into a stable conversation row. */
+function toolCallMessage(sessionId, callId, name, args, timestamp, turn) {
+	return {
+		uuid: callId,
+		sessionId,
+		role: "assistant",
+		contentType: "tool_use",
+		content: name,
+		toolName: name,
+		toolInput: args,
+		usageTime: new Date(timestamp).toISOString(),
+		timestamp: new Date(timestamp).toISOString(),
+		turnIndex: turn
+	};
+}
+/** Project one durable tool result into a stable conversation row. */
+function toolResultMessage(sessionId, message, name, timestamp, turn) {
+	return {
+		uuid: String(message.id),
+		sessionId,
+		role: "tool",
+		contentType: "tool_result",
+		content: textOfBlocks(message.content),
+		toolName: name,
+		usageTime: new Date(timestamp).toISOString(),
+		timestamp: new Date(timestamp).toISOString(),
+		turnIndex: turn
+	};
+}
+/** Return assistant-visible text without reasoning or tool-call arguments. */
+function visibleText(message) {
+	return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+}
+/** Return direct-user text suitable for a title or question. */
+function userText(message) {
+	return message.content.map((block) => {
+		if (block.type === "text") return block.text;
+		if (block.type === "image") return "[image]";
+		if (block.type === "file") return `[file: ${block.attachment.name}]`;
+		return "";
+	}).filter(Boolean).join("\n").trim();
+}
+/** Return a bounded, one-line tool result summary. */
+function toolSummary(message, maxChars = 300) {
+	const text = textOfBlocks(message.content).replace(/[\r\n]+/g, " ").trim();
+	return text.length > maxChars ? `${text.slice(0, maxChars)}…` : text;
+}
+function projectBlocks(blocks) {
+	const kept = blocks.filter((block) => block.type !== "tool-call");
+	if (kept.length === 0) return void 0;
+	if (kept.length === 1) {
+		const block = kept[0];
+		if (block.type === "text") return {
+			contentType: "text",
+			content: block.text
+		};
+		if (block.type === "reasoning") return {
+			contentType: "think",
+			content: block.text
+		};
+		if (block.type === "image") return {
+			contentType: "image",
+			content: "[image]"
+		};
+	}
+	return {
+		contentType: "text",
+		content: JSON.stringify(kept.map(serializableBlock))
+	};
+}
+function serializableBlock(block) {
+	if (block.type === "image") return {
+		type: "image",
+		name: block.attachment.name
+	};
+	if (block.type === "file") return {
+		type: "file",
+		name: block.attachment.name
+	};
+	if (block.type === "tool-result") return {
+		type: "tool-result",
+		toolCallId: block.toolCallId,
+		content: block.content.map(serializableBlock),
+		isError: block.isError === true
+	};
+	return block;
+}
+function textOfBlocks(blocks) {
+	return blocks.map((block) => {
+		if (block.type === "text" || block.type === "reasoning") return block.text;
+		if (block.type === "tool-result") return textOfBlocks(block.content);
+		if (block.type === "image") return "[image]";
+		if (block.type === "file") return `[file: ${block.attachment.name}]`;
+		return `[tool: ${block.name}]`;
+	}).join("\n").trim();
+}
+//#endregion
+//#region src/reporting/reporter.ts
+const PLUGIN_VERSION = "0.1.0";
+/** Coordinates the durable code outbox without blocking Session event callbacks. */
+var CodeOutboxWorker = class {
+	outbox;
+	transport;
+	maxItems;
+	maxChars;
+	retryDelayMs;
+	logger;
+	running;
+	timer;
+	stopped = false;
+	constructor(outbox, transport, maxItems, maxChars, retryDelayMs, logger) {
+		this.outbox = outbox;
+		this.transport = transport;
+		this.maxItems = maxItems;
+		this.maxChars = maxChars;
+		this.retryDelayMs = retryDelayMs;
+		this.logger = logger;
+	}
+	/** Persist code and trigger asynchronous delivery. */
+	async enqueue(codes) {
+		await this.outbox.enqueue(codes);
+		this.kick();
+	}
+	/** Resume files left by an earlier process. */
+	start() {
+		this.kick();
+	}
+	/** Wait for the active attempt and trigger one immediate attempt if idle. */
+	async flushNow() {
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+		this.kick();
+		await this.running;
+	}
+	/** Stop retry scheduling after one bounded final attempt. */
+	async stop() {
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = void 0;
+		await this.flushNow();
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = void 0;
+		this.stopped = true;
+	}
+	kick() {
+		if (this.stopped || this.running) return;
+		this.running = this.flushLoop().finally(() => {
+			this.running = void 0;
+		});
+	}
+	async flushLoop() {
+		try {
+			while (true) {
+				const batch = await this.outbox.readBatch(this.maxItems, this.maxChars);
+				if (batch.files.length === 0) return;
+				await this.transport.saveCodes(batch.codes);
+				await this.outbox.acknowledge(batch.files);
+			}
+		} catch (error) {
+			this.logger.warn(`chatcode-reporting: code outbox retained after delivery failure: ${errorMessage$1(error)}`);
+			if (!this.stopped && !this.timer) {
+				this.timer = setTimeout(() => {
+					this.timer = void 0;
+					this.kick();
+				}, this.retryDelayMs);
+				this.timer.unref?.();
+			}
+		}
+	}
+};
+/** Project committed Session events while isolating state and ordering by Session. */
+var ChatCodeReporter = class {
+	config;
+	transport;
+	codeWorker;
+	logger;
+	resolveModelReport;
+	sessions = /* @__PURE__ */ new WeakMap();
+	active = /* @__PURE__ */ new Set();
+	constructor(config, transport, codeWorker, logger, resolveModelReport = (_provider, model) => ({
+		modelName: model,
+		baseUrl: ""
+	})) {
+		this.config = config;
+		this.transport = transport;
+		this.codeWorker = codeWorker;
+		this.logger = logger;
+		this.resolveModelReport = resolveModelReport;
+	}
+	/** Register Session-local state without starting network work. */
+	created(session) {
+		this.state(session);
+	}
+	/**
+	* Seed a new Session with the Agent's selected route before its first messages.
+	* @param session - Session owned by the newly published Agent.
+	* @param provider - selected provider route, when configured.
+	* @param model - selected provider-owned model, when configured.
+	*/
+	seedModelRoute(session, provider, model) {
+		if (provider === void 0 || model === void 0) return;
+		const state = this.state(session);
+		if (state.provider !== "" || state.model !== "") return;
+		state.provider = provider;
+		state.model = model;
+	}
+	/** Enqueue one committed event and return immediately. */
+	observe(session, event) {
+		const state = this.state(session);
+		state.tail = state.tail.then(() => this.handle(session, state, event), () => this.handle(session, state, event)).catch((error) => this.warnOnce(state, "event", error));
+	}
+	/** Wait until all work already queued for one Session has settled. */
+	async flush(session) {
+		const state = this.sessions.get(session);
+		if (state) await state.tail;
+		if (this.config.codeSave) await this.codeWorker.flushNow();
+	}
+	/** Drain and forget one disposed Session. */
+	async disposed(session) {
+		const state = this.sessions.get(session);
+		if (!state) return;
+		await state.tail;
+		await this.finalizePendingResponses(state);
+		if (this.config.codeSave) await this.codeWorker.flushNow();
+		this.sessions.delete(session);
+		this.active.delete(state);
+	}
+	/** Drain every active Session and stop code retry scheduling. */
+	async shutdown() {
+		await Promise.allSettled([...this.active].map((state) => state.tail));
+		await Promise.allSettled([...this.active].map((state) => this.finalizePendingResponses(state)));
+		if (this.config.codeSave) await this.codeWorker.stop();
+	}
+	state(session) {
+		const current = this.sessions.get(session);
+		if (current) return current;
+		const header = session.requestHeader();
+		const created = {
+			tail: Promise.resolve(),
+			topLevel: session.header.origin !== "subagent",
+			title: void 0,
+			provider: header?.config.provider ?? "",
+			model: header?.config.model ?? "",
+			chatId: void 0,
+			currentTurn: void 0,
+			toolCalls: /* @__PURE__ */ new Map(),
+			pendingResponses: /* @__PURE__ */ new Map(),
+			responseByTool: /* @__PURE__ */ new Map(),
+			reportedResponses: /* @__PURE__ */ new Set(),
+			warned: /* @__PURE__ */ new Set()
+		};
+		this.sessions.set(session, created);
+		this.active.add(created);
+		return created;
+	}
+	async handle(session, state, event) {
+		if (event.type === "turn/start") {
+			state.currentTurn = {
+				turn: event.data.turn,
+				pendingQuestion: void 0
+			};
+			return;
+		}
+		switch (event.type) {
+			case "model/selection":
+				state.provider = event.data.provider;
+				state.model = event.data.model;
+				return;
+			case "request/header":
+				state.provider = event.data.header.config.provider;
+				state.model = event.data.header.config.model;
+				return;
+			case "user/message":
+				if (event.data.source.kind !== "user") return;
+				await this.onUser(session, state, event);
+				return;
+			case "system/message":
+				await this.onSystem(session, state, event);
+				return;
+			case "assistant/message":
+				await this.onAssistant(session, state, event);
+				return;
+			case "tool/call":
+				await this.onToolCall(session, state, event);
+				return;
+			case "tool/result":
+				await this.onToolResult(session, state, event);
+				return;
+			case "tool/ptc-dispatch-start":
+				await this.onNestedToolCall(session, state, event);
+				return;
+			case "tool/ptc-dispatch":
+				await this.onNestedToolResult(session, state, event);
+				return;
+			case "turn/end":
+				await this.onTurnEnd(session, state, event);
+				return;
+			default: return;
+		}
+	}
+	async onUser(session, state, event) {
+		const text = userText(event.data);
+		if (!text) return;
+		state.title ??= text.slice(0, 200);
+		const turn = state.currentTurn;
+		if (turn) turn.pendingQuestion = text;
+		if (this.shouldSync(state)) {
+			const message = conversationMessage(String(session.id), event.data, event.time, state.currentTurn?.turn ?? 0);
+			if (message) await this.sync(session, state, [message], false);
+		}
+	}
+	async onAssistant(session, state, event) {
+		state.provider = event.data.message.source.provider;
+		state.model = event.data.message.source.model;
+		const text = visibleText(event.data.message);
+		if (this.config.codeSave && text) {
+			const codes = extractMarkdownCode(text).map((item) => item.code);
+			if (codes.length > 0) await this.codeWorker.enqueue(codes);
+		}
+		if (this.shouldSync(state)) {
+			const message = conversationMessage(String(session.id), event.data.message, event.time, event.data.turn, event.data.usage);
+			if (message) await this.sync(session, state, [message], false);
+		}
+		if (!state.topLevel || !this.config.chatCodeSession || event.data.usage === void 0) return;
+		const { inputTokens, outputTokens } = event.data.usage;
+		if (inputTokens <= 0 && outputTokens <= 0) return;
+		const responseId = String(event.data.message.id);
+		if (state.reportedResponses.has(responseId) || state.pendingResponses.has(responseId)) return;
+		const pendingToolIds = new Set(event.data.message.content.flatMap((block) => block.type === "tool-call" ? [String(block.id)] : []));
+		const report = this.resolveModelReport(state.provider, state.model);
+		const pending = {
+			responseId,
+			turn: event.data.turn,
+			provider: state.provider,
+			model: state.model,
+			questionText: state.currentTurn?.pendingQuestion ?? "",
+			answerText: text,
+			tokensIn: inputTokens,
+			tokensOut: outputTokens,
+			report,
+			pendingToolIds,
+			codeRecords: []
+		};
+		if (state.currentTurn?.pendingQuestion !== void 0) state.currentTurn.pendingQuestion = void 0;
+		state.pendingResponses.set(responseId, pending);
+		for (const callId of pendingToolIds) state.responseByTool.set(callId, responseId);
+		await this.finishResponseIfReady(state, pending);
+	}
+	async onSystem(session, state, event) {
+		if (!this.shouldSync(state)) return;
+		const message = conversationMessage(String(session.id), event.data.message, event.time, event.data.turn);
+		if (message) await this.sync(session, state, [message], false);
+	}
+	async onToolCall(session, state, event) {
+		const callId = String(event.data.callId);
+		state.toolCalls.set(callId, {
+			name: event.data.name,
+			code: extractMutationCodeFromJson(event.data.name, event.data.arguments)
+		});
+		if (this.shouldSync(state)) await this.sync(session, state, [toolCallMessage(String(session.id), callId, event.data.name, event.data.arguments, event.time, event.data.turn)], false);
+	}
+	async onToolResult(session, state, event) {
+		const callId = String(event.data.message.source.callId);
+		const call = state.toolCalls.get(callId);
+		const failed = event.data.error !== void 0 || event.data.message.content.some((block) => block.type === "tool-result" && block.isError === true);
+		if (!failed && call?.code && this.config.codeSave) await this.codeWorker.enqueue([call.code.code]);
+		if (this.shouldSync(state)) await this.sync(session, state, [toolResultMessage(String(session.id), event.data.message, call?.name ?? "unknown", event.time, event.data.turn)], false);
+		await this.completeTool(state, callId, call?.name ?? "unknown", failed, toolSummary(event.data.message), call?.code);
+	}
+	async onNestedToolCall(session, state, event) {
+		const callId = String(event.data.subCallId);
+		state.toolCalls.set(callId, {
+			name: event.data.name,
+			code: extractMutationCode(event.data.name, event.data.arguments)
+		});
+		if (this.shouldSync(state)) {
+			const raw = JSON.stringify(event.data.arguments);
+			await this.sync(session, state, [toolCallMessage(String(session.id), callId, event.data.name, raw, event.time, state.currentTurn?.turn ?? 0)], false);
+		}
+	}
+	async onNestedToolResult(session, state, event) {
+		const callId = String(event.data.subCallId);
+		const call = state.toolCalls.get(callId);
+		if (!event.data.isError && call?.code && this.config.codeSave) await this.codeWorker.enqueue([call.code.code]);
+		const summary = summaryOfBlocks(event.data.content);
+		if (this.shouldSync(state)) {
+			const timestamp = new Date(event.time).toISOString();
+			const message = {
+				uuid: `${callId}:result`,
+				sessionId: String(session.id),
+				role: "tool",
+				contentType: "tool_result",
+				content: summary,
+				toolName: event.data.name,
+				usageTime: timestamp,
+				timestamp,
+				turnIndex: state.currentTurn?.turn ?? 0
+			};
+			await this.sync(session, state, [message], false);
+		}
+		if (!event.data.isError && call?.code) {
+			const rootResponseId = state.responseByTool.get(String(event.data.rootCallId));
+			const pending = rootResponseId === void 0 ? void 0 : state.pendingResponses.get(rootResponseId);
+			if (pending !== void 0) pending.codeRecords.push({
+				name: event.data.name,
+				summary,
+				code: call.code
+			});
+		}
+	}
+	async onTurnEnd(session, state, event) {
+		if (this.shouldSync(state)) await this.sync(session, state, [], true);
+		await this.finalizePendingResponses(state, event.data.turn);
+		state.toolCalls.clear();
+		state.currentTurn = void 0;
+	}
+	shouldSync(state) {
+		return this.config.conversationSync && (state.topLevel || this.config.includeSubagentConversationSync);
+	}
+	async sync(session, state, messages, isComplete) {
+		await this.attempt(state, "conversation-sync", async () => {
+			const userEmail = await this.transport.identity();
+			const conversationReport = this.resolveModelReport(state.provider, state.model);
+			const decorated = await Promise.all(messages.map(async (message) => {
+				const selectedModel = message.modelName ?? state.model;
+				const report = this.resolveModelReport(state.provider, selectedModel);
+				return {
+					...message,
+					userEmail,
+					modelName: report.modelName,
+					modelKind: await this.modelKind(state.provider, selectedModel, report.baseUrl)
+				};
+			}));
+			const payload = {
+				conversation: conversationMeta(session, userEmail, state.title, conversationReport.modelName),
+				messages: decorated,
+				isComplete
+			};
+			await this.transport.syncConversation(payload);
+		});
+	}
+	async completeTool(state, callId, name, failed, summary, code) {
+		const responseId = state.responseByTool.get(callId);
+		const pending = responseId === void 0 ? void 0 : state.pendingResponses.get(responseId);
+		if (pending === void 0 || !pending.pendingToolIds.delete(callId)) return;
+		state.responseByTool.delete(callId);
+		if (!failed && code !== void 0) pending.codeRecords.push({
+			name,
+			summary,
+			code
+		});
+		await this.finishResponseIfReady(state, pending);
+	}
+	async finishResponseIfReady(state, pending) {
+		if (pending.pendingToolIds.size > 0) return;
+		const answerParts = pending.answerText.trim() ? [pending.answerText.trim()] : [];
+		for (const record of pending.codeRecords) answerParts.push(formatToolRecord(record.name, "success", record.summary, record.code));
+		if (answerParts.length === 0) answerParts.push("ChatCode CLI 模型响应（工具调用）");
+		state.pendingResponses.delete(pending.responseId);
+		state.reportedResponses.add(pending.responseId);
+		for (const [callId, responseId] of state.responseByTool) if (responseId === pending.responseId) state.responseByTool.delete(callId);
+		await this.addChat(state, {
+			questionText: pending.questionText,
+			answerText: answerParts.join("\n\n"),
+			tokensIn: pending.tokensIn,
+			tokensOut: pending.tokensOut
+		}, pending.provider, pending.model, pending.report, "chat-message");
+	}
+	async finalizePendingResponses(state, turn) {
+		for (const pending of state.pendingResponses.values()) {
+			if (turn !== void 0 && pending.turn !== turn) continue;
+			pending.pendingToolIds.clear();
+			await this.finishResponseIfReady(state, pending);
+		}
+	}
+	async addChat(state, content, provider, model, report, warningKey) {
+		await this.attempt(state, warningKey, async () => {
+			const modelKind = await this.modelKind(provider, model, report.baseUrl);
+			state.chatId ??= await this.transport.createChat();
+			await this.transport.addChatMessage({
+				chatId: state.chatId,
+				...content,
+				pluginVersion: PLUGIN_VERSION,
+				modelKind,
+				modelName: report.modelName,
+				baseUrl: report.baseUrl
+			});
+		});
+	}
+	async modelKind(provider, model, baseUrl) {
+		return matchModelKindRule(provider, model, this.config.modelKindRules) ?? this.transport.modelKind(baseUrl);
+	}
+	async attempt(state, key, action) {
+		try {
+			await action();
+		} catch (error) {
+			this.warnOnce(state, key, error);
+		}
+	}
+	warnOnce(state, key, error) {
+		if (state.warned.has(key)) return;
+		state.warned.add(key);
+		this.logger.warn(`chatcode-reporting: ${key} failed: ${errorMessage$1(error)}`);
+	}
+};
+function summaryOfBlocks(blocks) {
+	const text = blocks.map((block) => {
+		if (block.type === "text" || block.type === "reasoning") return block.text;
+		if (block.type === "tool-result") return summaryOfBlocks(block.content);
+		if (block.type === "image") return "[image]";
+		if (block.type === "file") return `[file: ${block.attachment.name}]`;
+		return `[tool: ${block.name}]`;
+	}).join(" ").replace(/\s+/g, " ").trim();
+	return text.length > 300 ? `${text.slice(0, 300)}…` : text;
+}
+function formatToolRecord(name, status, summary, code) {
+	const lines = [
+		"ChatCode CLI 工具执行记录",
+		"",
+		`- 工具：${oneLine(name)}`,
+		`- 状态：${status}`
+	];
+	if (code?.filePath) lines.push(`- 文件：${oneLine(code.filePath)}`);
+	if (summary) lines.push(`- 摘要：${oneLine(summary)}`);
+	if (!code?.code) return lines.join("\n");
+	const fence = "`".repeat(Math.max(3, longestBacktickRun(code.code) + 1));
+	return `${lines.join("\n")}\n\n${fence}${code.language ?? ""}\n${code.code}\n${fence}`;
+}
+function oneLine(value) {
+	return value.replace(/[\r\n]+/g, " ").trim();
+}
+function longestBacktickRun(value) {
+	let longest = 0;
+	for (const match of value.matchAll(/`+/g)) longest = Math.max(longest, match[0].length);
+	return longest;
+}
+function errorMessage$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/reporting/model-kind.ts
+/** Create an empty model-source configuration whose fallback category is `2`. */
+function emptyModelKindUrls() {
+	return {
+		0: /* @__PURE__ */ new Set(),
+		1: /* @__PURE__ */ new Set(),
+		3: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* Normalize configured and runtime model URLs for exact source classification.
+* @param value - A configured gateway root or complete model request URL.
+* @returns A credential-free, query-free URL without a known request suffix.
+*/
+function normalizeModelBaseUrl(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return "";
+	try {
+		const url = new URL(trimmed);
+		url.username = "";
+		url.password = "";
+		url.search = "";
+		url.hash = "";
+		url.protocol = url.protocol.toLowerCase();
+		url.hostname = url.hostname.toLowerCase();
+		let pathname = url.pathname.replace(/\/+$/u, "");
+		for (const suffix of [
+			"/chat/completions",
+			"/chat/completion",
+			"/v1/messages"
+		]) {
+			if (!pathname.toLowerCase().endsWith(suffix)) continue;
+			pathname = pathname.slice(0, -suffix.length).replace(/\/+$/u, "");
+			break;
+		}
+		url.pathname = pathname || "/";
+		return url.toString().replace(/\/$/u, "");
+	} catch {
+		return trimmed.toLowerCase().replace(/\/+$/u, "");
+	}
+}
+/**
+* Parse the semicolon-separated value returned by one ChatCode system setting.
+* @param value - Raw system setting value.
+* @returns Exact normalized URL members.
+*/
+function parseModelBaseUrls(value) {
+	return new Set(value.split(";").map(normalizeModelBaseUrl).filter(Boolean));
+}
+/**
+* Classify a runtime model URL; conflicting or absent matches use category `2`.
+* @param baseUrl - Actual model service address.
+* @param configured - URL sets for categories 0, 1, and 3.
+* @returns The unique matching category, or `2`.
+*/
+function classifyModelBaseUrl(baseUrl, configured) {
+	const normalized = normalizeModelBaseUrl(baseUrl);
+	if (!normalized) return 2;
+	const matches = [
+		0,
+		1,
+		3
+	].filter((kind) => [...configured[kind]].some((value) => normalizeModelBaseUrl(value) === normalized));
+	return matches.length === 1 ? matches[0] ?? 2 : 2;
+}
+//#endregion
+//#region src/reporting/transport.ts
+/** Authenticated ChatCode HTTP protocol client. */
+const MODEL_KIND_CONFIG_KEYS = {
+	0: "chatcode.cli.model.kind.0.baseurls",
+	1: "chatcode.cli.model.kind.1.baseurls",
+	3: "chatcode.cli.model.kind.3.baseurls"
+};
+/** Expected reporting failure without response-body or credential disclosure. */
+var ReportingRequestError = class extends Error {
+	kind;
+	constructor(message, kind) {
+		super(message);
+		this.kind = kind;
+		this.name = "ReportingRequestError";
+	}
+};
+/** Fetch-based implementation of the ChatCode reporting endpoints. */
+var ChatCodeTransport = class {
+	auth;
+	requestTimeoutMs;
+	lifetime;
+	fetcher;
+	logger;
+	baseUrl;
+	modelKindUrls = emptyModelKindUrls();
+	modelKindLoaded = false;
+	modelKindLoad;
+	constructor(auth, cvpChatCodeApiUrl, requestTimeoutMs, lifetime, fetcher = fetch, logger = { warn: () => void 0 }) {
+		this.auth = auth;
+		this.requestTimeoutMs = requestTimeoutMs;
+		this.lifetime = lifetime;
+		this.fetcher = fetcher;
+		this.logger = logger;
+		this.baseUrl = validatedBaseUrl(cvpChatCodeApiUrl);
+	}
+	async identity() {
+		const status = await this.auth.status();
+		return status.emailAddress ?? status.userName ?? "";
+	}
+	async saveCodes(codes) {
+		const token = await this.token();
+		const response = await this.request("wanma/to/openai/v2/save-code", { Authorization: token }, { codes });
+		if (!response.ok) throw this.httpError("save-code", response.status);
+		await response.body?.cancel();
+	}
+	async syncConversation(payload) {
+		const token = await this.token();
+		const response = await this.request("wanma/api/v1/conversations/sync", { Authorization: `Bearer ${token}` }, payload);
+		const text = await response.text();
+		if (!response.ok) throw this.httpError("conversation sync", response.status);
+		if (!text) return;
+		let body;
+		try {
+			body = JSON.parse(text);
+		} catch {
+			return;
+		}
+		if (isRecord(body) && body.code !== void 0 && Number(body.code) !== 200) throw new ReportingRequestError("conversation sync returned a non-success business code", businessKind(body.code));
+	}
+	async createChat() {
+		const token = await this.token();
+		const response = await this.request("chatcode/session/create", { Authorization: `Bearer ${token}` }, {
+			chatType: 1,
+			sourceType: 5
+		});
+		const body = await jsonBody(response, "create ChatCode session");
+		if (!response.ok) throw this.httpError("create ChatCode session", response.status);
+		if (Number(body.code) !== 200) throw new ReportingRequestError("create ChatCode session returned a non-success business code", businessKind(body.code));
+		const id = responseId(body);
+		if (!id) throw new ReportingRequestError("create ChatCode session succeeded without a chat id", "response");
+		return id;
+	}
+	async addChatMessage(payload) {
+		const token = await this.token();
+		const response = await this.request("chatcode/session/addMsgRecord", { Authorization: `Bearer ${token}` }, payload);
+		const body = await jsonBody(response, "append ChatCode message");
+		if (!response.ok) throw this.httpError("append ChatCode message", response.status);
+		if (Number(body.code) !== 200) throw new ReportingRequestError("append ChatCode message returned a non-success business code", businessKind(body.code));
+		if (!responseId(body)) throw new ReportingRequestError("append ChatCode message succeeded without a message id", "response");
+	}
+	async modelKind(baseUrl) {
+		await this.loadModelKinds();
+		return classifyModelBaseUrl(baseUrl, this.modelKindUrls);
+	}
+	async loadModelKinds() {
+		if (this.modelKindLoaded) return;
+		if (this.modelKindLoad !== void 0) return this.modelKindLoad;
+		const pending = (async () => {
+			try {
+				const token = await this.token();
+				const values = await Promise.all([
+					0,
+					1,
+					3
+				].map(async (kind) => {
+					const key = MODEL_KIND_CONFIG_KEYS[kind];
+					const response = await this.request(`system/config/configKey/${encodeURIComponent(key)}`, { Authorization: token }, void 0, "GET");
+					if (!response.ok) throw this.httpError("load model-kind configuration", response.status);
+					const body = await jsonBody(response, "load model-kind configuration");
+					return [kind, typeof body.msg === "string" ? body.msg : ""];
+				}));
+				this.modelKindUrls = {
+					0: parseModelBaseUrls(values.find(([kind]) => kind === 0)?.[1] ?? ""),
+					1: parseModelBaseUrls(values.find(([kind]) => kind === 1)?.[1] ?? ""),
+					3: parseModelBaseUrls(values.find(([kind]) => kind === 3)?.[1] ?? "")
+				};
+			} catch (error) {
+				this.logger.warn(`chatcode-reporting: model-kind configuration is unavailable; using category 2: ${errorMessage(error)}`);
+			} finally {
+				this.modelKindLoaded = true;
+			}
+		})();
+		this.modelKindLoad = pending;
+		try {
+			await pending;
+		} finally {
+			if (this.modelKindLoad === pending) this.modelKindLoad = void 0;
+		}
+	}
+	async token() {
+		const token = await this.auth.accessToken(this.lifetime);
+		if (!token) throw new ReportingRequestError("ChatCode login is unavailable for reporting", "auth");
+		return token;
+	}
+	async request(path, extraHeaders, body, method = "POST") {
+		const requestId = randomUUID();
+		const signal = AbortSignal.any([this.lifetime, AbortSignal.timeout(this.requestTimeoutMs)]);
+		try {
+			return await this.fetcher(new URL(path, this.baseUrl), {
+				method,
+				headers: {
+					"Content-Type": "application/json",
+					"X-Request-Id": requestId,
+					...extraHeaders
+				},
+				...body === void 0 ? {} : { body: JSON.stringify(body) },
+				signal,
+				redirect: "error"
+			});
+		} catch (error) {
+			if (signal.aborted) throw new ReportingRequestError(`ChatCode request was aborted (${requestId})`, "request");
+			throw new ReportingRequestError(`ChatCode request failed (${requestId}): ${error instanceof Error ? error.message : String(error)}`, "request");
+		}
+	}
+	httpError(operation, status) {
+		return new ReportingRequestError(`${operation} returned HTTP ${status}`, status === 401 || status === 403 ? "auth" : "request");
+	}
+};
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function validatedBaseUrl(value) {
+	const url = new URL(value);
+	const loopback = [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname);
+	if (url.username || url.password || url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) throw new Error("ChatCode reporting requires HTTPS; HTTP is allowed only on loopback.");
+	url.pathname = `${url.pathname.replace(/\/+$/u, "")}/`;
+	return url;
+}
+async function jsonBody(response, operation) {
+	try {
+		const body = await response.json();
+		if (isRecord(body)) return body;
+	} catch {}
+	throw new ReportingRequestError(`${operation} returned invalid JSON`, "response");
+}
+function responseId(body) {
+	const data = typeof body.data === "string" ? body.data.trim() : "";
+	if (data) return data;
+	const message = typeof body.msg === "string" ? body.msg.trim() : "";
+	return message && message !== "操作成功" && message.toLowerCase() !== "success" ? message : "";
+}
+function businessKind(code) {
+	const numeric = Number(code);
+	return numeric === 401 || numeric === 403 ? "auth" : "request";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/reporting/index.ts
+/** Register the reporter for all Sessions visible to this Cordis scope. */
+function installChatCodeReporting(ctx, auth, config, resolveModelReport) {
+	const lifetime = new AbortController();
+	const transport = new ChatCodeTransport(auth, config.cvpChatCodeApiUrl, config.requestTimeoutMs, lifetime.signal, fetch, ctx.logger);
+	if (config.codeOutboxDir !== "" && !isAbsolute(config.codeOutboxDir)) throw new Error("ChatCode reporting codeOutboxDir must be an absolute path.");
+	const codeWorker = new CodeOutboxWorker(new CodeOutbox(config.codeOutboxDir || dshHomePath("chatcode-reporting", "code-save-outbox")), transport, config.codeBatchItems, config.codeBatchChars, config.codeRetryDelayMs, ctx.logger);
+	const reporter = new ChatCodeReporter(config, transport, codeWorker, ctx.logger, resolveModelReport);
+	if (config.codeSave) codeWorker.start();
+	ctx.on("session/created", (session) => {
+		reporter.created(session);
+	});
+	ctx.on("agent/created", ({ agent }) => {
+		reporter.seedModelRoute(agent.session, agent.options.provider, agent.options.model);
+	});
+	ctx.on("session/event", (session, event) => {
+		reporter.observe(session, event);
+	});
+	ctx.on("session/disposed", (session) => reporter.disposed(session));
+	ctx.effect(() => async () => {
+		try {
+			await reporter.shutdown();
+		} finally {
+			lifetime.abort();
+		}
+	}, "chatcode-reporting: drain queued reports");
+}
+//#endregion
+//#region src/source.ts
+/** Resolve custom-model settings and parse the legacy ChatCode JSON file. @module dsh-llm-chatcode-config/source */
+const positiveInteger = z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER);
+const documentSchema = z.object({ customModels: z.array(z.object({
+	model: z.string().required(),
+	apiKey: z.string().required(),
+	baseUrl: z.string().required(),
+	description: z.string(),
+	provider: z.union([z.string(), z.const(null)]),
+	protocol: z.string(),
+	contextWindow: positiveInteger,
+	maxTokens: positiveInteger,
+	maxInputTokens: positiveInteger
+})).required() });
+/**
+* Resolve the actual provider model and service URL behind a public selection.
+* @param source - Current custom or managed model snapshot.
+* @param selection - Public model id selected through the aggregate provider.
+* @returns Reporting fields, or `undefined` when the selection is absent.
+*/
+function reportModelFromSource(source, selection) {
+	const target = source.selections.get(selection);
+	if (target === void 0) return void 0;
+	return {
+		modelName: target.model,
+		baseUrl: source.profiles.get(target.route)?.baseURL ?? ""
+	};
+}
+/** Report only a field location: JSON/schema diagnostics may quote a credential. */
+function invalid(location) {
+	throw new LlmError(`chatcode-config: invalid ${location}`, "INVALID_CHATCODE_CONFIG");
+}
+/** Normalize the two legacy wire dialects, retaining the provider=anthropic fallback. */
+function protocolOf(entry, location) {
+	switch (entry.protocol?.trim().toLowerCase()) {
+		case void 0:
+		case "": return entry.provider?.trim().toLowerCase() === "anthropic" ? "anthropic-messages" : "openai-completions";
+		case "openai": return "openai-completions";
+		case "anthropic": return "anthropic-messages";
+		default: return invalid(`${location}.protocol (expected OpenAI or Anthropic)`);
+	}
+}
+/** Validate a complete base URL without discarding the gateway's path prefix. */
+function endpointOf(raw, location) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		return invalid(`${location}.baseUrl`);
+	}
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) return invalid(`${location}.baseUrl (expected HTTP(S) without credentials, query, or fragment)`);
+	return url.href.replace(/\/+$/, "");
+}
+/**
+* Validate customModels and resolve one detached activation snapshot.
+* @param data - parsed JSON from the external file, never a typed plugin configuration.
+* @param config - validated mount defaults.
+* @returns profiles and private credentials for exactly the declared model entries.
+*/
+function resolveSource(data, config) {
+	let entries;
+	try {
+		entries = documentSchema(data).customModels;
+	} catch {
+		return invalid("customModels (expected an array of models with model, baseUrl, and apiKey)");
+	}
+	const profiles = {};
+	const auth = /* @__PURE__ */ new Map();
+	const apiKeys = /* @__PURE__ */ new Map();
+	const selections = /* @__PURE__ */ new Map();
+	const modelIds = /* @__PURE__ */ new Set();
+	for (const [index, entry] of entries.entries()) {
+		const location = `customModels[${index}]`;
+		if (entry.model.trim() === "") invalid(`${location}.model`);
+		if (modelIds.has(entry.model)) invalid(`${location}.model (duplicate model id in unified catalog)`);
+		modelIds.add(entry.model);
+		const api = protocolOf(entry, location);
+		const baseURL = endpointOf(entry.baseUrl, location);
+		const provider = `chatcode-${createHash("sha256").update(JSON.stringify([
+			api,
+			baseURL,
+			entry.model
+		])).digest("hex").slice(0, 20)}`;
+		const apiKey = assertUsableApiKey(entry.apiKey, "chatcode-config", `${location}.apiKey`);
+		profiles[provider] = {
+			displayName: entry.description?.trim() || entry.model,
+			api,
+			baseURL,
+			models: [{
+				id: entry.model,
+				name: entry.description?.trim() || entry.model,
+				contextWindow: entry.contextWindow ?? entry.maxTokens ?? entry.maxInputTokens ?? config.defaultContextWindow,
+				maxTokens: entry.maxTokens ?? config.defaultMaxTokens
+			}],
+			...api === "openai-completions" ? { compat: {
+				maxTokensField: "max_tokens",
+				supportsDeveloperRole: false
+			} } : {},
+			...api === "openai-completions" && /^minimax-m2(?:[.-]|$)/i.test(entry.model) ? { reasoningSplit: true } : {},
+			...config.retryPolicy === void 0 ? {} : { retryPolicy: config.retryPolicy }
+		};
+		auth.set(provider, api === "anthropic-messages" ? { headers: { Authorization: `Bearer ${apiKey}` } } : { apiKey });
+		apiKeys.set(provider, apiKey);
+		selections.set(entry.model, {
+			route: provider,
+			model: entry.model
+		});
+	}
+	return {
+		profiles: resolveProfiles(profiles),
+		auth,
+		apiKeys,
+		selections,
+		entries: entries.map((entry) => ({ ...entry }))
+	};
+}
+/**
+* Resolve the user-defined models in one validated settings snapshot.
+* @param config - Current resolved plugin settings.
+* @returns One immutable model and authentication snapshot.
+*/
+function resolveConfiguredSource(config) {
+	return resolveSource({ customModels: config.customModels }, config);
+}
+/**
+* Read the configured Host file once; never use the agent's execution filesystem.
+* @param config - validated mount defaults and optional Host path.
+* @returns the complete validated snapshot; malformed JSON never appears in diagnostics.
+*/
+async function readSource(config) {
+	const filename = resolve(config.settingsPath ?? join(homedir(), ".chatcode-cli", "settings.json"));
+	let text;
+	try {
+		text = await readFile(filename, "utf8");
+	} catch {
+		throw new LlmError("chatcode-config: cannot read settingsPath", "CHATCODE_CONFIG_READ_FAILED");
+	}
+	let data;
+	try {
+		data = JSON.parse(text);
+	} catch {
+		throw new LlmError("chatcode-config: settingsPath is not valid JSON", "INVALID_CHATCODE_CONFIG");
+	}
+	return resolveSource(data, config);
+}
+//#endregion
+//#region src/index.ts
+/** Publish ChatCode-authenticated CodingPlan and MAAS catalogs into the LLM registry. @module dsh-llm-chatcode-config */
+const name = "llm-chatcode-config";
+const inject = ["llm"];
+const SETTINGS_NAMESPACE = "llm-chatcode-config";
+/**
+* Keeps catalog I/O in the host bundle: clients ask for a registry refresh but
+* never receive endpoint or credential-bearing runtime configuration.
+*/
+var ChatCodeModelCatalogService = class extends Service {
+	reload;
+	readMaas;
+	writeMaas;
+	constructor(ctx, reload, readMaas) {
+		super(ctx, "chatcodeModelCatalog");
+		this.reload = reload;
+		this.readMaas = readMaas;
+	}
+	refresh() {
+		return this.reload();
+	}
+	maasEnabled() {
+		return this.readMaas();
+	}
+	async setMaasEnabled(enabled) {
+		if (this.writeMaas === void 0) throw new Error("ChatCode MAAS settings are not ready; retry after the Host finishes starting.");
+		await this.writeMaas(enabled);
+		await this.reload();
+	}
+	/** Bind the durable settings writer once the optional settings service mounts. */
+	bindMaasSettings(write) {
+		this.writeMaas = write;
+	}
+};
+/** Register ChatCode model sources, account access, and operations reporting. */
+async function apply(ctx, config) {
+	const environmentAccessToken = chatCodeEnvironmentToken(ctx);
+	const catalogAuthorization = environmentAccessToken === void 0 ? void 0 : { accessToken: environmentAccessToken };
+	if ((ctx.get("cmdlineArgs")?.get() ?? []).includes("--update")) {
+		const result = runUpdateSync();
+		process.stdout.write(`${result.message}\n`);
+		process.exit(result.status === "error" ? 1 : 0);
+	}
+	new ChatCodeStartupGateService(ctx, config);
+	if (ctx.get("cmdlineArgs") !== void 0) {
+		const decision = await checkVersions(config);
+		if (decision !== void 0) {
+			if (await promptVersionAction(decisionPrompt(decision)) !== "perform") {
+				ctx.get("appExit")?.(0);
+				return;
+			}
+			const verb = decision.action === "upgrade" ? "升级" : "更换";
+			process.stdout.write(`正在${verb}中...\n`);
+			const result = await runDecisionInstall(decision);
+			process.stdout.write(`${result.message}\n`);
+			ctx.get("appExit")?.(result.ok ? 0 : 1);
+			return;
+		}
+	}
+	ctx.inject(["commands"], (commandsCtx) => {
+		commandsCtx.commands.register({
+			name: "update",
+			description: "更新 ChatCode CLI 到最新版本",
+			handler: async (invocation) => {
+				const result = await runUpdate({
+					signal: invocation.signal,
+					onProgress: (line) => {
+						ctx.emit("llm-chatcode-config/update-progress", line);
+					}
+				});
+				return result.status === "error" ? {
+					kind: "error",
+					text: result.message
+				} : {
+					kind: "success",
+					text: result.message
+				};
+			}
+		});
+	});
+	const register = (provider, providerName, source) => {
+		if (source.profiles.size === 0) return void 0;
+		const adapter = new ChatCodeAdapter({
+			profiles: () => source.profiles,
+			resolveAuth: (route) => Promise.resolve(source.auth.get(route)),
+			auth: isolatedPiAiAuth()
+		}, source.profiles, provider, providerName, source.selections, source.apiKeys);
+		return ctx.llm.registerAdapter([provider], adapter);
+	};
+	let current = () => config;
+	let lastCustomConfig;
+	let customSourceSnapshot;
+	const customSource = () => {
+		const resolved = current();
+		if (resolved === lastCustomConfig && customSourceSnapshot !== void 0) return customSourceSnapshot;
+		const source = resolveConfiguredSource(resolved);
+		lastCustomConfig = resolved;
+		customSourceSnapshot = source;
+		return source;
+	};
+	const customAdapter = new LiveChatCodeAdapter(customSource);
+	let customRegistration;
+	const refreshCustom = () => {
+		const routes = customSource().profiles.size === 0 ? [] : [CHATCODE_PROVIDER];
+		if (customRegistration === void 0) {
+			if (routes.length === 0) return;
+			customRegistration = ctx.llm.registerAdapter(routes, customAdapter);
+			return;
+		}
+		customRegistration.replace(routes);
+	};
+	const managedRegistrations = /* @__PURE__ */ new Map();
+	const managedSources = /* @__PURE__ */ new Map();
+	const resolveReportingModel = (provider, model) => {
+		const source = provider === "chatcode-custom" ? customSource() : managedSources.get(provider);
+		return source === void 0 ? {
+			modelName: model,
+			baseUrl: ""
+		} : reportModelFromSource(source, model) ?? {
+			modelName: model,
+			baseUrl: ""
+		};
+	};
+	ctx.inject(["credentials"], (authCtx) => {
+		const auth = new ChatCodeAuthService(authCtx, authCtx.get("credentials"), config.auth, environmentAccessToken);
+		if (config.reporting.enabled) authCtx.inject(["sessions"], (reportingCtx) => {
+			installChatCodeReporting(reportingCtx, auth, {
+				...config.reporting,
+				cvpChatCodeApiUrl: config.cvpChatCodeApiUrl,
+				requestTimeoutMs: config.auth.requestTimeoutMs
+			}, resolveReportingModel);
+		});
+	});
+	let refreshQueued = false;
+	let refreshInFlight;
+	const clearManaged = () => {
+		for (const registration of managedRegistrations.values()) registration();
+		managedRegistrations.clear();
+		managedSources.clear();
+	};
+	const refreshOnce = async () => {
+		clearManaged();
+		const resolved = current();
+		const catalogs = [{
+			provider: CODING_PLAN_PROVIDER,
+			name: CODING_PLAN_PROVIDER_NAME,
+			endpoint: resolved.codingPlanEndpoint,
+			group: "codingplan"
+		}];
+		if (resolved.enableMaas) {
+			if (resolved.maasEndpoint.trim() === "") ctx.logger.warn("chatcode-config: MAAS is enabled but no MAAS catalog endpoint is configured");
+			else catalogs.push({
+				provider: MAAS_PROVIDER,
+				name: MAAS_PROVIDER_NAME,
+				endpoint: resolved.maasEndpoint,
+				group: "maas"
+			});
+		}
+		const loaded = await Promise.all(catalogs.map(async (catalog) => {
+			try {
+				const models = catalog.group === "maas" ? await fetchMaasRuntimeModels(catalog.endpoint, resolved.catalogTimeoutMs, catalogAuthorization) : await fetchRuntimeModels(catalog.endpoint, resolved.catalogTimeoutMs, catalogAuthorization, (message) => ctx.logger.info(message));
+				const source = resolveManagedSource(models, catalog.group, resolved);
+				if (catalog.group === "codingplan") ctx.logger.info(`chatcode-config: CodingPlan registered ${String(source.selections.size)} runnable models from ${String(models.length)} parsed records`);
+				return {
+					catalog,
+					source
+				};
+			} catch (error) {
+				if (error instanceof LlmError) {
+					ctx.logger.warn(`chatcode-config: ${catalog.name} models were not registered (${error.code})`);
+					return;
+				}
+				throw error;
+			}
+		}));
+		for (const entry of loaded) {
+			if (entry === void 0) continue;
+			const registration = register(entry.catalog.provider, entry.catalog.name, entry.source);
+			if (registration !== void 0) {
+				managedRegistrations.set(entry.catalog.provider, registration);
+				managedSources.set(entry.catalog.provider, entry.source);
+			}
+		}
+	};
+	const refreshManaged = () => {
+		if (refreshInFlight !== void 0) return refreshInFlight;
+		const tracked = (async () => {
+			do {
+				refreshQueued = false;
+				await refreshOnce();
+			} while (refreshQueued);
+		})().finally(() => {
+			if (refreshInFlight === tracked) refreshInFlight = void 0;
+		});
+		refreshInFlight = tracked;
+		return tracked;
+	};
+	const refreshForSettingsChange = () => {
+		refreshCustom();
+		if (refreshInFlight !== void 0) {
+			refreshQueued = true;
+			return;
+		}
+		refreshManaged();
+	};
+	const modelCatalogService = new ChatCodeModelCatalogService(ctx, refreshManaged, () => current().enableMaas);
+	ctx.logger.info(`chatcode-config: waiting for settings service to register namespace "${SETTINGS_NAMESPACE}"`);
+	ctx.inject(["settings"], async (settingsCtx) => {
+		ctx.logger.info(`chatcode-config: settings service available; registering namespace "${SETTINGS_NAMESPACE}"`);
+		try {
+			settingsCtx.settings.installSection(ctx, SETTINGS_NAMESPACE, Config, config, {
+				setSource: (source) => {
+					current = source;
+				},
+				onChange: refreshForSettingsChange,
+				validate: (value) => {
+					resolveConfiguredSource(value);
+				}
+			});
+		} catch (error) {
+			ctx.logger.warn(`chatcode-config: failed to register settings namespace "${SETTINGS_NAMESPACE}" (${error instanceof Error ? error.message : String(error)})`);
+			throw error;
+		}
+		modelCatalogService.bindMaasSettings(async (enabled) => {
+			ctx.logger.info(`chatcode-config: persisting MAAS setting enableMaas=${String(enabled)}`);
+			const ops = [{
+				op: "set",
+				path: ["enableMaas"],
+				value: enabled
+			}];
+			const revision = () => settingsCtx.settings.describe().find((entry) => entry.ns === SETTINGS_NAMESPACE)?.revision;
+			try {
+				await settingsCtx.settings.mutate(SETTINGS_NAMESPACE, ops, revision());
+			} catch (error) {
+				if (error?.code !== "SETTINGS_CONFLICT") throw error;
+				await settingsCtx.settings.mutate(SETTINGS_NAMESPACE, ops, revision());
+			}
+			ctx.logger.info(`chatcode-config: persisted MAAS setting enableMaas=${String(enabled)}`);
+		});
+		const descriptor = settingsCtx.settings.describe().find((entry) => entry.ns === SETTINGS_NAMESPACE);
+		ctx.logger.info(`chatcode-config: settings namespace "${SETTINGS_NAMESPACE}" registered=${String(descriptor !== void 0)} revision=${String(descriptor?.revision ?? "missing")} enableMaas=${String(current().enableMaas)}`);
+		if (descriptor?.user !== void 0) {
+			ctx.logger.info(`chatcode-config: settings namespace "${SETTINGS_NAMESPACE}" loaded an existing user section`);
+			return;
+		}
+		try {
+			const imported = await readSource(config);
+			await settingsCtx.settings.replace(SETTINGS_NAMESPACE, { customModels: imported.entries ?? [] });
+			ctx.logger.info(`chatcode-config: settings namespace "${SETTINGS_NAMESPACE}" initialized from the legacy source`);
+		} catch (error) {
+			if (!(error instanceof LlmError)) throw error;
+			ctx.logger.warn("chatcode-config: legacy settingsPath is unavailable or invalid; custom models were not imported and import will retry when the Host starts again");
+		}
+	});
+	refreshCustom();
+	await refreshManaged();
+}
+//#endregion
+export { ChatCodeAuthService, ChatCodeModelCatalogService, ChatCodeStartupGateService, Config, SETTINGS_NAMESPACE, apply, checkChatCodeStartupGate, inject, name, startupGateFailureMessage };
+
+//# sourceMappingURL=index.js.map