@mastra/schema-compat 0.10.2-alpha.2 → 0.10.2

package/src/provider-compats/deepseek.ts

@@ -1,8 +1,7 @@
 import type { LanguageModelV1 } from 'ai';
-import type { z } from 'zod';
+import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ShapeValue } from '../schema-compatibility';
+import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
 
 export class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: LanguageModelV1) {
@@ -18,24 +17,19 @@ export class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
     return this.getModel().modelId.includes('deepseek') && !this.getModel().modelId.includes('r1');
   }
 
-  processZodType<T extends z.AnyZodObject>(value: z.ZodTypeAny): ShapeValue<T> {
-    switch (value._def.typeName) {
-      case 'ZodOptional':
-        return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
-      case 'ZodObject': {
-        return this.defaultZodObjectHandler(value);
-      }
-      case 'ZodArray': {
-        return this.defaultZodArrayHandler(value, ['min', 'max']);
-      }
-      case 'ZodUnion': {
-        return this.defaultZodUnionHandler(value);
-      }
-      case 'ZodString': {
-        return this.defaultZodStringHandler(value);
-      }
-      default:
-        return value as ShapeValue<T>;
+  processZodType(value: ZodTypeAny): ZodTypeAny {
+    if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value, ['min', 'max']);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isString(value)) {
+      return this.defaultZodStringHandler(value);
     }
+
+    return value;
   }
 }

package/src/provider-compats/google.ts

@@ -1,8 +1,16 @@
 import type { LanguageModelV1 } from 'ai';
-import type { z } from 'zod';
+import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer, UNSUPPORTED_ZOD_TYPES } from '../schema-compatibility';
-import type { ShapeValue } from '../schema-compatibility';
+import {
+  SchemaCompatLayer,
+  UNSUPPORTED_ZOD_TYPES,
+  isArr,
+  isNumber,
+  isObj,
+  isOptional,
+  isString,
+  isUnion,
+} from '../schema-compatibility';
 
 export class GoogleSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: LanguageModelV1) {
@@ -17,38 +25,31 @@ export class GoogleSchemaCompatLayer extends SchemaCompatLayer {
     return this.getModel().provider.includes('google') || this.getModel().modelId.includes('google');
   }
 
-  processZodType<T extends z.AnyZodObject>(value: z.ZodTypeAny): ShapeValue<T> {
-    switch (value._def.typeName) {
-      case 'ZodOptional':
-        return this.defaultZodOptionalHandler(value, [
-          'ZodObject',
-          'ZodArray',
-          'ZodUnion',
-          'ZodString',
-          'ZodNumber',
-          ...UNSUPPORTED_ZOD_TYPES,
-        ]);
-      case 'ZodObject': {
-        return this.defaultZodObjectHandler(value);
-      }
-      case 'ZodArray': {
-        return this.defaultZodArrayHandler(value, []);
-      }
-      case 'ZodUnion': {
-        return this.defaultZodUnionHandler(value);
-      }
+  processZodType(value: ZodTypeAny): ZodTypeAny {
+    if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value, [
+        'ZodObject',
+        'ZodArray',
+        'ZodUnion',
+        'ZodString',
+        'ZodNumber',
+        ...UNSUPPORTED_ZOD_TYPES,
+      ]);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value, []);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isString(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
-      case 'ZodString': {
-        return this.defaultZodStringHandler(value);
-      }
-      case 'ZodNumber': {
-        // 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);
-      }
-      default:
-        return this.defaultUnsupportedZodTypeHandler(value);
+      return this.defaultZodStringHandler(value);
+    } else if (isNumber(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);
   }
 }

package/src/provider-compats/meta.ts

@@ -1,8 +1,7 @@
 import type { LanguageModelV1 } from 'ai';
-import type { z } from 'zod';
+import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ShapeValue } from '../schema-compatibility';
+import { SchemaCompatLayer, isArr, isNumber, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
 
 export class MetaSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: LanguageModelV1) {
@@ -17,27 +16,21 @@ export class MetaSchemaCompatLayer extends SchemaCompatLayer {
     return this.getModel().modelId.includes('meta');
   }
 
-  processZodType<T extends z.AnyZodObject>(value: z.ZodTypeAny): ShapeValue<T> {
-    switch (value._def.typeName) {
-      case 'ZodOptional':
-        return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
-      case 'ZodObject': {
-        return this.defaultZodObjectHandler(value);
-      }
-      case 'ZodArray': {
-        return this.defaultZodArrayHandler(value, ['min', 'max']);
-      }
-      case 'ZodUnion': {
-        return this.defaultZodUnionHandler(value);
-      }
-      case 'ZodNumber': {
-        return this.defaultZodNumberHandler(value);
-      }
-      case 'ZodString': {
-        return this.defaultZodStringHandler(value);
-      }
-      default:
-        return value as ShapeValue<T>;
+  processZodType(value: ZodTypeAny): ZodTypeAny {
+    if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value, ['min', 'max']);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isNumber(value)) {
+      return this.defaultZodNumberHandler(value);
+    } else if (isString(value)) {
+      return this.defaultZodStringHandler(value);
     }
+
+    return value;
   }
 }

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

@@ -1,8 +1,18 @@
 import type { LanguageModelV1 } from 'ai';
 import { z } from 'zod';
+import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ShapeValue } from '../schema-compatibility';
+import {
+  SchemaCompatLayer,
+  isArr,
+  isDate,
+  isDefault,
+  isNumber,
+  isObj,
+  isOptional,
+  isString,
+  isUnion,
+} from '../schema-compatibility';
 
 export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: LanguageModelV1) {
@@ -30,57 +40,48 @@ export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
     return false;
   }
 
-  processZodType<T extends z.AnyZodObject>(value: z.ZodTypeAny): ShapeValue<T> {
-    switch (value._def.typeName) {
-      case 'ZodOptional':
-        const innerZodType = this.processZodType(value._def.innerType);
-        return innerZodType.nullable() as ShapeValue<T>;
-      case 'ZodObject': {
-        return this.defaultZodObjectHandler(value);
+  processZodType(value: ZodTypeAny): ZodTypeAny {
+    if (isOptional(value)) {
+      const innerZodType = this.processZodType(value._def.innerType);
+      return innerZodType.nullable();
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isDefault(value)) {
+      const defaultDef = value._def;
+      const innerType = defaultDef.innerType;
+      const defaultValue = defaultDef.defaultValue();
+      const constraints: { defaultValue?: unknown } = {};
+      if (defaultValue !== undefined) {
+        constraints.defaultValue = defaultValue;
       }
-      case 'ZodArray': {
-        return this.defaultZodArrayHandler(value);
-      }
-      case 'ZodUnion': {
-        return this.defaultZodUnionHandler(value);
-      }
-      case 'ZodDefault': {
-        const defaultDef = (value as z.ZodDefault<any>)._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<T>(innerType);
-        if (description) {
-          result = result.describe(description);
-        }
-        return result;
-      }
-      case 'ZodNumber': {
-        return this.defaultZodNumberHandler(value);
-      }
-      case 'ZodString': {
-        return this.defaultZodStringHandler(value);
+      const description = this.mergeParameterDescription(value.description, constraints);
+      let result = this.processZodType(innerType);
+      if (description) {
+        result = result.describe(description);
       }
-      case 'ZodDate': {
-        return this.defaultZodDateHandler(value);
-      }
-      case '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`,
-          );
-      }
-      default:
-        return this.defaultUnsupportedZodTypeHandler(value);
+      return result;
+    } else if (isNumber(value)) {
+      return this.defaultZodNumberHandler(value);
+    } else if (isString(value)) {
+      return this.defaultZodStringHandler(value);
+    } else if (isDate(value)) {
+      return this.defaultZodDateHandler(value);
+    } else if (value._def.typeName === '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);
   }
 }

package/src/provider-compats/openai.ts

@@ -1,8 +1,8 @@
 import type { LanguageModelV1 } from 'ai';
-import type { z } from 'zod';
+import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ShapeValue, StringCheckType } from '../schema-compatibility';
+import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
+import type { StringCheckType } from '../schema-compatibility';
 
 export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: LanguageModelV1) {
@@ -24,38 +24,33 @@ export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
     return false;
   }
 
-  processZodType<T extends z.AnyZodObject>(value: z.ZodTypeAny): ShapeValue<T> {
-    switch (value._def.typeName) {
-      case 'ZodOptional':
-        return this.defaultZodOptionalHandler(value, [
-          'ZodObject',
-          'ZodArray',
-          'ZodUnion',
-          'ZodString',
-          'ZodNever',
-          'ZodUndefined',
-          'ZodTuple',
-        ]);
-      case 'ZodObject': {
-        return this.defaultZodObjectHandler(value);
-      }
-      case 'ZodUnion': {
-        return this.defaultZodUnionHandler(value);
-      }
-      case 'ZodArray': {
-        return this.defaultZodArrayHandler(value);
-      }
-      case 'ZodString': {
-        const model = this.getModel();
-        const checks: StringCheckType[] = ['emoji'];
+  processZodType(value: ZodTypeAny): ZodTypeAny {
+    if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value, [
+        'ZodObject',
+        'ZodArray',
+        'ZodUnion',
+        'ZodString',
+        'ZodNever',
+        'ZodUndefined',
+        'ZodTuple',
+      ]);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value);
+    } else if (isString(value)) {
+      const model = this.getModel();
+      const checks: StringCheckType[] = ['emoji'];
 
-        if (model.modelId.includes('gpt-4o-mini')) {
-          checks.push('regex');
-        }
-        return this.defaultZodStringHandler(value, checks);
+      if (model.modelId.includes('gpt-4o-mini')) {
+        checks.push('regex');
       }
-      default:
-        return this.defaultUnsupportedZodTypeHandler(value, ['ZodNever', 'ZodUndefined', 'ZodTuple']);
+      return this.defaultZodStringHandler(value, checks);
     }
+
+    return this.defaultUnsupportedZodTypeHandler(value, ['ZodNever', 'ZodUndefined', 'ZodTuple']);
   }
 }

package/src/schema-compatibility.test.ts

@@ -2,7 +2,7 @@ import type { LanguageModelV1 } from 'ai';
 import { MockLanguageModelV1 } from 'ai/test';
 import { describe, it, expect, beforeEach } from 'vitest';
 import { z } from 'zod';
-import { SchemaCompatLayer } from './schema-compatibility';
+import { isArr, isObj, isOptional, isString, isUnion, SchemaCompatLayer } from './schema-compatibility';
 
 class MockSchemaCompatibility extends SchemaCompatLayer {
   constructor(model: LanguageModelV1) {
@@ -17,8 +17,22 @@ class MockSchemaCompatibility extends SchemaCompatLayer {
     return 'jsonSchema7' as const;
   }
 
-  processZodType(value: z.ZodTypeAny): any {
-    return value;
+  processZodType(value: z.ZodTypeAny): z.ZodTypeAny {
+    if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      // For these tests, we will handle all checks by converting them to descriptions.
+      return this.defaultZodArrayHandler(value, ['min', 'max', 'length']);
+    } else if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isString(value)) {
+      // Add a marker to confirm it was processed
+      return z.string().describe(`${value.description || 'string'}:processed`);
+    } else {
+      return value;
+    }
   }
 }
 
@@ -78,16 +92,18 @@ describe('SchemaCompatLayer', () => {
   });
 
   describe('defaultZodObjectHandler', () => {
-    it('should process object shape correctly', () => {
+    it('should process object shape correctly and recursively', () => {
       const testSchema = z.object({
-        name: z.string(),
-        age: z.number(),
+        name: z.string().describe('The name'),
+        age: z.number(), // not a string, so won't get a description
       });
 
-      const result = compatibility.defaultZodObjectHandler(testSchema);
+      const result = compatibility.defaultZodObjectHandler(testSchema) as z.ZodObject<any, any, any>;
+      const newShape = result.shape;
 
-      expect(result).toBeInstanceOf(z.ZodObject);
-      expect(result._def.typeName).toBe('ZodObject');
+      expect(newShape.name).toBeInstanceOf(z.ZodString);
+      expect(newShape.name.description).toBe('The name:processed');
+      expect(newShape.age.description).toBeUndefined();
     });
 
     it('should preserve description', () => {
@@ -101,6 +117,16 @@ describe('SchemaCompatLayer', () => {
 
       expect(result.description).toBe('Test object');
     });
+
+    it('should preserve strictness', () => {
+      const strictSchema = z.object({ name: z.string() }).strict();
+      const result = compatibility.defaultZodObjectHandler(strictSchema);
+      expect(result._def.unknownKeys).toBe('strict');
+
+      const nonStrictSchema = z.object({ name: z.string() });
+      const nonStrictResult = compatibility.defaultZodObjectHandler(nonStrictSchema);
+      expect(nonStrictResult._def.unknownKeys).toBe('strip'); // default
+    });
   });
 
   describe('defaultUnsupportedZodTypeHandler', () => {
@@ -130,59 +156,38 @@ describe('SchemaCompatLayer', () => {
   });
 
   describe('defaultZodArrayHandler', () => {
-    it('should handle array with constraints', () => {
+    it('should handle array with constraints and convert to description', () => {
       const arraySchema = z.array(z.string()).min(2).max(10);
-
       const result = compatibility.defaultZodArrayHandler(arraySchema);
-
-      expect(result).toBeInstanceOf(z.ZodArray);
       expect(result.description).toContain('minLength');
       expect(result.description).toContain('maxLength');
     });
 
-    it('should handle array without constraints', () => {
-      const arraySchema = z.array(z.string());
-
-      const result = compatibility.defaultZodArrayHandler(arraySchema);
+    it('should preserve constraints not in handleChecks', () => {
+      const arraySchema = z.array(z.string()).min(2).max(10);
+      // Only handle 'min', so 'max' should be preserved as a validator
+      const result = compatibility.defaultZodArrayHandler(arraySchema, ['min']);
 
-      expect(result).toBeInstanceOf(z.ZodArray);
+      expect(result.description).toContain('minLength');
+      expect(result.description).not.toContain('maxLength');
+      expect(result._def.maxLength?.value).toBe(10); // Preserved
     });
 
     it('should handle exact length constraint', () => {
       const arraySchema = z.array(z.string()).length(5);
-
       const result = compatibility.defaultZodArrayHandler(arraySchema);
-
-      expect(result).toBeInstanceOf(z.ZodArray);
       expect(result.description).toContain('exactLength');
     });
 
     it('should preserve original description', () => {
-      const arraySchema = z.array(z.string()).describe('String array');
-
+      const arraySchema = z.array(z.string()).describe('String array').min(1);
       const result = compatibility.defaultZodArrayHandler(arraySchema);
-
       expect(result.description).toContain('String array');
+      expect(result.description).toContain('minLength');
     });
   });
 
   describe('defaultZodUnionHandler', () => {
-    it('should handle union types', () => {
-      const unionSchema = z.union([z.string(), z.number()]);
-
-      const result = compatibility.defaultZodUnionHandler(unionSchema);
-
-      expect(result).toBeInstanceOf(z.ZodUnion);
-    });
-
-    it('should preserve description', () => {
-      const unionSchema = z.union([z.string(), z.number()]).describe('String or number');
-
-      const result = compatibility.defaultZodUnionHandler(unionSchema);
-
-      expect(result.description).toBe('String or number');
-    });
-
     it('should throw error for union with less than 2 options', () => {
       const mockUnion = {
         _def: {
@@ -195,6 +200,19 @@ describe('SchemaCompatLayer', () => {
         compatibility.defaultZodUnionHandler(mockUnion);
       }).toThrow('Union must have at least 2 options');
     });
+
+    it('should handle union types and process recursively', () => {
+      const unionSchema = z.union([z.string().describe('A string'), z.number()]);
+      const result = compatibility.defaultZodUnionHandler(unionSchema) as z.ZodUnion<any>;
+      const processedString = result.options[0];
+      expect(processedString.description).toBe('A string:processed');
+    });
+
+    it('should preserve description', () => {
+      const unionSchema = z.union([z.string(), z.number()]).describe('String or number');
+      const result = compatibility.defaultZodUnionHandler(unionSchema);
+      expect(result.description).toBe('String or number');
+    });
   });
 
   describe('defaultZodStringHandler', () => {
@@ -347,4 +365,107 @@ describe('SchemaCompatLayer', () => {
       expect(result).toBe(optionalNever);
     });
   });
+
+  describe('Top-level schema processing (processToAISDKSchema)', () => {
+    it('should process a simple object schema', () => {
+      const objectSchema = z.object({ user: z.string().describe('user name') });
+      const result = compatibility.processToAISDKSchema(objectSchema);
+      const userProp = result.jsonSchema.properties?.user as any;
+      expect(userProp.description).toBe('user name:processed');
+    });
+
+    it('should preserve top-level array constraints during processing', () => {
+      const arraySchema = z.array(z.string().describe('item')).min(1);
+
+      // In our mock, 'min' is converted to a description.
+      const result = compatibility.processToAISDKSchema(arraySchema);
+
+      expect(result.jsonSchema.type).toBe('array');
+      expect(result.jsonSchema.description).toContain('minLength');
+      // The validator itself should be gone
+      expect(
+        result.validate?.([
+          /* empty array */
+        ]).success,
+      ).toBe(true);
+
+      // Now test that a constraint is preserved if not handled
+      class PreservingMock extends MockSchemaCompatibility {
+        processZodType(value: z.ZodTypeAny): z.ZodTypeAny {
+          if (value instanceof z.ZodArray) {
+            return this.defaultZodArrayHandler(value as any, [
+              /* handle nothing */
+            ]);
+          }
+          return super.processZodType(value);
+        }
+      }
+      const preservingCompat = new PreservingMock(mockModel);
+      const preservingResult = preservingCompat.processToAISDKSchema(arraySchema);
+      expect(preservingResult.jsonSchema.description).toBeUndefined();
+      expect(
+        preservingResult.validate?.([
+          /* empty array */
+        ]).success,
+      ).toBe(false); // validator preserved
+    });
+
+    it('should preserve top-level object constraints (strict)', () => {
+      const strictSchema = z.object({ name: z.string() }).strict();
+      const result = compatibility.processToAISDKSchema(strictSchema);
+      expect(result.jsonSchema.additionalProperties).toBe(false);
+    });
+
+    it('should process array of objects, including nested properties', () => {
+      const arraySchema = z.array(
+        z.object({
+          name: z.string().describe('The name'),
+          value: z.number().describe('The value'), // number is not processed in our mock
+        }),
+      );
+      const result = compatibility.processToAISDKSchema(arraySchema);
+      const items = result.jsonSchema.items as any;
+      expect(items.properties.name.description).toBe('The name:processed');
+      expect(items.properties.value.description).toBe('The value');
+    });
+
+    it('should handle optional object schemas', () => {
+      const optionalSchema = z
+        .object({
+          name: z.string(),
+        })
+        .optional();
+
+      const result = compatibility.processToAISDKSchema(optionalSchema);
+      expect(result.validate!({ name: 'test' }).success).toBe(true);
+      expect(result.validate!(undefined).success).toBe(true);
+
+      const jsonSchema = result.jsonSchema;
+      const objectDef = (jsonSchema.anyOf as any[])?.find(def => def.type === 'object');
+      expect(objectDef.properties.name.description).toBe('string:processed');
+    });
+
+    it('should handle optional array schemas', () => {
+      const optionalSchema = z.array(z.string()).optional();
+      const result = compatibility.processToAISDKSchema(optionalSchema);
+      expect(result.validate!(['test']).success).toBe(true);
+      expect(result.validate!(undefined).success).toBe(true);
+
+      const jsonSchema = result.jsonSchema;
+      const arrayDef = (jsonSchema.anyOf as any[])?.find(def => def.type === 'array');
+      const items = arrayDef.items as any;
+      expect(items.description).toBe('string:processed');
+    });
+
+    it('should handle optional scalar schemas', () => {
+      const optionalSchema = z.string().optional();
+      const result = compatibility.processToAISDKSchema(optionalSchema);
+      expect(result.validate!('test').success).toBe(true);
+      expect(result.validate!(undefined).success).toBe(true);
+
+      const jsonSchema = result.jsonSchema;
+      const stringDef = (jsonSchema.anyOf as any[])?.find(def => def.type === 'string');
+      expect(stringDef.description).toBe('string:processed');
+    });
+  });
 });