@webskill/sdk 0.14.0 → 0.15.0

package/dist/llm-B7lLH0ZI.js

@@ -0,0 +1,1767 @@
+import { t as WebSkillError } from "./errors-BDZNpC13.js";
+
+//#region ../runtime/src/llm/parts.ts
+/** 纯文本消息内容的构造快捷方式（引擎内部绝大多数消息仍是纯文本） */
+const textParts = (text) => [{
+	type: "text",
+	text
+}];
+/** 取出 parts 中的文本（非文本分片在纯文本语境下无法表达，此处按丢弃处理——调用方须先校验） */
+const partsToText = (parts) => (parts ?? []).reduce((acc, part) => part.type === "text" ? acc + part.text : acc, "");
+/**
+* run 的提示词文本投影：`RuntimeRun.userPrompt` 与快照都是字符串字段，
+* 而多模态提示词里的图片/文件分片没有文本形态，用占位符标注，避免记录成空串。
+*/
+const promptText = (prompt) => {
+	if (typeof prompt === "string") return prompt;
+	return prompt.map((part) => part.type === "text" ? part.text : `[${part.type}: ${part.mimeType}]`).join("\n");
+};
+const isContentPart = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const part = value;
+	if (part["type"] === "text") return typeof part["text"] === "string";
+	if (part["type"] === "image" || part["type"] === "file") return typeof part["mimeType"] === "string" && typeof part["data"] === "string";
+	return false;
+};
+/**
+* 0.4.0 起 `content` 是 parts 数组。旧的 `string` content 一律拒绝，不做静默转换：
+* 转换会让「模型看到的输入」与「历史记录的输入」悄悄分叉。
+*/
+function validateLlmMessages(messages) {
+	messages.forEach((message, index) => {
+		if (typeof message.content === "string") throw new WebSkillError("VALIDATION_FAILED", `messages[${index}].content is a string; since schema version 2 it must be an array of content parts. Legacy data is not converted automatically.`);
+		if (!Array.isArray(message.content) || !message.content.every(isContentPart)) throw new WebSkillError("VALIDATION_FAILED", `messages[${index}].content is not a valid array of content parts`);
+	});
+}
+/** provider 不支持某类分片时的统一拒绝：静默丢弃会让模型回答一个它没看见的附件 */
+function rejectUnsupportedPart(part, provider, where) {
+	throw new WebSkillError("VALIDATION_FAILED", `${provider} does not support ${part.type} content in ${where} messages`);
+}
+
+//#endregion
+//#region ../runtime/src/llm/sealToolCallPairs.ts
+/** 与正常工具结果同构：模型读到的是「这次调用被中断了」，而不是一个凭空消失的调用 */
+function interruptedToolResult(call, options = {}) {
+	const code = options.code ?? "RUN_INTERRUPTED";
+	const because = options.reason === void 0 ? "" : ` (${options.reason})`;
+	return {
+		ok: false,
+		content: [],
+		error: {
+			code,
+			message: `Tool call "${call.name}" produced no result: the run ended before it finished${because}.`
+		}
+	};
+}
+/** 尚无 `role:'tool'` 应答的工具调用，按消息顺序 */
+function findUnpairedToolCalls(messages) {
+	const answered = new Set(messages.filter((m) => m.role === "tool").map((m) => m.toolCallId));
+	return messages.filter((m) => m.role === "assistant" && m.toolCalls?.length).flatMap((m) => m.toolCalls ?? []).filter((call) => !answered.has(call.id));
+}
+/**
+* 为每个未应答的工具调用补一条结构化的中断说明。
+*
+* 补齐消息紧跟在该 assistant 已有的 tool 兄弟之后——供应商装配按相邻块分组，
+* 插到序列末尾会让它归属到别的 assistant 消息上。
+* 本函数**不改写入参**，也不写盘（AC-11.8）。
+*/
+function sealToolCallPairs(messages, options = {}) {
+	const answered = new Set(messages.filter((m) => m.role === "tool").map((m) => m.toolCallId));
+	const code = options.code ?? "RUN_INTERRUPTED";
+	const sealed = [];
+	const out = [];
+	for (let i = 0; i < messages.length; i += 1) {
+		const message = messages[i];
+		out.push(message);
+		if (message.role !== "assistant" || !message.toolCalls?.length) continue;
+		const missing = message.toolCalls.filter((call) => !answered.has(call.id));
+		if (missing.length === 0) continue;
+		while (i + 1 < messages.length && messages[i + 1].role === "tool") {
+			out.push(messages[i + 1]);
+			i += 1;
+		}
+		for (const call of missing) {
+			out.push({
+				role: "tool",
+				toolCallId: call.id,
+				content: textParts(JSON.stringify(interruptedToolResult(call, {
+					...options,
+					code
+				})))
+			});
+			answered.add(call.id);
+			sealed.push({
+				callId: call.id,
+				toolName: call.name,
+				code
+			});
+		}
+	}
+	return {
+		messages: sealed.length === 0 ? [...messages] : out,
+		sealed
+	};
+}
+
+//#endregion
+//#region ../runtime/src/llm/portableSchema.ts
+/**
+* 自引用展开时允许的最大 **schema 节点** 嵌套深度（properties/$defs 这类容器映射本身不计一层）。
+* 超出即抛错而非静默截断：静默截断会让模型收到残缺 schema 后产出无法校验的参数，
+* 症状比直接失败更难查。
+*/
+const PORTABLE_SCHEMA_MAX_DEPTH = 8;
+/**
+* $defs 必须与 type / properties 同级，位于每个工具 inputSchema 的根。
+* 已验证：放进 properties.spec 内层会得到同样的 "Unsupported ref: #" ——
+* Qwen / LM Studio 按当前 schema 上下文解析 $defs，不回溯根文档。
+* 因此本模块只在**根**写入 $defs，不得改成就近放置。
+*/
+const DEFS_KEY = "$defs";
+const SELF_REF = "#";
+const NODE_NAME = "Node";
+const COMPONENT_PREFIX = "Component_";
+/** 值为「名称 → 子 schema」的映射。包内导出：vendorSchema 要用同一套下钻规则（两套会漂移）。 */
+const SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
+	"properties",
+	"patternProperties",
+	"dependentSchemas",
+	"$defs",
+	"definitions"
+]);
+/** 值为「子 schema 数组」。 */
+const SCHEMA_LIST_KEYS = /* @__PURE__ */ new Set([
+	"oneOf",
+	"anyOf",
+	"allOf",
+	"prefixItems"
+]);
+/** 值为单个子 schema（items 在 draft-07 遗留写法里也可能是数组）。 */
+const SCHEMA_KEYS = /* @__PURE__ */ new Set([
+	"items",
+	"additionalItems",
+	"additionalProperties",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"contains",
+	"propertyNames",
+	"not",
+	"if",
+	"then",
+	"else"
+]);
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSelfRef(value) {
+	return isRecord$2(value) && value["$ref"] === SELF_REF;
+}
+/**
+* 按 JSON Schema 关键字下降到子 schema。
+* 只走 schema 位置，`enum` / `const` / `default` 等数据位置一律不进——
+* 那里出现的 `{ $ref: '#' }` 是字面数据而非引用，改写它会破坏语义。
+*/
+function forEachSubSchema(node, visit) {
+	for (const [key, value] of Object.entries(node)) {
+		if (SCHEMA_MAP_KEYS.has(key)) {
+			if (isRecord$2(value)) for (const name of Object.keys(value)) visit(value[name], [key, name]);
+			continue;
+		}
+		if (SCHEMA_LIST_KEYS.has(key)) {
+			if (Array.isArray(value)) value.forEach((item, index) => visit(item, [key, index]));
+			continue;
+		}
+		if (SCHEMA_KEYS.has(key)) if (Array.isArray(value)) value.forEach((item, index) => visit(item, [key, index]));
+		else visit(value, [key]);
+	}
+}
+function pathKey(path) {
+	return path.join("\0");
+}
+/**
+* 找出所有 `$ref: '#'` 所属的 schema resource 根。
+* `#` 解析到最近的带 `$id` 的祖先；没有则是文档根。
+*/
+function collectSelfRefRoots(node, path, resourceRoot, out) {
+	if (!isRecord$2(node)) return;
+	if (isSelfRef(node)) {
+		out.set(pathKey(resourceRoot), resourceRoot);
+		return;
+	}
+	const nextRoot = typeof node["$id"] === "string" && path.length > 0 ? path : resourceRoot;
+	forEachSubSchema(node, (child, childPath) => {
+		collectSelfRefRoots(child, [...path, ...childPath], nextRoot, out);
+	});
+}
+function getAt(schema, path) {
+	let current = schema;
+	for (const segment of path) if (Array.isArray(current) && typeof segment === "number") current = current[segment];
+	else if (isRecord$2(current) && typeof segment === "string") current = current[segment];
+	else return void 0;
+	return current;
+}
+/** 返回把 `path` 处替换为 `replacement` 后的新对象；沿途节点浅拷贝，其余共享。 */
+function setAt(schema, path, replacement) {
+	if (path.length === 0) return replacement;
+	const [head, ...rest] = path;
+	const child = getAt(schema, [head]);
+	const nextChild = rest.length === 0 ? replacement : setAt(child, rest, replacement);
+	if (Array.isArray(schema) && typeof head === "number") {
+		const copy = [...schema];
+		copy[head] = nextChild;
+		return copy;
+	}
+	return {
+		...schema,
+		[head]: nextChild
+	};
+}
+/**
+* 深拷贝并把 `{ $ref: '#' }` 改写为指向根 `$defs` 中的具名节点。
+* 同时剥掉非根位置的 `$id` / `$schema`：它们会重设 base URI，
+* 正是严格解析器无法解析 `#` 的直接原因。
+*/
+function rewriteSelfRefs(node, target, depth) {
+	if (!isRecord$2(node)) return node;
+	if (depth > 8) throw new WebSkillError("TOOL_SCHEMA_UNAVAILABLE", `Tool schema nesting exceeds ${8} levels; cannot produce a portable form`);
+	if (isSelfRef(node)) {
+		const rest = {};
+		for (const [key, value] of Object.entries(node)) if (key !== "$ref") rest[key] = value;
+		return {
+			$ref: `#/${DEFS_KEY}/${target}`,
+			...rest
+		};
+	}
+	const result = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "$id" || key === "$schema") continue;
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord$2(value)) {
+			const mapped = {};
+			for (const [name, child] of Object.entries(value)) mapped[name] = rewriteSelfRefs(child, target, depth + 1);
+			result[key] = mapped;
+			continue;
+		}
+		if (SCHEMA_LIST_KEYS.has(key) || SCHEMA_KEYS.has(key)) {
+			result[key] = Array.isArray(value) ? value.map((child) => rewriteSelfRefs(child, target, depth + 1)) : rewriteSelfRefs(value, target, depth + 1);
+			continue;
+		}
+		result[key] = value;
+	}
+	return result;
+}
+function uniqueName(base, taken) {
+	if (!taken.has(base)) return base;
+	const prefixed = `Portable${base}`;
+	if (!taken.has(prefixed)) return prefixed;
+	let index = 2;
+	while (taken.has(`${prefixed}_${index}`)) index += 1;
+	return `${prefixed}_${index}`;
+}
+function renameDefRefs(node, renames) {
+	if (Array.isArray(node)) return node.map((child) => renameDefRefs(child, renames));
+	if (!isRecord$2(node)) return node;
+	const out = {};
+	const prefix = `#/${DEFS_KEY}/`;
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "$ref" && typeof value === "string" && value.startsWith(prefix)) {
+			const [head, ...tail] = value.slice(prefix.length).split("/");
+			const mapped = head === void 0 ? void 0 : renames.get(head);
+			out[key] = mapped === void 0 ? value : [`${prefix}${mapped}`, ...tail].join("/");
+			continue;
+		}
+		out[key] = renameDefRefs(value, renames);
+	}
+	return out;
+}
+/**
+* 把非根位置的 `$defs` 搬到根。zod 每次 `toJSONSchema()` 各自产出 `$defs.__schemaN`，
+* 嵌进大 schema 后其 `#/$defs/...` 从大根解析不到——提升即修复。重名时避让并改写引用。
+*/
+function hoistNestedDefs(schema) {
+	const rootDefs = isRecord$2(schema[DEFS_KEY]) ? { ...schema[DEFS_KEY] } : {};
+	const taken = new Set(Object.keys(rootDefs));
+	let hoisted = false;
+	function visit(node, isRoot) {
+		if (Array.isArray(node)) return node.map((child) => visit(child, false));
+		if (!isRecord$2(node)) return node;
+		const nested = !isRoot && isRecord$2(node[DEFS_KEY]) ? node[DEFS_KEY] : void 0;
+		const body = {};
+		for (const [key, value] of Object.entries(node)) {
+			if (key === DEFS_KEY && nested !== void 0) continue;
+			if (key === DEFS_KEY) {
+				body[key] = value;
+				continue;
+			}
+			if (SCHEMA_MAP_KEYS.has(key) && isRecord$2(value)) {
+				const mapped = {};
+				for (const [name, child] of Object.entries(value)) mapped[name] = visit(child, false);
+				body[key] = mapped;
+				continue;
+			}
+			if (SCHEMA_LIST_KEYS.has(key) && Array.isArray(value)) {
+				body[key] = value.map((child) => visit(child, false));
+				continue;
+			}
+			if (SCHEMA_KEYS.has(key)) {
+				body[key] = visit(value, false);
+				continue;
+			}
+			body[key] = value;
+		}
+		if (nested === void 0) return body;
+		hoisted = true;
+		const renames = /* @__PURE__ */ new Map();
+		for (const name of Object.keys(nested)) {
+			const target = uniqueName(name, taken);
+			taken.add(target);
+			if (target !== name) renames.set(name, target);
+		}
+		for (const [name, def] of Object.entries(nested)) {
+			const moved = visit(def, false);
+			rootDefs[renames.get(name) ?? name] = renames.size > 0 ? renameDefRefs(moved, renames) : moved;
+		}
+		return renames.size > 0 ? renameDefRefs(body, renames) : body;
+	}
+	const out = visit(schema, true);
+	return hoisted ? {
+		...out,
+		[DEFS_KEY]: rootDefs
+	} : schema;
+}
+/**
+* 把工具 inputSchema 重写为严格解析器可接受的 JSON Schema 2020-12 形态：
+* 非根 `$defs` 提到根，自引用的 schema resource 提到根 `$defs`，
+* 所有 `$ref: '#'` 改写为 `$ref: '#/$defs/<Node>'`。
+*
+* 幂等：不含自引用也不含嵌套 `$defs` 的 schema 原样返回。
+*
+* 这是**传输层适配**，只应在出站请求体上调用；不要下沉到 AgentLoop，
+* 否则 trace / eventBus 观测到的 schema 会与技能作者写的不一致。
+*/
+function toPortableToolSchema(input) {
+	const schema = hoistNestedDefs(input);
+	const roots = /* @__PURE__ */ new Map();
+	collectSelfRefRoots(schema, [], [], roots);
+	if (roots.size === 0) return schema;
+	if (roots.size > 1) throw new WebSkillError("TOOL_SCHEMA_UNAVAILABLE", "Tool schema contains self references in more than one schema resource; cannot produce a portable form");
+	const rootPath = [...roots.values()][0] ?? [];
+	const resource = getAt(schema, rootPath);
+	if (!isRecord$2(resource)) return schema;
+	const existingDefs = isRecord$2(schema[DEFS_KEY]) ? schema[DEFS_KEY] : void 0;
+	const taken = new Set(Object.keys(existingDefs ?? {}));
+	const nodeName = uniqueName(NODE_NAME, taken);
+	taken.add(nodeName);
+	const added = {};
+	const branches = resource["oneOf"];
+	if (Array.isArray(branches)) {
+		const refs = branches.map((branch, index) => {
+			const name = uniqueName(`${COMPONENT_PREFIX}${index}`, taken);
+			taken.add(name);
+			added[name] = rewriteSelfRefs(branch, nodeName, 1);
+			return { $ref: `#/${DEFS_KEY}/${name}` };
+		});
+		const description = resource["description"];
+		added[nodeName] = typeof description === "string" ? {
+			description,
+			oneOf: refs
+		} : { oneOf: refs };
+	} else {
+		const body = {};
+		for (const [key, value] of Object.entries(resource)) if (key !== DEFS_KEY) body[key] = value;
+		added[nodeName] = rewriteSelfRefs(body, nodeName, 1);
+	}
+	return {
+		...setAt(schema, rootPath, { $ref: `#/${DEFS_KEY}/${nodeName}` }),
+		[DEFS_KEY]: {
+			...existingDefs ?? {},
+			...added
+		}
+	};
+}
+
+//#endregion
+//#region ../runtime/src/llm/modelUnfillableParams.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* 与 `interaction/schemaToForm` 的 file 判定保持一致：JSON Schema 里二进制内容的
+* 两种标准写法（`format: binary` / `contentEncoding: base64`）。
+*/
+function isModelUnfillable(node) {
+	return isRecord$1(node) && node["type"] === "string" && (node["format"] === "binary" || node["contentEncoding"] === "base64");
+}
+function stripNode(node) {
+	if (Array.isArray(node)) return node.map(stripNode);
+	if (!isRecord$1(node)) return node;
+	const out = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord$1(value)) {
+			const mapped = {};
+			for (const [name, child] of Object.entries(value)) {
+				if (key === "properties" && isModelUnfillable(child)) continue;
+				mapped[name] = stripNode(child);
+			}
+			out[key] = mapped;
+			continue;
+		}
+		if (SCHEMA_LIST_KEYS.has(key) && Array.isArray(value)) {
+			out[key] = value.map(stripNode);
+			continue;
+		}
+		if (SCHEMA_KEYS.has(key)) {
+			out[key] = stripNode(value);
+			continue;
+		}
+		out[key] = value;
+	}
+	const required = out["required"];
+	const properties = out["properties"];
+	if (Array.isArray(required) && isRecord$1(properties)) out["required"] = required.filter((name) => typeof name !== "string" || name in properties);
+	return out;
+}
+/**
+* 把模型不可能自己产出的字段（本地文件二进制）从**出站**工具 schema 里剥离。
+*
+* 模型拿不到用户磁盘上的文件，留着这个字段只有两种下场：模型拒绝调用工具
+* （实测 DeepSeek 直接回文本「请上传文件」，file-pick 永远触发不了），或编造一个
+* 占位字符串把技能跑挂。剥掉后模型以缺参形式调用，引擎的 missing-params 链路
+* 会弹 file-pick 让用户用系统文件选择器补这个字段。
+*
+* 这是**传输层适配**，只应在出站请求体上调用；不要下沉到 AgentLoop——
+* 引擎侧的 missing 校验看的必须是技能作者写的完整 inputSchema。
+*
+* 已知边界（0.10.0 复核注记）：只剥 `properties` 里的 inline 二进制字段；
+* 通过 `$ref` 指向 `$defs` 中二进制定义的字段仍会下发（剥掉会留悬空 $ref），
+* 这类技能依旧可能拿不到 file-pick——需要完整修复时再补「剥 $def + 剥指向它的 $ref」。
+*/
+function stripModelUnfillableParams(schema) {
+	return stripNode(schema);
+}
+
+//#endregion
+//#region ../runtime/src/llm/vendorSchema.ts
+/** 各家都认的基础关键字。Google `FunctionDeclaration.parameters` 是其中最窄的一家。 */
+const BASE_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"description",
+	"title",
+	"default",
+	"enum",
+	"const",
+	"properties",
+	"required",
+	"items",
+	"anyOf",
+	"oneOf",
+	"minimum",
+	"maximum",
+	"minItems",
+	"maxItems",
+	"nullable",
+	"format"
+]);
+/** 宽松侧：保留 0.6.0 的透传行为，本版不主动收紧（没有实证之前收紧只会制造新的破坏） */
+const PERMISSIVE_KEYWORDS = /* @__PURE__ */ new Set([
+	...BASE_KEYWORDS,
+	"additionalProperties",
+	"patternProperties",
+	"dependentSchemas",
+	"definitions",
+	"$defs",
+	"$ref",
+	"$schema",
+	"$id",
+	"allOf",
+	"not",
+	"if",
+	"then",
+	"else",
+	"prefixItems",
+	"additionalItems",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"contains",
+	"propertyNames",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"minLength",
+	"maxLength",
+	"pattern",
+	"uniqueItems",
+	"examples",
+	"readOnly",
+	"writeOnly",
+	"deprecated"
+]);
+const OPENAI_SCHEMA_PROFILE = {
+	id: "openai-compatible",
+	allowedKeywords: PERMISSIVE_KEYWORDS,
+	supportsRefs: true
+};
+const ANTHROPIC_SCHEMA_PROFILE = {
+	id: "anthropic",
+	allowedKeywords: PERMISSIVE_KEYWORDS,
+	supportsRefs: true
+};
+/**
+* Google Gen AI 的 `FunctionDeclaration.parameters` 收到 `additionalProperties`
+* 直接回 400 `Unknown name "additionalProperties"`，且不解析 `$ref` / `$defs`。
+*
+* 本 profile 描述的是 **`parameters` 这一字段**的能力，不是 Google 的能力上限：
+* 完整 JSON Schema（含 `$ref` / `$defs`）走另一个字段 `parametersJsonSchema`。
+* 把 `supportsRefs: false` 读成「Google 不支持引用」是错的，分流见 `googleGenAiClient.toGenAiTools`。
+*/
+const GOOGLE_SCHEMA_PROFILE = {
+	id: "google",
+	allowedKeywords: BASE_KEYWORDS,
+	supportsRefs: false
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** 只在 schema 位置上找 `$ref`：enum / const / default 里的同名键是字面数据，不是引用 */
+function containsRef(node) {
+	if (Array.isArray(node)) return node.some(containsRef);
+	if (!isRecord(node)) return false;
+	if (typeof node["$ref"] === "string") return true;
+	for (const [key, value] of Object.entries(node)) {
+		if (SCHEMA_MAP_KEYS.has(key)) {
+			if (isRecord(value) && Object.values(value).some(containsRef)) return true;
+			continue;
+		}
+		if (SCHEMA_LIST_KEYS.has(key)) {
+			if (Array.isArray(value) && value.some(containsRef)) return true;
+			continue;
+		}
+		if (SCHEMA_KEYS.has(key) && containsRef(value)) return true;
+	}
+	return false;
+}
+function sanitizeNode(node, profile) {
+	if (Array.isArray(node)) return node.map((item) => sanitizeNode(item, profile));
+	if (!isRecord(node)) return node;
+	const out = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (!profile.allowedKeywords.has(key)) continue;
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
+			const mapped = {};
+			for (const [name, child] of Object.entries(value)) mapped[name] = sanitizeNode(child, profile);
+			out[key] = mapped;
+			continue;
+		}
+		if (SCHEMA_LIST_KEYS.has(key) && Array.isArray(value)) {
+			out[key] = value.map((child) => sanitizeNode(child, profile));
+			continue;
+		}
+		if (SCHEMA_KEYS.has(key)) {
+			out[key] = sanitizeNode(value, profile);
+			continue;
+		}
+		out[key] = value;
+	}
+	return out;
+}
+/**
+* 按供应商 profile 清洗出站 schema。产出新对象，不修改入参（工具源可能复用同一个实例）。
+*
+* 这是**传输层适配**，只应在出站请求体上调用；不要下沉到 AgentLoop，
+* 否则 trace / eventBus 观测到的 schema 会与技能作者写的不一致。
+*
+* @throws WebSkillError `TOOL_SCHEMA_UNAVAILABLE` — schema 依赖该供应商不支持的引用
+*/
+function sanitizeForVendor(schema, profile, toolName) {
+	if (!profile.supportsRefs && containsRef(schema)) throw new WebSkillError("TOOL_SCHEMA_UNAVAILABLE", `Tool "${toolName}" requires $ref support that provider "${profile.id}" does not accept`);
+	return sanitizeNode(schema, profile);
+}
+/**
+* schema 能否走 profile 描述的受限通道。与 `sanitizeForVendor` 同判据，但不抛错——
+* 调用方需要的是「选哪条通道」而不是「失败」。
+*/
+function isExpressibleForVendor(schema, profile) {
+	return profile.supportsRefs || !containsRef(schema);
+}
+/**
+* 放宽不可终止的递归环：Gemini 只接受「可选 / 可为 null / 可零长数组」的引用环。
+* 对 `items` 直接是 `$ref` 的数组节点删去 `minItems`。
+*
+* **只作用于出站副本**：catalog 本体的校验判据不变。
+*/
+function relaxRefLoops(schema) {
+	return relaxNode(schema);
+}
+function relaxNode(node) {
+	if (Array.isArray(node)) return node.map(relaxNode);
+	if (!isRecord(node)) return node;
+	const out = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "minItems" && isRecord(node["items"]) && typeof node["items"]["$ref"] === "string") continue;
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
+			const mapped = {};
+			for (const [name, child] of Object.entries(value)) mapped[name] = relaxNode(child);
+			out[key] = mapped;
+			continue;
+		}
+		if (SCHEMA_LIST_KEYS.has(key) && Array.isArray(value)) {
+			out[key] = value.map(relaxNode);
+			continue;
+		}
+		if (SCHEMA_KEYS.has(key)) {
+			out[key] = relaxNode(value);
+			continue;
+		}
+		out[key] = value;
+	}
+	return out;
+}
+
+//#endregion
+//#region ../runtime/src/llm/sse.ts
+function createSseFrameReader() {
+	let buffer = "";
+	let data = [];
+	const dispatch = (out) => {
+		if (data.length === 0) return;
+		out.push(data.join("\n"));
+		data = [];
+	};
+	const consumeLine = (line, out) => {
+		if (line === "") {
+			dispatch(out);
+			return;
+		}
+		if (line.startsWith(":")) return;
+		const colon = line.indexOf(":");
+		if (colon < 0) return;
+		if (line.slice(0, colon) !== "data") return;
+		const value = line.slice(colon + 1);
+		data.push(value.startsWith(" ") ? value.slice(1) : value);
+	};
+	return {
+		push(chunk) {
+			const out = [];
+			buffer += chunk;
+			buffer = buffer.replace(/\r\n/g, "\n");
+			let newline;
+			while ((newline = buffer.indexOf("\n")) >= 0) {
+				const line = buffer.slice(0, newline);
+				buffer = buffer.slice(newline + 1);
+				consumeLine(line, out);
+			}
+			return out;
+		},
+		flush() {
+			const out = [];
+			if (buffer !== "") {
+				const line = buffer;
+				buffer = "";
+				consumeLine(line, out);
+			}
+			dispatch(out);
+			return out;
+		}
+	};
+}
+
+//#endregion
+//#region ../runtime/src/llm/thinkTags.ts
+/**
+* 内联 `<think>` 段落切分器（内部模块，不进公开导出）。
+*
+* 本地部署的思考型模型（Qwen 等经 OpenAI 兼容端点）不下发 `reasoning_content`，
+* 而是把推理直接写进 `content`，用 `<think>` … `</think>` 包起来。不切分的话
+* 思考正文会当成回答正文流进界面、进消息历史、进落盘，既污染上下文也没法折叠。
+*/
+const OPEN = "<think>";
+const CLOSE = "</think>";
+/** buffer 是否为 tag 的真前缀（还不能判定，得再等） */
+const isPartialPrefix = (buffer, tag) => buffer.length < tag.length && tag.startsWith(buffer);
+function createThinkTagSplitter() {
+	let buffer = "";
+	let inThink = false;
+	const consume = () => {
+		let text = "";
+		let thinking = "";
+		for (;;) {
+			const tag = inThink ? CLOSE : OPEN;
+			const hit = buffer.indexOf(tag);
+			if (hit >= 0) {
+				const before = buffer.slice(0, hit);
+				if (inThink) thinking += before;
+				else text += before;
+				buffer = buffer.slice(hit + tag.length);
+				inThink = !inThink;
+				continue;
+			}
+			const start = buffer.lastIndexOf("<");
+			const keep = start >= 0 && isPartialPrefix(buffer.slice(start), tag) ? start : buffer.length;
+			const emit = buffer.slice(0, keep);
+			if (inThink) thinking += emit;
+			else text += emit;
+			buffer = buffer.slice(keep);
+			return {
+				text,
+				thinking
+			};
+		}
+	};
+	return {
+		push(delta) {
+			buffer += delta;
+			return consume();
+		},
+		flush() {
+			const rest = buffer;
+			buffer = "";
+			return inThink ? {
+				text: "",
+				thinking: rest
+			} : {
+				text: rest,
+				thinking: ""
+			};
+		}
+	};
+}
+/** 非流式整段切分：返回正文与思考正文（无 `<think>` 时 thinking 为 undefined） */
+function splitThinkTags(content) {
+	if (!content.includes(OPEN)) return { text: content };
+	const splitter = createThinkTagSplitter();
+	const first = splitter.push(content);
+	const last = splitter.flush();
+	const thinking = first.thinking + last.thinking;
+	return {
+		text: first.text + last.text,
+		...thinking !== "" ? { thinking } : {}
+	};
+}
+
+//#endregion
+//#region ../runtime/src/llm/openAiCompatibleClient.ts
+const dataUrl = (part) => `data:${part.mimeType};base64,${part.data}`;
+/** parts → OpenAI content；纯文本折叠成字符串（兼容端点对数组形态支持不一） */
+const toOpenAiContent = (parts, where) => {
+	if (parts.every((p) => p.type === "text")) return partsToText(parts);
+	return parts.map((part) => {
+		switch (part.type) {
+			case "text": return {
+				type: "text",
+				text: part.text
+			};
+			case "image": return {
+				type: "image_url",
+				image_url: { url: dataUrl(part) }
+			};
+			case "file": return {
+				type: "file",
+				file: {
+					...part.name !== void 0 ? { filename: part.name } : {},
+					file_data: dataUrl(part)
+				}
+			};
+			default: return rejectUnsupportedPart(part, "OpenAI", where);
+		}
+	});
+};
+/** system / tool 消息只接受文本：这两类在 OpenAI 协议里没有多模态形态 */
+const toOpenAiText = (parts, where) => {
+	const nonText = parts.find((p) => p.type !== "text");
+	if (nonText) rejectUnsupportedPart(nonText, "OpenAI", where);
+	return partsToText(parts);
+};
+const toOpenAiMessage = (msg) => {
+	if (msg.role === "tool") return {
+		role: "tool",
+		tool_call_id: msg.toolCallId,
+		content: toOpenAiText(msg.content, "tool")
+	};
+	if (msg.role === "system") return {
+		role: "system",
+		content: toOpenAiText(msg.content, "system")
+	};
+	if (msg.role === "assistant" && msg.toolCalls?.length) {
+		const content = toOpenAiContent(msg.content, "assistant");
+		return {
+			role: "assistant",
+			content: content === "" ? null : 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: toOpenAiContent(msg.content, msg.role)
+	};
+};
+const toOpenAiTools = (tools) => tools.map((tool) => ({
+	type: "function",
+	function: {
+		name: tool.name,
+		...tool.description ? { description: tool.description } : {},
+		parameters: sanitizeForVendor(toPortableToolSchema(stripModelUnfillableParams(tool.inputSchema)), OPENAI_SCHEMA_PROFILE, tool.name)
+	}
+}));
+const errorMessage$2 = (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 ?? ((input, init) => fetch(input, init));
+	}
+	#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$2(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();
+		const frames = createSseFrameReader();
+		const think = createThinkTagSplitter();
+		let done = false;
+		let usage;
+		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$2(e)}`, data);
+			}
+			const usageRaw = chunk.usage;
+			if (usageRaw && (typeof usageRaw["prompt_tokens"] === "number" || typeof usageRaw["completion_tokens"] === "number")) usage = {
+				inputTokens: typeof usageRaw["prompt_tokens"] === "number" ? usageRaw["prompt_tokens"] : 0,
+				outputTokens: typeof usageRaw["completion_tokens"] === "number" ? usageRaw["completion_tokens"] : 0
+			};
+			const delta = chunk.choices?.[0]?.delta;
+			if (!delta) return;
+			if (typeof delta["reasoning_content"] === "string" && delta["reasoning_content"] !== "") yield {
+				type: "thinking-delta",
+				delta: delta["reasoning_content"]
+			};
+			if (typeof delta["content"] === "string" && delta["content"] !== "") {
+				const split = think.push(delta["content"]);
+				if (split.thinking !== "") yield {
+					type: "thinking-delta",
+					delta: split.thinking
+				};
+				if (split.text !== "") yield {
+					type: "text-delta",
+					delta: split.text
+				};
+			}
+			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();
+				const payloads = readerDone ? frames.flush() : frames.push(decoder.decode(value, { stream: true }));
+				for (const payload of payloads) {
+					yield* handleFrame(payload);
+					if (done) break;
+				}
+				if (done || readerDone) break;
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		const tail = think.flush();
+		if (tail.thinking !== "") yield {
+			type: "thinking-delta",
+			delta: tail.thinking
+		};
+		if (tail.text !== "") yield {
+			type: "text-delta",
+			delta: tail.text
+		};
+		if (toolCallsByIndex.size > 0) yield {
+			type: "tool-calls",
+			toolCalls: [...toolCallsByIndex.entries()].sort(([a], [b]) => a - b).map(([index, acc]) => {
+				let args = {};
+				let parseError;
+				try {
+					args = JSON.parse(acc.arguments || "{}");
+				} catch (e) {
+					parseError = e instanceof Error ? e.message : String(e);
+				}
+				return {
+					id: acc.id || `call-${index}`,
+					name: acc.name,
+					arguments: args,
+					...parseError ? { argumentsParseError: parseError } : {}
+				};
+			})
+		};
+		yield {
+			type: "done",
+			...usage ? { usage } : {}
+		};
+	}
+	async #postChat(input, stream) {
+		const { baseUrl, apiKey, model } = this.#requireConfig();
+		validateLlmMessages(input.messages);
+		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;
+			body["stream_options"] = { include_usage: 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$2(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)}` : ""}`, { status: res.status });
+		}
+		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) => {
+				let args = {};
+				let parseError;
+				try {
+					args = JSON.parse(tc.function?.arguments ?? "{}");
+				} catch (e) {
+					parseError = e instanceof Error ? e.message : String(e);
+				}
+				return {
+					id: tc.id,
+					name: tc.function?.name ?? "",
+					arguments: args,
+					...parseError ? { argumentsParseError: parseError } : {}
+				};
+			});
+			const raw = choice["content"];
+			const split = typeof raw === "string" ? splitThinkTags(raw) : {
+				text: "",
+				thinking: void 0
+			};
+			const content = split.text;
+			const declared = choice["reasoning_content"];
+			const thinking = typeof declared === "string" && declared !== "" ? declared : split.thinking;
+			const usageRaw = data.usage;
+			const usage = usageRaw && (typeof usageRaw["prompt_tokens"] === "number" || typeof usageRaw["completion_tokens"] === "number") ? {
+				inputTokens: typeof usageRaw["prompt_tokens"] === "number" ? usageRaw["prompt_tokens"] : 0,
+				outputTokens: typeof usageRaw["completion_tokens"] === "number" ? usageRaw["completion_tokens"] : 0
+			} : void 0;
+			return {
+				content: content !== "" ? textParts(content) : void 0,
+				toolCalls: toolCalls?.length ? toolCalls : void 0,
+				...typeof thinking === "string" && thinking !== "" ? { thinking } : {},
+				...usage ? { usage } : {},
+				raw: data
+			};
+		} catch (e) {
+			throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to interpret LLM response: ${errorMessage$2(e)}`, data);
+		}
+	}
+};
+
+//#endregion
+//#region ../runtime/src/llm/anthropicClient.ts
+const ANTHROPIC_VERSION = "2023-06-01";
+const errorMessage$1 = (e) => e instanceof Error ? e.message : String(e);
+/** parts → Anthropic content blocks（image/document 均为 base64 source） */
+const toAnthropicBlocks = (parts, where) => parts.map((part) => {
+	switch (part.type) {
+		case "text": return {
+			type: "text",
+			text: part.text
+		};
+		case "image": return {
+			type: "image",
+			source: {
+				type: "base64",
+				media_type: part.mimeType,
+				data: part.data
+			}
+		};
+		case "file": return {
+			type: "document",
+			source: {
+				type: "base64",
+				media_type: part.mimeType,
+				data: part.data
+			}
+		};
+		default: return rejectUnsupportedPart(part, "Anthropic", where);
+	}
+});
+/** system 是独立的字符串参数，无多模态形态 */
+const toAnthropicSystemText = (parts) => {
+	const nonText = parts.find((p) => p.type !== "text");
+	if (nonText) rejectUnsupportedPart(nonText, "Anthropic", "system");
+	return partsToText(parts);
+};
+/** LlmMessage 序列 → system 独立参数 + user/assistant 消息（tool 结果合并进 user 消息 tool_result blocks） */
+function toAnthropicMessages(messages) {
+	const system = messages.filter((m) => m.role === "system").map((m) => toAnthropicSystemText(m.content)).join("\n");
+	const out = [];
+	for (const msg of messages) {
+		if (msg.role === "system") continue;
+		if (msg.role === "tool") {
+			const block = {
+				type: "tool_result",
+				tool_use_id: msg.toolCallId ?? "",
+				content: toAnthropicBlocks(msg.content, "tool")
+			};
+			const last = out.at(-1);
+			if (last && last.role === "user" && Array.isArray(last.content)) last.content.push(block);
+			else out.push({
+				role: "user",
+				content: [block]
+			});
+			continue;
+		}
+		if (msg.role === "assistant" && msg.toolCalls?.length) {
+			const content = toAnthropicBlocks(msg.content, "assistant");
+			for (const call of msg.toolCalls) content.push({
+				type: "tool_use",
+				id: call.id,
+				name: call.name,
+				input: call.arguments
+			});
+			out.push({
+				role: "assistant",
+				content
+			});
+			continue;
+		}
+		out.push({
+			role: msg.role,
+			content: toAnthropicBlocks(msg.content, msg.role)
+		});
+	}
+	return system === "" ? { messages: out } : {
+		system,
+		messages: out
+	};
+}
+const toAnthropicTools = (tools) => tools.map((tool) => ({
+	name: tool.name,
+	...tool.description ? { description: tool.description } : {},
+	input_schema: sanitizeForVendor(toPortableToolSchema(stripModelUnfillableParams(tool.inputSchema)), ANTHROPIC_SCHEMA_PROFILE, tool.name)
+}));
+/** Anthropic Messages API 客户端（零依赖 fetch；Node/浏览器通用） */
+var AnthropicClient = class {
+	#config;
+	#fetch;
+	constructor(config) {
+		this.#config = config;
+		this.#fetch = config.fetchImpl ?? ((input, init) => fetch(input, init));
+	}
+	#baseUrl() {
+		return (this.#config.baseUrl ?? "https://api.anthropic.com").replace(/\/+$/, "");
+	}
+	#headers() {
+		return {
+			"content-type": "application/json",
+			"x-api-key": this.#config.apiKey,
+			"anthropic-version": ANTHROPIC_VERSION,
+			...this.#config.dangerouslyAllowDirectBrowserAccess ? { "anthropic-dangerous-direct-browser-access": "true" } : {}
+		};
+	}
+	async complete(input) {
+		const res = await this.#post(input, false);
+		let data;
+		try {
+			data = await res.json();
+		} catch (e) {
+			throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to parse LLM response: ${errorMessage$1(e)}`, e);
+		}
+		return this.#parseResponse(data);
+	}
+	/** SSE 流式：text_delta → text-delta；input_json_delta 按 block index 聚合 → tool-calls */
+	async *stream(input) {
+		const res = await this.#post(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();
+		const frames = createSseFrameReader();
+		let inputTokens;
+		let outputTokens;
+		const handleFrame = function* (data) {
+			let chunk;
+			try {
+				chunk = JSON.parse(data);
+			} catch (e) {
+				throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to parse LLM stream frame: ${errorMessage$1(e)}`, data);
+			}
+			const type = chunk["type"];
+			if (type === "error") throw new WebSkillError("LLM_REQUEST_FAILED", `LLM stream error: ${chunk["error"]?.message ?? data}`);
+			if (type === "message_start") {
+				const usage = chunk["message"]?.["usage"];
+				if (typeof usage?.["input_tokens"] === "number") inputTokens = usage["input_tokens"];
+				if (typeof usage?.["output_tokens"] === "number") outputTokens = usage["output_tokens"];
+				return;
+			}
+			if (type === "message_delta") {
+				const usage = chunk["usage"];
+				if (typeof usage?.["output_tokens"] === "number") outputTokens = usage["output_tokens"];
+				return;
+			}
+			if (type === "content_block_start") {
+				const block = chunk["content_block"];
+				if (block?.["type"] === "tool_use") {
+					const index = typeof chunk["index"] === "number" ? chunk["index"] : 0;
+					toolCallsByIndex.set(index, {
+						id: typeof block["id"] === "string" ? block["id"] : "",
+						name: typeof block["name"] === "string" ? block["name"] : "",
+						arguments: ""
+					});
+				}
+				return;
+			}
+			if (type === "content_block_delta") {
+				const index = typeof chunk["index"] === "number" ? chunk["index"] : 0;
+				const delta = chunk["delta"];
+				if (delta?.["type"] === "text_delta" && typeof delta["text"] === "string" && delta["text"] !== "") {
+					yield {
+						type: "text-delta",
+						delta: delta["text"]
+					};
+					return;
+				}
+				if (delta?.["type"] === "thinking_delta" && typeof delta["thinking"] === "string" && delta["thinking"] !== "") {
+					yield {
+						type: "thinking-delta",
+						delta: delta["thinking"]
+					};
+					return;
+				}
+				if (delta?.["type"] === "input_json_delta" && typeof delta["partial_json"] === "string") {
+					const acc = toolCallsByIndex.get(index) ?? {
+						id: "",
+						name: "",
+						arguments: ""
+					};
+					acc.arguments += delta["partial_json"];
+					toolCallsByIndex.set(index, acc);
+				}
+				return;
+			}
+		};
+		try {
+			for (;;) {
+				const { value, done: readerDone } = await reader.read();
+				const payloads = readerDone ? frames.flush() : frames.push(decoder.decode(value, { stream: true }));
+				for (const payload of payloads) yield* handleFrame(payload);
+				if (readerDone) 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 = {};
+				let parseError;
+				try {
+					args = JSON.parse(acc.arguments || "{}");
+				} catch (e) {
+					parseError = e instanceof Error ? e.message : String(e);
+				}
+				return {
+					id: acc.id || `call-${index}`,
+					name: acc.name,
+					arguments: args,
+					...parseError ? { argumentsParseError: parseError } : {}
+				};
+			})
+		};
+		const usage = inputTokens !== void 0 || outputTokens !== void 0 ? {
+			inputTokens: inputTokens ?? 0,
+			outputTokens: outputTokens ?? 0
+		} : void 0;
+		yield {
+			type: "done",
+			...usage ? { usage } : {}
+		};
+	}
+	async #post(input, stream) {
+		validateLlmMessages(input.messages);
+		const { system, messages } = toAnthropicMessages(input.messages);
+		const body = {
+			model: input.model ?? this.#config.model,
+			max_tokens: this.#config.maxTokens ?? 4096,
+			messages
+		};
+		if (system !== void 0) body["system"] = system;
+		if (input.tools?.length) body["tools"] = toAnthropicTools(input.tools);
+		const thinkingBudget = this.#config.thinkingBudgetTokens;
+		if (thinkingBudget !== void 0 && Number.isInteger(thinkingBudget) && thinkingBudget > 0) body["thinking"] = {
+			type: "enabled",
+			budget_tokens: thinkingBudget
+		};
+		else if (input.temperature !== void 0) body["temperature"] = input.temperature;
+		if (stream) body["stream"] = true;
+		let res;
+		try {
+			res = await this.#fetch(`${this.#baseUrl()}/v1/messages`, {
+				method: "POST",
+				headers: this.#headers(),
+				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$1(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)}` : ""}`, { status: res.status });
+		}
+		return res;
+	}
+	/**
+	* 真实调用路径探测（FR-27.1）：`POST /v1/messages` 最小请求（max_tokens=1），200 即可达。
+	* Anthropic 兼容端点（如 LM Studio 的 /anthropic 层）不实现 `GET /v1/models`，
+	* 用 /models 探测会把「能对话」误判为「不可达」——checkAvailability 的语义从
+	* 「/models 可达」改为「能完成一次真实调用」。
+	*/
+	async checkAvailability() {
+		try {
+			return (await this.#fetch(`${this.#baseUrl()}/v1/messages`, {
+				method: "POST",
+				headers: this.#headers(),
+				body: JSON.stringify({
+					model: this.#config.model,
+					max_tokens: 1,
+					messages: [{
+						role: "user",
+						content: "ping"
+					}]
+				})
+			})).ok;
+		} catch {
+			return false;
+		}
+	}
+	#parseResponse(data) {
+		try {
+			const blocks = data.content;
+			if (!Array.isArray(blocks)) throw new Error("response has no content blocks");
+			const text = blocks.filter((b) => b["type"] === "text").map((b) => String(b["text"] ?? "")).join("");
+			const thinking = blocks.filter((b) => b["type"] === "thinking").map((b) => String(b["thinking"] ?? "")).join("");
+			const toolCalls = blocks.filter((b) => b["type"] === "tool_use").map((b) => ({
+				id: typeof b["id"] === "string" ? b["id"] : "",
+				name: typeof b["name"] === "string" ? b["name"] : "",
+				arguments: typeof b["input"] === "object" && b["input"] !== null ? b["input"] : {}
+			}));
+			const usageRaw = data.usage;
+			const usage = typeof usageRaw?.["input_tokens"] === "number" || typeof usageRaw?.["output_tokens"] === "number" ? {
+				inputTokens: typeof usageRaw["input_tokens"] === "number" ? usageRaw["input_tokens"] : 0,
+				outputTokens: typeof usageRaw["output_tokens"] === "number" ? usageRaw["output_tokens"] : 0
+			} : void 0;
+			return {
+				content: text === "" ? void 0 : textParts(text),
+				toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+				...thinking === "" ? {} : { thinking },
+				...usage ? { usage } : {},
+				raw: data
+			};
+		} catch (e) {
+			throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to interpret LLM response: ${errorMessage$1(e)}`, data);
+		}
+	}
+};
+
+//#endregion
+//#region ../runtime/src/llm/googleGenAiClient.ts
+const errorMessage = (e) => e instanceof Error ? e.message : String(e);
+/** usageMetadata → LlmTokenUsage（promptTokenCount / candidatesTokenCount；无字段返回 undefined） */
+function parseGenAiUsage(data) {
+	const usage = data?.usageMetadata;
+	if (!usage) return void 0;
+	const input = usage["promptTokenCount"];
+	const output = usage["candidatesTokenCount"];
+	if (typeof input !== "number" && typeof output !== "number") return void 0;
+	return {
+		inputTokens: typeof input === "number" ? input : 0,
+		outputTokens: typeof output === "number" ? output : 0
+	};
+}
+/** parts → GenAI parts（二进制统一走 inlineData） */
+const toGenAiParts = (parts, where) => parts.map((part) => {
+	switch (part.type) {
+		case "text": return { text: part.text };
+		case "image":
+		case "file": return { inlineData: {
+			mimeType: part.mimeType,
+			data: part.data
+		} };
+		default: return rejectUnsupportedPart(part, "Google GenAI", where);
+	}
+});
+/** systemInstruction 与 functionResponse 只接受文本 */
+const toGenAiText = (parts, where) => {
+	const nonText = parts.find((p) => p.type !== "text");
+	if (nonText) rejectUnsupportedPart(nonText, "Google GenAI", where);
+	return partsToText(parts);
+};
+/** tool 结果文本包装为 functionResponse.response 对象 */
+function responseObject(content) {
+	try {
+		const parsed = JSON.parse(content);
+		if (typeof parsed === "object" && parsed !== null) return parsed;
+	} catch {}
+	return { result: content };
+}
+/** LlmMessage 序列 → systemInstruction + contents（tool 结果合并进 user 消息 functionResponse parts） */
+function toGenAiContents(messages) {
+	const system = messages.filter((m) => m.role === "system").map((m) => toGenAiText(m.content, "system")).join("\n");
+	const nameByCallId = /* @__PURE__ */ new Map();
+	for (const msg of messages) if (msg.role === "assistant") for (const call of msg.toolCalls ?? []) nameByCallId.set(call.id, call.name);
+	const out = [];
+	for (const msg of messages) {
+		if (msg.role === "system") continue;
+		if (msg.role === "tool") {
+			const callId = msg.toolCallId ?? "";
+			const part = { functionResponse: {
+				name: nameByCallId.get(callId) ?? callId,
+				response: responseObject(toGenAiText(msg.content, "tool"))
+			} };
+			const last = out.at(-1);
+			if (last && last.role === "user") last.parts.push(part);
+			else out.push({
+				role: "user",
+				parts: [part]
+			});
+			continue;
+		}
+		if (msg.role === "assistant") {
+			const parts = toGenAiParts(msg.content, "assistant");
+			for (const call of msg.toolCalls ?? []) {
+				const signature = call.vendor?.["thoughtSignature"];
+				parts.push({
+					functionCall: {
+						name: call.name,
+						args: call.arguments
+					},
+					...typeof signature === "string" ? { thoughtSignature: signature } : {}
+				});
+			}
+			out.push({
+				role: "model",
+				parts: parts.length > 0 ? parts : [{ text: "" }]
+			});
+			continue;
+		}
+		out.push({
+			role: "user",
+			parts: toGenAiParts(msg.content, msg.role)
+		});
+	}
+	return system === "" ? { contents: out } : {
+		systemInstruction: { parts: [{ text: system }] },
+		contents: out
+	};
+}
+const toGenAiTools = (tools) => [{ functionDeclarations: tools.map((tool) => {
+	const portable = toPortableToolSchema(stripModelUnfillableParams(tool.inputSchema));
+	return {
+		name: tool.name,
+		...tool.description ? { description: tool.description } : {},
+		...isExpressibleForVendor(portable, GOOGLE_SCHEMA_PROFILE) ? { parameters: sanitizeForVendor(portable, GOOGLE_SCHEMA_PROFILE, tool.name) } : { parametersJsonSchema: relaxRefLoops(portable) }
+	};
+}) }];
+/** Google GenAI（generateContent / streamGenerateContent）客户端（零依赖 fetch） */
+var GoogleGenAiClient = class {
+	#config;
+	#fetch;
+	constructor(config) {
+		this.#config = config;
+		this.#fetch = config.fetchImpl ?? ((input, init) => fetch(input, init));
+	}
+	#baseUrl() {
+		return (this.#config.baseUrl ?? "https://generativelanguage.googleapis.com").replace(/\/+$/, "");
+	}
+	async complete(input) {
+		const res = await this.#post(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);
+		}
+		const parts = this.#responseParts(data);
+		const text = parts.filter((p) => typeof p["text"] === "string").map((p) => String(p["text"])).join("");
+		const toolCalls = this.#functionCalls(parts);
+		const usage = parseGenAiUsage(data);
+		return {
+			content: text === "" ? void 0 : textParts(text),
+			toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+			...usage ? { usage } : {},
+			raw: data
+		};
+	}
+	/** SSE 流式：chunk.parts text → text-delta；functionCall 聚合 → tool-calls */
+	async *stream(input) {
+		const res = await this.#post(input, true);
+		if (!res.body) throw new WebSkillError("LLM_REQUEST_FAILED", "LLM streaming response has no body");
+		const toolCalls = [];
+		const decoder = new TextDecoder();
+		const reader = res.body.getReader();
+		const frames = createSseFrameReader();
+		let usage;
+		const handleFrame = function* (data) {
+			let chunk;
+			try {
+				chunk = JSON.parse(data);
+			} catch (e) {
+				throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to parse LLM stream frame: ${errorMessage(e)}`, data);
+			}
+			usage = parseGenAiUsage(chunk) ?? usage;
+			const parts = chunk.candidates?.[0]?.content?.parts;
+			for (const part of parts ?? []) {
+				if (typeof part["text"] === "string" && part["text"] !== "") {
+					yield {
+						type: "text-delta",
+						delta: part["text"]
+					};
+					continue;
+				}
+				const call = part["functionCall"];
+				if (call) {
+					const signature = part["thoughtSignature"];
+					toolCalls.push({
+						id: `call-${toolCalls.length}`,
+						name: call.name ?? "",
+						arguments: call.args ?? {},
+						...typeof signature === "string" ? { vendor: { thoughtSignature: signature } } : {}
+					});
+				}
+			}
+		};
+		try {
+			for (;;) {
+				const { value, done: readerDone } = await reader.read();
+				const payloads = readerDone ? frames.flush() : frames.push(decoder.decode(value, { stream: true }));
+				for (const payload of payloads) yield* handleFrame(payload);
+				if (readerDone) break;
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		if (toolCalls.length > 0) yield {
+			type: "tool-calls",
+			toolCalls
+		};
+		yield {
+			type: "done",
+			...usage ? { usage } : {}
+		};
+	}
+	async #post(input, stream) {
+		const model = input.model ?? this.#config.model;
+		const action = stream ? ":streamGenerateContent?alt=sse" : ":generateContent";
+		validateLlmMessages(input.messages);
+		const { systemInstruction, contents } = toGenAiContents(input.messages);
+		const body = { contents };
+		if (systemInstruction) body["systemInstruction"] = systemInstruction;
+		if (input.tools?.length) body["tools"] = toGenAiTools(input.tools);
+		if (input.temperature !== void 0) body["generationConfig"] = { temperature: input.temperature };
+		let res;
+		try {
+			res = await this.#fetch(`${this.#baseUrl()}/v1beta/models/${encodeURIComponent(model)}${action}`, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					"x-goog-api-key": this.#config.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)}` : ""}`, { status: res.status });
+		}
+		return res;
+	}
+	/** 轻量探测（GET /v1beta/models），集成测试据此决定 skip */
+	async checkAvailability() {
+		try {
+			return (await this.#fetch(`${this.#baseUrl()}/v1beta/models`, { headers: { "x-goog-api-key": this.#config.apiKey } })).ok;
+		} catch {
+			return false;
+		}
+	}
+	#responseParts(data) {
+		try {
+			const parts = data.candidates?.[0]?.content?.parts;
+			if (!Array.isArray(parts)) throw new Error("response has no candidates[0].content.parts");
+			return parts;
+		} catch (e) {
+			throw new WebSkillError("LLM_REQUEST_FAILED", `Failed to interpret LLM response: ${errorMessage(e)}`, data);
+		}
+	}
+	#functionCalls(parts) {
+		const out = [];
+		for (const part of parts) {
+			const call = part["functionCall"];
+			if (call) {
+				const signature = part["thoughtSignature"];
+				out.push({
+					id: `call-${out.length}`,
+					name: call.name ?? "",
+					arguments: call.args ?? {},
+					...typeof signature === "string" ? { vendor: { thoughtSignature: signature } } : {}
+				});
+			}
+		}
+		return out;
+	}
+};
+
+//#endregion
+//#region ../runtime/src/llm/vercelAiAdapter.ts
+/** v5 { inputTokens, outputTokens } 与 v4 { promptTokens, completionTokens } 两种形状都接 */
+function fromVercelUsage(raw) {
+	const u = raw ?? {};
+	const input = u["inputTokens"] ?? u["promptTokens"];
+	const output = u["outputTokens"] ?? u["completionTokens"];
+	if (typeof input !== "number" && typeof output !== "number") return void 0;
+	return {
+		inputTokens: typeof input === "number" ? input : 0,
+		outputTokens: typeof output === "number" ? output : 0
+	};
+}
+function toVercelToolSpecs(tools) {
+	const out = {};
+	for (const tool of tools) out[tool.name] = {
+		...tool.description ? { description: tool.description } : {},
+		inputSchema: tool.inputSchema
+	};
+	return out;
+}
+/**
+* 归一化供应商思考内容：v5 的 `reasoningText`（字符串）与 v4 的 `reasoning`
+* （Array<{ text; type }>）都能落到同一条 `LlmResponse.thinking`。
+*/
+function normalizeThinking(value) {
+	if (typeof value === "string") return value !== "" ? value : void 0;
+	if (!Array.isArray(value)) return void 0;
+	const text = value.map((part) => typeof part?.text === "string" ? part.text : "").join("");
+	return text !== "" ? text : void 0;
+}
+/** 接受 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 : {}
+		};
+	});
+	const thinking = normalizeThinking(r.reasoningText ?? r.reasoning);
+	const usage = fromVercelUsage(r.usage);
+	return {
+		content: typeof r.text === "string" && r.text !== "" ? textParts(r.text) : void 0,
+		toolCalls: toolCalls.length ? toolCalls : void 0,
+		...thinking !== void 0 ? { thinking } : {},
+		...usage ? { usage } : {},
+		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 "reasoning-delta": {
+			const delta = p["text"] ?? p["delta"];
+			return typeof delta === "string" && delta !== "" ? {
+				type: "thinking-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": {
+			const usage = fromVercelUsage(p["totalUsage"] ?? p["usage"]);
+			return {
+				type: "done",
+				...usage ? { usage } : {}
+			};
+		}
+		default: return;
+	}
+}
+
+//#endregion
+//#region ../runtime/src/llm/mockLlmClient.ts
+/**
+* 预设响应序列的确定性 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 thinking = "";
+			let toolCalls;
+			let usage;
+			for (const event of events) if (event.type === "text-delta") content += event.delta;
+			else if (event.type === "thinking-delta") thinking += event.delta;
+			else if (event.type === "tool-calls") toolCalls = event.toolCalls;
+			else if (event.type === "done") {
+				if (event.content !== void 0) content = event.content;
+				if (event.usage !== void 0) usage = event.usage;
+			}
+			return {
+				content: content === "" ? void 0 : textParts(content),
+				toolCalls,
+				...thinking === "" ? {} : { thinking },
+				...usage ? { usage } : {}
+			};
+		}
+		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.thinking !== void 0 && response.thinking !== "") {
+			const half = Math.ceil(response.thinking.length / 2);
+			yield {
+				type: "thinking-delta",
+				delta: response.thinking.slice(0, half)
+			};
+			const rest = response.thinking.slice(half);
+			if (rest !== "") yield {
+				type: "thinking-delta",
+				delta: rest
+			};
+		}
+		const text = partsToText(response.content);
+		if (text !== "") {
+			const chunkSize = Math.max(1, Math.ceil(text.length / 3));
+			for (let i = 0; i < text.length; i += chunkSize) yield {
+				type: "text-delta",
+				delta: text.slice(i, i + chunkSize)
+			};
+		}
+		if (response.toolCalls?.length) yield {
+			type: "tool-calls",
+			toolCalls: response.toolCalls
+		};
+		yield {
+			type: "done",
+			...response.usage ? { usage: response.usage } : {}
+		};
+	}
+};
+
+//#endregion
+export { GoogleGenAiClient as a, findUnpairedToolCalls as c, partsToText as d, promptText as f, toVercelToolSpecs as i, interruptedToolResult as l, fromVercelResult as n, AnthropicClient as o, textParts as p, fromVercelStreamPart as r, OpenAiCompatibleClient as s, MockLlmClient as t, sealToolCallPairs as u };