openai 7.4.0 → 7.6.0

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

@@ -1,12 +1,12 @@
-import { Refs } from '../Refs';
+import type { Refs } from '../Refs';
 
 export type JsonSchema7NullType = {
   type: 'null';
 };
 
 export function parseNullDef(refs: Refs): JsonSchema7NullType {
-  return refs.target === 'openApi3' ?
-      ({
+  return refs.target === 'openApi3'
+    ? ({
         enum: ['null'],
         nullable: true,
       } as any)

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

@@ -1,7 +1,8 @@
-import { ZodNullableDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-import { JsonSchema7NullType } from './null';
+import type { ZodNullableDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
+import type { JsonSchema7NullType } from './null';
 import { primitiveMappings } from './union';
 
 export type JsonSchema7NullableType =
@@ -43,7 +44,9 @@ export function parseNullableDef(
       forceResolution,
     );
 
-    if (base && '$ref' in base) return { allOf: [base], nullable: true } as any;
+    if (base && '$ref' in base) {
+      return { allOf: [base], nullable: true } as any;
+    }
 
     return base && ({ ...base, nullable: true } as any);
   }

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

@@ -1,6 +1,7 @@
-import { ZodNumberDef } from 'zod/v3';
-import { addErrorMessage, ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { Refs } from '../Refs';
+import type { ZodNumberDef } from 'zod/v3';
+import type { ErrorMessages } from '../errorMessages';
+import { addErrorMessage, setResponseValueAndErrors } from '../errorMessages';
+import type { Refs } from '../Refs';
 
 export type JsonSchema7NumberType = {
   type: 'number' | 'integer';
@@ -17,15 +18,18 @@ export function parseNumberDef(def: ZodNumberDef, refs: Refs): JsonSchema7Number
     type: 'number',
   };
 
-  if (!def.checks) return res;
+  if (!def.checks) {
+    return res;
+  }
 
   for (const check of def.checks) {
     switch (check.kind) {
-      case 'int':
+      case 'int': {
         res.type = 'integer';
         addErrorMessage(res, 'type', check.message, refs);
         break;
-      case 'min':
+      }
+      case 'min': {
         if (refs.target === 'jsonSchema7') {
           if (check.inclusive) {
             setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
@@ -39,7 +43,8 @@ export function parseNumberDef(def: ZodNumberDef, refs: Refs): JsonSchema7Number
           setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
         }
         break;
-      case 'max':
+      }
+      case 'max': {
         if (refs.target === 'jsonSchema7') {
           if (check.inclusive) {
             setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
@@ -53,9 +58,11 @@ export function parseNumberDef(def: ZodNumberDef, refs: Refs): JsonSchema7Number
           setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
         }
         break;
-      case 'multipleOf':
+      }
+      case 'multipleOf': {
         setResponseValueAndErrors(res, 'multipleOf', check.value, check.message, refs);
         break;
+      }
     }
   }
   return res;

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

@@ -1,23 +1,23 @@
-import { ZodObjectDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodObjectDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 function decideAdditionalProperties(def: ZodObjectDef, refs: Refs) {
   if (refs.removeAdditionalStrategy === 'strict') {
-    return def.catchall._def.typeName === 'ZodNever' ?
-        def.unknownKeys !== 'strict'
-      : parseDef(def.catchall._def, {
+    return def.catchall._def.typeName === 'ZodNever'
+      ? def.unknownKeys !== 'strict'
+      : (parseDef(def.catchall._def, {
           ...refs,
           currentPath: [...refs.currentPath, 'additionalProperties'],
-        }) ?? true;
-  } else {
-    return def.catchall._def.typeName === 'ZodNever' ?
-        def.unknownKeys === 'passthrough'
-      : parseDef(def.catchall._def, {
-          ...refs,
-          currentPath: [...refs.currentPath, 'additionalProperties'],
-        }) ?? true;
+        }) ?? true);
   }
+  return def.catchall._def.typeName === 'ZodNever'
+    ? def.unknownKeys === 'passthrough'
+    : (parseDef(def.catchall._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'additionalProperties'],
+      }) ?? true);
 }
 
 export type JsonSchema7ObjectType = {
@@ -28,49 +28,52 @@ export type JsonSchema7ObjectType = {
 };
 
 export function parseObjectDef(def: ZodObjectDef, refs: Refs) {
+  const properties: Record<string, JsonSchema7Type> = {};
+  const required: string[] = [];
+  for (const [propName, propDef] of Object.entries(def.shape())) {
+    if (propDef === undefined || propDef._def === undefined) {
+      continue;
+    }
+    const propertyPath = [...refs.currentPath, 'properties', propName];
+    if (propName === '__proto__') {
+      throw new Error(
+        `Zod field at \`${propertyPath.join('/')}\` uses unsupported property name \`__proto__\`, which Zod omits from parsed output.`,
+      );
+    }
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: propertyPath,
+      propertyPath,
+    });
+    if (parsedDef === undefined) {
+      continue;
+    }
+    if (
+      refs.openaiStrictMode &&
+      propDef.isOptional() &&
+      !propDef.isNullable() &&
+      propDef._def?.defaultValue === undefined
+    ) {
+      throw new Error(
+        `Zod field at \`${propertyPath.join(
+          '/',
+        )}\` uses \`.optional()\` without \`.nullable()\` which is not supported by the API. See: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#all-fields-must-be-required`,
+      );
+    }
+    properties[propName] = parsedDef;
+    if (!propDef.isOptional() || refs.openaiStrictMode) {
+      required.push(propName);
+    }
+  }
+
   const result: JsonSchema7ObjectType = {
     type: 'object',
-    ...Object.entries(def.shape()).reduce(
-      (
-        acc: {
-          properties: Record<string, JsonSchema7Type>;
-          required: string[];
-        },
-        [propName, propDef],
-      ) => {
-        if (propDef === undefined || propDef._def === undefined) return acc;
-        const propertyPath = [...refs.currentPath, 'properties', propName];
-        const parsedDef = parseDef(propDef._def, {
-          ...refs,
-          currentPath: propertyPath,
-          propertyPath,
-        });
-        if (parsedDef === undefined) return acc;
-        if (
-          refs.openaiStrictMode &&
-          propDef.isOptional() &&
-          !propDef.isNullable() &&
-          typeof propDef._def?.defaultValue === 'undefined'
-        ) {
-          throw new Error(
-            `Zod field at \`${propertyPath.join(
-              '/',
-            )}\` uses \`.optional()\` without \`.nullable()\` which is not supported by the API. See: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#all-fields-must-be-required`,
-          );
-        }
-        return {
-          properties: {
-            ...acc.properties,
-            [propName]: parsedDef,
-          },
-          required:
-            propDef.isOptional() && !refs.openaiStrictMode ? acc.required : [...acc.required, propName],
-        };
-      },
-      { properties: {}, required: [] },
-    ),
+    properties,
+    required,
     additionalProperties: decideAdditionalProperties(def, refs),
   };
-  if (!result.required!.length) delete result.required;
+  if (!result.required!.length) {
+    delete result.required;
+  }
   return result;
 }

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

@@ -1,6 +1,7 @@
-import { ZodOptionalDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodOptionalDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 export const parseOptionalDef = (
   def: ZodOptionalDef,
@@ -23,8 +24,8 @@ export const parseOptionalDef = (
     forceResolution,
   );
 
-  return innerSchema ?
-      {
+  return innerSchema
+    ? {
         anyOf: [
           {
             not: {},

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

@@ -1,7 +1,8 @@
-import { ZodPipelineDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-import { JsonSchema7AllOfType } from './intersection';
+import type { ZodPipelineDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
+import type { JsonSchema7AllOfType } from './intersection';
 
 export const parsePipelineDef = (
   def: ZodPipelineDef<any, any>,

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

@@ -1,6 +1,7 @@
-import { ZodPromiseDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodPromiseDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
 
 export function parsePromiseDef(
   def: ZodPromiseDef,

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

@@ -1,7 +1,6 @@
-import { ZodReadonlyDef } from 'zod/v3';
+import type { ZodReadonlyDef } from 'zod/v3';
 import { parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { Refs } from '../Refs';
 
-export const parseReadonlyDef = (def: ZodReadonlyDef<any>, refs: Refs, forceResolution: boolean) => {
-  return parseDef(def.innerType._def, refs, forceResolution);
-};
+export const parseReadonlyDef = (def: ZodReadonlyDef<any>, refs: Refs, forceResolution: boolean) =>
+  parseDef(def.innerType._def, refs, forceResolution);

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

@@ -1,9 +1,12 @@
-import { ZodFirstPartyTypeKind, ZodMapDef, ZodRecordDef, ZodTypeAny } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-import { JsonSchema7EnumType } from './enum';
-import { JsonSchema7ObjectType } from './object';
-import { JsonSchema7StringType, parseStringDef } from './string';
+import type { ZodMapDef, ZodRecordDef, ZodTypeAny } from 'zod/v3';
+import { ZodFirstPartyTypeKind } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
+import type { JsonSchema7EnumType } from './enum';
+import type { JsonSchema7ObjectType } from './object';
+import type { JsonSchema7StringType } from './string';
+import { parseStringDef } from './string';
 
 type JsonSchema7RecordPropertyNamesType =
   | Omit<JsonSchema7StringType, 'type'>
@@ -23,16 +26,14 @@ export function parseRecordDef(
     return {
       type: 'object',
       required: def.keyType._def.values,
-      properties: def.keyType._def.values.reduce(
-        (acc: Record<string, JsonSchema7Type>, key: string) => ({
-          ...acc,
-          [key]:
-            parseDef(def.valueType._def, {
-              ...refs,
-              currentPath: [...refs.currentPath, 'properties', key],
-            }) ?? {},
-        }),
-        {},
+      properties: Object.fromEntries(
+        def.keyType._def.values.map((key: string) => [
+          key,
+          parseDef(def.valueType._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, 'properties', key],
+          }) ?? {},
+        ]),
       ),
       additionalProperties: false,
     } satisfies JsonSchema7ObjectType as any;
@@ -52,9 +53,9 @@ export function parseRecordDef(
   }
 
   if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
-    const keyType: JsonSchema7RecordPropertyNamesType = Object.entries(
-      parseStringDef(def.keyType._def, refs),
-    ).reduce((acc, [key, value]) => (key === 'type' ? acc : { ...acc, [key]: value }), {});
+    const keyType = Object.fromEntries(
+      Object.entries(parseStringDef(def.keyType._def, refs)).filter(([key]) => key !== 'type'),
+    ) as JsonSchema7RecordPropertyNamesType;
 
     return {
       ...schema,

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),
+  };
 }