@mcp-b/webmcp-ts-sdk 4.0.0 → 5.0.0

package/dist/index.js

@@ -1,80 +1,13 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { mergeCapabilities, mergeCapabilities as mergeCapabilities$1 } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
-import { CallToolRequestSchema, CallToolRequestSchema as CallToolRequestSchema$1, CallToolResultSchema, CreateMessageRequestSchema, CreateMessageResultSchema, ElicitRequestSchema, ElicitResultSchema, ErrorCode, GetPromptRequestSchema, GetPromptRequestSchema as GetPromptRequestSchema$1, GetPromptResultSchema, InitializeRequestSchema, InitializeResultSchema, JSONRPCMessageSchema, LATEST_PROTOCOL_VERSION, ListPromptsRequestSchema, ListPromptsRequestSchema as ListPromptsRequestSchema$1, ListPromptsResultSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListToolsRequestSchema, ListToolsRequestSchema as ListToolsRequestSchema$1, ListToolsResultSchema, LoggingLevelSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SUPPORTED_PROTOCOL_VERSIONS, ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
-import { toJsonValue } from "@mcp-b/webmcp-polyfill/schema";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { getParseErrorMessage, normalizeObjectSchema, safeParseAsync } from "@modelcontextprotocol/sdk/server/zod-compat.js";
-import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
-import { validateAndWarnToolName } from "@modelcontextprotocol/sdk/shared/toolNameValidation.js";
-import { CfWorkerJsonSchemaValidator, CfWorkerJsonSchemaValidator as CfWorkerJsonSchemaValidator$1, CfWorkerJsonSchemaValidator as PolyfillJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";
+import { coerceWebMcpToolDescriptor, createInvalidStateError, createToolInvocationFailedError, createUnknownError, isPlainObject, normalizeInputSchema, normalizeToolResponse, parseChromeToolInput, serializeChromeToolResult, toWebMcpAnnotations, validateExecutableOrigin, validatePotentiallyTrustworthyOrigins, validateWebMcpAccess, validateWebMcpToolDescriptor, withAbortSignal } from "@mcp-b/webmcp-polyfill/schema";
+import { McpServer, ResourceTemplate, fromJsonSchema, isInputRequiredResult, mergeCapabilities } from "@modelcontextprotocol/server";
 
 //#region src/browser-server.ts
-const DEFAULT_INPUT_SCHEMA = {
-	type: "object",
-	properties: {}
-};
-const DEFAULT_CLIENT_REQUEST_TIMEOUT = 1e4;
+const DEFAULT_INPUT_SCHEMA = normalizeInputSchema(void 0).inputSchema;
 const SERVER_MARKER_PROPERTY = "__isBrowserMcpServer";
-function isPlainObject(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function isCallToolResult(value) {
-	return isPlainObject(value) && Array.isArray(value.content);
-}
-function isPermissionsPolicySecurityError(error) {
-	if (!error || typeof error !== "object") return false;
-	const { name, message } = error;
-	return name === "SecurityError" && typeof message === "string" && /permissions policy|feature "tools" is disallowed/i.test(message);
-}
-function isAbortError(error) {
-	return Boolean(error) && typeof error === "object" && error.name === "AbortError";
-}
-function createAbortError() {
-	if (typeof DOMException === "function") return new DOMException("signal is aborted without reason", "AbortError");
-	const error = /* @__PURE__ */ new Error("signal is aborted without reason");
-	error.name = "AbortError";
-	return error;
-}
-function isPromiseLike(value) {
-	return Boolean(value) && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+function isBrowserMcpServer(context) {
+	return typeof context === "object" && context !== null && SERVER_MARKER_PROPERTY in context && context[SERVER_MARKER_PROPERTY] === true;
 }
-function serializeTextContent(value) {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-function normalizeToolResponse(value) {
-	if (isCallToolResult(value)) return value;
-	const structuredContent = toJsonValue(value);
-	return {
-		content: [{
-			type: "text",
-			text: serializeTextContent(value)
-		}],
-		...structuredContent !== void 0 ? { structuredContent } : {},
-		isError: false
-	};
-}
-function parseNativeToolInputSchema(inputSchema) {
-	if (!inputSchema) return DEFAULT_INPUT_SCHEMA;
-	try {
-		const parsed = JSON.parse(inputSchema);
-		if (isPlainObject(parsed)) return parsed;
-	} catch {}
-	return DEFAULT_INPUT_SCHEMA;
-}
-function toToolListItemFromNativeToolInfo(tool) {
-	return {
-		name: tool.name,
-		description: tool.description ?? "",
-		inputSchema: parseNativeToolInputSchema(tool.inputSchema)
-	};
-}
-function parseNativeToolResult(toolName, serialized) {
+function parseNativeToolResult(serialized) {
 	if (serialized === null) return {
 		content: [{
 			type: "text",
@@ -82,609 +15,459 @@ function parseNativeToolResult(toolName, serialized) {
 		}],
 		isError: true
 	};
-	let parsed;
+	let result;
 	try {
-		parsed = JSON.parse(serialized);
-	} catch (parseError) {
-		throw new Error(`Failed to parse serialized tool response for ${toolName}: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+		result = JSON.parse(serialized);
+	} catch {
+		return normalizeToolResponse(serialized);
 	}
-	return normalizeToolResponse(parsed);
+	return isInputRequiredResult(result) ? result : normalizeToolResponse(result);
 }
-function withDefaultTimeout(options) {
-	if (options?.signal) return options;
+function toMcpInputSchema(normalized) {
+	const standardSchema = Object.getOwnPropertyDescriptor(normalized.inputSchema, "~standard");
+	return standardSchema && !standardSchema.enumerable ? normalized.inputSchema : fromJsonSchema(normalized.inputSchema);
+}
+function toMcpAnnotations(annotations) {
+	if (!annotations) return void 0;
+	const { untrustedContentHint: _untrustedContentHint, ...mcpAnnotations } = annotations;
+	return mcpAnnotations;
+}
+function toNativeTool(tool, inputSchema, execute) {
+	const annotations = tool.annotations ? toWebMcpAnnotations(tool.annotations) : void 0;
 	return {
-		...options,
-		signal: AbortSignal.timeout(DEFAULT_CLIENT_REQUEST_TIMEOUT)
+		name: tool.name,
+		...tool.title !== void 0 ? { title: tool.title } : {},
+		description: tool.description,
+		...inputSchema !== void 0 ? { inputSchema } : {},
+		...annotations ? { annotations } : {},
+		execute
 	};
 }
 /**
-* Browser-optimized MCP Server that speaks WebMCP natively.
+* Thin WebMCP-to-MCP v2 adapter.
 *
-* Implements `registerTool(tool, options?)` while retaining MCP capabilities
-* (resources, prompts, elicitation, sampling) via BaseMcpServer.
-*
-* Deprecated compatibility (kept for Chrome Beta 147 and existing wrappers,
-* removed in the next major): `unregisterTool(name)`.
-*
-* When `native` is provided, tool operations are mirrored so that
-* navigator.modelContextTesting stays in sync.
+* The official v2 `McpServer` owns MCP registration, validation, and transport
+* behavior. This class only adds the document-facing WebMCP contract and native
+* Chrome mirroring.
 */
-var BrowserMcpServer = class extends McpServer {
+var BrowserMcpServer = class extends EventTarget {
 	[SERVER_MARKER_PROPERTY] = true;
+	mcpServer;
 	native;
-	_promptSchemas = /* @__PURE__ */ new Map();
-	_jsonValidator;
-	_publicMethodsBound = false;
-	_unregisterToolDeprecationWarned = false;
-	_nativeToolCleanups = /* @__PURE__ */ new Map();
-	_tools = /* @__PURE__ */ new Map();
-	_producerEventTarget = new EventTarget();
-	_ontoolchange = null;
-	_producerToolsChangedQueued = false;
-	constructor(serverInfo, options) {
-		const validator = options?.jsonSchemaValidator ?? new CfWorkerJsonSchemaValidator$1();
-		const enhancedOptions = {
-			capabilities: mergeCapabilities$1(options?.capabilities || {}, {
+	ownerDocument;
+	tools = /* @__PURE__ */ new Map();
+	peerOrigin;
+	registrations = /* @__PURE__ */ new Set();
+	nativeToolAbortControllers = /* @__PURE__ */ new Map();
+	nativeBackfilledTools = /* @__PURE__ */ new Map();
+	pendingTools = /* @__PURE__ */ new Map();
+	removingNativeTools = /* @__PURE__ */ new Set();
+	nativeSyncQueue = Promise.resolve();
+	nativeToolChangeQueue = Promise.resolve();
+	nativeToolChangeListener;
+	closed = false;
+	closePromise;
+	ontoolchangeHandler = null;
+	ontoolchangeListener = (event) => {
+		this.ontoolchangeHandler?.call(this, event);
+	};
+	constructor(serverInfo, options = {}) {
+		super();
+		const { native, ...serverOptions } = options;
+		this.mcpServer = new McpServer(serverInfo, {
+			...serverOptions,
+			capabilities: mergeCapabilities(serverOptions.capabilities ?? {}, {
 				tools: { listChanged: true },
 				resources: { listChanged: true },
 				prompts: { listChanged: true }
-			}),
-			jsonSchemaValidator: validator
-		};
-		super(serverInfo, enhancedOptions);
-		this._jsonValidator = validator;
-		this.native = options?.native;
-		this.bindPublicApiMethods();
-		this.installToolRequestHandlers();
-	}
-	/**
-	* navigator.modelContext consumers may destructure methods (e.g. const { registerTool } = ...).
-	* Bind methods once so they remain callable outside instance-method invocation syntax.
-	*/
-	bindPublicApiMethods() {
-		if (this._publicMethodsBound) return;
-		this.registerTool = this.registerTool.bind(this);
-		this.unregisterTool = this.unregisterTool.bind(this);
-		this.listTools = this.listTools.bind(this);
-		this.getTools = this.getTools.bind(this);
-		this.callTool = this.callTool.bind(this);
-		this.executeTool = this.executeTool.bind(this);
-		this.addEventListener = this.addEventListener.bind(this);
-		this.removeEventListener = this.removeEventListener.bind(this);
-		this.dispatchEvent = this.dispatchEvent.bind(this);
-		this.registerResource = this.registerResource.bind(this);
-		this.listResources = this.listResources.bind(this);
-		this.readResource = this.readResource.bind(this);
-		this.registerPrompt = this.registerPrompt.bind(this);
-		this.listPrompts = this.listPrompts.bind(this);
-		this.getPrompt = this.getPrompt.bind(this);
-		this.createMessage = this.createMessage.bind(this);
-		this.elicitInput = this.elicitInput.bind(this);
-		this._publicMethodsBound = true;
-	}
-	get _parentResources() {
-		return this._registeredResources;
-	}
-	get _parentPrompts() {
-		return this._registeredPrompts;
-	}
-	toJsonSchema(schema, pipeStrategy) {
-		if (!schema || typeof schema !== "object") return {};
-		const normalized = normalizeObjectSchema(schema);
-		return normalized ? toJsonSchemaCompat(normalized, {
-			strictUnions: true,
-			pipeStrategy
-		}) : schema;
+			})
+		});
+		this.native = native;
+		this.ownerDocument = globalThis.document ?? null;
+		if (native) {
+			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);
+		}
 	}
-	toInputTransportSchema(schema) {
-		const jsonSchema = this.toJsonSchema(schema, "input");
-		if (Object.keys(jsonSchema).length === 0) return DEFAULT_INPUT_SCHEMA;
-		if (jsonSchema.type === void 0) return {
-			type: "object",
-			...jsonSchema
-		};
-		return jsonSchema;
+	get ontoolchange() {
+		return this.ontoolchangeHandler;
 	}
-	toOutputTransportSchema(schema) {
-		return this.toJsonSchema(schema, "output");
+	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;
 	}
-	isZodSchema(schema) {
-		if (!schema || typeof schema !== "object") return false;
-		const s = schema;
-		return "_zod" in s || "_def" in s;
-	}
-	getNativeLegacyToolsApi() {
-		if (!this.native) return;
-		const candidate = this.native;
-		if (typeof candidate.listTools !== "function" || typeof candidate.callTool !== "function") return;
-		return candidate;
+	async notifyProducerToolsChanged() {
+		if (this.closed) return;
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		if (!this.closed) this.dispatchEvent(new Event("toolchange"));
 	}
 	getNativeStandardToolsApi() {
-		if (!this.native) return;
 		const candidate = this.native;
-		if (typeof candidate.getTools !== "function" || typeof candidate.executeTool !== "function") return;
-		return candidate;
-	}
-	getNativeUnregisterTool() {
-		if (!this.native) return;
-		const unregisterTool = this.native.unregisterTool;
-		if (typeof unregisterTool !== "function") return;
-		return (nameOrTool) => unregisterTool.call(this.native, nameOrTool);
-	}
-	createNativeToolCleanup(signal) {
-		const controller = new AbortController();
-		let removeSignalListener;
-		if (signal) {
-			const abortNativeSignal = () => {
-				controller.abort();
-			};
-			if (signal.aborted) abortNativeSignal();
-			else {
-				signal.addEventListener("abort", abortNativeSignal, { once: true });
-				removeSignalListener = () => signal.removeEventListener("abort", abortNativeSignal);
-			}
-		}
-		return {
-			options: { signal: controller.signal },
-			abort: () => {
-				removeSignalListener?.();
-				if (!controller.signal.aborted) controller.abort();
-			}
-		};
+		return candidate && typeof candidate.executeTool === "function" ? candidate : void 0;
 	}
-	registerNativeToolMirror(tool, signal) {
+	async registerNativeToolMirror(tool, normalized, options, execute, controller) {
 		if (!this.native) return;
 		const nativeRegister = this.native.registerTool;
-		const nativeUnregisterTool = this.getNativeUnregisterTool();
-		const cleanup = Boolean(signal) || !nativeUnregisterTool ? this.createNativeToolCleanup(signal) : void 0;
-		let nativeRegisterResult;
+		const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+		const nativeInputSchema = normalized.registeredInputSchema === void 0 ? void 0 : JSON.parse(normalized.registeredInputSchema);
+		this.nativeToolAbortControllers.set(tool.name, controller);
 		try {
-			if (cleanup) nativeRegisterResult = nativeRegister.call(this.native, tool, cleanup.options);
-			else nativeRegisterResult = nativeRegister.call(this.native, tool);
+			await nativeRegister.call(this.native, toNativeTool(tool, nativeInputSchema, (input) => execute(input)), {
+				...options,
+				signal
+			});
 		} catch (error) {
-			cleanup?.abort();
-			if (isPermissionsPolicySecurityError(error)) {
-				console.warn("[BrowserMcpServer] Native WebMCP tool mirror is blocked by permissions policy; continuing with WebMCP transport registration only.");
-				return;
-			}
+			controller.abort();
+			if (this.nativeToolAbortControllers.get(tool.name) === controller) this.nativeToolAbortControllers.delete(tool.name);
 			throw error;
 		}
-		if (!cleanup) return;
-		const nativeToolCleanup = {
-			abort: cleanup.abort,
-			nativeSignalAccepted: nativeRegister.length >= 2 || !nativeUnregisterTool
+		if (this.nativeToolAbortControllers.get(tool.name) === controller) this.removingNativeTools.delete(tool.name);
+	}
+	abortNativeToolMirror(name, controller = this.nativeToolAbortControllers.get(name)) {
+		if (!controller || this.nativeToolAbortControllers.get(name) !== controller) return;
+		this.removingNativeTools.add(name);
+		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 } : {},
+			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 } : {}
 		};
-		this._nativeToolCleanups.set(tool.name, nativeToolCleanup);
-		if (isPromiseLike(nativeRegisterResult)) nativeRegisterResult.then(void 0, (error) => {
-			cleanup.abort();
-			if (this._nativeToolCleanups.get(tool.name) === nativeToolCleanup) this._nativeToolCleanups.delete(tool.name);
-			if (isPermissionsPolicySecurityError(error)) {
-				console.warn("[BrowserMcpServer] Native WebMCP tool mirror is blocked by permissions policy; continuing with WebMCP transport registration only.");
-				return;
-			}
-			if (isAbortError(error)) return;
-			console.warn("[BrowserMcpServer] Native WebMCP tool mirror registration rejected; continuing with WebMCP transport registration only.", error);
-		});
-		return nativeToolCleanup;
 	}
-	unregisterNativeToolMirror(name, options) {
-		const cleanup = this._nativeToolCleanups.get(name);
-		this._nativeToolCleanups.delete(name);
-		const nativeUnregisterTool = this.getNativeUnregisterTool();
-		if (options?.preferAbortSignal && cleanup?.nativeSignalAccepted === true || !nativeUnregisterTool) {
-			cleanup?.abort();
-			return;
-		}
+	registerTool = async (toolValue, optionsValue = {}) => {
+		const options = optionsValue ?? {};
+		validateWebMcpAccess(this.ownerDocument);
+		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);
+		options.signal?.throwIfAborted();
+		const execute = async (args, signal) => {
+			signal?.throwIfAborted();
+			return withAbortSignal(Promise.resolve().then(() => Reflect.apply(tool.execute, void 0, [args])), signal);
+		};
+		const controller = new AbortController();
+		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);
+		};
+		options.signal?.addEventListener("abort", abort, { once: true });
+		this.pendingTools.set(tool.name, controller);
 		try {
-			nativeUnregisterTool(name);
+			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);
+			this.tools.set(tool.name, registered);
+			this.applyToolExposure();
+			if (options.signal?.aborted) {
+				abort();
+				options.signal.throwIfAborted();
+			}
+		} catch (error) {
+			this.abortNativeToolMirror(tool.name, controller);
+			options.signal?.removeEventListener("abort", abort);
+			options.signal?.throwIfAborted();
+			throw error;
 		} finally {
-			cleanup?.abort();
+			if (this.pendingTools.get(tool.name) === controller) this.pendingTools.delete(tool.name);
+		}
+		if (options.signal) {
+			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.closed) throw createInvalidStateError("BrowserMcpServer is closed");
+		options.signal?.throwIfAborted();
+	};
+	removeTool(name, options) {
+		const registered = this.tools.get(name);
+		if (registered) {
+			if (registered.abortSignal && registered.abortListener) registered.abortSignal.removeEventListener("abort", registered.abortListener);
+			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);
 	}
-	installToolRequestHandlers() {
-		this.server.setRequestHandler(ListToolsRequestSchema$1, () => ({ tools: this.listToolsForMcpTransport() }));
-		this.server.setRequestHandler(CallToolRequestSchema$1, async (request) => {
-			try {
-				const params = request.params.arguments === void 0 ? { name: request.params.name } : {
-					name: request.params.name,
-					arguments: request.params.arguments
-				};
-				const result = await this.callTool(params);
-				return this.toMcpCallToolResult(result);
-			} catch (error) {
-				return {
-					content: [{
-						type: "text",
-						text: error instanceof Error ? error.message : String(error)
-					}],
-					isError: true
-				};
-			}
+	syncNativeTools() {
+		const sync = this.nativeSyncQueue.then(async () => {
+			if (this.closed) return;
+			const native = this.getNativeStandardToolsApi();
+			if (native) await this.backfillNativeStandardTools(native);
 		});
-	}
-	registerToolInServer(tool) {
-		validateAndWarnToolName(tool.name);
-		const inputSchema = this.toInputTransportSchema(tool.inputSchema);
-		const outputSchema = tool.outputSchema ? this.toOutputTransportSchema(tool.outputSchema) : void 0;
-		if (this._tools.has(tool.name)) throw new Error(`Tool ${tool.name} is already registered`);
-		const registeredTool = {
-			...tool.title ? { title: tool.title } : {},
-			description: tool.description,
-			inputSchema,
-			...outputSchema ? { outputSchema } : {},
-			...tool.annotations ? { annotations: tool.annotations } : {},
-			handler: async (args) => {
-				return normalizeToolResponse(await tool.execute(args, { requestUserInteraction: async (cb) => cb() }));
+		this.nativeSyncQueue = sync.then(() => void 0, () => void 0);
+		return sync;
+	}
+	async backfillNativeStandardTools(native) {
+		const tools = await native.getTools();
+		if (this.closed) return;
+		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;
 			}
-		};
-		this._tools.set(tool.name, registeredTool);
-		this.sendToolListChanged();
-		this.notifyProducerToolsChanged();
-	}
-	get ontoolchange() {
-		return this._ontoolchange;
-	}
-	set ontoolchange(handler) {
-		this._ontoolchange = handler;
-	}
-	addEventListener(type, listener, options) {
-		this._producerEventTarget.addEventListener(type, listener, options);
-	}
-	removeEventListener(type, listener, options) {
-		this._producerEventTarget.removeEventListener(type, listener, options);
-	}
-	dispatchEvent(event) {
-		return this._producerEventTarget.dispatchEvent(event);
-	}
-	notifyProducerToolsChanged() {
-		if (this._producerToolsChangedQueued) return;
-		this._producerToolsChangedQueued = true;
-		queueMicrotask(() => {
-			this._producerToolsChangedQueued = false;
-			const event = new Event("toolchange");
-			try {
-				this._ontoolchange?.call(this, event);
-			} catch (error) {
-				console.warn("[BrowserMcpServer] navigator.modelContext.ontoolchange handler threw:", error);
+			if (!inputSchema) {
+				console.warn(`[BrowserMcpServer] Native tool "${tool.name}" was not exposed over MCP because its input schema is malformed.`);
+				continue;
 			}
-			this.dispatchEvent(event);
-		});
-	}
-	backfillTools(tools, execute) {
-		let synced = 0;
-		for (const sourceTool of tools) {
-			if (!sourceTool?.name || this._tools.has(sourceTool.name)) continue;
-			const toolDescriptor = {
-				name: sourceTool.name,
-				description: sourceTool.description ?? "",
-				inputSchema: sourceTool.inputSchema ?? DEFAULT_INPUT_SCHEMA,
-				execute: async (args) => execute(sourceTool.name, args)
+			const item = {
+				name: tool.name,
+				...tool.title !== void 0 ? { title: tool.title } : {},
+				description: tool.description,
+				inputSchema,
+				...tool.annotations ? { annotations: tool.annotations } : {}
 			};
-			if (sourceTool.outputSchema) toolDescriptor.outputSchema = sourceTool.outputSchema;
-			if (sourceTool.annotations) toolDescriptor.annotations = sourceTool.annotations;
-			this.registerToolInServer(toolDescriptor);
-			synced++;
+			nextTools.set(tool.name, {
+				source: tool,
+				item,
+				fingerprint: JSON.stringify(item)
+			});
 		}
-		return synced;
-	}
-	registerTool(tool, options) {
-		const signal = options?.signal;
-		if (signal?.aborted) return Promise.reject(createAbortError());
-		this.registerNativeToolMirror(tool, signal);
-		try {
-			this.registerToolInServer(tool);
-		} catch (error) {
-			if (this.native) try {
-				this.unregisterNativeToolMirror(tool.name);
-			} catch (rollbackError) {
-				console.error("[BrowserMcpServer] Rollback of native tool registration failed:", rollbackError);
+		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;
 			}
-			throw error;
+			this.nativeBackfilledTools.set(name, next);
 		}
-		if (signal) signal.addEventListener("abort", () => {
-			const removed = this._tools.delete(tool.name);
-			if (removed) this.sendToolListChanged();
+		for (const [name, next] of nextTools) {
+			if (this.tools.has(name)) continue;
+			const execute = async (args, signal) => {
+				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));
+			};
+			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)
+			};
 			try {
-				this.unregisterNativeToolMirror(tool.name, { preferAbortSignal: true });
+				const normalized = this.validateToolDescriptor(tool);
+				this.tools.set(tool.name, this.registerToolInMcp(tool, normalized, execute, void 0));
+				this.nativeBackfilledTools.set(name, next);
 			} catch (error) {
-				console.warn("[BrowserMcpServer] Native unregister via abort fallback failed:", error);
+				console.warn(`[BrowserMcpServer] Native tool "${name}" was not exposed over MCP because its schema could not be compiled:`, error);
 			}
-			if (removed) this.notifyProducerToolsChanged();
-		}, { once: true });
-		return Promise.resolve();
-	}
-	/**
-	* Backfill tools that were already registered on the native/polyfill context
-	* before this BrowserMcpServer wrapper was installed.
-	*/
-	syncNativeTools() {
-		let synced = 0;
-		const nativeLegacyToolsApi = this.getNativeLegacyToolsApi();
-		if (nativeLegacyToolsApi) {
-			const nativeCallTool = nativeLegacyToolsApi.callTool.bind(nativeLegacyToolsApi);
-			synced += this.backfillTools(nativeLegacyToolsApi.listTools(), async (name, args) => nativeCallTool({
-				name,
-				arguments: args
-			}));
 		}
-		const nativeStandardToolsApi = this.getNativeStandardToolsApi();
-		if (nativeStandardToolsApi) this.backfillNativeStandardTools(nativeStandardToolsApi).catch((error) => {
-			console.warn("[BrowserMcpServer] Native WebMCP tool backfill failed:", error);
-		});
-		return synced;
-	}
-	async backfillNativeStandardTools(nativeToolsApi) {
-		const nativeTools = await nativeToolsApi.getTools.call(this.native);
-		return this.backfillTools(nativeTools.map(toToolListItemFromNativeToolInfo), async (name, args) => {
-			const nativeTool = nativeTools.find((tool) => tool.name === name);
-			if (!nativeTool) throw new Error(`Native tool not found: ${name}`);
-			return parseNativeToolResult(name, await nativeToolsApi.executeTool.call(this.native, nativeTool, JSON.stringify(args ?? {})));
-		});
-	}
-	unregisterTool(nameOrTool) {
-		this.warnUnregisterToolDeprecationOnce();
-		const name = this.resolveToolNameForUnregister(nameOrTool);
-		const removed = this._tools.delete(name);
-		if (removed) this.sendToolListChanged();
-		if (this.native) this.unregisterNativeToolMirror(name);
-		if (removed) this.notifyProducerToolsChanged();
 	}
 	registerResource(descriptor) {
-		const registered = super.registerResource(descriptor.name, descriptor.uri, {
-			...descriptor.description !== void 0 && { description: descriptor.description },
-			...descriptor.mimeType !== void 0 && { mimeType: descriptor.mimeType }
-		}, async (uri) => ({ contents: (await descriptor.read(uri)).contents }));
-		return { unregister: () => registered.remove() };
+		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 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);
+		return { unregister: () => {
+			if (this.registrations.delete(mcpHandle)) mcpHandle.remove();
+		} };
 	}
 	registerPrompt(descriptor) {
-		if (descriptor.argsSchema) this._promptSchemas.set(descriptor.name, descriptor.argsSchema);
-		const registered = super.registerPrompt(descriptor.name, { ...descriptor.description !== void 0 && { description: descriptor.description } }, async (args) => ({ messages: (await descriptor.get(args)).messages }));
+		if (this.closed) throw createInvalidStateError("BrowserMcpServer is closed");
+		const registeredDescriptor = {
+			...descriptor,
+			...descriptor.argsSchema === void 0 ? {} : { 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 ?? {}));
+		this.registrations.add(mcpHandle);
 		return { unregister: () => {
-			this._promptSchemas.delete(descriptor.name);
-			registered.remove();
+			if (this.registrations.delete(mcpHandle)) mcpHandle.remove();
 		} };
 	}
-	resolveToolNameForUnregister(nameOrTool) {
-		if (typeof nameOrTool === "string") return nameOrTool;
-		if (isPlainObject(nameOrTool) && typeof nameOrTool.name === "string") return nameOrTool.name;
-		throw new TypeError("Failed to execute 'unregisterTool' on 'ModelContext': parameter 1 must be a string or an object with a string name.");
-	}
-	warnUnregisterToolDeprecationOnce() {
-		if (this._unregisterToolDeprecationWarned) return;
-		this._unregisterToolDeprecationWarned = true;
-		console.warn("[BrowserMcpServer] navigator.modelContext.unregisterTool() is deprecated. The April 23, 2026 WebMCP draft removed it in favor of registerTool(tool, { signal }) — pass an AbortSignal and abort it to unregister.");
-	}
-	listResources() {
-		return Object.entries(this._parentResources).filter(([, resource]) => resource.enabled).map(([uri, resource]) => ({
-			uri,
-			name: resource.name,
-			...resource.metadata
-		}));
-	}
-	async readResource(uri) {
-		const resource = this._parentResources[uri];
-		if (!resource) throw new Error(`Resource not found: ${uri}`);
-		return resource.readCallback(new URL(uri), {});
-	}
-	listPrompts() {
-		return Object.entries(this._parentPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
-			const schema = this._promptSchemas.get(name);
-			return {
-				name,
-				...prompt.description !== void 0 && { description: prompt.description },
-				...schema?.properties ? { arguments: Object.entries(schema.properties).map(([argName, prop]) => ({
-					name: argName,
-					...typeof prop === "object" && prop !== null && "description" in prop ? { description: prop.description } : {},
-					...schema.required?.includes(argName) ? { required: true } : {}
-				})) } : {}
-			};
-		});
-	}
-	async getPrompt(name, args = {}) {
-		const prompt = this._parentPrompts[name];
-		if (!prompt) throw new Error(`Prompt not found: ${name}`);
-		const schema = this._promptSchemas.get(name);
-		if (schema) {
-			const result = this._jsonValidator.getValidator(schema)(args);
-			if (!result.valid) throw new Error(`Invalid arguments for prompt ${name}: ${result.errorMessage}`);
-		}
-		return prompt.callback(args, {});
-	}
 	listTools() {
-		return [...this._tools.entries()].map(([name, tool]) => {
-			const item = {
-				name,
-				description: tool.description ?? "",
-				inputSchema: tool.inputSchema
-			};
-			if (tool.outputSchema) item.outputSchema = tool.outputSchema;
-			if (tool.annotations) item.annotations = tool.annotations;
-			return item;
-		});
-	}
-	listToolsForMcpTransport() {
-		return this.listTools().map((tool) => {
-			if (!tool.outputSchema || tool.outputSchema.type === "object") return tool;
-			if (tool.outputSchema.type === void 0) return {
-				...tool,
-				outputSchema: {
-					...tool.outputSchema,
-					type: "object"
-				}
-			};
-			const { outputSchema: _outputSchema, ...mcpTool } = tool;
-			return mcpTool;
-		});
-	}
-	toMcpCallToolResult(result) {
-		return {
-			content: result.content,
-			...isPlainObject(result.structuredContent) ? { structuredContent: result.structuredContent } : {},
-			...result.isError !== void 0 ? { isError: result.isError } : {}
-		};
-	}
-	async getTools() {
-		const origin = typeof globalThis.location === "object" && typeof globalThis.location?.origin === "string" ? globalThis.location.origin : "";
-		const currentWindow = typeof globalThis.window === "object" ? globalThis.window : void 0;
-		return this.listTools().map((tool) => {
-			let inputSchema;
-			try {
-				inputSchema = JSON.stringify(tool.inputSchema ?? DEFAULT_INPUT_SCHEMA);
-			} catch {
-				inputSchema = JSON.stringify(DEFAULT_INPUT_SCHEMA);
-			}
+		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: tool.name,
-				title: this._tools.get(tool.name)?.title ?? tool.description ?? "",
-				description: tool.description ?? "",
-				inputSchema,
+				name: item.name,
+				title: item.title ?? "",
+				description: item.description,
+				...isPlainObject(parsed) ? { inputSchema: parsed } : {},
 				origin,
-				window: currentWindow
+				window: currentWindow,
+				...item.annotations ? { annotations: toWebMcpAnnotations(item.annotations) } : {}
 			};
-		});
-	}
-	/**
-	* Override SDK's validateToolInput to handle both Zod schemas and plain JSON Schema.
-	* Zod schemas use the SDK's safeParseAsync; plain JSON Schema uses the configured SDK validator.
-	*/
-	async validateToolInput(tool, args, toolName) {
-		if (!tool.inputSchema) return void 0;
-		if (this.isZodSchema(tool.inputSchema)) {
-			const result = await safeParseAsync(tool.inputSchema, args ?? {});
-			if (!result.success) throw new Error(`Invalid arguments for tool ${toolName}: ${getParseErrorMessage(result.error)}`);
-			return result.data;
+		}).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		return tools;
+	}
+	async executeTool(tool, inputArgsJson, options) {
+		validateWebMcpAccess(this.ownerDocument);
+		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);
 		}
-		const result = this._jsonValidator.getValidator(tool.inputSchema)(args ?? {});
-		if (!result.valid) throw new Error(`Invalid arguments for tool ${toolName}: ${result.errorMessage}`);
-		return result.data;
 	}
 	/**
-	* Override SDK's validateToolOutput to handle both Zod schemas and plain JSON Schema.
+	* 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.
 	*/
-	async validateToolOutput(tool, result, toolName) {
-		if (!tool.outputSchema) return;
-		const r = result;
-		if (!("content" in r) || r.isError) return;
-		if (r.structuredContent === void 0) throw new Error(`Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
-		if (this.isZodSchema(tool.outputSchema)) {
-			const parseResult = await safeParseAsync(tool.outputSchema, r.structuredContent);
-			if (!parseResult.success) throw new Error(`Output validation error: Invalid structured content for tool ${toolName}: ${getParseErrorMessage(parseResult.error)}`);
-			return;
+	applyToolExposure() {
+		for (const { exposedTo, mcpHandle } of this.tools.values()) {
+			if (!exposedTo?.length || !mcpHandle) continue;
+			const visible = this.peerOrigin !== void 0 && exposedTo.includes(this.peerOrigin);
+			if (visible === mcpHandle.enabled) continue;
+			if (visible) mcpHandle.enable();
+			else mcpHandle.disable();
 		}
-		const validationResult = this._jsonValidator.getValidator(tool.outputSchema)(r.structuredContent);
-		if (!validationResult.valid) throw new Error(`Output validation error: Invalid structured content for tool ${toolName}: ${validationResult.errorMessage}`);
 	}
 	/**
-	* Executes a registered tool by name.
-	*
-	* @deprecated Prefer the WebMCP standard producer path: get a descriptor from
-	* `getTools()` and pass it to `executeTool(tool, inputArgsJson)`. This method
-	* remains as an MCP-B compatibility convenience and MCP transport bridge.
+	* Follow the peer origin of transports that report one, so `exposedTo` can be scoped to
+	* the embedder actually connected. Duck-typed rather than imported: the SDK must not take
+	* a build dependency on `@mcp-b/transports`, and transports that never name a peer simply
+	* leave every restricted tool disabled.
 	*/
-	async callTool(params) {
-		const tool = this._tools.get(params.name);
-		if (!tool) throw new Error(`Tool not found: ${params.name}`);
-		const args = await this.validateToolInput(tool, params.arguments, params.name);
-		const result = await tool.handler(args ?? {});
-		await this.validateToolOutput(tool, result, params.name);
-		return result;
-	}
-	async executeTool(toolOrName, inputArgsJsonOrArgs = {}) {
-		if (typeof toolOrName === "string") return this.callTool({
-			name: toolOrName,
-			arguments: typeof inputArgsJsonOrArgs === "string" ? JSON.parse(inputArgsJsonOrArgs) : inputArgsJsonOrArgs
-		});
-		const result = await this.callTool({
-			name: toolOrName.name,
-			arguments: typeof inputArgsJsonOrArgs === "string" ? JSON.parse(inputArgsJsonOrArgs) : inputArgsJsonOrArgs
-		});
-		const serialized = JSON.stringify(result);
-		return serialized === void 0 ? null : serialized;
+	observePeerOrigin(transport) {
+		if (!("clientOrigin" in transport)) return;
+		const peered = transport;
+		this.peerOrigin = peered.clientOrigin;
+		this.applyToolExposure();
+		const previous = peered.onclientorigin;
+		peered.onclientorigin = (origin) => {
+			previous?.(origin);
+			this.peerOrigin = origin;
+			this.applyToolExposure();
+		};
 	}
-	/**
-	* Override connect to initialize request handlers BEFORE the transport connection.
-	* This prevents "Cannot register capabilities after connecting to transport" errors
-	* when tools are registered dynamically after connection.
-	*
-	* Tool handlers are installed with the public low-level Server API in the constructor.
-	* Prompt/resource handlers still come from the parent, then prompt handlers are replaced
-	* where the parent expects Zod shapes instead of plain JSON Schema.
-	*/
-	async connect(transport) {
-		this.setResourceRequestHandlers();
-		this.setPromptRequestHandlers();
-		this.server.setRequestHandler(ListPromptsRequestSchema$1, () => ({ prompts: this.listPrompts() }));
-		this.server.setRequestHandler(GetPromptRequestSchema$1, async (request) => {
-			const prompt = this._parentPrompts[request.params.name];
-			if (!prompt) throw new Error(`Prompt ${request.params.name} not found`);
-			if (!prompt.enabled) throw new Error(`Prompt ${request.params.name} disabled`);
-			const schema = this._promptSchemas.get(request.params.name);
-			if (schema) {
-				const result = this._jsonValidator.getValidator(schema)(request.params.arguments ?? {});
-				if (!result.valid) throw new Error(`Invalid arguments for prompt ${request.params.name}: ${result.errorMessage}`);
-				return prompt.callback(request.params.arguments, {});
+	connect(transport) {
+		if (this.closed) return Promise.reject(createInvalidStateError("BrowserMcpServer is closed"));
+		this.observePeerOrigin(transport);
+		return this.mcpServer.connect(transport);
+	}
+	close() {
+		if (this.closePromise) return this.closePromise;
+		this.closed = true;
+		this.closePromise = (async () => {
+			if (this.native && this.nativeToolChangeListener) {
+				this.native.removeEventListener("toolchange", this.nativeToolChangeListener);
+				this.nativeToolChangeListener = void 0;
 			}
-			return prompt.callback({}, {});
-		});
-		return super.connect(transport);
-	}
-	async createMessage(params, options) {
-		return this.server.createMessage(params, withDefaultTimeout(options));
-	}
-	async elicitInput(params, options) {
-		return this.server.elicitInput(params, withDefaultTimeout(options));
-	}
-};
-
-//#endregion
-//#region src/no-op-validator.ts
-/**
-* No-op JSON Schema validator for browser environments.
-*
-* This validator bypasses the MCP SDK's internal ajv-based validation which causes
-* "Error compiling schema" errors in browser extensions due to ajv's use of
-* eval/Function constructor.
-*
-* Validation is handled externally by Zod in @mcp-b/global, making the SDK's
-* internal validation redundant. This no-op validator allows the SDK to function
-* without the ajv dependency issues.
-*/
-/**
-* A no-op JSON Schema validator that always returns valid.
-*
-* Use this in browser environments where:
-* - ajv causes "Error compiling schema" errors
-* - Validation is already handled elsewhere (e.g., by Zod)
-* - You need to avoid eval/Function constructor restrictions
-*
-* @example
-* ```typescript
-* import { BrowserMcpServer } from '@mcp-b/webmcp-ts-sdk';
-* import { NoOpJsonSchemaValidator } from '@mcp-b/webmcp-ts-sdk/no-op-validator';
-*
-* const server = new BrowserMcpServer(
-*   { name: 'my-server', version: '1.0.0' },
-*   { jsonSchemaValidator: new NoOpJsonSchemaValidator() }
-* );
-* ```
-*/
-var NoOpJsonSchemaValidator = class {
-	/**
-	* Returns a validator function that always passes.
-	* The input data is passed through unchanged.
-	*
-	* @param _schema - The JSON Schema (ignored)
-	* @returns A validator function that always returns valid
-	*/
-	getValidator(_schema) {
-		return (input) => ({
-			valid: true,
-			data: input,
-			errorMessage: void 0
-		});
+			for (const name of this.nativeToolAbortControllers.keys()) this.abortNativeToolMirror(name);
+			for (const name of this.tools.keys()) this.removeTool(name, { notify: false });
+			for (const handle of this.registrations) handle.remove();
+			this.registrations.clear();
+			this.nativeBackfilledTools.clear();
+			this.removingNativeTools.clear();
+			await this.mcpServer.close();
+		})();
+		return this.closePromise;
 	}
 };
 
 //#endregion
-export { BrowserMcpServer, BrowserMcpServer as McpServer, CallToolRequestSchema, CallToolResultSchema, CfWorkerJsonSchemaValidator, Client, CreateMessageRequestSchema, CreateMessageResultSchema, ElicitRequestSchema, ElicitResultSchema, ErrorCode, GetPromptRequestSchema, GetPromptResultSchema, InitializeRequestSchema, InitializeResultSchema, JSONRPCMessageSchema, LATEST_PROTOCOL_VERSION, ListPromptsRequestSchema, ListPromptsResultSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListToolsRequestSchema, ListToolsResultSchema, LoggingLevelSchema, NoOpJsonSchemaValidator, PolyfillJsonSchemaValidator, ReadBuffer, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SERVER_MARKER_PROPERTY, SUPPORTED_PROTOCOL_VERSIONS, ToolListChangedNotificationSchema, mergeCapabilities, serializeMessage };
+export { BrowserMcpServer, isBrowserMcpServer };
 //# sourceMappingURL=index.js.map