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

package/dist/index.js

@@ -1,7 +1,8 @@
 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 { fromJSONSchema, toJSONSchema } from "zod/v4";
+import { zodToJsonSchema as zodToJsonSchema$1 } from "zod-to-json-schema";
 
 //#region src/logger.ts
 /**
@@ -91,87 +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 schemas:
-* - Zod 4 schemas have `_zod` property
-* - Zod 3 schemas have `_def` property
-*
-* Both are supported as of Zod 3.25+ (which includes Zod 4 under the hood).
-*/
+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;
-		const obj = val;
-		if ("_zod" in obj || "_def" in obj) return true;
+	return values.some((value) => isZod4Schema(value) || isZod3Schema(value));
+}
+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("z.toJSONSchema failed, falling back to zod-to-json-schema:", error);
+		return null;
+	}
+};
+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 nativeSchema = tryNativeZodToJsonSchema(schema);
+	if (nativeSchema) return nativeSchema;
+	try {
+		return fallbackZodToJsonSchema(schema);
+	} catch (error) {
+		logger$2.warn("zodToJsonSchema failed:", error);
+		return {
+			type: "object",
+			properties: {}
+		};
 	}
-	return false;
 }
-/**
-* Convert JSON Schema to Zod validator.
-* Uses fromJSONSchema from 'zod/v4' which is available in Zod 3.25+ and Zod 4.
-*/
-function jsonSchemaToZod(jsonSchema) {
+function jsonSchemaToZod$1(jsonSchema) {
 	try {
-		return 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 toJSONSchema from 'zod/v4' which is available in Zod 3.25+ and Zod 4.
-*
-* Works with schemas created from both `import { z } from 'zod'` (Zod 3.25+ compat)
-* and `import { z } from 'zod/v4'` (native Zod 4).
-*
-* @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 { $schema: _,...rest } = toJSONSchema(z.object(schema));
-	return rest;
-}
-/**
-* Normalize a schema to both JSON Schema and Zod formats.
-* Detects which format is provided and converts to the other.
-*
-* Supports:
-* - Zod schemas from `import { z } from 'zod'` (Zod 3.25+ compat layer)
-* - Zod schemas from `import { z } from 'zod/v4'` (native Zod 4)
-* - 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
@@ -276,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) {