@mastra/schema-compat 0.11.7 → 0.11.8-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @mastra/schema-compat
 
+## 0.11.8-alpha.0
+
+### Patch Changes
+
+- Fixed OpenAI schema compatibility when using `agent.generate()` or `agent.stream()` with `structuredOutput`. ([#10454](https://github.com/mastra-ai/mastra/pull/10454))
+
+  ## Changes
+  - **Automatic transformation**: Zod schemas are now automatically transformed for OpenAI strict mode compatibility when using OpenAI models (including reasoning models like o1, o3, o4)
+  - **Optional field handling**: `.optional()` fields are converted to `.nullable()` with a transform that converts `null` → `undefined`, preserving optional semantics while satisfying OpenAI's strict mode requirements
+  - **Preserves nullable fields**: Intentionally `.nullable()` fields remain unchanged
+  - **Deep transformation**: Handles `.optional()` fields at any nesting level (objects, arrays, unions, etc.)
+  - **JSON Schema objects**: Not transformed, only Zod schemas
+
+  ## Example
+
+  ```typescript
+  const agent = new Agent({
+    name: 'data-extractor',
+    model: { provider: 'openai', modelId: 'gpt-4o' },
+    instructions: 'Extract user information',
+  });
+
+  const schema = z.object({
+    name: z.string(),
+    age: z.number().optional(),
+    deletedAt: z.date().nullable(),
+  });
+
+  // Schema is automatically transformed for OpenAI compatibility
+  const result = await agent.generate('Extract: John, deleted yesterday', {
+    structuredOutput: { schema },
+  });
+
+  // Result: { name: 'John', age: undefined, deletedAt: null }
+  ```
+
 ## 0.11.7
 
 ### Patch Changes

package/dist/index.cjs

@@ -86,7 +86,8 @@ var SUPPORTED_ZOD_TYPES = [
   "ZodNumber",
   "ZodDate",
   "ZodAny",
-  "ZodDefault"
+  "ZodDefault",
+  "ZodNullable"
 ];
 var ALL_ZOD_TYPES = [...SUPPORTED_ZOD_TYPES, ...UNSUPPORTED_ZOD_TYPES];
 var SchemaCompatLayer = class {
@@ -503,7 +504,8 @@ var SUPPORTED_ZOD_TYPES2 = [
   "ZodNumber",
   "ZodDate",
   "ZodAny",
-  "ZodDefault"
+  "ZodDefault",
+  "ZodNullable"
 ];
 var SchemaCompatLayer2 = class {
   model;
@@ -546,6 +548,12 @@ var SchemaCompatLayer2 = class {
   isNull(v) {
     return v instanceof v4.ZodNull;
   }
+  /**
+   * Type guard for nullable Zod types
+   */
+  isNullable(v) {
+    return v instanceof v4.ZodNullable;
+  }
   /**
    * Type guard for array Zod types
    */
@@ -1139,6 +1147,9 @@ function isDate(z10) {
 function isDefault(z10) {
   return (v) => v instanceof z10["ZodDefault"];
 }
+function isNullable(z10) {
+  return (v) => v instanceof z10["ZodNullable"];
+}
 
 // src/provider-compats/anthropic.ts
 var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
@@ -1279,15 +1290,30 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
   }
   processZodType(value) {
     if (isOptional2(zod.z)(value)) {
-      return this.defaultZodOptionalHandler(value, [
-        "ZodObject",
-        "ZodArray",
-        "ZodUnion",
-        "ZodString",
-        "ZodNever",
-        "ZodUndefined",
-        "ZodTuple"
-      ]);
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      if (innerType) {
+        if (isNullable(zod.z)(innerType)) {
+          const processed = this.processZodType(innerType);
+          return processed.transform((val) => val === null ? void 0 : val);
+        }
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable().transform((val) => val === null ? void 0 : val);
+      }
+      return value;
+    } else if (isNullable(zod.z)(value)) {
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      if (innerType) {
+        if (isOptional2(zod.z)(innerType)) {
+          const innerInnerType = "_def" in innerType ? innerType._def.innerType : innerType._zod?.def?.innerType;
+          if (innerInnerType) {
+            const processedInnerInner = this.processZodType(innerInnerType);
+            return processedInnerInner.nullable().transform((val) => val === null ? void 0 : val);
+          }
+        }
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable();
+      }
+      return value;
     } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value);
     } else if (isUnion2(zod.z)(value)) {
@@ -1327,8 +1353,30 @@ var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer3 {
   }
   processZodType(value) {
     if (isOptional2(zod.z)(value)) {
-      const innerZodType = this.processZodType(value._def.innerType);
-      return innerZodType.nullable();
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      if (innerType) {
+        if (isNullable(zod.z)(innerType)) {
+          const processed = this.processZodType(innerType);
+          return processed.transform((val) => val === null ? void 0 : val);
+        }
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable().transform((val) => val === null ? void 0 : val);
+      }
+      return value;
+    } else if (isNullable(zod.z)(value)) {
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      if (innerType && isOptional2(zod.z)(innerType)) {
+        const innerInnerType = "_def" in innerType ? innerType._def.innerType : innerType._zod?.def?.innerType;
+        if (innerInnerType) {
+          const processedInnerInner = this.processZodType(innerInnerType);
+          return processedInnerInner.nullable().transform((val) => val === null ? void 0 : val);
+        }
+      }
+      if (innerType) {
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable();
+      }
+      return value;
     } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value, { passthrough: false });
     } else if (isArr2(zod.z)(value)) {