@mastra/schema-compat 1.2.7 → 1.2.8

package/dist/index.js

@@ -1,6 +1,6 @@
-import { toStandardSchema, standardSchemaToJSONSchema, isStandardSchemaWithJSON } from './chunk-MZRYAZ7Z.js';
-export { JSON_SCHEMA_LIBRARY_OPTIONS, isStandardJSONSchema, isStandardSchema, isStandardSchemaWithJSON, standardSchemaToJSONSchema, toStandardSchema } from './chunk-MZRYAZ7Z.js';
-import { zodToJsonSchema, ensureAllPropertiesRequired } from './chunk-7ZCSAPV3.js';
+import { toStandardSchema, standardSchemaToJSONSchema, isStandardSchemaWithJSON } from './chunk-MRY3A2NG.js';
+export { JSON_SCHEMA_LIBRARY_OPTIONS, isStandardJSONSchema, isStandardSchema, isStandardSchemaWithJSON, standardSchemaToJSONSchema, toStandardSchema } from './chunk-MRY3A2NG.js';
+import { zodToJsonSchema } from './chunk-7ZCSAPV3.js';
 export { ensureAllPropertiesRequired, prepareJsonSchemaForOpenAIStrictMode } from './chunk-7ZCSAPV3.js';
 import { require_json_schema_traverse } from './chunk-K7I3YXWP.js';
 import { __toESM } from './chunk-5WRI5ZAA.js';
@@ -3611,7 +3611,8 @@ function applyCompatLayer({
     const standardSchema = toStandardSchema(schema);
     for (const compat of compatLayers) {
       if (compat.shouldApply()) {
-        return compat.processToJSONSchema(standardSchema);
+        const compatSchema = compat.processToCompatSchema(standardSchema);
+        return standardSchemaToJSONSchema(compatSchema);
       }
     }
     return standardSchemaToJSONSchema(standardSchema);
@@ -4638,9 +4639,6 @@ function isOneOfSchema(schema) {
 function isUnionSchema(schema) {
   return isAnyOfSchema(schema) || isOneOfSchema(schema) || Array.isArray(schema.type);
 }
-function isEnumSchema(schema) {
-  return Array.isArray(schema.enum) && schema.enum.length > 0;
-}
 function isAllOfSchema(schema) {
   return Array.isArray(schema.allOf) && schema.allOf.length > 0;
 }
@@ -4666,6 +4664,10 @@ var SchemaCompatLayer3 = class {
     this.v3Layer = new SchemaCompatLayer(model, this);
     this.v4Layer = new SchemaCompatLayer2(model, this);
   }
+  preProcessJSONNode(_schema, _parentSchema) {
+  }
+  postProcessJSONNode(_schema, _parentSchema) {
+  }
   /**
    * Gets the language model associated with this compatibility layer.
    *
@@ -4758,10 +4760,6 @@ var SchemaCompatLayer3 = class {
       return this.v3Layer.isIntersection(v);
     }
   }
-  preProcessJSONNode(_schema, _parentSchema) {
-  }
-  postProcessJSONNode(_schema, _parentSchema) {
-  }
   defaultZodObjectHandler(value, options = { passthrough: true }) {
     if ("_zod" in value) {
       return this.v4Layer.defaultZodObjectHandler(value, options);
@@ -4869,12 +4867,21 @@ var SchemaCompatLayer3 = class {
       return this.v3Layer.defaultZodIntersectionHandler(value);
     }
   }
+  /**
+   * @deprecated please use processToCompatSchema to usse StandardSchemaWithJSON
+   * @param zodSchema
+   * @returns
+   */
   processToAISDKSchema(zodSchema2) {
     const processedSchema = this.processZodType(zodSchema2);
     return convertZodSchemaToAISDKSchema(processedSchema, this.getSchemaTarget());
   }
-  processToJSONSchema(zodSchema2, io = "input") {
-    const standardSchema = toStandardSchema(zodSchema2);
+  /**
+   * @param schema
+   * @returns
+   */
+  processToJSONSchema(schema, io = "input") {
+    const standardSchema = toStandardSchema(schema);
     const jsonSchema2 = standardSchemaToJSONSchema(standardSchema, {
       target: "draft-07",
       io
@@ -4882,16 +4889,33 @@ var SchemaCompatLayer3 = class {
     });
     (0, import_json_schema_traverse.default)(jsonSchema2, {
       cb: {
-        pre: (schema) => {
-          this.preProcessJSONNode(schema);
+        pre: (schema2) => {
+          this.preProcessJSONNode(schema2);
         },
-        post: (schema) => {
-          this.postProcessJSONNode(schema);
+        post: (schema2) => {
+          this.postProcessJSONNode(schema2);
         }
       }
     });
     return jsonSchema2;
   }
+  processToCompatSchema(schema) {
+    return {
+      "~standard": {
+        version: 1,
+        vendor: "mastra",
+        validate: (value) => toStandardSchema(schema)["~standard"].validate(value),
+        jsonSchema: {
+          input: () => {
+            return this.processToJSONSchema(schema, "input");
+          },
+          output: () => {
+            return this.processToJSONSchema(schema, "output");
+          }
+        }
+      }
+    };
+  }
   // ==========================================
   // JSON Schema Default Handlers
   // ==========================================
@@ -4903,6 +4927,9 @@ var SchemaCompatLayer3 = class {
     if (schema.properties && schema.additionalProperties === void 0) {
       schema.additionalProperties = false;
     }
+    if (!Object.keys(schema.properties ?? {}).length) {
+      schema.required = [];
+    }
     return schema;
   }
   /**
@@ -5125,6 +5152,7 @@ var SchemaCompatLayer3 = class {
    * and applies pre/post processing via traverse.
    *
    * Uses 'input' io mode so that fields with defaults are optional (appropriate for tool parameters).
+   * @deprecated please use processToCompatSchema
    */
   toJSONSchema(zodSchema2) {
     const SCHEMA_TARGET_TO_STANDARD = {
@@ -5205,9 +5233,6 @@ function wrapSchemaWithNullTransform(schema) {
     }
   };
 }
-
-// src/provider-compats/openai.ts
-var import_json_schema_traverse2 = __toESM(require_json_schema_traverse(), 1);
 function isOptional2(z11) {
   return (v) => v instanceof z11["ZodOptional"];
 }
@@ -5243,10 +5268,18 @@ function isIntersection(z11) {
 }
 
 // src/provider-compats/openai.ts
+var allowedStringFormats = [
+  "date-time",
+  "time",
+  "date",
+  "duration",
+  "email",
+  "hostname",
+  "ipv4",
+  "ipv6",
+  "uuid"
+];
 var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
-  constructor(model) {
-    super(model);
-  }
   getSchemaTarget() {
     return `jsonSchema7`;
   }
@@ -5324,43 +5357,44 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
       "ZodTuple"
     ]);
   }
-  /**
-   * Override to fix additionalProperties: {} which OpenAI doesn't support.
-   * Converts empty object {} to true to preserve passthrough intent.
-   */
-  processToJSONSchema(zodSchema2) {
-    const jsonSchema2 = super.processToJSONSchema(zodSchema2);
-    const fixedSchema = this.fixAdditionalProperties(jsonSchema2);
-    return ensureAllPropertiesRequired(fixedSchema);
-  }
   /**
    * Override to apply the same JSON Schema fixes (additionalProperties, required fields)
    * that processToJSONSchema applies. The base implementation skips JSON Schema traversal,
    * which causes OpenAI strict mode to reject tool schemas missing additionalProperties: false.
    */
   processToAISDKSchema(zodSchema2) {
-    const jsonSchemaResult = zodToJsonSchema(zodSchema2, this.getSchemaTarget());
-    const originalJsonSchema = JSON.parse(JSON.stringify(jsonSchemaResult));
-    (0, import_json_schema_traverse2.default)(jsonSchemaResult, {
-      cb: {
-        pre: (schema) => {
-          this.preProcessJSONNode(schema);
-        },
-        post: (schema) => {
-          this.postProcessJSONNode(schema);
-        }
-      }
-    });
-    const fixedSchema = this.fixAdditionalProperties(jsonSchemaResult);
-    const finalSchema = ensureAllPropertiesRequired(fixedSchema);
-    return jsonSchema(finalSchema, {
+    const compat = this.processToCompatSchema(zodSchema2);
+    const transformedJsonSchema = standardSchemaToJSONSchema(compat);
+    return jsonSchema(transformedJsonSchema, {
       validate: (value) => {
-        const transformed = transformNullToUndefined(value, originalJsonSchema);
+        const transformed = this.#traverse(value, transformedJsonSchema);
         const result = zodSchema2.safeParse(transformed);
         return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
       }
     });
   }
+  processToCompatSchema(schema) {
+    const originalStandardSchema = toStandardSchema(schema);
+    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);
+        },
+        jsonSchema: {
+          input: () => {
+            return this.processToJSONSchema(schema, "input");
+          },
+          output: () => {
+            return this.processToJSONSchema(schema, "output");
+          }
+        }
+      }
+    };
+  }
   preProcessJSONNode(schema, _parentSchema) {
     if (isAllOfSchema(schema)) {
       this.defaultAllOfHandler(schema);
@@ -5369,13 +5403,12 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
       this.defaultArrayHandler(schema);
+    } else if (isNumberSchema(schema)) {
+      this.defaultNumberHandler(schema);
     } else if (isStringSchema(schema)) {
-      const model = this.getModel();
-      if (model.modelId?.includes("gpt-4o-mini")) {
-        if (schema.format === "emoji") {
+      if (schema.format) {
+        if (!allowedStringFormats.includes(schema.format)) {
           delete schema.format;
-        }
-        if (schema.pattern) {
           delete schema.pattern;
         }
       }
@@ -5399,75 +5432,110 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
         }
       ];
     }
-    if (schema.type === "object" && schema.additionalProperties === void 0) {
-      schema.additionalProperties = false;
-    }
     if (isObjectSchema(schema)) {
-      const keys = Object.keys(schema.properties || {});
-      if (keys.length) {
-        for (const key of keys) {
-          if (!schema.required?.includes(key) && schema.properties?.[key]?.type) {
-            const prop = schema.properties[key];
-            const subSchema = {};
-            for (const propKey of Object.keys(prop)) {
-              if (propKey !== "anyOf") {
-                subSchema[propKey] = prop[propKey];
+      schema.additionalProperties = false;
+      if (schema.properties) {
+        for (const key of Object.keys(schema.properties)) {
+          const prop = schema.properties[key];
+          if (!schema.required) {
+            schema.required = [];
+          }
+          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" }
+                ];
               }
             }
-            prop.anyOf = [subSchema, { type: "null" }];
-            for (const propKey of Object.keys(subSchema)) {
-              delete prop[propKey];
-            }
           }
         }
-        schema.required = keys;
-      }
-      if ("propertyNames" in schema) {
-        delete schema.propertyNames;
       }
     }
   }
-  /**
-   * Recursively fixes additionalProperties: {} to additionalProperties: true.
-   * OpenAI requires additionalProperties to be either:
-   * - false (no additional properties allowed)
-   * - true (any additional properties allowed)
-   * - an object with a "type" key (typed additional properties)
-   * An empty object {} is NOT valid.
-   */
-  fixAdditionalProperties(schema) {
-    if (typeof schema !== "object" || schema === null) {
-      return schema;
+  #traverse(value, schema) {
+    const resolved = this.#resolveAnyOf(schema);
+    if ((isDateFormat(resolved) || resolved["x-date"] === true) && typeof value === "string") {
+      return new Date(value);
     }
-    const result = { ...schema };
-    if (result.additionalProperties !== void 0 && typeof result.additionalProperties === "object" && result.additionalProperties !== null && !Array.isArray(result.additionalProperties) && Object.keys(result.additionalProperties).length === 0) {
-      result.additionalProperties = true;
+    const isArrayType = resolved.type === "array" || Array.isArray(resolved.type) && resolved.type.includes("array");
+    if (isArrayType) {
+      if (!Array.isArray(value)) {
+        return value;
+      }
+      return value.map((item) => this.#traverse(item, resolved.items));
     }
-    if (result.properties) {
-      result.properties = Object.fromEntries(
-        Object.entries(result.properties).map(([key, value]) => [
-          key,
-          this.fixAdditionalProperties(value)
-        ])
-      );
+    const isObjectType = resolved.type === "object" || Array.isArray(resolved.type) && resolved.type.includes("object");
+    if (!isObjectType) {
+      return value;
     }
-    if (result.items) {
-      if (Array.isArray(result.items)) {
-        result.items = result.items.map((item) => this.fixAdditionalProperties(item));
-      } else {
-        result.items = this.fixAdditionalProperties(result.items);
+    const properties = resolved.properties;
+    if (!properties || !value) {
+      return value;
+    }
+    const obj = value;
+    const optionalProperties = resolved["x-optional"] ?? [];
+    for (const key in obj) {
+      if (optionalProperties.includes(key) && obj[key] === null) {
+        obj[key] = void 0;
+      } else if (properties[key]) {
+        obj[key] = this.#traverse(obj[key], properties[key]);
       }
     }
-    if (result.additionalProperties && typeof result.additionalProperties === "object" && !Array.isArray(result.additionalProperties) && Object.keys(result.additionalProperties).length > 0) {
-      result.additionalProperties = this.fixAdditionalProperties(result.additionalProperties);
+    return obj;
+  }
+  /**
+   * If schema has anyOf, return the first non-null variant for traversal.
+   * Otherwise return the schema itself.
+   */
+  #resolveAnyOf(schema) {
+    if (Array.isArray(schema.anyOf)) {
+      const nonNull = schema.anyOf.find((s) => s.type !== "null");
+      if (nonNull) {
+        return nonNull;
+      }
     }
-    return result;
+    return schema;
   }
 };
+function isDateFormat(schema) {
+  return schema.format === "date-time" || schema.format === "date";
+}
 var OpenAIReasoningSchemaCompatLayer = class extends OpenAISchemaCompatLayer {
   getSchemaTarget() {
     return `openApi3`;
   }
+  isReasoningModel() {
+    const modelId = this.getModel().modelId;
+    if (!modelId) return false;
+    return modelId.includes(`o3`) || modelId.includes(`o4`) || modelId.includes(`o1`);
+  }
   shouldApply() {
     const model = this.getModel();
     if (this.isReasoningModel() && (model.provider.includes(`openai`) || model.modelId?.includes(`openai`))) {
@@ -5540,30 +5608,6 @@ Argument was an "any" type, but you (the LLM) do not support "any", so it was ca
     }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
-  processToJSONSchema(zodSchema2) {
-    const jsonSchema2 = super.processToJSONSchema(zodSchema2);
-    return ensureAllPropertiesRequired(jsonSchema2);
-  }
-  preProcessJSONNode(schema, _parentSchema) {
-    if (isAllOfSchema(schema)) {
-      this.defaultAllOfHandler(schema);
-    }
-    if (isObjectSchema(schema)) {
-      this.defaultObjectHandler(schema);
-    } else if (isArraySchema(schema)) {
-      this.defaultArrayHandler(schema);
-    } else if (isNumberSchema(schema)) {
-      this.defaultNumberHandler(schema);
-    } else if (isStringSchema(schema)) {
-      this.defaultStringHandler(schema);
-    }
-  }
-  postProcessJSONNode(schema) {
-    super.postProcessJSONNode(schema);
-    if (schema.type === "object" && schema.properties !== void 0) {
-      schema.additionalProperties = false;
-    }
-  }
 };
 
 // src/standard-schema-compat.ts
@@ -5642,7 +5686,40 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
-  preProcessJSONNode(schema, _parentSchema) {
+  processToAISDKSchema(zodSchema2) {
+    const compat = this.processToCompatSchema(zodSchema2);
+    const transformedJsonSchema = standardSchemaToJSONSchema(compat);
+    return jsonSchema(transformedJsonSchema, {
+      validate: (value) => {
+        const transformed = this.#traverse(value, transformedJsonSchema);
+        const result = zodSchema2.safeParse(transformed);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    });
+  }
+  processToCompatSchema(schema) {
+    const originalStandardSchema = toStandardSchema(schema);
+    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);
+        },
+        jsonSchema: {
+          input: () => {
+            return this.processToJSONSchema(schema, "input");
+          },
+          output: () => {
+            return this.processToJSONSchema(schema, "output");
+          }
+        }
+      }
+    };
+  }
+  preProcessJSONNode(schema) {
     if (isAllOfSchema(schema)) {
       this.defaultAllOfHandler(schema);
     }
@@ -5650,24 +5727,68 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
       this.defaultArrayHandler(schema);
+    } else if (isNumberSchema(schema)) {
+      this.defaultNumberHandler(schema);
     } else if (isStringSchema(schema)) {
-      if (this.getModel().modelId.includes("claude-3.5-haiku")) {
-        this.defaultStringHandler(schema);
-      }
+      this.defaultStringHandler(schema);
     }
   }
   postProcessJSONNode(schema) {
     if (isUnionSchema(schema)) {
       this.defaultUnionHandler(schema);
     }
-    if (isObjectSchema(schema)) {
-      if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && Object.keys(schema.additionalProperties).length === 0) {
-        schema.additionalProperties = true;
-      }
-      if ("propertyNames" in schema) {
-        delete schema.propertyNames;
+  }
+  #traverse(value, schema) {
+    const resolved = this.#resolveSchemaForValue(schema, value);
+    if (resolved["x-date"] === true && typeof value === "string") {
+      return new Date(value);
+    }
+    const isArrayType = resolved.type === "array" || Array.isArray(resolved.type) && resolved.type.includes("array");
+    if (isArrayType) {
+      if (!Array.isArray(value)) {
+        return value;
       }
+      return value.map((item) => this.#traverse(item, resolved.items));
+    }
+    const isObjectType = resolved.type === "object" || Array.isArray(resolved.type) && resolved.type.includes("object");
+    if (!isObjectType) {
+      return value;
     }
+    const properties = resolved.properties;
+    if (!properties || !value) {
+      return value;
+    }
+    const obj = value;
+    for (const key in obj) {
+      if (properties[key]) {
+        obj[key] = this.#traverse(obj[key], properties[key]);
+      }
+    }
+    return obj;
+  }
+  // #resolveAnyOf(schema: Record<string, unknown>): Record<string, unknown> {
+  //   if (Array.isArray(schema.anyOf)) {
+  //     const nonNull = (schema.anyOf as Record<string, unknown>[]).find(s => s.type !== 'null');
+  //     if (nonNull) {
+  //       return nonNull;
+  //     }
+  //   }
+  //   return schema;
+  // }
+  #resolveSchemaForValue(schema, value) {
+    if (!Array.isArray(schema.anyOf)) {
+      return schema;
+    }
+    const variants = schema.anyOf;
+    const nonNullVariants = variants.filter((variant) => variant.type !== "null");
+    if (variants.length === 2 && nonNullVariants.length === 1) {
+      return nonNullVariants[0];
+    }
+    const keys = value && typeof value === "object" ? Object.keys(value) : [];
+    return nonNullVariants.find((variant) => {
+      const properties = variant.properties;
+      return !!properties && keys.some((key) => key in properties);
+    }) ?? schema;
   }
 };
 var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
@@ -5696,7 +5817,40 @@ var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
     return value;
   }
-  preProcessJSONNode(schema, _parentSchema) {
+  processToAISDKSchema(zodSchema2) {
+    const compat = this.processToCompatSchema(zodSchema2);
+    const transformedJsonSchema = standardSchemaToJSONSchema(compat);
+    return jsonSchema(transformedJsonSchema, {
+      validate: (value) => {
+        const transformed = this.#traverse(value, transformedJsonSchema);
+        const result = zodSchema2.safeParse(transformed);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    });
+  }
+  processToCompatSchema(schema) {
+    const originalStandardSchema = toStandardSchema(schema);
+    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);
+        },
+        jsonSchema: {
+          input: () => {
+            return this.processToJSONSchema(schema, "input");
+          },
+          output: () => {
+            return this.processToJSONSchema(schema, "output");
+          }
+        }
+      }
+    };
+  }
+  preProcessJSONNode(schema) {
     if (isAllOfSchema(schema)) {
       this.defaultAllOfHandler(schema);
     }
@@ -5708,18 +5862,47 @@ var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
       this.defaultStringHandler(schema);
     }
   }
-  postProcessJSONNode(schema, _parentSchema) {
+  postProcessJSONNode(schema) {
     if (isUnionSchema(schema)) {
       this.defaultUnionHandler(schema);
     }
-    if (isObjectSchema(schema)) {
-      if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && Object.keys(schema.additionalProperties).length === 0) {
-        schema.additionalProperties = true;
+  }
+  #traverse(value, schema) {
+    const resolved = this.#resolveAnyOf(schema);
+    if (resolved["x-date"] === true && typeof value === "string") {
+      return new Date(value);
+    }
+    const isArrayType = resolved.type === "array" || Array.isArray(resolved.type) && resolved.type.includes("array");
+    if (isArrayType) {
+      if (!Array.isArray(value)) {
+        return value;
+      }
+      return value.map((item) => this.#traverse(item, resolved.items));
+    }
+    const isObjectType = resolved.type === "object" || Array.isArray(resolved.type) && resolved.type.includes("object");
+    if (!isObjectType) {
+      return value;
+    }
+    const properties = resolved.properties;
+    if (!properties || !value) {
+      return value;
+    }
+    const obj = value;
+    for (const key in obj) {
+      if (properties[key]) {
+        obj[key] = this.#traverse(obj[key], properties[key]);
       }
-      if ("propertyNames" in schema) {
-        delete schema.propertyNames;
+    }
+    return obj;
+  }
+  #resolveAnyOf(schema) {
+    if (Array.isArray(schema.anyOf)) {
+      const nonNull = schema.anyOf.find((s) => s.type !== "null");
+      if (nonNull) {
+        return nonNull;
       }
     }
+    return schema;
   }
 };
 function fixNullableUnionTypes(schema) {
@@ -5773,6 +5956,16 @@ function fixNullableUnionTypes(schema) {
   if (result.allOf && Array.isArray(result.allOf)) {
     result.allOf = result.allOf.map((s) => fixNullableUnionTypes(s));
   }
+  if (result.anyOf && Array.isArray(result.anyOf)) {
+    if (result.description) {
+      for (const item of result.anyOf) {
+        if (typeof item === "object" && item !== null && !item.description) {
+          item.description = result.description;
+        }
+      }
+    }
+    return { anyOf: result.anyOf };
+  }
   return result;
 }
 var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
@@ -5783,7 +5976,7 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
     return "jsonSchema7";
   }
   shouldApply() {
-    return this.getModel().provider.includes("google") || this.getModel().modelId.includes("google");
+    return this.getModel().provider.includes("google") || this.getModel().modelId.includes("gemini-") || this.getModel().modelId.includes("google");
   }
   processZodType(value) {
     if (isOptional2(z)(value)) {
@@ -5814,43 +6007,100 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
-  processToJSONSchema(zodSchema2, io = "input") {
-    const result = super.processToJSONSchema(zodSchema2, io);
-    return fixNullableUnionTypes(result);
-  }
+  // public processToJSONSchema(zodSchema: PublicSchema<any>, io?: 'input' | 'output'): JSONSchema7 {
+  //   const result = super.processToJSONSchema(zodSchema, io);
+  //   // Fix union type arrays that Gemini doesn't support
+  //   return fixNullableUnionTypes(result as Record<string, any>) as JSONSchema7;
+  // }
   processToAISDKSchema(zodSchema2) {
-    const result = super.processToAISDKSchema(zodSchema2);
-    const fixedJsonSchema = fixNullableUnionTypes(result.jsonSchema);
-    return { ...result, jsonSchema: fixedJsonSchema };
+    const compat = this.processToCompatSchema(zodSchema2);
+    const transformedJsonSchema = standardSchemaToJSONSchema(compat);
+    const fixedJsonSchema = fixNullableUnionTypes(transformedJsonSchema);
+    return jsonSchema(fixedJsonSchema, {
+      validate: (value) => {
+        const transformed = this.#traverse(value, fixedJsonSchema);
+        const result = zodSchema2.safeParse(transformed);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    });
   }
-  preProcessJSONNode(schema, _parentSchema) {
+  processToCompatSchema(schema) {
+    const originalStandardSchema = toStandardSchema(schema);
+    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);
+        },
+        jsonSchema: {
+          input: () => {
+            return this.processToJSONSchema(schema, "input");
+          },
+          output: () => {
+            return this.processToJSONSchema(schema, "output");
+          }
+        }
+      }
+    };
+  }
+  preProcessJSONNode(schema) {
     if (isAllOfSchema(schema)) {
       this.defaultAllOfHandler(schema);
     }
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
+    } else if (isNumberSchema(schema)) {
+      this.defaultNumberHandler(schema);
     } else if (isArraySchema(schema)) {
       this.defaultArrayHandler(schema);
     } else if (isStringSchema(schema)) {
       this.defaultStringHandler(schema);
-    } else if (isNumberSchema(schema)) {
-      this.defaultNumberHandler(schema);
-    } else if (isEnumSchema(schema)) {
-      schema.type = "string";
     }
   }
-  postProcessJSONNode(schema, _parentSchema) {
+  postProcessJSONNode(schema) {
     if (isUnionSchema(schema)) {
       this.defaultUnionHandler(schema);
     }
-    if (isObjectSchema(schema)) {
-      if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && Object.keys(schema.additionalProperties).length === 0) {
-        schema.additionalProperties = true;
+  }
+  #traverse(value, schema) {
+    const resolved = this.#resolveAnyOf(schema);
+    if (resolved["x-date"] === true && typeof value === "string") {
+      return new Date(value);
+    }
+    const isArrayType = resolved.type === "array" || Array.isArray(resolved.type) && resolved.type.includes("array");
+    if (isArrayType) {
+      if (!Array.isArray(value)) {
+        return value;
       }
-      if ("propertyNames" in schema) {
-        delete schema.propertyNames;
+      return value.map((item) => this.#traverse(item, resolved.items));
+    }
+    const isObjectType = resolved.type === "object" || Array.isArray(resolved.type) && resolved.type.includes("object");
+    if (!isObjectType) {
+      return value;
+    }
+    const properties = resolved.properties;
+    if (!properties || !value) {
+      return value;
+    }
+    const obj = value;
+    for (const key in obj) {
+      if (properties[key]) {
+        obj[key] = this.#traverse(obj[key], properties[key]);
       }
     }
+    return obj;
+  }
+  #resolveAnyOf(schema) {
+    if (Array.isArray(schema.anyOf)) {
+      const nonNull = schema.anyOf.find((s) => s.type !== "null");
+      if (nonNull) {
+        return nonNull;
+      }
+    }
+    return schema;
   }
 };
 var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
@@ -5881,7 +6131,40 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
     return value;
   }
-  preProcessJSONNode(schema, _parentSchema) {
+  processToAISDKSchema(zodSchema2) {
+    const compat = this.processToCompatSchema(zodSchema2);
+    const transformedJsonSchema = standardSchemaToJSONSchema(compat);
+    return jsonSchema(transformedJsonSchema, {
+      validate: (value) => {
+        const transformed = this.#traverse(value, transformedJsonSchema);
+        const result = zodSchema2.safeParse(transformed);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    });
+  }
+  processToCompatSchema(schema) {
+    const originalStandardSchema = toStandardSchema(schema);
+    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);
+        },
+        jsonSchema: {
+          input: () => {
+            return this.processToJSONSchema(schema, "input");
+          },
+          output: () => {
+            return this.processToJSONSchema(schema, "output");
+          }
+        }
+      }
+    };
+  }
+  preProcessJSONNode(schema) {
     if (isAllOfSchema(schema)) {
       this.defaultAllOfHandler(schema);
     }
@@ -5891,22 +6174,49 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
       this.defaultArrayHandler(schema);
     } else if (isStringSchema(schema)) {
       this.defaultStringHandler(schema);
-    } else if (isNumberSchema(schema)) {
-      this.defaultNumberHandler(schema);
     }
   }
-  postProcessJSONNode(schema, _parentSchema) {
+  postProcessJSONNode(schema) {
     if (isUnionSchema(schema)) {
       this.defaultUnionHandler(schema);
     }
-    if (isObjectSchema(schema)) {
-      if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && Object.keys(schema.additionalProperties).length === 0) {
-        schema.additionalProperties = true;
+  }
+  #traverse(value, schema) {
+    const resolved = this.#resolveAnyOf(schema);
+    if (resolved["x-date"] === true && typeof value === "string") {
+      return new Date(value);
+    }
+    const isArrayType = resolved.type === "array" || Array.isArray(resolved.type) && resolved.type.includes("array");
+    if (isArrayType) {
+      if (!Array.isArray(value)) {
+        return value;
       }
-      if ("propertyNames" in schema) {
-        delete schema.propertyNames;
+      return value.map((item) => this.#traverse(item, resolved.items));
+    }
+    const isObjectType = resolved.type === "object" || Array.isArray(resolved.type) && resolved.type.includes("object");
+    if (!isObjectType) {
+      return value;
+    }
+    const properties = resolved.properties;
+    if (!properties || !value) {
+      return value;
+    }
+    const obj = value;
+    for (const key in obj) {
+      if (properties[key]) {
+        obj[key] = this.#traverse(obj[key], properties[key]);
       }
     }
+    return obj;
+  }
+  #resolveAnyOf(schema) {
+    if (Array.isArray(schema.anyOf)) {
+      const nonNull = schema.anyOf.find((s) => s.type !== "null");
+      if (nonNull) {
+        return nonNull;
+      }
+    }
+    return schema;
   }
 };