@mastra/schema-compat 1.3.11 → 1.3.12-alpha.1

package/dist/index.js

@@ -1,6 +1,6 @@
 import { r as __toESM$1, t as require_json_schema_traverse } from "./json-schema-traverse-B35mHRM8.js";
 import { ensureAllPropertiesRequired, prepareJsonSchemaForOpenAIStrictMode, zodToJsonSchema as zodToJsonSchema$1 } from "./zod-to-json.js";
-import { a as standardSchemaToJSONSchema, i as isStandardSchemaWithJSON, n as isStandardJSONSchema, o as toStandardSchema, r as isStandardSchema, t as JSON_SCHEMA_LIBRARY_OPTIONS } from "./schema-BwlBcZRB.js";
+import { a as standardSchemaToJSONSchema, i as isStandardSchemaWithJSON, n as isStandardJSONSchema, o as toStandardSchema, r as isStandardSchema, t as JSON_SCHEMA_LIBRARY_OPTIONS } from "./schema-e0VHpMt0.js";
 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";
@@ -4970,6 +4970,13 @@ var SchemaCompatLayer = class {
 */
 function transformNullToUndefined(value, jsonSchema) {
 	if (value === null || value === void 0) return value;
+	const branches = jsonSchema.anyOf ?? jsonSchema.oneOf;
+	if (Array.isArray(branches)) {
+		const { anyOf: _anyOf, oneOf: _oneOf, ...parent } = jsonSchema;
+		const branch = findMatchingBranch(value, branches);
+		if (!branch) return "properties" in parent || "items" in parent ? transformNullToUndefined(value, parent) : value;
+		return transformNullToUndefined(value, mergeSchemas(parent, branch));
+	}
 	if (typeof value !== "object" || Array.isArray(value)) {
 		if (Array.isArray(value) && jsonSchema.items && typeof jsonSchema.items === "object") return value.map((item) => transformNullToUndefined(item, jsonSchema.items));
 		return value;
@@ -4984,6 +4991,58 @@ function transformNullToUndefined(value, jsonSchema) {
 	return result;
 }
 /**
+* Picks the non-null union branch (from `anyOf`/`oneOf`) whose shape matches the value,
+* e.g. the object branch of a `.nullable()` object. For objects, branches whose required
+* keys are missing or whose `const`/`enum` properties (discriminators) disagree are skipped.
+*/
+function findMatchingBranch(value, branches) {
+	const isArray = Array.isArray(value);
+	if (typeof value !== "object" && !isArray) return;
+	return branches.find((branch) => {
+		if (!branch || typeof branch !== "object") return false;
+		const types = Array.isArray(branch.type) ? branch.type : [branch.type];
+		if (isArray) {
+			if (!("items" in branch || types.includes("array"))) return false;
+			const items = branch.items;
+			return !items || typeof items !== "object" || value.every((item) => itemMatches(item, items));
+		}
+		if (!("properties" in branch || "anyOf" in branch || "oneOf" in branch || types.includes("object"))) return false;
+		return objectMatchesBranch(value, branch);
+	});
+}
+function itemMatches(item, schema) {
+	if (item === null || typeof item !== "object" || Array.isArray(item)) return true;
+	const branches = schema.anyOf ?? schema.oneOf;
+	if (Array.isArray(branches)) return findMatchingBranch(item, branches) !== void 0;
+	return objectMatchesBranch(item, schema);
+}
+function objectMatchesBranch(value, branch) {
+	if ((branch.required ?? []).some((key) => !(key in value))) return false;
+	const properties = branch.properties ?? {};
+	return Object.entries(properties).every(([key, prop]) => {
+		if (!prop || typeof prop !== "object" || !(key in value)) return true;
+		if ("const" in prop) return prop.const === value[key];
+		if (Array.isArray(prop.enum)) return prop.enum.includes(value[key]);
+		return true;
+	});
+}
+function mergeSchemas(parent, branch) {
+	const merged = {
+		...parent,
+		...branch
+	};
+	if (parent.items && !branch.items) merged.items = parent.items;
+	if (!parent.properties) return merged;
+	return {
+		...merged,
+		properties: {
+			...parent.properties,
+			...branch.properties
+		},
+		required: [.../* @__PURE__ */ new Set([...parent.required ?? [], ...branch.required ?? []])]
+	};
+}
+/**
 * Wraps a StandardSchemaWithJSON to transform null values to undefined for
 * optional fields before validation. This is a schema-agnostic solution for
 * OpenAI strict mode, which sends null for optional fields.
@@ -5227,6 +5286,15 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
 						"x-optional"
 					];
 					const arrayKeywords = ["items"];
+					const numericKeywords = [
+						"format",
+						"minimum",
+						"maximum",
+						"exclusiveMinimum",
+						"exclusiveMaximum",
+						"multipleOf"
+					];
+					const isNumericType = (type) => type === "integer" || type === "number";
 					const genericConstraintKeywords = [
 						"const",
 						"enum",
@@ -5276,10 +5344,26 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
 						prop.anyOf = types.map((type) => {
 							if (type === "null") return { type: "null" };
 							const branch = { type };
-							for (const keyword of typeSpecificKeywords(type)) if (keyword in prop) branch[keyword] = prop[keyword];
+							const numericFormat = typeof prop.format === "string" && [
+								"int32",
+								"int64",
+								"float",
+								"double"
+							].includes(prop.format);
+							const formatOwner = types.includes("string") && !numericFormat ? type === "string" : isNumericType(type);
+							for (const keyword of [
+								...typeSpecificKeywords(type),
+								...isNumericType(type) ? numericKeywords.filter((k) => k !== "format") : [],
+								...formatOwner ? ["format"] : []
+							]) if (keyword in prop) branch[keyword] = prop[keyword];
 							return Object.assign(branch, branchConstraints);
 						});
-						for (const keyword of [...objectKeywords, ...arrayKeywords]) delete prop[keyword];
+						const numericBranchExists = types.some(isNumericType);
+						for (const keyword of [
+							...objectKeywords,
+							...arrayKeywords,
+							...numericBranchExists ? numericKeywords : []
+						]) delete prop[keyword];
 					} else if (prop.type && prop.type !== "null") {
 						const originalType = prop.type;
 						const keywords = typeSpecificKeywords(originalType);
@@ -5300,6 +5384,7 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
 							};
 							if (isRedundantNullableUnion(originalType)) delete propSchema.anyOf;
 							for (const keyword of [...genericConstraintKeywords, "anyOf"]) delete prop[keyword];
+							if (isNumericType(originalType)) for (const keyword of numericKeywords) delete prop[keyword];
 							delete prop.type;
 							prop.anyOf = [propSchema, { type: "null" }];
 						}