@webskill/sdk 0.0.1

package/dist/browser.js

@@ -0,0 +1,856 @@
+import { D as normalizeToolContent, E as mergeCatalogEntries, I as SkillDiscovery, O as parseBridgeRequest, R as WebSkillError, f as MockLlmClient, h as ProgressiveRouter, i as AgentLoop, m as OpenAiCompatibleClient, o as FsArtifactStore, s as FsMemoryStore, x as bridgeError, z as buildCatalog } from "./dist-B_ldNWwT.js";
+
+//#region ../browser/dist/index.js
+/** 检测当前环境是否可用 OPFS（navigator.storage.getDirectory） */
+function isOpfsAvailable(globalScope) {
+	return typeof (globalScope ?? globalThis).navigator?.storage?.getDirectory === "function";
+}
+const isDomException = (e, name) => e instanceof DOMException && e.name === name;
+const mapError = (e, path) => {
+	if (isDomException(e, "NotFoundError")) return new WebSkillError("FS_NOT_FOUND", `Path not found: ${path}`);
+	if (isDomException(e, "NotAllowedError")) return new WebSkillError("FS_PERMISSION_DENIED", `Permission denied: ${path}`, e);
+	if (e instanceof WebSkillError) return e;
+	return new WebSkillError("FS_NOT_FOUND", `OPFS operation failed at ${path}: ${String(e)}`, e);
+};
+/** 基于 navigator.storage.getDirectory() 的 FileSystemProvider（路径一律 POSIX 风格） */
+var OpfsProvider = class {
+	kind = "opfs";
+	#rootName;
+	#rootPromise;
+	constructor(deps = {}) {
+		this.#rootName = deps.rootName ?? "webskill";
+	}
+	async #root() {
+		this.#rootPromise ??= (async () => {
+			return (await navigator.storage.getDirectory()).getDirectoryHandle(this.#rootName, { create: true });
+		})();
+		return this.#rootPromise;
+	}
+	#segments(p) {
+		return p.replace(/\\/g, "/").split("/").filter((s) => s !== "" && s !== ".");
+	}
+	async #walkDir(p, create) {
+		let dir = await this.#root();
+		for (const segment of this.#segments(p)) dir = await dir.getDirectoryHandle(segment, { create });
+		return dir;
+	}
+	async #walkFile(p) {
+		const segments = this.#segments(p);
+		const name = segments.pop();
+		if (!name) throw new WebSkillError("FS_NOT_FOUND", `Path not found: ${p}`);
+		return (await this.#walkDir(`/${segments.join("/")}`, false)).getFileHandle(name);
+	}
+	async #wrap(p, op) {
+		try {
+			return await op();
+		} catch (e) {
+			throw mapError(e, p);
+		}
+	}
+	async readText(p) {
+		return this.#wrap(p, async () => {
+			return (await (await this.#walkFile(p)).getFile()).text();
+		});
+	}
+	async writeText(p, content) {
+		await this.writeBinary(p, new TextEncoder().encode(content));
+	}
+	async readBinary(p) {
+		return this.#wrap(p, async () => {
+			const handle = await this.#walkFile(p);
+			return new Uint8Array(await (await handle.getFile()).arrayBuffer());
+		});
+	}
+	async writeBinary(p, content) {
+		await this.#wrap(p, async () => {
+			const segments = this.#segments(p);
+			const name = segments.pop();
+			if (!name) throw new WebSkillError("FS_NOT_FOUND", `Invalid file path: ${p}`);
+			const writable = await (await (await this.#walkDir(`/${segments.join("/")}`, true)).getFileHandle(name, { create: true })).createWritable();
+			await writable.write(content);
+			await writable.close();
+		});
+	}
+	async exists(p) {
+		try {
+			await this.stat(p);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async stat(p) {
+		return this.#wrap(p, async () => {
+			if (this.#segments(p).length === 0) return {
+				path: "/",
+				type: "directory"
+			};
+			try {
+				const file = await (await this.#walkFile(p)).getFile();
+				return {
+					path: p,
+					type: "file",
+					size: file.size,
+					mtimeMs: file.lastModified
+				};
+			} catch (e) {
+				if (isDomException(e, "NotFoundError") || isDomException(e, "TypeMismatchError")) return {
+					path: p,
+					type: "directory",
+					name: (await this.#walkDir(p, false)).name
+				};
+				throw e;
+			}
+		});
+	}
+	async list(p) {
+		return this.#wrap(p, async () => {
+			const dir = await this.#walkDir(p, false);
+			const out = [];
+			for await (const [name, handle] of dir.entries()) {
+				const base = p.replace(/\/+$/, "");
+				out.push({
+					path: `${base}/${name}`,
+					type: handle.kind === "directory" ? "directory" : "file"
+				});
+			}
+			return out;
+		});
+	}
+	async mkdir(p) {
+		await this.#wrap(p, async () => {
+			await this.#walkDir(p, true);
+		});
+	}
+	async remove(p, options) {
+		await this.#wrap(p, async () => {
+			const segments = this.#segments(p);
+			const name = segments.pop();
+			if (!name) throw new WebSkillError("FS_NOT_FOUND", `Invalid path: ${p}`);
+			await (await this.#walkDir(`/${segments.join("/")}`, false)).removeEntry(name, { recursive: options?.recursive ?? false });
+		});
+	}
+};
+/**
+* Worker 引导源码（字符串 → Blob URL → new Worker(url, {type:'module'})）。
+* 注意：内容为纯 JS，不能含反引号与 ${ 占位（外层用模板字符串内嵌）。
+*
+* 协议（宿主 ↔ Worker）：
+* - 宿主 → Worker：{type:'load', id, source} 请求加载脚本定义
+* - 宿主 → Worker：{type:'execute', id, skillName, runId, source, args} 请求执行
+* - Worker → 宿主：{type:'load-result', id, ok, definition?, error?}
+* - Worker → 宿主：{type:'execute-result', id, ok, value?, stdout, stderr, error?}
+* - Worker → 宿主：{type:'bridge', request} 能力桥 RPC（readReference/writeArtifact/confirm）
+* - 宿主 → Worker：{type:'bridge-response', response}
+*
+* .js 源码经 data: URL 动态 import；主线程从不 import 技能脚本。
+*/
+const WORKER_BOOTSTRAP_SOURCE = String.raw`
+'use strict';
+
+var pending = new Map();
+var bridgeSeq = 0;
+
+function loadModule(source) {
+  var url = 'data:text/javascript;charset=utf-8,' + encodeURIComponent(source);
+  return import(url);
+}
+
+function postError(type, id, code, message, extra) {
+  var msg = { type: type, id: id, ok: false, error: { code: code, message: message } };
+  if (extra) Object.assign(msg, extra);
+  self.postMessage(msg);
+}
+
+function callCapability(kind, payload) {
+  var request = Object.assign({ kind: kind, id: 'br-' + (++bridgeSeq) }, payload);
+  return new Promise(function (resolve, reject) {
+    pending.set(request.id, { resolve: resolve, reject: reject });
+    self.postMessage({ type: 'bridge', request: request });
+  }).then(function (response) {
+    if (!response.ok) {
+      var err = new Error((response.error && response.error.message) || 'capability call failed');
+      err.code = (response.error && response.error.code) || 'TOOL_EXECUTION_FAILED';
+      throw err;
+    }
+    return response.value;
+  });
+}
+
+function makeContext(msg) {
+  return {
+    skillName: msg.skillName,
+    runId: msg.runId,
+    readReference: function (path) {
+      return callCapability('readReference', { path: path });
+    },
+    writeArtifact: function (path, content, options) {
+      return callCapability('writeArtifact', {
+        path: path,
+        content: typeof content === 'string' ? content : Array.from(content || []),
+        mimeType: options && options.mimeType,
+      });
+    },
+    confirm: function (message) {
+      return callCapability('confirm', { message: message });
+    },
+  };
+}
+
+self.onmessage = async function (event) {
+  var msg = event.data;
+  if (!msg || typeof msg !== 'object') return;
+
+  if (msg.type === 'bridge-response') {
+    var entry = pending.get(msg.response && msg.response.id);
+    if (entry) {
+      pending.delete(msg.response.id);
+      entry.resolve(msg.response);
+    }
+    return;
+  }
+
+  if (msg.type === 'load') {
+    try {
+      var mod = await loadModule(msg.source);
+      self.postMessage({
+        type: 'load-result',
+        id: msg.id,
+        ok: true,
+        definition: {
+          description: typeof mod.description === 'string' ? mod.description : undefined,
+          inputSchema: mod.inputSchema !== undefined ? mod.inputSchema : undefined,
+          hasRun: typeof mod.run === 'function',
+        },
+      });
+    } catch (e) {
+      postError('load-result', msg.id, 'TOOL_EXECUTION_FAILED', String((e && e.message) || e));
+    }
+    return;
+  }
+
+  if (msg.type === 'execute') {
+    var stdout = [];
+    var stderr = [];
+    var originals = {
+      log: console.log, info: console.info, debug: console.debug,
+      warn: console.warn, error: console.error,
+    };
+    console.log = console.info = console.debug = function () {
+      stdout.push(Array.from(arguments).map(String).join(' '));
+    };
+    console.warn = console.error = function () {
+      stderr.push(Array.from(arguments).map(String).join(' '));
+    };
+    try {
+      var mod2 = await loadModule(msg.source);
+      if (typeof mod2.run !== 'function') {
+        throw new Error('Script does not export a run function');
+      }
+      var value = await mod2.run(msg.args, makeContext(msg));
+      self.postMessage({
+        type: 'execute-result', id: msg.id, ok: true,
+        value: value === undefined ? null : value,
+        stdout: stdout, stderr: stderr,
+      });
+    } catch (e2) {
+      postError(
+        'execute-result', msg.id,
+        (e2 && e2.code) || 'TOOL_EXECUTION_FAILED',
+        String((e2 && e2.message) || e2),
+        { stdout: stdout, stderr: stderr },
+      );
+    } finally {
+      console.log = originals.log; console.info = originals.info; console.debug = originals.debug;
+      console.warn = originals.warn; console.error = originals.error;
+    }
+  }
+};
+`;
+const defaultWorkerFactory = () => {
+	const blob = new Blob([WORKER_BOOTSTRAP_SOURCE], { type: "text/javascript" });
+	const url = URL.createObjectURL(blob);
+	const worker = new Worker(url, { type: "module" });
+	URL.revokeObjectURL(url);
+	return worker;
+};
+const baseName = (p) => p.split("/").pop() ?? p;
+const messageOf = (e) => e instanceof Error ? e.message : String(e);
+/**
+* Web Worker 脚本沙箱执行器：loadDefinition 与 execute 都在 Worker 内完成，
+* 主线程从不 import 技能脚本；每次执行独立 Worker；超时 terminate 强杀。
+*/
+var BrowserWorkerScriptExecutor = class {
+	#fs;
+	#workerFactory;
+	#capabilities;
+	constructor(deps) {
+		this.#fs = deps.fs;
+		this.#workerFactory = deps.workerFactory ?? defaultWorkerFactory;
+		this.#capabilities = {
+			readReference: deps.capabilities?.readReference ?? true,
+			writeArtifact: deps.capabilities?.writeArtifact ?? true,
+			confirm: deps.capabilities?.confirm ?? true
+		};
+	}
+	/** 定位 scripts/<name>.js；.ts → TOOL_UNSUPPORTED（D4）；冲突/缺失结构化报错 */
+	async #locateScript(skillRoot, scriptName) {
+		const jsPath = `${skillRoot}/scripts/${scriptName}.js`;
+		const tsPath = `${skillRoot}/scripts/${scriptName}.ts`;
+		const [hasJs, hasTs] = await Promise.all([this.#fs.exists(jsPath), this.#fs.exists(tsPath)]);
+		if (hasJs && hasTs) throw new WebSkillError("TOOL_EXECUTION_FAILED", `Script "${scriptName}" is ambiguous: both .ts and .js exist under ${skillRoot}/scripts`);
+		if (hasTs) throw new WebSkillError("TOOL_UNSUPPORTED", `Browser sandbox executes .js only; "${scriptName}.ts" needs transpilation (deferred: D4)`);
+		if (!hasJs) throw new WebSkillError("TOOL_NOT_FOUND", `Script "${scriptName}" not found under ${skillRoot}/scripts`);
+		return {
+			path: jsPath,
+			source: await this.#fs.readText(jsPath)
+		};
+	}
+	async loadDefinition(skillRoot, scriptName) {
+		const script = await this.#locateScript(skillRoot, scriptName);
+		const skillName = baseName(skillRoot);
+		const worker = this.#workerFactory();
+		try {
+			const data = await this.#request(worker, {
+				type: "load",
+				id: "load-1",
+				source: script.source
+			});
+			if (!data.ok) throw new WebSkillError("TOOL_EXECUTION_FAILED", `Failed to load script "${scriptName}": ${data.error?.message ?? "unknown error"}`);
+			return {
+				name: `${skillName}__${scriptName}`,
+				description: data.definition?.description,
+				inputSchema: data.definition?.inputSchema,
+				source: "script",
+				skillName
+			};
+		} finally {
+			worker.terminate();
+		}
+	}
+	async execute(input) {
+		const { skillRoot, scriptName, args, context, timeoutMs } = input;
+		let script;
+		try {
+			script = await this.#locateScript(skillRoot, scriptName);
+		} catch (e) {
+			return {
+				ok: false,
+				content: [],
+				error: {
+					code: e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED",
+					message: messageOf(e)
+				}
+			};
+		}
+		const worker = this.#workerFactory();
+		try {
+			const response = await this.#request(worker, {
+				type: "execute",
+				id: "exec-1",
+				skillName: context.skillName,
+				runId: context.runId,
+				source: script.source,
+				args
+			}, timeoutMs, (bridgeRequest) => this.#handleBridge(bridgeRequest, context));
+			if (!response.ok) {
+				const stderrSummary = response.stderr?.length ? ` | stderr: ${response.stderr.join(" | ").slice(0, 500)}` : "";
+				return {
+					ok: false,
+					content: [],
+					error: {
+						code: response.error?.code ?? "TOOL_EXECUTION_FAILED",
+						message: `${response.error?.message ?? "script execution failed"}${stderrSummary}`
+					}
+				};
+			}
+			const content = normalizeToolContent(response.value);
+			if (response.stdout?.length) content.push({
+				type: "text",
+				text: response.stdout.join("\n")
+			});
+			return {
+				ok: true,
+				content
+			};
+		} catch (e) {
+			return {
+				ok: false,
+				content: [],
+				error: {
+					code: e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED",
+					message: messageOf(e)
+				}
+			};
+		} finally {
+			worker.terminate();
+		}
+	}
+	/** 发消息并按 id 等回包；可选超时；onBridge 处理执行期间的能力桥请求 */
+	#request(worker, message, timeoutMs, onBridge) {
+		const id = String(message["id"]);
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			const timer = timeoutMs !== void 0 ? setTimeout(() => {
+				if (settled) return;
+				settled = true;
+				worker.terminate();
+				reject(new WebSkillError("RUN_TIMEOUT", `Script timed out after ${timeoutMs}ms (worker terminated)`));
+			}, timeoutMs) : void 0;
+			worker.addEventListener("message", (event) => {
+				const data = event.data;
+				if (!data || typeof data !== "object") return;
+				if (data.type === "bridge" && onBridge) {
+					const request = parseBridgeRequest(data.request);
+					const respond = (response) => worker.postMessage({
+						type: "bridge-response",
+						response
+					});
+					if (!request) {
+						respond(bridgeError("unknown", "TOOL_EXECUTION_FAILED", "invalid bridge request"));
+						return;
+					}
+					onBridge(request).then(respond, (e) => respond(bridgeError(request.id, "TOOL_EXECUTION_FAILED", messageOf(e))));
+					return;
+				}
+				if (data.id !== id || settled) return;
+				settled = true;
+				if (timer) clearTimeout(timer);
+				resolve(data);
+			});
+			worker.postMessage(message);
+		});
+	}
+	/** 能力桥宿主侧处理：能力关闭即 TOOL_UNSUPPORTED；readReference/writeArtifact/confirm 委托 context */
+	async #handleBridge(request, context) {
+		const unsupported = (capability) => bridgeError(request.id, "TOOL_UNSUPPORTED", `Capability "${capability}" is disabled`);
+		try {
+			switch (request.kind) {
+				case "readReference":
+					if (!this.#capabilities.readReference) return unsupported("readReference");
+					return {
+						id: request.id,
+						ok: true,
+						value: await context.readReference(request.path)
+					};
+				case "writeArtifact": {
+					if (!this.#capabilities.writeArtifact) return unsupported("writeArtifact");
+					const content = typeof request.content === "string" ? request.content : new Uint8Array(request.content);
+					const artifact = await context.writeArtifact(request.path, content, { ...request.mimeType ? { mimeType: request.mimeType } : {} });
+					return {
+						id: request.id,
+						ok: true,
+						value: artifact
+					};
+				}
+				case "confirm":
+					if (!this.#capabilities.confirm || !context.confirm) return unsupported("confirm");
+					return {
+						id: request.id,
+						ok: true,
+						value: await context.confirm(request.message)
+					};
+			}
+		} catch (e) {
+			return bridgeError(request.id, e instanceof WebSkillError ? e.code : "TOOL_EXECUTION_FAILED", messageOf(e));
+		}
+	}
+};
+const isRecord = (v) => typeof v === "object" && v !== null;
+const isNonEmptyString = (v) => typeof v === "string" && v !== "";
+/** Worker 侧入站校验：非法消息返回 undefined（忽略） */
+function parseMainMessage(data) {
+	if (!isRecord(data) || !isNonEmptyString(data["type"])) return void 0;
+	switch (data["type"]) {
+		case "init": return isNonEmptyString(data["id"]) && isRecord(data["config"]) ? {
+			type: "init",
+			id: data["id"],
+			config: data["config"]
+		} : void 0;
+		case "run": return isNonEmptyString(data["id"]) && typeof data["prompt"] === "string" ? {
+			type: "run",
+			id: data["id"],
+			prompt: data["prompt"],
+			...isNonEmptyString(data["runId"]) ? { runId: data["runId"] } : {}
+		} : void 0;
+		case "cancel":
+		case "status": return isNonEmptyString(data["id"]) && isNonEmptyString(data["runId"]) ? {
+			type: data["type"],
+			id: data["id"],
+			runId: data["runId"]
+		} : void 0;
+		case "interaction-response": {
+			const response = data["response"];
+			return isNonEmptyString(data["workerMessageId"]) && isRecord(response) && isNonEmptyString(response["id"]) ? {
+				type: "interaction-response",
+				workerMessageId: data["workerMessageId"],
+				response: {
+					id: response["id"],
+					...response["value"] !== void 0 ? { value: response["value"] } : {},
+					...response["cancelled"] === true ? { cancelled: true } : {}
+				}
+			} : void 0;
+		}
+		default: return;
+	}
+}
+/** 主线程侧入站校验 */
+function parseWorkerEvent(data) {
+	if (!isRecord(data) || !isNonEmptyString(data["type"])) return;
+	if (data["type"] === "render-result") return isRecord(data["request"]) && Array.isArray(data["request"]["blocks"]) ? {
+		type: "render-result",
+		request: data["request"]
+	} : void 0;
+	if (data["type"] === "text-delta") return isNonEmptyString(data["runId"]) && typeof data["delta"] === "string" ? {
+		type: "text-delta",
+		runId: data["runId"],
+		delta: data["delta"]
+	} : void 0;
+	if (!isNonEmptyString(data["id"])) return;
+	switch (data["type"]) {
+		case "ready": return {
+			type: "ready",
+			id: data["id"]
+		};
+		case "result": {
+			const error = data["error"];
+			return {
+				type: "result",
+				id: data["id"],
+				...data["result"] !== void 0 ? { result: data["result"] } : {},
+				...isRecord(error) && typeof error["code"] === "string" && typeof error["message"] === "string" ? { error: {
+					code: error["code"],
+					message: error["message"]
+				} } : {}
+			};
+		}
+		case "interaction": return isNonEmptyString(data["workerMessageId"]) && isRecord(data["request"]) ? {
+			type: "interaction",
+			id: data["id"],
+			workerMessageId: data["workerMessageId"],
+			request: data["request"]
+		} : void 0;
+		default: return;
+	}
+}
+/**
+* Worker 内 UiBridge：request → 'interaction' 消息到主线程，
+* 挂起等待 'interaction-response' → resolve（行内 await 跨线程成立）。
+* renderResult 为单向通知（'render-result' 消息，主线程页面桥消费）。
+*/
+var WorkerUiBridge = class {
+	#scope;
+	#pending = /* @__PURE__ */ new Map();
+	#seq = 0;
+	constructor(scope) {
+		this.#scope = scope;
+	}
+	/** 宿主转发主线程的 interaction-response */
+	handleInteractionResponse(workerMessageId, response) {
+		const resolve = this.#pending.get(workerMessageId);
+		if (resolve) {
+			this.#pending.delete(workerMessageId);
+			resolve(response);
+		}
+	}
+	/** 取消全部挂起请求（cancel 语义：视为用户取消） */
+	cancelAll() {
+		for (const [id, resolve] of this.#pending) resolve({
+			id,
+			cancelled: true
+		});
+		this.#pending.clear();
+	}
+	request(input) {
+		const workerMessageId = `ui-${++this.#seq}`;
+		return new Promise((resolve) => {
+			this.#pending.set(workerMessageId, resolve);
+			this.#scope.postMessage({
+				type: "interaction",
+				id: workerMessageId,
+				workerMessageId,
+				request: input
+			});
+		});
+	}
+	async renderResult(input) {
+		this.#scope.postMessage({
+			type: "render-result",
+			request: input
+		});
+	}
+	async onTextDelta(runId, delta) {
+		this.#scope.postMessage({
+			type: "text-delta",
+			runId,
+			delta
+		});
+	}
+};
+const serializeError = (e) => ({
+	code: e instanceof WebSkillError ? e.code : "RUN_FAILED",
+	message: e instanceof Error ? e.message : String(e)
+});
+const defaultCreateLlm = (config) => config.mockResponses ? new MockLlmClient(config.mockResponses, { streaming: config.mockStreaming ?? false }) : new OpenAiCompatibleClient(config);
+/**
+* Worker 内宿主（engine-in-worker）：
+* 组合 fs + FsArtifactStore/FsMemoryStore + LlmClient + AgentLoop + 沙箱执行器；
+* UiBridge 经 interaction/interaction-response 消息桥接主线程。
+*/
+function startWorkerRuntimeHost(scope, overrides = {}) {
+	let state;
+	/** runId → 运行状态（status/cancel 用） */
+	const runs = /* @__PURE__ */ new Map();
+	/** 当前活跃交互桥（cancel 时取消挂起交互） */
+	let activeUiBridge;
+	const post = (data) => scope.postMessage(data);
+	const result = (id, payload) => post({
+		type: "result",
+		id,
+		...payload
+	});
+	async function handleInit(id, config) {
+		const fs = overrides.fs ?? new OpfsProvider(config.opfsRootName ? { rootName: config.opfsRootName } : {});
+		state = {
+			fs,
+			llm: (overrides.createLlm ?? defaultCreateLlm)(config.llm),
+			executor: new BrowserWorkerScriptExecutor({
+				fs,
+				...overrides.workerFactory ? { workerFactory: overrides.workerFactory } : {}
+			}),
+			...config.interaction ? { interaction: config.interaction } : {},
+			roots: config.roots ?? ["/skills"]
+		};
+		post({
+			type: "ready",
+			id
+		});
+	}
+	async function handleRun(id, prompt, requestedRunId) {
+		if (!state) {
+			result(id, { error: {
+				code: "RUN_FAILED",
+				message: "Host is not initialized"
+			} });
+			return;
+		}
+		const runId = requestedRunId ?? `run-${Math.random().toString(36).slice(2, 10)}`;
+		runs.set(runId, { status: "running" });
+		try {
+			const { entries } = await new SkillDiscovery(state.fs, state.roots).discover();
+			const providerEntries = (await Promise.all((overrides.skillProviders ?? []).map(async (p) => {
+				try {
+					return await p.listSkills();
+				} catch {
+					return [];
+				}
+			}))).flat();
+			const catalog = providerEntries.length > 0 ? { skills: mergeCatalogEntries(buildCatalog(entries).skills, providerEntries) } : buildCatalog(entries);
+			const route = await new ProgressiveRouter().route(catalog);
+			const uiBridge = new WorkerUiBridge(scope);
+			activeUiBridge = uiBridge;
+			const runResult = await new AgentLoop({
+				llm: state.llm,
+				executor: state.executor,
+				artifactStore: new FsArtifactStore({
+					root: "artifacts",
+					fs: state.fs
+				}),
+				memory: new FsMemoryStore({
+					root: "memory",
+					fs: state.fs
+				}),
+				fs: state.fs,
+				skillIndex: new Map(entries.map((e) => [e.name, e.root])),
+				uiBridge,
+				...state.interaction ? { interaction: state.interaction } : {},
+				...overrides.externalTools ? { externalTools: overrides.externalTools } : {},
+				...overrides.skillProviders ? { skillProviders: overrides.skillProviders } : {}
+			}).run({
+				sessionId: `session-${runId}`,
+				userPrompt: prompt,
+				route,
+				runId
+			});
+			runs.set(runId, { status: runResult.run.status });
+			result(id, { result: runResult });
+		} catch (e) {
+			runs.set(runId, { status: "failed" });
+			result(id, { error: serializeError(e) });
+		} finally {
+			activeUiBridge = void 0;
+		}
+	}
+	scope.addEventListener("message", (event) => {
+		const message = parseMainMessage(event.data);
+		if (!message) return;
+		if (message.type === "interaction-response") {
+			activeUiBridge?.handleInteractionResponse(message.workerMessageId, message.response);
+			return;
+		}
+		switch (message.type) {
+			case "init":
+				handleInit(message.id, message.config).catch((e) => result(message.id, { error: serializeError(e) }));
+				return;
+			case "run":
+				handleRun(message.id, message.prompt, message.runId);
+				return;
+			case "status": {
+				const info = runs.get(message.runId);
+				result(message.id, { ...info ? { result: {
+					runId: message.runId,
+					status: info.status
+				} } : { error: {
+					code: "RUN_FAILED",
+					message: `Unknown run: ${message.runId}`
+				} } });
+				return;
+			}
+			case "cancel":
+				if (!runs.get(message.runId)) {
+					result(message.id, { error: {
+						code: "RUN_FAILED",
+						message: `Unknown run: ${message.runId}`
+					} });
+					return;
+				}
+				if (activeUiBridge) {
+					activeUiBridge.cancelAll();
+					result(message.id, { result: {
+						runId: message.runId,
+						cancelling: true
+					} });
+				} else result(message.id, { error: {
+					code: "RUN_FAILED",
+					message: "Run cannot be cancelled in its current state"
+				} });
+		}
+	});
+}
+/** 主线程客户端：init/run/cancel/status/dispose 的 Promise API + 交互转发 */
+var WorkerRuntimeClient = class {
+	#worker;
+	#uiBridge;
+	#timeoutMs;
+	#pending = /* @__PURE__ */ new Map();
+	#seq = 0;
+	constructor(deps) {
+		this.#worker = deps.worker;
+		this.#uiBridge = deps.uiBridge;
+		this.#timeoutMs = deps.timeoutMs ?? 12e4;
+		this.#worker.addEventListener("message", (event) => {
+			this.#onMessage(event.data);
+		});
+	}
+	init(config) {
+		return this.#call({
+			type: "init",
+			id: this.#nextId(),
+			config
+		});
+	}
+	run(prompt, runId) {
+		return this.#call({
+			type: "run",
+			id: this.#nextId(),
+			prompt,
+			...runId ? { runId } : {}
+		});
+	}
+	status(runId) {
+		return this.#call({
+			type: "status",
+			id: this.#nextId(),
+			runId
+		});
+	}
+	cancel(runId) {
+		return this.#call({
+			type: "cancel",
+			id: this.#nextId(),
+			runId
+		});
+	}
+	dispose() {
+		for (const [id, pending] of this.#pending) {
+			clearTimeout(pending.timer);
+			pending.resolve({
+				type: "result",
+				id,
+				error: {
+					code: "RUN_FAILED",
+					message: "Client disposed"
+				}
+			});
+		}
+		this.#pending.clear();
+		this.#worker.terminate();
+	}
+	#nextId() {
+		return `req-${++this.#seq}`;
+	}
+	#call(message) {
+		const timeoutMs = this.#timeoutMs;
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				this.#pending.delete(message.id);
+				resolve({
+					type: "result",
+					id: message.id,
+					error: {
+						code: "RUN_TIMEOUT",
+						message: `Worker request "${message.type}" timed out after ${timeoutMs}ms`
+					}
+				});
+			}, timeoutMs);
+			this.#pending.set(message.id, {
+				resolve,
+				timer
+			});
+			this.#worker.postMessage(message);
+		});
+	}
+	async #onMessage(data) {
+		const event = parseWorkerEvent(data);
+		if (!event) return;
+		if (event.type === "interaction") {
+			let response;
+			if (!this.#uiBridge) response = {
+				id: event.request.id,
+				cancelled: true
+			};
+			else try {
+				response = await this.#uiBridge.request(event.request);
+			} catch (e) {
+				response = {
+					id: event.request.id,
+					cancelled: true
+				};
+				console.warn(`UiBridge request failed, responding as cancelled: ${e instanceof Error ? e.message : String(e)}`);
+			}
+			this.#worker.postMessage({
+				type: "interaction-response",
+				workerMessageId: event.workerMessageId,
+				response
+			});
+			return;
+		}
+		if (event.type === "render-result") {
+			await this.#uiBridge?.renderResult?.(event.request);
+			return;
+		}
+		if (event.type === "text-delta") {
+			await this.#uiBridge?.onTextDelta?.(event.runId, event.delta);
+			return;
+		}
+		const pending = this.#pending.get(event.id);
+		if (pending) {
+			this.#pending.delete(event.id);
+			clearTimeout(pending.timer);
+			pending.resolve(event);
+		}
+	}
+};
+
+//#endregion
+export { BrowserWorkerScriptExecutor, OpfsProvider, WORKER_BOOTSTRAP_SOURCE, WorkerRuntimeClient, WorkerUiBridge, bridgeError, isOpfsAvailable, parseBridgeRequest, parseMainMessage, parseWorkerEvent, startWorkerRuntimeHost };