openai 7.3.0 → 7.5.0

package/src/_vendor/zod-to-json-schema/parsers/set.ts

@@ -1,7 +1,9 @@
-import { ZodSetDef } from 'zod/v3';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodSetDef } from 'zod/v3';
+import type { ErrorMessages } from '../errorMessages';
+import { setResponseValueAndErrors } from '../errorMessages';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 export type JsonSchema7SetType = {
   type: 'array';

package/src/_vendor/zod-to-json-schema/parsers/string.ts

@@ -1,7 +1,8 @@
 // @ts-nocheck
-import { ZodStringDef } from 'zod/v3';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { Refs } from '../Refs';
+import type { ZodStringDef } from 'zod/v3';
+import type { ErrorMessages } from '../errorMessages';
+import { setResponseValueAndErrors } from '../errorMessages';
+import type { Refs } from '../Refs';
 
 let emojiRegex: RegExp | undefined;
 
@@ -21,7 +22,7 @@ export const zodPatterns = {
   /**
    * `a-z` was added to replicate /i flag
    */
-  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9-]*\.)+[a-zA-Z]{2,}$/,
   /**
    * Constructed a valid Unicode RegExp
    *
@@ -35,7 +36,8 @@ export const zodPatterns = {
    */
   emoji: () => {
     if (emojiRegex === undefined) {
-      emojiRegex = RegExp('^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$', 'u');
+      const emojiPattern = '^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$';
+      emojiRegex = new RegExp(emojiPattern, 'u');
     }
     return emojiRegex;
   },
@@ -95,7 +97,7 @@ export function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7String
   if (def.checks) {
     for (const check of def.checks) {
       switch (check.kind) {
-        case 'min':
+        case 'min': {
           setResponseValueAndErrors(
             res,
             'minLength',
@@ -104,7 +106,8 @@ export function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7String
             refs,
           );
           break;
-        case 'max':
+        }
+        case 'max': {
           setResponseValueAndErrors(
             res,
             'maxLength',
@@ -114,55 +117,71 @@ export function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7String
           );
 
           break;
-        case 'email':
+        }
+        case 'email': {
           switch (refs.emailStrategy) {
-            case 'format:email':
+            case 'format:email': {
               addFormat(res, 'email', check.message, refs);
               break;
-            case 'format:idn-email':
+            }
+            case 'format:idn-email': {
               addFormat(res, 'idn-email', check.message, refs);
               break;
-            case 'pattern:zod':
+            }
+            case 'pattern:zod': {
               addPattern(res, zodPatterns.email, check.message, refs);
               break;
+            }
           }
 
           break;
-        case 'url':
+        }
+        case 'url': {
           addFormat(res, 'uri', check.message, refs);
           break;
-        case 'uuid':
+        }
+        case 'uuid': {
           addFormat(res, 'uuid', check.message, refs);
           break;
-        case 'regex':
+        }
+        case 'regex': {
           addPattern(res, check.regex, check.message, refs);
           break;
-        case 'cuid':
+        }
+        case 'cuid': {
           addPattern(res, zodPatterns.cuid, check.message, refs);
           break;
-        case 'cuid2':
+        }
+        case 'cuid2': {
           addPattern(res, zodPatterns.cuid2, check.message, refs);
           break;
-        case 'startsWith':
-          addPattern(res, RegExp(`^${processPattern(check.value)}`), check.message, refs);
+        }
+        case 'startsWith': {
+          addPattern(res, new RegExp(`^${processPattern(check.value)}`), check.message, refs);
           break;
-        case 'endsWith':
-          addPattern(res, RegExp(`${processPattern(check.value)}$`), check.message, refs);
+        }
+        case 'endsWith': {
+          addPattern(res, new RegExp(`${processPattern(check.value)}$`), check.message, refs);
           break;
+        }
 
-        case 'datetime':
+        case 'datetime': {
           addFormat(res, 'date-time', check.message, refs);
           break;
-        case 'date':
+        }
+        case 'date': {
           addFormat(res, 'date', check.message, refs);
           break;
-        case 'time':
+        }
+        case 'time': {
           addFormat(res, 'time', check.message, refs);
           break;
-        case 'duration':
+        }
+        case 'duration': {
           addFormat(res, 'duration', check.message, refs);
           break;
-        case 'length':
+        }
+        case 'length': {
           setResponseValueAndErrors(
             res,
             'minLength',
@@ -178,8 +197,9 @@ export function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7String
             refs,
           );
           break;
+        }
         case 'includes': {
-          addPattern(res, RegExp(processPattern(check.value)), check.message, refs);
+          addPattern(res, new RegExp(processPattern(check.value)), check.message, refs);
           break;
         }
         case 'ip': {
@@ -191,9 +211,10 @@ export function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7String
           }
           break;
         }
-        case 'emoji':
+        case 'emoji': {
           addPattern(res, zodPatterns.emoji, check.message, refs);
           break;
+        }
         case 'ulid': {
           addPattern(res, zodPatterns.ulid, check.message, refs);
           break;
@@ -219,13 +240,16 @@ export function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7String
         }
         case 'nanoid': {
           addPattern(res, zodPatterns.nanoid, check.message, refs);
+          break;
         }
         case 'toLowerCase':
         case 'toUpperCase':
-        case 'trim':
+        case 'trim': {
           break;
-        default:
-          ((_: never) => {})(check);
+        }
+        default: {
+          ((_: never) => undefined)(check);
+        }
       }
     }
   }
@@ -234,9 +258,7 @@ export function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7String
 }
 
 const escapeNonAlphaNumeric = (value: string) =>
-  Array.from(value)
-    .map((c) => (/[a-zA-Z0-9]/.test(c) ? c : `\\${c}`))
-    .join('');
+  [...value].map((c) => (/[a-zA-Z0-9]/.test(c) ? c : `\\${c}`)).join('');
 
 const addFormat = (
   schema: JsonSchema7StringType,
@@ -315,7 +337,9 @@ const addPattern = (
 // Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true
 const processRegExp = (regexOrFunction: RegExp | (() => RegExp), refs: Refs): string => {
   const regex = typeof regexOrFunction === 'function' ? regexOrFunction() : regexOrFunction;
-  if (!refs.applyRegexFlags || !regex.flags) return regex.source;
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
 
   // Currently handled flags
   const flags = {
@@ -341,7 +365,7 @@ const processRegExp = (regexOrFunction: RegExp | (() => RegExp), refs: Refs): st
 
     if (flags.i) {
       if (inCharGroup) {
-        if (source[i].match(/[a-z]/)) {
+        if (/[a-z]/.test(source[i])) {
           if (inCharRange) {
             pattern += source[i];
             pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
@@ -354,7 +378,7 @@ const processRegExp = (regexOrFunction: RegExp | (() => RegExp), refs: Refs): st
           }
           continue;
         }
-      } else if (source[i].match(/[a-z]/)) {
+      } else if (/[a-z]/.test(source[i])) {
         pattern += `[${source[i]}${source[i].toUpperCase()}]`;
         continue;
       }

package/src/_vendor/zod-to-json-schema/parsers/tuple.ts

@@ -1,6 +1,7 @@
-import { ZodTupleDef, ZodTupleItems, ZodTypeAny } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodTupleDef, ZodTupleItems, ZodTypeAny } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 export type JsonSchema7TupleType = {
   type: 'array';
@@ -30,25 +31,24 @@ export function parseTupleDef(
             currentPath: [...refs.currentPath, 'items', `${i}`],
           }),
         )
-        .reduce((acc: JsonSchema7Type[], x) => (x === undefined ? acc : [...acc, x]), []),
+        .filter((x): x is JsonSchema7Type => x !== undefined),
       additionalItems: parseDef(def.rest._def, {
         ...refs,
         currentPath: [...refs.currentPath, 'additionalItems'],
       }),
     };
-  } else {
-    return {
-      type: 'array',
-      minItems: def.items.length,
-      maxItems: def.items.length,
-      items: def.items
-        .map((x, i) =>
-          parseDef(x._def, {
-            ...refs,
-            currentPath: [...refs.currentPath, 'items', `${i}`],
-          }),
-        )
-        .reduce((acc: JsonSchema7Type[], x) => (x === undefined ? acc : [...acc, x]), []),
-    };
   }
+  return {
+    type: 'array',
+    minItems: def.items.length,
+    maxItems: def.items.length,
+    items: def.items
+      .map((x, i) =>
+        parseDef(x._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, 'items', `${i}`],
+        }),
+      )
+      .filter((x): x is JsonSchema7Type => x !== undefined),
+  };
 }

package/src/_vendor/zod-to-json-schema/parsers/union.ts

@@ -1,6 +1,7 @@
-import { ZodDiscriminatedUnionDef, ZodLiteralDef, ZodTypeAny, ZodUnionDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodDiscriminatedUnionDef, ZodLiteralDef, ZodTypeAny, ZodUnionDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 export const primitiveMappings = {
   ZodString: 'string',
@@ -31,10 +32,11 @@ export function parseUnionDef(
   def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>,
   refs: Refs,
 ): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined {
-  if (refs.target === 'openApi3') return asAnyOf(def, refs);
+  if (refs.target === 'openApi3') {
+    return asAnyOf(def, refs);
+  }
 
-  const options: readonly ZodTypeAny[] =
-    def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  const options: readonly ZodTypeAny[] = def.options instanceof Map ? [...def.options.values()] : def.options;
 
   // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.
   if (
@@ -42,10 +44,13 @@ export function parseUnionDef(
   ) {
     // all types in union are primitive and lack checks, so might as well squash into {type: [...]}
 
-    const types = options.reduce((types: JsonSchema7Primitive[], x) => {
+    const types: JsonSchema7Primitive[] = [];
+    for (const x of options) {
       const type = primitiveMappings[x._def.typeName as ZodPrimitive]; //Can be safely casted due to row 43
-      return type && !types.includes(type) ? [...types, type] : types;
-    }, []);
+      if (type && !types.includes(type)) {
+        types.push(type);
+      }
+    }
 
     return {
       type: types.length > 1 ? types : types[0]!,
@@ -53,46 +58,56 @@ export function parseUnionDef(
   } else if (options.every((x) => x._def.typeName === 'ZodLiteral' && !x.description)) {
     // all options literals
 
-    const types = options.reduce((acc: JsonSchema7Primitive[], x: { _def: ZodLiteralDef }) => {
+    const types: JsonSchema7Primitive[] = [];
+    for (const x of options as readonly { _def: ZodLiteralDef }[]) {
       const type = typeof x._def.value;
       switch (type) {
         case 'string':
         case 'number':
-        case 'boolean':
-          return [...acc, type];
-        case 'bigint':
-          return [...acc, 'integer' as const];
-        case 'object':
-          if (x._def.value === null) return [...acc, 'null' as const];
-        case 'symbol':
-        case 'undefined':
-        case 'function':
-        default:
-          return acc;
+        case 'boolean': {
+          types.push(type);
+          break;
+        }
+        case 'bigint': {
+          types.push('integer');
+          break;
+        }
+        case 'object': {
+          if (x._def.value === null) {
+            types.push('null');
+          }
+          break;
+        }
       }
-    }, []);
+    }
 
     if (types.length === options.length) {
       // all the literals are primitive, as far as null can be considered primitive
 
       const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      const enumValues: (string | number | bigint | boolean | null)[] = [];
+      for (const x of options) {
+        if (!enumValues.includes(x._def.value)) {
+          enumValues.push(x._def.value);
+        }
+      }
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0]!,
-        enum: options.reduce(
-          (acc, x) => {
-            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-          },
-          [] as (string | number | bigint | boolean | null)[],
-        ),
+        enum: enumValues,
       };
     }
   } else if (options.every((x) => x._def.typeName === 'ZodEnum')) {
+    const enumValues: string[] = [];
+    for (const x of options) {
+      for (const value of x._def.values) {
+        if (!enumValues.includes(value)) {
+          enumValues.push(value);
+        }
+      }
+    }
     return {
       type: 'string',
-      enum: options.reduce(
-        (acc: string[], x) => [...acc, ...x._def.values.filter((x: string) => !acc.includes(x))],
-        [],
-      ),
+      enum: enumValues,
     };
   }
 
@@ -103,7 +118,7 @@ const asAnyOf = (
   def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>,
   refs: Refs,
 ): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined => {
-  const anyOf = ((def.options instanceof Map ? Array.from(def.options.values()) : def.options) as any[])
+  const anyOf = ((def.options instanceof Map ? [...def.options.values()] : def.options) as any[])
     .map((x, i) =>
       parseDef(x._def, {
         ...refs,

package/src/_vendor/zod-to-json-schema/util.ts

@@ -1,11 +1,15 @@
 import type { ZodSchema, ZodTypeDef } from 'zod/v3';
 
-export const zodDef = (zodSchema: ZodSchema | ZodTypeDef): ZodTypeDef => {
-  return '_def' in zodSchema ? zodSchema._def : zodSchema;
-};
+export const zodDef = (zodSchema: ZodSchema | ZodTypeDef): ZodTypeDef =>
+  '_def' in zodSchema ? zodSchema._def : zodSchema;
 
-export function isEmptyObj(obj: Object | null | undefined): boolean {
-  if (!obj) return true;
-  for (const _k in obj) return false;
+export function isEmptyObj(obj: object | null | undefined): boolean {
+  if (!obj) {
+    return true;
+  }
+  // oxlint-disable-next-line guard-for-in -- inherited enumerable properties make the object non-empty
+  for (const _k in obj) {
+    return false;
+  }
   return true;
 }

package/src/_vendor/zod-to-json-schema/zodToJsonSchema.ts

@@ -1,43 +1,115 @@
-import { ZodSchema } from 'zod/v3';
-import { Options, Targets } from './Options';
-import { JsonSchema7Type, parseDef } from './parseDef';
+import type { ZodSchema } from 'zod/v3';
+import type { Options, Targets } from './Options';
+import type { JsonSchema7Type } from './parseDef';
+import { parseDef } from './parseDef';
 import { getRefs } from './Refs';
 import { zodDef, isEmptyObj } from './util';
 
+function ownStrictRootSchema(
+  schema: unknown,
+  name: string | undefined,
+  nameStrategy: string,
+): JsonSchema7Type {
+  if (schema === null || typeof schema !== 'object') {
+    throw new TypeError('Root schema must be a plain JSON-schema record');
+  }
+
+  const prototype = Object.getPrototypeOf(schema) as object | null;
+  if (![null, Object.prototype].includes(prototype)) {
+    throw new TypeError('Root schema must be a plain JSON-schema record');
+  }
+
+  const owned: Record<string, unknown> = {};
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(schema))) {
+    if (!descriptor.enumerable) {
+      continue;
+    }
+    if (!('value' in descriptor)) {
+      throw new TypeError(`Root schema property '${key}' must be a data property`);
+    }
+
+    const value: unknown = descriptor.value;
+    if (key === 'toJSON' && typeof value === 'function') {
+      throw new TypeError("Root schema cannot contain a callable 'toJSON' property");
+    }
+    if (['undefined', 'function', 'symbol'].includes(typeof value)) {
+      continue;
+    }
+
+    Object.defineProperty(owned, key, {
+      configurable: true,
+      enumerable: true,
+      value,
+      writable: true,
+    });
+  }
+
+  const { type, nullable, $ref: reference } = owned;
+  if (!['undefined', 'boolean'].includes(typeof nullable)) {
+    throw new TypeError("Root schema 'nullable' must be a boolean");
+  }
+  if (type !== 'object' || nullable === true) {
+    let actualType: string | undefined;
+    if (typeof type === 'string') {
+      actualType = nullable === true ? `${type},null` : type;
+    } else if (Array.isArray(type)) {
+      actualType = type.join(',');
+    }
+    throw new Error(
+      `Root schema must have type: 'object' but got type: ${actualType ? `'${actualType}'` : 'undefined'}`,
+    );
+  }
+  if (reference !== undefined) {
+    throw new Error("Root schema must be a concrete object and cannot contain '$ref'");
+  }
+
+  if (name !== undefined && nameStrategy !== 'duplicate-ref') {
+    throw new Error("Root schema must have type: 'object' but got type: undefined");
+  }
+
+  return owned as JsonSchema7Type;
+}
+
 const zodToJsonSchema = <Target extends Targets = 'jsonSchema7'>(
   schema: ZodSchema<any>,
   options?: Partial<Options<Target>> | string,
 ): (Target extends 'jsonSchema7' ? JsonSchema7Type : object) & {
   $schema?: string;
-  definitions?: {
-    [key: string]: Target extends 'jsonSchema7' ? JsonSchema7Type
-    : Target extends 'jsonSchema2019-09' ? JsonSchema7Type
-    : object;
-  };
+  definitions?: Record<
+    string,
+    Target extends 'jsonSchema7'
+      ? JsonSchema7Type
+      : Target extends 'jsonSchema2019-09'
+        ? JsonSchema7Type
+        : object
+  >;
 } => {
   const refs = getRefs(options);
+  if (refs.openaiStrictMode) {
+    refs.definitions = { ...refs.definitions };
+  }
 
-  const name =
-    typeof options === 'string' ? options
-    : options?.nameStrategy === 'title' ? undefined
-    : options?.name;
+  let name: string | undefined;
+  if (typeof options === 'string') {
+    name = options;
+  } else if (options?.nameStrategy !== 'title') {
+    name = options?.name;
+  }
 
-  const main =
+  const parsed =
     parseDef(
       schema._def,
-      name === undefined ? refs : (
-        {
-          ...refs,
-          currentPath: [...refs.basePath, refs.definitionPath, name],
-        }
-      ),
-      false,
+      name === undefined
+        ? refs
+        : {
+            ...refs,
+            currentPath: [...refs.basePath, refs.definitionPath, name],
+          },
+      refs.openaiStrictMode === true,
     ) ?? {};
+  const main = refs.openaiStrictMode ? ownStrictRootSchema(parsed, name, refs.nameStrategy) : parsed;
 
-  const title =
-    typeof options === 'object' && options.name !== undefined && options.nameStrategy === 'title' ?
-      options.name
-    : undefined;
+  const title = refs.nameStrategy === 'title' ? refs.name : undefined;
 
   if (title !== undefined) {
     main.title = title;
@@ -60,7 +132,9 @@ const zodToJsonSchema = <Target extends Targets = 'jsonSchema7'>(
       const newDefinitions = Object.entries(refs.definitions).filter(
         ([key]) => !processedDefinitions.has(key),
       );
-      if (newDefinitions.length === 0) break;
+      if (newDefinitions.length === 0) {
+        break;
+      }
 
       for (const [key, schema] of newDefinitions) {
         definitions[key] =
@@ -76,19 +150,19 @@ const zodToJsonSchema = <Target extends Targets = 'jsonSchema7'>(
     return definitions;
   })();
 
-  const combined: ReturnType<typeof zodToJsonSchema<Target>> =
-    name === undefined ?
-      definitions ?
-        {
+  let combined: ReturnType<typeof zodToJsonSchema<Target>>;
+  if (name === undefined) {
+    combined = definitions
+      ? {
           ...main,
           [refs.definitionPath]: definitions,
         }
-      : main
-    : refs.nameStrategy === 'duplicate-ref' ?
-      {
-        ...main,
-        ...(definitions || refs.seenRefs.size ?
-          {
+      : main;
+  } else if (refs.nameStrategy === 'duplicate-ref') {
+    combined = {
+      ...main,
+      ...(definitions || refs.seenRefs.size
+        ? {
             [refs.definitionPath]: {
               ...definitions,
               // only actually duplicate the schema definition if it was ever referenced
@@ -97,16 +171,16 @@ const zodToJsonSchema = <Target extends Targets = 'jsonSchema7'>(
             },
           }
         : undefined),
-      }
-    : {
-        $ref: [...(refs.$refStrategy === 'relative' ? [] : refs.basePath), refs.definitionPath, name].join(
-          '/',
-        ),
-        [refs.definitionPath]: {
-          ...definitions,
-          [name]: main,
-        },
-      };
+    };
+  } else {
+    combined = {
+      $ref: [...(refs.$refStrategy === 'relative' ? [] : refs.basePath), refs.definitionPath, name].join('/'),
+      [refs.definitionPath]: {
+        ...definitions,
+        [name]: main,
+      },
+    };
+  }
 
   if (refs.target === 'jsonSchema7') {
     combined.$schema = 'http://json-schema.org/draft-07/schema#';