@mcp-b/global 0.0.0-beta-20260109203913

package/dist/index.js

@@ -0,0 +1,1790 @@
+import { IframeChildTransport, TabServerTransport } from "@mcp-b/transports";
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, Server } from "@mcp-b/webmcp-ts-sdk";
+import { jsonSchemaToZod } from "@composio/json-schema-to-zod";
+import { z } from "zod";
+import { zodToJsonSchema as zodToJsonSchema$1 } from "zod-to-json-schema";
+
+//#region src/validation.ts
+/**
+* Detect if a schema is a Zod schema object (Record<string, ZodType>)
+* or a JSON Schema object
+*/
+function isZodSchema(schema) {
+	if (typeof schema !== "object" || schema === null) return false;
+	if ("type" in schema && typeof schema.type === "string") return false;
+	const values = Object.values(schema);
+	if (values.length === 0) return false;
+	return values.some((val) => val instanceof z.ZodType);
+}
+/**
+* Convert JSON Schema to Zod validator
+* Uses @composio/json-schema-to-zod for conversion
+*/
+function jsonSchemaToZod$1(jsonSchema) {
+	try {
+		return jsonSchemaToZod(jsonSchema);
+	} catch (error) {
+		console.warn("[Web Model Context] Failed to convert JSON Schema to Zod:", error);
+		return z.object({}).passthrough();
+	}
+}
+/**
+* Convert Zod schema object to JSON Schema
+* Uses zod-to-json-schema package for comprehensive conversion
+*
+* @param schema - Record of Zod type definitions (e.g., { name: z.string(), age: z.number() })
+* @returns JSON Schema object compatible with MCP InputSchema
+*/
+function zodToJsonSchema(schema) {
+	const { $schema: _,...rest } = zodToJsonSchema$1(z.object(schema), {
+		$refStrategy: "none",
+		target: "jsonSchema7"
+	});
+	return rest;
+}
+/**
+* Normalize a schema to both JSON Schema and Zod formats
+* Detects which format is provided and converts to the other
+*/
+function normalizeSchema(schema) {
+	if (isZodSchema(schema)) return {
+		jsonSchema: zodToJsonSchema(schema),
+		zodValidator: z.object(schema)
+	};
+	const jsonSchema = schema;
+	return {
+		jsonSchema,
+		zodValidator: jsonSchemaToZod$1(jsonSchema)
+	};
+}
+/**
+* Validate data with Zod schema and return formatted result
+*/
+function validateWithZod(data, validator) {
+	const result = validator.safeParse(data);
+	if (!result.success) return {
+		success: false,
+		error: `Validation failed:\n${result.error.errors.map((err) => `  - ${err.path.join(".") || "root"}: ${err.message}`).join("\n")}`
+	};
+	return {
+		success: true,
+		data: result.data
+	};
+}
+
+//#endregion
+//#region src/global.ts
+/**
+* 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";
+/**
+* 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() {
+	if (typeof window === "undefined" || typeof navigator === "undefined") return {
+		hasNativeContext: false,
+		hasNativeTesting: false
+	};
+	const modelContext = navigator.modelContext;
+	const modelContextTesting = navigator.modelContextTesting;
+	if (!modelContext || !modelContextTesting) return {
+		hasNativeContext: false,
+		hasNativeTesting: false
+	};
+	if (POLYFILL_MARKER_PROPERTY in modelContextTesting && modelContextTesting[POLYFILL_MARKER_PROPERTY] === true) return {
+		hasNativeContext: false,
+		hasNativeTesting: false
+	};
+	return {
+		hasNativeContext: true,
+		hasNativeTesting: true
+	};
+}
+/**
+* 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
+	*/
+	constructor(bridge, nativeContext, nativeTesting) {
+		this.bridge = bridge;
+		this.nativeContext = nativeContext;
+		this.nativeTesting = nativeTesting;
+		this.nativeTesting.registerToolsChangedCallback(() => {
+			console.log("[Native Adapter] Tool change detected from native API");
+			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();
+			console.log(`[Native Adapter] Syncing ${nativeTools.length} tools from native API`);
+			this.bridge.tools.clear();
+			for (const toolInfo of nativeTools) try {
+				const inputSchema = JSON.parse(toolInfo.inputSchema);
+				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);
+					},
+					inputValidator: jsonSchemaToZod$1(inputSchema)
+				};
+				this.bridge.tools.set(toolInfo.name, validatedTool);
+			} catch (error) {
+				console.error(`[Native Adapter] Failed to sync tool "${toolInfo.name}":`, error);
+			}
+			this.notifyMCPServers();
+		} 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
+	*/
+	convertToToolResponse(result) {
+		if (typeof result === "string") return { content: [{
+			type: "text",
+			text: result
+		}] };
+		if (result === void 0 || result === null) return { content: [{
+			type: "text",
+			text: ""
+		}] };
+		if (typeof result === "object") return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}],
+			structuredContent: result
+		};
+		return { content: [{
+			type: "text",
+			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",
+			params: {}
+		});
+		if (this.bridge.iframeServer?.notification) this.bridge.iframeServer.notification({
+			method: "notifications/tools/list_changed",
+			params: {}
+		});
+	}
+	/**
+	* Provides context (tools) to AI models via the native API.
+	* Delegates to navigator.modelContext.provideContext().
+	* Tool change callback will fire and trigger sync automatically.
+	*
+	* @param {ModelContextInput} context - Context containing tools to register
+	*/
+	provideContext(context) {
+		console.log("[Native Adapter] Delegating provideContext to native API");
+		this.nativeContext.provideContext(context);
+	}
+	/**
+	* Registers a single tool dynamically via the native API.
+	* Delegates to navigator.modelContext.registerTool().
+	* 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) {
+		console.log(`[Native Adapter] Delegating registerTool("${tool.name}") to native API`);
+		return this.nativeContext.registerTool(tool);
+	}
+	/**
+	* 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) {
+		console.log(`[Native Adapter] Delegating unregisterTool("${name}") to native API`);
+		this.nativeContext.unregisterTool(name);
+	}
+	/**
+	* Clears all registered tools via the native API.
+	* Delegates to navigator.modelContext.clearContext().
+	*/
+	clearContext() {
+		console.log("[Native Adapter] Delegating clearContext to native API");
+		this.nativeContext.clearContext();
+	}
+	/**
+	* Executes a tool via the native API.
+	* Delegates to navigator.modelContextTesting.executeTool() with JSON string args.
+	*
+	* @param {string} toolName - Name of the tool to execute
+	* @param {Record<string, unknown>} args - Arguments to pass to the tool
+	* @returns {Promise<ToolResponse>} The tool's response in MCP format
+	* @internal
+	*/
+	async executeTool(toolName, args) {
+		console.log(`[Native Adapter] Executing tool "${toolName}" via native API`);
+		try {
+			const result = await this.nativeTesting.executeTool(toolName, JSON.stringify(args));
+			return this.convertToToolResponse(result);
+		} catch (error) {
+			console.error(`[Native Adapter] Error executing tool "${toolName}":`, error);
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+	/**
+	* 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,
+			description: tool.description,
+			inputSchema: tool.inputSchema,
+			...tool.outputSchema && { outputSchema: tool.outputSchema },
+			...tool.annotations && { annotations: tool.annotations }
+		}));
+	}
+	/**
+	* Registers a resource dynamically.
+	* Note: Native Chromium API does not yet support resources.
+	* This is a polyfill-only feature.
+	*/
+	registerResource(_resource) {
+		console.warn("[Native Adapter] 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) {
+		console.warn("[Native Adapter] 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) {
+		console.warn("[Native Adapter] 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) {
+		console.warn("[Native Adapter] 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);
+	}
+	/**
+	* 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);
+	}
+	/**
+	* 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) {
+		console.log("[Native Adapter] Requesting sampling from client");
+		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);
+	}
+	/**
+	* 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) {
+		console.log("[Native Adapter] Requesting elicitation from client");
+		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);
+	}
+};
+/**
+* ToolCallEvent implementation for the Web Model Context API.
+* Represents an event fired when a tool is called, allowing event listeners
+* to intercept and provide custom responses.
+*
+* @class WebToolCallEvent
+* @extends {Event}
+* @implements {ToolCallEvent}
+*/
+var WebToolCallEvent = class extends Event {
+	name;
+	arguments;
+	_response = null;
+	_responded = false;
+	/**
+	* Creates a new ToolCallEvent.
+	*
+	* @param {string} toolName - Name of the tool being called
+	* @param {Record<string, unknown>} args - Validated arguments for the tool
+	*/
+	constructor(toolName, args) {
+		super("toolcall", { cancelable: true });
+		this.name = toolName;
+		this.arguments = args;
+	}
+	/**
+	* Provides a response for this tool call, preventing the default tool execution.
+	*
+	* @param {ToolResponse} response - The response to use instead of executing the tool
+	* @throws {Error} If a response has already been provided
+	*/
+	respondWith(response) {
+		if (this._responded) throw new Error("Response already provided for this tool call");
+		this._response = response;
+		this._responded = true;
+	}
+	/**
+	* Gets the response provided via respondWith().
+	*
+	* @returns {ToolResponse | null} The response, or null if none provided
+	*/
+	getResponse() {
+		return this._response;
+	}
+	/**
+	* Checks whether a response has been provided for this tool call.
+	*
+	* @returns {boolean} True if respondWith() was called
+	*/
+	hasResponse() {
+		return this._responded;
+	}
+};
+/**
+* Time window in milliseconds to detect rapid duplicate tool registrations.
+* Used to filter out double-registrations caused by React Strict Mode.
+*/
+const RAPID_DUPLICATE_WINDOW_MS = 50;
+/**
+* Testing API implementation for the Model Context Protocol.
+* Provides debugging, mocking, and testing capabilities for tool execution.
+* Implements both Chromium native methods and polyfill-specific extensions.
+*
+* @class WebModelContextTesting
+* @implements {ModelContextTesting}
+*/
+var WebModelContextTesting = class {
+	/**
+	* Marker property to identify this as a polyfill implementation.
+	* Used by detectNativeAPI() to distinguish polyfill from native Chromium API.
+	* 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
+	*/
+	[POLYFILL_MARKER_PROPERTY] = true;
+	toolCallHistory = [];
+	mockResponses = /* @__PURE__ */ new Map();
+	toolsChangedCallbacks = /* @__PURE__ */ new Set();
+	bridge;
+	/**
+	* Creates a new WebModelContextTesting instance.
+	*
+	* @param {MCPBridge} bridge - The MCP bridge instance to test
+	*/
+	constructor(bridge) {
+		this.bridge = bridge;
+	}
+	/**
+	* Records a tool call in the history.
+	* Called internally by WebModelContext when tools are executed.
+	*
+	* @param {string} toolName - Name of the tool that was called
+	* @param {Record<string, unknown>} args - Arguments passed to the tool
+	* @internal
+	*/
+	recordToolCall(toolName, args) {
+		this.toolCallHistory.push({
+			toolName,
+			arguments: args,
+			timestamp: Date.now()
+		});
+	}
+	/**
+	* Checks if a mock response is registered for a specific tool.
+	*
+	* @param {string} toolName - Name of the tool to check
+	* @returns {boolean} True if a mock response exists
+	* @internal
+	*/
+	hasMockResponse(toolName) {
+		return this.mockResponses.has(toolName);
+	}
+	/**
+	* Retrieves the mock response for a specific tool.
+	*
+	* @param {string} toolName - Name of the tool
+	* @returns {ToolResponse | undefined} The mock response, or undefined if none exists
+	* @internal
+	*/
+	getMockResponse(toolName) {
+		return this.mockResponses.get(toolName);
+	}
+	/**
+	* Notifies all registered callbacks that the tools list has changed.
+	* Called internally when tools are registered, unregistered, or cleared.
+	*
+	* @internal
+	*/
+	notifyToolsChanged() {
+		for (const callback of this.toolsChangedCallbacks) try {
+			callback();
+		} catch (error) {
+			console.error("[Model Context Testing] Error in tools changed callback:", error);
+		}
+	}
+	/**
+	* Executes a tool directly with JSON string input (Chromium native API).
+	* Parses the JSON input, validates it, and executes the tool.
+	*
+	* @param {string} toolName - Name of the tool to execute
+	* @param {string} inputArgsJson - JSON string of input arguments
+	* @returns {Promise<unknown>} The tool's result, or undefined on error
+	* @throws {SyntaxError} If the input JSON is invalid
+	* @throws {Error} If the tool does not exist
+	*/
+	async executeTool(toolName, inputArgsJson) {
+		console.log(`[Model Context Testing] Executing tool: ${toolName}`);
+		let args;
+		try {
+			args = JSON.parse(inputArgsJson);
+		} catch (error) {
+			throw new SyntaxError(`Invalid JSON input: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!this.bridge.tools.get(toolName)) throw new Error(`Tool not found: ${toolName}`);
+		const result = await this.bridge.modelContext.executeTool(toolName, args);
+		if (result.isError) return;
+		if (result.structuredContent) return result.structuredContent;
+		if (result.content && result.content.length > 0) {
+			const firstContent = result.content[0];
+			if (firstContent && firstContent.type === "text") return firstContent.text;
+		}
+	}
+	/**
+	* Lists all registered tools with inputSchema as JSON string (Chromium native API).
+	* Returns an array of ToolInfo objects where inputSchema is stringified.
+	*
+	* @returns {Array<{name: string, description: string, inputSchema: string}>} Array of tool information
+	*/
+	listTools() {
+		return this.bridge.modelContext.listTools().map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			inputSchema: JSON.stringify(tool.inputSchema)
+		}));
+	}
+	/**
+	* Registers a callback that fires when the tools list changes (Chromium native API).
+	* The callback will be invoked on registerTool, unregisterTool, provideContext, and clearContext.
+	*
+	* @param {() => void} callback - Function to call when tools change
+	*/
+	registerToolsChangedCallback(callback) {
+		this.toolsChangedCallbacks.add(callback);
+		console.log("[Model Context Testing] Tools changed callback registered");
+	}
+	/**
+	* Gets all tool calls that have been recorded (polyfill extension).
+	*
+	* @returns {Array<{toolName: string, arguments: Record<string, unknown>, timestamp: number}>} Tool call history
+	*/
+	getToolCalls() {
+		return [...this.toolCallHistory];
+	}
+	/**
+	* Clears the tool call history (polyfill extension).
+	*/
+	clearToolCalls() {
+		this.toolCallHistory = [];
+		console.log("[Model Context Testing] Tool call history cleared");
+	}
+	/**
+	* Sets a mock response for a specific tool (polyfill extension).
+	* When set, the tool's execute function will be bypassed.
+	*
+	* @param {string} toolName - Name of the tool to mock
+	* @param {ToolResponse} response - The mock response to return
+	*/
+	setMockToolResponse(toolName, response) {
+		this.mockResponses.set(toolName, response);
+		console.log(`[Model Context Testing] Mock response set for tool: ${toolName}`);
+	}
+	/**
+	* Clears the mock response for a specific tool (polyfill extension).
+	*
+	* @param {string} toolName - Name of the tool
+	*/
+	clearMockToolResponse(toolName) {
+		this.mockResponses.delete(toolName);
+		console.log(`[Model Context Testing] Mock response cleared for tool: ${toolName}`);
+	}
+	/**
+	* Clears all mock tool responses (polyfill extension).
+	*/
+	clearAllMockToolResponses() {
+		this.mockResponses.clear();
+		console.log("[Model Context Testing] All mock responses cleared");
+	}
+	/**
+	* Gets the current tools registered in the system (polyfill extension).
+	*
+	* @returns {ReturnType<InternalModelContext['listTools']>} Array of registered tools
+	*/
+	getRegisteredTools() {
+		return this.bridge.modelContext.listTools();
+	}
+	/**
+	* Resets the entire testing state (polyfill extension).
+	* Clears both tool call history and all mock responses.
+	*/
+	reset() {
+		this.clearToolCalls();
+		this.clearAllMockToolResponses();
+		console.log("[Model Context Testing] Testing state reset");
+	}
+};
+/**
+* ModelContext implementation that bridges to the Model Context Protocol SDK.
+* Implements the W3C Web Model Context API proposal with two-bucket tool management:
+* - Bucket A (provideContextTools): Tools registered via provideContext()
+* - Bucket B (dynamicTools): Tools registered via registerTool()
+*
+* This separation ensures that component-scoped dynamic tools persist across
+* app-level provideContext() calls.
+*
+* @class WebModelContext
+* @implements {InternalModelContext}
+*/
+var WebModelContext = class {
+	bridge;
+	eventTarget;
+	provideContextTools;
+	dynamicTools;
+	provideContextResources;
+	dynamicResources;
+	provideContextPrompts;
+	dynamicPrompts;
+	toolRegistrationTimestamps;
+	resourceRegistrationTimestamps;
+	promptRegistrationTimestamps;
+	toolUnregisterFunctions;
+	resourceUnregisterFunctions;
+	promptUnregisterFunctions;
+	/**
+	* Tracks which list change notifications are pending.
+	* Uses microtask-based batching to coalesce rapid registrations
+	* (e.g., React mount phase) into a single notification per list type.
+	*/
+	pendingNotifications = /* @__PURE__ */ new Set();
+	testingAPI;
+	/**
+	* Creates a new WebModelContext instance.
+	*
+	* @param {MCPBridge} bridge - The MCP bridge to use for communication
+	*/
+	constructor(bridge) {
+		this.bridge = bridge;
+		this.eventTarget = new EventTarget();
+		this.provideContextTools = /* @__PURE__ */ new Map();
+		this.dynamicTools = /* @__PURE__ */ new Map();
+		this.toolRegistrationTimestamps = /* @__PURE__ */ new Map();
+		this.toolUnregisterFunctions = /* @__PURE__ */ new Map();
+		this.provideContextResources = /* @__PURE__ */ new Map();
+		this.dynamicResources = /* @__PURE__ */ new Map();
+		this.resourceRegistrationTimestamps = /* @__PURE__ */ new Map();
+		this.resourceUnregisterFunctions = /* @__PURE__ */ new Map();
+		this.provideContextPrompts = /* @__PURE__ */ new Map();
+		this.dynamicPrompts = /* @__PURE__ */ new Map();
+		this.promptRegistrationTimestamps = /* @__PURE__ */ new Map();
+		this.promptUnregisterFunctions = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Sets the testing API instance.
+	* Called during initialization to enable testing features.
+	*
+	* @param {WebModelContextTesting} testingAPI - The testing API instance
+	* @internal
+	*/
+	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);
+	}
+	/**
+	* Dispatches a tool call event to all registered listeners.
+	*
+	* @param {Event} event - The event to dispatch
+	* @returns {boolean} False if event was cancelled, true otherwise
+	*/
+	dispatchEvent(event) {
+		return this.eventTarget.dispatchEvent(event);
+	}
+	/**
+	* Provides context (tools, resources, prompts) to AI models by registering base items (Bucket A).
+	* Clears and replaces all previously registered base items while preserving
+	* dynamic items registered via register* methods.
+	*
+	* @param {ModelContextInput} context - Context containing tools, resources, and prompts to register
+	* @throws {Error} If a name/uri collides with existing dynamic items
+	*/
+	provideContext(context) {
+		const toolCount = context.tools?.length ?? 0;
+		const resourceCount = context.resources?.length ?? 0;
+		const promptCount = context.prompts?.length ?? 0;
+		console.log(`[Web Model Context] provideContext: ${toolCount} tools, ${resourceCount} resources, ${promptCount} prompts`);
+		this.provideContextTools.clear();
+		this.provideContextResources.clear();
+		this.provideContextPrompts.clear();
+		for (const tool of context.tools ?? []) {
+			if (this.dynamicTools.has(tool.name)) throw new Error(`[Web Model Context] Tool name collision: "${tool.name}" is already registered via registerTool(). Please use a different name or unregister the dynamic tool first.`);
+			const { jsonSchema: inputJson, zodValidator: inputZod } = normalizeSchema(tool.inputSchema);
+			const normalizedOutput = tool.outputSchema ? normalizeSchema(tool.outputSchema) : null;
+			const validatedTool = {
+				name: tool.name,
+				description: tool.description,
+				inputSchema: inputJson,
+				...normalizedOutput && { outputSchema: normalizedOutput.jsonSchema },
+				...tool.annotations && { annotations: tool.annotations },
+				execute: tool.execute,
+				inputValidator: inputZod,
+				...normalizedOutput && { outputValidator: normalizedOutput.zodValidator }
+			};
+			this.provideContextTools.set(tool.name, validatedTool);
+		}
+		for (const resource of context.resources ?? []) {
+			if (this.dynamicResources.has(resource.uri)) throw new Error(`[Web Model Context] Resource URI collision: "${resource.uri}" is already registered via registerResource(). Please use a different URI or unregister the dynamic resource first.`);
+			const validatedResource = this.validateResource(resource);
+			this.provideContextResources.set(resource.uri, validatedResource);
+		}
+		for (const prompt of context.prompts ?? []) {
+			if (this.dynamicPrompts.has(prompt.name)) throw new Error(`[Web Model Context] Prompt name collision: "${prompt.name}" is already registered via registerPrompt(). Please use a different name or unregister the dynamic prompt first.`);
+			const validatedPrompt = this.validatePrompt(prompt);
+			this.provideContextPrompts.set(prompt.name, validatedPrompt);
+		}
+		this.updateBridgeTools();
+		this.updateBridgeResources();
+		this.updateBridgePrompts();
+		this.scheduleListChanged("tools");
+		this.scheduleListChanged("resources");
+		this.scheduleListChanged("prompts");
+	}
+	/**
+	* Validates and normalizes a resource descriptor.
+	* @private
+	*/
+	validateResource(resource) {
+		const templateParamRegex = /\{([^}]+)\}/g;
+		const templateParams = [];
+		for (const match of resource.uri.matchAll(templateParamRegex)) {
+			const paramName = match[1];
+			if (paramName) templateParams.push(paramName);
+		}
+		return {
+			uri: resource.uri,
+			name: resource.name,
+			description: resource.description,
+			mimeType: resource.mimeType,
+			read: resource.read,
+			isTemplate: templateParams.length > 0,
+			templateParams
+		};
+	}
+	/**
+	* Validates and normalizes a prompt descriptor.
+	* @private
+	*/
+	validatePrompt(prompt) {
+		let argsSchema;
+		let argsValidator;
+		if (prompt.argsSchema) {
+			const normalized = normalizeSchema(prompt.argsSchema);
+			argsSchema = normalized.jsonSchema;
+			argsValidator = normalized.zodValidator;
+		}
+		return {
+			name: prompt.name,
+			description: prompt.description,
+			argsSchema,
+			get: prompt.get,
+			argsValidator
+		};
+	}
+	/**
+	* Registers a single tool dynamically (Bucket B).
+	* Dynamic tools persist across provideContext() calls and can be independently managed.
+	*
+	* @param {ToolDescriptor} tool - The tool descriptor to register
+	* @returns {{unregister: () => void}} Object with unregister function
+	* @throws {Error} If tool name collides with existing tools
+	*/
+	registerTool(tool) {
+		console.log(`[Web Model Context] Registering tool dynamically: ${tool.name}`);
+		const now = Date.now();
+		const lastRegistration = this.toolRegistrationTimestamps.get(tool.name);
+		if (lastRegistration && now - lastRegistration < RAPID_DUPLICATE_WINDOW_MS) {
+			console.warn(`[Web Model Context] Tool "${tool.name}" registered multiple times within ${RAPID_DUPLICATE_WINDOW_MS}ms. This is likely due to React Strict Mode double-mounting. Ignoring duplicate registration.`);
+			const existingUnregister = this.toolUnregisterFunctions.get(tool.name);
+			if (existingUnregister) return { unregister: existingUnregister };
+		}
+		if (this.provideContextTools.has(tool.name)) throw new Error(`[Web Model Context] Tool name collision: "${tool.name}" is already registered via provideContext(). Please use a different name or update your provideContext() call.`);
+		if (this.dynamicTools.has(tool.name)) throw new Error(`[Web Model Context] Tool name collision: "${tool.name}" is already registered via registerTool(). Please unregister it first or use a different name.`);
+		const { jsonSchema: inputJson, zodValidator: inputZod } = normalizeSchema(tool.inputSchema);
+		const normalizedOutput = tool.outputSchema ? normalizeSchema(tool.outputSchema) : null;
+		const validatedTool = {
+			name: tool.name,
+			description: tool.description,
+			inputSchema: inputJson,
+			...normalizedOutput && { outputSchema: normalizedOutput.jsonSchema },
+			...tool.annotations && { annotations: tool.annotations },
+			execute: tool.execute,
+			inputValidator: inputZod,
+			...normalizedOutput && { outputValidator: normalizedOutput.zodValidator }
+		};
+		this.dynamicTools.set(tool.name, validatedTool);
+		this.toolRegistrationTimestamps.set(tool.name, now);
+		this.updateBridgeTools();
+		this.scheduleListChanged("tools");
+		const unregisterFn = () => {
+			console.log(`[Web Model Context] Unregistering tool: ${tool.name}`);
+			if (this.provideContextTools.has(tool.name)) throw new Error(`[Web Model Context] Cannot unregister tool "${tool.name}": This tool was registered via provideContext(). Use provideContext() to update the base tool set.`);
+			if (!this.dynamicTools.has(tool.name)) {
+				console.warn(`[Web Model Context] Tool "${tool.name}" is not registered, ignoring unregister call`);
+				return;
+			}
+			this.dynamicTools.delete(tool.name);
+			this.toolRegistrationTimestamps.delete(tool.name);
+			this.toolUnregisterFunctions.delete(tool.name);
+			this.updateBridgeTools();
+			this.scheduleListChanged("tools");
+		};
+		this.toolUnregisterFunctions.set(tool.name, unregisterFn);
+		return { unregister: unregisterFn };
+	}
+	/**
+	* Registers a single resource dynamically (Bucket B).
+	* Dynamic resources persist across provideContext() calls and can be independently managed.
+	*
+	* @param {ResourceDescriptor} resource - The resource descriptor to register
+	* @returns {{unregister: () => void}} Object with unregister function
+	* @throws {Error} If resource URI collides with existing resources
+	*/
+	registerResource(resource) {
+		console.log(`[Web Model Context] Registering resource dynamically: ${resource.uri}`);
+		const now = Date.now();
+		const lastRegistration = this.resourceRegistrationTimestamps.get(resource.uri);
+		if (lastRegistration && now - lastRegistration < RAPID_DUPLICATE_WINDOW_MS) {
+			console.warn(`[Web Model Context] Resource "${resource.uri}" registered multiple times within ${RAPID_DUPLICATE_WINDOW_MS}ms. This is likely due to React Strict Mode double-mounting. Ignoring duplicate registration.`);
+			const existingUnregister = this.resourceUnregisterFunctions.get(resource.uri);
+			if (existingUnregister) return { unregister: existingUnregister };
+		}
+		if (this.provideContextResources.has(resource.uri)) throw new Error(`[Web Model Context] Resource URI collision: "${resource.uri}" is already registered via provideContext(). Please use a different URI or update your provideContext() call.`);
+		if (this.dynamicResources.has(resource.uri)) throw new Error(`[Web Model Context] Resource URI collision: "${resource.uri}" is already registered via registerResource(). Please unregister it first or use a different URI.`);
+		const validatedResource = this.validateResource(resource);
+		this.dynamicResources.set(resource.uri, validatedResource);
+		this.resourceRegistrationTimestamps.set(resource.uri, now);
+		this.updateBridgeResources();
+		this.scheduleListChanged("resources");
+		const unregisterFn = () => {
+			console.log(`[Web Model Context] Unregistering resource: ${resource.uri}`);
+			if (this.provideContextResources.has(resource.uri)) throw new Error(`[Web Model Context] Cannot unregister resource "${resource.uri}": This resource was registered via provideContext(). Use provideContext() to update the base resource set.`);
+			if (!this.dynamicResources.has(resource.uri)) {
+				console.warn(`[Web Model Context] Resource "${resource.uri}" is not registered, ignoring unregister call`);
+				return;
+			}
+			this.dynamicResources.delete(resource.uri);
+			this.resourceRegistrationTimestamps.delete(resource.uri);
+			this.resourceUnregisterFunctions.delete(resource.uri);
+			this.updateBridgeResources();
+			this.scheduleListChanged("resources");
+		};
+		this.resourceUnregisterFunctions.set(resource.uri, unregisterFn);
+		return { unregister: unregisterFn };
+	}
+	/**
+	* Unregisters a resource by URI.
+	* Can unregister resources from either Bucket A (provideContext) or Bucket B (registerResource).
+	*
+	* @param {string} uri - URI of the resource to unregister
+	*/
+	unregisterResource(uri) {
+		console.log(`[Web Model Context] Unregistering resource: ${uri}`);
+		const inProvideContext = this.provideContextResources.has(uri);
+		const inDynamic = this.dynamicResources.has(uri);
+		if (!inProvideContext && !inDynamic) {
+			console.warn(`[Web Model Context] Resource "${uri}" is not registered, ignoring unregister call`);
+			return;
+		}
+		if (inProvideContext) this.provideContextResources.delete(uri);
+		if (inDynamic) {
+			this.dynamicResources.delete(uri);
+			this.resourceRegistrationTimestamps.delete(uri);
+			this.resourceUnregisterFunctions.delete(uri);
+		}
+		this.updateBridgeResources();
+		this.scheduleListChanged("resources");
+	}
+	/**
+	* Lists all registered resources in MCP format.
+	* Returns static resources from both buckets (not templates).
+	*
+	* @returns {Resource[]} Array of resource descriptors
+	*/
+	listResources() {
+		return Array.from(this.bridge.resources.values()).filter((r) => !r.isTemplate).map((resource) => ({
+			uri: resource.uri,
+			name: resource.name,
+			description: resource.description,
+			mimeType: resource.mimeType
+		}));
+	}
+	/**
+	* Lists all registered resource templates.
+	* Returns only resources with URI templates (dynamic resources).
+	*
+	* @returns {Array<{uriTemplate: string, name: string, description?: string, mimeType?: string}>}
+	*/
+	listResourceTemplates() {
+		return Array.from(this.bridge.resources.values()).filter((r) => r.isTemplate).map((resource) => ({
+			uriTemplate: resource.uri,
+			name: resource.name,
+			...resource.description !== void 0 && { description: resource.description },
+			...resource.mimeType !== void 0 && { mimeType: resource.mimeType }
+		}));
+	}
+	/**
+	* Registers a single prompt dynamically (Bucket B).
+	* Dynamic prompts persist across provideContext() calls and can be independently managed.
+	*
+	* @param {PromptDescriptor} prompt - The prompt descriptor to register
+	* @returns {{unregister: () => void}} Object with unregister function
+	* @throws {Error} If prompt name collides with existing prompts
+	*/
+	registerPrompt(prompt) {
+		console.log(`[Web Model Context] Registering prompt dynamically: ${prompt.name}`);
+		const now = Date.now();
+		const lastRegistration = this.promptRegistrationTimestamps.get(prompt.name);
+		if (lastRegistration && now - lastRegistration < RAPID_DUPLICATE_WINDOW_MS) {
+			console.warn(`[Web Model Context] Prompt "${prompt.name}" registered multiple times within ${RAPID_DUPLICATE_WINDOW_MS}ms. This is likely due to React Strict Mode double-mounting. Ignoring duplicate registration.`);
+			const existingUnregister = this.promptUnregisterFunctions.get(prompt.name);
+			if (existingUnregister) return { unregister: existingUnregister };
+		}
+		if (this.provideContextPrompts.has(prompt.name)) throw new Error(`[Web Model Context] Prompt name collision: "${prompt.name}" is already registered via provideContext(). Please use a different name or update your provideContext() call.`);
+		if (this.dynamicPrompts.has(prompt.name)) throw new Error(`[Web Model Context] Prompt name collision: "${prompt.name}" is already registered via registerPrompt(). Please unregister it first or use a different name.`);
+		const validatedPrompt = this.validatePrompt(prompt);
+		this.dynamicPrompts.set(prompt.name, validatedPrompt);
+		this.promptRegistrationTimestamps.set(prompt.name, now);
+		this.updateBridgePrompts();
+		this.scheduleListChanged("prompts");
+		const unregisterFn = () => {
+			console.log(`[Web Model Context] Unregistering prompt: ${prompt.name}`);
+			if (this.provideContextPrompts.has(prompt.name)) throw new Error(`[Web Model Context] Cannot unregister prompt "${prompt.name}": This prompt was registered via provideContext(). Use provideContext() to update the base prompt set.`);
+			if (!this.dynamicPrompts.has(prompt.name)) {
+				console.warn(`[Web Model Context] Prompt "${prompt.name}" is not registered, ignoring unregister call`);
+				return;
+			}
+			this.dynamicPrompts.delete(prompt.name);
+			this.promptRegistrationTimestamps.delete(prompt.name);
+			this.promptUnregisterFunctions.delete(prompt.name);
+			this.updateBridgePrompts();
+			this.scheduleListChanged("prompts");
+		};
+		this.promptUnregisterFunctions.set(prompt.name, unregisterFn);
+		return { unregister: unregisterFn };
+	}
+	/**
+	* Unregisters a prompt by name.
+	* Can unregister prompts from either Bucket A (provideContext) or Bucket B (registerPrompt).
+	*
+	* @param {string} name - Name of the prompt to unregister
+	*/
+	unregisterPrompt(name) {
+		console.log(`[Web Model Context] Unregistering prompt: ${name}`);
+		const inProvideContext = this.provideContextPrompts.has(name);
+		const inDynamic = this.dynamicPrompts.has(name);
+		if (!inProvideContext && !inDynamic) {
+			console.warn(`[Web Model Context] Prompt "${name}" is not registered, ignoring unregister call`);
+			return;
+		}
+		if (inProvideContext) this.provideContextPrompts.delete(name);
+		if (inDynamic) {
+			this.dynamicPrompts.delete(name);
+			this.promptRegistrationTimestamps.delete(name);
+			this.promptUnregisterFunctions.delete(name);
+		}
+		this.updateBridgePrompts();
+		this.scheduleListChanged("prompts");
+	}
+	/**
+	* Lists all registered prompts in MCP format.
+	* Returns prompts from both buckets.
+	*
+	* @returns {Prompt[]} Array of prompt descriptors
+	*/
+	listPrompts() {
+		return Array.from(this.bridge.prompts.values()).map((prompt) => ({
+			name: prompt.name,
+			description: prompt.description,
+			arguments: prompt.argsSchema?.properties ? Object.entries(prompt.argsSchema.properties).map(([name, schema]) => ({
+				name,
+				description: schema.description,
+				required: prompt.argsSchema?.required?.includes(name) ?? false
+			})) : void 0
+		}));
+	}
+	/**
+	* Unregisters a tool by name (Chromium native API).
+	* Can unregister tools from either Bucket A (provideContext) or Bucket B (registerTool).
+	*
+	* @param {string} name - Name of the tool to unregister
+	*/
+	unregisterTool(name) {
+		console.log(`[Web Model Context] Unregistering tool: ${name}`);
+		const inProvideContext = this.provideContextTools.has(name);
+		const inDynamic = this.dynamicTools.has(name);
+		if (!inProvideContext && !inDynamic) {
+			console.warn(`[Web Model Context] Tool "${name}" is not registered, ignoring unregister call`);
+			return;
+		}
+		if (inProvideContext) this.provideContextTools.delete(name);
+		if (inDynamic) {
+			this.dynamicTools.delete(name);
+			this.toolRegistrationTimestamps.delete(name);
+			this.toolUnregisterFunctions.delete(name);
+		}
+		this.updateBridgeTools();
+		this.scheduleListChanged("tools");
+	}
+	/**
+	* Clears all registered context from both buckets (Chromium native API).
+	* Removes all tools, resources, and prompts registered via provideContext() and register* methods.
+	*/
+	clearContext() {
+		console.log("[Web Model Context] Clearing all context (tools, resources, prompts)");
+		this.provideContextTools.clear();
+		this.dynamicTools.clear();
+		this.toolRegistrationTimestamps.clear();
+		this.toolUnregisterFunctions.clear();
+		this.provideContextResources.clear();
+		this.dynamicResources.clear();
+		this.resourceRegistrationTimestamps.clear();
+		this.resourceUnregisterFunctions.clear();
+		this.provideContextPrompts.clear();
+		this.dynamicPrompts.clear();
+		this.promptRegistrationTimestamps.clear();
+		this.promptUnregisterFunctions.clear();
+		this.updateBridgeTools();
+		this.updateBridgeResources();
+		this.updateBridgePrompts();
+		this.scheduleListChanged("tools");
+		this.scheduleListChanged("resources");
+		this.scheduleListChanged("prompts");
+	}
+	/**
+	* Updates the bridge tools map with merged tools from both buckets.
+	* The final tool list is the union of Bucket A (provideContext) and Bucket B (dynamic).
+	*
+	* @private
+	*/
+	updateBridgeTools() {
+		this.bridge.tools.clear();
+		for (const [name, tool] of this.provideContextTools) this.bridge.tools.set(name, tool);
+		for (const [name, tool] of this.dynamicTools) this.bridge.tools.set(name, tool);
+		console.log(`[Web Model Context] Updated bridge with ${this.provideContextTools.size} base tools + ${this.dynamicTools.size} dynamic tools = ${this.bridge.tools.size} total`);
+	}
+	/**
+	* Notifies all servers and testing callbacks that the tools list has changed.
+	* Sends MCP notifications to connected servers and invokes registered testing callbacks.
+	*
+	* @private
+	*/
+	notifyToolsListChanged() {
+		if (this.bridge.tabServer.notification) this.bridge.tabServer.notification({
+			method: "notifications/tools/list_changed",
+			params: {}
+		});
+		if (this.bridge.iframeServer?.notification) this.bridge.iframeServer.notification({
+			method: "notifications/tools/list_changed",
+			params: {}
+		});
+		if (this.testingAPI && "notifyToolsChanged" in this.testingAPI) this.testingAPI.notifyToolsChanged();
+	}
+	/**
+	* Updates the bridge resources map with merged resources from both buckets.
+	*
+	* @private
+	*/
+	updateBridgeResources() {
+		this.bridge.resources.clear();
+		for (const [uri, resource] of this.provideContextResources) this.bridge.resources.set(uri, resource);
+		for (const [uri, resource] of this.dynamicResources) this.bridge.resources.set(uri, resource);
+		console.log(`[Web Model Context] Updated bridge with ${this.provideContextResources.size} base resources + ${this.dynamicResources.size} dynamic resources = ${this.bridge.resources.size} total`);
+	}
+	/**
+	* Notifies all servers that the resources list has changed.
+	*
+	* @private
+	*/
+	notifyResourcesListChanged() {
+		if (this.bridge.tabServer.notification) this.bridge.tabServer.notification({
+			method: "notifications/resources/list_changed",
+			params: {}
+		});
+		if (this.bridge.iframeServer?.notification) this.bridge.iframeServer.notification({
+			method: "notifications/resources/list_changed",
+			params: {}
+		});
+	}
+	/**
+	* Updates the bridge prompts map with merged prompts from both buckets.
+	*
+	* @private
+	*/
+	updateBridgePrompts() {
+		this.bridge.prompts.clear();
+		for (const [name, prompt] of this.provideContextPrompts) this.bridge.prompts.set(name, prompt);
+		for (const [name, prompt] of this.dynamicPrompts) this.bridge.prompts.set(name, prompt);
+		console.log(`[Web Model Context] Updated bridge with ${this.provideContextPrompts.size} base prompts + ${this.dynamicPrompts.size} dynamic prompts = ${this.bridge.prompts.size} total`);
+	}
+	/**
+	* Notifies all servers that the prompts list has changed.
+	*
+	* @private
+	*/
+	notifyPromptsListChanged() {
+		if (this.bridge.tabServer.notification) this.bridge.tabServer.notification({
+			method: "notifications/prompts/list_changed",
+			params: {}
+		});
+		if (this.bridge.iframeServer?.notification) this.bridge.iframeServer.notification({
+			method: "notifications/prompts/list_changed",
+			params: {}
+		});
+	}
+	/**
+	* Schedules a list changed notification using microtask batching.
+	* Multiple calls for the same list type within the same task are coalesced
+	* into a single notification. This dramatically reduces notification spam
+	* during React mount/unmount cycles.
+	*
+	* @param listType - The type of list that changed ('tools' | 'resources' | 'prompts')
+	* @private
+	*/
+	scheduleListChanged(listType) {
+		if (this.pendingNotifications.has(listType)) return;
+		this.pendingNotifications.add(listType);
+		queueMicrotask(() => {
+			this.pendingNotifications.delete(listType);
+			switch (listType) {
+				case "tools":
+					this.notifyToolsListChanged();
+					break;
+				case "resources":
+					this.notifyResourcesListChanged();
+					break;
+				case "prompts":
+					this.notifyPromptsListChanged();
+					break;
+				default: {
+					const _exhaustive = listType;
+					console.error(`[Web Model Context] Unknown list type: ${_exhaustive}`);
+				}
+			}
+		});
+	}
+	/**
+	* Reads a resource by URI (internal use only by MCP bridge).
+	* Handles both static resources and URI templates.
+	*
+	* @param {string} uri - The URI of the resource to read
+	* @returns {Promise<{contents: ResourceContents[]}>} The resource contents
+	* @throws {Error} If resource is not found
+	* @internal
+	*/
+	async readResource(uri) {
+		console.log(`[Web Model Context] Reading resource: ${uri}`);
+		const staticResource = this.bridge.resources.get(uri);
+		if (staticResource && !staticResource.isTemplate) try {
+			const parsedUri = new URL(uri);
+			return await staticResource.read(parsedUri);
+		} catch (error) {
+			console.error(`[Web Model Context] Error reading resource ${uri}:`, error);
+			throw error;
+		}
+		for (const resource of this.bridge.resources.values()) {
+			if (!resource.isTemplate) continue;
+			const params = this.matchUriTemplate(resource.uri, uri);
+			if (params) try {
+				const parsedUri = new URL(uri);
+				return await resource.read(parsedUri, params);
+			} catch (error) {
+				console.error(`[Web Model Context] Error reading resource ${uri}:`, error);
+				throw error;
+			}
+		}
+		throw new Error(`Resource not found: ${uri}`);
+	}
+	/**
+	* Matches a URI against a URI template and extracts parameters.
+	*
+	* @param {string} template - The URI template (e.g., "file://{path}")
+	* @param {string} uri - The actual URI to match
+	* @returns {Record<string, string> | null} Extracted parameters or null if no match
+	* @private
+	*/
+	matchUriTemplate(template, uri) {
+		const paramNames = [];
+		let regexPattern = template.replace(/[.*+?^${}()|[\]\\]/g, (char) => {
+			if (char === "{" || char === "}") return char;
+			return `\\${char}`;
+		});
+		regexPattern = regexPattern.replace(/\{([^}]+)\}/g, (_, paramName) => {
+			paramNames.push(paramName);
+			return "(.+)";
+		});
+		const regex = /* @__PURE__ */ new RegExp(`^${regexPattern}$`);
+		const match = uri.match(regex);
+		if (!match) return null;
+		const params = {};
+		for (let i = 0; i < paramNames.length; i++) {
+			const paramName = paramNames[i];
+			const paramValue = match[i + 1];
+			if (paramName !== void 0 && paramValue !== void 0) params[paramName] = paramValue;
+		}
+		return params;
+	}
+	/**
+	* Gets a prompt with arguments (internal use only by MCP bridge).
+	*
+	* @param {string} name - Name of the prompt
+	* @param {Record<string, unknown>} args - Arguments to pass to the prompt
+	* @returns {Promise<{messages: PromptMessage[]}>} The prompt messages
+	* @throws {Error} If prompt is not found
+	* @internal
+	*/
+	async getPrompt(name, args) {
+		console.log(`[Web Model Context] Getting prompt: ${name}`);
+		const prompt = this.bridge.prompts.get(name);
+		if (!prompt) throw new Error(`Prompt not found: ${name}`);
+		if (prompt.argsValidator && args) {
+			const validation = validateWithZod(args, prompt.argsValidator);
+			if (!validation.success) {
+				console.error(`[Web Model Context] Argument validation failed for prompt ${name}:`, validation.error);
+				throw new Error(`Argument validation error for prompt "${name}":\n${validation.error}`);
+			}
+		}
+		try {
+			return await prompt.get(args ?? {});
+		} catch (error) {
+			console.error(`[Web Model Context] Error getting prompt ${name}:`, error);
+			throw error;
+		}
+	}
+	/**
+	* Executes a tool with validation and event dispatch.
+	* Follows this sequence:
+	* 1. Validates input arguments against schema
+	* 2. Records tool call in testing API (if available)
+	* 3. Checks for mock response (if testing)
+	* 4. Dispatches 'toolcall' event to listeners
+	* 5. Executes tool function if not prevented
+	* 6. Validates output (permissive mode - warns only)
+	*
+	* @param {string} toolName - Name of the tool to execute
+	* @param {Record<string, unknown>} args - Arguments to pass to the tool
+	* @returns {Promise<ToolResponse>} The tool's response
+	* @throws {Error} If tool is not found
+	* @internal
+	*/
+	async executeTool(toolName, args) {
+		const tool = this.bridge.tools.get(toolName);
+		if (!tool) throw new Error(`Tool not found: ${toolName}`);
+		console.log(`[Web Model Context] Validating input for tool: ${toolName}`);
+		const validation = validateWithZod(args, tool.inputValidator);
+		if (!validation.success) {
+			console.error(`[Web Model Context] Input validation failed for ${toolName}:`, validation.error);
+			return {
+				content: [{
+					type: "text",
+					text: `Input validation error for tool "${toolName}":\n${validation.error}`
+				}],
+				isError: true
+			};
+		}
+		const validatedArgs = validation.data;
+		if (this.testingAPI) this.testingAPI.recordToolCall(toolName, validatedArgs);
+		if (this.testingAPI?.hasMockResponse(toolName)) {
+			const mockResponse = this.testingAPI.getMockResponse(toolName);
+			if (mockResponse) {
+				console.log(`[Web Model Context] Returning mock response for tool: ${toolName}`);
+				return mockResponse;
+			}
+		}
+		const event = new WebToolCallEvent(toolName, validatedArgs);
+		this.dispatchEvent(event);
+		if (event.defaultPrevented && event.hasResponse()) {
+			const response = event.getResponse();
+			if (response) {
+				console.log(`[Web Model Context] Tool ${toolName} handled by event listener`);
+				return response;
+			}
+		}
+		console.log(`[Web Model Context] Executing tool: ${toolName}`);
+		try {
+			const response = await tool.execute(validatedArgs);
+			if (tool.outputValidator && response.structuredContent) {
+				const outputValidation = validateWithZod(response.structuredContent, tool.outputValidator);
+				if (!outputValidation.success) console.warn(`[Web Model Context] Output validation failed for ${toolName}:`, outputValidation.error);
+			}
+			if (response.metadata && "willNavigate" in response.metadata) console.info(`[Web Model Context] Tool "${toolName}" will trigger navigation`, response.metadata);
+			return response;
+		} catch (error) {
+			console.error(`[Web Model Context] Error executing tool ${toolName}:`, error);
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	}
+	/**
+	* Lists all registered tools in MCP format.
+	* Returns tools from both buckets with full MCP specification including
+	* annotations and output schemas.
+	*
+	* @returns {Array<{name: string, description: string, inputSchema: InputSchema, outputSchema?: InputSchema, annotations?: ToolAnnotations}>} Array of tool descriptors
+	*/
+	listTools() {
+		return Array.from(this.bridge.tools.values()).map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			inputSchema: tool.inputSchema,
+			...tool.outputSchema && { outputSchema: tool.outputSchema },
+			...tool.annotations && { annotations: tool.annotations }
+		}));
+	}
+	/**
+	* Request an LLM completion from the connected client.
+	* This sends a sampling request to the connected MCP client.
+	*
+	* @param {SamplingRequestParams} params - Parameters for the sampling request
+	* @returns {Promise<SamplingResult>} The LLM completion result
+	*/
+	async createMessage(params) {
+		console.log("[Web Model Context] Requesting sampling from client");
+		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);
+	}
+	/**
+	* Request user input from the connected client.
+	* This sends an elicitation request to the connected MCP client.
+	*
+	* @param {ElicitationParams} params - Parameters for the elicitation request
+	* @returns {Promise<ElicitationResult>} The user's response
+	*/
+	async elicitInput(params) {
+		console.log("[Web Model Context] Requesting elicitation from client");
+		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);
+	}
+};
+/**
+* Initializes the MCP bridge with dual-server support.
+* Creates TabServer for same-window communication and optionally IframeChildServer
+* for parent-child iframe communication.
+*
+* @param {WebModelContextInitOptions} [options] - Configuration options
+* @returns {MCPBridge} The initialized MCP bridge
+*/
+function initializeMCPBridge(options) {
+	console.log("[Web Model Context] Initializing MCP bridge");
+	const hostname = window.location.hostname || "localhost";
+	const transportOptions = options?.transport;
+	const setupServerHandlers = (server, bridge$1) => {
+		server.setRequestHandler(ListToolsRequestSchema, async () => {
+			console.log("[MCP Bridge] Handling list_tools request");
+			return { tools: bridge$1.modelContext.listTools() };
+		});
+		server.setRequestHandler(CallToolRequestSchema, async (request) => {
+			console.log(`[MCP Bridge] Handling call_tool request: ${request.params.name}`);
+			const toolName = request.params.name;
+			const args = request.params.arguments || {};
+			try {
+				const response = await bridge$1.modelContext.executeTool(toolName, args);
+				return {
+					content: response.content,
+					isError: response.isError,
+					...response.structuredContent && { structuredContent: response.structuredContent }
+				};
+			} catch (error) {
+				console.error(`[MCP Bridge] Error calling tool ${toolName}:`, error);
+				throw error;
+			}
+		});
+		server.setRequestHandler(ListResourcesRequestSchema, async () => {
+			console.log("[MCP Bridge] Handling list_resources request");
+			return { resources: bridge$1.modelContext.listResources() };
+		});
+		server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+			console.log(`[MCP Bridge] Handling read_resource request: ${request.params.uri}`);
+			try {
+				return await bridge$1.modelContext.readResource(request.params.uri);
+			} catch (error) {
+				console.error(`[MCP Bridge] Error reading resource ${request.params.uri}:`, error);
+				throw error;
+			}
+		});
+		server.setRequestHandler(ListPromptsRequestSchema, async () => {
+			console.log("[MCP Bridge] Handling list_prompts request");
+			return { prompts: bridge$1.modelContext.listPrompts() };
+		});
+		server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+			console.log(`[MCP Bridge] Handling get_prompt request: ${request.params.name}`);
+			try {
+				return await bridge$1.modelContext.getPrompt(request.params.name, request.params.arguments);
+			} catch (error) {
+				console.error(`[MCP Bridge] Error getting prompt ${request.params.name}:`, error);
+				throw error;
+			}
+		});
+	};
+	const customTransport = transportOptions?.create?.();
+	if (customTransport) {
+		console.log("[Web Model Context] Using custom transport");
+		const server = new Server({
+			name: hostname,
+			version: "1.0.0"
+		}, { capabilities: {
+			tools: { listChanged: true },
+			resources: { listChanged: true },
+			prompts: { listChanged: true }
+		} });
+		const bridge$1 = {
+			tabServer: server,
+			tools: /* @__PURE__ */ new Map(),
+			resources: /* @__PURE__ */ new Map(),
+			prompts: /* @__PURE__ */ new Map(),
+			modelContext: void 0,
+			isInitialized: true
+		};
+		bridge$1.modelContext = new WebModelContext(bridge$1);
+		setupServerHandlers(server, bridge$1);
+		server.connect(customTransport);
+		console.log("[Web Model Context] MCP server connected with custom transport");
+		return bridge$1;
+	}
+	console.log("[Web Model Context] Using dual-server mode");
+	const tabServerEnabled = transportOptions?.tabServer !== false;
+	const tabServer = new Server({
+		name: `${hostname}-tab`,
+		version: "1.0.0"
+	}, { capabilities: {
+		tools: { listChanged: true },
+		resources: { listChanged: true },
+		prompts: { listChanged: true }
+	} });
+	const bridge = {
+		tabServer,
+		tools: /* @__PURE__ */ new Map(),
+		resources: /* @__PURE__ */ new Map(),
+		prompts: /* @__PURE__ */ new Map(),
+		modelContext: void 0,
+		isInitialized: true
+	};
+	bridge.modelContext = new WebModelContext(bridge);
+	setupServerHandlers(tabServer, bridge);
+	if (tabServerEnabled) {
+		const { allowedOrigins,...restTabServerOptions } = typeof transportOptions?.tabServer === "object" ? transportOptions.tabServer : {};
+		const tabTransport = new TabServerTransport({
+			allowedOrigins: allowedOrigins ?? ["*"],
+			...restTabServerOptions
+		});
+		tabServer.connect(tabTransport);
+		console.log("[Web Model Context] Tab server connected");
+	}
+	const isInIframe = typeof window !== "undefined" && window.parent !== window;
+	const iframeServerConfig = transportOptions?.iframeServer;
+	if (iframeServerConfig !== false && (iframeServerConfig !== void 0 || isInIframe)) {
+		console.log("[Web Model Context] Enabling iframe server");
+		const iframeServer = new Server({
+			name: `${hostname}-iframe`,
+			version: "1.0.0"
+		}, { capabilities: {
+			tools: { listChanged: true },
+			resources: { listChanged: true },
+			prompts: { listChanged: true }
+		} });
+		setupServerHandlers(iframeServer, bridge);
+		const { allowedOrigins,...restIframeServerOptions } = typeof iframeServerConfig === "object" ? iframeServerConfig : {};
+		const iframeTransport = new IframeChildTransport({
+			allowedOrigins: allowedOrigins ?? ["*"],
+			...restIframeServerOptions
+		});
+		iframeServer.connect(iframeTransport);
+		bridge.iframeServer = iframeServer;
+		console.log("[Web Model Context] Iframe server connected");
+	}
+	return bridge;
+}
+/**
+* Initializes the Web Model Context API on window.navigator.
+* Creates and exposes navigator.modelContext and navigator.modelContextTesting.
+* Automatically detects and uses native Chromium implementation if available.
+*
+* @param {WebModelContextInitOptions} [options] - Configuration options
+* @throws {Error} If initialization fails
+* @example
+* ```typescript
+* import { initializeWebModelContext } from '@mcp-b/global';
+*
+* initializeWebModelContext({
+*   transport: {
+*     tabServer: {
+*       allowedOrigins: ['https://example.com']
+*     }
+*   }
+* });
+* ```
+*/
+function initializeWebModelContext(options) {
+	if (typeof window === "undefined") {
+		console.warn("[Web Model Context] Not in browser environment, skipping initialization");
+		return;
+	}
+	const effectiveOptions = options ?? window.__webModelContextOptions;
+	const native = detectNativeAPI();
+	if (native.hasNativeContext && native.hasNativeTesting) {
+		const nativeContext = window.navigator.modelContext;
+		const nativeTesting = window.navigator.modelContextTesting;
+		if (!nativeContext || !nativeTesting) {
+			console.error("[Web Model Context] Native API detection mismatch");
+			return;
+		}
+		console.log("✅ [Web Model Context] Native Chromium API detected");
+		console.log("   Using native implementation with MCP bridge synchronization");
+		console.log("   Native API will automatically collect tools from embedded iframes");
+		try {
+			const bridge = initializeMCPBridge(effectiveOptions);
+			bridge.modelContext = new NativeModelContextAdapter(bridge, nativeContext, nativeTesting);
+			bridge.modelContextTesting = nativeTesting;
+			Object.defineProperty(window, "__mcpBridge", {
+				value: bridge,
+				writable: false,
+				configurable: true
+			});
+			console.log("✅ [Web Model Context] MCP bridge synced with native API");
+			console.log("   MCP clients will receive automatic tool updates from native registry");
+		} catch (error) {
+			console.error("[Web Model Context] Failed to initialize native adapter:", error);
+			throw error;
+		}
+		return;
+	}
+	if (native.hasNativeContext && !native.hasNativeTesting) {
+		console.warn("[Web Model Context] Partial native API detected");
+		console.warn("   navigator.modelContext exists but navigator.modelContextTesting is missing");
+		console.warn("   Cannot sync with native API. Please enable experimental features:");
+		console.warn("      - Navigate to chrome://flags");
+		console.warn("      - Enable \"Experimental Web Platform Features\"");
+		console.warn("      - Or launch with: --enable-experimental-web-platform-features");
+		console.warn("   Skipping initialization to avoid conflicts");
+		return;
+	}
+	if (window.navigator.modelContext) {
+		console.warn("[Web Model Context] window.navigator.modelContext already exists, skipping initialization");
+		return;
+	}
+	console.log("[Web Model Context] Native API not detected, installing polyfill");
+	try {
+		const bridge = initializeMCPBridge(effectiveOptions);
+		Object.defineProperty(window.navigator, "modelContext", {
+			value: bridge.modelContext,
+			writable: false,
+			configurable: false
+		});
+		Object.defineProperty(window, "__mcpBridge", {
+			value: bridge,
+			writable: false,
+			configurable: true
+		});
+		console.log("✅ [Web Model Context] window.navigator.modelContext initialized successfully");
+		console.log("[Model Context Testing] Installing polyfill");
+		console.log("   💡 To use the native implementation in Chromium:");
+		console.log("      - Navigate to chrome://flags");
+		console.log("      - Enable \"Experimental Web Platform Features\"");
+		console.log("      - Or launch with: --enable-experimental-web-platform-features");
+		const testingAPI = new WebModelContextTesting(bridge);
+		bridge.modelContextTesting = testingAPI;
+		bridge.modelContext.setTestingAPI(testingAPI);
+		Object.defineProperty(window.navigator, "modelContextTesting", {
+			value: testingAPI,
+			writable: false,
+			configurable: true
+		});
+		console.log("✅ [Model Context Testing] Polyfill installed at window.navigator.modelContextTesting");
+	} catch (error) {
+		console.error("[Web Model Context] Failed to initialize:", error);
+		throw error;
+	}
+}
+/**
+* Cleans up the Web Model Context API.
+* Closes all MCP servers and removes API from window.navigator.
+* Useful for testing and hot module replacement.
+*
+* @example
+* ```typescript
+* import { cleanupWebModelContext } from '@mcp-b/global';
+*
+* cleanupWebModelContext();
+* ```
+*/
+function cleanupWebModelContext() {
+	if (typeof window === "undefined") return;
+	if (window.__mcpBridge) try {
+		window.__mcpBridge.tabServer.close();
+		if (window.__mcpBridge.iframeServer) window.__mcpBridge.iframeServer.close();
+	} catch (error) {
+		console.warn("[Web Model Context] Error closing MCP servers:", error);
+	}
+	delete window.navigator.modelContext;
+	delete window.navigator.modelContextTesting;
+	delete window.__mcpBridge;
+	console.log("[Web Model Context] Cleaned up");
+}
+
+//#endregion
+//#region src/index.ts
+function mergeTransportOptions(base, override) {
+	if (!base) return override;
+	if (!override) return base;
+	return {
+		...base,
+		...override,
+		tabServer: {
+			...base.tabServer ?? {},
+			...override.tabServer ?? {}
+		}
+	};
+}
+function mergeInitOptions(base, override) {
+	if (!base) return override;
+	if (!override) return base;
+	return {
+		...base,
+		...override,
+		transport: mergeTransportOptions(base.transport ?? {}, override.transport ?? {})
+	};
+}
+function parseScriptTagOptions(script) {
+	if (!script || !script.dataset) return;
+	const { dataset } = script;
+	if (dataset.webmcpOptions) try {
+		return JSON.parse(dataset.webmcpOptions);
+	} catch (error) {
+		console.error("[Web Model Context] Invalid JSON in data-webmcp-options:", error);
+		return;
+	}
+	const options = {};
+	let hasOptions = false;
+	if (dataset.webmcpAutoInitialize !== void 0) {
+		options.autoInitialize = dataset.webmcpAutoInitialize !== "false";
+		hasOptions = true;
+	}
+	const tabServerOptions = {};
+	let hasTabServerOptions = false;
+	if (dataset.webmcpAllowedOrigins) {
+		const origins = dataset.webmcpAllowedOrigins.split(",").map((origin) => origin.trim()).filter((origin) => origin.length > 0);
+		if (origins.length > 0) {
+			tabServerOptions.allowedOrigins = origins;
+			hasOptions = true;
+			hasTabServerOptions = true;
+		}
+	}
+	if (dataset.webmcpChannelId) {
+		tabServerOptions.channelId = dataset.webmcpChannelId;
+		hasOptions = true;
+		hasTabServerOptions = true;
+	}
+	if (hasTabServerOptions) options.transport = {
+		...options.transport ?? {},
+		tabServer: {
+			...options.transport?.tabServer ?? {},
+			...tabServerOptions
+		}
+	};
+	return hasOptions ? options : void 0;
+}
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+	const globalOptions = window.__webModelContextOptions;
+	const scriptElement = document.currentScript;
+	const scriptOptions = parseScriptTagOptions(scriptElement);
+	const mergedOptions = mergeInitOptions(globalOptions, scriptOptions) ?? globalOptions ?? scriptOptions;
+	if (mergedOptions) window.__webModelContextOptions = mergedOptions;
+	const shouldAutoInitialize = mergedOptions?.autoInitialize !== false;
+	try {
+		if (shouldAutoInitialize) initializeWebModelContext(mergedOptions);
+	} catch (error) {
+		console.error("[Web Model Context] Auto-initialization failed:", error);
+	}
+}
+
+//#endregion
+export { cleanupWebModelContext, initializeWebModelContext, zodToJsonSchema };
+//# sourceMappingURL=index.js.map