@mcp-b/webmcp-ts-sdk 2.1.0 → 2.2.1

package/dist/index.js

@@ -105,10 +105,10 @@ function isSchemaOptional(schema) {
 */
 function getLiteralValue(schema) {
 	if (isZ4Schema(schema)) {
-		const def$1 = schema._zod?.def;
-		if (def$1) {
-			if (def$1.value !== void 0) return def$1.value;
-			if (Array.isArray(def$1.values) && def$1.values.length > 0) return def$1.values[0];
+		const def = schema._zod?.def;
+		if (def) {
+			if (def.value !== void 0) return def.value;
+			if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
 		}
 	}
 	const def = schema._def;
@@ -196,7 +196,7 @@ const RequestIdSchema = z.union([z.string(), z.number().int()]);
 * A request that expects a response.
 */
 const JSONRPCRequestSchema = z.object({
-	jsonrpc: z.literal(JSONRPC_VERSION),
+	jsonrpc: z.literal("2.0"),
 	id: RequestIdSchema,
 	...RequestSchema.shape
 }).strict();
@@ -205,7 +205,7 @@ const isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).succes
 * A notification which does not expect a response.
 */
 const JSONRPCNotificationSchema = z.object({
-	jsonrpc: z.literal(JSONRPC_VERSION),
+	jsonrpc: z.literal("2.0"),
 	...NotificationSchema.shape
 }).strict();
 const isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
@@ -213,7 +213,7 @@ const isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(val
 * A successful (non-error) response to a request.
 */
 const JSONRPCResultResponseSchema = z.object({
-	jsonrpc: z.literal(JSONRPC_VERSION),
+	jsonrpc: z.literal("2.0"),
 	id: RequestIdSchema,
 	result: ResultSchema
 }).strict();
@@ -228,21 +228,21 @@ const isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse
 * Error codes defined by the JSON-RPC specification.
 */
 var ErrorCode;
-(function(ErrorCode$1) {
-	ErrorCode$1[ErrorCode$1["ConnectionClosed"] = -32e3] = "ConnectionClosed";
-	ErrorCode$1[ErrorCode$1["RequestTimeout"] = -32001] = "RequestTimeout";
-	ErrorCode$1[ErrorCode$1["ParseError"] = -32700] = "ParseError";
-	ErrorCode$1[ErrorCode$1["InvalidRequest"] = -32600] = "InvalidRequest";
-	ErrorCode$1[ErrorCode$1["MethodNotFound"] = -32601] = "MethodNotFound";
-	ErrorCode$1[ErrorCode$1["InvalidParams"] = -32602] = "InvalidParams";
-	ErrorCode$1[ErrorCode$1["InternalError"] = -32603] = "InternalError";
-	ErrorCode$1[ErrorCode$1["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
+(function(ErrorCode) {
+	ErrorCode[ErrorCode["ConnectionClosed"] = -32e3] = "ConnectionClosed";
+	ErrorCode[ErrorCode["RequestTimeout"] = -32001] = "RequestTimeout";
+	ErrorCode[ErrorCode["ParseError"] = -32700] = "ParseError";
+	ErrorCode[ErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+	ErrorCode[ErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+	ErrorCode[ErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+	ErrorCode[ErrorCode["InternalError"] = -32603] = "InternalError";
+	ErrorCode[ErrorCode["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
 })(ErrorCode || (ErrorCode = {}));
 /**
 * A response to a request that indicates an error occurred.
 */
 const JSONRPCErrorResponseSchema = z.object({
-	jsonrpc: z.literal(JSONRPC_VERSION),
+	jsonrpc: z.literal("2.0"),
 	id: RequestIdSchema.optional(),
 	error: z.object({
 		code: z.number().int(),
@@ -1720,7 +1720,7 @@ var Protocol = class {
 		});
 	}
 	_onprogress(notification) {
-		const { progressToken,...params } = notification.params;
+		const { progressToken, ...params } = notification.params;
 		const messageId = Number(progressToken);
 		const handler = this._progressHandlers.get(messageId);
 		if (!handler) {
@@ -1834,34 +1834,34 @@ var Protocol = class {
 				};
 			} else throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
 			while (true) {
-				const task$1 = await this.getTask({ taskId }, options);
+				const task = await this.getTask({ taskId }, options);
 				yield {
 					type: "taskStatus",
-					task: task$1
+					task
 				};
-				if (isTerminal(task$1.status)) {
-					if (task$1.status === "completed") yield {
+				if (isTerminal(task.status)) {
+					if (task.status === "completed") yield {
 						type: "result",
 						result: await this.getTaskResult({ taskId }, resultSchema, options)
 					};
-					else if (task$1.status === "failed") yield {
+					else if (task.status === "failed") yield {
 						type: "error",
 						error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
 					};
-					else if (task$1.status === "cancelled") yield {
+					else if (task.status === "cancelled") yield {
 						type: "error",
 						error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
 					};
 					return;
 				}
-				if (task$1.status === "input_required") {
+				if (task.status === "input_required") {
 					yield {
 						type: "result",
 						result: await this.getTaskResult({ taskId }, resultSchema, options)
 					};
 					return;
 				}
-				const pollInterval = task$1.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
+				const pollInterval = task.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
 				await new Promise((resolve) => setTimeout(resolve, pollInterval));
 				options?.signal?.throwIfAborted();
 			}
@@ -1954,7 +1954,7 @@ var Protocol = class {
 			options?.signal?.addEventListener("abort", () => {
 				cancel(options?.signal?.reason);
 			});
-			const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+			const timeout = options?.timeout ?? 6e4;
 			const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
 			this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
 			const relatedTaskId = relatedTask?.taskId;
@@ -2035,7 +2035,7 @@ var Protocol = class {
 		this.assertNotificationCapability(notification.method);
 		const relatedTaskId = options?.relatedTask?.taskId;
 		if (relatedTaskId) {
-			const jsonrpcNotification$1 = {
+			const jsonrpcNotification = {
 				...notification,
 				jsonrpc: "2.0",
 				params: {
@@ -2048,7 +2048,7 @@ var Protocol = class {
 			};
 			await this._enqueueTaskMessage(relatedTaskId, {
 				type: "notification",
-				message: jsonrpcNotification$1,
+				message: jsonrpcNotification,
 				timestamp: Date.now()
 			});
 			return;
@@ -2059,21 +2059,21 @@ var Protocol = class {
 			Promise.resolve().then(() => {
 				this._pendingDebouncedNotifications.delete(notification.method);
 				if (!this._transport) return;
-				let jsonrpcNotification$1 = {
+				let jsonrpcNotification = {
 					...notification,
 					jsonrpc: "2.0"
 				};
-				if (options?.relatedTask) jsonrpcNotification$1 = {
-					...jsonrpcNotification$1,
+				if (options?.relatedTask) jsonrpcNotification = {
+					...jsonrpcNotification,
 					params: {
-						...jsonrpcNotification$1.params,
+						...jsonrpcNotification.params,
 						_meta: {
-							...jsonrpcNotification$1.params?._meta || {},
+							...jsonrpcNotification.params?._meta || {},
 							[RELATED_TASK_META_KEY]: options.relatedTask
 						}
 					}
 				};
-				this._transport?.send(jsonrpcNotification$1, options).catch((error) => this._onerror(error));
+				this._transport?.send(jsonrpcNotification, options).catch((error) => this._onerror(error));
 			});
 			return;
 		}
@@ -2300,7 +2300,6 @@ var Ajv = class {
 		return "";
 	}
 };
-var ajv_default = Ajv;
 
 //#endregion
 //#region src/stubs/ajv-formats.ts
@@ -2312,8 +2311,11 @@ function addFormats(_ajv) {}
 
 //#endregion
 //#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
+/**
+* AJV-based JSON Schema validator provider
+*/
 function createDefaultAjvInstance() {
-	const ajv = new ajv_default({
+	const ajv = new Ajv({
 		strict: false,
 		validateFormats: true,
 		validateSchema: false,
@@ -2388,6 +2390,12 @@ var AjvJsonSchemaValidator = class {
 //#endregion
 //#region ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.26.0_@cfworker+json-schema@4.1.1_zod@4.3.5/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
 /**
+* Experimental client task features for MCP SDK.
+* WARNING: These APIs are experimental and may change without notice.
+*
+* @experimental
+*/
+/**
 * Experimental task features for MCP clients.
 *
 * Access via `client.experimental.tasks`:
@@ -3563,8 +3571,8 @@ function getCompleter(schema) {
 	return schema[COMPLETABLE_SYMBOL]?.complete;
 }
 var McpZodTypeKind;
-(function(McpZodTypeKind$1) {
-	McpZodTypeKind$1["Completable"] = "McpCompletable";
+(function(McpZodTypeKind) {
+	McpZodTypeKind["Completable"] = "McpCompletable";
 })(McpZodTypeKind || (McpZodTypeKind = {}));
 
 //#endregion
@@ -4336,6 +4344,11 @@ function isCallToolResult(value) {
 function isJsonPrimitive(value) {
 	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
+function isPermissionsPolicySecurityError(error) {
+	if (!error || typeof error !== "object") return false;
+	const { name, message } = error;
+	return name === "SecurityError" && typeof message === "string" && /permissions policy|feature "tools" is disallowed/i.test(message);
+}
 function isJsonValue(value) {
 	if (isJsonPrimitive(value)) return Number.isFinite(value) || typeof value !== "number";
 	if (Array.isArray(value)) return value.every((entry) => isJsonValue(entry));
@@ -4376,13 +4389,15 @@ function withDefaultTimeout(options) {
 /**
 * Browser-optimized MCP Server that speaks WebMCP natively.
 *
-* This server IS navigator.modelContext — it implements the WebMCP standard API
-* (provideContext, registerTool, unregisterTool, clearContext) while retaining
-* full MCP protocol capabilities (resources, prompts, elicitation, sampling)
-* via the inherited BaseMcpServer surface.
+* Implements `registerTool(tool, options?)` while retaining MCP capabilities
+* (resources, prompts, elicitation, sampling) via BaseMcpServer.
+*
+* Deprecated compatibility (kept for Chrome Beta 147 and existing wrappers,
+* removed in the next major): `unregisterTool(name)`, `provideContext()`,
+* `clearContext()`, and the `{ unregister }` handle returned from `registerTool`.
 *
-* When `native` is provided, all tool operations are mirrored to it so that
-* navigator.modelContextTesting (polyfill testing shim) stays in sync.
+* When `native` is provided, tool operations are mirrored so that
+* navigator.modelContextTesting stays in sync.
 */
 var BrowserMcpServer = class extends McpServer {
 	[SERVER_MARKER_PROPERTY] = true;
@@ -4390,6 +4405,12 @@ var BrowserMcpServer = class extends McpServer {
 	_promptSchemas = /* @__PURE__ */ new Map();
 	_jsonValidator;
 	_publicMethodsBound = false;
+	_provideContextDeprecationWarned = false;
+	_clearContextDeprecationWarned = false;
+	_unregisterToolDeprecationWarned = false;
+	_nativeToolCleanups = /* @__PURE__ */ new Map();
+	_producerEventTarget = new EventTarget();
+	_ontoolchange = null;
 	constructor(serverInfo, options) {
 		const validator = new PolyfillJsonSchemaValidator();
 		const enhancedOptions = {
@@ -4416,8 +4437,12 @@ var BrowserMcpServer = class extends McpServer {
 		this.provideContext = this.provideContext.bind(this);
 		this.clearContext = this.clearContext.bind(this);
 		this.listTools = this.listTools.bind(this);
+		this.getTools = this.getTools.bind(this);
 		this.callTool = this.callTool.bind(this);
 		this.executeTool = this.executeTool.bind(this);
+		this.addEventListener = this.addEventListener.bind(this);
+		this.removeEventListener = this.removeEventListener.bind(this);
+		this.dispatchEvent = this.dispatchEvent.bind(this);
 		this.registerResource = this.registerResource.bind(this);
 		this.listResources = this.listResources.bind(this);
 		this.readResource = this.readResource.bind(this);
@@ -4478,6 +4503,71 @@ var BrowserMcpServer = class extends McpServer {
 		if (typeof candidate.listTools !== "function" || typeof candidate.callTool !== "function") return;
 		return candidate;
 	}
+	getNativeUnregisterTool() {
+		if (!this.native) return;
+		const unregisterTool = this.native.unregisterTool;
+		if (typeof unregisterTool !== "function") return;
+		return (nameOrTool) => unregisterTool.call(this.native, nameOrTool);
+	}
+	createNativeToolCleanup(signal) {
+		const controller = new AbortController();
+		let removeSignalListener;
+		if (signal) {
+			const abortNativeSignal = () => {
+				controller.abort();
+			};
+			if (signal.aborted) abortNativeSignal();
+			else {
+				signal.addEventListener("abort", abortNativeSignal, { once: true });
+				removeSignalListener = () => signal.removeEventListener("abort", abortNativeSignal);
+			}
+		}
+		return {
+			options: { signal: controller.signal },
+			abort: () => {
+				removeSignalListener?.();
+				if (!controller.signal.aborted) controller.abort();
+			}
+		};
+	}
+	registerNativeToolMirror(tool, signal) {
+		if (!this.native) return;
+		const nativeRegister = this.native.registerTool;
+		const nativeUnregisterTool = this.getNativeUnregisterTool();
+		const cleanup = Boolean(signal) || !nativeUnregisterTool ? this.createNativeToolCleanup(signal) : void 0;
+		try {
+			if (cleanup) nativeRegister.call(this.native, tool, cleanup.options);
+			else nativeRegister.call(this.native, tool);
+		} catch (error) {
+			cleanup?.abort();
+			if (isPermissionsPolicySecurityError(error)) {
+				console.warn("[BrowserMcpServer] Native WebMCP tool mirror is blocked by permissions policy; continuing with WebMCP transport registration only.");
+				return;
+			}
+			throw error;
+		}
+		if (!cleanup) return;
+		const nativeToolCleanup = {
+			abort: cleanup.abort,
+			nativeSignalAccepted: nativeRegister.length >= 2 || !nativeUnregisterTool
+		};
+		this._nativeToolCleanups.set(tool.name, nativeToolCleanup);
+		return nativeToolCleanup;
+	}
+	unregisterNativeToolMirror(name, options) {
+		const cleanup = this._nativeToolCleanups.get(name);
+		this._nativeToolCleanups.delete(name);
+		const nativeUnregisterTool = this.getNativeUnregisterTool();
+		if (options?.preferAbortSignal && cleanup?.nativeSignalAccepted === true || !nativeUnregisterTool) {
+			cleanup?.abort();
+			return;
+		}
+		try {
+			nativeUnregisterTool(name);
+		} finally {
+			cleanup?.abort();
+		}
+	}
 	registerToolInServer(tool) {
 		const inputSchema = this.toTransportSchema(tool.inputSchema);
 		super.registerTool(tool.name, {
@@ -4488,8 +4578,35 @@ var BrowserMcpServer = class extends McpServer {
 		}, async (args) => {
 			return normalizeToolResponse(await tool.execute(args, { requestUserInteraction: async (cb) => cb() }));
 		});
+		this.notifyProducerToolsChanged();
 		return { unregister: () => this.unregisterTool(tool.name) };
 	}
+	get ontoolchange() {
+		return this._ontoolchange;
+	}
+	set ontoolchange(handler) {
+		this._ontoolchange = handler;
+	}
+	addEventListener(type, listener, options) {
+		this._producerEventTarget.addEventListener(type, listener, options);
+	}
+	removeEventListener(type, listener, options) {
+		this._producerEventTarget.removeEventListener(type, listener, options);
+	}
+	dispatchEvent(event) {
+		return this._producerEventTarget.dispatchEvent(event);
+	}
+	notifyProducerToolsChanged() {
+		queueMicrotask(() => {
+			const event = new Event("toolchange");
+			try {
+				this._ontoolchange?.call(this, event);
+			} catch (error) {
+				console.warn("[BrowserMcpServer] navigator.modelContext.ontoolchange handler threw:", error);
+			}
+			this.dispatchEvent(event);
+		});
+	}
 	backfillTools(tools, execute) {
 		let synced = 0;
 		for (const sourceTool of tools) {
@@ -4507,18 +4624,34 @@ var BrowserMcpServer = class extends McpServer {
 		}
 		return synced;
 	}
-	registerTool(tool) {
-		if (this.native) this.native.registerTool(tool);
+	registerTool(tool, options) {
+		const signal = options?.signal;
+		if (signal?.aborted) {
+			console.warn(`[BrowserMcpServer] registerTool("${tool?.name ?? "<unknown>"}") skipped: options.signal was already aborted.`);
+			return { unregister: () => {} };
+		}
+		this.registerNativeToolMirror(tool, signal);
+		let handle;
 		try {
-			return this.registerToolInServer(tool);
+			handle = this.registerToolInServer(tool);
 		} catch (error) {
 			if (this.native) try {
-				this.native.unregisterTool(tool.name);
+				this.unregisterNativeToolMirror(tool.name);
 			} catch (rollbackError) {
 				console.error("[BrowserMcpServer] Rollback of native tool registration failed:", rollbackError);
 			}
 			throw error;
 		}
+		if (signal) signal.addEventListener("abort", () => {
+			this._parentTools[tool.name]?.remove();
+			try {
+				this.unregisterNativeToolMirror(tool.name, { preferAbortSignal: true });
+			} catch (error) {
+				console.warn("[BrowserMcpServer] Native unregister via abort fallback failed:", error);
+			}
+			this.notifyProducerToolsChanged();
+		}, { once: true });
+		return handle;
 	}
 	/**
 	* Backfill tools that were already registered on the native/polyfill context
@@ -4533,9 +4666,26 @@ var BrowserMcpServer = class extends McpServer {
 			arguments: args
 		}));
 	}
-	unregisterTool(name) {
-		this._parentTools[name]?.remove();
-		if (this.native) this.native.unregisterTool(name);
+	unregisterTool(nameOrTool) {
+		this.warnUnregisterToolDeprecationOnce();
+		const name = this.resolveToolNameForUnregister(nameOrTool);
+		const existing = this._parentTools[name];
+		existing?.remove();
+		if (this.native) this.unregisterNativeToolMirror(name);
+		if (existing) this.notifyProducerToolsChanged();
+	}
+	clearRegisteredTools() {
+		let changed = false;
+		for (const name of Object.keys(this._parentTools)) {
+			this._parentTools[name]?.remove();
+			changed = true;
+			if (this.native) try {
+				this.unregisterNativeToolMirror(name);
+			} catch (error) {
+				console.warn("[BrowserMcpServer] Native unregister during clear failed:", error);
+			}
+		}
+		if (changed) this.notifyProducerToolsChanged();
 	}
 	registerResource(descriptor) {
 		const registered = super.registerResource(descriptor.name, descriptor.uri, {
@@ -4553,13 +4703,33 @@ var BrowserMcpServer = class extends McpServer {
 		} };
 	}
 	provideContext(options) {
-		for (const tool of Object.values(this._parentTools)) tool.remove();
-		if (this.native) this.native.clearContext();
+		this.warnProvideContextDeprecationOnce();
+		this.clearRegisteredTools();
 		for (const tool of options?.tools ?? []) this.registerTool(tool);
 	}
 	clearContext() {
-		for (const tool of Object.values(this._parentTools)) tool.remove();
-		if (this.native) this.native.clearContext();
+		this.warnClearContextDeprecationOnce();
+		this.clearRegisteredTools();
+	}
+	resolveToolNameForUnregister(nameOrTool) {
+		if (typeof nameOrTool === "string") return nameOrTool;
+		if (isPlainObject$1(nameOrTool) && typeof nameOrTool.name === "string") return nameOrTool.name;
+		throw new TypeError("Failed to execute 'unregisterTool' on 'ModelContext': parameter 1 must be a string or an object with a string name.");
+	}
+	warnProvideContextDeprecationOnce() {
+		if (this._provideContextDeprecationWarned) return;
+		this._provideContextDeprecationWarned = true;
+		console.warn("[BrowserMcpServer] navigator.modelContext.provideContext() is deprecated and will be removed in the next major version. Register tools individually with registerTool() instead.");
+	}
+	warnClearContextDeprecationOnce() {
+		if (this._clearContextDeprecationWarned) return;
+		this._clearContextDeprecationWarned = true;
+		console.warn("[BrowserMcpServer] navigator.modelContext.clearContext() is deprecated and will be removed in the next major version. Unregister individual tools instead.");
+	}
+	warnUnregisterToolDeprecationOnce() {
+		if (this._unregisterToolDeprecationWarned) return;
+		this._unregisterToolDeprecationWarned = true;
+		console.warn("[BrowserMcpServer] navigator.modelContext.unregisterTool() is deprecated. The April 23, 2026 WebMCP draft removed it in favor of registerTool(tool, { signal }) — pass an AbortSignal and abort it to unregister.");
 	}
 	listResources() {
 		return Object.entries(this._parentResources).filter(([, resource]) => resource.enabled).map(([uri, resource]) => ({
@@ -4609,6 +4779,21 @@ var BrowserMcpServer = class extends McpServer {
 			return item;
 		});
 	}
+	getTools() {
+		return this.listTools().map((tool) => {
+			let inputSchema;
+			try {
+				inputSchema = JSON.stringify(tool.inputSchema ?? DEFAULT_INPUT_SCHEMA);
+			} catch {
+				inputSchema = JSON.stringify(DEFAULT_INPUT_SCHEMA);
+			}
+			return {
+				name: tool.name,
+				description: tool.description ?? "",
+				inputSchema
+			};
+		});
+	}
 	/**
 	* Override SDK's validateToolInput to handle both Zod schemas and plain JSON Schema.
 	* Zod schemas use the SDK's safeParseAsync; plain JSON Schema uses PolyfillJsonSchemaValidator.
@@ -4616,9 +4801,9 @@ var BrowserMcpServer = class extends McpServer {
 	async validateToolInput(tool, args, toolName) {
 		if (!tool.inputSchema) return void 0;
 		if (this.isZodSchema(tool.inputSchema)) {
-			const result$1 = await safeParseAsync(tool.inputSchema, args ?? {});
-			if (!result$1.success) throw new Error(`Invalid arguments for tool ${toolName}: ${getParseErrorMessage(result$1.error)}`);
-			return result$1.data;
+			const result = await safeParseAsync(tool.inputSchema, args ?? {});
+			if (!result.success) throw new Error(`Invalid arguments for tool ${toolName}: ${getParseErrorMessage(result.error)}`);
+			return result.data;
 		}
 		const result = this._jsonValidator.getValidator(tool.inputSchema)(args ?? {});
 		if (!result.valid) throw new Error(`Invalid arguments for tool ${toolName}: ${result.errorMessage}`);