@ai-sdk/provider-utils 4.0.8 → 4.0.10

package/src/to-json-schema/zod3-to-json-schema/parse-def.test.ts

@@ -1,224 +0,0 @@
-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('parseDef', () => {
-  it('should return a proper json schema with some common types without validation', () => {
-    const zodSchema = z.object({
-      requiredString: z.string(),
-      optionalString: z.string().optional(),
-      literalString: z.literal('literalStringValue'),
-      stringArray: z.array(z.string()),
-      stringEnum: z.enum(['stringEnumOptionA', 'stringEnumOptionB']),
-      tuple: z.tuple([z.string(), z.number(), z.boolean()]),
-      record: z.record(z.boolean()),
-      requiredNumber: z.number(),
-      optionalNumber: z.number().optional(),
-      numberOrNull: z.number().nullable(),
-      numberUnion: z.union([z.literal(1), z.literal(2), z.literal(3)]),
-      mixedUnion: z.union([
-        z.literal('abc'),
-        z.literal(123),
-        z.object({ nowItGetsAnnoying: z.literal(true) }),
-      ]),
-      objectOrNull: z.object({ myString: z.string() }).nullable(),
-      passthrough: z.object({ myString: z.string() }).passthrough(),
-    });
-
-    const parsedSchema = parseDef(zodSchema._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        requiredString: {
-          type: 'string',
-        },
-        optionalString: {
-          type: 'string',
-        },
-        literalString: {
-          type: 'string',
-          const: 'literalStringValue',
-        },
-        stringArray: {
-          type: 'array',
-          items: {
-            type: 'string',
-          },
-        },
-        stringEnum: {
-          type: 'string',
-          enum: ['stringEnumOptionA', 'stringEnumOptionB'],
-        },
-        tuple: {
-          type: 'array',
-          minItems: 3,
-          items: [
-            {
-              type: 'string',
-            },
-            {
-              type: 'number',
-            },
-            {
-              type: 'boolean',
-            },
-          ],
-          maxItems: 3,
-        },
-        record: {
-          type: 'object',
-          additionalProperties: {
-            type: 'boolean',
-          },
-        },
-        requiredNumber: {
-          type: 'number',
-        },
-        optionalNumber: {
-          type: 'number',
-        },
-        numberOrNull: {
-          type: ['number', 'null'],
-        },
-        numberUnion: {
-          type: 'number',
-          enum: [1, 2, 3],
-        },
-        mixedUnion: {
-          anyOf: [
-            {
-              type: 'string',
-              const: 'abc',
-            },
-            {
-              type: 'number',
-              const: 123,
-            },
-            {
-              type: 'object',
-              properties: {
-                nowItGetsAnnoying: {
-                  type: 'boolean',
-                  const: true,
-                },
-              },
-              required: ['nowItGetsAnnoying'],
-              additionalProperties: false,
-            },
-          ],
-        },
-        objectOrNull: {
-          anyOf: [
-            {
-              type: 'object',
-              properties: {
-                myString: {
-                  type: 'string',
-                },
-              },
-              required: ['myString'],
-              additionalProperties: false,
-            },
-            {
-              type: 'null',
-            },
-          ],
-        },
-        passthrough: {
-          type: 'object',
-          properties: {
-            myString: {
-              type: 'string',
-            },
-          },
-          required: ['myString'],
-          additionalProperties: true,
-        },
-      },
-      required: [
-        'requiredString',
-        'literalString',
-        'stringArray',
-        'stringEnum',
-        'tuple',
-        'record',
-        'requiredNumber',
-        'numberOrNull',
-        'numberUnion',
-        'mixedUnion',
-        'objectOrNull',
-        'passthrough',
-      ],
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-
-  it('should handle a nullable string properly', () => {
-    const shorthand = z.string().nullable();
-    const union = z.union([z.string(), z.null()]);
-
-    expect(parseDef(shorthand._def, getRefs())).toStrictEqual({
-      type: ['string', 'null'],
-    } satisfies JSONSchema7);
-    expect(parseDef(union._def, getRefs())).toStrictEqual({
-      type: ['string', 'null'],
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to use branded string', () => {
-    const schema = z.string().brand<'x'>();
-    const parsedSchema = parseDef(schema._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'string',
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to use readonly', () => {
-    const parsedSchema = parseDef(z.object({}).readonly()._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {},
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to use catch', () => {
-    const parsedSchema = parseDef(z.number().catch(5)._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'number',
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to use pipeline', () => {
-    const schema = z.number().pipe(z.number().int());
-
-    expect(parseDef(schema._def, getRefs())).toStrictEqual({
-      allOf: [{ type: 'number' }, { type: 'integer' }],
-    } satisfies JSONSchema7);
-  });
-
-  it('should get undefined for function', () => {
-    const parsedSchema = parseDef(z.function()._def, getRefs());
-    expect(parsedSchema).toBeUndefined();
-  });
-
-  it('should get undefined for void', () => {
-    const parsedSchema = parseDef(z.void()._def, getRefs());
-    expect(parsedSchema).toBeUndefined();
-  });
-
-  it('nested lazy', () => {
-    const zodSchema = z.lazy(() => z.lazy(() => z.string()));
-    const parsed = parseDef(zodSchema._def, getRefs());
-
-    expect(parsed).toStrictEqual({
-      type: 'string',
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,98 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { JSONSchema7 } from '@ai-sdk/provider';
-import { z } from 'zod/v3';
-import { parseArrayDef } from './array';
-import { getRefs } from '../refs';
-
-describe('array', () => {
-  it('should be possible to describe a simple array', () => {
-    const parsedSchema = parseArrayDef(z.array(z.string())._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'array',
-      items: {
-        type: 'string',
-      },
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe a simple array with any item', () => {
-    const parsedSchema = parseArrayDef(z.array(z.any())._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'array',
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe a string array with a minimum and maximum length', () => {
-    const parsedSchema = parseArrayDef(
-      z.array(z.string()).min(2).max(4)._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'array',
-      items: {
-        type: 'string',
-      },
-      minItems: 2,
-      maxItems: 4,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe a string array with an exact length', () => {
-    const parsedSchema = parseArrayDef(
-      z.array(z.string()).length(5)._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'array',
-      items: {
-        type: 'string',
-      },
-      minItems: 5,
-      maxItems: 5,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe a string array with a minimum length of 1 by using nonempty', () => {
-    const parsedSchema = parseArrayDef(
-      z.array(z.any()).nonempty()._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'array',
-      minItems: 1,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible do properly reference array items', () => {
-    const willHaveBeenSeen = z.object({ hello: z.string() });
-    const unionSchema = z.union([willHaveBeenSeen, willHaveBeenSeen]);
-    const arraySchema = z.array(unionSchema);
-    const jsonSchema = parseArrayDef(arraySchema._def, getRefs());
-
-    expect(jsonSchema).toStrictEqual({
-      items: {
-        anyOf: [
-          {
-            additionalProperties: false,
-            properties: {
-              hello: {
-                type: 'string',
-              },
-            },
-            required: ['hello'],
-            type: 'object',
-          },
-          {
-            $ref: '#/items/anyOf/0',
-          },
-        ],
-      },
-      type: 'array',
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,51 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { JSONSchema7 } from '@ai-sdk/provider';
-import { z } from 'zod/v3';
-import { parseBigintDef } from './bigint';
-
-describe('bigint', () => {
-  it('should be possible to use bigint', () => {
-    const parsedSchema = parseBigintDef(z.bigint()._def);
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'integer',
-      format: 'int64',
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to define gt/lt', () => {
-    const parsedSchema = parseBigintDef(
-      z.bigint().gte(BigInt(10)).lte(BigInt(20))._def,
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'integer',
-      format: 'int64',
-      minimum: BigInt(10) as any, // json schema type does not support bigint
-      maximum: BigInt(20) as any, // json schema type does not support bigint
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to define gt/lt', () => {
-    const parsedSchema = parseBigintDef(
-      z.bigint().gt(BigInt(10)).lt(BigInt(20))._def,
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'integer',
-      format: 'int64',
-      exclusiveMinimum: BigInt(10) as any, // json schema type does not support bigint
-      exclusiveMaximum: BigInt(20) as any, // json schema type does not support bigint
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to define multipleOf', () => {
-    const parsedSchema = parseBigintDef(z.bigint().multipleOf(BigInt(5))._def);
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'integer',
-      format: 'int64',
-      multipleOf: BigInt(5) as any, // json schema type does not support bigint
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseBrandedDef } from './branded';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('branded', () => {
-  it('should be possible to use branded string', () => {
-    const schema = z.string().brand<'x'>();
-    const parsedSchema = parseBrandedDef(schema._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'string',
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,15 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseCatchDef } from './catch';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('catch', () => {
-  it('should be possible to use catch', () => {
-    const parsedSchema = parseCatchDef(z.number().catch(5)._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'number',
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,97 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseDateDef } from './date';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('Date validations', it => {
-  it('should be possible to date as a string type', () => {
-    const zodDateSchema = z.date();
-    const parsedSchemaWithOption = parseDateDef(
-      zodDateSchema._def,
-      getRefs({ dateStrategy: 'string' }),
-    );
-    const parsedSchemaFromDefault = parseDateDef(zodDateSchema._def, getRefs());
-
-    const jsonSchema: JSONSchema7 = {
-      type: 'string',
-      format: 'date-time',
-    };
-
-    expect(parsedSchemaWithOption).toStrictEqual(jsonSchema);
-    expect(parsedSchemaFromDefault).toStrictEqual(jsonSchema);
-  });
-
-  it('should be possible to describe minimum date', () => {
-    const zodDateSchema = z
-      .date()
-      .min(new Date('1970-01-02'), { message: 'Too old' });
-    const parsedSchema = parseDateDef(
-      zodDateSchema._def,
-      getRefs({ dateStrategy: 'integer' }),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'integer',
-      format: 'unix-time',
-      minimum: 86400000,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe maximum date', () => {
-    const zodDateSchema = z.date().max(new Date('1970-01-02'));
-    const parsedSchema = parseDateDef(
-      zodDateSchema._def,
-      getRefs({ dateStrategy: 'integer' }),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'integer',
-      format: 'unix-time',
-      maximum: 86400000,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe both maximum and minimum date', () => {
-    const zodDateSchema = z
-      .date()
-      .min(new Date('1970-01-02'))
-      .max(new Date('1972-01-02'));
-    const parsedSchema = parseDateDef(
-      zodDateSchema._def,
-      getRefs({ dateStrategy: 'integer' }),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'integer',
-      format: 'unix-time',
-      minimum: 86400000,
-      maximum: 63158400000,
-    } satisfies JSONSchema7);
-  });
-
-  it('multiple choices of strategy should result in anyOf', () => {
-    const zodDateSchema = z.date();
-    const parsedSchema = parseDateDef(
-      zodDateSchema._def,
-      getRefs({ dateStrategy: ['format:date-time', 'format:date', 'integer'] }),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      anyOf: [
-        {
-          type: 'string',
-          format: 'date-time',
-        },
-        {
-          type: 'string',
-          format: 'date',
-        },
-        {
-          type: 'integer',
-          format: 'unix-time',
-        },
-      ],
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseDefaultDef } from './default';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('default', () => {
-  it('should be possible to use default on objects', () => {
-    const parsedSchema = parseDefaultDef(
-      z.object({ foo: z.boolean() }).default({ foo: true })._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      additionalProperties: false,
-      required: ['foo'],
-      properties: {
-        foo: {
-          type: 'boolean',
-        },
-      },
-      default: {
-        foo: true,
-      },
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to use default on primitives', () => {
-    const parsedSchema = parseDefaultDef(
-      z.string().default('default')._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'string',
-      default: 'default',
-    } satisfies JSONSchema7);
-  });
-
-  it('default with transform', () => {
-    const stringWithDefault = z
-      .string()
-      .transform(val => val.toUpperCase())
-      .default('default');
-
-    const parsedSchema = parseDefaultDef(stringWithDefault._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'string',
-      default: 'default',
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,41 +0,0 @@
-import { describe, it, expect, test } from 'vitest';
-import { z } from 'zod/v3';
-import { parseEffectsDef } from './effects';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('effects', () => {
-  it('should be possible to use refine', () => {
-    const parsedSchema = parseEffectsDef(
-      z.number().refine(x => x + 1)._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'number',
-    } satisfies JSONSchema7);
-  });
-
-  it('should default to the input type', () => {
-    const schema = z.string().transform(arg => parseInt(arg));
-
-    const jsonSchema = parseEffectsDef(schema._def, getRefs());
-
-    expect(jsonSchema).toStrictEqual({
-      type: 'string',
-    } satisfies JSONSchema7);
-  });
-
-  test("should return object based on 'any' strategy", () => {
-    const schema = z.string().transform(arg => parseInt(arg));
-
-    const jsonSchema = parseEffectsDef(
-      schema._def,
-      getRefs({
-        effectStrategy: 'any',
-      }),
-    );
-
-    expect(jsonSchema).toStrictEqual({} satisfies JSONSchema7);
-  });
-});

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

@@ -1,92 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseIntersectionDef } from './intersection';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('intersection', () => {
-  it('should be possible to use intersections', () => {
-    const intersection = z.intersection(z.string().min(1), z.string().max(3));
-
-    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
-
-    expect(jsonSchema).toStrictEqual({
-      allOf: [
-        {
-          type: 'string',
-          minLength: 1,
-        },
-        {
-          type: 'string',
-          maxLength: 3,
-        },
-      ],
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to deref intersections', () => {
-    const schema = z.string();
-    const intersection = z.intersection(schema, schema);
-    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
-
-    expect(jsonSchema).toStrictEqual({
-      allOf: [
-        {
-          type: 'string',
-        },
-        {
-          $ref: '#/allOf/0',
-        },
-      ],
-    } satisfies JSONSchema7);
-  });
-
-  it('should return `unevaluatedProperties` only if all of the multiple sub-schemas have additionalProperties set to false', () => {
-    const schema1 = z.object({
-      foo: z.string(),
-    });
-    const schema2 = z.object({
-      bar: z.string(),
-    });
-    const schema3 = z
-      .object({
-        baz: z.string(),
-      })
-      .passthrough();
-    const intersection = schema1.and(schema2).and(schema3);
-    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
-
-    expect(jsonSchema).toStrictEqual({
-      allOf: [
-        {
-          properties: {
-            foo: {
-              type: 'string',
-            },
-          },
-          required: ['foo'],
-          type: 'object',
-        },
-        {
-          properties: {
-            bar: {
-              type: 'string',
-            },
-          },
-          required: ['bar'],
-          type: 'object',
-        },
-        {
-          additionalProperties: true,
-          properties: {
-            baz: {
-              type: 'string',
-            },
-          },
-          required: ['baz'],
-          type: 'object',
-        },
-      ],
-    } satisfies JSONSchema7);
-  });
-});