@mcp-b/global 1.3.0 → 1.5.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { IframeChildTransport, TabServerTransport } from "@mcp-b/transports";
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, Server } from "@mcp-b/webmcp-ts-sdk";
-import { jsonSchemaToZod } from "@n8n/json-schema-to-zod";
+import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
 import { z } from "zod";
 import { zodToJsonSchema as zodToJsonSchema$1 } from "zod-to-json-schema";
 
@@ -89,6 +89,24 @@ function createLogger(namespace) {
 	};
 }
 
+//#endregion
+//#region src/tab-server-capabilities.ts
+function getTabServerCapabilities(server) {
+	return server.server;
+}
+function requireCreateMessageCapability(server) {
+	const capabilities = getTabServerCapabilities(server);
+	const createMessage = capabilities?.createMessage;
+	if (!createMessage) throw new Error("Sampling is not supported: no connected client with sampling capability");
+	return createMessage.bind(capabilities);
+}
+function requireElicitInputCapability(server) {
+	const capabilities = getTabServerCapabilities(server);
+	const elicitInput = capabilities?.elicitInput;
+	if (!elicitInput) throw new Error("Elicitation is not supported: no connected client with elicitation capability");
+	return elicitInput.bind(capabilities);
+}
+
 //#endregion
 //#region src/validation.ts
 const logger$2 = createLogger("WebModelContext");
@@ -159,27 +177,17 @@ function validateWithZod(data, validator) {
 }
 
 //#endregion
-//#region src/global.ts
-const logger$1 = createLogger("WebModelContext");
+//#region src/native-adapter.ts
 const nativeLogger = createLogger("NativeAdapter");
-const bridgeLogger = createLogger("MCPBridge");
-const testingLogger = createLogger("ModelContextTesting");
-/**
-* Marker property name used to identify polyfill implementations.
-* This constant ensures single source of truth for the marker used in
-* both detection (detectNativeAPI) and definition (WebModelContextTesting).
-*/
-const POLYFILL_MARKER_PROPERTY = "__isWebMCPPolyfill";
+const testingLogger$1 = createLogger("ModelContextTesting");
+const POLYFILL_MARKER_PROPERTY$1 = "__isWebMCPPolyfill";
+const CONSUMER_SHIM_MARKER_PROPERTY = "__webMCPConsumerShimInstalled";
+const CONSUMER_CALL_TOOL_SHIM_MARKER_PROPERTY = "__webMCPCallToolShimInstalled";
+const MODEL_CONTEXT_TESTING_DEPRECATION_MESSAGE = "navigator.modelContextTesting is deprecated. Use navigator.modelContext.callTool() and addEventListener('toolschanged', ...) instead.";
 /**
 * Detect if the native Chromium Web Model Context API is available.
 * Checks for both navigator.modelContext and navigator.modelContextTesting,
 * and verifies they are native implementations (not polyfills).
-*
-* Detection uses a marker property (`__isWebMCPPolyfill`) on the testing API
-* to reliably distinguish polyfills from native implementations. This approach
-* works correctly even when class names are minified in production builds.
-*
-* @returns Detection result with flags for native context and testing API availability
 */
 function detectNativeAPI() {
 	/* c8 ignore next 2 */
@@ -193,7 +201,7 @@ function detectNativeAPI() {
 		hasNativeContext: Boolean(modelContext),
 		hasNativeTesting: Boolean(modelContextTesting)
 	};
-	if (POLYFILL_MARKER_PROPERTY in modelContextTesting && modelContextTesting[POLYFILL_MARKER_PROPERTY] === true) return {
+	if (POLYFILL_MARKER_PROPERTY$1 in modelContextTesting && modelContextTesting[POLYFILL_MARKER_PROPERTY$1] === true) return {
 		hasNativeContext: false,
 		hasNativeTesting: false
 	};
@@ -203,62 +211,146 @@ function detectNativeAPI() {
 	};
 }
 /**
+* Installs a deprecation getter for navigator.modelContextTesting.
+* Emits a warning on first access while preserving compatibility behavior.
+*/
+function installDeprecatedTestingAccessor(modelContextTesting) {
+	let hasWarned = false;
+	try {
+		Object.defineProperty(window.navigator, "modelContextTesting", {
+			configurable: true,
+			enumerable: true,
+			get() {
+				if (!hasWarned) {
+					testingLogger$1.warn(MODEL_CONTEXT_TESTING_DEPRECATION_MESSAGE);
+					hasWarned = true;
+				}
+				return modelContextTesting;
+			}
+		});
+	} catch (error) {
+		testingLogger$1.warn("Failed to install modelContextTesting deprecation accessor:", error);
+	}
+}
+/**
+* Dispatches a tools-changed event on a modelContext object.
+*/
+function dispatchToolsChangedEvent(modelContext) {
+	try {
+		modelContext.dispatchEvent(new Event("toolschanged"));
+	} catch (error) {
+		nativeLogger.warn("Failed to dispatch \"toolschanged\" event:", error);
+	}
+}
+/**
+* Installs consumer methods on an existing modelContext object.
+* This allows native producer APIs to expose consumer semantics without replacing the object.
+*/
+function installConsumerShim(nativeContext, callTool, options) {
+	const target = nativeContext;
+	if (target[CONSUMER_SHIM_MARKER_PROPERTY] === true) return;
+	let installedCallToolShim = false;
+	if (typeof target.callTool !== "function") try {
+		Object.defineProperty(target, "callTool", {
+			configurable: true,
+			writable: true,
+			value: callTool
+		});
+		installedCallToolShim = true;
+	} catch (error) {
+		nativeLogger.warn("Failed to install modelContext.callTool shim:", error);
+	}
+	if (!options.hasNativeTesting) {
+		const queueToolsChanged = () => {
+			if (options.onToolRegistryMutated) {
+				queueMicrotask(options.onToolRegistryMutated);
+				return;
+			}
+			queueMicrotask(() => dispatchToolsChangedEvent(nativeContext));
+		};
+		const wrapMethod = (methodName) => {
+			const original = target[methodName];
+			if (typeof original !== "function") return;
+			try {
+				Object.defineProperty(target, methodName, {
+					configurable: true,
+					writable: true,
+					value: (...args) => {
+						const result = original.apply(target, args);
+						if (methodName === "registerTool" && result && typeof result === "object" && "unregister" in result) {
+							const registration = result;
+							if (typeof registration.unregister === "function") {
+								const originalUnregister = registration.unregister.bind(registration);
+								registration.unregister = () => {
+									originalUnregister();
+									queueToolsChanged();
+								};
+							}
+						}
+						queueToolsChanged();
+						return result;
+					}
+				});
+			} catch (error) {
+				nativeLogger.warn(`Failed to wrap modelContext.${methodName} for "toolschanged":`, error);
+			}
+		};
+		wrapMethod("provideContext");
+		wrapMethod("registerTool");
+		wrapMethod("unregisterTool");
+		wrapMethod("clearContext");
+	}
+	try {
+		Object.defineProperty(target, CONSUMER_SHIM_MARKER_PROPERTY, {
+			configurable: true,
+			enumerable: false,
+			writable: false,
+			value: true
+		});
+		if (installedCallToolShim) Object.defineProperty(target, CONSUMER_CALL_TOOL_SHIM_MARKER_PROPERTY, {
+			configurable: true,
+			enumerable: false,
+			writable: false,
+			value: true
+		});
+	} catch {}
+}
+/**
 * Adapter that wraps the native Chromium Web Model Context API.
 * Synchronizes tool changes from the native API to the MCP bridge,
 * enabling MCP clients to stay in sync with the native tool registry.
-*
-* Key features:
-* - Listens to native tool changes via registerToolsChangedCallback()
-* - Syncs native tools to MCP bridge automatically
-* - Delegates tool execution to native API
-* - Converts native results to MCP ToolResponse format
-*
-* @class NativeModelContextAdapter
-* @implements {InternalModelContext}
 */
 var NativeModelContextAdapter = class {
 	nativeContext;
 	nativeTesting;
 	bridge;
 	syncInProgress = false;
-	/**
-	* Creates a new NativeModelContextAdapter.
-	*
-	* @param {MCPBridge} bridge - The MCP bridge instance
-	* @param {ModelContext} nativeContext - The native navigator.modelContext
-	* @param {ModelContextTesting} nativeTesting - The native navigator.modelContextTesting
-	*/
+	hasCompletedInitialToolSync = false;
 	constructor(bridge, nativeContext, nativeTesting) {
 		this.bridge = bridge;
 		this.nativeContext = nativeContext;
 		this.nativeTesting = nativeTesting;
-		this.nativeTesting.registerToolsChangedCallback(() => {
+		if (this.nativeTesting) this.nativeTesting.registerToolsChangedCallback(() => {
 			this.syncToolsFromNative();
 		});
 		this.syncToolsFromNative();
 	}
-	/**
-	* Synchronizes tools from the native API to the MCP bridge.
-	* Fetches all tools from navigator.modelContextTesting.listTools()
-	* and updates the bridge's tool registry.
-	*
-	* @private
-	*/
 	syncToolsFromNative() {
 		if (this.syncInProgress) return;
 		this.syncInProgress = true;
 		try {
-			const nativeTools = this.nativeTesting.listTools();
+			const nativeTestingTools = this.nativeTesting?.listTools();
+			const nativeTools = this.nativeContext.listTools();
 			this.bridge.tools.clear();
-			for (const toolInfo of nativeTools) try {
-				const inputSchema = JSON.parse(toolInfo.inputSchema);
+			const sourceTools = nativeTestingTools ?? nativeTools;
+			for (const toolInfo of sourceTools) try {
+				const inputSchema = nativeTestingTools && "inputSchema" in toolInfo && typeof toolInfo.inputSchema === "string" ? JSON.parse(toolInfo.inputSchema) : toolInfo.inputSchema ?? { type: "object" };
 				const validatedTool = {
 					name: toolInfo.name,
 					description: toolInfo.description,
 					inputSchema,
 					execute: async (args) => {
-						const result = await this.nativeTesting.executeTool(toolInfo.name, JSON.stringify(args));
-						return this.convertToToolResponse(result);
+						return this.executeTool(toolInfo.name, args);
 					},
 					inputValidator: jsonSchemaToZod$1(inputSchema)
 				};
@@ -267,19 +359,39 @@ var NativeModelContextAdapter = class {
 				nativeLogger.error(`Failed to sync tool "${toolInfo.name}":`, error);
 			}
 			this.notifyMCPServers();
+			if (this.hasCompletedInitialToolSync) dispatchToolsChangedEvent(this.nativeContext);
+			else this.hasCompletedInitialToolSync = true;
 		} finally {
 			this.syncInProgress = false;
 		}
 	}
 	/**
-	* Converts native API result to MCP ToolResponse format.
-	* Native API returns simplified values (string, number, object, etc.)
-	* which need to be wrapped in the MCP CallToolResult format.
-	*
-	* @param {unknown} result - The result from native executeTool()
-	* @returns {ToolResponse} Formatted MCP ToolResponse
-	* @private
+	* Public refresh hook for consumer shims that detect native tool mutations
+	* without modelContextTesting callbacks.
 	*/
+	refreshToolsFromNative() {
+		this.syncToolsFromNative();
+	}
+	async executeToolViaNative(toolName, args) {
+		const nativeWithConsumer = this.nativeContext;
+		if (typeof nativeWithConsumer.callTool === "function" && nativeWithConsumer[CONSUMER_CALL_TOOL_SHIM_MARKER_PROPERTY] !== true) {
+			const result = await nativeWithConsumer.callTool({
+				name: toolName,
+				arguments: args
+			});
+			if (result && typeof result === "object" && "content" in result && Array.isArray(result.content)) return result;
+			return this.convertToToolResponse(result);
+		}
+		if (this.nativeTesting) {
+			const result = await this.nativeTesting.executeTool(toolName, JSON.stringify(args));
+			return this.convertToToolResponse(result);
+		}
+		if (typeof nativeWithConsumer.executeTool === "function") {
+			const result = await nativeWithConsumer.executeTool(toolName, args);
+			return this.convertToToolResponse(result);
+		}
+		throw new Error("[Native Adapter] Tool execution is not supported by this native implementation");
+	}
 	convertToToolResponse(result) {
 		if (typeof result === "string") return { content: [{
 			type: "text",
@@ -301,11 +413,6 @@ var NativeModelContextAdapter = class {
 			text: String(result)
 		}] };
 	}
-	/**
-	* Notifies all connected MCP servers that the tools list has changed.
-	*
-	* @private
-	*/
 	notifyMCPServers() {
 		if (this.bridge.tabServer?.notification) this.bridge.tabServer.notification({
 			method: "notifications/tools/list_changed",
@@ -316,13 +423,6 @@ var NativeModelContextAdapter = class {
 			params: {}
 		});
 	}
-	/**
-	* Provides context (tools) to AI models via the native API.
-	* Converts Zod schemas to JSON Schema before passing to native API.
-	* Tool change callback will fire and trigger sync automatically.
-	*
-	* @param {ModelContextInput} context - Context containing tools to register
-	*/
 	provideContext(context) {
 		const { tools,...rest } = context;
 		const normalizedContext = { ...rest };
@@ -332,14 +432,6 @@ var NativeModelContextAdapter = class {
 		}));
 		this.nativeContext.provideContext(normalizedContext);
 	}
-	/**
-	* Registers a single tool dynamically via the native API.
-	* Converts Zod schemas to JSON Schema before passing to native API.
-	* Tool change callback will fire and trigger sync automatically.
-	*
-	* @param {ToolDescriptor} tool - The tool descriptor to register
-	* @returns {{unregister: () => void}} Object with unregister function
-	*/
 	registerTool(tool) {
 		const normalizedTool = {
 			...tool,
@@ -347,37 +439,15 @@ var NativeModelContextAdapter = class {
 		};
 		return this.nativeContext.registerTool(normalizedTool);
 	}
-	/**
-	* Unregisters a tool by name via the native API.
-	* Delegates to navigator.modelContext.unregisterTool().
-	*
-	* @param {string} name - Name of the tool to unregister
-	*/
 	unregisterTool(name) {
 		this.nativeContext.unregisterTool(name);
 	}
-	/**
-	* Clears all registered tools via the native API.
-	* Delegates to navigator.modelContext.clearContext().
-	*/
 	clearContext() {
 		this.nativeContext.clearContext();
 	}
-	/**
-	* Executes a tool via the native API.
-	* Delegates to navigator.modelContextTesting.executeTool() with JSON string args.
-	* Note: skipValidation option is ignored - native API handles its own validation.
-	*
-	* @param {string} toolName - Name of the tool to execute
-	* @param {Record<string, unknown>} args - Arguments to pass to the tool
-	* @param {Object} [_options] - Execution options (ignored for native adapter)
-	* @returns {Promise<ToolResponse>} The tool's response in MCP format
-	* @internal
-	*/
 	async executeTool(toolName, args, _options) {
 		try {
-			const result = await this.nativeTesting.executeTool(toolName, JSON.stringify(args));
-			return this.convertToToolResponse(result);
+			return await this.executeToolViaNative(toolName, args);
 		} catch (error) {
 			nativeLogger.error(`Error executing tool "${toolName}":`, error);
 			return {
@@ -389,12 +459,6 @@ var NativeModelContextAdapter = class {
 			};
 		}
 	}
-	/**
-	* Lists all registered tools from the MCP bridge.
-	* Returns tools synced from the native API.
-	*
-	* @returns {Array<{name: string, description: string, inputSchema: InputSchema}>} Array of tool descriptors
-	*/
 	listTools() {
 		return Array.from(this.bridge.tools.values()).map((tool) => ({
 			name: tool.name,
@@ -404,128 +468,76 @@ var NativeModelContextAdapter = class {
 			...tool.annotations && { annotations: tool.annotations }
 		}));
 	}
-	/**
-	* Registers a resource dynamically.
-	* Note: Native Chromium API does not yet support resources.
-	* This is a polyfill-only feature.
-	*/
+	async callTool(params) {
+		if (!params?.name || typeof params.name !== "string") throw new Error("Tool name is required");
+		if (!this.bridge.tools.has(params.name)) throw new Error(`Tool not found: ${params.name}`);
+		return this.executeTool(params.name, params.arguments ?? {});
+	}
 	registerResource(_resource) {
 		nativeLogger.warn("registerResource is not supported by native API");
 		return { unregister: () => {} };
 	}
-	/**
-	* Unregisters a resource by URI.
-	* Note: Native Chromium API does not yet support resources.
-	*/
 	unregisterResource(_uri) {
 		nativeLogger.warn("unregisterResource is not supported by native API");
 	}
-	/**
-	* Lists all registered resources.
-	* Note: Native Chromium API does not yet support resources.
-	*/
 	listResources() {
 		return [];
 	}
-	/**
-	* Lists all resource templates.
-	* Note: Native Chromium API does not yet support resources.
-	*/
 	listResourceTemplates() {
 		return [];
 	}
-	/**
-	* Reads a resource by URI.
-	* Note: Native Chromium API does not yet support resources.
-	* @internal
-	*/
 	async readResource(_uri) {
 		throw new Error("[Native Adapter] readResource is not supported by native API");
 	}
-	/**
-	* Registers a prompt dynamically.
-	* Note: Native Chromium API does not yet support prompts.
-	* This is a polyfill-only feature.
-	*/
 	registerPrompt(_prompt) {
 		nativeLogger.warn("registerPrompt is not supported by native API");
 		return { unregister: () => {} };
 	}
-	/**
-	* Unregisters a prompt by name.
-	* Note: Native Chromium API does not yet support prompts.
-	*/
 	unregisterPrompt(_name) {
 		nativeLogger.warn("unregisterPrompt is not supported by native API");
 	}
-	/**
-	* Lists all registered prompts.
-	* Note: Native Chromium API does not yet support prompts.
-	*/
 	listPrompts() {
 		return [];
 	}
-	/**
-	* Gets a prompt with arguments.
-	* Note: Native Chromium API does not yet support prompts.
-	* @internal
-	*/
 	async getPrompt(_name, _args) {
 		throw new Error("[Native Adapter] getPrompt is not supported by native API");
 	}
-	/**
-	* Adds an event listener for tool call events.
-	* Delegates to the native API's addEventListener.
-	*
-	* @param {'toolcall'} type - Event type
-	* @param {(event: ToolCallEvent) => void | Promise<void>} listener - Event handler
-	* @param {boolean | AddEventListenerOptions} [options] - Event listener options
-	*/
 	addEventListener(type, listener, options) {
-		this.nativeContext.addEventListener(type, listener, options);
+		if (type === "toolcall") {
+			this.nativeContext.addEventListener("toolcall", listener, options);
+			return;
+		}
+		this.nativeContext.addEventListener("toolschanged", listener, options);
 	}
-	/**
-	* Removes an event listener for tool call events.
-	* Delegates to the native API's removeEventListener.
-	*
-	* @param {'toolcall'} type - Event type
-	* @param {(event: ToolCallEvent) => void | Promise<void>} listener - Event handler
-	* @param {boolean | EventListenerOptions} [options] - Event listener options
-	*/
 	removeEventListener(type, listener, options) {
-		this.nativeContext.removeEventListener(type, listener, options);
+		if (type === "toolcall") {
+			this.nativeContext.removeEventListener("toolcall", listener, options);
+			return;
+		}
+		this.nativeContext.removeEventListener("toolschanged", listener, options);
 	}
-	/**
-	* Dispatches a tool call event.
-	* Delegates to the native API's dispatchEvent.
-	*
-	* @param {Event} event - The event to dispatch
-	* @returns {boolean} False if event was cancelled, true otherwise
-	*/
 	dispatchEvent(event) {
 		return this.nativeContext.dispatchEvent(event);
 	}
-	/**
-	* Request an LLM completion from the connected client.
-	* Note: Native Chromium API does not yet support sampling.
-	* This is handled by the polyfill.
-	*/
 	async createMessage(params) {
-		const underlyingServer = this.bridge.tabServer.server;
-		if (!underlyingServer?.createMessage) throw new Error("Sampling is not supported: no connected client with sampling capability");
-		return underlyingServer.createMessage(params);
+		return requireCreateMessageCapability(this.bridge.tabServer)(params);
 	}
-	/**
-	* Request user input from the connected client.
-	* Note: Native Chromium API does not yet support elicitation.
-	* This is handled by the polyfill.
-	*/
 	async elicitInput(params) {
-		const underlyingServer = this.bridge.tabServer.server;
-		if (!underlyingServer?.elicitInput) throw new Error("Elicitation is not supported: no connected client with elicitation capability");
-		return underlyingServer.elicitInput(params);
+		return requireElicitInputCapability(this.bridge.tabServer)(params);
 	}
 };
+
+//#endregion
+//#region src/global.ts
+const logger$1 = createLogger("WebModelContext");
+const bridgeLogger = createLogger("MCPBridge");
+const testingLogger = createLogger("ModelContextTesting");
+/**
+* Marker property name used to identify polyfill implementations.
+* This constant ensures single source of truth for the marker used in
+* both detection (detectNativeAPI) and definition (WebModelContextTesting).
+*/
+const POLYFILL_MARKER_PROPERTY = "__isWebMCPPolyfill";
 /**
 * ToolCallEvent implementation for the Web Model Context API.
 * Represents an event fired when a tool is called, allowing event listeners
@@ -599,7 +611,7 @@ var WebModelContextTesting = class {
 	* This approach works reliably even when class names are minified in production builds.
 	*
 	* @see POLYFILL_MARKER_PROPERTY - The constant defining this property name
-	* @see MayHavePolyfillMarker - The interface for type-safe detection
+	* @see detectNativeAPI in native-adapter.ts - native/polyfill detection logic
 	*/
 	[POLYFILL_MARKER_PROPERTY] = true;
 	toolCallHistory = [];
@@ -830,23 +842,9 @@ var WebModelContext = class {
 	setTestingAPI(testingAPI) {
 		this.testingAPI = testingAPI;
 	}
-	/**
-	* Adds an event listener for tool call events.
-	*
-	* @param {'toolcall'} type - Event type (only 'toolcall' is supported)
-	* @param {(event: ToolCallEvent) => void | Promise<void>} listener - Event handler function
-	* @param {boolean | AddEventListenerOptions} [options] - Event listener options
-	*/
 	addEventListener(type, listener, options) {
 		this.eventTarget.addEventListener(type, listener, options);
 	}
-	/**
-	* Removes an event listener for tool call events.
-	*
-	* @param {'toolcall'} type - Event type (only 'toolcall' is supported)
-	* @param {(event: ToolCallEvent) => void | Promise<void>} listener - Event handler function
-	* @param {boolean | EventListenerOptions} [options] - Event listener options
-	*/
 	removeEventListener(type, listener, options) {
 		this.eventTarget.removeEventListener(type, listener, options);
 	}
@@ -916,7 +914,7 @@ var WebModelContext = class {
 		const templateParams = [];
 		for (const match of resource.uri.matchAll(templateParamRegex)) {
 			const paramName = match[1];
-			templateParams.push(paramName);
+			if (typeof paramName === "string") templateParams.push(paramName);
 		}
 		return {
 			uri: resource.uri,
@@ -1238,6 +1236,7 @@ var WebModelContext = class {
 			params: {}
 		});
 		if (this.testingAPI && "notifyToolsChanged" in this.testingAPI) this.testingAPI.notifyToolsChanged();
+		this.dispatchEvent(new Event("toolschanged"));
 	}
 	/**
 	* Updates the bridge resources map with merged resources from both buckets.
@@ -1387,7 +1386,9 @@ var WebModelContext = class {
 		const params = {};
 		for (let i = 0; i < paramNames.length; i++) {
 			const paramName = paramNames[i];
-			params[paramName] = match[i + 1];
+			const paramValue = match[i + 1];
+			if (typeof paramName !== "string" || typeof paramValue !== "string") continue;
+			params[paramName] = paramValue;
 		}
 		return params;
 	}
@@ -1501,6 +1502,15 @@ var WebModelContext = class {
 		}));
 	}
 	/**
+	* Executes a registered tool using MCP-style params.
+	* Throws for missing tools and returns MCP-shaped errors for execution/validation failures.
+	*/
+	async callTool(params) {
+		if (!params?.name || typeof params.name !== "string") throw new Error("Tool name is required");
+		if (!this.bridge.tools.has(params.name)) throw new Error(`Tool not found: ${params.name}`);
+		return this.executeTool(params.name, params.arguments ?? {});
+	}
+	/**
 	* Request an LLM completion from the connected client.
 	* This sends a sampling request to the connected MCP client.
 	*
@@ -1508,9 +1518,7 @@ var WebModelContext = class {
 	* @returns {Promise<SamplingResult>} The LLM completion result
 	*/
 	async createMessage(params) {
-		const underlyingServer = this.bridge.tabServer.server;
-		if (!underlyingServer?.createMessage) throw new Error("Sampling is not supported: no connected client with sampling capability");
-		return underlyingServer.createMessage(params);
+		return requireCreateMessageCapability(this.bridge.tabServer)(params);
 	}
 	/**
 	* Request user input from the connected client.
@@ -1520,9 +1528,7 @@ var WebModelContext = class {
 	* @returns {Promise<ElicitationResult>} The user's response
 	*/
 	async elicitInput(params) {
-		const underlyingServer = this.bridge.tabServer.server;
-		if (!underlyingServer?.elicitInput) throw new Error("Elicitation is not supported: no connected client with elicitation capability");
-		return underlyingServer.elicitInput(params);
+		return requireElicitInputCapability(this.bridge.tabServer)(params);
 	}
 };
 /**
@@ -1678,43 +1684,44 @@ function initializeWebModelContext(options) {
 	}
 	const effectiveOptions = options ?? window.__webModelContextOptions;
 	const native = detectNativeAPI();
-	if (native.hasNativeContext && native.hasNativeTesting) {
+	if (native.hasNativeContext) {
 		const nativeContext = window.navigator.modelContext;
-		const nativeTesting = window.navigator.modelContextTesting;
-		if (!nativeContext || !nativeTesting) {
+		const nativeTesting = native.hasNativeTesting ? window.navigator.modelContextTesting : void 0;
+		if (!nativeContext) {
 			logger$1.error("Native API detection mismatch");
 			return;
 		}
 		logger$1.info("✅ Native Chromium API detected");
-		logger$1.info("   Using native implementation with MCP bridge synchronization");
-		logger$1.info("   Native API will automatically collect tools from embedded iframes");
+		if (nativeTesting) {
+			logger$1.info("   Using native implementation with MCP bridge synchronization");
+			logger$1.info("   Native API will automatically collect tools from embedded iframes");
+		} else logger$1.info("   Native modelContextTesting not detected; installing consumer shim on modelContext");
 		try {
 			const bridge = initializeMCPBridge(effectiveOptions);
-			bridge.modelContext = new NativeModelContextAdapter(bridge, nativeContext, nativeTesting);
-			bridge.modelContextTesting = nativeTesting;
+			const adapter = new NativeModelContextAdapter(bridge, nativeContext, nativeTesting);
+			bridge.modelContext = adapter;
+			if (nativeTesting) {
+				bridge.modelContextTesting = nativeTesting;
+				installDeprecatedTestingAccessor(nativeTesting);
+			}
+			installConsumerShim(nativeContext, (params) => adapter.callTool(params), {
+				hasNativeTesting: Boolean(nativeTesting),
+				...!nativeTesting && { onToolRegistryMutated: () => adapter.refreshToolsFromNative() }
+			});
 			Object.defineProperty(window, "__mcpBridge", {
 				value: bridge,
 				writable: false,
 				configurable: true
 			});
 			logger$1.info("✅ MCP bridge synced with native API");
-			logger$1.info("   MCP clients will receive automatic tool updates from native registry");
+			if (nativeTesting) logger$1.info("   MCP clients will receive automatic tool updates from native registry");
+			else logger$1.warn("   Native testing callbacks are unavailable; tool list change events are best-effort.");
 		} catch (error) {
 			logger$1.error("Failed to initialize native adapter:", error);
 			throw error;
 		}
 		return;
 	}
-	if (native.hasNativeContext && !native.hasNativeTesting) {
-		logger$1.warn("Partial native API detected");
-		logger$1.warn("   navigator.modelContext exists but navigator.modelContextTesting is missing");
-		logger$1.warn("   Cannot sync with native API. Please enable experimental features:");
-		logger$1.warn("      - Navigate to chrome://flags");
-		logger$1.warn("      - Enable \"Experimental Web Platform Features\"");
-		logger$1.warn("      - Or launch with: --enable-experimental-web-platform-features");
-		logger$1.warn("   Skipping initialization to avoid conflicts");
-		return;
-	}
 	if (window.navigator.modelContext) {
 		logger$1.warn("window.navigator.modelContext already exists, skipping initialization");
 		return;
@@ -1741,11 +1748,7 @@ function initializeWebModelContext(options) {
 		const testingAPI = new WebModelContextTesting(bridge);
 		bridge.modelContextTesting = testingAPI;
 		bridge.modelContext.setTestingAPI(testingAPI);
-		Object.defineProperty(window.navigator, "modelContextTesting", {
-			value: testingAPI,
-			writable: false,
-			configurable: true
-		});
+		installDeprecatedTestingAccessor(testingAPI);
 		testingLogger.info("✅ Polyfill installed at window.navigator.modelContextTesting");
 	} catch (error) {
 		logger$1.error("Failed to initialize:", error);
@@ -1773,8 +1776,19 @@ function cleanupWebModelContext() {
 	} catch (error) {
 		logger$1.warn("Error closing MCP servers:", error);
 	}
-	delete window.navigator.modelContext;
-	delete window.navigator.modelContextTesting;
+	const safeDeleteNavigatorProperty = (propertyName) => {
+		if (Object.getOwnPropertyDescriptor(window.navigator, propertyName)?.configurable === false) {
+			logger$1.debug(`Skipping cleanup for navigator.${propertyName} because property is non-configurable`);
+			return;
+		}
+		try {
+			delete window.navigator[propertyName];
+		} catch (error) {
+			logger$1.warn(`Failed to remove navigator.${propertyName} during cleanup:`, error);
+		}
+	};
+	safeDeleteNavigatorProperty("modelContext");
+	safeDeleteNavigatorProperty("modelContextTesting");
 	delete window.__mcpBridge;
 	logger$1.info("Cleaned up");
 }