@ai-sdk/provider-utils 4.0.4 → 4.0.6

package/src/to-json-schema/zod3-to-json-schema/parsers/native-enum.ts

@@ -0,0 +1,31 @@
+import { ZodNativeEnumDef } from 'zod/v3';
+
+export type JsonSchema7NativeEnumType = {
+  type: 'string' | 'number' | ['string', 'number'];
+  enum: (string | number)[];
+};
+
+export function parseNativeEnumDef(
+  def: ZodNativeEnumDef,
+): JsonSchema7NativeEnumType {
+  const object = def.values;
+  const actualKeys = Object.keys(def.values).filter((key: string) => {
+    return typeof object[object[key]] !== 'number';
+  });
+
+  const actualValues = actualKeys.map((key: string) => object[key]);
+
+  const parsedTypes = Array.from(
+    new Set(actualValues.map((values: string | number) => typeof values)),
+  );
+
+  return {
+    type:
+      parsedTypes.length === 1
+        ? parsedTypes[0] === 'string'
+          ? 'string'
+          : 'number'
+        : ['string', 'number'],
+    enum: actualValues,
+  };
+}

package/src/to-json-schema/zod3-to-json-schema/parsers/never.ts

@@ -0,0 +1,9 @@
+import { JsonSchema7AnyType, parseAnyDef } from './any';
+
+export type JsonSchema7NeverType = {
+  not: JsonSchema7AnyType;
+};
+
+export function parseNeverDef(): JsonSchema7NeverType | undefined {
+  return { not: parseAnyDef() };
+}

package/src/to-json-schema/zod3-to-json-schema/parsers/null.ts

@@ -0,0 +1,9 @@
+export type JsonSchema7NullType = {
+  type: 'null';
+};
+
+export function parseNullDef(): JsonSchema7NullType {
+  return {
+    type: 'null',
+  };
+}

package/src/to-json-schema/zod3-to-json-schema/parsers/nullable.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseObjectDef } from './object';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('nullable', () => {
+  it('should be possible to properly reference nested nullable primitives', () => {
+    const nullablePrimitive = z.string().nullable();
+
+    const schema = z.object({
+      one: nullablePrimitive,
+      two: nullablePrimitive,
+    });
+
+    const jsonSchema: any = parseObjectDef(schema._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      additionalProperties: false,
+      type: 'object',
+      properties: {
+        one: { type: ['string', 'null'] },
+        two: { $ref: '#/properties/one' },
+      },
+      required: ['one', 'two'],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to properly reference nested nullable primitives', () => {
+    const three = z.string();
+
+    const nullableObject = z
+      .object({
+        three,
+      })
+      .nullable();
+
+    const schema = z.object({
+      one: nullableObject,
+      two: nullableObject,
+      three,
+    });
+
+    const jsonSchema: any = parseObjectDef(schema._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        one: {
+          anyOf: [
+            {
+              type: 'object',
+              additionalProperties: false,
+              required: ['three'],
+              properties: { three: { type: 'string' } },
+            },
+            { type: 'null' },
+          ],
+        },
+        two: { $ref: '#/properties/one' },
+        three: { $ref: '#/properties/one/anyOf/0/properties/three' },
+      },
+      required: ['one', 'two', 'three'],
+      additionalProperties: false,
+    } satisfies JSONSchema7);
+  });
+});

package/src/to-json-schema/zod3-to-json-schema/parsers/nullable.ts

@@ -0,0 +1,42 @@
+import { ZodNullableDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+import { JsonSchema7NullType } from './null';
+import { primitiveMappings } from './union';
+
+export type JsonSchema7NullableType =
+  | {
+      anyOf: [JsonSchema7Type, JsonSchema7NullType];
+    }
+  | {
+      type: [string, 'null'];
+    };
+
+export function parseNullableDef(
+  def: ZodNullableDef,
+  refs: Refs,
+): JsonSchema7NullableType | undefined {
+  if (
+    ['ZodString', 'ZodNumber', 'ZodBigInt', 'ZodBoolean', 'ZodNull'].includes(
+      def.innerType._def.typeName,
+    ) &&
+    (!def.innerType._def.checks || !def.innerType._def.checks.length)
+  ) {
+    return {
+      type: [
+        primitiveMappings[
+          def.innerType._def.typeName as keyof typeof primitiveMappings
+        ],
+        'null',
+      ],
+    };
+  }
+
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'anyOf', '0'],
+  });
+
+  return base && { anyOf: [base, { type: 'null' }] };
+}

package/src/to-json-schema/zod3-to-json-schema/parsers/number.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { JSONSchema7 } from '@ai-sdk/provider';
+import { z } from 'zod/v3';
+import { parseNumberDef } from './number';
+
+describe('number', () => {
+  it('should be possible to describe minimum number', () => {
+    const parsedSchema = parseNumberDef(z.number().min(5)._def);
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'number',
+      minimum: 5,
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe maximum number', () => {
+    const parsedSchema = parseNumberDef(z.number().max(5)._def);
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'number',
+      maximum: 5,
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe both minimum and maximum number', () => {
+    const parsedSchema = parseNumberDef(z.number().min(5).max(5)._def);
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'number',
+      minimum: 5,
+      maximum: 5,
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe an integer', () => {
+    const parsedSchema = parseNumberDef(z.number().int()._def);
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'integer',
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe multiples of n', () => {
+    const parsedSchema = parseNumberDef(z.number().multipleOf(2)._def);
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'number',
+      multipleOf: 2,
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe positive, negative, nonpositive and nonnegative numbers', () => {
+    const parsedSchema = parseNumberDef(
+      z.number().positive().negative().nonpositive().nonnegative()._def,
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'number',
+      minimum: 0,
+      maximum: 0,
+      exclusiveMaximum: 0,
+      exclusiveMinimum: 0,
+    } satisfies JSONSchema7);
+  });
+});

package/src/to-json-schema/zod3-to-json-schema/parsers/number.ts

@@ -0,0 +1,44 @@
+import { ZodNumberDef } from 'zod/v3';
+
+export type JsonSchema7NumberType = {
+  type: 'number' | 'integer';
+  minimum?: number;
+  exclusiveMinimum?: number;
+  maximum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+};
+
+export function parseNumberDef(def: ZodNumberDef): JsonSchema7NumberType {
+  const res: JsonSchema7NumberType = {
+    type: 'number',
+  };
+
+  if (!def.checks) return res;
+
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case 'int':
+        res.type = 'integer';
+        break;
+      case 'min':
+        if (check.inclusive) {
+          res.minimum = check.value;
+        } else {
+          res.exclusiveMinimum = check.value;
+        }
+        break;
+      case 'max':
+        if (check.inclusive) {
+          res.maximum = check.value;
+        } else {
+          res.exclusiveMaximum = check.value;
+        }
+        break;
+      case 'multipleOf':
+        res.multipleOf = check.value;
+        break;
+    }
+  }
+  return res;
+}

package/src/to-json-schema/zod3-to-json-schema/parsers/object.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseObjectDef } from './object';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('object', () => {
+  it('should be possible to describe catchAll schema', () => {
+    const schema = z
+      .object({ normalProperty: z.string() })
+      .catchall(z.boolean());
+
+    const parsedSchema = parseObjectDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        normalProperty: { type: 'string' },
+      },
+      required: ['normalProperty'],
+      additionalProperties: {
+        type: 'boolean',
+      },
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to use selective partial', () => {
+    const schema = z
+      .object({ foo: z.boolean(), bar: z.number() })
+      .partial({ foo: true });
+
+    const parsedSchema = parseObjectDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        foo: { type: 'boolean' },
+        bar: { type: 'number' },
+      },
+      required: ['bar'],
+      additionalProperties: false,
+    } satisfies JSONSchema7);
+  });
+
+  it('should allow additional properties unless strict when removeAdditionalStrategy is strict', () => {
+    const schema = z.object({ foo: z.boolean(), bar: z.number() });
+
+    const parsedSchema = parseObjectDef(
+      schema._def,
+      getRefs({ removeAdditionalStrategy: 'strict' }),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        foo: { type: 'boolean' },
+        bar: { type: 'number' },
+      },
+      required: ['foo', 'bar'],
+      additionalProperties: true,
+    } satisfies JSONSchema7);
+
+    const strictSchema = z
+      .object({ foo: z.boolean(), bar: z.number() })
+      .strict();
+
+    const parsedStrictSchema = parseObjectDef(
+      strictSchema._def,
+      getRefs({ removeAdditionalStrategy: 'strict' }),
+    );
+
+    expect(parsedStrictSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        foo: { type: 'boolean' },
+        bar: { type: 'number' },
+      },
+      required: ['foo', 'bar'],
+      additionalProperties: false,
+    } satisfies JSONSchema7);
+  });
+
+  it('should allow additional properties with catchall when removeAdditionalStrategy is strict', () => {
+    const schema = z
+      .object({ foo: z.boolean(), bar: z.number() })
+      .catchall(z.boolean());
+
+    const parsedSchema = parseObjectDef(
+      schema._def,
+      getRefs({ removeAdditionalStrategy: 'strict' }),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        foo: { type: 'boolean' },
+        bar: { type: 'number' },
+      },
+      required: ['foo', 'bar'],
+      additionalProperties: {
+        type: 'boolean',
+      },
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to not set additionalProperties at all when allowed', () => {
+    const schema = z
+      .object({ foo: z.boolean(), bar: z.number() })
+      .passthrough();
+
+    const parsedSchema = parseObjectDef(
+      schema._def,
+      getRefs({
+        removeAdditionalStrategy: 'passthrough',
+        allowedAdditionalProperties: undefined,
+      }),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        foo: { type: 'boolean' },
+        bar: { type: 'number' },
+      },
+      required: ['foo', 'bar'],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to not set additionalProperties at all when rejected', () => {
+    const schema = z.object({ foo: z.boolean(), bar: z.number() }).strict();
+
+    const parsedSchema = parseObjectDef(
+      schema._def,
+      getRefs({
+        removeAdditionalStrategy: 'passthrough',
+        rejectedAdditionalProperties: undefined,
+      }),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        foo: { type: 'boolean' },
+        bar: { type: 'number' },
+      },
+      required: ['foo', 'bar'],
+    } satisfies JSONSchema7);
+  });
+});

package/src/to-json-schema/zod3-to-json-schema/parsers/object.ts

@@ -0,0 +1,88 @@
+import { ZodObjectDef, ZodTypeAny } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+
+export type JsonSchema7ObjectType = {
+  type: 'object';
+  properties: Record<string, JsonSchema7Type>;
+  additionalProperties?: boolean | JsonSchema7Type;
+  required?: string[];
+};
+
+export function parseObjectDef(def: ZodObjectDef, refs: Refs) {
+  const result: JsonSchema7ObjectType = {
+    type: 'object',
+    properties: {},
+  };
+
+  const required: string[] = [];
+
+  const shape = def.shape();
+
+  for (const propName in shape) {
+    let propDef = shape[propName];
+
+    if (propDef === undefined || propDef._def === undefined) {
+      continue;
+    }
+
+    const propOptional = safeIsOptional(propDef);
+
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'properties', propName],
+      propertyPath: [...refs.currentPath, 'properties', propName],
+    });
+
+    if (parsedDef === undefined) {
+      continue;
+    }
+
+    result.properties[propName] = parsedDef;
+
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+
+  if (required.length) {
+    result.required = required;
+  }
+
+  const additionalProperties = decideAdditionalProperties(def, refs);
+
+  if (additionalProperties !== undefined) {
+    result.additionalProperties = additionalProperties;
+  }
+
+  return result;
+}
+
+function decideAdditionalProperties(def: ZodObjectDef, refs: Refs) {
+  if (def.catchall._def.typeName !== 'ZodNever') {
+    return parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'additionalProperties'],
+    });
+  }
+
+  switch (def.unknownKeys) {
+    case 'passthrough':
+      return refs.allowedAdditionalProperties;
+    case 'strict':
+      return refs.rejectedAdditionalProperties;
+    case 'strip':
+      return refs.removeAdditionalStrategy === 'strict'
+        ? refs.allowedAdditionalProperties
+        : refs.rejectedAdditionalProperties;
+  }
+}
+
+function safeIsOptional(schema: ZodTypeAny): boolean {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}

package/src/to-json-schema/zod3-to-json-schema/parsers/optional.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('Standalone optionals', () => {
+  it('should work as unions with undefined', () => {
+    const parsedSchema = parseDef(z.string().optional()._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      anyOf: [
+        {
+          not: {},
+        },
+        {
+          type: 'string',
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+
+  it('should work as unions with void', () => {
+    const parsedSchema = parseDef(z.void().optional()._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({} satisfies JSONSchema7);
+  });
+
+  it('should not affect object properties', () => {
+    const parsedSchema = parseDef(
+      z.object({ myProperty: z.string().optional() })._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        myProperty: {
+          type: 'string',
+        },
+      },
+      additionalProperties: false,
+    } satisfies JSONSchema7);
+  });
+
+  it('should work with nested properties', () => {
+    const parsedSchema = parseDef(
+      z.object({ myProperty: z.string().optional().array() })._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        myProperty: {
+          type: 'array',
+          items: {
+            anyOf: [{ not: {} }, { type: 'string' }],
+          },
+        },
+      },
+      required: ['myProperty'],
+      additionalProperties: false,
+    } satisfies JSONSchema7);
+  });
+
+  it('should work with nested properties as object properties', () => {
+    const parsedSchema = parseDef(
+      z.object({
+        myProperty: z.object({ myInnerProperty: z.string().optional() }),
+      })._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        myProperty: {
+          type: 'object',
+          properties: {
+            myInnerProperty: {
+              type: 'string',
+            },
+          },
+          additionalProperties: false,
+        },
+      },
+      required: ['myProperty'],
+      additionalProperties: false,
+    } satisfies JSONSchema7);
+  });
+
+  it('should work with nested properties with nested object property parents', () => {
+    const parsedSchema = parseDef(
+      z.object({
+        myProperty: z.object({
+          myInnerProperty: z.string().optional().array(),
+        }),
+      })._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      properties: {
+        myProperty: {
+          type: 'object',
+          properties: {
+            myInnerProperty: {
+              type: 'array',
+              items: {
+                anyOf: [
+                  { not: {} },
+                  {
+                    type: 'string',
+                  },
+                ],
+              },
+            },
+          },
+          required: ['myInnerProperty'],
+          additionalProperties: false,
+        },
+      },
+      required: ['myProperty'],
+      additionalProperties: false,
+    } satisfies JSONSchema7);
+  });
+
+  it('should work with ref pathing', () => {
+    const recurring = z.string();
+
+    const schema = z.tuple([recurring.optional(), recurring]);
+
+    const parsedSchema = parseDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'array',
+      minItems: 2,
+      maxItems: 2,
+      items: [
+        { anyOf: [{ not: {} }, { type: 'string' }] },
+        { $ref: '#/items/0/anyOf/1' },
+      ],
+    } satisfies JSONSchema7);
+  });
+});

package/src/to-json-schema/zod3-to-json-schema/parsers/optional.ts

@@ -0,0 +1,23 @@
+import { ZodOptionalDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+import { parseAnyDef } from './any';
+
+export const parseOptionalDef = (
+  def: ZodOptionalDef,
+  refs: Refs,
+): JsonSchema7Type | undefined => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef(def.innerType._def, refs);
+  }
+
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'anyOf', '1'],
+  });
+
+  return innerSchema
+    ? { anyOf: [{ not: parseAnyDef() }, innerSchema] }
+    : parseAnyDef();
+};