@mcp-b/global 2.0.3-canary.2 → 2.0.3-canary.3

package/dist/index.js

@@ -1,5 +1,6 @@
 import { IframeChildTransport, TabServerTransport } from "@mcp-b/transports";
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, Server } from "@mcp-b/webmcp-ts-sdk";
+import { jsonSchemaToZod } from "@n8n/json-schema-to-zod";
 import { z } from "zod";
 import { zodToJsonSchema as zodToJsonSchema$1 } from "zod-to-json-schema";
 
@@ -91,145 +92,101 @@ function createLogger(namespace) {
 //#endregion
 //#region src/validation.ts
 const logger$2 = createLogger("WebModelContext");
-/**
-* Check if a schema is a Zod 4 schema.
-* Zod 4 schemas have a `_zod` property, Zod 3 schemas have `_def`.
-*/
-function isZod4Schema(schema) {
-	if (typeof schema !== "object" || schema === null) return false;
-	return "_zod" in schema;
-}
-/**
-* Check if a schema is a Zod 3 schema.
-*/
-function isZod3Schema(schema) {
-	if (typeof schema !== "object" || schema === null) return false;
-	return "_def" in schema && !("_zod" in schema);
-}
-let zodV4Module = null;
-let zodV4LoadAttempted = false;
-/**
-* Attempt to load zod/v4 module. Returns null if not available (Zod 3.x).
-*/
-async function getZodV4Module() {
-	if (zodV4LoadAttempted) return zodV4Module;
-	zodV4LoadAttempted = true;
-	try {
-		const mod = await import("zod/v4");
-		zodV4Module = {
-			toJSONSchema: mod.toJSONSchema,
-			fromJSONSchema: "fromJSONSchema" in mod ? mod.fromJSONSchema : void 0
-		};
-	} catch {
-		zodV4Module = null;
-	}
-	return zodV4Module;
-}
-function getZodV4ModuleSync() {
-	return zodV4Module;
-}
-getZodV4Module().catch(() => {});
-/**
-* Detect if a schema is a Zod schema object (Record<string, ZodType>)
-* or a JSON Schema object.
-*
-* Uses duck-typing to detect Zod schemas:
-* - Zod 4 schemas have `_zod` property
-* - Zod 3 schemas have `_def` 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;
-	for (const val of values) {
-		if (val == null || typeof val !== "object") continue;
-		if (isZod4Schema(val) || isZod3Schema(val)) return true;
-	}
-	return false;
+	return values.some((value) => isZod4Schema(value) || isZod3Schema(value));
 }
-/**
-* Convert Zod schema object to JSON Schema.
-* Uses the appropriate method based on detected Zod version:
-* - Zod 4: Built-in toJSONSchema from zod/v4
-* - Zod 3: zod-to-json-schema external library
-*
-* @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 zodV4 = getZodV4ModuleSync();
-	if (isZod4Schema(zodObject) && zodV4?.toJSONSchema) try {
-		const { $schema: _,...rest } = zodV4.toJSONSchema(zodObject, { target: "draft-7" });
-		return rest;
+const hasZod4Schemas = (schema) => Object.values(schema).some((value) => isZod4Schema(value));
+const tryNativeZodToJsonSchema = (schema) => {
+	if (!hasZod4Schemas(schema) || !hasNativeToJSONSchema) return null;
+	try {
+		return stripSchemaMeta(nativeToJsonSchema(z.object(schema), { target: "draft-7" }));
 	} catch (error) {
-		logger$2.warn("Zod 4 toJSONSchema failed, falling back to zod-to-json-schema:", error);
+		logger$2.warn("z.toJSONSchema failed, falling back to zod-to-json-schema:", error);
+		return null;
 	}
-	try {
-		const { $schema: _,...rest } = zodToJsonSchema$1(zodObject, {
+};
+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"
-		});
-		return rest;
+		}));
+		if (!isOptionalSchema(zodSchema)) required.push(key);
+	}
+	const result = {
+		type: "object",
+		properties
+	};
+	if (required.length > 0) result.required = required;
+	return result;
+};
+function zodToJsonSchema(schema) {
+	const nativeSchema = tryNativeZodToJsonSchema(schema);
+	if (nativeSchema) return nativeSchema;
+	try {
+		return fallbackZodToJsonSchema(schema);
 	} catch (error) {
-		logger$2.warn("zod-to-json-schema failed:", error);
+		logger$2.warn("zodToJsonSchema failed:", error);
 		return {
 			type: "object",
 			properties: {}
 		};
 	}
 }
-/**
-* Convert JSON Schema to Zod validator.
-* Only available in Zod 4.x via fromJSONSchema.
-* Falls back to a passthrough validator in Zod 3.x.
-*
-* Note: When using Zod 3.x with JSON Schema input, server-side validation
-* is skipped. The MCP client still validates against the JSON Schema.
-*/
-function jsonSchemaToZod(jsonSchema) {
-	const zodV4 = getZodV4ModuleSync();
-	if (zodV4?.fromJSONSchema) try {
-		return zodV4.fromJSONSchema(jsonSchema);
+function jsonSchemaToZod$1(jsonSchema) {
+	try {
+		return jsonSchemaToZod(jsonSchema);
 	} catch (error) {
-		logger$2.warn("fromJSONSchema failed:", error);
+		logger$2.warn("jsonSchemaToZod failed:", error);
+		return z.object({}).passthrough();
 	}
-	else logger$2.debug("fromJSONSchema not available (Zod 3.x). Server-side validation will be skipped for JSON Schema input. Upgrade to Zod 4.x for full JSON Schema validation support.");
-	return z.object({}).passthrough();
 }
-/**
-* Normalize a schema to both JSON Schema and Zod formats.
-* Detects which format is provided and converts to the other.
-*
-* Supports:
-* - Zod schemas from Zod 3.x or Zod 4.x
-* - Plain JSON Schema objects
-*/
+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
@@ -334,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) {