@mastra/schema-compat 0.0.0-ai-v5-20250626003446 → 0.0.0-fix-fetch-workflow-runs-20250624231457

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/schema-compat@0.10.2 build /home/runner/work/mastra/mastra/packages/schema-compat
+> @mastra/schema-compat@0.10.3-alpha.1 build /home/runner/work/mastra/mastra/packages/schema-compat
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 2200ms
+TSC ⚡️ Build success in 1480ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/schema-compat/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/schema-compat/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 1893ms
+DTS ⚡️ Build success in 1431ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 21.19 KB
-ESM ⚡️ Build success in 149ms
-CJS dist/index.cjs 21.82 KB
-CJS ⚡️ Build success in 149ms
+CJS dist/index.cjs 21.59 KB
+CJS ⚡️ Build success in 138ms
+ESM dist/index.js 20.96 KB
+ESM ⚡️ Build success in 138ms

package/CHANGELOG.md

@@ -1,10 +1,23 @@
 # @mastra/schema-compat
 
-## 0.0.0-ai-v5-20250626003446
+## 0.0.0-fix-fetch-workflow-runs-20250624231457
 
-### Minor Changes
+### Patch Changes
+
+- 98bbe5a: Claude cannot handle tuple schemas now.
+- a853c43: Allow for object.passthrough in schema compat (aka MCP tool support).
+
+## 0.10.3-alpha.1
+
+### Patch Changes
+
+- a853c43: Allow for object.passthrough in schema compat (aka MCP tool support).
+
+## 0.10.3-alpha.0
+
+### Patch Changes
 
-- 66858d4: AI SDK v5 beta
+- 98bbe5a: Claude cannot handle tuple schemas now.
 
 ## 0.10.2
 

package/dist/_tsup-dts-rollup.d.cts

@@ -1,5 +1,5 @@
 import type { JSONSchema7 } from 'json-schema';
-import type { LanguageModel } from 'ai';
+import type { LanguageModelV1 } from 'ai';
 import type { Schema } from 'ai';
 import type { Targets } from 'zod-to-json-schema';
 import { z } from 'zod';
@@ -54,7 +54,7 @@ export { AllZodType }
 export { AllZodType as AllZodType_alias_1 }
 
 declare class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -170,7 +170,7 @@ declare type DateConstraints = {
 };
 
 declare class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -179,7 +179,7 @@ export { DeepSeekSchemaCompatLayer }
 export { DeepSeekSchemaCompatLayer as DeepSeekSchemaCompatLayer_alias_1 }
 
 declare class GoogleSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -216,7 +216,7 @@ export { isUnion }
 export { isUnion as isUnion_alias_1 }
 
 declare class MetaSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -240,7 +240,7 @@ declare type NumberConstraints = {
 };
 
 declare class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     isReasoningModel(): boolean;
     shouldApply(): boolean;
@@ -250,7 +250,7 @@ export { OpenAIReasoningSchemaCompatLayer }
 export { OpenAIReasoningSchemaCompatLayer as OpenAIReasoningSchemaCompatLayer_alias_1 }
 
 declare class OpenAISchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -304,13 +304,13 @@ declare abstract class SchemaCompatLayer {
      *
      * @param model - The language model this compatibility layer applies to
      */
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     /**
      * Gets the language model associated with this compatibility layer.
      *
      * @returns The language model instance
      */
-    getModel(): SchemaCompatModel;
+    getModel(): LanguageModelV1;
     /**
      * Determines whether this compatibility layer should be applied for the current model.
      *
@@ -339,7 +339,9 @@ declare abstract class SchemaCompatLayer {
      * @param value - The Zod object to process
      * @returns The processed Zod object
      */
-    defaultZodObjectHandler(value: ZodObject<any, any, any>): ZodObject<any, any, any>;
+    defaultZodObjectHandler(value: ZodObject<any, any, any>, options?: {
+        passthrough?: boolean;
+    }): ZodObject<any, any, any>;
     /**
      * Merges validation constraints into a parameter description.
      *
@@ -427,8 +429,6 @@ declare abstract class SchemaCompatLayer {
 export { SchemaCompatLayer }
 export { SchemaCompatLayer as SchemaCompatLayer_alias_1 }
 
-export declare type SchemaCompatModel = Exclude<LanguageModel, string>;
-
 /**
  * Utility type to extract the keys from a Zod object shape.
  */

package/dist/_tsup-dts-rollup.d.ts

@@ -1,5 +1,5 @@
 import type { JSONSchema7 } from 'json-schema';
-import type { LanguageModel } from 'ai';
+import type { LanguageModelV1 } from 'ai';
 import type { Schema } from 'ai';
 import type { Targets } from 'zod-to-json-schema';
 import { z } from 'zod';
@@ -54,7 +54,7 @@ export { AllZodType }
 export { AllZodType as AllZodType_alias_1 }
 
 declare class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -170,7 +170,7 @@ declare type DateConstraints = {
 };
 
 declare class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -179,7 +179,7 @@ export { DeepSeekSchemaCompatLayer }
 export { DeepSeekSchemaCompatLayer as DeepSeekSchemaCompatLayer_alias_1 }
 
 declare class GoogleSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -216,7 +216,7 @@ export { isUnion }
 export { isUnion as isUnion_alias_1 }
 
 declare class MetaSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -240,7 +240,7 @@ declare type NumberConstraints = {
 };
 
 declare class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     isReasoningModel(): boolean;
     shouldApply(): boolean;
@@ -250,7 +250,7 @@ export { OpenAIReasoningSchemaCompatLayer }
 export { OpenAIReasoningSchemaCompatLayer as OpenAIReasoningSchemaCompatLayer_alias_1 }
 
 declare class OpenAISchemaCompatLayer extends SchemaCompatLayer {
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     getSchemaTarget(): Targets | undefined;
     shouldApply(): boolean;
     processZodType(value: ZodTypeAny): ZodTypeAny;
@@ -304,13 +304,13 @@ declare abstract class SchemaCompatLayer {
      *
      * @param model - The language model this compatibility layer applies to
      */
-    constructor(model: SchemaCompatModel);
+    constructor(model: LanguageModelV1);
     /**
      * Gets the language model associated with this compatibility layer.
      *
      * @returns The language model instance
      */
-    getModel(): SchemaCompatModel;
+    getModel(): LanguageModelV1;
     /**
      * Determines whether this compatibility layer should be applied for the current model.
      *
@@ -339,7 +339,9 @@ declare abstract class SchemaCompatLayer {
      * @param value - The Zod object to process
      * @returns The processed Zod object
      */
-    defaultZodObjectHandler(value: ZodObject<any, any, any>): ZodObject<any, any, any>;
+    defaultZodObjectHandler(value: ZodObject<any, any, any>, options?: {
+        passthrough?: boolean;
+    }): ZodObject<any, any, any>;
     /**
      * Merges validation constraints into a parameter description.
      *
@@ -427,8 +429,6 @@ declare abstract class SchemaCompatLayer {
 export { SchemaCompatLayer }
 export { SchemaCompatLayer as SchemaCompatLayer_alias_1 }
 
-export declare type SchemaCompatModel = Exclude<LanguageModel, string>;
-
 /**
  * Utility type to extract the keys from a Zod object shape.
  */

package/dist/index.cjs

@@ -115,7 +115,7 @@ var SchemaCompatLayer = class {
    * @param value - The Zod object to process
    * @returns The processed Zod object
    */
-  defaultZodObjectHandler(value) {
+  defaultZodObjectHandler(value, options = { passthrough: true }) {
     const processedShape = Object.entries(value.shape).reduce((acc, [key, propValue]) => {
       acc[key] = this.processZodType(propValue);
       return acc;
@@ -130,6 +130,9 @@ var SchemaCompatLayer = class {
     if (value.description) {
       result = result.describe(value.description);
     }
+    if (options.passthrough && value._def.unknownKeys === "passthrough") {
+      result = result.passthrough();
+    }
     return result;
   }
   /**
@@ -425,9 +428,8 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
   }
   processZodType(value) {
     if (isOptional(value)) {
-      const handleTypes = ["ZodObject", "ZodArray", "ZodUnion", "ZodNever", "ZodUndefined"];
+      const handleTypes = ["ZodObject", "ZodArray", "ZodUnion", "ZodNever", "ZodUndefined", "ZodTuple"];
       if (this.getModel().modelId.includes("claude-3.5-haiku")) handleTypes.push("ZodString");
-      if (this.getModel().modelId.includes("claude-3.7")) handleTypes.push("ZodTuple");
       return this.defaultZodOptionalHandler(value, handleTypes);
     } else if (isObj(value)) {
       return this.defaultZodObjectHandler(value);
@@ -442,11 +444,7 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
         return value;
       }
     }
-    if (this.getModel().modelId.includes("claude-3.7")) {
-      return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodTuple", "ZodUndefined"]);
-    } else {
-      return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodUndefined"]);
-    }
+    return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodTuple", "ZodUndefined"]);
   }
 };
 
@@ -551,10 +549,7 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
     return `jsonSchema7`;
   }
   shouldApply() {
-    if (
-      // !this.getModel().supportsStructuredOutputs && // <- TODO: this no longer exists, do we need it?
-      this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`)
-    ) {
+    if (!this.getModel().supportsStructuredOutputs && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))) {
       return true;
     }
     return false;
@@ -598,10 +593,7 @@ var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().modelId.includes(`o3`) || this.getModel().modelId.includes(`o4`);
   }
   shouldApply() {
-    if (
-      // (this.getModel().supportsStructuredOutputs || this.isReasoningModel()) && // <- supportsStructuredOutputs no longer exists
-      this.isReasoningModel() && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))
-    ) {
+    if ((this.getModel().supportsStructuredOutputs || this.isReasoningModel()) && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))) {
       return true;
     }
     return false;
@@ -611,7 +603,7 @@ var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
       const innerZodType = this.processZodType(value._def.innerType);
       return innerZodType.nullable();
     } else if (isObj(value)) {
-      return this.defaultZodObjectHandler(value);
+      return this.defaultZodObjectHandler(value, { passthrough: false });
     } else if (isArr(value)) {
       return this.defaultZodArrayHandler(value);
     } else if (isUnion(value)) {

package/dist/index.js

@@ -113,7 +113,7 @@ var SchemaCompatLayer = class {
    * @param value - The Zod object to process
    * @returns The processed Zod object
    */
-  defaultZodObjectHandler(value) {
+  defaultZodObjectHandler(value, options = { passthrough: true }) {
     const processedShape = Object.entries(value.shape).reduce((acc, [key, propValue]) => {
       acc[key] = this.processZodType(propValue);
       return acc;
@@ -128,6 +128,9 @@ var SchemaCompatLayer = class {
     if (value.description) {
       result = result.describe(value.description);
     }
+    if (options.passthrough && value._def.unknownKeys === "passthrough") {
+      result = result.passthrough();
+    }
     return result;
   }
   /**
@@ -423,9 +426,8 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
   }
   processZodType(value) {
     if (isOptional(value)) {
-      const handleTypes = ["ZodObject", "ZodArray", "ZodUnion", "ZodNever", "ZodUndefined"];
+      const handleTypes = ["ZodObject", "ZodArray", "ZodUnion", "ZodNever", "ZodUndefined", "ZodTuple"];
       if (this.getModel().modelId.includes("claude-3.5-haiku")) handleTypes.push("ZodString");
-      if (this.getModel().modelId.includes("claude-3.7")) handleTypes.push("ZodTuple");
       return this.defaultZodOptionalHandler(value, handleTypes);
     } else if (isObj(value)) {
       return this.defaultZodObjectHandler(value);
@@ -440,11 +442,7 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
         return value;
       }
     }
-    if (this.getModel().modelId.includes("claude-3.7")) {
-      return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodTuple", "ZodUndefined"]);
-    } else {
-      return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodUndefined"]);
-    }
+    return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodTuple", "ZodUndefined"]);
   }
 };
 
@@ -549,10 +547,7 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
     return `jsonSchema7`;
   }
   shouldApply() {
-    if (
-      // !this.getModel().supportsStructuredOutputs && // <- TODO: this no longer exists, do we need it?
-      this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`)
-    ) {
+    if (!this.getModel().supportsStructuredOutputs && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))) {
       return true;
     }
     return false;
@@ -596,10 +591,7 @@ var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().modelId.includes(`o3`) || this.getModel().modelId.includes(`o4`);
   }
   shouldApply() {
-    if (
-      // (this.getModel().supportsStructuredOutputs || this.isReasoningModel()) && // <- supportsStructuredOutputs no longer exists
-      this.isReasoningModel() && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))
-    ) {
+    if ((this.getModel().supportsStructuredOutputs || this.isReasoningModel()) && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))) {
       return true;
     }
     return false;
@@ -609,7 +601,7 @@ var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
       const innerZodType = this.processZodType(value._def.innerType);
       return innerZodType.nullable();
     } else if (isObj(value)) {
-      return this.defaultZodObjectHandler(value);
+      return this.defaultZodObjectHandler(value, { passthrough: false });
     } else if (isArr(value)) {
       return this.defaultZodArrayHandler(value);
     } else if (isUnion(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/schema-compat",
-  "version": "0.0.0-ai-v5-20250626003446",
+  "version": "0.0.0-fix-fetch-workflow-runs-20250624231457",
   "description": "Tool schema compatibility layer for Mastra.ai",
   "type": "module",
   "main": "dist/index.js",
@@ -33,19 +33,19 @@
     "zod-to-json-schema": "^3.24.5"
   },
   "peerDependencies": {
-    "ai": "5.0.0-beta.1",
+    "ai": "^4.0.0",
     "zod": "^3.0.0"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
-    "ai": "5.0.0-beta.1",
-    "eslint": "^9.28.0",
-    "tsup": "^8.5.0",
     "@types/node": "^20.19.0",
+    "ai": "4.3.16",
+    "eslint": "^9.29.0",
+    "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "zod": "^3.25.57",
-    "@internal/lint": "0.0.0-ai-v5-20250626003446"
+    "zod": "^3.25.67",
+    "@internal/lint": "0.0.0-fix-fetch-workflow-runs-20250624231457"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/provider-compats/anthropic.ts

@@ -1,10 +1,11 @@
+import type { LanguageModelV1 } from 'ai';
 import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
 import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { AllZodType, SchemaCompatModel } from '../schema-compatibility';
+import type { AllZodType } from '../schema-compatibility';
 
 export class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
+  constructor(model: LanguageModelV1) {
     super(model);
   }
 
@@ -18,9 +19,8 @@ export class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
 
   processZodType(value: ZodTypeAny): ZodTypeAny {
     if (isOptional(value)) {
-      const handleTypes: AllZodType[] = ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodNever', 'ZodUndefined'];
+      const handleTypes: AllZodType[] = ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodNever', 'ZodUndefined', 'ZodTuple'];
       if (this.getModel().modelId.includes('claude-3.5-haiku')) handleTypes.push('ZodString');
-      if (this.getModel().modelId.includes('claude-3.7')) handleTypes.push('ZodTuple');
       return this.defaultZodOptionalHandler(value, handleTypes);
     } else if (isObj(value)) {
       return this.defaultZodObjectHandler(value);
@@ -39,10 +39,6 @@ export class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
       }
     }
 
-    if (this.getModel().modelId.includes('claude-3.7')) {
-      return this.defaultUnsupportedZodTypeHandler(value, ['ZodNever', 'ZodTuple', 'ZodUndefined']);
-    } else {
-      return this.defaultUnsupportedZodTypeHandler(value, ['ZodNever', 'ZodUndefined']);
-    }
+    return this.defaultUnsupportedZodTypeHandler(value, ['ZodNever', 'ZodTuple', 'ZodUndefined']);
   }
 }

package/src/provider-compats/deepseek.ts

@@ -1,10 +1,10 @@
+import type { LanguageModelV1 } from 'ai';
 import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
 import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { SchemaCompatModel } from '../schema-compatibility';
 
 export class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
+  constructor(model: LanguageModelV1) {
     super(model);
   }
 

package/src/provider-compats/google.ts

@@ -1,3 +1,4 @@
+import type { LanguageModelV1 } from 'ai';
 import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
 import {
@@ -10,10 +11,9 @@ import {
   isString,
   isUnion,
 } from '../schema-compatibility';
-import type { SchemaCompatModel } from '../schema-compatibility';
 
 export class GoogleSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
+  constructor(model: LanguageModelV1) {
     super(model);
   }
 

package/src/provider-compats/meta.ts

@@ -1,10 +1,10 @@
+import type { LanguageModelV1 } from 'ai';
 import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
 import { SchemaCompatLayer, isArr, isNumber, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { SchemaCompatModel } from '../schema-compatibility';
 
 export class MetaSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
+  constructor(model: LanguageModelV1) {
     super(model);
   }
 

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

@@ -1,3 +1,4 @@
+import type { LanguageModelV1 } from 'ai';
 import { z } from 'zod';
 import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
@@ -12,10 +13,9 @@ import {
   isString,
   isUnion,
 } from '../schema-compatibility';
-import type { SchemaCompatModel } from '../schema-compatibility';
 
 export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
+  constructor(model: LanguageModelV1) {
     super(model);
   }
 
@@ -31,8 +31,7 @@ export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
 
   shouldApply(): boolean {
     if (
-      // (this.getModel().supportsStructuredOutputs || this.isReasoningModel()) && // <- supportsStructuredOutputs no longer exists
-      this.isReasoningModel() &&
+      (this.getModel().supportsStructuredOutputs || this.isReasoningModel()) &&
       (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))
     ) {
       return true;
@@ -46,7 +45,7 @@ export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
       const innerZodType = this.processZodType(value._def.innerType);
       return innerZodType.nullable();
     } else if (isObj(value)) {
-      return this.defaultZodObjectHandler(value);
+      return this.defaultZodObjectHandler(value, { passthrough: false });
     } else if (isArr(value)) {
       return this.defaultZodArrayHandler(value);
     } else if (isUnion(value)) {

package/src/provider-compats/openai.ts

@@ -1,10 +1,11 @@
+import type { LanguageModelV1 } from 'ai';
 import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
 import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { SchemaCompatModel, StringCheckType } from '../schema-compatibility';
+import type { StringCheckType } from '../schema-compatibility';
 
 export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
+  constructor(model: LanguageModelV1) {
     super(model);
   }
 
@@ -14,9 +15,8 @@ export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
 
   shouldApply(): boolean {
     if (
-      // !this.getModel().supportsStructuredOutputs && // <- TODO: this no longer exists, do we need it?
-      this.getModel().provider.includes(`openai`) ||
-      this.getModel().modelId.includes(`openai`)
+      !this.getModel().supportsStructuredOutputs &&
+      (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))
     ) {
       return true;
     }

package/src/provider-compats.test.ts

@@ -1,4 +1,4 @@
-import { MockLanguageModelV2 } from 'ai/test';
+import { MockLanguageModelV1 } from 'ai/test';
 import { describe, it, expect } from 'vitest';
 import { z } from 'zod';
 import {
@@ -12,27 +12,27 @@ import {
 
 describe('Provider Compatibility Classes', () => {
   const mockModels = {
-    anthropic: new MockLanguageModelV2({
+    anthropic: new MockLanguageModelV1({
       modelId: 'claude-3-sonnet-20240229',
       doGenerate: async () => ({ response: { id: 'test' } }) as any,
     }),
-    openai: new MockLanguageModelV2({
+    openai: new MockLanguageModelV1({
       modelId: 'openai/gpt-4',
       doGenerate: async () => ({ response: { id: 'test' } }) as any,
     }),
-    openaiReasoning: new MockLanguageModelV2({
+    openaiReasoning: new MockLanguageModelV1({
       modelId: 'openai/o3-mini',
       doGenerate: async () => ({ response: { id: 'test' } }) as any,
     }),
-    google: new MockLanguageModelV2({
+    google: new MockLanguageModelV1({
       modelId: 'gemini-pro',
       doGenerate: async () => ({ response: { id: 'test' } }) as any,
     }),
-    deepseek: new MockLanguageModelV2({
+    deepseek: new MockLanguageModelV1({
       modelId: 'deepseek-chat',
       doGenerate: async () => ({ response: { id: 'test' } }) as any,
     }),
-    meta: new MockLanguageModelV2({
+    meta: new MockLanguageModelV1({
       modelId: 'llama-3.1-405b-instruct',
       doGenerate: async () => ({ response: { id: 'test' } }) as any,
     }),

package/src/schema-compatibility.test.ts

@@ -1,11 +1,11 @@
-import { MockLanguageModelV2 } from 'ai/test';
+import type { LanguageModelV1 } from 'ai';
+import { MockLanguageModelV1 } from 'ai/test';
 import { describe, it, expect, beforeEach } from 'vitest';
 import { z } from 'zod';
-import type { SchemaCompatModel } from './schema-compatibility';
 import { isArr, isObj, isOptional, isString, isUnion, SchemaCompatLayer } from './schema-compatibility';
 
 class MockSchemaCompatibility extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
+  constructor(model: LanguageModelV1) {
     super(model);
   }
 
@@ -36,8 +36,9 @@ class MockSchemaCompatibility extends SchemaCompatLayer {
   }
 }
 
-const mockModel = new MockLanguageModelV2({
+const mockModel = new MockLanguageModelV1({
   modelId: 'test-model',
+  defaultObjectGenerationMode: 'json',
 });
 
 describe('SchemaCompatLayer', () => {
@@ -382,11 +383,9 @@ describe('SchemaCompatLayer', () => {
       expect(result.jsonSchema.type).toBe('array');
       expect(result.jsonSchema.description).toContain('minLength');
       // The validator itself should be gone
-      // TODO: success type is messed up in AI SDK V5 for us
       expect(
         result.validate?.([
           /* empty array */
-          // @ts-expect-error
         ]).success,
       ).toBe(true);
 
@@ -407,7 +406,6 @@ describe('SchemaCompatLayer', () => {
       expect(
         preservingResult.validate?.([
           /* empty array */
-          // @ts-expect-error
         ]).success,
       ).toBe(false); // validator preserved
     });
@@ -439,9 +437,7 @@ describe('SchemaCompatLayer', () => {
         .optional();
 
       const result = compatibility.processToAISDKSchema(optionalSchema);
-      // @ts-expect-error
       expect(result.validate!({ name: 'test' }).success).toBe(true);
-      // @ts-expect-error
       expect(result.validate!(undefined).success).toBe(true);
 
       const jsonSchema = result.jsonSchema;
@@ -452,9 +448,7 @@ describe('SchemaCompatLayer', () => {
     it('should handle optional array schemas', () => {
       const optionalSchema = z.array(z.string()).optional();
       const result = compatibility.processToAISDKSchema(optionalSchema);
-      // @ts-expect-error
       expect(result.validate!(['test']).success).toBe(true);
-      // @ts-expect-error
       expect(result.validate!(undefined).success).toBe(true);
 
       const jsonSchema = result.jsonSchema;
@@ -466,9 +460,7 @@ describe('SchemaCompatLayer', () => {
     it('should handle optional scalar schemas', () => {
       const optionalSchema = z.string().optional();
       const result = compatibility.processToAISDKSchema(optionalSchema);
-      // @ts-expect-error
       expect(result.validate!('test').success).toBe(true);
-      // @ts-expect-error
       expect(result.validate!(undefined).success).toBe(true);
 
       const jsonSchema = result.jsonSchema;

package/src/schema-compatibility.ts

@@ -1,12 +1,10 @@
-import type { Schema, LanguageModel } from 'ai';
+import type { Schema, LanguageModelV1 } from 'ai';
 import type { JSONSchema7 } from 'json-schema';
 import { z, ZodOptional, ZodObject, ZodArray, ZodUnion, ZodString, ZodNumber, ZodDate, ZodDefault } from 'zod';
 import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
 import { convertZodSchemaToAISDKSchema } from './utils';
 
-export type SchemaCompatModel = Exclude<LanguageModel, string>;
-
 /**
  * All supported string validation check types that can be processed or converted to descriptions.
  * @constant
@@ -183,14 +181,14 @@ type DateConstraints = {
  * ```
  */
 export abstract class SchemaCompatLayer {
-  private model: SchemaCompatModel;
+  private model: LanguageModelV1;
 
   /**
    * Creates a new schema compatibility instance.
    *
    * @param model - The language model this compatibility layer applies to
    */
-  constructor(model: SchemaCompatModel) {
+  constructor(model: LanguageModelV1) {
     this.model = model;
   }
 
@@ -199,7 +197,7 @@ export abstract class SchemaCompatLayer {
    *
    * @returns The language model instance
    */
-  getModel(): SchemaCompatModel {
+  getModel(): LanguageModelV1 {
     return this.model;
   }
 
@@ -234,7 +232,10 @@ export abstract class SchemaCompatLayer {
    * @param value - The Zod object to process
    * @returns The processed Zod object
    */
-  public defaultZodObjectHandler(value: ZodObject<any, any, any>): ZodObject<any, any, any> {
+  public defaultZodObjectHandler(
+    value: ZodObject<any, any, any>,
+    options: { passthrough?: boolean } = { passthrough: true },
+  ): ZodObject<any, any, any> {
     const processedShape = Object.entries(value.shape).reduce<Record<string, ZodTypeAny>>((acc, [key, propValue]) => {
       acc[key] = this.processZodType(propValue as ZodTypeAny);
       return acc;
@@ -252,6 +253,11 @@ export abstract class SchemaCompatLayer {
     if (value.description) {
       result = result.describe(value.description);
     }
+
+    if (options.passthrough && value._def.unknownKeys === 'passthrough') {
+      result = result.passthrough();
+    }
+
     return result;
   }
 

package/src/utils.test.ts

@@ -1,19 +1,19 @@
 import { jsonSchema } from 'ai';
-import type { Schema } from 'ai';
-import { MockLanguageModelV2 } from 'ai/test';
+import type { LanguageModelV1, Schema } from 'ai';
+import { MockLanguageModelV1 } from 'ai/test';
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { z } from 'zod';
-import type { SchemaCompatModel } from './schema-compatibility';
 import { SchemaCompatLayer } from './schema-compatibility';
 import { convertZodSchemaToAISDKSchema, convertSchemaToZod, applyCompatLayer } from './utils';
 
-const mockModel = new MockLanguageModelV2({
+const mockModel = new MockLanguageModelV1({
   modelId: 'test-model',
+  defaultObjectGenerationMode: 'json',
 });
 
 class MockSchemaCompatibility extends SchemaCompatLayer {
   constructor(
-    model: SchemaCompatModel,
+    model: LanguageModelV1,
     private shouldApplyValue: boolean = true,
   ) {
     super(model);
@@ -66,20 +66,12 @@ describe('Builder Functions', () => {
       expect(result.validate).toBeDefined();
 
       const validResult = result.validate!({ email: 'test@example.com' });
-      // TODO: tool types are broken
-      // @ts-expect-error
       expect(validResult.success).toBe(true);
-      // TODO: tool types are broken
-      // @ts-expect-error
       if (validResult.success) {
-        // TODO: tool types are broken
-        // @ts-expect-error
         expect(validResult.value).toEqual({ email: 'test@example.com' });
       }
 
       const invalidResult = result.validate!({ email: 'invalid-email' });
-      // TODO: tool types are broken
-      // @ts-expect-error
       expect(invalidResult.success).toBe(false);
     });