agentpage 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1987 @@
+import { Type } from "@sinclair/typebox";
+
+//#region src/core/agent-loop/constants.ts
+/**
+* Agent Loop 默认配置常量。
+*
+* 统一集中在该文件，避免在主循环中散落“魔法数字”。
+*/
+const DEFAULT_MAX_ROUNDS = 10;
+const DEFAULT_RECOVERY_WAIT_MS = 1e3;
+const DEFAULT_ACTION_RECOVERY_ROUNDS = 5;
+
+//#endregion
+//#region src/core/agent-loop/helpers.ts
+/** 异步睡眠，确保恢复重试按顺序串行执行。 */
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** 将工具返回内容统一转为字符串，便于拼接进消息。 */
+function toContentString(content) {
+	return typeof content === "string" ? content : JSON.stringify(content, null, 2);
+}
+/** 判定工具失败是否属于“元素不存在”，用于触发快照恢复。 */
+function isElementNotFoundResult(result) {
+	const details = result.details;
+	if (details && typeof details === "object") {
+		if (details.code === "ELEMENT_NOT_FOUND") return true;
+	}
+	const content = toContentString(result.content);
+	return content.includes("未找到") && content.includes("元素");
+}
+/** 为同一动作构造稳定 key，用于统计恢复重试次数。 */
+function buildToolCallKey(name, input) {
+	return `${name}:${JSON.stringify(input)}`;
+}
+/**
+* 解析恢复等待时长：
+* - 优先 `waitMs`
+* - 其次 `waitSeconds`
+* - 最后回退默认值
+*/
+function resolveRecoveryWaitMs(input) {
+	if (!input || typeof input !== "object") return DEFAULT_RECOVERY_WAIT_MS;
+	const params = input;
+	const waitMs = params.waitMs;
+	if (typeof waitMs === "number" && Number.isFinite(waitMs)) return Math.max(0, Math.floor(waitMs));
+	const waitSeconds = params.waitSeconds;
+	if (typeof waitSeconds === "number" && Number.isFinite(waitSeconds)) return Math.max(0, Math.floor(waitSeconds * 1e3));
+	return DEFAULT_RECOVERY_WAIT_MS;
+}
+/** 将工具输入压缩成简短文本，用于轨迹展示。 */
+function formatToolInputBrief(input) {
+	if (!input || typeof input !== "object") return "";
+	const params = input;
+	const parts = [];
+	for (const key of [
+		"action",
+		"selector",
+		"waitMs",
+		"waitSeconds",
+		"url",
+		"text"
+	]) {
+		const value = params[key];
+		if (value === void 0 || value === null) continue;
+		if (typeof value === "string") parts.push(`${key}=${JSON.stringify(value).slice(0, 80)}`);
+		else if (typeof value === "number" || typeof value === "boolean") parts.push(`${key}=${String(value)}`);
+	}
+	if (parts.length === 0) return "";
+	return ` (${parts.join(", ")})`;
+}
+/**
+* 将完整轨迹格式化为可读文本。
+* 支持附加“当前步骤”用于在恢复提示中高亮失败动作。
+*/
+function buildToolTrace(trace, current) {
+	const lines = trace.map((entry, index) => {
+		const code = entry.result.details && typeof entry.result.details === "object" ? entry.result.details.code : void 0;
+		const codeText = typeof code === "string" ? ` [${code}]` : "";
+		const marker = entry.marker ? ` ${entry.marker}` : "";
+		return `${index + 1}. [round ${entry.round}] ${entry.name}${formatToolInputBrief(entry.input)}${codeText}${marker}`;
+	});
+	if (current) {
+		const code = current.result?.details && typeof current.result.details === "object" ? current.result.details.code : void 0;
+		const codeText = typeof code === "string" ? ` [${code}]` : "";
+		const marker = current.marker ? ` ${current.marker}` : "";
+		lines.push(`${lines.length + 1}. [round ${current.round}] ${current.name}${formatToolInputBrief(current.input)}${codeText}${marker}`);
+	}
+	return lines.length > 0 ? lines.join("\n") : "(暂无工具执行记录)";
+}
+/** 从工具参数中读取 action。 */
+function getToolAction(input) {
+	if (!input || typeof input !== "object") return void 0;
+	const action = input.action;
+	return typeof action === "string" ? action : void 0;
+}
+/** 判定工具结果是否标记 error。 */
+function hasToolError(result) {
+	return result.details && typeof result.details === "object" ? Boolean(result.details.error) : false;
+}
+/** 读取当前页面 URL（通过 page_info 工具）。 */
+async function readPageUrl(registry) {
+	const result = await registry.dispatch("page_info", { action: "get_url" });
+	return typeof result.content === "string" ? result.content : void 0;
+}
+/** 读取当前页面快照（通过 page_info 工具）。 */
+async function readPageSnapshot(registry, maxDepth = 8) {
+	return toContentString((await registry.dispatch("page_info", {
+		action: "snapshot",
+		maxDepth
+	})).content);
+}
+
+//#endregion
+//#region src/core/agent-loop/index.ts
+/**
+* 执行 Agent 决策循环（环境无关）。
+*
+* 完整流程：
+* 1. 获取已注册的工具列表
+* 2. 循环：发消息给 AI → 检查是否返回 tool_call → 执行 → 反馈 → 继续
+* 3. AI 不再调用工具时，返回最终回复
+*/
+async function executeAgentLoop(params) {
+	const { client, registry, systemPrompt, message, history, dryRun = false, maxRounds = DEFAULT_MAX_ROUNDS, callbacks } = params;
+	const tools = registry.getDefinitions();
+	const messages = [...history ?? [], {
+		role: "user",
+		content: message
+	}];
+	const allToolCalls = [];
+	const fullToolTrace = [];
+	const actionRecoveryAttempts = /* @__PURE__ */ new Map();
+	const pageContext = { needsSnapshotBeforeDom: false };
+	let finalReply = "";
+	for (let round = 0; round < maxRounds; round++) {
+		callbacks?.onRound?.(round);
+		const response = await client.chat({
+			systemPrompt,
+			messages,
+			tools
+		});
+		if (!response.toolCalls || response.toolCalls.length === 0) {
+			finalReply = response.text ?? "";
+			if (finalReply) callbacks?.onText?.(finalReply);
+			break;
+		}
+		if (response.text) callbacks?.onText?.(response.text);
+		if (dryRun) {
+			finalReply = response.text ? response.text + "\n\n" : "";
+			finalReply += "🔧 AI 请求调用以下工具（dry-run 模式，未执行）：\n";
+			for (const tc of response.toolCalls) {
+				callbacks?.onToolCall?.(tc.name, tc.input);
+				finalReply += `\n┌─ 工具: ${tc.name}\n`;
+				finalReply += `│  ID:   ${tc.id}\n`;
+				finalReply += `│  参数:\n`;
+				const inputStr = JSON.stringify(tc.input, null, 2);
+				for (const line of inputStr.split("\n")) finalReply += `│    ${line}\n`;
+				finalReply += `└────────────────────\n`;
+			}
+			break;
+		}
+		const toolResults = [];
+		for (const tc of response.toolCalls) {
+			callbacks?.onToolCall?.(tc.name, tc.input);
+			const latestUrl = await readPageUrl(registry);
+			if (latestUrl) {
+				if (!pageContext.currentUrl) pageContext.currentUrl = latestUrl;
+				else if (latestUrl !== pageContext.currentUrl) {
+					pageContext.currentUrl = latestUrl;
+					pageContext.needsSnapshotBeforeDom = true;
+				}
+			}
+			if (tc.name === "dom" && pageContext.needsSnapshotBeforeDom) {
+				const snapshotText = await readPageSnapshot(registry, 8);
+				pageContext.latestSnapshot = snapshotText;
+				pageContext.needsSnapshotBeforeDom = false;
+				const result = {
+					content: [
+						`检测到页面 URL 变化：${pageContext.currentUrl ?? "(未知)"}`,
+						"已在执行 DOM 操作前生成最新快照，请基于该快照重新定位目标元素后重试当前工具调用。",
+						"",
+						"本次对话任务完整工具轨迹：",
+						buildToolTrace(fullToolTrace, {
+							round,
+							name: tc.name,
+							input: tc.input,
+							marker: "[URL变化待重定位]"
+						}),
+						"",
+						"最新页面快照：",
+						snapshotText
+					].join("\n"),
+					details: {
+						error: true,
+						code: "URL_CHANGED_REQUIRE_NEW_SNAPSHOT",
+						url: pageContext.currentUrl
+					}
+				};
+				allToolCalls.push({
+					name: tc.name,
+					input: tc.input,
+					result
+				});
+				fullToolTrace.push({
+					round,
+					name: tc.name,
+					input: tc.input,
+					result,
+					marker: "[URL变化待重定位]"
+				});
+				callbacks?.onToolResult?.(tc.name, result);
+				toolResults.push({
+					toolCallId: tc.id,
+					result: toContentString(result.content)
+				});
+				continue;
+			}
+			let result = await registry.dispatch(tc.name, tc.input);
+			if (tc.name === "dom" && isElementNotFoundResult(result)) {
+				const key = buildToolCallKey(tc.name, tc.input);
+				const attempts = (actionRecoveryAttempts.get(key) ?? 0) + 1;
+				actionRecoveryAttempts.set(key, attempts);
+				const recoveryWaitMs = resolveRecoveryWaitMs(tc.input);
+				if (attempts <= DEFAULT_ACTION_RECOVERY_ROUNDS) {
+					await sleep$1(recoveryWaitMs);
+					const snapshotText = await readPageSnapshot(registry, 8);
+					pageContext.latestSnapshot = snapshotText;
+					const originalError = toContentString(result.content);
+					const fullTrace = buildToolTrace(fullToolTrace, {
+						round,
+						name: tc.name,
+						input: tc.input,
+						result,
+						marker: "[当前失败]"
+					});
+					result = {
+						content: [
+							originalError,
+							"",
+							`自动恢复 ${attempts}/${DEFAULT_ACTION_RECOVERY_ROUNDS}：等待 ${recoveryWaitMs}ms 后重新获取页面快照。`,
+							"本次对话任务完整工具轨迹（含本次失败）：",
+							fullTrace,
+							"请根据下方最新快照，重新定位本次操作目标元素并再次调用工具。",
+							"",
+							"最新页面快照：",
+							snapshotText
+						].join("\n"),
+						details: {
+							error: true,
+							code: "ELEMENT_NOT_FOUND_RECOVERY",
+							recoveryAttempt: attempts,
+							recoveryMaxRounds: DEFAULT_ACTION_RECOVERY_ROUNDS,
+							waitMs: recoveryWaitMs
+						}
+					};
+				} else {
+					const originalError = toContentString(result.content);
+					const fullTrace = buildToolTrace(fullToolTrace, {
+						round,
+						name: tc.name,
+						input: tc.input,
+						result,
+						marker: "[超过恢复上限]"
+					});
+					result = {
+						content: [
+							originalError,
+							"",
+							`已达到最大自动恢复次数（${DEFAULT_ACTION_RECOVERY_ROUNDS}）。请根据当前页面状态调整操作目标后重试。`,
+							"本次对话任务完整工具轨迹：",
+							fullTrace
+						].join("\n"),
+						details: {
+							error: true,
+							code: "ELEMENT_NOT_FOUND_MAX_RECOVERY_REACHED",
+							recoveryAttempt: attempts,
+							recoveryMaxRounds: DEFAULT_ACTION_RECOVERY_ROUNDS,
+							waitMs: recoveryWaitMs
+						}
+					};
+				}
+			}
+			allToolCalls.push({
+				name: tc.name,
+				input: tc.input,
+				result
+			});
+			fullToolTrace.push({
+				round,
+				name: tc.name,
+				input: tc.input,
+				result
+			});
+			if (tc.name === "navigate") {
+				const action = getToolAction(tc.input);
+				if (action === "goto" || action === "back" || action === "forward" || action === "reload") {
+					if (!hasToolError(result)) pageContext.needsSnapshotBeforeDom = true;
+				}
+			}
+			callbacks?.onToolResult?.(tc.name, result);
+			toolResults.push({
+				toolCallId: tc.id,
+				result: typeof result.content === "string" ? result.content : JSON.stringify(result.content)
+			});
+		}
+		messages.push({
+			role: "assistant",
+			content: response.text ?? "",
+			toolCalls: response.toolCalls
+		});
+		messages.push({
+			role: "tool",
+			content: toolResults
+		});
+	}
+	if (finalReply) messages.push({
+		role: "assistant",
+		content: finalReply
+	});
+	return {
+		reply: finalReply,
+		toolCalls: allToolCalls,
+		messages
+	};
+}
+
+//#endregion
+//#region src/core/ai-client/constants.ts
+/**
+* 各 Provider 的默认 API 端点。
+*
+* - openai   → OpenAI 官方 API
+* - copilot  → GitHub Models API（使用 OpenAI 兼容格式）
+* - anthropic → Anthropic Messages API
+*/
+const PROVIDER_ENDPOINTS = {
+	openai: "https://api.openai.com/v1",
+	copilot: "https://models.inference.ai.azure.com",
+	anthropic: "https://api.anthropic.com"
+};
+/**
+* 校验 provider 是否受支持。
+*
+* @throws 不支持的 provider 抛出 Error，附带支持列表
+*/
+function validateProvider(provider) {
+	if (!PROVIDER_ENDPOINTS[provider]) {
+		const supported = Object.keys(PROVIDER_ENDPOINTS).join(", ");
+		throw new Error(`Unknown AI provider: ${provider}. Supported: ${supported}`);
+	}
+}
+/**
+* 解析 provider 对应的 API 基础 URL。
+*
+* 优先使用用户自定义的 baseURL（如本地 Ollama），
+* 其次使用 PROVIDER_ENDPOINTS 中的默认值。
+*/
+function resolveBaseURL(config) {
+	return config.baseURL ?? PROVIDER_ENDPOINTS[config.provider] ?? "";
+}
+/**
+* 清理 TypeBox Schema — 去除 Symbol 等不可序列化的属性。
+*
+* TypeBox 的 Type.Object() 产物包含 Symbol key（如 [Kind]、[Hint]），
+* 这些 Symbol 在 JSON.stringify 时会被忽略，但某些 AI API 端点
+* 对 JSON Schema 做严格校验时可能报错。
+*
+* 通过 JSON roundtrip（stringify → parse）清理掉所有不可序列化的属性。
+*/
+function cleanSchema(schema) {
+	return JSON.parse(JSON.stringify(schema));
+}
+
+//#endregion
+//#region src/core/ai-client/custom.ts
+/**
+* 可继承的 AI 客户端基类 — 实现 AIClient 接口。
+*
+* 设计原则：
+* - 实现 `AIClient` 接口 → 可直接传入 `executeAgentLoop()` 和 `WebAgent`
+* - 构造时注入 `chatHandler` → 无需继承即可自定义对话逻辑
+* - `chat()` 方法可被子类覆盖 → 支持继承式扩展（添加中间件逻辑）
+*/
+var BaseAIClient = class {
+	/** 用户提供的对话处理函数 */
+	chatHandler;
+	constructor(options) {
+		this.chatHandler = options.chatHandler;
+	}
+	/**
+	* 发送对话请求并获取 AI 响应。
+	*
+	* 默认实现直接委托给 `chatHandler`。
+	* 子类可覆盖此方法添加中间件逻辑（日志、重试、缓存等）。
+	*
+	* @param params - 统一格式的聊天参数
+	* @returns 统一格式的 AI 响应
+	*/
+	async chat(params) {
+		return this.chatHandler(params);
+	}
+};
+
+//#endregion
+//#region src/core/ai-client/openai.ts
+/**
+* OpenAI / Copilot AI 客户端 — 继承 BaseAIClient。
+*
+* 封装完整的 OpenAI Chat Completions API 调用流程：
+* 1. buildOpenAIRequest() → 构建 HTTP 请求
+* 2. fetch() → 发送请求
+* 3. parseOpenAIResponse() → 解析响应为统一格式
+*
+* 使用示例：
+* ```ts
+* const client = new OpenAIClient({
+*   provider: "openai",
+*   model: "gpt-4o",
+*   apiKey: "sk-xxx",
+* });
+* const response = await client.chat({ systemPrompt, messages, tools });
+* ```
+*
+* 也可用于 Copilot（GitHub Models）：
+* ```ts
+* const client = new OpenAIClient({
+*   provider: "copilot",
+*   model: "gpt-4o",
+*   apiKey: "ghp_xxx",
+* });
+* ```
+*/
+var OpenAIClient = class extends BaseAIClient {
+	/** AI 客户端配置（provider / model / apiKey / baseURL） */
+	config;
+	constructor(config) {
+		super({ chatHandler: async (params) => {
+			const req = buildOpenAIRequest(this.config, params);
+			const res = await fetch(req.url, {
+				method: req.method,
+				headers: req.headers,
+				body: req.body
+			});
+			if (!res.ok) {
+				const errText = await res.text();
+				throw new Error(`AI API ${res.status}: ${errText.slice(0, 500)}`);
+			}
+			return parseOpenAIResponse(await res.json());
+		} });
+		this.config = config;
+	}
+};
+/**
+* 将统一格式的 ChatParams 转换为 OpenAI Chat Completions API 请求。
+*
+* 转换逻辑：
+* - system prompt → `{ role: "system", content }` 消息
+* - 工具定义 → `tools` 数组（function calling 格式）
+* - 工具结果 → 拆分为多条 `{ role: "tool", tool_call_id }` 消息
+* - AI 回复含工具调用 → `tool_calls` 字段
+*
+* 默认参数：temperature=0.3, max_tokens=8192, tool_choice="auto"
+*/
+function buildOpenAIRequest(config, params) {
+	const baseURL = resolveBaseURL(config);
+	const { systemPrompt, messages, tools } = params;
+	const openaiTools = tools?.map((t) => ({
+		type: "function",
+		function: {
+			name: t.name,
+			description: t.description,
+			parameters: cleanSchema(t.schema)
+		}
+	}));
+	const openaiMessages = convertMessages$1(systemPrompt, messages);
+	const body = {
+		model: config.model,
+		messages: openaiMessages,
+		temperature: .3,
+		max_tokens: 8192
+	};
+	if (openaiTools && openaiTools.length > 0) {
+		body.tools = openaiTools;
+		body.tool_choice = "auto";
+	}
+	return {
+		url: `${baseURL}/chat/completions`,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${config.apiKey}`
+		},
+		body: JSON.stringify(body)
+	};
+}
+/**
+* 将 OpenAI Chat Completions API 原始响应解析为统一的 AIChatResponse。
+*
+* 解析要点：
+* - 文本回复 → `choice.message.content`
+* - 工具调用 → `choice.message.tool_calls`，arguments 为 JSON 字符串需 parse
+* - Token 用量 → `usage.prompt_tokens` / `usage.completion_tokens`
+*
+* @throws 无有效 choice 时抛出 Error
+*/
+function parseOpenAIResponse(data) {
+	const d = data;
+	const choice = d.choices?.[0];
+	if (!choice) throw new Error("AI 未返回有效响应");
+	const msg = choice.message;
+	const toolCalls = msg.tool_calls?.map((tc) => ({
+		id: tc.id,
+		name: tc.function.name,
+		input: JSON.parse(tc.function.arguments)
+	}));
+	return {
+		text: msg.content || void 0,
+		toolCalls: toolCalls?.length ? toolCalls : void 0,
+		usage: d.usage ? {
+			inputTokens: d.usage.prompt_tokens ?? 0,
+			outputTokens: d.usage.completion_tokens ?? 0
+		} : void 0
+	};
+}
+/**
+* 将统一消息格式转换为 OpenAI 消息数组。
+*
+* 三种特殊消息的处理：
+* 1. tool 消息（工具结果）→ 每个结果拆分为单独的 `role: "tool"` 消息
+* 2. assistant 含 toolCalls → 附带 `tool_calls` 字段
+* 3. 其他消息 → 直接映射 role + content
+*/
+function convertMessages$1(systemPrompt, messages) {
+	const result = [{
+		role: "system",
+		content: systemPrompt
+	}];
+	for (const m of messages) if (m.role === "tool" && Array.isArray(m.content)) for (const tc of m.content) result.push({
+		role: "tool",
+		content: tc.result,
+		tool_call_id: tc.toolCallId
+	});
+	else if (m.role === "assistant" && m.toolCalls?.length) result.push({
+		role: "assistant",
+		content: typeof m.content === "string" ? m.content : null,
+		tool_calls: m.toolCalls.map((tc) => ({
+			id: tc.id,
+			type: "function",
+			function: {
+				name: tc.name,
+				arguments: JSON.stringify(tc.input)
+			}
+		}))
+	});
+	else result.push({
+		role: m.role,
+		content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+	});
+	return result;
+}
+
+//#endregion
+//#region src/core/ai-client/anthropic.ts
+/**
+* Anthropic AI 客户端 — 继承 BaseAIClient。
+*
+* 封装完整的 Anthropic Messages API 调用流程：
+* 1. buildAnthropicRequest() → 构建 HTTP 请求
+* 2. fetch() → 发送请求
+* 3. parseAnthropicResponse() → 解析响应为统一格式
+*
+* 使用示例：
+* ```ts
+* const client = new AnthropicClient({
+*   provider: "anthropic",
+*   model: "claude-sonnet-4-20250514",
+*   apiKey: "sk-ant-xxx",
+* });
+* const response = await client.chat({ systemPrompt, messages, tools });
+* ```
+*/
+var AnthropicClient = class extends BaseAIClient {
+	/** AI 客户端配置（provider / model / apiKey / baseURL） */
+	config;
+	constructor(config) {
+		super({ chatHandler: async (params) => {
+			const req = buildAnthropicRequest(this.config, params);
+			const res = await fetch(req.url, {
+				method: req.method,
+				headers: req.headers,
+				body: req.body
+			});
+			if (!res.ok) {
+				const errText = await res.text();
+				throw new Error(`AI API ${res.status}: ${errText.slice(0, 500)}`);
+			}
+			return parseAnthropicResponse(await res.json());
+		} });
+		this.config = config;
+	}
+};
+/**
+* 将统一格式的 ChatParams 转换为 Anthropic Messages API 请求。
+*
+* 关键格式差异（与 OpenAI 相比）：
+* - system prompt → body.system 字段（非消息数组元素）
+* - 工具定义 → input_schema（而非 parameters）
+* - 工具结果 → user 角色 + tool_result content block
+* - AI 工具调用 → assistant 角色 + tool_use content block
+*
+* max_tokens 策略：opus 模型 16384，其他模型 8192。
+* 认证头使用 `x-api-key`（而非 Authorization Bearer）。
+*/
+function buildAnthropicRequest(config, params) {
+	const baseURL = resolveBaseURL(config);
+	const { systemPrompt, messages, tools } = params;
+	const anthropicTools = tools?.map((t) => ({
+		name: t.name,
+		description: t.description,
+		input_schema: cleanSchema(t.schema)
+	}));
+	const anthropicMessages = convertMessages(messages);
+	const body = {
+		model: config.model,
+		max_tokens: config.model.includes("opus") ? 16384 : 8192,
+		system: systemPrompt,
+		messages: anthropicMessages
+	};
+	if (anthropicTools && anthropicTools.length > 0) body.tools = anthropicTools;
+	return {
+		url: `${baseURL}/v1/messages`,
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"x-api-key": config.apiKey,
+			"anthropic-version": "2023-06-01"
+		},
+		body: JSON.stringify(body)
+	};
+}
+/**
+* 将 Anthropic Messages API 原始响应解析为统一的 AIChatResponse。
+*
+* Anthropic 使用 content block 数组返回多种内容：
+* - type="text"     → 文本回复（可能多个，合并为一个字符串）
+* - type="tool_use" → 工具调用（id + name + input）
+*
+* Token 用量字段名也不同：input_tokens / output_tokens（非 prompt_tokens）。
+*/
+function parseAnthropicResponse(data) {
+	const d = data;
+	const text = d.content?.filter((b) => b.type === "text").map((b) => b.text).join("");
+	const toolCalls = d.content?.filter((b) => b.type === "tool_use").map((b) => ({
+		id: b.id,
+		name: b.name,
+		input: b.input
+	}));
+	return {
+		text: text || void 0,
+		toolCalls: toolCalls?.length ? toolCalls : void 0,
+		usage: d.usage ? {
+			inputTokens: d.usage.input_tokens,
+			outputTokens: d.usage.output_tokens
+		} : void 0
+	};
+}
+/**
+* 将统一消息格式转换为 Anthropic 消息数组。
+*
+* 关键差异处理：
+* 1. 过滤 system 消息（Anthropic 通过 body.system 传入）
+* 2. tool 角色消息 → user 角色 + tool_result content block
+* 3. assistant 含 toolCalls → text + tool_use content blocks
+*/
+function convertMessages(messages) {
+	return messages.filter((m) => m.role !== "system").map((m) => {
+		if (m.role === "tool" && Array.isArray(m.content)) return {
+			role: "user",
+			content: m.content.map((tc) => ({
+				type: "tool_result",
+				tool_use_id: tc.toolCallId,
+				content: tc.result
+			}))
+		};
+		if (m.role === "assistant" && m.toolCalls?.length) {
+			const content = [];
+			if (m.content && typeof m.content === "string") content.push({
+				type: "text",
+				text: m.content
+			});
+			for (const tc of m.toolCalls) content.push({
+				type: "tool_use",
+				id: tc.id,
+				name: tc.name,
+				input: tc.input
+			});
+			return {
+				role: "assistant",
+				content
+			};
+		}
+		return {
+			role: m.role,
+			content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+		};
+	});
+}
+
+//#endregion
+//#region src/core/ai-client/index.ts
+/**
+* 创建 AI 客户端（高层 API）。
+*
+* 根据 provider 自动创建对应的客户端类实例：
+* - openai / copilot → new OpenAIClient(config)
+* - anthropic        → new AnthropicClient(config)
+*
+* 返回 AIClient 接口，调用 chat() 即可与 AI 对话。
+*
+* @param config - 包含 provider、model、apiKey 等配置
+* @returns AIClient 实例（OpenAIClient 或 AnthropicClient）
+*/
+function createAIClient(config) {
+	validateProvider(config.provider);
+	switch (config.provider) {
+		case "openai":
+		case "copilot": return new OpenAIClient(config);
+		case "anthropic": return new AnthropicClient(config);
+		default: throw new Error(`Unknown AI provider: ${config.provider}. Supported: openai, copilot, anthropic`);
+	}
+}
+
+//#endregion
+//#region src/core/tool-registry.ts
+/**
+* 工具注册表实例 — 管理一组工具的注册、查询和分发。
+*
+* 每个 Agent 拥有独立的 ToolRegistry 实例，从而：
+* - Node Agent 的 exec/file 工具不会泄漏到 Web Agent
+* - Web Agent 的 dom/navigate 工具不会泄漏到 Node Agent
+* - 测试中不同 case 互不影响
+*/
+var ToolRegistry = class {
+	tools = /* @__PURE__ */ new Map();
+	/** 注册一个工具 */
+	register(tool) {
+		this.tools.set(tool.name, tool);
+	}
+	/** 获取所有已注册的工具定义列表（发给 AI，告知可用工具） */
+	getDefinitions() {
+		return Array.from(this.tools.values());
+	}
+	/**
+	* 根据工具名分发并执行工具调用。
+	* - 找到工具 → 执行 execute() → 返回结果
+	* - 找不到 → 返回错误信息（不抛异常，让 AI 知道工具不存在）
+	* - 执行出错 → 捕获异常，返回错误信息（不中断 Agent 循环）
+	*/
+	async dispatch(name, input) {
+		const tool = this.tools.get(name);
+		if (!tool) return {
+			content: `Unknown tool: ${name}`,
+			details: {
+				error: true,
+				toolName: name
+			}
+		};
+		try {
+			const params = input ?? {};
+			return await tool.execute(params);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return {
+				content: `Tool "${name}" failed: ${message}`,
+				details: {
+					error: true,
+					toolName: name,
+					message
+				}
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/core/system-prompt.ts
+/**
+* 构建系统提示词。
+* 由两部分组成：身份描述 + 可用工具列表。
+*/
+function buildSystemPrompt(params = {}) {
+	const sections = [];
+	sections.push("You are AutoPilot, an AI agent embedded in the user's web page.\nYou can interact with the page by clicking elements, filling forms, reading content, and executing JavaScript.\nAlways confirm destructive actions with the user before executing.\n\n## 操作策略\n\n每次用户请求操作页面时，系统会自动附上当前页面的 DOM 快照。\n快照中每个元素都带有 ref 属性（基于层级位置的唯一路径，如 /body/main/form/button）。\n请严格遵循以下流程：\n1. 分析快照，理解页面结构和元素层级关系。\n2. 从快照中找到目标元素，复制其 ref 路径。\n3. 将 ref 路径作为 dom 工具的 selector 参数传入。\n4. **禁止**猜测 CSS 选择器（如 'button'、'#id'、'.class'），必须使用快照中的 ref 路径。\n5. 规划操作步骤后，按顺序逐步执行。\n\n## 元素选择原则（语义优先）\n\n页面中可能存在多个文本相似的元素（如多个「发送」按钮、多个输入框）。\n**严禁仅凭元素文本匹配来选择操作对象**，必须结合以下语义上下文综合判断：\n1. **层级归属**：元素属于哪个区域/表单/卡片？从 ref 路径的父级结构判断（如 /body/main/form 下的按钮属于该表单）。\n2. **功能关联**：元素与用户意图的功能是否匹配？一个「发送」按钮在聊天区域，另一个在表单区域，要根据用户想操作的功能区来选择。\n3. **周围元素**：查看目标元素的兄弟节点和父级容器，理解它所在的功能模块。\n4. **属性辅助**：利用 id、class、placeholder、aria-label、name 等属性辅助确认元素的用途。\n5. **操作上下文**：如果用户在一系列操作中（如先填写表单再点提交），选择与前序操作同区域的元素。\n\n示例：用户说「点击发送按钮」，页面有两个按钮都叫「发送」：\n- /body/div[1]/div/chat-area/button → 聊天发送按钮\n- /body/div[1]/div/form/button → 表单提交按钮\n你必须根据用户意图和对话上下文判断应该点击哪个，而不是随意选择。");
+	const tools = params.tools ?? [];
+	if (tools.length > 0) {
+		const toolLines = tools.map((t) => `- **${t.name}**: ${t.description}`);
+		sections.push("## Available Tools\n\n" + toolLines.join("\n") + "\n\nUse tools when needed to complete the user's request.");
+	}
+	return sections.join("\n\n");
+}
+
+//#endregion
+//#region src/web/page-info-tool.ts
+/**
+* Page Info Tool — 基于 Web API 的页面信息获取工具。
+*
+* 替代 Playwright 的 getTitle/getUrl/snapshot 等。
+* 运行环境：浏览器 Content Script。
+*
+* 支持 6 种动作：
+*   get_url       — 获取当前页面 URL
+*   get_title     — 获取页面标题
+*   get_selection — 获取用户选中的文本
+*   get_viewport  — 获取视口尺寸和滚动位置
+*   snapshot      — 获取页面 DOM 结构快照（AI 可读的文本描述）
+*   query_all     — 查询所有匹配选择器的元素，返回摘要信息
+*/
+/**
+* 生成页面 DOM 快照 — 将 DOM 树转为 AI 可理解的文本描述。
+*
+* 类似 Playwright 的 ariaSnapshot()，但基于 Web API 实现。
+* 只遍历可见元素，跳过 script/style/svg 等无意义节点。
+*
+* 每个元素自动生成基于层级位置的 XPath 引用（ref），
+* AI 可以通过 ref 精确定位元素，无需猜测 CSS 选择器。
+*
+* 输出格式示例：
+*   [header] ref="/body/header"
+*     [nav] ref="/body/header/nav"
+*       [a] "首页" href="/" ref="/body/header/nav/a[1]"
+*       [a] "关于" href="/about" ref="/body/header/nav/a[2]"
+*   [main] ref="/body/main"
+*     [h1] "欢迎来到示例网站" ref="/body/main/h1"
+*     [input] type="text" placeholder="搜索..." ref="/body/main/input"
+*     [button] "搜索" id="search-btn" onclick ref="/body/main/button"
+*
+* 增强信息：
+* - id：元素的 id 属性
+* - placeholder：输入框的占位文本
+* - 事件绑定：onclick/onchange 等内联事件处理器
+* - 状态属性：disabled/checked/readonly/required 等
+*
+* @param root - 快照根元素（默认 document.body）
+* @param options - 快照选项对象，或传入数字作为 maxDepth（向后兼容）
+*/
+function generateSnapshot(root = document.body, options = {}) {
+	const opts = typeof options === "number" ? { maxDepth: options } : options;
+	const maxDepth = opts.maxDepth ?? 6;
+	const viewportOnly = opts.viewportOnly ?? true;
+	const pruneLayout = opts.pruneLayout ?? true;
+	const SKIP_TAGS = new Set([
+		"SCRIPT",
+		"STYLE",
+		"SVG",
+		"NOSCRIPT",
+		"LINK",
+		"META",
+		"BR",
+		"HR"
+	]);
+	/** 纯布局容器标签 — 智能剪枝时可能被折叠 */
+	const LAYOUT_TAGS = new Set([
+		"DIV",
+		"SPAN",
+		"SECTION",
+		"ARTICLE",
+		"ASIDE",
+		"MAIN",
+		"HEADER",
+		"FOOTER",
+		"NAV",
+		"FIGURE",
+		"FIGCAPTION"
+	]);
+	/** 视口尺寸（viewportOnly 开启时使用） */
+	const vpWidth = viewportOnly ? window.innerWidth : 0;
+	const vpHeight = viewportOnly ? window.innerHeight : 0;
+	const INTERACTIVE_ATTRS = [
+		"href",
+		"type",
+		"placeholder",
+		"value",
+		"name",
+		"role",
+		"aria-label",
+		"src",
+		"alt",
+		"title",
+		"for",
+		"action",
+		"method",
+		"target",
+		"min",
+		"max",
+		"pattern",
+		"maxlength",
+		"tabindex"
+	];
+	/** 布尔状态属性 — 只在存在时输出（无值），如 disabled、checked */
+	const BOOLEAN_ATTRS = [
+		"disabled",
+		"checked",
+		"readonly",
+		"required",
+		"selected",
+		"hidden",
+		"multiple",
+		"autofocus",
+		"open"
+	];
+	/** 内联事件属性前缀 */
+	const EVENT_PREFIX = "on";
+	/**
+	* 计算元素在父节点中同标签兄弟里的序号（1-based，XPath 规范）。
+	* 如果同标签兄弟只有一个，返回空字符串（无需索引消歧）。
+	*/
+	function getSiblingIndex(el) {
+		const parent = el.parentElement;
+		if (!parent) return "";
+		const tag = el.tagName;
+		const siblings = Array.from(parent.children).filter((c) => c.tagName === tag);
+		if (siblings.length <= 1) return "";
+		return `[${siblings.indexOf(el) + 1}]`;
+	}
+	/**
+	* 判断元素是否与视口相交（部分可见也算）。
+	* 对根级容器（depth <= 1）始终返回 true，确保不丢失顶层结构。
+	*/
+	function isInViewport(el, depth) {
+		if (!viewportOnly) return true;
+		if (depth <= 1) return true;
+		const rect = el.getBoundingClientRect();
+		if (rect.bottom < 0 || rect.top > vpHeight) return false;
+		if (rect.right < 0 || rect.left > vpWidth) return false;
+		if (rect.width === 0 && rect.height === 0) return false;
+		return true;
+	}
+	/**
+	* 判断元素是否为「无意义布局容器」（智能剪枝候选）。
+	* 满足所有条件时返回 true：
+	* 1. 标签是常见布局容器（div/span/section 等）
+	* 2. 没有 id
+	* 3. 没有交互属性（href/role/aria-label/onclick 等）
+	* 4. 没有直接文本内容
+	*/
+	function isEmptyLayoutContainer(el, directText) {
+		if (!pruneLayout) return false;
+		if (!LAYOUT_TAGS.has(el.tagName)) return false;
+		if (el.getAttribute("id")) return false;
+		if (el.getAttribute("role") || el.getAttribute("aria-label")) return false;
+		for (const attr of Array.from(el.attributes)) if (attr.name.startsWith("on")) return false;
+		if (directText) return false;
+		return true;
+	}
+	function walk(el, depth, parentPath) {
+		if (depth > maxDepth) return "";
+		if (SKIP_TAGS.has(el.tagName)) return "";
+		const style = window.getComputedStyle(el);
+		if (style.display === "none" || style.visibility === "hidden") return "";
+		if (!isInViewport(el, depth)) return "";
+		const indent = "  ".repeat(depth);
+		const tag = el.tagName.toLowerCase();
+		const currentPath = `${parentPath}/${tag}${getSiblingIndex(el)}`;
+		const attrs = [];
+		const elId = el.getAttribute("id");
+		if (elId) attrs.push(`id="${elId}"`);
+		const className = el.getAttribute("class")?.trim();
+		if (className) {
+			const classes = className.split(/\s+/).filter(Boolean).slice(0, 3).join(" ");
+			if (classes) attrs.push(`class="${classes}"`);
+		}
+		for (const attr of INTERACTIVE_ATTRS) {
+			const val = el.getAttribute(attr);
+			if (val) attrs.push(`${attr}="${val}"`);
+		}
+		for (const attr of BOOLEAN_ATTRS) if (el.hasAttribute(attr)) attrs.push(attr);
+		const events = [];
+		for (const attrObj of Array.from(el.attributes)) if (attrObj.name.startsWith(EVENT_PREFIX)) events.push(attrObj.name);
+		if (events.length > 0) attrs.push(`events=[${events.join(",")}]`);
+		const dataAttrs = [];
+		for (const attrObj of Array.from(el.attributes)) if (attrObj.name.startsWith("data-") && dataAttrs.length < 3) dataAttrs.push(`${attrObj.name}="${attrObj.value.slice(0, 30)}"`);
+		if (dataAttrs.length > 0) attrs.push(...dataAttrs);
+		if ((el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) && el.value) {
+			const currentVal = el.value.slice(0, 60);
+			if (el.getAttribute("value") !== currentVal) attrs.push(`current-value="${currentVal}"`);
+		}
+		let directText = "";
+		for (let i = 0; i < el.childNodes.length; i++) {
+			const node = el.childNodes[i];
+			if (node.nodeType === Node.TEXT_NODE) {
+				const t = node.textContent?.trim();
+				if (t) directText += t + " ";
+			}
+		}
+		directText = directText.trim();
+		if (isEmptyLayoutContainer(el, directText)) {
+			const childLines = [];
+			for (let i = 0; i < el.children.length; i++) {
+				const childResult = walk(el.children[i], depth, currentPath);
+				if (childResult) childLines.push(childResult);
+			}
+			return childLines.join("\n");
+		}
+		let line = `${indent}[${tag}]`;
+		if (directText) line += ` "${directText.slice(0, 80)}"`;
+		if (attrs.length) line += ` ${attrs.join(" ")}`;
+		line += ` ref="${currentPath}"`;
+		const lines = [line];
+		for (let i = 0; i < el.children.length; i++) {
+			const childResult = walk(el.children[i], depth + 1, currentPath);
+			if (childResult) lines.push(childResult);
+		}
+		return lines.join("\n");
+	}
+	return walk(root, 0, "") || "(空页面)";
+}
+/**
+* 查询所有匹配元素并返回摘要信息（标签、文本、关键属性）。
+*/
+function queryAllElements(selector, limit = 20) {
+	try {
+		const elements = document.querySelectorAll(selector);
+		if (elements.length === 0) return `未找到匹配 "${selector}" 的元素`;
+		const results = [`找到 ${elements.length} 个元素：`];
+		const count = Math.min(elements.length, limit);
+		for (let i = 0; i < count; i++) {
+			const el = elements[i];
+			const tag = el.tagName.toLowerCase();
+			const text = el.textContent?.trim().slice(0, 60) ?? "";
+			const id = el.id ? `#${el.id}` : "";
+			const cls = el.className && typeof el.className === "string" ? `.${el.className.split(" ").filter(Boolean).join(".")}` : "";
+			results.push(`  ${i + 1}. <${tag}${id}${cls}> "${text}"`);
+		}
+		if (elements.length > limit) results.push(`  ...还有 ${elements.length - limit} 个元素`);
+		return results.join("\n");
+	} catch (e) {
+		return `选择器语法错误: ${selector}`;
+	}
+}
+function createPageInfoTool() {
+	return {
+		name: "page_info",
+		description: [
+			"Get information about the current page.",
+			"Actions: get_url, get_title, get_selection (selected text),",
+			"get_viewport (size & scroll), snapshot (DOM structure), query_all (find all matching elements)."
+		].join(" "),
+		schema: Type.Object({
+			action: Type.String({ description: "Info action: get_url | get_title | get_selection | get_viewport | snapshot | query_all" }),
+			selector: Type.Optional(Type.String({ description: "CSS selector for query_all action" })),
+			maxDepth: Type.Optional(Type.Number({ description: "Max depth for snapshot (default: 6)" })),
+			viewportOnly: Type.Optional(Type.Boolean({ description: "Only snapshot elements visible in viewport (default: true)" })),
+			pruneLayout: Type.Optional(Type.Boolean({ description: "Collapse empty layout containers like div/span (default: true)" }))
+		}),
+		execute: async (params) => {
+			const action = params.action;
+			try {
+				switch (action) {
+					case "get_url": return { content: window.location.href };
+					case "get_title": return { content: document.title || "(无标题)" };
+					case "get_selection": return { content: (window.getSelection()?.toString().trim() ?? "") || "(未选中任何文本)" };
+					case "get_viewport": {
+						const info = {
+							viewportWidth: window.innerWidth,
+							viewportHeight: window.innerHeight,
+							scrollX: window.scrollX,
+							scrollY: window.scrollY,
+							pageWidth: document.documentElement.scrollWidth,
+							pageHeight: document.documentElement.scrollHeight
+						};
+						return { content: JSON.stringify(info, null, 2) };
+					}
+					case "snapshot": {
+						const maxDepth = params.maxDepth ?? 6;
+						const viewportOnly = params.viewportOnly ?? true;
+						const pruneLayout = params.pruneLayout ?? true;
+						return { content: generateSnapshot(document.body, {
+							maxDepth,
+							viewportOnly,
+							pruneLayout
+						}) };
+					}
+					case "query_all": {
+						const selector = params.selector;
+						if (!selector) return { content: "缺少 selector 参数" };
+						return { content: queryAllElements(selector) };
+					}
+					default: return { content: `未知的页面信息动作: ${action}` };
+				}
+			} catch (err) {
+				return {
+					content: `页面信息操作 "${action}" 失败: ${err instanceof Error ? err.message : String(err)}`,
+					details: {
+						error: true,
+						action
+					}
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/web/dom-tool.ts
+/**
+* DOM Tool — 基于 Web API 的 DOM 操作工具。
+*
+* 替代 Playwright 的 click/fill/type 等操作，直接在页面上下文中执行。
+* 运行环境：浏览器 Content Script。
+*
+* 支持 8 种动作：
+*   click        — 点击元素
+*   fill         — 填写输入框（清空后设值）
+*   type         — 逐字符模拟键入
+*   get_text     — 获取元素文本内容
+*   get_attr     — 获取元素属性值
+*   set_attr     — 设置元素属性
+*   add_class    — 添加 CSS 类名
+*   remove_class — 移除 CSS 类名
+*/
+const DEFAULT_WAIT_MS = 1e3;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* 通过快照 ref（XPath 路径）解析到 DOM 元素。
+*
+* ref 格式示例：/body/div[1]/main/form/input[2]
+* 每段为 tagName，可选 [n] 表示同标签兄弟中第 n 个（1-based）。
+*/
+function resolveRef(ref) {
+	const segments = ref.split("/").filter(Boolean);
+	let current = document.documentElement;
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		if (!current) return null;
+		const match = seg.match(/^([a-z0-9-]+)(?:\[(\d+)\])?$/i);
+		if (!match) return null;
+		const tag = match[1].toUpperCase();
+		const index = match[2] ? parseInt(match[2], 10) : 1;
+		if (i === 0 && current.tagName === tag) continue;
+		const children = Array.from(current.children).filter((c) => c.tagName === tag);
+		const sameTagCount = children.length;
+		if (sameTagCount === 0) return null;
+		if (sameTagCount === 1) current = children[0];
+		else {
+			if (index < 1 || index > sameTagCount) return null;
+			current = children[index - 1];
+		}
+	}
+	return current;
+}
+/**
+* 安全地查询 DOM 元素。
+*
+* 支持两种定位方式：
+* - ref 路径（以 "/" 开头）：使用快照生成的 XPath 精确定位
+* - CSS 选择器（其他）：传统 querySelector
+*/
+function queryElement(selector) {
+	try {
+		if (selector.startsWith("/")) {
+			const el = resolveRef(selector);
+			if (!el) return `未找到 ref "${selector}" 对应的元素`;
+			return el;
+		}
+		const el = document.querySelector(selector);
+		if (!el) return `未找到匹配 "${selector}" 的元素`;
+		return el;
+	} catch (e) {
+		return `选择器语法错误: ${selector}`;
+	}
+}
+/**
+* 在给定超时时间内轮询查找元素。
+* - 返回 Element：找到元素
+* - 返回 string：选择器语法错误
+* - 返回 null：超时未找到
+*/
+async function waitForElement(selector, timeoutMs) {
+	const start = Date.now();
+	while (Date.now() - start <= timeoutMs) {
+		const elOrError = queryElement(selector);
+		if (typeof elOrError !== "string") return elOrError;
+		if (elOrError.startsWith("选择器语法错误")) return elOrError;
+		await sleep(100);
+	}
+	return null;
+}
+function resolveWaitMs(params) {
+	const waitMs = params.waitMs;
+	if (typeof waitMs === "number" && Number.isFinite(waitMs)) return Math.max(0, Math.floor(waitMs));
+	const waitSeconds = params.waitSeconds;
+	if (typeof waitSeconds === "number" && Number.isFinite(waitSeconds)) return Math.max(0, Math.floor(waitSeconds * 1e3));
+	return DEFAULT_WAIT_MS;
+}
+/**
+* 模拟真实用户输入：触发 input、change 事件，兼容 React/Vue 等框架。
+*/
+function dispatchInputEvents(el) {
+	el.dispatchEvent(new Event("input", {
+		bubbles: true,
+		cancelable: true
+	}));
+	el.dispatchEvent(new Event("change", {
+		bubbles: true,
+		cancelable: true
+	}));
+}
+/**
+* 生成元素的可读描述，用于在操作结果中展示实际命中的 DOM 节点。
+* 格式：<tag#id.class> "文本" [attr=val, ...]
+*/
+function describeElement(el) {
+	const tag = el.tagName.toLowerCase();
+	const id = el.id ? `#${el.id}` : "";
+	const cls = el.className && typeof el.className === "string" ? el.className.trim().split(/\s+/).filter(Boolean).slice(0, 3).map((c) => `.${c}`).join("") : "";
+	const text = el.textContent?.trim().slice(0, 40) ?? "";
+	const textHint = text ? ` "${text}"` : "";
+	const hints = [];
+	for (const attr of [
+		"type",
+		"name",
+		"placeholder",
+		"href",
+		"role"
+	]) {
+		const val = el.getAttribute(attr);
+		if (val) hints.push(`${attr}=${val}`);
+	}
+	return `<${tag}${id}${cls}>${textHint}${hints.length > 0 ? ` [${hints.join(", ")}]` : ""}`;
+}
+function createDomTool() {
+	return {
+		name: "dom",
+		description: [
+			"Perform DOM operations on the current page.",
+			"Actions: click, fill, type, get_text, get_attr, set_attr, add_class, remove_class.",
+			"Use the ref path from the DOM snapshot (e.g. /body/main/button) as selector to precisely target elements.",
+			"CSS selectors are also supported but ref paths are preferred for accuracy."
+		].join(" "),
+		schema: Type.Object({
+			action: Type.String({ description: "DOM action: click | fill | type | get_text | get_attr | set_attr | add_class | remove_class" }),
+			selector: Type.String({ description: "Element ref path from snapshot (e.g. /body/main/button[2]) or CSS selector" }),
+			value: Type.Optional(Type.String({ description: "Value for fill/type/set_attr actions" })),
+			attribute: Type.Optional(Type.String({ description: "Attribute name for get_attr/set_attr actions" })),
+			className: Type.Optional(Type.String({ description: "CSS class name for add_class/remove_class" })),
+			waitMs: Type.Optional(Type.Number({ description: "Optional wait timeout in ms before action (default: 1000). Use 0 to disable waiting." })),
+			waitSeconds: Type.Optional(Type.Number({ description: "Optional wait timeout in seconds before action. Used when waitMs is not provided." }))
+		}),
+		execute: async (params) => {
+			const action = params.action;
+			const selector = params.selector;
+			const waitMs = resolveWaitMs(params);
+			if (!selector) return { content: "缺少 selector 参数" };
+			let el;
+			if (waitMs > 0) {
+				const found = await waitForElement(selector, waitMs);
+				if (typeof found === "string") return {
+					content: found,
+					details: {
+						error: true,
+						code: "INVALID_SELECTOR",
+						action,
+						selector
+					}
+				};
+				if (!found) return {
+					content: `未找到匹配 "${selector}" 的元素`,
+					details: {
+						error: true,
+						code: "ELEMENT_NOT_FOUND",
+						action,
+						selector,
+						waitMs
+					}
+				};
+				el = found;
+			} else {
+				const elOrError = queryElement(selector);
+				if (typeof elOrError === "string") return {
+					content: elOrError,
+					details: {
+						error: true,
+						code: elOrError.startsWith("未找到") ? "ELEMENT_NOT_FOUND" : "INVALID_SELECTOR",
+						action,
+						selector,
+						waitMs
+					}
+				};
+				el = elOrError;
+			}
+			try {
+				switch (action) {
+					case "click":
+						if (el instanceof HTMLElement) {
+							el.focus();
+							el.click();
+						} else el.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+						return { content: `已点击 ${describeElement(el)}` };
+					case "fill": {
+						const value = params.value;
+						if (value === void 0) return { content: "缺少 value 参数" };
+						if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+							el.focus();
+							el.value = value;
+							dispatchInputEvents(el);
+						} else if (el instanceof HTMLElement && el.isContentEditable) {
+							el.focus();
+							el.textContent = value;
+							el.dispatchEvent(new Event("input", { bubbles: true }));
+						} else return { content: `"${selector}" 不是可编辑元素` };
+						return { content: `已填写 ${describeElement(el)}: "${value}"` };
+					}
+					case "type": {
+						const value = params.value;
+						if (value === void 0) return { content: "缺少 value 参数" };
+						if (el instanceof HTMLElement) el.focus();
+						for (const char of value) {
+							el.dispatchEvent(new KeyboardEvent("keydown", {
+								key: char,
+								bubbles: true
+							}));
+							el.dispatchEvent(new KeyboardEvent("keypress", {
+								key: char,
+								bubbles: true
+							}));
+							if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) el.value += char;
+							el.dispatchEvent(new Event("input", { bubbles: true }));
+							el.dispatchEvent(new KeyboardEvent("keyup", {
+								key: char,
+								bubbles: true
+							}));
+						}
+						return { content: `已逐字输入到 ${describeElement(el)}: "${value}"` };
+					}
+					case "get_text": {
+						const text = el.textContent?.trim() ?? "";
+						return { content: `${describeElement(el)} 的文本内容：${text || "(空)"}` };
+					}
+					case "get_attr": {
+						const attribute = params.attribute;
+						if (!attribute) return { content: "缺少 attribute 参数" };
+						const attrValue = el.getAttribute(attribute);
+						return { content: `${describeElement(el)} 的 ${attribute} = ${attrValue ?? "(不存在)"}` };
+					}
+					case "set_attr": {
+						const attribute = params.attribute;
+						const value = params.value;
+						if (!attribute || value === void 0) return { content: "缺少 attribute 或 value 参数" };
+						el.setAttribute(attribute, value);
+						return { content: `已设置 ${describeElement(el)} 的 ${attribute}="${value}"` };
+					}
+					case "add_class": {
+						const className = params.className;
+						if (!className) return { content: "缺少 className 参数" };
+						el.classList.add(className);
+						return { content: `已添加 class "${className}" 到 ${describeElement(el)}` };
+					}
+					case "remove_class": {
+						const className = params.className;
+						if (!className) return { content: "缺少 className 参数" };
+						el.classList.remove(className);
+						return { content: `已移除 ${describeElement(el)} 的 class "${className}"` };
+					}
+					default: return { content: `未知的 DOM 动作: ${action}` };
+				}
+			} catch (err) {
+				return {
+					content: `DOM 操作 "${action}" 失败: ${err instanceof Error ? err.message : String(err)}`,
+					details: {
+						error: true,
+						action,
+						selector
+					}
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/web/navigate-tool.ts
+/**
+* Navigate Tool — 基于 Web API 的页面导航工具。
+*
+* 替代 Playwright 的 goto/goBack/goForward/reload。
+* 运行环境：浏览器 Content Script。
+*
+* 支持 5 种动作：
+*   goto    — 跳转到指定 URL
+*   back    — 浏览器后退
+*   forward — 浏览器前进
+*   reload  — 刷新当前页面
+*   scroll  — 滚动页面到指定位置或元素
+*/
+function createNavigateTool() {
+	return {
+		name: "navigate",
+		description: ["Navigate the current page.", "Actions: goto (open URL), back, forward, reload, scroll (to position or element)."].join(" "),
+		schema: Type.Object({
+			action: Type.String({ description: "Navigation action: goto | back | forward | reload | scroll" }),
+			url: Type.Optional(Type.String({ description: "URL for goto action" })),
+			selector: Type.Optional(Type.String({ description: "CSS selector for scroll action (scrolls element into view)" })),
+			x: Type.Optional(Type.Number({ description: "Horizontal scroll position (pixels)" })),
+			y: Type.Optional(Type.Number({ description: "Vertical scroll position (pixels)" }))
+		}),
+		execute: async (params) => {
+			const action = params.action;
+			try {
+				switch (action) {
+					case "goto": {
+						const url = params.url;
+						if (!url) return { content: "缺少 url 参数" };
+						window.location.href = url;
+						return { content: `正在导航到 ${url}` };
+					}
+					case "back":
+						window.history.back();
+						return { content: "已后退" };
+					case "forward":
+						window.history.forward();
+						return { content: "已前进" };
+					case "reload":
+						window.location.reload();
+						return { content: "正在刷新页面" };
+					case "scroll": {
+						const selector = params.selector;
+						if (selector) {
+							const el = document.querySelector(selector);
+							if (!el) return { content: `未找到元素 "${selector}"` };
+							el.scrollIntoView({
+								behavior: "smooth",
+								block: "center"
+							});
+							return { content: `已滚动到元素 "${selector}"` };
+						}
+						const x = params.x ?? 0;
+						const y = params.y ?? 0;
+						window.scrollTo({
+							left: x,
+							top: y,
+							behavior: "smooth"
+						});
+						return { content: `已滚动到 (${x}, ${y})` };
+					}
+					default: return { content: `未知的导航动作: ${action}` };
+				}
+			} catch (err) {
+				return {
+					content: `导航操作 "${action}" 失败: ${err instanceof Error ? err.message : String(err)}`,
+					details: {
+						error: true,
+						action
+					}
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/web/wait-tool.ts
+/**
+* Wait Tool — 基于 MutationObserver 的元素等待工具。
+*
+* 替代 Playwright 的 waitForSelector/waitForNavigation。
+* 运行环境：浏览器 Content Script。
+*
+* 支持 3 种动作：
+*   wait_for_selector  — 等待匹配选择器的元素出现
+*   wait_for_hidden    — 等待元素消失或隐藏
+*   wait_for_text      — 等待页面中出现指定文本
+*/
+/** 默认超时时间（毫秒） */
+const DEFAULT_TIMEOUT = 1e4;
+/**
+* 通过 MutationObserver 等待元素出现。
+* 先检查元素是否已存在，不存在则监听 DOM 变化直到出现或超时。
+*/
+function waitForSelector(selector, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		const existing = document.querySelector(selector);
+		if (existing) {
+			resolve(existing);
+			return;
+		}
+		const timer = setTimeout(() => {
+			observer.disconnect();
+			reject(/* @__PURE__ */ new Error(`等待 "${selector}" 超时 (${timeoutMs}ms)`));
+		}, timeoutMs);
+		const observer = new MutationObserver(() => {
+			const el = document.querySelector(selector);
+			if (el) {
+				clearTimeout(timer);
+				observer.disconnect();
+				resolve(el);
+			}
+		});
+		observer.observe(document.body, {
+			childList: true,
+			subtree: true,
+			attributes: true
+		});
+	});
+}
+/**
+* 等待元素消失或变为不可见。
+*/
+function waitForHidden(selector, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		const existing = document.querySelector(selector);
+		if (!existing) {
+			resolve();
+			return;
+		}
+		const style = window.getComputedStyle(existing);
+		if (style.display === "none" || style.visibility === "hidden") {
+			resolve();
+			return;
+		}
+		const timer = setTimeout(() => {
+			observer.disconnect();
+			reject(/* @__PURE__ */ new Error(`等待 "${selector}" 消失超时 (${timeoutMs}ms)`));
+		}, timeoutMs);
+		const observer = new MutationObserver(() => {
+			const el = document.querySelector(selector);
+			if (!el) {
+				clearTimeout(timer);
+				observer.disconnect();
+				resolve();
+				return;
+			}
+			const s = window.getComputedStyle(el);
+			if (s.display === "none" || s.visibility === "hidden") {
+				clearTimeout(timer);
+				observer.disconnect();
+				resolve();
+			}
+		});
+		observer.observe(document.body, {
+			childList: true,
+			subtree: true,
+			attributes: true,
+			attributeFilter: [
+				"style",
+				"class",
+				"hidden"
+			]
+		});
+	});
+}
+/**
+* 等待页面中出现指定文本。
+*/
+function waitForText(text, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		if (document.body.textContent?.includes(text)) {
+			resolve();
+			return;
+		}
+		const timer = setTimeout(() => {
+			observer.disconnect();
+			reject(/* @__PURE__ */ new Error(`等待文本 "${text}" 出现超时 (${timeoutMs}ms)`));
+		}, timeoutMs);
+		const observer = new MutationObserver(() => {
+			if (document.body.textContent?.includes(text)) {
+				clearTimeout(timer);
+				observer.disconnect();
+				resolve();
+			}
+		});
+		observer.observe(document.body, {
+			childList: true,
+			subtree: true,
+			characterData: true
+		});
+	});
+}
+function createWaitTool() {
+	return {
+		name: "wait",
+		description: [
+			"Wait for DOM changes on the current page.",
+			"Actions: wait_for_selector (element appears), wait_for_hidden (element disappears),",
+			"wait_for_text (specific text appears in page)."
+		].join(" "),
+		schema: Type.Object({
+			action: Type.String({ description: "Wait action: wait_for_selector | wait_for_hidden | wait_for_text" }),
+			selector: Type.Optional(Type.String({ description: "CSS selector for wait_for_selector/wait_for_hidden" })),
+			text: Type.Optional(Type.String({ description: "Text to wait for in wait_for_text" })),
+			timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds (default: 10000)" }))
+		}),
+		execute: async (params) => {
+			const action = params.action;
+			const timeoutMs = params.timeout ?? DEFAULT_TIMEOUT;
+			try {
+				switch (action) {
+					case "wait_for_selector": {
+						const selector = params.selector;
+						if (!selector) return { content: "缺少 selector 参数" };
+						await waitForSelector(selector, timeoutMs);
+						return { content: `元素 "${selector}" 已出现` };
+					}
+					case "wait_for_hidden": {
+						const selector = params.selector;
+						if (!selector) return { content: "缺少 selector 参数" };
+						await waitForHidden(selector, timeoutMs);
+						return { content: `元素 "${selector}" 已消失` };
+					}
+					case "wait_for_text": {
+						const text = params.text;
+						if (!text) return { content: "缺少 text 参数" };
+						await waitForText(text, timeoutMs);
+						return { content: `文本 "${text}" 已出现` };
+					}
+					default: return { content: `未知的等待动作: ${action}` };
+				}
+			} catch (err) {
+				return {
+					content: `等待操作 "${action}" 失败: ${err instanceof Error ? err.message : String(err)}`,
+					details: {
+						error: true,
+						action
+					}
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/web/evaluate-tool.ts
+/**
+* Evaluate Tool — 在页面上下文中执行任意 JavaScript 表达式。
+*
+* 替代 Playwright 的 page.evaluate()。
+* 运行环境：浏览器 Content Script。
+*
+* 这是最灵活的工具 — 当其他 tools 无法满足需求时，
+* AI 可以直接编写 JS 代码来操作页面。
+*
+* 支持 2 种动作：
+*   evaluate        — 执行 JS 表达式并返回结果
+*   evaluate_handle — 执行 JS 并返回序列化的 DOM 信息
+*/
+/**
+* 安全执行 JS 表达式，捕获错误并序列化结果。
+*/
+function safeEvaluate(expression) {
+	try {
+		return { result: new Function(`"use strict"; return (${expression});`)() };
+	} catch (err) {
+		try {
+			return { result: new Function(`"use strict"; ${expression}`)() };
+		} catch (err2) {
+			return { error: err2 instanceof Error ? err2.message : String(err2) };
+		}
+	}
+}
+/**
+* 将执行结果序列化为字符串（处理 DOM 元素、循环引用等）。
+*/
+function serializeResult(value) {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (value instanceof Element) return `<${value.tagName.toLowerCase()}${value.id ? `#${value.id}` : ""}> "${value.textContent?.trim().slice(0, 100) ?? ""}"`;
+	if (value instanceof NodeList || value instanceof HTMLCollection) {
+		const items = Array.from(value).map((el, i) => `  ${i}: ${serializeResult(el)}`);
+		return `[${value.length} elements]\n${items.join("\n")}`;
+	}
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+}
+function createEvaluateTool() {
+	return {
+		name: "evaluate",
+		description: [
+			"Execute JavaScript code in the current page context.",
+			"Use this when other tools cannot accomplish the task.",
+			"Can access document, window, and all page APIs."
+		].join(" "),
+		schema: Type.Object({ expression: Type.String({ description: "JavaScript expression or code block to execute. Has access to document, window, etc." }) }),
+		execute: async (params) => {
+			const expression = params.expression;
+			if (!expression) return { content: "缺少 expression 参数" };
+			const { result, error } = safeEvaluate(expression);
+			if (error) return {
+				content: `JS 执行错误: ${error}`,
+				details: {
+					error: true,
+					expression
+				}
+			};
+			return { content: serializeResult(result) };
+		}
+	};
+}
+
+//#endregion
+//#region src/web/messaging.ts
+/**
+* 创建代理执行器 — 在 Service Worker 端使用。
+*
+* 它不直接执行 DOM 操作，而是通过 chrome.tabs.sendMessage
+* 把调用请求发给当前活动 tab 的 content script 执行。
+*
+* @returns execute 函数，签名与 ToolDefinition.execute 相同
+*/
+function createProxyExecutor() {
+	return async (toolName, params) => {
+		const callId = `${toolName}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+		const [tab] = await chrome.tabs.query({
+			active: true,
+			currentWindow: true
+		});
+		if (!tab?.id) return { content: "错误：没有活动的浏览器标签页" };
+		const message = {
+			type: "AUTOPILOT_TOOL_CALL",
+			toolName,
+			params,
+			callId
+		};
+		try {
+			return (await chrome.tabs.sendMessage(tab.id, message)).result;
+		} catch (err) {
+			return {
+				content: `工具调用失败（content script 可能未加载）: ${err instanceof Error ? err.message : String(err)}`,
+				details: {
+					error: true,
+					toolName
+				}
+			};
+		}
+	};
+}
+/**
+* 在 Content Script 端注册工具执行处理器。
+*
+* 监听来自 Service Worker 的 AUTOPILOT_TOOL_CALL 消息，
+* 根据 toolName 找到对应的执行函数，执行后返回结果。
+*
+* @param executors 工具名称 → 执行函数的映射
+*/
+function registerToolHandler(executors) {
+	chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+		const msg = message;
+		if (msg?.type !== "AUTOPILOT_TOOL_CALL") return false;
+		const executor = executors.get(msg.toolName);
+		if (!executor) {
+			sendResponse({
+				type: "AUTOPILOT_TOOL_RESULT",
+				callId: msg.callId,
+				result: { content: `未知工具: ${msg.toolName}` }
+			});
+			return true;
+		}
+		executor(msg.params).then((result) => {
+			sendResponse({
+				type: "AUTOPILOT_TOOL_RESULT",
+				callId: msg.callId,
+				result
+			});
+		}).catch((err) => {
+			sendResponse({
+				type: "AUTOPILOT_TOOL_RESULT",
+				callId: msg.callId,
+				result: {
+					content: `工具 ${msg.toolName} 执行异常: ${err instanceof Error ? err.message : String(err)}`,
+					details: { error: true }
+				}
+			});
+		});
+		return true;
+	});
+}
+
+//#endregion
+//#region src/web/index.ts
+/**
+* WebAgent — 浏览器端 AI Agent 类。
+*
+* 封装了完整的 Agent 能力，可在浏览器中独立运行：
+* - 对话（chat）   → 发消息、获取 AI 回复
+* - 工具注册       → 注册内置 Web 工具或自定义工具
+* - 决策循环       → 复用 core/agent-loop.ts 的通用逻辑
+* - AI 连接        → 复用 core/ai-client.ts（基于 fetch，跨平台）
+*
+* 使用示例：
+* ```ts
+* const agent = new WebAgent({ token: "ghp_xxx", provider: "copilot" });
+* agent.registerTools();     // 注册内置 Web 工具
+* agent.callbacks.onText = (text) => console.log(text);
+*
+* const result = await agent.chat("获取页面标题");
+* console.log(result.reply);
+* ```
+*
+* 架构位置：
+*   ┌──────────────────────────────────────────────────┐
+*   │  WebAgent（浏览器端入口）                         │
+*   │  ┌──────────┐  ┌────────────┐  ┌──────────────┐ │
+*   │  │ core/    │  │ core/      │  │ web/       │ │
+*   │  │ ai-client│  │ agent-loop │  │ (DOM/导航等)│ │
+*   │  │ (fetch)  │  │ (通用循环) │  │              │ │
+*   │  └──────────┘  └────────────┘  └──────────────┘ │
+*   └──────────────────────────────────────────────────┘
+*/
+var WebAgent = class {
+	/** 用户传入的自定义 AI 客户端实例（优先级高于 token/provider） */
+	client;
+	token;
+	provider;
+	model;
+	baseURL;
+	dryRun;
+	maxRounds;
+	customSystemPrompt;
+	/** 多轮对话记忆开关 */
+	memory;
+	/** 对话历史（memory 开启时自动累积） */
+	history = [];
+	/** 自动快照开关 */
+	autoSnapshot;
+	/** 快照选项 */
+	snapshotOptions;
+	/** 工具注册表实例 — 每个 WebAgent 拥有独立的工具集 */
+	registry = new ToolRegistry();
+	/** 事件回调 — 绑定后可实时获取 Agent 进度，用于 UI 展示 */
+	callbacks = {};
+	constructor(options) {
+		this.client = options.client;
+		this.token = options.token || "";
+		this.provider = options.provider ?? "copilot";
+		this.model = options.model ?? "gpt-4o";
+		this.baseURL = options.baseURL;
+		this.dryRun = options.dryRun ?? false;
+		this.maxRounds = options.maxRounds ?? 10;
+		this.customSystemPrompt = options.systemPrompt;
+		this.memory = options.memory ?? false;
+		this.autoSnapshot = options.autoSnapshot ?? true;
+		this.snapshotOptions = options.snapshotOptions ?? {};
+	}
+	/** 注册所有内置 Web 工具（dom, navigate, page_info, wait, evaluate） */
+	registerTools() {
+		this.registry.register(createDomTool());
+		this.registry.register(createNavigateTool());
+		this.registry.register(createPageInfoTool());
+		this.registry.register(createWaitTool());
+		this.registry.register(createEvaluateTool());
+	}
+	/** 注册一个自定义工具 */
+	registerTool(tool) {
+		this.registry.register(tool);
+	}
+	/** 获取所有已注册的工具定义列表 */
+	getTools() {
+		return this.registry.getDefinitions();
+	}
+	/** 设置 API Token */
+	setToken(token) {
+		this.token = token;
+	}
+	/**
+	* 设置自定义 AI 客户端实例。
+	*
+	* 传入后将优先使用该实例进行对话，忽略 token / provider / model / baseURL。
+	* 传入 undefined 可恢复使用内置客户端。
+	*/
+	setClient(client) {
+		this.client = client;
+	}
+	/** 设置 AI 提供商 */
+	setProvider(provider) {
+		this.provider = provider;
+	}
+	/** 设置模型 */
+	setModel(model) {
+		this.model = model;
+	}
+	/** 切换干运行模式 */
+	setDryRun(enabled) {
+		this.dryRun = enabled;
+	}
+	/** 设置自定义系统提示词 */
+	setSystemPrompt(prompt) {
+		this.customSystemPrompt = prompt;
+	}
+	/** 开启或关闭多轮对话记忆 */
+	setMemory(enabled) {
+		this.memory = enabled;
+		if (!enabled) this.history = [];
+	}
+	/** 获取当前记忆开关状态 */
+	getMemory() {
+		return this.memory;
+	}
+	/** 开启或关闭自动快照 */
+	setAutoSnapshot(enabled) {
+		this.autoSnapshot = enabled;
+	}
+	/** 获取当前自动快照开关状态 */
+	getAutoSnapshot() {
+		return this.autoSnapshot;
+	}
+	/** 设置快照选项（视口裁剪、智能剪枝等） */
+	setSnapshotOptions(options) {
+		this.snapshotOptions = options;
+	}
+	/** 获取当前快照选项 */
+	getSnapshotOptions() {
+		return { ...this.snapshotOptions };
+	}
+	/** 清空对话历史（不影响记忆开关） */
+	clearHistory() {
+		this.history = [];
+	}
+	/**
+	* 发送消息并获取 AI 回复（含完整工具调用循环）。
+	*
+	* 内部流程（全部复用 core）：
+	* 1. createAIClient() → 创建 fetch AI 客户端
+	* 2. buildSystemPrompt() → 构建系统提示词
+	* 3. executeAgentLoop() → 执行决策循环
+	* 4. callbacks → 实时通知 UI
+	*/
+	async chat(message) {
+		const client = this.client ?? this.createBuiltinClient();
+		let systemPrompt = this.customSystemPrompt ?? buildSystemPrompt({ tools: this.registry.getDefinitions() });
+		if (this.autoSnapshot) try {
+			const snapshot = generateSnapshot(document.body, {
+				maxDepth: 8,
+				...this.snapshotOptions
+			});
+			this.callbacks.onSnapshot?.(snapshot);
+			systemPrompt += [
+				"\n\n## 当前页面 DOM 快照（实时生成）\n",
+				"每个元素末尾的 ref=\"...\" 是基于层级位置生成的唯一路径。",
+				"操作元素时，必须使用 ref 路径作为 selector 参数（如 /body/main/form/input）。\n",
+				"```",
+				snapshot,
+				"```\n",
+				"## 操作规则\n",
+				"1. 从快照中找到目标元素，复制其 ref 路径。",
+				"2. 将 ref 路径作为 dom 工具的 selector 参数传入。",
+				"3. 禁止猜测 CSS 选择器（如 \"button\"、\"#send\"），必须使用快照中的 ref。",
+				"4. 如果快照中看不到目标元素，先滚动页面或调整 maxDepth 获取更深的快照。",
+				"5. 先规划操作步骤，再按顺序逐步执行。",
+				"6. **语义选择**：当页面存在多个文本相同的元素时，严禁随意选择。必须根据 ref 路径的父级结构、周围兄弟元素、所在功能区域来判断哪个才是用户意图中的目标。例如聊天区的\"发送\"和表单的\"提交\"是不同功能，要结合用户当前操作的上下文来选择正确的元素。"
+			].join("\n");
+		} catch {}
+		const result = await executeAgentLoop({
+			client,
+			registry: this.registry,
+			systemPrompt,
+			message,
+			history: this.memory ? this.history : void 0,
+			dryRun: this.dryRun,
+			maxRounds: this.maxRounds,
+			callbacks: this.callbacks
+		});
+		if (this.memory) this.history = result.messages;
+		return result;
+	}
+	/**
+	* 创建内置 AI 客户端（基于 token / provider / model 配置）。
+	*
+	* @throws 未设置 token 时抛出 Error
+	*/
+	createBuiltinClient() {
+		if (!this.token) throw new Error("未设置 Token，请先调用 setToken() 或传入自定义 client");
+		return createAIClient({
+			provider: this.provider,
+			model: this.model,
+			apiKey: this.token,
+			baseURL: this.baseURL
+		});
+	}
+};
+
+//#endregion
+export { WebAgent, createDomTool, createEvaluateTool, createNavigateTool, createPageInfoTool, createProxyExecutor, createWaitTool, generateSnapshot, registerToolHandler };
+//# sourceMappingURL=index.mjs.map