@mastra/schema-compat 1.2.4 → 1.2.5

package/dist/index.cjs

@@ -10,7 +10,7 @@ var zodFromJsonSchema = require('zod-from-json-schema');
 var zodFromJsonSchemaV3 = require('zod-from-json-schema-v3');
 var v4 = require('zod/v4');
 
-// ../_vendored/ai_v4/dist/chunk-GBOGIFXJ.js
+// ../_vendored/ai_v4/dist/chunk-OPIPXJLE.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3746,6 +3746,12 @@ var SchemaCompatLayer = class {
   isDefault(v) {
     return v instanceof v3.ZodDefault;
   }
+  /**
+   * Type guard for intersection Zod types
+   */
+  isIntersection(v) {
+    return v instanceof v3.ZodIntersection;
+  }
   /**
    * Determines whether this compatibility layer should be applied for the current model.
    *
@@ -4055,6 +4061,36 @@ var SchemaCompatLayer = class {
       return value;
     }
   }
+  /**
+   * Recursively collects leaf types from a ZodIntersection tree.
+   */
+  collectIntersectionLeaves(value) {
+    if (value instanceof v3.ZodIntersection) {
+      return [...this.collectIntersectionLeaves(value._def.left), ...this.collectIntersectionLeaves(value._def.right)];
+    }
+    return [value];
+  }
+  /**
+   * Default handler for Zod intersection types.
+   * Flattens the intersection tree and merges object shapes into a single z.object().
+   * Falls back to z.any() for non-object intersections.
+   */
+  defaultZodIntersectionHandler(value) {
+    const leaves = this.collectIntersectionLeaves(value);
+    const processed = leaves.map((leaf) => this.processZodType(leaf));
+    if (processed.every((p) => p instanceof v3.ZodObject)) {
+      const mergedShape = {};
+      for (const obj of processed) {
+        Object.assign(mergedShape, obj.shape);
+      }
+      let result = v3.z.object(mergedShape);
+      if (value.description) {
+        result = result.describe(value.description);
+      }
+      return result;
+    }
+    return v3.z.any().describe(value.description || "intersection type");
+  }
   /**
    * Processes a Zod object schema and converts it to an AI SDK Schema.
    *
@@ -4183,6 +4219,12 @@ var SchemaCompatLayer2 = class {
   isDefault(v) {
     return v instanceof v4.ZodDefault;
   }
+  /**
+   * Type guard for intersection Zod types
+   */
+  isIntersection(v) {
+    return v instanceof v4.ZodIntersection;
+  }
   /**
    * Determines whether this compatibility layer should be applied for the current model.
    *
@@ -4507,6 +4549,44 @@ var SchemaCompatLayer2 = class {
       return value;
     }
   }
+  /**
+   * Recursively collects leaf types from a ZodIntersection tree.
+   */
+  collectIntersectionLeaves(value) {
+    if (value instanceof v4.ZodIntersection) {
+      return [
+        ...this.collectIntersectionLeaves(value._zod.def.left),
+        ...this.collectIntersectionLeaves(value._zod.def.right)
+      ];
+    }
+    return [value];
+  }
+  /**
+   * Default handler for Zod intersection types.
+   * Flattens the intersection tree and merges object shapes into a single z.object().
+   * Falls back to z.any() for non-object intersections.
+   */
+  defaultZodIntersectionHandler(value) {
+    const leaves = this.collectIntersectionLeaves(value);
+    const processed = leaves.map((leaf) => this.processZodType(leaf));
+    if (processed.every((p) => p instanceof v4.ZodObject)) {
+      const mergedShape = {};
+      for (const obj of processed) {
+        for (const [key, field] of Object.entries(obj.shape)) {
+          if (key in mergedShape) {
+            throw new Error("Cannot flatten intersections with overlapping keys");
+          }
+          mergedShape[key] = field;
+        }
+      }
+      let result = v4.z.object(mergedShape);
+      if (value.description) {
+        result = result.describe(value.description);
+      }
+      return result;
+    }
+    return v4.z.any().describe(value.description || "intersection type");
+  }
   /**
    * Processes a Zod object schema and converts it to an AI SDK Schema.
    *
@@ -4561,6 +4641,9 @@ function isUnionSchema(schema) {
 function isEnumSchema(schema) {
   return Array.isArray(schema.enum) && schema.enum.length > 0;
 }
+function isAllOfSchema(schema) {
+  return Array.isArray(schema.allOf) && schema.allOf.length > 0;
+}
 function isOptionalSchema(propertyName, parentSchema) {
   if (!parentSchema.required || !Array.isArray(parentSchema.required)) {
     return true;
@@ -4668,6 +4751,13 @@ var SchemaCompatLayer3 = class {
       return this.v3Layer.isDefault(v);
     }
   }
+  isIntersection(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isIntersection(v);
+    } else {
+      return this.v3Layer.isIntersection(v);
+    }
+  }
   preProcessJSONNode(_schema, _parentSchema) {
   }
   postProcessJSONNode(_schema, _parentSchema) {
@@ -4772,6 +4862,13 @@ var SchemaCompatLayer3 = class {
       );
     }
   }
+  defaultZodIntersectionHandler(value) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodIntersectionHandler(value);
+    } else {
+      return this.v3Layer.defaultZodIntersectionHandler(value);
+    }
+  }
   processToAISDKSchema(zodSchema2) {
     const processedSchema = this.processZodType(zodSchema2);
     return convertZodSchemaToAISDKSchema(processedSchema, this.getSchemaTarget());
@@ -4927,6 +5024,31 @@ var SchemaCompatLayer3 = class {
     }
     return schema;
   }
+  /**
+   * Default handler for JSON Schema allOf (intersection) types.
+   * Flattens allOf sub-schemas by merging properties and required arrays into a single object schema.
+   */
+  defaultAllOfHandler(schema) {
+    if (!schema.allOf || !Array.isArray(schema.allOf)) return schema;
+    const mergedProperties = {};
+    const mergedRequired = [];
+    for (const subSchema of schema.allOf) {
+      if (subSchema.properties) {
+        Object.assign(mergedProperties, subSchema.properties);
+      }
+      if (Array.isArray(subSchema.required)) {
+        mergedRequired.push(...subSchema.required);
+      }
+    }
+    delete schema.allOf;
+    schema.type = "object";
+    schema.properties = mergedProperties;
+    if (mergedRequired.length > 0) {
+      schema.required = [...new Set(mergedRequired)];
+    }
+    schema.additionalProperties = false;
+    return schema;
+  }
   /**
    * Default handler for JSON Schema nullable types.
    * Ensures nullable types are represented correctly.
@@ -4986,6 +5108,9 @@ var SchemaCompatLayer3 = class {
   isUnionSchema(schema) {
     return isUnionSchema(schema);
   }
+  isAllOfSchema(schema) {
+    return isAllOfSchema(schema);
+  }
   /**
    * Checks if a property is optional within a parent object schema.
    * A property is optional if it's not in the parent's `required` array.
@@ -5107,6 +5232,9 @@ function isDefault(z11) {
 function isNullable(z11) {
   return (v) => v instanceof z11["ZodNullable"];
 }
+function isIntersection(z11) {
+  return (v) => v instanceof z11["ZodIntersection"];
+}
 
 // src/provider-compats/openai.ts
 var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
@@ -5181,6 +5309,9 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
       }
       return this.defaultZodStringHandler(value, checks);
     }
+    if (isIntersection(zod.z)(value)) {
+      return this.defaultZodIntersectionHandler(value);
+    }
     return this.defaultUnsupportedZodTypeHandler(value, [
       "ZodNever",
       "ZodUndefined",
@@ -5225,6 +5356,9 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
     });
   }
   preProcessJSONNode(schema, _parentSchema) {
+    if (isAllOfSchema(schema)) {
+      this.defaultAllOfHandler(schema);
+    }
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
@@ -5395,6 +5529,9 @@ var OpenAIReasoningSchemaCompatLayer = class extends OpenAISchemaCompatLayer {
 Argument was an "any" type, but you (the LLM) do not support "any", so it was cast to a "string" type`
       );
     }
+    if (isIntersection(zod.z)(value)) {
+      return this.defaultZodIntersectionHandler(value);
+    }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
   processToJSONSchema(zodSchema2) {
@@ -5402,6 +5539,9 @@ Argument was an "any" type, but you (the LLM) do not support "any", so it was ca
     return chunkUFJG5KPA_cjs.ensureAllPropertiesRequired(jsonSchema2);
   }
   preProcessJSONNode(schema, _parentSchema) {
+    if (isAllOfSchema(schema)) {
+      this.defaultAllOfHandler(schema);
+    }
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
@@ -5491,10 +5631,15 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
       }
     } else if (isNull(zod.z)(value)) {
       return zod.z.any().refine((v) => v === null, { message: "must be null" }).describe(value.description || "must be null");
+    } else if (isIntersection(zod.z)(value)) {
+      return this.defaultZodIntersectionHandler(value);
     }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
   preProcessJSONNode(schema, _parentSchema) {
+    if (isAllOfSchema(schema)) {
+      this.defaultAllOfHandler(schema);
+    }
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
@@ -5540,10 +5685,15 @@ var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
       return this.defaultZodUnionHandler(value);
     } else if (isString2(zod.z)(value)) {
       return this.defaultZodStringHandler(value);
+    } else if (isIntersection(zod.z)(value)) {
+      return this.defaultZodIntersectionHandler(value);
     }
     return value;
   }
   preProcessJSONNode(schema, _parentSchema) {
+    if (isAllOfSchema(schema)) {
+      this.defaultAllOfHandler(schema);
+    }
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
@@ -5653,6 +5803,8 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
       return this.defaultZodStringHandler(value);
     } else if (isNumber2(zod.z)(value)) {
       return this.defaultZodNumberHandler(value);
+    } else if (isIntersection(zod.z)(value)) {
+      return this.defaultZodIntersectionHandler(value);
     }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
@@ -5666,6 +5818,9 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
     return { ...result, jsonSchema: fixedJsonSchema };
   }
   preProcessJSONNode(schema, _parentSchema) {
+    if (isAllOfSchema(schema)) {
+      this.defaultAllOfHandler(schema);
+    }
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
@@ -5715,10 +5870,15 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
       return this.defaultZodNumberHandler(value);
     } else if (isString2(zod.z)(value)) {
       return this.defaultZodStringHandler(value);
+    } else if (isIntersection(zod.z)(value)) {
+      return this.defaultZodIntersectionHandler(value);
     }
     return value;
   }
   preProcessJSONNode(schema, _parentSchema) {
+    if (isAllOfSchema(schema)) {
+      this.defaultAllOfHandler(schema);
+    }
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {