@mastra/schema-compat 1.3.6-alpha.0 → 1.3.6-alpha.3

package/dist/index.js

@@ -4,8 +4,138 @@ import { a as standardSchemaToJSONSchema, i as isStandardSchemaWithJSON, n as is
 import { ZodArray, ZodDate, ZodDefault, ZodFirstPartyTypeKind, ZodIntersection, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodString, ZodUnion, z } from "zod/v3";
 import { z as z$1 } from "zod";
 import { convertJsonSchemaToZod } from "zod-from-json-schema";
-import { convertJsonSchemaToZod as convertJsonSchemaToZod$1 } from "zod-from-json-schema-v3";
 import { ZodArray as ZodArray$1, ZodDate as ZodDate$1, ZodDefault as ZodDefault$1, ZodIntersection as ZodIntersection$1, ZodNull as ZodNull$1, ZodNullable as ZodNullable$1, ZodNumber as ZodNumber$1, ZodObject as ZodObject$1, ZodOptional as ZodOptional$1, ZodString as ZodString$1, ZodUnion as ZodUnion$1, z as z$2 } from "zod/v4";
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod-from-json-schema/0.0.5/8e273a13436172e49bb0898e3f9caf0fd3966851d12111764522ea958a085aeb/node_modules/zod-from-json-schema/dist/index.mjs
+function convertJsonSchemaToZod$1(schema) {
+	function addMetadata(zodSchema, jsonSchema) {
+		if (jsonSchema.description) zodSchema = zodSchema.describe(jsonSchema.description);
+		return zodSchema;
+	}
+	if (schema.const !== void 0) {
+		if (typeof schema.const === "string") return addMetadata(z$1.literal(schema.const), schema);
+		else if (typeof schema.const === "number") return addMetadata(z$1.literal(schema.const), schema);
+		else if (typeof schema.const === "boolean") return addMetadata(z$1.literal(schema.const), schema);
+		else if (schema.const === null) return addMetadata(z$1.null(), schema);
+		return addMetadata(z$1.literal(schema.const), schema);
+	}
+	if (schema.type) switch (schema.type) {
+		case "string": {
+			if (schema.enum) {
+				if (schema.enum.length === 0) return addMetadata(z$1.string(), schema);
+				return addMetadata(z$1.enum(schema.enum), schema);
+			}
+			let stringSchema = z$1.string();
+			if (schema.minLength !== void 0) stringSchema = stringSchema.min(schema.minLength);
+			if (schema.maxLength !== void 0) stringSchema = stringSchema.max(schema.maxLength);
+			if (schema.pattern !== void 0) {
+				const regex = new RegExp(schema.pattern);
+				stringSchema = stringSchema.regex(regex);
+			}
+			return addMetadata(stringSchema, schema);
+		}
+		case "number":
+		case "integer": {
+			if (schema.enum) {
+				if (schema.enum.length === 0) return addMetadata(z$1.number(), schema);
+				const options = schema.enum.map((val) => z$1.literal(val));
+				if (options.length === 1) return addMetadata(options[0], schema);
+				if (options.length >= 2) return addMetadata(z$1.union([
+					options[0],
+					options[1],
+					...options.slice(2)
+				]), schema);
+			}
+			let numberSchema = schema.type === "integer" ? z$1.number().int() : z$1.number();
+			if (schema.minimum !== void 0) numberSchema = numberSchema.min(schema.minimum);
+			if (schema.maximum !== void 0) numberSchema = numberSchema.max(schema.maximum);
+			if (schema.exclusiveMinimum !== void 0) numberSchema = numberSchema.gt(schema.exclusiveMinimum);
+			if (schema.exclusiveMaximum !== void 0) numberSchema = numberSchema.lt(schema.exclusiveMaximum);
+			if (schema.multipleOf !== void 0) numberSchema = numberSchema.multipleOf(schema.multipleOf);
+			return addMetadata(numberSchema, schema);
+		}
+		case "boolean":
+			if (schema.enum) {
+				if (schema.enum.length === 0) return addMetadata(z$1.boolean(), schema);
+				const options = schema.enum.map((val) => z$1.literal(val));
+				if (options.length === 1) return addMetadata(options[0], schema);
+				if (options.length >= 2) return addMetadata(z$1.union([
+					options[0],
+					options[1],
+					...options.slice(2)
+				]), schema);
+			}
+			return addMetadata(z$1.boolean(), schema);
+		case "null": return addMetadata(z$1.null(), schema);
+		case "object":
+			if (schema.properties) {
+				const shape = {};
+				for (const [key, propSchema] of Object.entries(schema.properties)) shape[key] = convertJsonSchemaToZod$1(propSchema);
+				if (schema.required && Array.isArray(schema.required)) {
+					const required = new Set(schema.required);
+					for (const key of Object.keys(shape)) if (!required.has(key)) shape[key] = shape[key].optional();
+				} else for (const key of Object.keys(shape)) shape[key] = shape[key].optional();
+				let zodSchema;
+				if (schema.additionalProperties !== false) zodSchema = z$1.object(shape).passthrough();
+				else zodSchema = z$1.object(shape);
+				return addMetadata(zodSchema, schema);
+			}
+			return addMetadata(z$1.object({}), schema);
+		case "array": {
+			let arraySchema;
+			if (schema.items) arraySchema = z$1.array(convertJsonSchemaToZod$1(schema.items));
+			else arraySchema = z$1.array(z$1.any());
+			if (schema.minItems !== void 0) arraySchema = arraySchema.min(schema.minItems);
+			if (schema.maxItems !== void 0) arraySchema = arraySchema.max(schema.maxItems);
+			if (schema.uniqueItems === true) arraySchema = arraySchema.refine((items) => {
+				const seen = /* @__PURE__ */ new Set();
+				return items.every((item) => {
+					if (typeof item === "string" || typeof item === "number" || typeof item === "boolean") {
+						if (seen.has(item)) return false;
+						seen.add(item);
+						return true;
+					}
+					const serialized = JSON.stringify(item);
+					if (seen.has(serialized)) return false;
+					seen.add(serialized);
+					return true;
+				});
+			}, { message: "Array items must be unique" });
+			return addMetadata(arraySchema, schema);
+		}
+	}
+	if (schema.enum) {
+		if (schema.enum.length === 0) return addMetadata(z$1.never(), schema);
+		if (schema.enum.every((val) => typeof val === "string")) return addMetadata(z$1.enum(schema.enum), schema);
+		else {
+			const options = schema.enum.map((val) => z$1.literal(val));
+			if (options.length === 1) return addMetadata(options[0], schema);
+			if (options.length >= 2) return addMetadata(z$1.union([
+				options[0],
+				options[1],
+				...options.slice(2)
+			]), schema);
+		}
+	}
+	if (schema.anyOf && schema.anyOf.length >= 2) {
+		const schemas = schema.anyOf.map(convertJsonSchemaToZod$1);
+		return addMetadata(z$1.union([
+			schemas[0],
+			schemas[1],
+			...schemas.slice(2)
+		]), schema);
+	}
+	if (schema.allOf) return addMetadata(schema.allOf.reduce((acc, s) => z$1.intersection(acc, convertJsonSchemaToZod$1(s)), z$1.object({})), schema);
+	if (schema.oneOf && schema.oneOf.length >= 2) {
+		const schemas = schema.oneOf.map(convertJsonSchemaToZod$1);
+		return addMetadata(z$1.union([
+			schemas[0],
+			schemas[1],
+			...schemas.slice(2)
+		]), schema);
+	}
+	return addMetadata(z$1.any(), schema);
+}
+//#endregion
 //#region ../_vendored/ai_v4/dist/dist-Cm5DZgxA.js
 var marker$1 = "vercel.ai.error";
 var symbol$1 = Symbol.for(marker$1);
@@ -5050,6 +5180,7 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
 		}
 		if (isObjectSchema(schema)) {
 			schema.additionalProperties = false;
+			delete schema.propertyNames;
 			if (schema.properties) for (const key of Object.keys(schema.properties)) {
 				const prop = schema.properties[key];
 				if (!schema.required) schema.required = [];
@@ -5316,28 +5447,29 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
 		return this.defaultUnsupportedZodTypeHandler(value);
 	}
 	processToAISDKSchema(zodSchema) {
-		const transformedJsonSchema = standardSchemaToJSONSchema(this.processToCompatSchema(zodSchema));
-		return jsonSchema(transformedJsonSchema, { validate: (value) => {
-			const transformed = this.#traverse(value, transformedJsonSchema);
-			const result = zodSchema.safeParse(transformed);
-			return result.success ? {
-				success: true,
-				value: result.data
-			} : {
+		const compat = this.processToCompatSchema(zodSchema);
+		return jsonSchema(standardSchemaToJSONSchema(compat), { validate: (value) => {
+			const result = compat["~standard"].validate(value);
+			if (result instanceof Promise) throw new Error("Async validation is not supported");
+			return "issues" in result && result.issues ? {
 				success: false,
-				error: result.error
+				error: new Error(result.issues.map((i) => i.message).join(", "))
+			} : {
+				success: true,
+				value: result.value
 			};
 		} });
 	}
 	processToCompatSchema(schema) {
 		const originalStandardSchema = toStandardSchema(schema);
+		const validationStandardSchema = this.#getCompatValidationStandardSchema(schema, originalStandardSchema);
 		return { "~standard": {
 			version: 1,
 			vendor: "mastra",
 			validate: (value) => {
 				const transformedJsonSchema = this.processToJSONSchema(schema, "input");
 				const transformed = this.#traverse(value, transformedJsonSchema);
-				return originalStandardSchema["~standard"].validate(transformed);
+				return validationStandardSchema["~standard"].validate(transformed);
 			},
 			jsonSchema: {
 				input: () => {
@@ -5373,6 +5505,242 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
 		for (const key in obj) if (properties[key]) obj[key] = this.#traverse(obj[key], properties[key]);
 		return obj;
 	}
+	#isHaikuModel() {
+		return this.getModel().modelId.includes("claude-3.5-haiku");
+	}
+	#getCompatValidationStandardSchema(schema, originalStandardSchema) {
+		if (!this.#isHaikuModel() || !isZodType(schema)) return originalStandardSchema;
+		return toStandardSchema(this.#stripHaikuStringLengthConstraints(schema));
+	}
+	/**
+	* Strip Haiku-ignored string min/max from a Zod schema for execute-time validation.
+	* Preserves object-level refinements and wrapper semantics unlike full-tree processZodType.
+	*/
+	#stripHaikuStringLengthConstraints(value) {
+		const schemas = /* @__PURE__ */ new WeakMap();
+		if ("_zod" in value) return this.#stripHaikuStringLengthConstraintsV4(value, schemas);
+		return this.#stripHaikuStringLengthConstraintsV3(value, schemas);
+	}
+	#stripHaikuStringLengthConstraintsV4(value, schemas) {
+		const cached = schemas.get(value);
+		if (cached) return cached;
+		const schema = value;
+		const def = schema._zod.def;
+		const strip = (child) => this.#stripHaikuStringLengthConstraintsV4(child, schemas);
+		let nextDef = def;
+		const replace = (key) => {
+			const current = def[key];
+			if (!current) return;
+			const stripped = strip(current);
+			if (stripped !== current) nextDef = {
+				...nextDef,
+				[key]: stripped
+			};
+		};
+		switch (def.type) {
+			case "string": {
+				const checks = (def.checks ?? []).filter((check) => check._zod.def.check !== "min_length" && check._zod.def.check !== "max_length");
+				if (checks.length !== (def.checks?.length ?? 0)) nextDef = {
+					...def,
+					checks
+				};
+				break;
+			}
+			case "object": {
+				const shape = def.shape;
+				const nextShape = Object.fromEntries(Object.entries(shape).map(([key, child]) => [key, strip(child)]));
+				if (Object.keys(shape).some((key) => nextShape[key] !== shape[key])) nextDef = {
+					...nextDef,
+					shape: nextShape
+				};
+				replace("catchall");
+				break;
+			}
+			case "array":
+				replace("element");
+				break;
+			case "union": {
+				const options = def.options;
+				const nextOptions = options.map(strip);
+				if (nextOptions.some((option, index) => option !== options[index])) nextDef = {
+					...nextDef,
+					options: nextOptions
+				};
+				break;
+			}
+			case "intersection":
+				replace("left");
+				replace("right");
+				break;
+			case "tuple": {
+				const items = def.items;
+				const nextItems = items.map(strip);
+				if (nextItems.some((item, index) => item !== items[index])) nextDef = {
+					...nextDef,
+					items: nextItems
+				};
+				replace("rest");
+				break;
+			}
+			case "record":
+			case "map":
+				replace("keyType");
+				replace("valueType");
+				break;
+			case "set":
+				replace("valueType");
+				break;
+			case "optional":
+			case "nullable":
+			case "default":
+			case "prefault":
+			case "nonoptional":
+			case "success":
+			case "catch":
+			case "readonly":
+				replace("innerType");
+				break;
+			case "pipe":
+				replace("in");
+				replace("out");
+				break;
+			case "promise":
+				replace("innerType");
+				break;
+			case "lazy":
+				nextDef = {
+					...def,
+					getter: () => strip(def.getter())
+				};
+				break;
+		}
+		if (nextDef === def) {
+			schemas.set(value, value);
+			return value;
+		}
+		let stripped = schema.clone(nextDef);
+		const metadata = schema.meta();
+		if (metadata) stripped = stripped.meta(metadata);
+		schemas.set(value, stripped);
+		return stripped;
+	}
+	#stripHaikuStringLengthConstraintsV3(value, schemas) {
+		const cached = schemas.get(value);
+		if (cached) return cached;
+		const schema = value;
+		const def = schema._def;
+		const strip = (child) => this.#stripHaikuStringLengthConstraintsV3(child, schemas);
+		let nextDef = def;
+		const replace = (key) => {
+			const current = def[key];
+			if (!current) return;
+			const stripped = strip(current);
+			if (stripped !== current) nextDef = {
+				...nextDef,
+				[key]: stripped
+			};
+		};
+		switch (def.typeName) {
+			case "ZodString": {
+				const checks = (def.checks ?? []).filter((check) => check.kind !== "min" && check.kind !== "max");
+				if (checks.length !== (def.checks?.length ?? 0)) nextDef = {
+					...def,
+					checks
+				};
+				break;
+			}
+			case "ZodObject": {
+				const shape = def.shape();
+				const nextShape = Object.fromEntries(Object.entries(shape).map(([key, child]) => [key, strip(child)]));
+				if (Object.keys(shape).some((key) => nextShape[key] !== shape[key])) nextDef = {
+					...nextDef,
+					shape: () => nextShape
+				};
+				replace("catchall");
+				break;
+			}
+			case "ZodArray":
+			case "ZodPromise":
+			case "ZodBranded":
+				replace("type");
+				break;
+			case "ZodUnion": {
+				const options = def.options;
+				const nextOptions = options.map(strip);
+				if (nextOptions.some((option, index) => option !== options[index])) nextDef = {
+					...nextDef,
+					options: nextOptions
+				};
+				break;
+			}
+			case "ZodDiscriminatedUnion": {
+				const options = def.options;
+				const nextOptions = options.map(strip);
+				if (nextOptions.some((option, index) => option !== options[index])) {
+					const optionsMap = new Map(def.optionsMap);
+					for (const [key, option] of optionsMap) {
+						const index = options.indexOf(option);
+						if (index !== -1) optionsMap.set(key, nextOptions[index]);
+					}
+					nextDef = {
+						...nextDef,
+						options: nextOptions,
+						optionsMap
+					};
+				}
+				break;
+			}
+			case "ZodIntersection":
+				replace("left");
+				replace("right");
+				break;
+			case "ZodTuple": {
+				const items = def.items;
+				const nextItems = items.map(strip);
+				if (nextItems.some((item, index) => item !== items[index])) nextDef = {
+					...nextDef,
+					items: nextItems
+				};
+				replace("rest");
+				break;
+			}
+			case "ZodRecord":
+			case "ZodMap":
+				replace("keyType");
+				replace("valueType");
+				break;
+			case "ZodSet":
+				replace("valueType");
+				break;
+			case "ZodOptional":
+			case "ZodNullable":
+			case "ZodDefault":
+			case "ZodCatch":
+			case "ZodReadonly":
+				replace("innerType");
+				break;
+			case "ZodEffects":
+				replace("schema");
+				break;
+			case "ZodPipeline":
+				replace("in");
+				replace("out");
+				break;
+			case "ZodLazy":
+				nextDef = {
+					...def,
+					getter: () => strip(def.getter())
+				};
+				break;
+		}
+		if (nextDef === def) {
+			schemas.set(value, value);
+			return value;
+		}
+		const stripped = new schema.constructor(nextDef);
+		schemas.set(value, stripped);
+		return stripped;
+	}
 	#resolveSchemaForValue(schema, value) {
 		if (!Array.isArray(schema.anyOf)) return schema;
 		const variants = schema.anyOf;