@mcp-b/webmcp-ts-sdk 5.1.0 → 6.0.0

package/dist/index.js

@@ -1,4 +1,5 @@
-import { coerceWebMcpToolDescriptor, createInvalidStateError, createToolInvocationFailedError, createUnknownError, isPlainObject, normalizeInputSchema, normalizeToolResponse, parseChromeToolInput, serializeChromeToolResult, toWebMcpAnnotations, validateExecutableOrigin, validatePotentiallyTrustworthyOrigins, validateWebMcpAccess, validateWebMcpToolDescriptor, withAbortSignal } from "@mcp-b/webmcp-polyfill/schema";
+import { a as createInvalidStateError, i as coerceWebMcpToolDescriptor, n as normalizeInputSchema, o as isPlainObject, r as normalizeToolResponse, s as serializeInputSchema, t as isMcpStandardSchema } from "./schema-FbP7xLdQ.js";
+import { installWebMCP } from "@mcp-b/webmcp-polyfill";
 import { McpServer, ResourceTemplate, fromJsonSchema, isInputRequiredResult, mergeCapabilities } from "@modelcontextprotocol/server";
 
 //#region src/browser-server.ts
@@ -7,48 +8,40 @@ const SERVER_MARKER_PROPERTY = "__isBrowserMcpServer";
 function isBrowserMcpServer(context) {
 	return typeof context === "object" && context !== null && SERVER_MARKER_PROPERTY in context && context[SERVER_MARKER_PROPERTY] === true;
 }
+function isPeerOriginTransport(transport) {
+	return "clientOrigin" in transport && (transport.clientOrigin === void 0 || typeof transport.clientOrigin === "string") && (!("onclientorigin" in transport) || transport.onclientorigin === void 0 || typeof transport.onclientorigin === "function");
+}
 function parseNativeToolResult(serialized) {
-	if (serialized === null) return {
-		content: [{
-			type: "text",
-			text: "Tool execution interrupted by navigation"
-		}],
-		isError: true
-	};
 	let result;
 	try {
 		result = JSON.parse(serialized);
 	} catch {
-		return normalizeToolResponse(serialized);
+		result = serialized;
 	}
-	return isInputRequiredResult(result) ? result : normalizeToolResponse(result);
-}
-function toMcpInputSchema(normalized) {
-	const standardSchema = Object.getOwnPropertyDescriptor(normalized.inputSchema, "~standard");
-	return standardSchema && !standardSchema.enumerable ? normalized.inputSchema : fromJsonSchema(normalized.inputSchema);
+	if (isPlainObject(result)) return result;
+	return { content: [{
+		type: "text",
+		text: typeof result === "string" ? result : serialized
+	}] };
 }
-function toMcpAnnotations(annotations) {
-	if (!annotations) return void 0;
-	const { untrustedContentHint: _untrustedContentHint, ...mcpAnnotations } = annotations;
-	return mcpAnnotations;
+/** Runs `operation` in a microtask; rejects with the reason as soon as `signal` aborts. */
+function withAbortSignal(operation, signal) {
+	return new Promise((resolve, reject) => {
+		signal.throwIfAborted();
+		const onAbort = () => reject(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+		Promise.resolve().then(operation).then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
 }
-function toNativeTool(tool, inputSchema, execute) {
-	const annotations = tool.annotations ? toWebMcpAnnotations(tool.annotations) : void 0;
-	return {
-		name: tool.name,
-		...tool.title !== void 0 ? { title: tool.title } : {},
-		description: tool.description,
-		...inputSchema !== void 0 ? { inputSchema } : {},
-		...annotations ? { annotations } : {},
-		execute
-	};
+function toMcpInputSchema(normalized) {
+	if (isMcpStandardSchema(normalized.inputSchema)) return normalized.inputSchema;
+	return fromJsonSchema(normalized.inputSchema);
 }
 /**
 * Thin WebMCP-to-MCP v2 adapter.
 *
 * The official v2 `McpServer` owns MCP registration, validation, and transport
-* behavior. This class only adds the document-facing WebMCP contract and native
-* Chrome mirroring.
+* behavior. This class extends the upstream WebMCP context with MCP capabilities.
 */
 var BrowserMcpServer = class extends EventTarget {
 	[SERVER_MARKER_PROPERTY] = true;
@@ -68,13 +61,23 @@ var BrowserMcpServer = class extends EventTarget {
 	nativeToolChangeListener;
 	closed = false;
 	closePromise;
-	ontoolchangeHandler = null;
-	ontoolchangeListener = (event) => {
-		this.ontoolchangeHandler?.call(this, event);
+	eventHandlers = /* @__PURE__ */ new Map();
+	eventHandlerListener = (event) => {
+		this.eventHandlers.get(event.type)?.call(this, event);
+	};
+	nativeLifecycleListener = (event) => {
+		if (this.closed) return;
+		const mirrored = new Event(event.type);
+		if ("toolName" in event) Object.defineProperty(mirrored, "toolName", {
+			enumerable: true,
+			value: event.toolName
+		});
+		this.dispatchEvent(mirrored);
 	};
 	constructor(serverInfo, options = {}) {
 		super();
-		const { native, ...serverOptions } = options;
+		const { native: suppliedContext, ...serverOptions } = options;
+		if (!suppliedContext && !globalThis.document?.modelContext) installWebMCP();
 		this.mcpServer = new McpServer(serverInfo, {
 			...serverOptions,
 			capabilities: mergeCapabilities(serverOptions.capabilities ?? {}, {
@@ -83,59 +86,84 @@ var BrowserMcpServer = class extends EventTarget {
 				prompts: { listChanged: true }
 			})
 		});
-		this.native = native;
+		this.native = suppliedContext ?? globalThis.document?.modelContext;
 		this.ownerDocument = globalThis.document ?? null;
-		if (native && typeof native.addEventListener === "function" && typeof native.removeEventListener === "function") {
-			this.nativeToolChangeListener = () => {
-				if (this.closed) return;
-				this.nativeToolChangeQueue = this.nativeToolChangeQueue.then(async () => {
-					try {
-						await this.syncNativeTools();
-					} catch (error) {
-						console.warn("[BrowserMcpServer] Native WebMCP tool reconciliation failed:", error);
-					}
-					await this.notifyProducerToolsChanged();
-				});
-			};
-			native.addEventListener("toolchange", this.nativeToolChangeListener);
-		}
+		this.nativeToolChangeListener = () => {
+			if (this.closed) return;
+			this.nativeToolChangeQueue = this.nativeToolChangeQueue.then(async () => {
+				try {
+					await this.syncNativeTools();
+				} catch (error) {
+					console.warn("[BrowserMcpServer] Native WebMCP tool reconciliation failed:", error);
+				}
+				await this.notifyProducerToolsChanged();
+			});
+		};
+		this.native?.addEventListener("toolchange", this.nativeToolChangeListener);
+		this.native?.addEventListener("toolactivated", this.nativeLifecycleListener);
+		this.native?.addEventListener("toolcancel", this.nativeLifecycleListener);
+	}
+	getEventHandler(type) {
+		return this.eventHandlers.get(type) ?? null;
+	}
+	setEventHandler(type, handler) {
+		if (typeof handler === "function") {
+			if (!this.eventHandlers.has(type)) super.addEventListener(type, this.eventHandlerListener);
+			this.eventHandlers.set(type, handler);
+		} else if (this.eventHandlers.delete(type)) super.removeEventListener(type, this.eventHandlerListener);
 	}
 	get ontoolchange() {
-		return this.ontoolchangeHandler;
+		return this.getEventHandler("toolchange");
 	}
 	set ontoolchange(handler) {
-		const listener = typeof handler === "function" ? handler : null;
-		if (listener === null) {
-			this.ontoolchangeHandler = null;
-			super.removeEventListener("toolchange", this.ontoolchangeListener);
-			return;
-		}
-		if (this.ontoolchangeHandler === null) super.addEventListener("toolchange", this.ontoolchangeListener);
-		this.ontoolchangeHandler = listener;
+		this.setEventHandler("toolchange", handler);
+	}
+	get ontoolactivated() {
+		return this.getEventHandler("toolactivated");
+	}
+	set ontoolactivated(handler) {
+		this.setEventHandler("toolactivated", handler);
+	}
+	get ontoolcancel() {
+		return this.getEventHandler("toolcancel");
+	}
+	set ontoolcancel(handler) {
+		this.setEventHandler("toolcancel", handler);
 	}
 	async notifyProducerToolsChanged() {
 		if (this.closed) return;
 		await new Promise((resolve) => setTimeout(resolve, 0));
 		if (!this.closed) this.dispatchEvent(new Event("toolchange"));
 	}
-	getNativeStandardToolsApi() {
-		const candidate = this.native;
-		return candidate && typeof candidate.executeTool === "function" ? candidate : void 0;
-	}
 	async registerNativeToolMirror(tool, normalized, options, execute, controller) {
-		if (!this.native) return;
-		const nativeRegister = this.native.registerTool;
+		const native = this.native;
+		if (!native) return;
 		const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
-		const nativeInputSchema = normalized.registeredInputSchema === void 0 ? void 0 : JSON.parse(normalized.registeredInputSchema);
+		const nativeTool = {
+			name: tool.name,
+			description: tool.description,
+			execute
+		};
+		if (tool.title !== void 0) nativeTool.title = tool.title;
+		if (normalized.registeredInputSchema !== void 0) {
+			const inputSchema = JSON.parse(normalized.registeredInputSchema);
+			if (!isPlainObject(inputSchema)) throw new TypeError("inputSchema must be an object");
+			nativeTool.inputSchema = inputSchema;
+		}
+		if (tool.annotations) nativeTool.annotations = tool.annotations;
 		this.nativeToolAbortControllers.set(tool.name, controller);
 		try {
-			await nativeRegister.call(this.native, toNativeTool(tool, nativeInputSchema, (input) => execute(input)), {
+			await native.registerTool(nativeTool, {
 				...options,
 				signal
 			});
 		} catch (error) {
 			controller.abort();
 			if (this.nativeToolAbortControllers.get(tool.name) === controller) this.nativeToolAbortControllers.delete(tool.name);
+			if (error instanceof DOMException && error.name === "NotAllowedError") {
+				console.warn(`[BrowserMcpServer] Tool "${tool.name}" is available over MCP only: ${error.message}. Grant allow="tools" on the iframe to expose it to WebMCP.`);
+				return;
+			}
 			throw error;
 		}
 		if (this.nativeToolAbortControllers.get(tool.name) === controller) this.removingNativeTools.delete(tool.name);
@@ -146,79 +174,74 @@ var BrowserMcpServer = class extends EventTarget {
 		controller.abort();
 		this.nativeToolAbortControllers.delete(name);
 	}
-	validateToolDescriptor(tool) {
-		validateWebMcpToolDescriptor(tool);
-		if (this.tools.has(tool.name) || this.pendingTools.has(tool.name)) throw createInvalidStateError(`Tool already registered: ${tool.name}`);
-		return normalizeInputSchema(tool.inputSchema);
-	}
 	registerToolInMcp(tool, normalized, executeTool, exposedTo) {
-		const outputSchema = tool.outputSchema === void 0 ? void 0 : structuredClone(tool.outputSchema);
-		const mcpOutputSchema = outputSchema === void 0 ? void 0 : fromJsonSchema(outputSchema);
-		const mcpAnnotations = toMcpAnnotations(tool.annotations);
-		const mcpCompatibleInput = normalized.inputSchema.type === void 0 || normalized.inputSchema.type === "object";
-		const mcpHandle = mcpCompatibleInput ? this.mcpServer.registerTool(tool.name, {
-			...tool.title !== void 0 ? { title: tool.title } : {},
+		const item = {
+			name: tool.name,
 			description: tool.description,
-			inputSchema: toMcpInputSchema(normalized),
-			...mcpOutputSchema ? { outputSchema: mcpOutputSchema } : {},
-			...mcpAnnotations ? { annotations: mcpAnnotations } : {}
-		}, async (args, context) => {
-			const result = await executeTool(args, context.mcpReq.signal);
-			if (isInputRequiredResult(result)) throw new Error(`WebMCP tool "${tool.name}" returned input_required. Multi-round tool flows require BrowserMcpServer.mcpServer.registerTool().`);
-			return normalizeToolResponse(result);
-		}) : void 0;
-		if (exposedTo?.length) mcpHandle?.disable();
-		if (!mcpCompatibleInput) console.warn(`[BrowserMcpServer] Tool "${tool.name}" remains available through WebMCP but cannot be exposed over MCP because MCP input schemas require an object root.`);
-		return {
-			item: {
-				name: tool.name,
-				...tool.title !== void 0 ? { title: tool.title } : {},
-				description: tool.description,
-				inputSchema: normalized.inputSchema,
-				...outputSchema === void 0 ? {} : { outputSchema },
-				...tool.annotations ? { annotations: tool.annotations } : {}
-			},
-			...normalized.registeredInputSchema !== void 0 ? { registeredInputSchema: normalized.registeredInputSchema } : {},
-			execute: executeTool,
-			mcpHandle,
-			...exposedTo?.length ? { exposedTo } : {}
+			inputSchema: normalized.inputSchema
 		};
+		if (tool.title !== void 0) item.title = tool.title;
+		if (tool.outputSchema !== void 0) item.outputSchema = structuredClone(tool.outputSchema);
+		if (tool.annotations) item.annotations = tool.annotations;
+		const config = { description: tool.description };
+		if (item.outputSchema !== void 0) config.outputSchema = fromJsonSchema(item.outputSchema);
+		if (tool.title !== void 0) config.title = tool.title;
+		if (tool.annotations) {
+			const { untrustedContentHint: _untrustedContentHint, ...annotations } = tool.annotations;
+			config.annotations = annotations;
+		}
+		let mcpHandle;
+		if (normalized.inputSchema.type === void 0 || normalized.inputSchema.type === "object") {
+			config.inputSchema = toMcpInputSchema(normalized);
+			mcpHandle = this.mcpServer.registerTool(tool.name, config, async (args, context) => {
+				const result = await executeTool(args, { signal: context.mcpReq.signal });
+				if (isInputRequiredResult(result)) throw new Error(`WebMCP tool "${tool.name}" returned input_required. Multi-round tool flows require BrowserMcpServer.mcpServer.registerTool().`);
+				return normalizeToolResponse(result);
+			});
+			mcpHandle.disable();
+		} else console.warn(`[BrowserMcpServer] Tool "${tool.name}" remains available through WebMCP but cannot be exposed over MCP because MCP input schemas require an object root.`);
+		const registered = {
+			item,
+			mcpHandle
+		};
+		if (exposedTo?.length) registered.exposedTo = exposedTo;
+		return registered;
 	}
 	registerTool = async (toolValue, optionsValue = {}) => {
 		const { signal, exposedTo } = optionsValue ?? {};
-		const options = {
-			...signal ? { signal } : {},
-			...exposedTo ? { exposedTo: [...exposedTo] } : {}
-		};
-		validateWebMcpAccess(this.ownerDocument);
+		const options = {};
+		if (signal) options.signal = signal;
+		if (exposedTo) options.exposedTo = [...exposedTo];
 		if (this.closed) throw createInvalidStateError("BrowserMcpServer is closed");
 		if (!isPlainObject(toolValue)) throw new TypeError("registerTool(tool) requires a tool object");
 		const tool = coerceWebMcpToolDescriptor(toolValue);
-		const normalized = this.validateToolDescriptor(tool);
-		options.signal?.throwIfAborted();
-		validatePotentiallyTrustworthyOrigins(options.exposedTo);
+		if (this.tools.has(tool.name) && !this.nativeBackfilledTools.has(tool.name) || this.pendingTools.has(tool.name)) throw createInvalidStateError(`Tool already registered: ${tool.name}`);
+		const normalized = normalizeInputSchema(tool.inputSchema);
 		options.signal?.throwIfAborted();
-		const execute = async (args, signal) => {
-			signal?.throwIfAborted();
-			return withAbortSignal(Promise.resolve().then(() => Reflect.apply(tool.execute, void 0, [args])), signal);
-		};
+		const callback = tool.execute;
+		const execute = (args, options) => withAbortSignal(() => callback(args, options), options.signal);
 		const controller = new AbortController();
+		const exposedOrigins = options.exposedTo?.map((origin) => URL.parse(origin)?.origin ?? origin);
 		let registered;
 		const abort = () => {
 			if (this.pendingTools.get(tool.name) === controller) this.pendingTools.delete(tool.name);
 			if (registered && this.tools.get(tool.name) === registered) this.removeTool(tool.name);
-			else this.abortNativeToolMirror(tool.name, controller);
+			else {
+				registered?.mcpHandle?.remove();
+				this.abortNativeToolMirror(tool.name, controller);
+			}
+			registered = void 0;
 		};
 		options.signal?.addEventListener("abort", abort, { once: true });
 		this.pendingTools.set(tool.name, controller);
 		try {
+			if (!this.nativeBackfilledTools.has(tool.name)) registered = this.registerToolInMcp(tool, normalized, execute, exposedOrigins);
+			options.signal?.throwIfAborted();
 			await this.registerNativeToolMirror(tool, normalized, options, execute, controller);
 			if (this.closed) throw createInvalidStateError("BrowserMcpServer is closed");
 			options.signal?.throwIfAborted();
-			registered = this.registerToolInMcp(tool, normalized, execute, options.exposedTo?.map((origin) => {
-				const parsedOrigin = new URL(origin).origin;
-				return parsedOrigin === "null" ? origin : parsedOrigin;
-			}));
+			this.removeTool(tool.name, { skipNative: true });
+			registered ??= this.registerToolInMcp(tool, normalized, execute, exposedOrigins);
 			this.tools.set(tool.name, registered);
 			this.applyToolExposure();
 			if (options.signal?.aborted) {
@@ -226,6 +249,7 @@ var BrowserMcpServer = class extends EventTarget {
 				options.signal.throwIfAborted();
 			}
 		} catch (error) {
+			registered?.mcpHandle?.remove();
 			this.abortNativeToolMirror(tool.name, controller);
 			options.signal?.removeEventListener("abort", abort);
 			options.signal?.throwIfAborted();
@@ -237,8 +261,7 @@ var BrowserMcpServer = class extends EventTarget {
 			registered.abortSignal = options.signal;
 			registered.abortListener = abort;
 		}
-		if (this.tools.get(tool.name) === registered) if (this.native) await this.nativeToolChangeQueue;
-		else await this.notifyProducerToolsChanged();
+		if (this.tools.get(tool.name) === registered) await this.nativeToolChangeQueue;
 		if (this.closed) throw createInvalidStateError("BrowserMcpServer is closed");
 		options.signal?.throwIfAborted();
 	};
@@ -249,46 +272,52 @@ var BrowserMcpServer = class extends EventTarget {
 			this.tools.delete(name);
 			this.nativeBackfilledTools.delete(name);
 			registered.mcpHandle?.remove();
-			if ((options?.notify ?? true) && !this.native) this.notifyProducerToolsChanged();
 		}
 		if (!options?.skipNative) this.abortNativeToolMirror(name);
 	}
 	syncNativeTools() {
+		const native = this.native;
 		const sync = this.nativeSyncQueue.then(async () => {
-			if (this.closed) return;
-			const native = this.getNativeStandardToolsApi();
-			if (native) await this.backfillNativeStandardTools(native);
+			if (this.closed || !native) return;
+			await this.backfillNativeStandardTools(native);
 		});
 		this.nativeSyncQueue = sync.then(() => void 0, () => void 0);
 		return sync;
 	}
 	async backfillNativeStandardTools(native) {
-		const tools = await native.getTools();
+		const ownerWindow = this.ownerDocument?.defaultView;
+		const tools = (await native.getTools()).filter((tool) => {
+			if (tool.window === ownerWindow) return true;
+			if (ownerWindow?.parent !== ownerWindow) return false;
+			let frame = tool.window;
+			while (frame) {
+				if (frame === ownerWindow) return true;
+				const parent = frame.parent;
+				if (parent === frame) break;
+				frame = parent;
+			}
+			return false;
+		});
 		if (this.closed) return;
+		for (const name of this.removingNativeTools) if (!tools.some((tool) => tool.name === name && tool.window === ownerWindow)) this.removingNativeTools.delete(name);
 		const nextTools = /* @__PURE__ */ new Map();
-		const nativeNames = new Set(tools.map(({ name }) => name));
-		for (const name of this.removingNativeTools) if (!nativeNames.has(name)) this.removingNativeTools.delete(name);
 		for (const tool of tools) {
 			if (nextTools.has(tool.name) || this.pendingTools.has(tool.name) || this.removingNativeTools.has(tool.name)) continue;
-			let inputSchema = DEFAULT_INPUT_SCHEMA;
-			if (tool.inputSchema !== void 0) try {
-				const serialized = typeof tool.inputSchema === "string" ? tool.inputSchema : JSON.stringify(tool.inputSchema);
-				const parsed = JSON.parse(serialized);
-				inputSchema = isPlainObject(parsed) ? parsed : void 0;
-			} catch {
-				inputSchema = void 0;
-			}
-			if (!inputSchema) {
+			let inputSchema;
+			try {
+				inputSchema = JSON.parse(serializeInputSchema(tool.inputSchema ?? DEFAULT_INPUT_SCHEMA));
+			} catch {}
+			if (!isPlainObject(inputSchema)) {
 				console.warn(`[BrowserMcpServer] Native tool "${tool.name}" was not exposed over MCP because its input schema is malformed.`);
 				continue;
 			}
 			const item = {
 				name: tool.name,
-				...tool.title !== void 0 ? { title: tool.title } : {},
 				description: tool.description,
-				inputSchema,
-				...tool.annotations ? { annotations: tool.annotations } : {}
+				inputSchema
 			};
+			if (tool.title !== void 0) item.title = tool.title;
+			if (tool.annotations) item.annotations = tool.annotations;
 			nextTools.set(tool.name, {
 				source: tool,
 				item,
@@ -297,47 +326,41 @@ var BrowserMcpServer = class extends EventTarget {
 		}
 		for (const [name, current] of this.nativeBackfilledTools) {
 			const next = nextTools.get(name);
-			if (!next || next.fingerprint !== current.fingerprint) {
-				this.removeTool(name, {
-					skipNative: true,
-					notify: false
-				});
-				continue;
-			}
-			this.nativeBackfilledTools.set(name, next);
+			if (next?.fingerprint === current.fingerprint) this.nativeBackfilledTools.set(name, next);
+			else this.removeTool(name, { skipNative: true });
 		}
 		for (const [name, next] of nextTools) {
 			if (this.tools.has(name)) continue;
-			const execute = async (args, signal) => {
+			const execute = async (args, options) => {
 				const currentTool = this.nativeBackfilledTools.get(name)?.source;
 				if (!currentTool) throw new Error(`Native tool not found: ${name}`);
-				const input = JSON.stringify(args);
-				return parseNativeToolResult(signal ? await native.executeTool.call(this.native, currentTool, input, { signal }) : await native.executeTool.call(this.native, currentTool, input));
+				try {
+					return parseNativeToolResult(await native.executeTool(currentTool, args, options));
+				} catch (error) {
+					if (currentTool.window.closed) this.nativeToolChangeListener();
+					throw error;
+				}
 			};
 			const tool = {
-				name,
-				...next.item.title !== void 0 ? { title: next.item.title } : {},
-				description: next.item.description,
-				inputSchema: next.item.inputSchema,
-				...next.item.annotations ? { annotations: next.item.annotations } : {},
-				execute: (args) => execute(args)
+				...next.item,
+				execute
 			};
 			try {
-				const normalized = this.validateToolDescriptor(tool);
-				this.tools.set(tool.name, this.registerToolInMcp(tool, normalized, execute, void 0));
+				const normalized = normalizeInputSchema(tool.inputSchema);
+				this.tools.set(name, this.registerToolInMcp(tool, normalized, execute));
 				this.nativeBackfilledTools.set(name, next);
 			} catch (error) {
 				console.warn(`[BrowserMcpServer] Native tool "${name}" was not exposed over MCP because its schema could not be compiled:`, error);
 			}
 		}
+		this.applyToolExposure();
 	}
 	registerResource(descriptor) {
 		if (this.closed) throw createInvalidStateError("BrowserMcpServer is closed");
 		const registeredDescriptor = { ...descriptor };
-		const config = {
-			...registeredDescriptor.description !== void 0 ? { description: registeredDescriptor.description } : {},
-			...registeredDescriptor.mimeType !== void 0 ? { mimeType: registeredDescriptor.mimeType } : {}
-		};
+		const config = {};
+		if (registeredDescriptor.description !== void 0) config.description = registeredDescriptor.description;
+		if (registeredDescriptor.mimeType !== void 0) config.mimeType = registeredDescriptor.mimeType;
 		const template = registeredDescriptor.uri.includes("{") ? new ResourceTemplate(registeredDescriptor.uri, { list: void 0 }) : void 0;
 		const mcpHandle = template ? this.mcpServer.registerResource(registeredDescriptor.name, template, config, async (uri, variables) => registeredDescriptor.read(uri, variables)) : this.mcpServer.registerResource(registeredDescriptor.name, registeredDescriptor.uri, config, async (uri) => registeredDescriptor.read(uri));
 		this.registrations.add(mcpHandle);
@@ -347,15 +370,13 @@ var BrowserMcpServer = class extends EventTarget {
 	}
 	registerPrompt(descriptor) {
 		if (this.closed) throw createInvalidStateError("BrowserMcpServer is closed");
-		const registeredDescriptor = {
-			...descriptor,
-			...descriptor.argsSchema === void 0 ? {} : { argsSchema: structuredClone(descriptor.argsSchema) }
-		};
+		const registeredDescriptor = { ...descriptor };
+		if (descriptor.argsSchema !== void 0) registeredDescriptor.argsSchema = structuredClone(descriptor.argsSchema);
 		const argsSchema = registeredDescriptor.argsSchema === void 0 ? void 0 : fromJsonSchema(registeredDescriptor.argsSchema);
-		const mcpHandle = this.mcpServer.registerPrompt(registeredDescriptor.name, {
-			...registeredDescriptor.description !== void 0 ? { description: registeredDescriptor.description } : {},
-			...argsSchema ? { argsSchema } : {}
-		}, async (args) => registeredDescriptor.get(args ?? {}));
+		const config = {};
+		if (registeredDescriptor.description !== void 0) config.description = registeredDescriptor.description;
+		if (argsSchema) config.argsSchema = argsSchema;
+		const mcpHandle = this.mcpServer.registerPrompt(registeredDescriptor.name, config, async (args) => registeredDescriptor.get(args ?? {}));
 		this.registrations.add(mcpHandle);
 		return { unregister: () => {
 			if (this.registrations.delete(mcpHandle)) mcpHandle.remove();
@@ -365,69 +386,28 @@ var BrowserMcpServer = class extends EventTarget {
 		return structuredClone([...this.tools.values()].map(({ item }) => item));
 	}
 	async getTools(options) {
-		validateWebMcpAccess(this.ownerDocument);
 		if (this.closed) throw createInvalidStateError("BrowserMcpServer is closed");
-		if (this.native) return this.native.getTools(options);
-		validatePotentiallyTrustworthyOrigins(options?.fromOrigins);
-		if (options?.fromOrigins?.length) throw new DOMException("Cross-document tool discovery requires native WebMCP", "NotSupportedError");
-		const origin = globalThis.location?.origin ?? "";
-		const currentWindow = globalThis.window;
-		const tools = [...this.tools.values()].map(({ item, registeredInputSchema }) => {
-			const parsed = registeredInputSchema === void 0 ? void 0 : JSON.parse(registeredInputSchema);
-			return {
-				name: item.name,
-				title: item.title ?? "",
-				description: item.description,
-				...isPlainObject(parsed) ? { inputSchema: parsed } : {},
-				origin,
-				window: currentWindow,
-				...item.annotations ? { annotations: toWebMcpAnnotations(item.annotations) } : {}
-			};
-		}).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-		await new Promise((resolve) => setTimeout(resolve, 0));
-		return tools;
+		if (!this.native) throw createInvalidStateError("BrowserMcpServer has no WebMCP context");
+		return this.native.getTools(options);
 	}
-	async executeTool(tool, inputArgsJson, options) {
-		validateWebMcpAccess(this.ownerDocument);
+	async executeTool(...args) {
 		if (this.closed) throw createInvalidStateError("BrowserMcpServer is closed");
-		const native = this.getNativeStandardToolsApi();
-		if (native) return native.executeTool.call(this.native, tool, inputArgsJson, options);
-		if (tool === null || typeof tool !== "object") throw new TypeError("RegisteredTool must be an object");
-		for (const required of [
-			"name",
-			"description",
-			"window",
-			"origin"
-		]) if (!(required in tool)) throw new TypeError(`RegisteredTool.${required} is required`);
-		validateExecutableOrigin(tool.origin);
-		const origin = globalThis.location?.origin ?? "";
-		const currentWindow = globalThis.window;
-		if (tool.origin !== origin || tool.window !== currentWindow) throw createUnknownError(`Native tool not found: ${tool.name}`);
-		options?.signal?.throwIfAborted();
-		const registered = this.tools.get(tool.name);
-		if (!registered) throw createUnknownError(`Tool not found: ${tool.name}`);
-		const args = parseChromeToolInput(inputArgsJson);
-		try {
-			return serializeChromeToolResult(await withAbortSignal(registered.execute(args, options?.signal), registered.abortSignal, () => createUnknownError("Tool unregistered")));
-		} catch (error) {
-			if (options?.signal?.aborted && error === options.signal.reason) throw error;
-			if (registered.abortSignal?.aborted) throw error;
-			throw createToolInvocationFailedError(error);
-		}
+		if (!this.native) throw createInvalidStateError("BrowserMcpServer has no WebMCP context");
+		return this.native.executeTool(...args);
 	}
 	/**
 	* Re-evaluate which registered tools may appear on the wire.
 	*
-	* `exposedTo` narrows a tool to named embedder origins. The peer origin is only known
-	* once a transport that reports one has heard from its peer, so a restricted tool stays
-	* disabled until then — and stays disabled forever on transports that cannot name a peer
-	* at all. Failing closed keeps a tool that asked for a narrow audience from reaching a
-	* wider one; unrestricted tools are untouched and behave exactly as before.
+	* A published tool without `exposedTo` is enabled. `exposedTo` narrows a tool to named
+	* embedder origins. The peer origin is only known once a transport that reports one has
+	* heard from its peer, so a restricted tool stays disabled until then — and stays
+	* disabled forever on transports that cannot name a peer at all. Failing closed keeps a
+	* tool that asked for a narrow audience from reaching a wider one.
 	*/
 	applyToolExposure() {
 		for (const { exposedTo, mcpHandle } of this.tools.values()) {
-			if (!exposedTo?.length || !mcpHandle) continue;
-			const visible = this.peerOrigin !== void 0 && this.peerOrigin !== "null" && exposedTo.includes(this.peerOrigin);
+			if (!mcpHandle) continue;
+			const visible = !exposedTo?.length || this.peerOrigin !== void 0 && this.peerOrigin !== "null" && exposedTo.includes(this.peerOrigin);
 			if (visible === mcpHandle.enabled) continue;
 			if (visible) mcpHandle.enable();
 			else mcpHandle.disable();
@@ -444,7 +424,7 @@ var BrowserMcpServer = class extends EventTarget {
 		this.stopObservingPeerOrigin = void 0;
 		this.peerOrigin = void 0;
 		this.applyToolExposure();
-		if (!("clientOrigin" in transport)) return;
+		if (!isPeerOriginTransport(transport)) return;
 		const peered = transport;
 		this.peerOrigin = peered.clientOrigin;
 		this.applyToolExposure();
@@ -486,12 +466,11 @@ var BrowserMcpServer = class extends EventTarget {
 		this.stopObservingPeerOrigin?.();
 		this.stopObservingPeerOrigin = void 0;
 		this.closePromise = (async () => {
-			if (this.native && this.nativeToolChangeListener) {
-				this.native.removeEventListener("toolchange", this.nativeToolChangeListener);
-				this.nativeToolChangeListener = void 0;
-			}
+			this.native?.removeEventListener("toolchange", this.nativeToolChangeListener);
+			this.native?.removeEventListener("toolactivated", this.nativeLifecycleListener);
+			this.native?.removeEventListener("toolcancel", this.nativeLifecycleListener);
 			for (const name of this.nativeToolAbortControllers.keys()) this.abortNativeToolMirror(name);
-			for (const name of this.tools.keys()) this.removeTool(name, { notify: false });
+			for (const name of this.tools.keys()) this.removeTool(name);
 			for (const handle of this.registrations) handle.remove();
 			this.registrations.clear();
 			this.nativeBackfilledTools.clear();