@mcp-b/global 1.2.2-beta.0 → 1.3.0

package/dist/index.js

@@ -1,6 +1,8 @@
 import { IframeChildTransport, TabServerTransport } from "@mcp-b/transports";
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, Server } from "@mcp-b/webmcp-ts-sdk";
-import { z } from "zod/v4";
+import { jsonSchemaToZod } from "@n8n/json-schema-to-zod";
+import { z } from "zod";
+import { zodToJsonSchema as zodToJsonSchema$1 } from "zod-to-json-schema";
 
 //#region src/logger.ts
 /**
@@ -90,71 +92,70 @@ function createLogger(namespace) {
 //#endregion
 //#region src/validation.ts
 const logger$2 = createLogger("WebModelContext");
-/**
-* Detect if a schema is a Zod schema object (Record<string, ZodType>)
-* or a JSON Schema object.
-*
-* Uses duck-typing to detect Zod 4 schemas by checking for the `_zod` property.
-*/
+const isRecord = (value) => typeof value === "object" && value !== null;
+const stripSchemaMeta = (schema) => {
+	const { $schema: _,...rest } = schema;
+	return rest;
+};
+const isOptionalSchema = (schema) => {
+	const typeName = schema._def?.typeName;
+	return typeName === "ZodOptional" || typeName === "ZodDefault";
+};
 function isZodSchema(schema) {
-	if (typeof schema !== "object" || schema === null) return false;
+	if (!isRecord(schema)) 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 != null && typeof val === "object" && "_zod" in val);
+	return values.some((v) => isRecord(v) && "_def" in v);
 }
-/**
-* Convert JSON Schema to Zod validator
-* Uses Zod 4's native z.fromJSONSchema() for conversion
-*/
-function jsonSchemaToZod(jsonSchema) {
+function zodToJsonSchema(schema) {
+	const properties = {};
+	const required = [];
+	for (const [key, zodSchema] of Object.entries(schema)) {
+		properties[key] = stripSchemaMeta(zodToJsonSchema$1(zodSchema, {
+			strictUnions: true,
+			$refStrategy: "none"
+		}));
+		if (!isOptionalSchema(zodSchema)) required.push(key);
+	}
+	const result = {
+		type: "object",
+		properties
+	};
+	if (required.length > 0) result.required = required;
+	return result;
+}
+function jsonSchemaToZod$1(jsonSchema) {
 	try {
-		return z.fromJSONSchema(jsonSchema);
+		return jsonSchemaToZod(jsonSchema);
 	} catch (error) {
-		logger$2.warn("Failed to convert JSON Schema to Zod:", error);
+		logger$2.warn("jsonSchemaToZod failed:", error);
 		return z.object({}).passthrough();
 	}
 }
-/**
-* Convert Zod schema object to JSON Schema
-* Uses Zod 4's native z.toJSONSchema() for 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 zodObject = z.object(schema);
-	const { $schema: _,...rest } = z.toJSONSchema(zodObject);
-	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;
+	if (isZodSchema(schema)) {
+		const jsonSchema = zodToJsonSchema(schema);
+		return {
+			jsonSchema,
+			zodValidator: jsonSchemaToZod$1(jsonSchema)
+		};
+	}
 	return {
-		jsonSchema,
-		zodValidator: jsonSchemaToZod(jsonSchema)
+		jsonSchema: schema,
+		zodValidator: jsonSchemaToZod$1(schema)
 	};
 }
-/**
-* 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.issues.map((err) => `  - ${err.path.join(".") || "root"}: ${err.message}`).join("\n")}`
-	};
-	return {
+	if (result.success) return {
 		success: true,
 		data: result.data
 	};
+	return {
+		success: false,
+		error: `Validation failed:\n${result.error.issues.map((err) => `  - ${err.path.join(".") || "root"}: ${err.message}`).join("\n")}`
+	};
 }
 
 //#endregion
@@ -181,6 +182,7 @@ const POLYFILL_MARKER_PROPERTY = "__isWebMCPPolyfill";
 * @returns Detection result with flags for native context and testing API availability
 */
 function detectNativeAPI() {
+	/* c8 ignore next 2 */
 	if (typeof window === "undefined" || typeof navigator === "undefined") return {
 		hasNativeContext: false,
 		hasNativeTesting: false
@@ -188,8 +190,8 @@ function detectNativeAPI() {
 	const modelContext = navigator.modelContext;
 	const modelContextTesting = navigator.modelContextTesting;
 	if (!modelContext || !modelContextTesting) return {
-		hasNativeContext: false,
-		hasNativeTesting: false
+		hasNativeContext: Boolean(modelContext),
+		hasNativeTesting: Boolean(modelContextTesting)
 	};
 	if (POLYFILL_MARKER_PROPERTY in modelContextTesting && modelContextTesting[POLYFILL_MARKER_PROPERTY] === true) return {
 		hasNativeContext: false,
@@ -258,7 +260,7 @@ var NativeModelContextAdapter = class {
 						const result = await this.nativeTesting.executeTool(toolInfo.name, JSON.stringify(args));
 						return this.convertToToolResponse(result);
 					},
-					inputValidator: jsonSchemaToZod(inputSchema)
+					inputValidator: jsonSchemaToZod$1(inputSchema)
 				};
 				this.bridge.tools.set(toolInfo.name, validatedTool);
 			} catch (error) {
@@ -316,24 +318,34 @@ var NativeModelContextAdapter = class {
 	}
 	/**
 	* Provides context (tools) to AI models via the native API.
-	* Delegates to navigator.modelContext.provideContext().
+	* Converts Zod schemas to JSON Schema before passing to native API.
 	* Tool change callback will fire and trigger sync automatically.
 	*
 	* @param {ModelContextInput} context - Context containing tools to register
 	*/
 	provideContext(context) {
-		this.nativeContext.provideContext(context);
+		const { tools,...rest } = context;
+		const normalizedContext = { ...rest };
+		if (tools) normalizedContext.tools = tools.map((tool) => ({
+			...tool,
+			inputSchema: normalizeSchema(tool.inputSchema).jsonSchema
+		}));
+		this.nativeContext.provideContext(normalizedContext);
 	}
 	/**
 	* Registers a single tool dynamically via the native API.
-	* Delegates to navigator.modelContext.registerTool().
+	* Converts Zod schemas to JSON Schema before passing to native API.
 	* Tool change callback will fire and trigger sync automatically.
 	*
 	* @param {ToolDescriptor} tool - The tool descriptor to register
 	* @returns {{unregister: () => void}} Object with unregister function
 	*/
 	registerTool(tool) {
-		return this.nativeContext.registerTool(tool);
+		const normalizedTool = {
+			...tool,
+			inputSchema: normalizeSchema(tool.inputSchema).jsonSchema
+		};
+		return this.nativeContext.registerTool(normalizedTool);
 	}
 	/**
 	* Unregisters a tool by name via the native API.
@@ -354,13 +366,15 @@ var NativeModelContextAdapter = class {
 	/**
 	* Executes a tool via the native API.
 	* Delegates to navigator.modelContextTesting.executeTool() with JSON string args.
+	* Note: skipValidation option is ignored - native API handles its own validation.
 	*
 	* @param {string} toolName - Name of the tool to execute
 	* @param {Record<string, unknown>} args - Arguments to pass to the tool
+	* @param {Object} [_options] - Execution options (ignored for native adapter)
 	* @returns {Promise<ToolResponse>} The tool's response in MCP format
 	* @internal
 	*/
-	async executeTool(toolName, args) {
+	async executeTool(toolName, args, _options) {
 		try {
 			const result = await this.nativeTesting.executeTool(toolName, JSON.stringify(args));
 			return this.convertToToolResponse(result);
@@ -898,11 +912,11 @@ var WebModelContext = class {
 	* @private
 	*/
 	validateResource(resource) {
-		const templateParamRegex = /\{([^}]+)\}/g;
+		const templateParamRegex = /\{([^}]{1,100})\}/g;
 		const templateParams = [];
 		for (const match of resource.uri.matchAll(templateParamRegex)) {
 			const paramName = match[1];
-			if (paramName) templateParams.push(paramName);
+			templateParams.push(paramName);
 		}
 		return {
 			uri: resource.uri,
@@ -1318,7 +1332,13 @@ var WebModelContext = class {
 	async readResource(uri) {
 		const staticResource = this.bridge.resources.get(uri);
 		if (staticResource && !staticResource.isTemplate) try {
-			const parsedUri = new URL(uri);
+			let parsedUri;
+			try {
+				parsedUri = new URL(uri);
+			} catch {
+				parsedUri = new URL(`custom-scheme:///${encodeURIComponent(uri)}`);
+				parsedUri.originalUri = uri;
+			}
 			return await staticResource.read(parsedUri);
 		} catch (error) {
 			logger$1.error(`Error reading resource ${uri}:`, error);
@@ -1328,7 +1348,13 @@ var WebModelContext = class {
 			if (!resource.isTemplate) continue;
 			const params = this.matchUriTemplate(resource.uri, uri);
 			if (params) try {
-				const parsedUri = new URL(uri);
+				let parsedUri;
+				try {
+					parsedUri = new URL(uri);
+				} catch {
+					parsedUri = new URL(`custom-scheme:///${encodeURIComponent(uri)}`);
+					parsedUri.originalUri = uri;
+				}
 				return await resource.read(parsedUri, params);
 			} catch (error) {
 				logger$1.error(`Error reading resource ${uri}:`, error);
@@ -1361,8 +1387,7 @@ var WebModelContext = class {
 		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;
+			params[paramName] = match[i + 1];
 		}
 		return params;
 	}
@@ -1395,7 +1420,7 @@ var WebModelContext = class {
 	/**
 	* Executes a tool with validation and event dispatch.
 	* Follows this sequence:
-	* 1. Validates input arguments against schema
+	* 1. Validates input arguments against schema (unless skipValidation is true)
 	* 2. Records tool call in testing API (if available)
 	* 3. Checks for mock response (if testing)
 	* 4. Dispatches 'toolcall' event to listeners
@@ -1404,25 +1429,31 @@ var WebModelContext = class {
 	*
 	* @param {string} toolName - Name of the tool to execute
 	* @param {Record<string, unknown>} args - Arguments to pass to the tool
+	* @param {Object} [options] - Execution options
+	* @param {boolean} [options.skipValidation] - Skip input validation (used when MCP SDK already validated)
 	* @returns {Promise<ToolResponse>} The tool's response
 	* @throws {Error} If tool is not found
 	* @internal
 	*/
-	async executeTool(toolName, args) {
+	async executeTool(toolName, args, options) {
 		const tool = this.bridge.tools.get(toolName);
 		if (!tool) throw new Error(`Tool not found: ${toolName}`);
-		const validation = validateWithZod(args, tool.inputValidator);
-		if (!validation.success) {
-			logger$1.error(`Input validation failed for ${toolName}:`, validation.error);
-			return {
-				content: [{
-					type: "text",
-					text: `Input validation error for tool "${toolName}":\n${validation.error}`
-				}],
-				isError: true
-			};
+		let validatedArgs;
+		if (options?.skipValidation) validatedArgs = args;
+		else {
+			const validation = validateWithZod(args, tool.inputValidator);
+			if (!validation.success) {
+				logger$1.error(`Input validation failed for ${toolName}:`, validation.error);
+				return {
+					content: [{
+						type: "text",
+						text: `Input validation error for tool "${toolName}":\n${validation.error}`
+					}],
+					isError: true
+				};
+			}
+			validatedArgs = validation.data;
 		}
-		const validatedArgs = validation.data;
 		if (this.testingAPI) this.testingAPI.recordToolCall(toolName, validatedArgs);
 		if (this.testingAPI?.hasMockResponse(toolName)) {
 			const mockResponse = this.testingAPI.getMockResponse(toolName);
@@ -1640,6 +1671,7 @@ function initializeMCPBridge(options) {
 * ```
 */
 function initializeWebModelContext(options) {
+	/* c8 ignore next 4 */
 	if (typeof window === "undefined") {
 		logger$1.warn("Not in browser environment, skipping initialization");
 		return;
@@ -1733,6 +1765,7 @@ function initializeWebModelContext(options) {
 * ```
 */
 function cleanupWebModelContext() {
+	/* c8 ignore next */
 	if (typeof window === "undefined") return;
 	if (window.__mcpBridge) try {
 		window.__mcpBridge.tabServer.close();