openai 7.3.0 → 7.5.0

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

@@ -1,15 +1,16 @@
-import { ZodBigIntDef } from 'zod/v3';
-import { Refs } from '../Refs';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import type { ZodBigIntDef } from 'zod/v3';
+import type { Refs } from '../Refs';
+import type { ErrorMessages } from '../errorMessages';
+import { setResponseValueAndErrors } from '../errorMessages';
 
 export type JsonSchema7BigintType = {
   type: 'integer';
   format: 'int64';
-  minimum?: BigInt;
-  exclusiveMinimum?: BigInt;
-  maximum?: BigInt;
-  exclusiveMaximum?: BigInt;
-  multipleOf?: BigInt;
+  minimum?: bigint;
+  exclusiveMinimum?: bigint;
+  maximum?: bigint;
+  exclusiveMaximum?: bigint;
+  multipleOf?: bigint;
   errorMessage?: ErrorMessages<JsonSchema7BigintType>;
 };
 
@@ -19,11 +20,13 @@ export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7Bigint
     format: 'int64',
   };
 
-  if (!def.checks) return res;
+  if (!def.checks) {
+    return res;
+  }
 
   for (const check of def.checks) {
     switch (check.kind) {
-      case 'min':
+      case 'min': {
         if (refs.target === 'jsonSchema7') {
           if (check.inclusive) {
             setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
@@ -37,7 +40,8 @@ export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7Bigint
           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);
@@ -51,9 +55,11 @@ export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7Bigint
           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/branded.ts

@@ -1,6 +1,6 @@
-import { ZodBrandedDef } from 'zod/v3';
+import type { ZodBrandedDef } from 'zod/v3';
 import { parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { Refs } from '../Refs';
 
 export function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs, forceResolution: boolean) {
   return parseDef(_def.type._def, refs, forceResolution);

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

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

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

@@ -1,8 +1,9 @@
-import { ZodDateDef } from 'zod/v3';
-import { Refs } from '../Refs';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { JsonSchema7NumberType } from './number';
-import { DateStrategy } from '../Options';
+import type { ZodDateDef } from 'zod/v3';
+import type { Refs } from '../Refs';
+import type { ErrorMessages } from '../errorMessages';
+import { setResponseValueAndErrors } from '../errorMessages';
+import type { JsonSchema7NumberType } from './number';
+import type { DateStrategy } from '../Options';
 
 export type JsonSchema7DateType =
   | {
@@ -31,18 +32,21 @@ export function parseDateDef(
 
   switch (strategy) {
     case 'string':
-    case 'format:date-time':
+    case 'format:date-time': {
       return {
         type: 'string',
         format: 'date-time',
       };
-    case 'format:date':
+    }
+    case 'format:date': {
       return {
         type: 'string',
         format: 'date',
       };
-    case 'integer':
+    }
+    case 'integer': {
       return integerDateParser(def, refs);
+    }
   }
 }
 
@@ -58,7 +62,7 @@ const integerDateParser = (def: ZodDateDef, refs: Refs) => {
 
   for (const check of def.checks) {
     switch (check.kind) {
-      case 'min':
+      case 'min': {
         setResponseValueAndErrors(
           res,
           'minimum',
@@ -67,7 +71,8 @@ const integerDateParser = (def: ZodDateDef, refs: Refs) => {
           refs,
         );
         break;
-      case 'max':
+      }
+      case 'max': {
         setResponseValueAndErrors(
           res,
           'maximum',
@@ -76,6 +81,7 @@ const integerDateParser = (def: ZodDateDef, refs: Refs) => {
           refs,
         );
         break;
+      }
     }
   }
 

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { ZodEnumDef } from 'zod/v3';
+import type { ZodEnumDef } from 'zod/v3';
 
 export type JsonSchema7EnumType = {
   type: 'string';

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

@@ -1,7 +1,8 @@
-import { ZodIntersectionDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-import { JsonSchema7StringType } from './string';
+import type { ZodIntersectionDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
+import type { JsonSchema7StringType } from './string';
 
 export type JsonSchema7AllOfType = {
   allOf: JsonSchema7Type[];
@@ -11,7 +12,9 @@ export type JsonSchema7AllOfType = {
 const isJsonSchema7AllOfType = (
   type: JsonSchema7Type | JsonSchema7StringType,
 ): type is JsonSchema7AllOfType => {
-  if ('type' in type && type.type === 'string') return false;
+  if ('type' in type && type.type === 'string') {
+    return false;
+  }
   return 'allOf' in type;
 };
 
@@ -35,7 +38,7 @@ export function parseIntersectionDef(
 
   const mergedAllOf: JsonSchema7Type[] = [];
   // If either of the schemas is an allOf, merge them into a single allOf
-  allOf.forEach((schema) => {
+  for (const schema of allOf) {
     if (isJsonSchema7AllOfType(schema)) {
       mergedAllOf.push(...schema.allOf);
       if (schema.unevaluatedProperties === undefined) {
@@ -54,9 +57,9 @@ export function parseIntersectionDef(
       }
       mergedAllOf.push(nestedSchema);
     }
-  });
-  return mergedAllOf.length ?
-      {
+  }
+  return mergedAllOf.length
+    ? {
         allOf: mergedAllOf,
         ...unevaluatedProperties,
       }

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

@@ -1,16 +1,25 @@
-import { ZodLiteralDef } from 'zod/v3';
-import { Refs } from '../Refs';
+import type { ZodLiteralDef } from 'zod/v3';
+import type { Refs } from '../Refs';
+import { parseNullDef } from './null';
 
 export type JsonSchema7LiteralType =
   | {
       type: 'string' | 'number' | 'integer' | 'boolean';
       const: string | number | boolean;
     }
+  | {
+      type: 'null';
+      const?: null;
+    }
   | {
       type: 'object' | 'array';
     };
 
 export function parseLiteralDef(def: ZodLiteralDef, refs: Refs): JsonSchema7LiteralType {
+  if (def.value === null) {
+    return refs.target === 'openApi3' ? parseNullDef(refs) : { type: 'null', const: null };
+  }
+
   const parsedType = typeof def.value;
   if (
     parsedType !== 'bigint' &&

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

@@ -1,7 +1,9 @@
-import { ZodMapDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-import { JsonSchema7RecordType, parseRecordDef } from './record';
+import type { ZodMapDef } from 'zod/v3';
+import type { JsonSchema7Type } from '../parseDef';
+import { parseDef } from '../parseDef';
+import type { Refs } from '../Refs';
+import type { JsonSchema7RecordType } from './record';
+import { parseRecordDef } from './record';
 
 export type JsonSchema7MapType = {
   type: 'array';

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

@@ -1,4 +1,4 @@
-import { ZodNativeEnumDef } from 'zod/v3';
+import type { ZodNativeEnumDef } from 'zod/v3';
 
 export type JsonSchema7NativeEnumType = {
   type: 'string' | 'number' | ['string', 'number'];
@@ -7,21 +7,20 @@ export type JsonSchema7NativeEnumType = {
 
 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 actualKeys = Object.keys(def.values).filter(
+    (key: string) => 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)));
+  const parsedTypes = [...new Set(actualValues.map((values: string | number) => typeof values))];
+  let type: 'string' | 'number' | ['string', 'number'] = ['string', 'number'];
+  if (parsedTypes.length === 1) {
+    type = parsedTypes[0] === 'string' ? 'string' : 'number';
+  }
 
   return {
-    type:
-      parsedTypes.length === 1 ?
-        parsedTypes[0] === 'string' ?
-          'string'
-        : 'number'
-      : ['string', 'number'],
+    type,
     enum: actualValues,
   };
 }

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,