@webskill/sdk 0.0.1

package/dist/dist-B_ldNWwT.js

@@ -0,0 +1,1975 @@
+import { parse } from "yaml";
+
+//#region ../core/dist/index.js
+/** 所有公开 API 抛出的结构化错误，code 供上层可编程处理 */
+var WebSkillError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "WebSkillError";
+		this.code = code;
+		this.details = details;
+	}
+};
+const ROOT = "/";
+/** 内存文件系统：路径一律规范化为 `/` 分隔，写入自动创建父目录 */
+var MemoryFS = class {
+	kind = "memory";
+	#entries = /* @__PURE__ */ new Map();
+	constructor() {
+		this.#entries.set(ROOT, {
+			type: "directory",
+			content: /* @__PURE__ */ new Uint8Array(0),
+			mtimeMs: Date.now()
+		});
+	}
+	#normalize(path) {
+		const out = [];
+		for (const seg of path.replace(/\\/g, "/").split("/")) {
+			if (seg === "" || seg === ".") continue;
+			if (seg === "..") out.pop();
+			else out.push(seg);
+		}
+		return ROOT + out.join("/");
+	}
+	#parentOf(key) {
+		const i = key.lastIndexOf("/");
+		return i <= 0 ? ROOT : key.slice(0, i);
+	}
+	#ensureParents(key) {
+		const chain = [];
+		let dir = this.#parentOf(key);
+		while (!this.#entries.has(dir)) {
+			chain.push(dir);
+			dir = this.#parentOf(dir);
+		}
+		for (const d of chain.reverse()) this.#entries.set(d, {
+			type: "directory",
+			content: /* @__PURE__ */ new Uint8Array(0),
+			mtimeMs: Date.now()
+		});
+	}
+	#getFile(key) {
+		const entry = this.#entries.get(key);
+		if (!entry || entry.type !== "file") throw new WebSkillError("FS_NOT_FOUND", `File not found: ${key}`);
+		return entry;
+	}
+	#getDirectory(key) {
+		const entry = this.#entries.get(key);
+		if (!entry || entry.type !== "directory") throw new WebSkillError("FS_NOT_FOUND", `Directory not found: ${key}`);
+		return entry;
+	}
+	async readText(path) {
+		return new TextDecoder().decode(this.#getFile(this.#normalize(path)).content);
+	}
+	async writeText(path, content) {
+		await this.writeBinary(path, new TextEncoder().encode(content));
+	}
+	async readBinary(path) {
+		return this.#getFile(this.#normalize(path)).content;
+	}
+	async writeBinary(path, content) {
+		const key = this.#normalize(path);
+		this.#ensureParents(key);
+		this.#entries.set(key, {
+			type: "file",
+			content,
+			mtimeMs: Date.now()
+		});
+	}
+	async exists(path) {
+		return this.#entries.has(this.#normalize(path));
+	}
+	async stat(path) {
+		const key = this.#normalize(path);
+		const entry = this.#entries.get(key);
+		if (!entry) throw new WebSkillError("FS_NOT_FOUND", `Path not found: ${key}`);
+		return {
+			path: key,
+			type: entry.type,
+			size: entry.type === "file" ? entry.content.length : void 0,
+			mtimeMs: entry.mtimeMs
+		};
+	}
+	async list(path) {
+		const key = this.#normalize(path);
+		this.#getDirectory(key);
+		const prefix = key === ROOT ? ROOT : key + "/";
+		const out = [];
+		for (const [k, entry] of this.#entries) {
+			if (k === key || !k.startsWith(prefix)) continue;
+			if (k.slice(prefix.length).includes("/")) continue;
+			out.push({
+				path: k,
+				type: entry.type,
+				size: entry.type === "file" ? entry.content.length : void 0,
+				mtimeMs: entry.mtimeMs
+			});
+		}
+		return out;
+	}
+	async mkdir(path) {
+		const key = this.#normalize(path);
+		if (this.#entries.has(key)) return;
+		this.#ensureParents(key);
+		this.#entries.set(key, {
+			type: "directory",
+			content: /* @__PURE__ */ new Uint8Array(0),
+			mtimeMs: Date.now()
+		});
+	}
+	async remove(path, options) {
+		const key = this.#normalize(path);
+		if (!this.#entries.get(key)) throw new WebSkillError("FS_NOT_FOUND", `Path not found: ${key}`);
+		if (key === ROOT) throw new WebSkillError("FS_PATH_OUTSIDE_ROOT", "Cannot delete root directory");
+		const prefix = key + "/";
+		const descendants = [...this.#entries.keys()].filter((k) => k.startsWith(prefix));
+		if (descendants.length > 0 && !options?.recursive) throw new WebSkillError("FS_PATH_OUTSIDE_ROOT", `Directory not empty, use recursive: ${key}`);
+		for (const k of descendants) this.#entries.delete(k);
+		this.#entries.delete(key);
+	}
+};
+/** 统一分隔符为 `/`，去除 `.` 段与重复分隔符（不解析 `..`） */
+function normalizePath(path) {
+	return path.replace(/\\/g, "/").split("/").filter((s) => s !== "" && s !== ".").join("/");
+}
+/**
+* 将相对路径安全地解析到 root 之内。
+* 拒绝空路径、绝对路径（`/`、`\\`、`C:\` 形式）与任何 `..` 段。
+*/
+function resolveInsideRoot(root, relativePath) {
+	const fail = (reason) => {
+		throw new WebSkillError("FS_PATH_OUTSIDE_ROOT", `Path outside root: ${reason} (path: ${JSON.stringify(relativePath)})`);
+	};
+	if (relativePath.trim() === "") fail("empty path");
+	if (relativePath.startsWith("/") || relativePath.startsWith("\\") || /^[a-zA-Z]:[\\/]/.test(relativePath)) fail("absolute paths not allowed");
+	const segments = relativePath.replace(/\\/g, "/").split("/");
+	if (segments.some((s) => s === "..")) fail("`..` segments not allowed");
+	const clean = segments.filter((s) => s !== "" && s !== ".");
+	if (clean.length === 0) fail("path resolves to empty");
+	const normalizedRoot = normalizePath(root);
+	const joined = normalizedRoot === "" ? clean.join("/") : `${normalizedRoot}/${clean.join("/")}`;
+	return root.startsWith("/") || root.startsWith("\\") ? `/${joined}` : joined;
+}
+const FRONTMATTER_RE = /^---[^\S\r\n]*\r?\n([\s\S]*?)\r?\n---[^\S\r\n]*(?:\r?\n|$)([\s\S]*)$/;
+const invalid = (message, details) => {
+	throw new WebSkillError("SKILL_INVALID_METADATA", message, details);
+};
+function parseSkillMarkdown(raw) {
+	const match = FRONTMATTER_RE.exec(raw);
+	if (!match) invalid("SKILL.md missing YAML frontmatter (must start with a `---` line)");
+	const [, yamlText, bodyRaw] = match;
+	let data;
+	try {
+		data = parse(yamlText);
+	} catch (cause) {
+		invalid("frontmatter YAML parse failed", cause);
+	}
+	if (typeof data !== "object" || data === null || Array.isArray(data)) invalid("frontmatter must be a YAML object");
+	const metadata = data;
+	if (typeof metadata["name"] !== "string" || metadata["name"].trim() === "") invalid("frontmatter missing required `name` field");
+	if (typeof metadata["description"] !== "string" || metadata["description"].trim() === "") invalid("frontmatter missing required `description` field");
+	return {
+		metadata,
+		body: bodyRaw.trim()
+	};
+}
+const SKILL_NAME_MAX_LENGTH = 64;
+/** Agent Skills 官方命名规范：小写字母/数字/连字符，不允许首尾或连续连字符 */
+const SKILL_NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function isValidSkillName(name) {
+	return name.length <= 64 && SKILL_NAME_PATTERN.test(name);
+}
+const SCRIPT_EXTENSION_RE = /\.(ts|js)$/;
+/**
+* 技能合规规则的唯一实现。SkillDiscovery 与 validateSkills 都必须调用本函数，
+* 禁止各自重复实现规则（避免两套规则漂移）。
+*/
+function checkSkillRules(input) {
+	const { dirName } = input;
+	if (!input.hasSkillMd) return [{
+		code: "SKILL_NOT_FOUND",
+		severity: "warning",
+		message: `Directory ${dirName} missing SKILL.md, not treated as a skill, skipped`
+	}];
+	if (input.parseError) return [{
+		code: input.parseError.code,
+		severity: "error",
+		message: `SKILL.md parse failed for directory ${dirName}: ${input.parseError.message}`
+	}];
+	const issues = [];
+	const metadata = input.metadata;
+	if (metadata) {
+		if (!isValidSkillName(metadata.name)) issues.push({
+			code: "SKILL_INVALID_NAME",
+			severity: "error",
+			message: `Skill name ${JSON.stringify(metadata.name)} does not conform to naming convention (lowercase letters/digits/hyphens, ≤64 chars)`
+		});
+		if (metadata.name !== dirName) issues.push({
+			code: "SKILL_INVALID_NAME",
+			severity: "error",
+			message: `Skill name ${JSON.stringify(metadata.name)} does not match directory name ${JSON.stringify(dirName)}`
+		});
+		if (input.existingNames?.has(metadata.name)) issues.push({
+			code: "SKILL_DUPLICATE_NAME",
+			severity: "error",
+			message: `Duplicate skill name ${JSON.stringify(metadata.name)}`
+		});
+	}
+	for (const fileName of input.scriptFileNames ?? []) if (!SCRIPT_EXTENSION_RE.test(fileName)) issues.push({
+		code: "SKILL_UNSUPPORTED_SCRIPT",
+		severity: "error",
+		message: `Unsupported script file in scripts/ of directory ${dirName}: ${fileName} (only .ts/.js allowed)`
+	});
+	return issues;
+}
+/** 由条目列表构建 Catalog，保证按名称排序 */
+function buildCatalog(entries) {
+	return { skills: [...entries].sort((a, b) => a.name.localeCompare(b.name)) };
+}
+/** 按技能名读取技能根目录内的文件，全部读取强制经过路径安全检查 */
+var SkillReader = class {
+	#fs;
+	#index;
+	constructor(fs, index) {
+		this.#fs = fs;
+		this.#index = index;
+	}
+	#rootFor(skillName) {
+		const root = this.#index.get(skillName);
+		if (!root) throw new WebSkillError("SKILL_NOT_FOUND", `Unknown skill: ${skillName}`);
+		return root;
+	}
+	async readSkillMarkdown(skillName) {
+		return this.readSkillFile(skillName, "SKILL.md");
+	}
+	async readSkillFile(skillName, relativePath) {
+		return this.#fs.readText(resolveInsideRoot(this.#rootFor(skillName), relativePath));
+	}
+	async readSkillBinary(skillName, relativePath) {
+		return this.#fs.readBinary(resolveInsideRoot(this.#rootFor(skillName), relativePath));
+	}
+};
+const baseName$1 = (path) => path.split("/").pop() ?? path;
+var SkillDiscovery = class {
+	#fs;
+	#roots;
+	/** name → skillRoot，与 SkillReader 共享同一 Map 引用 */
+	#index = /* @__PURE__ */ new Map();
+	#reader;
+	constructor(fs, roots) {
+		this.#fs = fs;
+		this.#roots = roots;
+		this.#reader = new SkillReader(fs, this.#index);
+	}
+	async discover() {
+		this.#index.clear();
+		const entries = [];
+		const issues = [];
+		const claimedNames = /* @__PURE__ */ new Set();
+		for (const root of this.#roots) {
+			if (!await this.#fs.exists(root)) {
+				issues.push({
+					code: "FS_NOT_FOUND",
+					severity: "warning",
+					message: `Skill root directory not found, skipped: ${root}`,
+					path: root
+				});
+				continue;
+			}
+			for (const child of await this.#fs.list(root)) {
+				if (child.type !== "directory") continue;
+				const dirName = baseName$1(child.path);
+				const skillRoot = `${root}/${dirName}`;
+				const skillMdPath = `${skillRoot}/SKILL.md`;
+				const hasSkillMd = await this.#fs.exists(skillMdPath);
+				let metadata;
+				let parseError;
+				if (hasSkillMd) try {
+					metadata = parseSkillMarkdown(await this.#fs.readText(skillMdPath)).metadata;
+				} catch (e) {
+					parseError = e instanceof WebSkillError ? e : new WebSkillError("SKILL_INVALID_METADATA", String(e));
+				}
+				const scriptFileNames = await this.#listScriptFileNames(skillRoot);
+				const candidateIssues = checkSkillRules({
+					dirName,
+					hasSkillMd,
+					metadata,
+					parseError,
+					scriptFileNames,
+					existingNames: claimedNames
+				});
+				for (const issue of candidateIssues) issue.path ??= skillRoot;
+				issues.push(...candidateIssues);
+				if (metadata) claimedNames.add(metadata.name);
+				if (candidateIssues.some((i) => i.severity === "error") || !metadata) continue;
+				this.#index.set(metadata.name, skillRoot);
+				entries.push({
+					name: metadata.name,
+					description: metadata.description,
+					version: typeof metadata["version"] === "string" ? metadata["version"] : void 0,
+					license: typeof metadata["license"] === "string" ? metadata["license"] : void 0,
+					root: skillRoot,
+					source: "local",
+					hasScripts: scriptFileNames.length > 0,
+					hasReferences: await this.#fs.exists(`${skillRoot}/references`),
+					hasAssets: await this.#fs.exists(`${skillRoot}/assets`)
+				});
+			}
+		}
+		entries.sort((a, b) => a.name.localeCompare(b.name));
+		return {
+			entries,
+			issues
+		};
+	}
+	async catalog() {
+		const { entries, issues } = await this.discover();
+		return {
+			catalog: buildCatalog(entries),
+			issues
+		};
+	}
+	/** 按需加载技能完整文档；技能不存在时抛 SKILL_NOT_FOUND */
+	async loadDocument(skillName) {
+		if (this.#index.size === 0) await this.discover();
+		const { metadata, body } = parseSkillMarkdown(await this.#reader.readSkillMarkdown(skillName));
+		const skillRoot = this.#index.get(skillName);
+		return {
+			metadata,
+			body,
+			location: {
+				skillRoot,
+				skillMdPath: `${skillRoot}/SKILL.md`,
+				source: "local"
+			}
+		};
+	}
+	async #listScriptFileNames(skillRoot) {
+		const scriptsDir = `${skillRoot}/scripts`;
+		if (!await this.#fs.exists(scriptsDir)) return [];
+		return (await this.#fs.list(scriptsDir)).filter((s) => s.type === "file").map((s) => baseName$1(s.path));
+	}
+};
+/**
+* 合规校验。内部直接复用 SkillDiscovery 的扫描逻辑，
+* 规则判定同样落在 checkSkillRules 单一来源上。
+*/
+async function validateSkills(fs, roots) {
+	const { issues } = await new SkillDiscovery(fs, roots).discover();
+	return {
+		ok: !issues.some((i) => i.severity === "error"),
+		issues
+	};
+}
+function renderCatalogJson(catalog) {
+	return JSON.stringify(catalog, null, 2);
+}
+const jsonRenderer = {
+	format: "json",
+	render: renderCatalogJson
+};
+/** 转义 XML 五个特殊字符：& < > " ' */
+function escapeXml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function renderAvailableSkillsXml(catalog) {
+	const lines = ["<available_skills>"];
+	for (const skill of catalog.skills) {
+		lines.push("  <skill>");
+		lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+		lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+		if (skill.version !== void 0) lines.push(`    <version>${escapeXml(skill.version)}</version>`);
+		if (skill.license !== void 0) lines.push(`    <license>${escapeXml(skill.license)}</license>`);
+		lines.push(`    <source>${escapeXml(skill.source)}</source>`);
+		lines.push("  </skill>");
+	}
+	lines.push("</available_skills>");
+	return lines.join("\n");
+}
+const xmlRenderer = {
+	format: "xml",
+	render: renderAvailableSkillsXml
+};
+
+//#endregion
+//#region ../runtime/dist/index.js
+/**
+* 预设响应序列的确定性 LlmClient；handler 形式可按会话状态动态应答。
+* 默认不含 stream（存量行为）；构造传 { streaming: true } 启用流式：
+* 队列项 { stream: [...] } 按预设 delta 序列产出，LlmResponse 项自动合成增量。
+*/
+var MockLlmClient = class {
+	calls = [];
+	stream;
+	#queue;
+	constructor(responses, options) {
+		this.#queue = [...responses];
+		if (options?.streaming) this.stream = (input) => this.#streamImpl(input);
+	}
+	async complete(input) {
+		this.calls.push(input);
+		const next = this.#queue.shift();
+		if (!next) throw new WebSkillError("LLM_REQUEST_FAILED", "MockLlmClient: response queue exhausted");
+		if (typeof next === "function") return next(input);
+		if ("stream" in next) {
+			const events = typeof next.stream === "function" ? next.stream(input) : next.stream;
+			let content = "";
+			let toolCalls;
+			for (const event of events) if (event.type === "text-delta") content += event.delta;
+			else if (event.type === "tool-calls") toolCalls = event.toolCalls;
+			else if (event.type === "done" && event.content !== void 0) content = event.content;
+			return {
+				content,
+				toolCalls
+			};
+		}
+		return next;
+	}
+	async *#streamImpl(input) {
+		this.calls.push(input);
+		const next = this.#queue.shift();
+		if (!next) throw new WebSkillError("LLM_REQUEST_FAILED", "MockLlmClient: response queue exhausted");
+		if (typeof next !== "function" && "stream" in next) {
+			const events = typeof next.stream === "function" ? next.stream(input) : next.stream;
+			for (const event of events) yield event;
+			return;
+		}
+		const response = typeof next === "function" ? await next(input) : next;
+		if (response.content) {
+			const chunkSize = Math.max(1, Math.ceil(response.content.length / 3));
+			for (let i = 0; i < response.content.length; i += chunkSize) yield {
+				type: "text-delta",
+				delta: response.content.slice(i, i + chunkSize)
+			};
+		}
+		if (response.toolCalls?.length) yield {
+			type: "tool-calls",
+			toolCalls: response.toolCalls
+		};
+		yield { type: "done" };
+	}
+};
+const toOpenAiMessage = (msg) => {
+	if (msg.role === "tool") return {
+		role: "tool",
+		tool_call_id: msg.toolCallId,
+		content: msg.content
+	};
+	if (msg.role === "assistant" && msg.toolCalls?.length) return {
+		role: "assistant",
+		content: msg.content === "" ? null : msg.content,
+		tool_calls: msg.toolCalls.map((call) => ({
+			id: call.id,
+			type: "function",
+			function: {
+				name: call.name,
+				arguments: JSON.stringify(call.arguments)
+			}
+		}))
+	};
+	return {
+		role: msg.role,
+		content: msg.content
+	};
+};
+const toOpenAiTools = (tools) => tools.map((tool) => ({
+	type: "function",
+	function: {
+		name: tool.name,
+		...tool.description ? { description: tool.description } : {},
+		parameters: tool.inputSchema
+	}
+}));
+const errorMessage = (e) => e instanceof Error ? e.message : String(e);
+/** OpenAI chat completions 协议客户端（兼容端点通用） */
+var OpenAiCompatibleClient = class {
+	#config;
+	#fetch;
+	constructor(config) {
+		this.#config = config;
+		this.#fetch = config.fetchImpl ?? fetch;
+	}
+	#requireConfig() {
+		const { baseUrl, apiKey, model } = this.#config;
+		if (!baseUrl || !apiKey || !model) throw new WebSkillError("LLM_UNAVAILABLE", "LLM client is not configured: baseUrl, apiKey and model are all required");
+		return {
+			baseUrl: baseUrl.replace(/\/+$/, ""),
+			apiKey,
+			model
+		};
+	}
+	async complete(input) {
+		const res = await this.#postChat(input, false);
+		let data;
+		try {
+			data = await res.json();
+		} catch (e) {
+			throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to parse LLM response: ${errorMessage(e)}`, e);
+		}
+		return this.#parseResponse(data);
+	}
+	/** SSE 流式：fetch + ReadableStream 按行解析 data: 帧（Node/浏览器通用） */
+	async *stream(input) {
+		const res = await this.#postChat(input, true);
+		if (!res.body) throw new WebSkillError("LLM_REQUEST_FAILED", "LLM streaming response has no body");
+		const toolCallsByIndex = /* @__PURE__ */ new Map();
+		const decoder = new TextDecoder();
+		const reader = res.body.getReader();
+		let buffer = "";
+		let done = false;
+		const handleFrame = function* (data) {
+			if (data === "[DONE]") {
+				done = true;
+				return;
+			}
+			let chunk;
+			try {
+				chunk = JSON.parse(data);
+			} catch (e) {
+				throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to parse LLM stream frame: ${errorMessage(e)}`, data);
+			}
+			const delta = chunk.choices?.[0]?.delta;
+			if (!delta) return;
+			if (typeof delta["content"] === "string" && delta["content"] !== "") yield {
+				type: "text-delta",
+				delta: delta["content"]
+			};
+			const toolDeltas = delta["tool_calls"];
+			for (const td of toolDeltas ?? []) {
+				const index = td.index ?? 0;
+				const acc = toolCallsByIndex.get(index) ?? {
+					id: "",
+					name: "",
+					arguments: ""
+				};
+				if (td.id) acc.id = td.id;
+				if (td.function?.name) acc.name = td.function.name;
+				if (td.function?.arguments) acc.arguments += td.function.arguments;
+				toolCallsByIndex.set(index, acc);
+			}
+		};
+		try {
+			for (;;) {
+				const { value, done: readerDone } = await reader.read();
+				if (readerDone) break;
+				buffer += decoder.decode(value, { stream: true });
+				buffer = buffer.replace(/\r\n/g, "\n");
+				let newline;
+				while ((newline = buffer.indexOf("\n")) >= 0) {
+					const line = buffer.slice(0, newline).trim();
+					buffer = buffer.slice(newline + 1);
+					if (line === "" || line.startsWith(":")) continue;
+					if (!line.startsWith("data:")) continue;
+					yield* handleFrame(line.slice(5).trim());
+					if (done) break;
+				}
+				if (done) break;
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		if (toolCallsByIndex.size > 0) yield {
+			type: "tool-calls",
+			toolCalls: [...toolCallsByIndex.entries()].sort(([a], [b]) => a - b).map(([index, acc]) => {
+				let args = {};
+				try {
+					args = JSON.parse(acc.arguments || "{}");
+				} catch {}
+				return {
+					id: acc.id || `call-${index}`,
+					name: acc.name,
+					arguments: args
+				};
+			})
+		};
+		yield { type: "done" };
+	}
+	async #postChat(input, stream) {
+		const { baseUrl, apiKey, model } = this.#requireConfig();
+		const body = {
+			model: input.model ?? model,
+			messages: input.messages.map(toOpenAiMessage)
+		};
+		if (input.tools?.length) {
+			body["tools"] = toOpenAiTools(input.tools);
+			body["tool_choice"] = "auto";
+		}
+		if (input.temperature !== void 0) body["temperature"] = input.temperature;
+		if (stream) body["stream"] = true;
+		let res;
+		try {
+			res = await this.#fetch(`${baseUrl}/chat/completions`, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					authorization: `Bearer ${apiKey}`
+				},
+				body: JSON.stringify(body),
+				signal: input.signal ?? (this.#config.requestTimeoutMs ? AbortSignal.timeout(this.#config.requestTimeoutMs) : null)
+			});
+		} catch (e) {
+			throw new WebSkillError("LLM_REQUEST_FAILED", `LLM request failed: ${errorMessage(e)}`, e);
+		}
+		if (!res.ok) {
+			const detail = await res.text().catch(() => "");
+			throw new WebSkillError("LLM_REQUEST_FAILED", `LLM request failed with HTTP ${res.status}${detail ? `: ${detail.slice(0, 500)}` : ""}`);
+		}
+		return res;
+	}
+	/** 轻量探测（GET /models），集成测试据此决定 skip */
+	async checkAvailability() {
+		try {
+			const { baseUrl, apiKey } = this.#requireConfig();
+			return (await this.#fetch(`${baseUrl}/models`, { headers: { authorization: `Bearer ${apiKey}` } })).ok;
+		} catch {
+			return false;
+		}
+	}
+	#parseResponse(data) {
+		try {
+			const choice = data.choices?.[0]?.message;
+			if (!choice) throw new Error("response has no choices[0].message");
+			const toolCalls = choice["tool_calls"]?.map((tc) => {
+				const rawArgs = tc.function?.arguments ?? "{}";
+				return {
+					id: tc.id,
+					name: tc.function?.name ?? "",
+					arguments: JSON.parse(rawArgs)
+				};
+			});
+			const content = choice["content"];
+			return {
+				content: typeof content === "string" ? content : void 0,
+				toolCalls: toolCalls?.length ? toolCalls : void 0,
+				raw: data
+			};
+		} catch (e) {
+			throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to interpret LLM response: ${errorMessage(e)}`, data);
+		}
+	}
+};
+function toVercelToolSpecs(tools) {
+	const out = {};
+	for (const tool of tools) out[tool.name] = {
+		...tool.description ? { description: tool.description } : {},
+		inputSchema: tool.inputSchema
+	};
+	return out;
+}
+/** 接受 generateText 的返回值形状：{ text?, toolCalls?: [{ toolCallId, toolName, input|args }] } */
+function fromVercelResult(result) {
+	const r = result;
+	const toolCalls = (r.toolCalls ?? []).map((tc, i) => {
+		const args = tc.input ?? tc.args ?? {};
+		return {
+			id: typeof tc.toolCallId === "string" ? tc.toolCallId : `call-${i}`,
+			name: typeof tc.toolName === "string" ? tc.toolName : "",
+			arguments: typeof args === "object" && args !== null ? args : {}
+		};
+	});
+	return {
+		content: typeof r.text === "string" && r.text !== "" ? r.text : void 0,
+		toolCalls: toolCalls.length ? toolCalls : void 0,
+		raw: result
+	};
+}
+/**
+* Vercel streamText fullStream 片段 → LlmStreamEvent 映射。
+* 未知片段类型返回 undefined（调用方跳过）。
+*/
+function fromVercelStreamPart(part) {
+	const p = part ?? {};
+	switch (p["type"]) {
+		case "text-delta": {
+			const delta = p["text"] ?? p["delta"];
+			return typeof delta === "string" && delta !== "" ? {
+				type: "text-delta",
+				delta
+			} : void 0;
+		}
+		case "tool-call": return {
+			type: "tool-calls",
+			toolCalls: [{
+				id: typeof p["toolCallId"] === "string" ? p["toolCallId"] : "call-0",
+				name: typeof p["toolName"] === "string" ? p["toolName"] : "",
+				arguments: typeof p["input"] === "object" && p["input"] !== null ? p["input"] : {}
+			}]
+		};
+		case "finish": return { type: "done" };
+		default: return;
+	}
+}
+const INSTRUCTIONS$1 = `You are an agent that completes tasks by using skills.
+
+Skills are disclosed progressively: the catalog below only shows metadata. To use a skill:
+1. Call the "read_skill_file" tool to load the skill's SKILL.md instructions. Reading SKILL.md activates the skill's script tools, which are named "<skillName>__<scriptName>".
+2. Call the activated script tools to do the work.
+3. If a tool call fails, read the error, adjust your approach and retry, or continue without it.
+4. When the task is complete, answer in plain text without calling any tool.`;
+/** 渐进披露路由（默认）：system prompt 只注入 Catalog 元数据 + 工具使用说明 */
+var ProgressiveRouter = class {
+	async route(catalog) {
+		return {
+			strategy: "progressive",
+			catalog,
+			systemPrompt: `${INSTRUCTIONS$1}\n\n${renderAvailableSkillsXml(catalog)}`
+		};
+	}
+};
+const INSTRUCTIONS = `You are an agent that completes tasks by using skills.
+The full instructions of every available skill are injected below. Follow them directly.
+Script tools are named "<skillName>__<scriptName>".
+When the task is complete, answer in plain text without calling any tool.`;
+/** 全量披露路由（对照用）：注入每个技能的完整 SKILL.md 正文 */
+var FullDisclosureRouter = class {
+	#discovery;
+	constructor(discovery) {
+		this.#discovery = discovery;
+	}
+	async route(catalog) {
+		const sections = [];
+		for (const entry of catalog.skills) {
+			const doc = await this.#discovery.loadDocument(entry.name);
+			sections.push(`<skill name="${entry.name}">\n${doc.body}\n</skill>`);
+		}
+		return {
+			strategy: "full-disclosure",
+			catalog,
+			systemPrompt: `${INSTRUCTIONS}\n\n${sections.join("\n\n")}`
+		};
+	}
+};
+/**
+* 工具名解析规则（单一实现，Agent 循环使用）：
+* 1. `<skillName>__<scriptName>` 且前缀是已激活技能 → 本地脚本
+* 2. `endpoint:` 前缀 → TOOL_UNSUPPORTED（MCP 阶段实现）
+* 3. `mcp#` 前缀 → TOOL_UNSUPPORTED（WebMCP 阶段实现）
+* 4. 其余 → TOOL_NOT_FOUND
+*/
+function resolveToolName(name, activatedSkills) {
+	const sep = name.indexOf("__");
+	if (sep > 0) {
+		const skillName = name.slice(0, sep);
+		const scriptName = name.slice(sep + 2);
+		if (activatedSkills.has(skillName) && scriptName !== "") return {
+			kind: "script",
+			skillName,
+			scriptName
+		};
+	}
+	if (name.startsWith("endpoint:")) return {
+		kind: "unsupported",
+		code: "TOOL_UNSUPPORTED",
+		message: `Tool "${name}" uses an MCP endpoint, which is not supported yet`
+	};
+	if (name.startsWith("mcp#")) return {
+		kind: "unsupported",
+		code: "TOOL_UNSUPPORTED",
+		message: `Tool "${name}" is a WebMCP tool, which is not supported yet`
+	};
+	return {
+		kind: "not-found",
+		code: "TOOL_NOT_FOUND",
+		message: `Unknown tool "${name}". Activate the owning skill first by reading its SKILL.md`
+	};
+}
+/** ToolDefinition → LLM 工具 spec；缺 schema 时用宽松 object 兜底并在描述中标记 */
+function toLlmToolSpec(tool) {
+	if (tool.inputSchema) return {
+		name: tool.name,
+		...tool.description ? { description: tool.description } : {},
+		inputSchema: tool.inputSchema
+	};
+	const note = "Input schema unavailable; call with no arguments or a simple object.";
+	return {
+		name: tool.name,
+		description: tool.description ? `${tool.description} (${note})` : note,
+		inputSchema: {
+			type: "object",
+			properties: {}
+		}
+	};
+}
+const MCP_CONTENT_RE = /^(text|json|image|resource|audio)$/;
+/**
+* 脚本返回值归一到 MCP content 格式：数组沿用（逐项归一），
+* 字符串包装为 text，其他值序列化包装。Node/浏览器执行器共享。
+*/
+function normalizeToolContent(value) {
+	if (Array.isArray(value)) return value.map((item) => {
+		if (typeof item === "object" && item !== null && typeof item.type === "string" && MCP_CONTENT_RE.test(item.type)) {
+			const { type, ...rest } = item;
+			if (type === "json") return {
+				type: "json",
+				data: rest["data"] ?? rest
+			};
+			return {
+				type: "text",
+				text: typeof rest["text"] === "string" ? rest["text"] : JSON.stringify(rest)
+			};
+		}
+		return {
+			type: "text",
+			text: typeof item === "string" ? item : JSON.stringify(item)
+		};
+	});
+	if (typeof value === "string") return [{
+		type: "text",
+		text: value
+	}];
+	if (value === void 0 || value === null) return [{
+		type: "text",
+		text: ""
+	}];
+	return [{
+		type: "text",
+		text: typeof value === "object" ? JSON.stringify(value) : String(value)
+	}];
+}
+const READ_SKILL_FILE_TOOL_NAME = "read_skill_file";
+const READ_SKILL_FILE_INPUT_SCHEMA = {
+	type: "object",
+	properties: {
+		skillName: {
+			type: "string",
+			description: "Name of the skill to read (must match the catalog)"
+		},
+		path: {
+			type: "string",
+			description: "File path relative to the skill root. Defaults to \"SKILL.md\". Reading SKILL.md activates the skill."
+		}
+	},
+	required: ["skillName"]
+};
+/** 内置工具：读取技能文件（读 SKILL.md 是技能激活的入口） */
+const READ_SKILL_FILE_TOOL = {
+	name: READ_SKILL_FILE_TOOL_NAME,
+	description: "Read a file from a skill directory. Read \"SKILL.md\" first to get the skill instructions and activate its script tools.",
+	inputSchema: READ_SKILL_FILE_INPUT_SCHEMA,
+	source: "builtin"
+};
+const ASK_USER_TOOL_NAME = "ask_user";
+const ASK_USER_INPUT_SCHEMA = {
+	type: "object",
+	properties: { question: {
+		type: "string",
+		description: "The question to ask the user"
+	} },
+	required: ["question"]
+};
+/** 内建工具：LLM 信息不足时主动向用户提问；仅当配置了 UiBridge 时注册 */
+const ASK_USER_TOOL = {
+	name: ASK_USER_TOOL_NAME,
+	description: "Ask the user a question when information is missing and continue with their answer.",
+	inputSchema: ASK_USER_INPUT_SCHEMA,
+	source: "builtin"
+};
+/**
+* 脚本执行上下文：只暴露 readReference / writeArtifact 两个显式能力，
+* 不暴露 fs 本体（沙箱语义，对齐 deferred-items D1）。
+*/
+function createScriptContext(deps) {
+	const { fs, artifactStore, skillName, skillRoot, runId, confirm } = deps;
+	return {
+		skillName,
+		runId,
+		async readReference(relativePath) {
+			return fs.readText(resolveInsideRoot(skillRoot, `references/${relativePath}`));
+		},
+		async writeArtifact(path, content, options) {
+			return typeof content === "string" ? artifactStore.createTextArtifact({
+				runId,
+				path,
+				content,
+				mimeType: options?.mimeType
+			}) : artifactStore.createBinaryArtifact({
+				runId,
+				path,
+				content,
+				mimeType: options?.mimeType
+			});
+		},
+		...confirm ? { confirm } : {}
+	};
+}
+/**
+* 默认的结果渲染构造：LLM 最终输出 → markdown block，
+* run.artifacts → file blocks；summary 取 terminationReason。
+*/
+function buildRenderResult(run, output) {
+	const blocks = [];
+	if (output.trim() !== "") blocks.push({
+		type: "markdown",
+		text: output
+	});
+	for (const artifact of run.artifacts) blocks.push({
+		type: "file",
+		path: artifact.path,
+		...artifact.mimeType ? { mimeType: artifact.mimeType } : {},
+		size: artifact.size
+	});
+	return {
+		runId: run.id,
+		summary: run.terminationReason,
+		blocks,
+		artifacts: run.artifacts
+	};
+}
+/**
+* JsonSchema → 表单模型：按 properties 生成字段，required 标记必填；
+* providedArgs 已有的值作为 defaultValue 预填（表单只为补齐缺失项服务）。
+* type 映射：string→text、number/integer→number、boolean→boolean、enum→select、其余→textarea。
+*/
+function schemaToForm(schema, providedArgs) {
+	const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+	const fields = [];
+	for (const [name, prop] of Object.entries(schema.properties ?? {})) {
+		const provided = providedArgs?.[name];
+		const field = {
+			name,
+			label: name,
+			type: mapFieldType(prop),
+			...required.has(name) ? { required: true } : {},
+			...typeof prop.description === "string" ? { description: prop.description } : {},
+			...provided !== void 0 ? { defaultValue: provided } : prop.default !== void 0 ? { defaultValue: prop.default } : {}
+		};
+		if (Array.isArray(prop.enum)) field.options = prop.enum.map((v) => ({
+			label: String(v),
+			value: v
+		}));
+		fields.push(field);
+	}
+	return fields;
+}
+function mapFieldType(prop) {
+	if (Array.isArray(prop.enum)) return "select";
+	switch (prop.type) {
+		case "string": return "text";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		default: return "textarea";
+	}
+}
+/**
+* 测试用 UiBridge：按请求 id 或类型预设应答（永不 resolve 的 handler 可模拟超时）；
+* 记录全部请求供断言。
+*/
+var MockUiBridge = class {
+	requests = [];
+	#answers = /* @__PURE__ */ new Map();
+	#fallback;
+	/** key 为请求 id 或请求类型（'ask' | 'confirm' | 'form' | 'select'） */
+	respondTo(key, answer) {
+		this.#answers.set(key, answer);
+		return this;
+	}
+	setFallback(answer) {
+		this.#fallback = answer;
+		return this;
+	}
+	async request(input) {
+		this.requests.push(input);
+		const answer = this.#answers.get(input.id) ?? this.#answers.get(input.type) ?? this.#fallback;
+		if (!answer) return {
+			id: input.id,
+			cancelled: true
+		};
+		return typeof answer === "function" ? answer(input) : answer;
+	}
+};
+/** 生命周期事件总线：只读观测，支持按阶段或通配订阅 */
+var EventBus = class {
+	#listeners = /* @__PURE__ */ new Map();
+	/** 返回取消订阅函数 */
+	on(phase, listener) {
+		const key = phase;
+		let set = this.#listeners.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#listeners.set(key, set);
+		}
+		set.add(listener);
+		return () => set.delete(listener);
+	}
+	/** 当前订阅者数量（流式 delta 零订阅零开销判断用） */
+	listenerCount() {
+		let count = 0;
+		for (const set of this.#listeners.values()) count += set.size;
+		return count;
+	}
+	emit(event) {
+		const frozen = Object.freeze(event);
+		for (const listener of this.#listeners.get(event.phase) ?? []) listener(frozen);
+		for (const listener of this.#listeners.get("*") ?? []) listener(frozen);
+	}
+};
+const messageOf$1 = (e) => e instanceof Error ? e.message : String(e);
+/** 受控钩子执行器：逐个执行，超时/异常默认降级为 warning，可切严格模式 */
+var HookRunner = class {
+	#hooks = /* @__PURE__ */ new Map();
+	timeoutMs;
+	failOnHookError;
+	onWarning;
+	constructor(options = {}) {
+		this.timeoutMs = options.timeoutMs ?? 5e3;
+		this.failOnHookError = options.failOnHookError ?? false;
+		this.onWarning = options.onWarning;
+	}
+	register(phase, hook) {
+		const key = phase;
+		const list = this.#hooks.get(key) ?? [];
+		list.push(hook);
+		this.#hooks.set(key, list);
+		return this;
+	}
+	async run(phase, ctx) {
+		const hooks = [...this.#hooks.get(phase) ?? [], ...this.#hooks.get("*") ?? []];
+		for (const hook of hooks) try {
+			await this.#withTimeout(Promise.resolve().then(() => hook(ctx)), phase);
+		} catch (e) {
+			if (this.failOnHookError) throw e instanceof WebSkillError ? e : new WebSkillError("RUN_FAILED", messageOf$1(e), e);
+			this.onWarning?.(messageOf$1(e));
+		}
+	}
+	#withTimeout(promise, phase) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => reject(new WebSkillError("RUN_TIMEOUT", `Lifecycle hook for phase "${phase}" timed out after ${this.timeoutMs}ms`)), this.timeoutMs);
+			promise.then((v) => {
+				clearTimeout(timer);
+				resolve(v);
+			}, (e) => {
+				clearTimeout(timer);
+				reject(e instanceof Error ? e : new Error(String(e)));
+			});
+		});
+	}
+};
+/** 内存 MemoryStore：测试与浏览器降级用 */
+var InMemoryStore = class {
+	#data = /* @__PURE__ */ new Map();
+	async get(scope, key) {
+		return this.#data.get(scope)?.get(key);
+	}
+	async set(scope, key, value) {
+		let bucket = this.#data.get(scope);
+		if (!bucket) {
+			bucket = /* @__PURE__ */ new Map();
+			this.#data.set(scope, bucket);
+		}
+		bucket.set(key, value);
+	}
+	async delete(scope, key) {
+		this.#data.get(scope)?.delete(key);
+	}
+	async list(scope) {
+		return [...(this.#data.get(scope) ?? /* @__PURE__ */ new Map()).entries()].map(([key, value]) => ({
+			key,
+			value
+		}));
+	}
+	async clear(scope) {
+		if (scope === void 0) this.#data.clear();
+		else this.#data.delete(scope);
+	}
+};
+const encode = (s) => encodeURIComponent(s);
+/**
+* 基于 FileSystemProvider 的 MemoryStore：
+* <root>/<encodeURIComponent(scope)>/<encodeURIComponent(key)>.json
+* scope/key 全部编码防路径穿越；环境无关，构造必须显式传 fs。
+*/
+var FsMemoryStore = class {
+	#root;
+	#fs;
+	constructor(deps) {
+		this.#root = deps.root.replace(/\/+$/, "");
+		this.#fs = deps.fs;
+	}
+	#scopeDir(scope) {
+		return `${this.#root}/${encode(scope)}`;
+	}
+	#keyPath(scope, key) {
+		return `${this.#scopeDir(scope)}/${encode(key)}.json`;
+	}
+	async get(scope, key) {
+		const path = this.#keyPath(scope, key);
+		if (!await this.#fs.exists(path)) return void 0;
+		return JSON.parse(await this.#fs.readText(path));
+	}
+	async set(scope, key, value) {
+		await this.#fs.writeText(this.#keyPath(scope, key), JSON.stringify(value, null, 2));
+	}
+	async delete(scope, key) {
+		const path = this.#keyPath(scope, key);
+		if (await this.#fs.exists(path)) await this.#fs.remove(path);
+	}
+	async list(scope) {
+		const dir = this.#scopeDir(scope);
+		if (!await this.#fs.exists(dir)) return [];
+		const out = [];
+		for (const entry of await this.#fs.list(dir)) {
+			if (entry.type !== "file" || !entry.path.endsWith(".json")) continue;
+			const fileName = entry.path.split("/").pop() ?? "";
+			const key = decodeURIComponent(fileName.replace(/\.json$/, ""));
+			out.push({
+				key,
+				value: JSON.parse(await this.#fs.readText(entry.path))
+			});
+		}
+		return out.sort((a, b) => a.key.localeCompare(b.key));
+	}
+	async clear(scope) {
+		if (scope !== void 0) {
+			const dir = this.#scopeDir(scope);
+			if (await this.#fs.exists(dir)) await this.#fs.remove(dir, { recursive: true });
+			return;
+		}
+		if (!await this.#fs.exists(this.#root)) return;
+		for (const entry of await this.#fs.list(this.#root)) await this.#fs.remove(entry.path, { recursive: true });
+	}
+};
+/** 内存 ArtifactStore：测试与浏览器降级用；索引随进程生命周期存在 */
+var MemoryArtifactStore = class {
+	#byRun = /* @__PURE__ */ new Map();
+	#seq = 0;
+	async createTextArtifact(input) {
+		return this.#record({
+			runId: input.runId,
+			path: input.path,
+			type: "text",
+			size: new TextEncoder().encode(input.content).length,
+			mimeType: input.mimeType,
+			metadata: input.metadata
+		});
+	}
+	async createBinaryArtifact(input) {
+		return this.#record({
+			runId: input.runId,
+			path: input.path,
+			type: "binary",
+			size: input.content.length,
+			mimeType: input.mimeType,
+			metadata: input.metadata
+		});
+	}
+	async listArtifacts(runId) {
+		return [...this.#byRun.get(runId) ?? []];
+	}
+	#record(input) {
+		const artifact = {
+			id: `art-${++this.#seq}`,
+			runId: input.runId,
+			path: input.path,
+			type: input.type,
+			mimeType: input.mimeType,
+			size: input.size,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			metadata: input.metadata
+		};
+		const list = this.#byRun.get(input.runId) ?? [];
+		list.push(artifact);
+		this.#byRun.set(input.runId, list);
+		return artifact;
+	}
+};
+const INDEX_FILE = "index.json";
+/**
+* 基于 FileSystemProvider 的 ArtifactStore：产物落盘 <root>/<runId>/<path>，
+* 每次写入同步更新 <root>/<runId>/index.json，新实例可凭索引恢复列表。
+* 环境无关（OPFS/Node 均可），构造必须显式传 fs。
+*/
+var FsArtifactStore = class {
+	#root;
+	#fs;
+	constructor(deps) {
+		this.#root = deps.root.replace(/\/+$/, "");
+		this.#fs = deps.fs;
+	}
+	async createTextArtifact(input) {
+		const size = new TextEncoder().encode(input.content).length;
+		await this.#fs.writeText(this.#artifactPath(input.runId, input.path), input.content);
+		return this.#persist({
+			...input,
+			type: "text",
+			size
+		});
+	}
+	async createBinaryArtifact(input) {
+		await this.#fs.writeBinary(this.#artifactPath(input.runId, input.path), input.content);
+		return this.#persist({
+			...input,
+			type: "binary",
+			size: input.content.length
+		});
+	}
+	async listArtifacts(runId) {
+		const indexPath = `${this.#root}/${runId}/${INDEX_FILE}`;
+		if (!await this.#fs.exists(indexPath)) return [];
+		const raw = await this.#fs.readText(indexPath);
+		return JSON.parse(raw).artifacts ?? [];
+	}
+	#artifactPath(runId, artifactPath) {
+		return resolveInsideRoot(`${this.#root}/${runId}`, artifactPath);
+	}
+	async #persist(input) {
+		const artifact = {
+			id: `${input.runId}/${input.path}`,
+			runId: input.runId,
+			path: input.path,
+			type: input.type,
+			mimeType: input.mimeType,
+			size: input.size,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			metadata: input.metadata
+		};
+		const next = [...(await this.listArtifacts(input.runId)).filter((a) => a.id !== artifact.id), artifact];
+		await this.#fs.writeText(`${this.#root}/${input.runId}/${INDEX_FILE}`, JSON.stringify({ artifacts: next }, null, 2));
+		return artifact;
+	}
+};
+const isRecord = (v) => typeof v === "object" && v !== null;
+const isNonEmptyString = (v) => typeof v === "string" && v !== "";
+/** 入站校验：非法 kind / 缺 id / 缺字段 → undefined（调用方忽略并记 warning） */
+function parseBridgeRequest(data) {
+	if (!isRecord(data)) return void 0;
+	const { kind, id } = data;
+	if (!isNonEmptyString(id)) return void 0;
+	switch (kind) {
+		case "readReference": return isNonEmptyString(data["path"]) ? {
+			kind,
+			id,
+			path: data["path"]
+		} : void 0;
+		case "writeArtifact": {
+			const { path, content, mimeType } = data;
+			const validContent = typeof content === "string" || Array.isArray(content) && content.every((n) => typeof n === "number");
+			if (!isNonEmptyString(path) || !validContent) return void 0;
+			return {
+				kind,
+				id,
+				path,
+				content,
+				...isNonEmptyString(mimeType) ? { mimeType } : {}
+			};
+		}
+		case "confirm": return isNonEmptyString(data["message"]) ? {
+			kind,
+			id,
+			message: data["message"]
+		} : void 0;
+		default: return;
+	}
+}
+function bridgeError(id, code, message) {
+	return {
+		id,
+		ok: false,
+		error: {
+			code,
+			message
+		}
+	};
+}
+/** 结构化 trace 记录器；时钟与 id 工厂可注入（golden trace 用固定值保证确定性） */
+var TraceRecorder = class {
+	#runId;
+	#clock;
+	#events = [];
+	#seq = 0;
+	constructor(runId, clock = {}) {
+		this.#runId = runId;
+		this.#clock = clock;
+	}
+	record(type, opts) {
+		const event = {
+			id: this.#clock.createId?.() ?? `evt-${++this.#seq}`,
+			runId: this.#runId,
+			ts: this.#clock.now?.() ?? (/* @__PURE__ */ new Date()).toISOString(),
+			type,
+			...opts?.message !== void 0 ? { message: opts.message } : {},
+			...opts?.data !== void 0 ? { data: opts.data } : {}
+		};
+		this.#events.push(event);
+		return event;
+	}
+	list() {
+		return [...this.#events];
+	}
+};
+/** 交互终态（取消/超时）：从工具执行深处直接终止 run */
+var RunTerminated = class extends Error {
+	outcome;
+	constructor(outcome) {
+		super(outcome.message);
+		this.outcome = outcome;
+	}
+};
+/** bridge.request 自身异常（非超时）：恢复 running 后转为工具错误回喂 */
+var BridgeRequestError = class extends Error {};
+const baseName = (p) => p.split("/").pop() ?? p;
+const messageOf = (e) => e instanceof Error ? e.message : String(e);
+const toolError = (code, message) => ({
+	ok: false,
+	content: [],
+	error: {
+		code,
+		message
+	}
+});
+/**
+* 多轮 Agent 循环。
+* 工具失败一律转为 ToolResult{ok:false} 回喂 LLM 继续循环；
+* 缺参/确认/提问经 UiBridge 行内 await 暂停恢复；取消/超时/LLM 异常/护栏超限才终止 run。
+*/
+var AgentLoop = class {
+	#deps;
+	#config;
+	#policy;
+	constructor(deps, config = {}) {
+		this.#deps = deps;
+		this.#config = {
+			maxTurns: config.maxTurns ?? 10,
+			totalTimeoutMs: config.totalTimeoutMs ?? 12e4,
+			toolTimeoutMs: config.toolTimeoutMs ?? 3e4,
+			temperature: config.temperature,
+			renderResult: config.renderResult
+		};
+		this.#policy = {
+			missingParams: deps.interaction?.missingParams ?? "user",
+			confirmations: deps.interaction?.confirmations ?? "required",
+			interactionTimeoutMs: deps.interaction?.interactionTimeoutMs ?? 3e5
+		};
+	}
+	async run(input) {
+		const { llm, artifactStore } = this.#deps;
+		const now = this.#deps.clock?.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+		const runId = input.runId ?? `run-${Math.random().toString(36).slice(2, 10)}`;
+		const trace = new TraceRecorder(runId, this.#deps.clock);
+		const startedAt = now();
+		const startMs = Date.parse(startedAt);
+		const run = {
+			id: runId,
+			sessionId: input.sessionId,
+			status: "running",
+			phase: "route",
+			userPrompt: input.userPrompt,
+			startedAt,
+			activeSkillNames: [],
+			artifacts: [],
+			trace: []
+		};
+		const state = {
+			runId,
+			run,
+			trace,
+			reader: new SkillReader(this.#deps.fs, this.#deps.skillIndex),
+			activated: /* @__PURE__ */ new Set(),
+			activatedTools: /* @__PURE__ */ new Map(),
+			toolTimeoutMs: this.#config.toolTimeoutMs,
+			now,
+			interactionSeq: 0
+		};
+		if (this.#deps.hooks && !this.#deps.hooks.onWarning) this.#deps.hooks.onWarning = (message) => trace.record("run.warning", { message });
+		const route = this.#deps.catalogFilter ? {
+			...input.route,
+			catalog: { skills: await this.#deps.catalogFilter(input.route.catalog.skills) }
+		} : input.route;
+		trace.record("skill.routed", { data: {
+			strategy: route.strategy,
+			skillCount: route.catalog.skills.length
+		} });
+		await this.#lifecycle("route", state, { strategy: route.strategy });
+		const externalSpecs = (await Promise.all((this.#deps.externalTools ?? []).map(async (source) => {
+			try {
+				return await source.listToolSpecs();
+			} catch (e) {
+				trace.record("run.warning", { message: `External tool source "${source.kind}" failed to list specs: ${messageOf(e)}` });
+				return [];
+			}
+		}))).flat();
+		const messages = [{
+			role: "system",
+			content: route.systemPrompt
+		}, {
+			role: "user",
+			content: input.userPrompt
+		}];
+		const finish = async (status, reason, output, errorCode) => {
+			run.status = status;
+			run.terminationReason = reason;
+			run.endedAt = now();
+			run.activeSkillNames = [...state.activated].sort();
+			run.artifacts = await artifactStore.listArtifacts(runId);
+			if (status === "completed") trace.record("run.completed", { data: { reason } });
+			else if (status === "cancelled") trace.record("run.cancelled", {
+				message: output,
+				data: { reason }
+			});
+			else trace.record("run.failed", {
+				message: output,
+				data: {
+					reason,
+					...errorCode ? { code: errorCode } : {}
+				}
+			});
+			const bridge = this.#deps.uiBridge;
+			if (status === "completed" && bridge?.renderResult && this.#config.renderResult !== "off") try {
+				const request = buildRenderResult(run, output);
+				await bridge.renderResult(request);
+				trace.record("ui.rendered", { data: { blockCount: request.blocks.length } });
+			} catch (e) {
+				trace.record("run.warning", { message: `renderResult failed: ${messageOf(e)}` });
+			}
+			try {
+				await this.#lifecycle(status === "completed" ? "complete" : "fail", state, { reason });
+			} catch (e) {
+				trace.record("run.warning", { message: `Terminal lifecycle hook failed: ${messageOf(e)}` });
+			}
+			run.trace = trace.list();
+			return {
+				output,
+				run
+			};
+		};
+		try {
+			for (let turn = 1;; turn++) {
+				if (turn > this.#config.maxTurns) return await finish("failed", "max-turns", `Agent loop exceeded the maximum of ${this.#config.maxTurns} turns`, "RUN_MAX_TURNS_EXCEEDED");
+				if (Date.parse(now()) - startMs > this.#config.totalTimeoutMs) return await finish("failed", "timeout", `Agent loop exceeded the total timeout of ${this.#config.totalTimeoutMs}ms`, "RUN_TIMEOUT");
+				const toolSpecs = [
+					toLlmToolSpec(READ_SKILL_FILE_TOOL),
+					...this.#deps.uiBridge ? [toLlmToolSpec(ASK_USER_TOOL)] : [],
+					...[...state.activatedTools.values()].map(toLlmToolSpec),
+					...externalSpecs
+				];
+				trace.record("llm.request", { data: {
+					turn,
+					messageCount: messages.length,
+					toolCount: toolSpecs.length
+				} });
+				let response;
+				try {
+					response = llm.stream ? await this.#completeStreaming(llm, state, {
+						model: this.#deps.model,
+						messages,
+						tools: toolSpecs,
+						temperature: this.#config.temperature
+					}) : await llm.complete({
+						model: this.#deps.model,
+						messages,
+						tools: toolSpecs,
+						temperature: this.#config.temperature
+					});
+				} catch (e) {
+					const code = e instanceof WebSkillError && (e.code === "LLM_UNAVAILABLE" || e.code === "LLM_REQUEST_FAILED") ? e.code : "LLM_REQUEST_FAILED";
+					return await finish("failed", "llm-error", messageOf(e), code);
+				}
+				trace.record("llm.response", { data: {
+					turn,
+					hasToolCalls: Boolean(response.toolCalls?.length),
+					contentLength: response.content?.length ?? 0
+				} });
+				if (!response.toolCalls?.length) return await finish("completed", "final-answer", response.content ?? "");
+				await this.#lifecycle("execute", state, { turn });
+				messages.push({
+					role: "assistant",
+					content: response.content ?? "",
+					toolCalls: response.toolCalls
+				});
+				for (const call of response.toolCalls) {
+					let result;
+					try {
+						result = await this.#executeCall(call, state);
+					} catch (e) {
+						if (e instanceof RunTerminated) return await finish(e.outcome.status, e.outcome.reason, e.outcome.message, e.outcome.code);
+						throw e;
+					}
+					messages.push({
+						role: "tool",
+						toolCallId: call.id,
+						content: JSON.stringify(result)
+					});
+				}
+			}
+		} catch (e) {
+			if (e instanceof WebSkillError && e.code === "RUN_FAILED") return await finish("failed", "hook-error", messageOf(e), "RUN_FAILED");
+			throw e;
+		}
+	}
+	/**
+	* 流式 LLM 调用：text-delta 仅在 EventBus 有订阅者时发射 llm.delta 事件，
+	* 并同步转发 uiBridge.onTextDelta；tool-calls/done 组装为 LlmResponse 走原有分支。
+	*/
+	async #completeStreaming(llm, state, input) {
+		const emitDelta = (delta) => {
+			const bus = this.#deps.eventBus;
+			if (bus && bus.listenerCount() > 0) bus.emit({
+				phase: "execute",
+				runId: state.runId,
+				sessionId: state.run.sessionId,
+				ts: state.now(),
+				data: {
+					type: "llm.delta",
+					delta
+				}
+			});
+			this.#deps.uiBridge?.onTextDelta?.(state.runId, delta);
+		};
+		let content = "";
+		let doneContent;
+		const toolCalls = [];
+		for await (const event of llm.stream(input)) if (event.type === "text-delta") {
+			content += event.delta;
+			emitDelta(event.delta);
+		} else if (event.type === "tool-calls") toolCalls.push(...event.toolCalls);
+		else if (event.type === "done") doneContent = event.content;
+		return {
+			content: doneContent ?? (content === "" ? void 0 : content),
+			toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+		};
+	}
+	/** 生命周期接线：更新 phase、发事件、跑钩子 */
+	async #lifecycle(phase, state, data) {
+		state.run.phase = phase;
+		const event = {
+			phase,
+			runId: state.runId,
+			sessionId: state.run.sessionId,
+			ts: state.now(),
+			...data ? { data } : {}
+		};
+		this.#deps.eventBus?.emit(event);
+		if (this.#deps.hooks) await this.#deps.hooks.run(phase, {
+			event,
+			run: state.run
+		});
+	}
+	/**
+	* 交互暂停/恢复（行内 await，不做可序列化快照，见 deferred-items D3）：
+	* interrupted → bridge.request（带超时）→ 合并结果恢复；
+	* 取消 → RunTerminated(cancelled)；超时 → RunTerminated(interaction-timeout)。
+	*/
+	async #interact(state, request, traceData) {
+		const bridge = this.#deps.uiBridge;
+		if (!bridge) throw new Error("interact() requires a UiBridge");
+		const { run } = state;
+		run.status = "interrupted";
+		run.interruptExpiresAt = new Date(Date.parse(state.now()) + this.#policy.interactionTimeoutMs).toISOString();
+		await this.#lifecycle("interact", state, {
+			interactionId: request.id,
+			type: request.type
+		});
+		state.trace.record("ui.requested", { data: {
+			interactionId: request.id,
+			type: request.type,
+			...traceData
+		} });
+		let response;
+		try {
+			response = await this.#withInteractionTimeout(bridge.request(request), this.#policy.interactionTimeoutMs);
+		} catch (e) {
+			run.status = "running";
+			run.interruptExpiresAt = void 0;
+			if (e instanceof WebSkillError && e.code === "RUN_INTERACTION_TIMEOUT") throw new RunTerminated({
+				status: "failed",
+				reason: "interaction-timeout",
+				message: e.message,
+				code: "RUN_INTERACTION_TIMEOUT"
+			});
+			state.trace.record("run.warning", { message: `UiBridge request failed: ${messageOf(e)}` });
+			throw new BridgeRequestError(messageOf(e));
+		}
+		if (response.cancelled) throw new RunTerminated({
+			status: "cancelled",
+			reason: "user-cancelled",
+			message: "Interaction cancelled by user",
+			code: "RUN_CANCELLED"
+		});
+		run.status = "running";
+		run.interruptExpiresAt = void 0;
+		state.trace.record("ui.resumed", { data: {
+			interactionId: request.id,
+			type: request.type
+		} });
+		await this.#lifecycle("execute", state, { resumed: request.id });
+		await this.#appendParamHistory(state, request, response.value);
+		return response.value;
+	}
+	#withInteractionTimeout(promise, timeoutMs) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => reject(new WebSkillError("RUN_INTERACTION_TIMEOUT", `Interaction timed out after ${timeoutMs}ms`)), timeoutMs);
+			promise.then((v) => {
+				clearTimeout(timer);
+				resolve(v);
+			}, (e) => {
+				clearTimeout(timer);
+				reject(e instanceof Error ? e : new Error(String(e)));
+			});
+		});
+	}
+	async #executeCall(call, state) {
+		state.trace.record("tool.started", { data: {
+			name: call.name,
+			callId: call.id
+		} });
+		let result;
+		if (call.name === "read_skill_file") result = await this.#handleReadSkillFile(call, state);
+		else if (call.name === "ask_user") result = await this.#handleAskUser(call, state);
+		else {
+			const resolution = resolveToolName(call.name, state.activated);
+			if (resolution.kind === "script") result = await this.#handleScriptTool(call, resolution.skillName, resolution.scriptName, state);
+			else {
+				const source = (this.#deps.externalTools ?? []).find((s) => s.canHandle(call.name));
+				result = source ? await source.call(call.name, call.arguments) : toolError(resolution.code, resolution.message);
+			}
+		}
+		if (result.ok) state.trace.record("tool.completed", { data: {
+			name: call.name,
+			callId: call.id
+		} });
+		else state.trace.record("tool.failed", {
+			message: result.error?.message,
+			data: {
+				name: call.name,
+				callId: call.id,
+				code: result.error?.code
+			}
+		});
+		for (const artifact of result.artifacts ?? []) state.trace.record("artifact.created", { data: {
+			artifactId: artifact.id,
+			path: artifact.path
+		} });
+		return result;
+	}
+	async #handleAskUser(call, state) {
+		const question = call.arguments["question"];
+		if (typeof question !== "string" || question === "") return toolError("TOOL_EXECUTION_FAILED", "ask_user requires a non-empty \"question\" string argument");
+		try {
+			const value = await this.#interact(state, {
+				type: "ask",
+				id: this.#nextInteractionId(state),
+				message: question
+			}, { tool: call.name });
+			return {
+				ok: true,
+				content: [{
+					type: "text",
+					text: typeof value === "string" ? value : JSON.stringify(value ?? "")
+				}]
+			};
+		} catch (e) {
+			if (e instanceof BridgeRequestError) return toolError("UI_UNAVAILABLE", `ask_user failed: ${e.message}`);
+			throw e;
+		}
+	}
+	async #handleReadSkillFile(call, state) {
+		const skillName = call.arguments["skillName"];
+		if (typeof skillName !== "string" || skillName === "") return toolError("TOOL_EXECUTION_FAILED", "read_skill_file requires a non-empty \"skillName\" string argument");
+		const pathArg = call.arguments["path"] ?? "SKILL.md";
+		if (typeof pathArg !== "string") return toolError("TOOL_EXECUTION_FAILED", "read_skill_file \"path\" must be a string");
+		if (skillName.startsWith("mcp://")) return this.#handleReadExternalSkill(skillName, pathArg, state);
+		try {
+			const text = await state.reader.readSkillFile(skillName, pathArg);
+			let note = "";
+			if (pathArg === "SKILL.md" && !state.activated.has(skillName)) note = await this.#activateSkill(skillName, state);
+			return {
+				ok: true,
+				content: [{
+					type: "text",
+					text: text + note
+				}]
+			};
+		} catch (e) {
+			if (e instanceof WebSkillError && e.code === "SKILL_NOT_FOUND" && (this.#deps.skillProviders?.length ?? 0) > 0) return this.#handleReadExternalSkill(skillName, pathArg, state);
+			return toolError(e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED", `read_skill_file failed: ${messageOf(e)}`);
+		}
+	}
+	/** 经外部技能提供者读取技能文档/资源；skillKey 为技能名或 mcp:// URI */
+	async #handleReadExternalSkill(skillKey, pathArg, state) {
+		for (const provider of this.#deps.skillProviders ?? []) try {
+			let name = skillKey;
+			if (skillKey.startsWith("mcp://")) {
+				const entry = (await provider.listSkills()).find((e) => e.root === skillKey);
+				if (!entry) continue;
+				name = entry.name;
+			}
+			if (pathArg === "SKILL.md") {
+				const doc = await provider.loadSkill(name);
+				if (!state.activated.has(name)) {
+					state.activated.add(name);
+					state.trace.record("skill.activated", { data: {
+						skillName: name,
+						source: "external"
+					} });
+					await this.#lifecycle("activate", state, { skillName: name });
+					await this.#writeActivationMemory(name, state);
+				}
+				return {
+					ok: true,
+					content: [{
+						type: "text",
+						text: doc.body
+					}]
+				};
+			}
+			if (provider.readFile) return {
+				ok: true,
+				content: [{
+					type: "text",
+					text: await provider.readFile(name, pathArg)
+				}]
+			};
+		} catch {
+			continue;
+		}
+		return toolError("SKILL_NOT_FOUND", `Skill not found via external providers: ${skillKey}`);
+	}
+	/** 首次读到 SKILL.md 时激活技能：加载其 scripts 工具定义，供后续轮次使用 */
+	async #activateSkill(skillName, state) {
+		state.activated.add(skillName);
+		state.trace.record("skill.activated", { data: { skillName } });
+		await this.#lifecycle("activate", state, { skillName });
+		await this.#writeActivationMemory(skillName, state);
+		const root = this.#deps.skillIndex.get(skillName);
+		if (!root) return "";
+		const loaded = [];
+		let scriptFiles = [];
+		try {
+			scriptFiles = (await this.#deps.fs.list(`${root}/scripts`)).filter((s) => s.type === "file").map((s) => baseName(s.path));
+		} catch {
+			return "";
+		}
+		for (const file of scriptFiles) {
+			const match = /^(.*)\.(ts|js)$/.exec(file);
+			if (!match?.[1]) continue;
+			try {
+				const def = await this.#deps.executor.loadDefinition(root, match[1]);
+				state.activatedTools.set(def.name, def);
+				loaded.push(def.name);
+			} catch {}
+		}
+		return loaded.length ? `\n\nActivated tools: ${loaded.join(", ")}` : "";
+	}
+	async #handleScriptTool(call, skillName, scriptName, state) {
+		const root = this.#deps.skillIndex.get(skillName);
+		if (!root) return toolError("TOOL_NOT_FOUND", `Skill "${skillName}" is not in the catalog`);
+		let args = call.arguments;
+		const def = state.activatedTools.get(call.name);
+		const missing = (def?.inputSchema?.required ?? []).filter((key) => args[key] === void 0);
+		if (missing.length > 0 && this.#deps.uiBridge && this.#policy.missingParams === "user" && def?.inputSchema) try {
+			const value = await this.#interact(state, {
+				type: "form",
+				id: this.#nextInteractionId(state),
+				title: `Missing parameters for ${call.name}`,
+				fields: schemaToForm(def.inputSchema, args)
+			}, {
+				tool: call.name,
+				missing
+			});
+			if (typeof value === "object" && value !== null) args = {
+				...args,
+				...value
+			};
+		} catch (e) {
+			if (e instanceof BridgeRequestError) return toolError("UI_UNAVAILABLE", `Parameter form failed: ${e.message}`);
+			throw e;
+		}
+		const context = createScriptContext({
+			fs: this.#deps.fs,
+			artifactStore: this.#deps.artifactStore,
+			skillName,
+			skillRoot: root,
+			runId: state.runId,
+			confirm: (message) => this.#confirm(message, state)
+		});
+		try {
+			const before = new Set((await this.#deps.artifactStore.listArtifacts(state.runId)).map((a) => a.id));
+			const result = await this.#deps.executor.execute({
+				skillRoot: root,
+				scriptName,
+				args,
+				context,
+				timeoutMs: state.toolTimeoutMs
+			});
+			const fresh = (await this.#deps.artifactStore.listArtifacts(state.runId)).filter((a) => !before.has(a.id));
+			if (fresh.length > 0) result.artifacts = [...result.artifacts ?? [], ...fresh];
+			await this.#bumpSkillStat(skillName, result.ok ? "successes" : "failures", state);
+			return result;
+		} catch (e) {
+			if (e instanceof RunTerminated) throw e;
+			await this.#bumpSkillStat(skillName, "failures", state);
+			return toolError(e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED", `Tool "${call.name}" failed: ${messageOf(e)}`);
+		}
+	}
+	/** context.confirm 触发点：默认真实询问；auto-approve 直通；无 bridge 降级直通 + warning */
+	async #confirm(message, state) {
+		if (this.#policy.confirmations === "auto-approve") return true;
+		if (!this.#deps.uiBridge) {
+			state.trace.record("run.warning", { message: "No UiBridge configured; confirm() auto-approved" });
+			return true;
+		}
+		try {
+			return await this.#interact(state, {
+				type: "confirm",
+				id: this.#nextInteractionId(state),
+				message,
+				defaultValue: true
+			}, { kind: "confirm" }) !== false;
+		} catch (e) {
+			if (e instanceof BridgeRequestError) {
+				state.trace.record("run.warning", { message: `confirm() bridge failed, auto-approved: ${e.message}` });
+				return true;
+			}
+			throw e;
+		}
+	}
+	#nextInteractionId(state) {
+		return `int-${++state.interactionSeq}`;
+	}
+	async #memoryGet(scope, key) {
+		try {
+			return await this.#deps.memory?.get(scope, key);
+		} catch {
+			return;
+		}
+	}
+	async #memorySet(scope, key, value, state) {
+		try {
+			await this.#deps.memory?.set(scope, key, value);
+		} catch (e) {
+			state.trace.record("run.warning", { message: `Memory write failed: ${messageOf(e)}` });
+		}
+	}
+	async #writeActivationMemory(skillName, state) {
+		if (!this.#deps.memory) return;
+		const sessionScope = `session:${state.run.sessionId}`;
+		await this.#memorySet(sessionScope, "activeSkillNames", [...state.activated].sort(), state);
+		await this.#bumpSkillStat(skillName, "activations", state);
+		if (this.#deps.longTerm?.enabled) {
+			const userScope = `user:${this.#deps.longTerm.userId}`;
+			const usage = await this.#memoryGet(userScope, "skillUsage") ?? {};
+			usage[skillName] = (usage[skillName] ?? 0) + 1;
+			await this.#memorySet(userScope, "skillUsage", usage, state);
+		}
+	}
+	async #bumpSkillStat(skillName, field, state) {
+		if (!this.#deps.memory) return;
+		const scope = `skill:${skillName}`;
+		const stats = await this.#memoryGet(scope, "stats") ?? {
+			activations: 0,
+			successes: 0,
+			failures: 0
+		};
+		stats[field] = (stats[field] ?? 0) + 1;
+		await this.#memorySet(scope, "stats", stats, state);
+	}
+	async #appendParamHistory(state, request, value) {
+		if (!this.#deps.memory) return;
+		const scope = `session:${state.run.sessionId}`;
+		const history = await this.#memoryGet(scope, "paramHistory") ?? [];
+		history.push({
+			ts: state.now(),
+			interactionId: request.id,
+			type: request.type,
+			value
+		});
+		await this.#memorySet(scope, "paramHistory", history, state);
+	}
+};
+/**
+* Catalog 合并：同名本地优先；外部条目的 mcp:// 根 URI 保留，
+* 调用方可凭 URI 强制选择外部技能（绕过本地优先）。
+*/
+function mergeCatalogEntries(localEntries, providerEntries) {
+	const byName = new Map(localEntries.map((e) => [e.name, e]));
+	for (const entry of providerEntries) if (!byName.has(entry.name)) byName.set(entry.name, entry);
+	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+/** runtime 门面：组合 discovery / router / agent loop / lifecycle */
+var WebSkillRuntime = class {
+	#deps;
+	#discovery;
+	#router;
+	#session;
+	#events;
+	#catalogCache;
+	constructor(deps) {
+		this.#deps = deps;
+		this.#discovery = new SkillDiscovery(deps.fs, deps.roots);
+		this.#router = deps.router ?? new ProgressiveRouter();
+		this.#events = deps.eventBus ?? new EventBus();
+		this.#session = {
+			id: `session-${Math.random().toString(36).slice(2, 10)}`,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	get session() {
+		return this.#session;
+	}
+	/** 生命周期事件总线（只读观测） */
+	get events() {
+		return this.#events;
+	}
+	async discover() {
+		const result = await this.#discovery.discover();
+		this.#catalogCache = {
+			catalog: buildCatalog(result.entries),
+			index: new Map(result.entries.map((e) => [e.name, e.root]))
+		};
+		return result;
+	}
+	async run(userPrompt) {
+		if (!this.#catalogCache) await this.discover();
+		const cache = this.#catalogCache;
+		if (!cache) throw new Error("discover() did not populate the catalog cache");
+		const providerEntries = (await Promise.all((this.#deps.skillProviders ?? []).map(async (p) => {
+			try {
+				return await p.listSkills();
+			} catch {
+				return [];
+			}
+		}))).flat();
+		const catalog = providerEntries.length > 0 ? { skills: mergeCatalogEntries(cache.catalog.skills, providerEntries) } : cache.catalog;
+		const filteredCatalog = this.#deps.catalogFilter ? { skills: await this.#deps.catalogFilter(catalog.skills) } : catalog;
+		const route = await this.#router.route(filteredCatalog);
+		const result = await new AgentLoop({
+			llm: this.#deps.llm,
+			executor: this.#deps.executor,
+			artifactStore: this.#deps.artifactStore,
+			fs: this.#deps.fs,
+			skillIndex: cache.index,
+			model: this.#deps.model,
+			uiBridge: this.#deps.uiBridge,
+			interaction: this.#deps.interaction,
+			memory: this.#deps.memory,
+			hooks: this.#deps.hooks,
+			eventBus: this.#events,
+			longTerm: this.#deps.longTerm,
+			externalTools: this.#deps.externalTools,
+			skillProviders: this.#deps.skillProviders,
+			catalogFilter: this.#deps.catalogFilter
+		}, this.#deps.config).run({
+			sessionId: this.#session.id,
+			userPrompt,
+			route
+		});
+		if (this.#deps.onSkillMiss && result.run.activeSkillNames.length === 0) this.#deps.onSkillMiss({
+			prompt: userPrompt,
+			run: result.run
+		}).catch((e) => {
+			result.run.trace.push({
+				id: `evt-miss-${Date.now()}`,
+				runId: result.run.id,
+				ts: (/* @__PURE__ */ new Date()).toISOString(),
+				type: "run.warning",
+				message: `onSkillMiss hook failed: ${e instanceof Error ? e.message : String(e)}`
+			});
+		});
+		return result;
+	}
+};
+
+//#endregion
+export { schemaToForm as A, checkSkillRules as B, createScriptContext as C, normalizeToolContent as D, mergeCatalogEntries as E, SKILL_NAME_PATTERN as F, parseSkillMarkdown as G, isValidSkillName as H, SkillDiscovery as I, resolveInsideRoot as J, renderAvailableSkillsXml as K, SkillReader as L, toVercelToolSpecs as M, MemoryFS as N, parseBridgeRequest as O, SKILL_NAME_MAX_LENGTH as P, WebSkillError as R, buildRenderResult as S, fromVercelStreamPart as T, jsonRenderer as U, escapeXml as V, normalizePath as W, xmlRenderer as X, validateSkills as Y, READ_SKILL_FILE_TOOL as _, EventBus as a, WebSkillRuntime as b, FullDisclosureRouter as c, MemoryArtifactStore as d, MockLlmClient as f, READ_SKILL_FILE_INPUT_SCHEMA as g, ProgressiveRouter as h, AgentLoop as i, toLlmToolSpec as j, resolveToolName as k, HookRunner as l, OpenAiCompatibleClient as m, ASK_USER_TOOL as n, FsArtifactStore as o, MockUiBridge as p, renderCatalogJson as q, ASK_USER_TOOL_NAME as r, FsMemoryStore as s, ASK_USER_INPUT_SCHEMA as t, InMemoryStore as u, READ_SKILL_FILE_TOOL_NAME as v, fromVercelResult as w, bridgeError as x, TraceRecorder as y, buildCatalog as z };