@mcp-b/global 1.1.2 → 1.1.3-beta.2

package/dist/index.js

@@ -1,7 +1,8 @@
 import { IframeChildTransport, TabServerTransport } from "@mcp-b/transports";
-import { CallToolRequestSchema, ListToolsRequestSchema, Server } from "@mcp-b/webmcp-ts-sdk";
+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
 /**
@@ -29,44 +30,17 @@ function jsonSchemaToZod$1(jsonSchema) {
 }
 /**
 * Convert Zod schema object to JSON Schema
-* Based on react-webmcp implementation
+* 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 properties = {};
-	const required = [];
-	for (const [key, zodType] of Object.entries(schema)) {
-		const description = zodType.description || void 0;
-		let type = "string";
-		let enumValues;
-		let items;
-		if (zodType instanceof z.ZodString) type = "string";
-		else if (zodType instanceof z.ZodNumber) type = "number";
-		else if (zodType instanceof z.ZodBoolean) type = "boolean";
-		else if (zodType instanceof z.ZodArray) {
-			type = "array";
-			const elementType = zodType.element;
-			if (elementType instanceof z.ZodString) items = { type: "string" };
-			else if (elementType instanceof z.ZodNumber) items = { type: "number" };
-			else if (elementType instanceof z.ZodBoolean) items = { type: "boolean" };
-			else items = { type: "string" };
-		} else if (zodType instanceof z.ZodObject) type = "object";
-		else if (zodType instanceof z.ZodEnum) {
-			type = "string";
-			const enumDef = zodType._def;
-			if (enumDef?.values) enumValues = enumDef.values;
-		}
-		const propertySchema = { type };
-		if (description) propertySchema.description = description;
-		if (enumValues) propertySchema.enum = enumValues;
-		if (items) propertySchema.items = items;
-		properties[key] = propertySchema;
-		if (!zodType.isOptional()) required.push(key);
-	}
-	return {
-		type: "object",
-		properties,
-		...required.length > 0 && { required }
-	};
+	const { $schema: _,...rest } = zodToJsonSchema$1(z.object(schema), {
+		$refStrategy: "none",
+		target: "jsonSchema7"
+	});
+	return rest;
 }
 /**
 * Normalize a schema to both JSON Schema and Zod formats
@@ -326,6 +300,75 @@ var NativeModelContextAdapter = class {
 		}));
 	}
 	/**
+	* 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.
 	*
@@ -357,6 +400,28 @@ var NativeModelContextAdapter = class {
 	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.
@@ -612,8 +677,16 @@ var WebModelContext = class {
 	eventTarget;
 	provideContextTools;
 	dynamicTools;
-	registrationTimestamps;
-	unregisterFunctions;
+	provideContextResources;
+	dynamicResources;
+	provideContextPrompts;
+	dynamicPrompts;
+	toolRegistrationTimestamps;
+	resourceRegistrationTimestamps;
+	promptRegistrationTimestamps;
+	toolUnregisterFunctions;
+	resourceUnregisterFunctions;
+	promptUnregisterFunctions;
 	testingAPI;
 	/**
 	* Creates a new WebModelContext instance.
@@ -625,8 +698,16 @@ var WebModelContext = class {
 		this.eventTarget = new EventTarget();
 		this.provideContextTools = /* @__PURE__ */ new Map();
 		this.dynamicTools = /* @__PURE__ */ new Map();
-		this.registrationTimestamps = /* @__PURE__ */ new Map();
-		this.unregisterFunctions = /* @__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.
@@ -668,17 +749,22 @@ var WebModelContext = class {
 		return this.eventTarget.dispatchEvent(event);
 	}
 	/**
-	* Provides context (tools) to AI models by registering base tools (Bucket A).
-	* Clears and replaces all previously registered base tools while preserving
-	* dynamic tools registered via registerTool().
+	* 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 to register
-	* @throws {Error} If a tool name collides with an existing dynamic tool
+	* @param {ModelContextInput} context - Context containing tools, resources, and prompts to register
+	* @throws {Error} If a name/uri collides with existing dynamic items
 	*/
 	provideContext(context) {
-		console.log(`[Web Model Context] Registering ${context.tools.length} tools via provideContext`);
+		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();
-		for (const tool of context.tools) {
+		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;
@@ -694,8 +780,63 @@ var WebModelContext = class {
 			};
 			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.notifyToolsListChanged();
+		this.notifyResourcesListChanged();
+		this.notifyPromptsListChanged();
+	}
+	/**
+	* 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).
@@ -708,10 +849,10 @@ var WebModelContext = class {
 	registerTool(tool) {
 		console.log(`[Web Model Context] Registering tool dynamically: ${tool.name}`);
 		const now = Date.now();
-		const lastRegistration = this.registrationTimestamps.get(tool.name);
+		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.unregisterFunctions.get(tool.name);
+			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.`);
@@ -729,7 +870,7 @@ var WebModelContext = class {
 			...normalizedOutput && { outputValidator: normalizedOutput.zodValidator }
 		};
 		this.dynamicTools.set(tool.name, validatedTool);
-		this.registrationTimestamps.set(tool.name, now);
+		this.toolRegistrationTimestamps.set(tool.name, now);
 		this.updateBridgeTools();
 		this.notifyToolsListChanged();
 		const unregisterFn = () => {
@@ -740,15 +881,186 @@ var WebModelContext = class {
 				return;
 			}
 			this.dynamicTools.delete(tool.name);
-			this.registrationTimestamps.delete(tool.name);
-			this.unregisterFunctions.delete(tool.name);
+			this.toolRegistrationTimestamps.delete(tool.name);
+			this.toolUnregisterFunctions.delete(tool.name);
 			this.updateBridgeTools();
 			this.notifyToolsListChanged();
 		};
-		this.unregisterFunctions.set(tool.name, unregisterFn);
+		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.notifyResourcesListChanged();
+		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.notifyResourcesListChanged();
+		};
+		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.notifyResourcesListChanged();
+	}
+	/**
+	* 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.notifyPromptsListChanged();
+		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.notifyPromptsListChanged();
+		};
+		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.notifyPromptsListChanged();
+	}
+	/**
+	* 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).
 	*
@@ -765,24 +1077,36 @@ var WebModelContext = class {
 		if (inProvideContext) this.provideContextTools.delete(name);
 		if (inDynamic) {
 			this.dynamicTools.delete(name);
-			this.registrationTimestamps.delete(name);
-			this.unregisterFunctions.delete(name);
+			this.toolRegistrationTimestamps.delete(name);
+			this.toolUnregisterFunctions.delete(name);
 		}
 		this.updateBridgeTools();
 		this.notifyToolsListChanged();
 	}
 	/**
-	* Clears all registered tools from both buckets (Chromium native API).
-	* Removes all tools registered via provideContext() and registerTool().
+	* 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 tools");
+		console.log("[Web Model Context] Clearing all context (tools, resources, prompts)");
 		this.provideContextTools.clear();
 		this.dynamicTools.clear();
-		this.registrationTimestamps.clear();
-		this.unregisterFunctions.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.notifyToolsListChanged();
+		this.notifyResourcesListChanged();
+		this.notifyPromptsListChanged();
 	}
 	/**
 	* Updates the bridge tools map with merged tools from both buckets.
@@ -814,6 +1138,146 @@ var WebModelContext = class {
 		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: {}
+		});
+	}
+	/**
+	* 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
@@ -897,6 +1361,32 @@ var WebModelContext = class {
 			...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.
@@ -930,6 +1420,32 @@ function initializeMCPBridge(options) {
 				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) {
@@ -937,10 +1453,16 @@ function initializeMCPBridge(options) {
 		const server = new Server({
 			name: hostname,
 			version: "1.0.0"
-		}, { capabilities: { tools: { listChanged: true } } });
+		}, { 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
 		};
@@ -955,10 +1477,16 @@ function initializeMCPBridge(options) {
 	const tabServer = new Server({
 		name: `${hostname}-tab`,
 		version: "1.0.0"
-	}, { capabilities: { tools: { listChanged: true } } });
+	}, { 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
 	};
@@ -980,7 +1508,11 @@ function initializeMCPBridge(options) {
 		const iframeServer = new Server({
 			name: `${hostname}-iframe`,
 			version: "1.0.0"
-		}, { capabilities: { tools: { listChanged: true } } });
+		}, { capabilities: {
+			tools: { listChanged: true },
+			resources: { listChanged: true },
+			prompts: { listChanged: true }
+		} });
 		setupServerHandlers(iframeServer, bridge);
 		const { allowedOrigins,...restIframeServerOptions } = typeof iframeServerConfig === "object" ? iframeServerConfig : {};
 		const iframeTransport = new IframeChildTransport({
@@ -1197,5 +1729,5 @@ if (typeof window !== "undefined" && typeof document !== "undefined") {
 }
 
 //#endregion
-export { cleanupWebModelContext, initializeWebModelContext };
+export { cleanupWebModelContext, initializeWebModelContext, zodToJsonSchema };
 //# sourceMappingURL=index.js.map