@ai-sdk/provider-utils 4.0.5 → 4.0.6

package/src/schema.ts

@@ -0,0 +1,267 @@
+import { JSONSchema7, TypeValidationError } from '@ai-sdk/provider';
+import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
+import * as z3 from 'zod/v3';
+import * as z4 from 'zod/v4';
+import { addAdditionalPropertiesToJsonSchema } from './add-additional-properties-to-json-schema';
+import { zod3ToJsonSchema } from './to-json-schema/zod3-to-json-schema';
+
+/**
+ * Used to mark schemas so we can support both Zod and custom schemas.
+ */
+const schemaSymbol = Symbol.for('vercel.ai.schema');
+
+export type ValidationResult<OBJECT> =
+  | { success: true; value: OBJECT }
+  | { success: false; error: Error };
+
+export type Schema<OBJECT = unknown> = {
+  /**
+   * Used to mark schemas so we can support both Zod and custom schemas.
+   */
+  [schemaSymbol]: true;
+
+  /**
+   * Schema type for inference.
+   */
+  _type: OBJECT;
+
+  /**
+   * Optional. Validates that the structure of a value matches this schema,
+   * and returns a typed version of the value if it does.
+   */
+  readonly validate?: (
+    value: unknown,
+  ) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
+
+  /**
+   * The JSON Schema for the schema. It is passed to the providers.
+   */
+  readonly jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7>;
+};
+
+/**
+ * Creates a schema with deferred creation.
+ * This is important to reduce the startup time of the library
+ * and to avoid initializing unused validators.
+ *
+ * @param createValidator A function that creates a schema.
+ * @returns A function that returns a schema.
+ */
+export function lazySchema<SCHEMA>(
+  createSchema: () => Schema<SCHEMA>,
+): LazySchema<SCHEMA> {
+  // cache the validator to avoid initializing it multiple times
+  let schema: Schema<SCHEMA> | undefined;
+  return () => {
+    if (schema == null) {
+      schema = createSchema();
+    }
+    return schema;
+  };
+}
+
+export type LazySchema<SCHEMA> = () => Schema<SCHEMA>;
+
+export type ZodSchema<SCHEMA = any> =
+  | z3.Schema<SCHEMA, z3.ZodTypeDef, any>
+  | z4.core.$ZodType<SCHEMA, any>;
+
+export type StandardSchema<SCHEMA = any> = StandardSchemaV1<unknown, SCHEMA> &
+  StandardJSONSchemaV1<unknown, SCHEMA>;
+
+export type FlexibleSchema<SCHEMA = any> =
+  | Schema<SCHEMA>
+  | LazySchema<SCHEMA>
+  | ZodSchema<SCHEMA>
+  | StandardSchema<SCHEMA>;
+
+export type InferSchema<SCHEMA> =
+  SCHEMA extends ZodSchema<infer T>
+    ? T
+    : SCHEMA extends StandardSchema<infer T>
+      ? T
+      : SCHEMA extends LazySchema<infer T>
+        ? T
+        : SCHEMA extends Schema<infer T>
+          ? T
+          : never;
+
+/**
+ * Create a schema using a JSON Schema.
+ *
+ * @param jsonSchema The JSON Schema for the schema.
+ * @param options.validate Optional. A validation function for the schema.
+ */
+export function jsonSchema<OBJECT = unknown>(
+  jsonSchema:
+    | JSONSchema7
+    | PromiseLike<JSONSchema7>
+    | (() => JSONSchema7 | PromiseLike<JSONSchema7>),
+  {
+    validate,
+  }: {
+    validate?: (
+      value: unknown,
+    ) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
+  } = {},
+): Schema<OBJECT> {
+  return {
+    [schemaSymbol]: true,
+    _type: undefined as OBJECT, // should never be used directly
+    get jsonSchema() {
+      if (typeof jsonSchema === 'function') {
+        jsonSchema = jsonSchema(); // cache the function results
+      }
+      return jsonSchema;
+    },
+    validate,
+  };
+}
+
+function isSchema(value: unknown): value is Schema {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    schemaSymbol in value &&
+    value[schemaSymbol] === true &&
+    'jsonSchema' in value &&
+    'validate' in value
+  );
+}
+
+export function asSchema<OBJECT>(
+  schema: FlexibleSchema<OBJECT> | undefined,
+): Schema<OBJECT> {
+  return schema == null
+    ? jsonSchema({ properties: {}, additionalProperties: false })
+    : isSchema(schema)
+      ? schema
+      : '~standard' in schema
+        ? schema['~standard'].vendor === 'zod'
+          ? zodSchema(schema as ZodSchema<OBJECT>)
+          : standardSchema(schema as StandardSchema<OBJECT>)
+        : schema();
+}
+
+function standardSchema<OBJECT>(
+  standardSchema: StandardSchema<OBJECT>,
+): Schema<OBJECT> {
+  return jsonSchema(
+    () =>
+      addAdditionalPropertiesToJsonSchema(
+        standardSchema['~standard'].jsonSchema.input({
+          target: 'draft-07',
+        }) as JSONSchema7,
+      ),
+    {
+      validate: async value => {
+        const result = await standardSchema['~standard'].validate(value);
+        return 'value' in result
+          ? { success: true, value: result.value }
+          : {
+              success: false,
+              error: new TypeValidationError({
+                value,
+                cause: result.issues,
+              }),
+            };
+      },
+    },
+  );
+}
+
+export function zod3Schema<OBJECT>(
+  zodSchema: z3.Schema<OBJECT, z3.ZodTypeDef, any>,
+  options?: {
+    /**
+     * Enables support for references in the schema.
+     * This is required for recursive schemas, e.g. with `z.lazy`.
+     * However, not all language models and providers support such references.
+     * Defaults to `false`.
+     */
+    useReferences?: boolean;
+  },
+): Schema<OBJECT> {
+  // default to no references (to support openapi conversion for google)
+  const useReferences = options?.useReferences ?? false;
+
+  return jsonSchema(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () =>
+      zod3ToJsonSchema(zodSchema, {
+        $refStrategy: useReferences ? 'root' : 'none',
+      }) as JSONSchema7,
+    {
+      validate: async value => {
+        const result = await zodSchema.safeParseAsync(value);
+        return result.success
+          ? { success: true, value: result.data }
+          : { success: false, error: result.error };
+      },
+    },
+  );
+}
+
+export function zod4Schema<OBJECT>(
+  zodSchema: z4.core.$ZodType<OBJECT, any>,
+  options?: {
+    /**
+     * Enables support for references in the schema.
+     * This is required for recursive schemas, e.g. with `z.lazy`.
+     * However, not all language models and providers support such references.
+     * Defaults to `false`.
+     */
+    useReferences?: boolean;
+  },
+): Schema<OBJECT> {
+  // default to no references (to support openapi conversion for google)
+  const useReferences = options?.useReferences ?? false;
+
+  return jsonSchema(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () =>
+      addAdditionalPropertiesToJsonSchema(
+        z4.toJSONSchema(zodSchema, {
+          target: 'draft-7',
+          io: 'input',
+          reused: useReferences ? 'ref' : 'inline',
+        }) as JSONSchema7,
+      ),
+    {
+      validate: async value => {
+        const result = await z4.safeParseAsync(zodSchema, value);
+        return result.success
+          ? { success: true, value: result.data }
+          : { success: false, error: result.error };
+      },
+    },
+  );
+}
+
+export function isZod4Schema(
+  zodSchema: z4.core.$ZodType<any, any> | z3.Schema<any, z3.ZodTypeDef, any>,
+): zodSchema is z4.core.$ZodType<any, any> {
+  // https://zod.dev/library-authors?id=how-to-support-zod-3-and-zod-4-simultaneously
+  return '_zod' in zodSchema;
+}
+
+export function zodSchema<OBJECT>(
+  zodSchema:
+    | z4.core.$ZodType<OBJECT, any>
+    | z3.Schema<OBJECT, z3.ZodTypeDef, any>,
+  options?: {
+    /**
+     * Enables support for references in the schema.
+     * This is required for recursive schemas, e.g. with `z.lazy`.
+     * However, not all language models and providers support such references.
+     * Defaults to `false`.
+     */
+    useReferences?: boolean;
+  },
+): Schema<OBJECT> {
+  if (isZod4Schema(zodSchema)) {
+    return zod4Schema(zodSchema, options);
+  } else {
+    return zod3Schema(zodSchema, options);
+  }
+}

package/src/secure-json-parse.test.ts

@@ -0,0 +1,59 @@
+// Licensed under BSD-3-Clause (this file only)
+// Code adapted from https://github.com/fastify/secure-json-parse/blob/783fcb1b5434709466759847cec974381939673a/test/index.test.js
+//
+// Copyright (c) Vercel, Inc. (https://vercel.com)
+// Copyright (c) 2019 The Fastify Team
+// Copyright (c) 2019, Sideway Inc, and project contributors
+// All rights reserved.
+//
+// The complete list of contributors can be found at:
+// - https://github.com/hapijs/bourne/graphs/contributors
+// - https://github.com/fastify/secure-json-parse/graphs/contributors
+// - https://github.com/vercel/ai/commits/main/packages/provider-utils/src/secure-parse-json.test.ts
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import { describe, it, expect } from 'vitest';
+import { secureJsonParse } from './secure-json-parse';
+
+describe('secureJsonParse', () => {
+  it('parses object string', () => {
+    expect(secureJsonParse('{"a": 5, "b": 6}')).toStrictEqual(
+      JSON.parse('{"a": 5, "b": 6}'),
+    );
+  });
+
+  it('parses null string', () => {
+    expect(secureJsonParse('null')).toStrictEqual(JSON.parse('null'));
+  });
+
+  it('parses 0 string', () => {
+    expect(secureJsonParse('0')).toStrictEqual(JSON.parse('0'));
+  });
+
+  it('parses string string', () => {
+    expect(secureJsonParse('"X"')).toStrictEqual(JSON.parse('"X"'));
+  });
+
+  it('errors on constructor property', () => {
+    const text =
+      '{ "a": 5, "b": 6, "constructor": { "x": 7 }, "c": { "d": 0, "e": "text", "__proto__": { "y": 8 }, "f": { "g": 2 } } }';
+
+    expect(() => secureJsonParse(text)).toThrow(SyntaxError);
+  });
+
+  it('errors on proto property', () => {
+    const text =
+      '{ "a": 5, "b": 6, "__proto__": { "x": 7 }, "c": { "d": 0, "e": "text", "__proto__": { "y": 8 }, "f": { "g": 2 } } }';
+
+    expect(() => secureJsonParse(text)).toThrow(SyntaxError);
+  });
+});

package/src/secure-json-parse.ts

@@ -0,0 +1,92 @@
+// Licensed under BSD-3-Clause (this file only)
+// Code adapted from https://github.com/fastify/secure-json-parse/blob/783fcb1b5434709466759847cec974381939673a/index.js
+//
+// Copyright (c) Vercel, Inc. (https://vercel.com)
+// Copyright (c) 2019 The Fastify Team
+// Copyright (c) 2019, Sideway Inc, and project contributors
+// All rights reserved.
+//
+// The complete list of contributors can be found at:
+// - https://github.com/hapijs/bourne/graphs/contributors
+// - https://github.com/fastify/secure-json-parse/graphs/contributors
+// - https://github.com/vercel/ai/commits/main/packages/provider-utils/src/secure-parse-json.ts
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+const suspectProtoRx = /"__proto__"\s*:/;
+const suspectConstructorRx = /"constructor"\s*:/;
+
+function _parse(text: string) {
+  // Parse normally
+  const obj = JSON.parse(text);
+
+  // Ignore null and non-objects
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (
+    suspectProtoRx.test(text) === false &&
+    suspectConstructorRx.test(text) === false
+  ) {
+    return obj;
+  }
+
+  // Scan result for proto keys
+  return filter(obj);
+}
+
+function filter(obj: any) {
+  let next = [obj];
+
+  while (next.length) {
+    const nodes = next;
+    next = [];
+
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, '__proto__')) {
+        throw new SyntaxError('Object contains forbidden prototype property');
+      }
+
+      if (
+        Object.prototype.hasOwnProperty.call(node, 'constructor') &&
+        Object.prototype.hasOwnProperty.call(node.constructor, 'prototype')
+      ) {
+        throw new SyntaxError('Object contains forbidden prototype property');
+      }
+
+      for (const key in node) {
+        const value = node[key];
+        if (value && typeof value === 'object') {
+          next.push(value);
+        }
+      }
+    }
+  }
+  return obj;
+}
+
+export function secureJsonParse(text: string) {
+  const { stackTraceLimit } = Error;
+  try {
+    // Performance optimization, see https://github.com/fastify/secure-json-parse/pull/90
+    Error.stackTraceLimit = 0;
+  } catch (e) {
+    // Fallback in case Error is immutable (v8 readonly)
+    return _parse(text);
+  }
+
+  try {
+    return _parse(text);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+}

package/src/test/convert-array-to-async-iterable.ts

@@ -0,0 +1,9 @@
+export function convertArrayToAsyncIterable<T>(values: T[]): AsyncIterable<T> {
+  return {
+    async *[Symbol.asyncIterator]() {
+      for (const value of values) {
+        yield value;
+      }
+    },
+  };
+}

package/src/test/convert-array-to-readable-stream.ts

@@ -0,0 +1,15 @@
+export function convertArrayToReadableStream<T>(
+  values: T[],
+): ReadableStream<T> {
+  return new ReadableStream({
+    start(controller) {
+      try {
+        for (const value of values) {
+          controller.enqueue(value);
+        }
+      } finally {
+        controller.close();
+      }
+    },
+  });
+}

package/src/test/convert-async-iterable-to-array.ts

@@ -0,0 +1,9 @@
+export async function convertAsyncIterableToArray<T>(
+  iterable: AsyncIterable<T>,
+): Promise<T[]> {
+  const result: T[] = [];
+  for await (const item of iterable) {
+    result.push(item);
+  }
+  return result;
+}

package/src/test/convert-readable-stream-to-array.ts

@@ -0,0 +1,14 @@
+export async function convertReadableStreamToArray<T>(
+  stream: ReadableStream<T>,
+): Promise<T[]> {
+  const reader = stream.getReader();
+  const result: T[] = [];
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    result.push(value);
+  }
+
+  return result;
+}

package/src/test/convert-response-stream-to-array.ts

@@ -0,0 +1,9 @@
+import { convertReadableStreamToArray } from './convert-readable-stream-to-array';
+
+export async function convertResponseStreamToArray(
+  response: Response,
+): Promise<string[]> {
+  return convertReadableStreamToArray(
+    response.body!.pipeThrough(new TextDecoderStream()),
+  );
+}

package/src/test/index.ts

@@ -0,0 +1,7 @@
+export * from './convert-array-to-async-iterable';
+export * from './convert-array-to-readable-stream';
+export * from './convert-async-iterable-to-array';
+export * from './convert-readable-stream-to-array';
+export * from './convert-response-stream-to-array';
+export * from './is-node-version';
+export * from './mock-id';

package/src/test/is-node-version.ts

@@ -0,0 +1,4 @@
+export function isNodeVersion(version: number) {
+  const nodeMajorVersion = parseInt(process.version.slice(1).split('.')[0], 10);
+  return nodeMajorVersion === version;
+}

package/src/test/mock-id.ts

@@ -0,0 +1,8 @@
+export function mockId({
+  prefix = 'id',
+}: {
+  prefix?: string;
+} = {}): () => string {
+  let counter = 0;
+  return () => `${prefix}-${counter++}`;
+}

package/src/to-json-schema/zod3-to-json-schema/LICENSE

@@ -0,0 +1,16 @@
+ISC License
+
+Copyright (c) 2020, Stefan Terdell
+Copyright (c) 2025, Vercel Inc.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/src/to-json-schema/zod3-to-json-schema/README.md

@@ -0,0 +1,24 @@
+# `zod-to-json-schema`
+
+Originally copied from https://github.com/StefanTerdell/zod-to-json-schema because its `peerDependency` on `"zod": "^3.24.1"` while `ai` needs to support `zod@4` if users already use it. We want to avoid having both `zod@3` and `zod@4` in the dependency tree of our users.
+
+The code in this directory and sub-directories is released under the ISC license:
+
+```
+ISC License
+
+Copyright (c) 2020, Stefan Terdell
+Copyright (c) 2025, Vercel Inc.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+```

package/src/to-json-schema/zod3-to-json-schema/get-relative-path.ts

@@ -0,0 +1,7 @@
+export const getRelativePath = (pathA: string[], pathB: string[]) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i]) break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join('/');
+};

package/src/to-json-schema/zod3-to-json-schema/index.ts

@@ -0,0 +1 @@
+export { zod3ToJsonSchema } from './zod3-to-json-schema';

package/src/to-json-schema/zod3-to-json-schema/options.ts

@@ -0,0 +1,98 @@
+import { ZodSchema, ZodTypeDef } from 'zod/v3';
+import { Refs, Seen } from './refs';
+import { JsonSchema7Type } from './parse-types';
+
+export type DateStrategy =
+  | 'format:date-time'
+  | 'format:date'
+  | 'string'
+  | 'integer';
+
+export const ignoreOverride = Symbol(
+  'Let zodToJsonSchema decide on which parser to use',
+);
+
+export type OverrideCallback = (
+  def: ZodTypeDef,
+  refs: Refs,
+  seen: Seen | undefined,
+  forceResolution?: boolean,
+) => JsonSchema7Type | undefined | typeof ignoreOverride;
+
+export type PostProcessCallback = (
+  jsonSchema: JsonSchema7Type | undefined,
+  def: ZodTypeDef,
+  refs: Refs,
+) => JsonSchema7Type | undefined;
+
+export const jsonDescription: PostProcessCallback = (jsonSchema, def) => {
+  if (def.description) {
+    try {
+      return {
+        ...jsonSchema,
+        ...JSON.parse(def.description),
+      };
+    } catch {}
+  }
+
+  return jsonSchema;
+};
+
+export type Options = {
+  name: string | undefined;
+  $refStrategy: 'root' | 'relative' | 'none' | 'seen';
+  basePath: string[];
+  effectStrategy: 'input' | 'any';
+  pipeStrategy: 'input' | 'output' | 'all';
+  dateStrategy: DateStrategy | DateStrategy[];
+  mapStrategy: 'entries' | 'record';
+  removeAdditionalStrategy: 'passthrough' | 'strict';
+  allowedAdditionalProperties: true | undefined;
+  rejectedAdditionalProperties: false | undefined;
+  strictUnions: boolean;
+  definitionPath: string;
+  definitions: Record<string, ZodSchema>;
+  errorMessages: boolean;
+  patternStrategy: 'escape' | 'preserve';
+  applyRegexFlags: boolean;
+  emailStrategy: 'format:email' | 'format:idn-email' | 'pattern:zod';
+  base64Strategy: 'format:binary' | 'contentEncoding:base64' | 'pattern:zod';
+  nameStrategy: 'ref' | 'title';
+  override?: OverrideCallback;
+  postProcess?: PostProcessCallback;
+};
+
+export const defaultOptions: Options = {
+  name: undefined,
+  $refStrategy: 'root',
+  basePath: ['#'],
+  effectStrategy: 'input',
+  pipeStrategy: 'all',
+  dateStrategy: 'format:date-time',
+  mapStrategy: 'entries',
+  removeAdditionalStrategy: 'passthrough',
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: 'definitions',
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  patternStrategy: 'escape',
+  applyRegexFlags: false,
+  emailStrategy: 'format:email',
+  base64Strategy: 'contentEncoding:base64',
+  nameStrategy: 'ref',
+};
+
+export const getDefaultOptions = (
+  options: Partial<Options> | string | undefined,
+) =>
+  (typeof options === 'string'
+    ? {
+        ...defaultOptions,
+        name: options,
+      }
+    : {
+        ...defaultOptions,
+        ...options,
+      }) as Options;