@mastra/schema-compat 0.11.2-alpha.1 → 0.11.2-alpha.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @mastra/schema-compat
 
+## 0.11.2-alpha.2
+
+### Patch Changes
+
+- [#7343](https://github.com/mastra-ai/mastra/pull/7343) [`de3cbc6`](https://github.com/mastra-ai/mastra/commit/de3cbc61079211431bd30487982ea3653517278e) Thanks [@LekoArts](https://github.com/LekoArts)! - Update the `package.json` file to include additional fields like `repository`, `homepage` or `files`.
+
 ## 0.11.2-alpha.1
 
 ### Patch Changes

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@mastra/schema-compat",
-  "version": "0.11.2-alpha.1",
+  "version": "0.11.2-alpha.2",
   "description": "Tool schema compatibility layer for Mastra.ai",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
   "exports": {
     ".": {
       "import": {
@@ -58,6 +62,15 @@
     "zod": "^3.25.76",
     "@internal/lint": "0.0.34"
   },
+  "homepage": "https://mastra.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mastra-ai/mastra.git",
+    "directory": "packages/schema-compat"
+  },
+  "bugs": {
+    "url": "https://github.com/mastra-ai/mastra/issues"
+  },
   "scripts": {
     "build": "tsup --silent --config tsup.config.ts",
     "build:watch": "tsup --watch --silent --config tsup.config.ts",

package/.turbo/turbo-build.log

@@ -1,4 +0,0 @@
-
-> @mastra/schema-compat@0.11.2-alpha.1 build /home/runner/work/mastra/mastra/packages/schema-compat
-> tsup --silent --config tsup.config.ts
-

package/eslint.config.js

@@ -1,6 +0,0 @@
-import { createConfig } from '@internal/lint/eslint';
-
-const config = await createConfig();
-
-/** @type {import("eslint").Linter.Config[]} */
-export default [...config];

package/src/index.ts

@@ -1,40 +0,0 @@
-// Schema compatibility base class and related types
-export {
-  SchemaCompatLayer as SchemaCompatLayerV3,
-  ALL_STRING_CHECKS,
-  ALL_NUMBER_CHECKS,
-  ALL_ARRAY_CHECKS,
-  UNSUPPORTED_ZOD_TYPES,
-  SUPPORTED_ZOD_TYPES,
-  ALL_ZOD_TYPES,
-  // Types
-  type StringCheckType,
-  type NumberCheckType,
-  type ArrayCheckType,
-  type UnsupportedZodType,
-  type SupportedZodType,
-  type AllZodType,
-  type ZodShape,
-  type ShapeKey,
-  type ShapeValue,
-  // Re-usable type predicates
-  isOptional,
-  isObj,
-  isArr,
-  isUnion,
-  isString,
-  isNumber,
-} from './schema-compatibility-v3';
-export { SchemaCompatLayer as SchemaCompatLayerV4 } from './schema-compatibility-v4';
-export { SchemaCompatLayer } from './schema-compatibility';
-
-// Utility functions
-export { convertZodSchemaToAISDKSchema, applyCompatLayer, convertSchemaToZod } from './utils';
-
-// Provider compatibility implementations
-export { AnthropicSchemaCompatLayer } from './provider-compats/anthropic';
-export { DeepSeekSchemaCompatLayer } from './provider-compats/deepseek';
-export { GoogleSchemaCompatLayer } from './provider-compats/google';
-export { MetaSchemaCompatLayer } from './provider-compats/meta';
-export { OpenAISchemaCompatLayer } from './provider-compats/openai';
-export { OpenAIReasoningSchemaCompatLayer } from './provider-compats/openai-reasoning';

package/src/provider-compats/anthropic.ts

@@ -1,61 +0,0 @@
-import { z } from 'zod';
-import type { ZodType as ZodTypeV3, ZodObject as ZodObjectV3 } from 'zod/v3';
-import type { ZodType as ZodTypeV4, ZodObject as ZodObjectV4 } from 'zod/v4';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { AllZodType as AllZodTypeV3 } from '../schema-compatibility-v3';
-import type { AllZodType as AllZodTypeV4 } from '../schema-compatibility-v4';
-import type { ModelInformation } from '../types';
-import { isOptional, isObj, isArr, isUnion, isString } from '../zodTypes';
-
-export class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: ModelInformation) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return 'jsonSchema7';
-  }
-
-  shouldApply(): boolean {
-    return this.getModel().modelId.includes('claude');
-  }
-
-  processZodType(value: ZodTypeV3): ZodTypeV3;
-  processZodType(value: ZodTypeV4): ZodTypeV4;
-  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
-    if (isOptional(z)(value)) {
-      const handleTypes: AllZodTypeV3[] | AllZodTypeV4 = [
-        'ZodObject',
-        'ZodArray',
-        'ZodUnion',
-        'ZodNever',
-        'ZodUndefined',
-        'ZodTuple',
-      ];
-      if (this.getModel().modelId.includes('claude-3.5-haiku')) handleTypes.push('ZodString');
-      return this.defaultZodOptionalHandler(value, handleTypes);
-    } else if (isObj(z)(value)) {
-      return this.defaultZodObjectHandler(value);
-    } else if (isArr(z)(value)) {
-      return this.defaultZodArrayHandler(value, []);
-    } else if (isUnion(z)(value)) {
-      return this.defaultZodUnionHandler(value);
-    } else if (isString(z)(value)) {
-      // the claude-3.5-haiku model support these properties but the model doesn't respect them, but it respects them when they're
-      // added to the tool description
-
-      if (this.getModel().modelId.includes('claude-3.5-haiku')) {
-        return this.defaultZodStringHandler(value, ['max', 'min']);
-      } else {
-        return value;
-      }
-    }
-
-    return this.defaultUnsupportedZodTypeHandler(value as ZodObjectV4<any> | ZodObjectV3<any>, [
-      'ZodNever',
-      'ZodTuple',
-      'ZodUndefined',
-    ]);
-  }
-}

package/src/provider-compats/deepseek.ts

@@ -1,40 +0,0 @@
-import { z } from 'zod';
-import type { ZodType as ZodTypeV3 } from 'zod/v3';
-import type { ZodType as ZodTypeV4 } from 'zod/v4';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ModelInformation } from '../types';
-import { isOptional, isObj, isArr, isUnion, isString } from '../zodTypes';
-
-export class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: ModelInformation) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return 'jsonSchema7';
-  }
-
-  shouldApply(): boolean {
-    // Deepseek R1 performs perfectly without this compat layer
-    return this.getModel().modelId.includes('deepseek') && !this.getModel().modelId.includes('r1');
-  }
-
-  processZodType(value: ZodTypeV3): ZodTypeV3;
-  processZodType(value: ZodTypeV4): ZodTypeV4;
-  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
-    if (isOptional(z)(value)) {
-      return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
-    } else if (isObj(z)(value)) {
-      return this.defaultZodObjectHandler(value);
-    } else if (isArr(z)(value)) {
-      return this.defaultZodArrayHandler(value, ['min', 'max']);
-    } else if (isUnion(z)(value)) {
-      return this.defaultZodUnionHandler(value);
-    } else if (isString(z)(value)) {
-      return this.defaultZodStringHandler(value);
-    }
-
-    return value;
-  }
-}

package/src/provider-compats/google.ts

@@ -1,49 +0,0 @@
-import { z } from 'zod';
-import type { ZodType as ZodTypeV3, ZodObject as ZodObjectV3 } from 'zod/v3';
-import type { ZodType as ZodTypeV4, ZodObject as ZodObjectV4 } from 'zod/v4';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ModelInformation } from '../types';
-import { isOptional, isNull, isObj, isArr, isUnion, isString, isNumber } from '../zodTypes';
-
-export class GoogleSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: ModelInformation) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return 'jsonSchema7';
-  }
-
-  shouldApply(): boolean {
-    return this.getModel().provider.includes('google') || this.getModel().modelId.includes('google');
-  }
-  processZodType(value: ZodTypeV3): ZodTypeV3;
-  processZodType(value: ZodTypeV4): ZodTypeV4;
-  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
-    if (isOptional(z)(value)) {
-      return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
-    } else if (isNull(z)(value)) {
-      // Google models don't support null, so we need to convert it to any and then refine it to null
-      return z
-        .any()
-        .refine(v => v === null, { message: 'must be null' })
-        .describe(value.description || 'must be null');
-    } else if (isObj(z)(value)) {
-      return this.defaultZodObjectHandler(value);
-    } else if (isArr(z)(value)) {
-      return this.defaultZodArrayHandler(value, []);
-    } else if (isUnion(z)(value)) {
-      return this.defaultZodUnionHandler(value);
-    } else if (isString(z)(value)) {
-      // Google models support these properties but the model doesn't respect them, but it respects them when they're
-      // added to the tool description
-      return this.defaultZodStringHandler(value);
-    } else if (isNumber(z)(value)) {
-      // Google models support these properties but the model doesn't respect them, but it respects them when they're
-      // added to the tool description
-      return this.defaultZodNumberHandler(value);
-    }
-    return this.defaultUnsupportedZodTypeHandler(value as ZodObjectV4<any> | ZodObjectV3<any>);
-  }
-}

package/src/provider-compats/meta.ts

@@ -1,41 +0,0 @@
-import { z } from 'zod';
-import type { ZodType as ZodTypeV3 } from 'zod/v3';
-import type { ZodType as ZodTypeV4 } from 'zod/v4';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ModelInformation } from '../types';
-import { isOptional, isObj, isArr, isUnion, isNumber, isString } from '../zodTypes';
-
-export class MetaSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: ModelInformation) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return 'jsonSchema7';
-  }
-
-  shouldApply(): boolean {
-    return this.getModel().modelId.includes('meta');
-  }
-
-  processZodType(value: ZodTypeV3): ZodTypeV3;
-  processZodType(value: ZodTypeV4): ZodTypeV4;
-  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
-    if (isOptional(z)(value)) {
-      return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
-    } else if (isObj(z)(value)) {
-      return this.defaultZodObjectHandler(value);
-    } else if (isArr(z)(value)) {
-      return this.defaultZodArrayHandler(value, ['min', 'max']);
-    } else if (isUnion(z)(value)) {
-      return this.defaultZodUnionHandler(value);
-    } else if (isNumber(z)(value)) {
-      return this.defaultZodNumberHandler(value);
-    } else if (isString(z)(value)) {
-      return this.defaultZodStringHandler(value);
-    }
-
-    return value;
-  }
-}

package/src/provider-compats/openai-reasoning.ts

@@ -1,85 +0,0 @@
-import { z } from 'zod';
-import type { ZodType as ZodTypeV3, ZodObject as ZodObjectV3 } from 'zod/v3';
-import type { ZodType as ZodTypeV4, ZodObject as ZodObjectV4 } from 'zod/v4';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ModelInformation } from '../types';
-import { isOptional, isObj, isArr, isUnion, isDefault, isNumber, isString, isDate } from '../zodTypes';
-
-export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: ModelInformation) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return `openApi3`;
-  }
-
-  isReasoningModel(): boolean {
-    // there isn't a good way to automatically detect reasoning models besides doing this.
-    // in the future when o5 is released this compat wont apply and we'll want to come back and update this class + our tests
-    return (
-      this.getModel().modelId.includes(`o3`) ||
-      this.getModel().modelId.includes(`o4`) ||
-      this.getModel().modelId.includes(`o1`)
-    );
-  }
-
-  shouldApply(): boolean {
-    if (
-      (this.getModel().supportsStructuredOutputs || this.isReasoningModel()) &&
-      (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
-  processZodType(value: ZodTypeV3): ZodTypeV3;
-  processZodType(value: ZodTypeV4): ZodTypeV4;
-  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
-    if (isOptional(z)(value)) {
-      const innerZodType = this.processZodType(value._def.innerType);
-      return innerZodType.nullable();
-    } else if (isObj(z)(value)) {
-      return this.defaultZodObjectHandler(value, { passthrough: false });
-    } else if (isArr(z)(value)) {
-      return this.defaultZodArrayHandler(value);
-    } else if (isUnion(z)(value)) {
-      return this.defaultZodUnionHandler(value);
-    } else if (isDefault(z)(value)) {
-      const defaultDef = value._def;
-      const innerType = defaultDef.innerType;
-      const defaultValue = defaultDef.defaultValue();
-      const constraints: { defaultValue?: unknown } = {};
-      if (defaultValue !== undefined) {
-        constraints.defaultValue = defaultValue;
-      }
-
-      const description = this.mergeParameterDescription(value.description, constraints);
-      let result = this.processZodType(innerType);
-      if (description) {
-        result = result.describe(description);
-      }
-      return result;
-    } else if (isNumber(z)(value)) {
-      return this.defaultZodNumberHandler(value);
-    } else if (isString(z)(value)) {
-      return this.defaultZodStringHandler(value);
-    } else if (isDate(z)(value)) {
-      return this.defaultZodDateHandler(value);
-    } else if (value.constructor.name === 'ZodAny') {
-      // It's bad practice in the tool to use any, it's not reasonable for models that don't support that OOTB, to cast every single possible type
-      // in the schema. Usually when it's "any" it could be a json object or a union of specific types.
-      return z
-        .string()
-        .describe(
-          (value.description ?? '') +
-            `\nArgument was an "any" type, but you (the LLM) do not support "any", so it was cast to a "string" type`,
-        );
-    }
-
-    return this.defaultUnsupportedZodTypeHandler(value as ZodObjectV4<any> | ZodObjectV3<any>);
-  }
-}

package/src/provider-compats/openai.ts

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-import type { ZodType as ZodTypeV3, ZodObject as ZodObjectV3 } from 'zod/v3';
-import type { ZodType as ZodTypeV4, ZodObject as ZodObjectV4 } from 'zod/v4';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ModelInformation } from '../types';
-import { isOptional, isObj, isUnion, isArr, isString } from '../zodTypes';
-
-export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: ModelInformation) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return `jsonSchema7`;
-  }
-
-  shouldApply(): boolean {
-    if (
-      !this.getModel().supportsStructuredOutputs &&
-      (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
-  processZodType(value: ZodTypeV3): ZodTypeV3;
-  processZodType(value: ZodTypeV4): ZodTypeV4;
-  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
-    if (isOptional(z)(value)) {
-      return this.defaultZodOptionalHandler(value, [
-        'ZodObject',
-        'ZodArray',
-        'ZodUnion',
-        'ZodString',
-        'ZodNever',
-        'ZodUndefined',
-        'ZodTuple',
-      ]);
-    } else if (isObj(z)(value)) {
-      return this.defaultZodObjectHandler(value);
-    } else if (isUnion(z)(value)) {
-      return this.defaultZodUnionHandler(value);
-    } else if (isArr(z)(value)) {
-      return this.defaultZodArrayHandler(value);
-    } else if (isString(z)(value)) {
-      const model = this.getModel();
-      const checks = ['emoji'] as const;
-
-      if (model.modelId.includes('gpt-4o-mini')) {
-        return this.defaultZodStringHandler(value, ['emoji', 'regex']);
-      }
-
-      return this.defaultZodStringHandler(value, checks);
-    }
-
-    return this.defaultUnsupportedZodTypeHandler(value as ZodObjectV4<any> | ZodObjectV3<any>, [
-      'ZodNever',
-      'ZodUndefined',
-      'ZodTuple',
-    ]);
-  }
-}