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

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @mastra/schema-compat
 
+## 1.3.7-alpha.0
+
+### Patch Changes
+
+- Optional nested JSON Schema properties with multiple types no longer produce exponentially large OpenAI tool payloads. Payload growth now remains linear as these schemas become more deeply nested. ([#21190](https://github.com/mastra-ai/mastra/pull/21190))
+
+## 1.3.6
+
+### Patch Changes
+
+- Fixed OpenAI structured output requests failing when a schema uses `z.record()`. The OpenAI compatibility layer now removes the `propertyNames` keyword, which OpenAI strict mode does not permit. Requests that used to fail with "Invalid schema ... 'propertyNames' is not permitted" are now accepted. ([#20977](https://github.com/mastra-ai/mastra/pull/20977))
+
+  **Known limitation.** OpenAI strict mode cannot express an open-ended map. A `z.record()` field is still sent as a plain object with no value schema, so the model is not told what keys or values to produce. Use an explicit `z.object({ ... })` shape when you need the model to fill a map. See [#19273](https://github.com/mastra-ai/mastra/issues/19273).
+
+- Fix supervisor agent tool schemas for Gemini via OpenRouter. Properties with no Gemini-compatible type — most commonly `z.any()`, which serializes to an empty schema — are now rewritten into a permissive `anyOf` instead of being dropped. This resolves the misleading `required[N]: property is not defined` error when using Gemini models through OpenRouter as a supervisor agent (fixes #17325), while keeping fields the model is expected to fill (such as `resumeData` for tool suspend/resume) present in the tool contract. ([#17386](https://github.com/mastra-ai/mastra/pull/17386))
+
+- Fixed Zod v3 schema conversion for CommonJS consumers. ([#21147](https://github.com/mastra-ai/mastra/pull/21147))
+
+- Fixed tool execute-time input validation for Zod tools on Anthropic Claude 3.5 Haiku. The compat layer now skips string min/max checks that were removed from the model-facing JSON Schema, while preserving refinements, defaults, and other validation semantics. ([#19701](https://github.com/mastra-ai/mastra/pull/19701))
+
 ## 1.3.6-alpha.3
 
 ### Patch Changes

package/dist/index.cjs

@@ -5189,36 +5189,48 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
 				if (!schema.required?.includes(key)) {
 					schema["x-optional"] = [...schema["x-optional"] || [], key];
 					schema.required?.push(key);
-					if (prop.type) {
-						if (Array.isArray(prop.type)) {
-							const types = [...prop.type];
-							if (!types.includes("null")) types.push("null");
-							const propSchema = { ...prop };
-							delete propSchema.anyOf;
-							delete propSchema.type;
-							delete prop.type;
-							prop.anyOf = types.map((type) => type === "null" ? { type: "null" } : {
-								...propSchema,
-								type
-							});
-						} else if (prop.type !== "null") {
-							const originalType = prop.type;
-							const propSchema = { ...prop };
-							delete propSchema.anyOf;
-							delete propSchema.type;
-							delete prop.type;
-							prop.anyOf = [{
-								...propSchema,
-								type: originalType
-							}, { type: "null" }];
-						}
+					if (Array.isArray(prop.type)) {
+						const types = [...prop.type];
+						if (!types.includes("null")) types.push("null");
+						delete prop.anyOf;
+						delete prop.type;
+						if ("const" in prop) {
+							const constValue = prop.const;
+							prop.enum = !prop.enum || prop.enum.some((value) => JSON.stringify(value) === JSON.stringify(constValue)) ? [constValue, null] : [null];
+							delete prop.const;
+						} else if (prop.enum && !prop.enum.includes(null)) prop.enum = [...prop.enum, null];
+						const objectKeywords = [
+							"properties",
+							"required",
+							"additionalProperties",
+							"x-optional"
+						];
+						const arrayKeywords = ["items"];
+						prop.anyOf = types.map((type) => {
+							if (type === "null") return { type: "null" };
+							const branch = { type };
+							const keywords = type === "object" ? objectKeywords : type === "array" ? arrayKeywords : [];
+							for (const keyword of keywords) if (keyword in prop) branch[keyword] = prop[keyword];
+							return branch;
+						});
+						for (const keyword of [...objectKeywords, ...arrayKeywords]) delete prop[keyword];
+					} else if (prop.type && prop.type !== "null") {
+						const originalType = prop.type;
+						const propSchema = { ...prop };
+						delete propSchema.anyOf;
+						delete propSchema.type;
+						delete prop.type;
+						prop.anyOf = [{
+							...propSchema,
+							type: originalType
+						}, { type: "null" }];
 					}
 				}
 			}
 		}
 	}
 	#traverse(value, schema) {
-		const resolved = this.#resolveAnyOf(schema);
+		const resolved = this.#resolveAnyOf(schema, value);
 		if ((isDateFormat(resolved) || resolved["x-date"] === true) && typeof value === "string") return new Date(value);
 		if (resolved.type === "array" || Array.isArray(resolved.type) && resolved.type.includes("array")) {
 			if (!Array.isArray(value)) return value;
@@ -5234,13 +5246,33 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
 		return obj;
 	}
 	/**
-	* If schema has anyOf, return the first non-null variant for traversal.
+	* If schema has anyOf, return the variant whose type matches the value's shape
+	* (branches are type-specific), falling back to the first non-null variant.
 	* Otherwise return the schema itself.
 	*/
-	#resolveAnyOf(schema) {
+	#resolveAnyOf(schema, value) {
 		if (Array.isArray(schema.anyOf)) {
-			const nonNull = schema.anyOf.find((s) => s.type !== "null");
-			if (nonNull) return nonNull;
+			const nonNullVariants = schema.anyOf.filter((s) => s && s.type !== "null");
+			const valueType = Array.isArray(value) ? "array" : value !== null && typeof value === "object" ? "object" : typeof value === "number" ? Number.isInteger(value) ? "integer" : "number" : typeof value === "string" || typeof value === "boolean" ? typeof value : void 0;
+			if (valueType) {
+				const hasType = (variant, type) => (Array.isArray(variant.type) ? variant.type : [variant.type]).includes(type);
+				const exactMatch = nonNullVariants.find((variant) => hasType(variant, valueType));
+				if (exactMatch) return {
+					...schema,
+					...exactMatch
+				};
+				if (valueType === "integer") {
+					const numberMatch = nonNullVariants.find((variant) => hasType(variant, "number"));
+					if (numberMatch) return {
+						...schema,
+						...numberMatch
+					};
+				}
+			}
+			if (nonNullVariants[0]) return {
+				...schema,
+				...nonNullVariants[0]
+			};
 		}
 		return schema;
 	}