@mcp-b/global 0.0.0-beta-20260116035619 → 0.0.0-canary-20260126004552

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
 /**
@@ -43,7 +45,11 @@ function isDebugEnabled(namespace) {
 		if (!debugConfig) return false;
 		if (debugConfig === "*") return true;
 		return debugConfig.split(",").map((p) => p.trim()).some((pattern) => namespace === pattern || namespace.startsWith(`${pattern}:`));
-	} catch {
+	} catch (err) {
+		if (typeof console !== "undefined" && console.warn) {
+			const message = err instanceof Error ? err.message : String(err);
+			console.warn(`[WebMCP] localStorage access failed, debug logging disabled: ${message}`);
+		}
 		return false;
 	}
 }
@@ -86,71 +92,101 @@ 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 nativeToJsonSchema = z.toJSONSchema;
+const hasNativeToJSONSchema = typeof nativeToJsonSchema === "function";
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isZod4Schema = (schema) => isRecord(schema) && "_zod" in schema;
+const isZod3Schema = (schema) => isRecord(schema) && "_def" in schema && !("_zod" in schema);
+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((value) => isZod4Schema(value) || isZod3Schema(value));
 }
-/**
-* Convert JSON Schema to Zod validator
-* Uses Zod 4's native z.fromJSONSchema() for conversion
-*/
-function jsonSchemaToZod(jsonSchema) {
+const hasZod4Schemas = (schema) => Object.values(schema).some((value) => isZod4Schema(value));
+const tryNativeZodToJsonSchema = (schema) => {
+	if (!hasZod4Schemas(schema) || !hasNativeToJSONSchema) return null;
 	try {
-		return z.fromJSONSchema(jsonSchema);
+		return stripSchemaMeta(nativeToJsonSchema(z.object(schema), { target: "draft-7" }));
 	} catch (error) {
-		logger$2.warn("Failed to convert JSON Schema to Zod:", error);
-		return z.object({}).passthrough();
+		logger$2.warn("z.toJSONSchema failed, falling back to zod-to-json-schema:", error);
+		return null;
 	}
-}
-/**
-* 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
-*/
+};
+const fallbackZodToJsonSchema = (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 zodToJsonSchema(schema) {
-	const zodObject = z.object(schema);
-	const { $schema: _,...rest } = z.toJSONSchema(zodObject);
-	return rest;
+	const nativeSchema = tryNativeZodToJsonSchema(schema);
+	if (nativeSchema) return nativeSchema;
+	try {
+		return fallbackZodToJsonSchema(schema);
+	} catch (error) {
+		logger$2.warn("zodToJsonSchema failed:", error);
+		return {
+			type: "object",
+			properties: {}
+		};
+	}
 }
-/**
-* Normalize a schema to both JSON Schema and Zod formats
-* Detects which format is provided and converts to the other
-*/
+function jsonSchemaToZod$1(jsonSchema) {
+	try {
+		return jsonSchemaToZod(jsonSchema);
+	} catch (error) {
+		logger$2.warn("jsonSchemaToZod failed:", error);
+		return z.object({}).passthrough();
+	}
+}
+const buildZodValidator = (schema, jsonSchema) => {
+	if (hasZod4Schemas(schema) && hasNativeToJSONSchema) return z.object(schema);
+	return jsonSchemaToZod$1(jsonSchema);
+};
 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: buildZodValidator(schema, 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
@@ -177,6 +213,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
@@ -184,8 +221,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,
@@ -254,7 +291,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) {
@@ -894,11 +931,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,
@@ -1314,7 +1351,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);
@@ -1324,7 +1367,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);
@@ -1357,8 +1406,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;
 	}
@@ -1636,6 +1684,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;
@@ -1729,6 +1778,7 @@ function initializeWebModelContext(options) {
 * ```
 */
 function cleanupWebModelContext() {
+	/* c8 ignore next */
 	if (typeof window === "undefined") return;
 	if (window.__mcpBridge) try {
 		window.__mcpBridge.tabServer.close();