openai 7.4.0 → 7.5.0

package/src/_vendor/partial-json-parser/parser.ts

@@ -1,12 +1,12 @@
-const STR = 0b000000001;
-const NUM = 0b000000010;
-const ARR = 0b000000100;
-const OBJ = 0b000001000;
-const NULL = 0b000010000;
-const BOOL = 0b000100000;
-const NAN = 0b001000000;
-const INFINITY = 0b010000000;
-const MINUS_INFINITY = 0b100000000;
+const STR = 0b0_0000_0001;
+const NUM = 0b0_0000_0010;
+const ARR = 0b0_0000_0100;
+const OBJ = 0b0_0000_1000;
+const NULL = 0b0_0001_0000;
+const BOOL = 0b0_0010_0000;
+const NAN = 0b0_0100_0000;
+const INFINITY = 0b0_1000_0000;
+const MINUS_INFINITY = 0b1_0000_0000;
 
 const INF = INFINITY | MINUS_INFINITY;
 const SPECIAL = NULL | BOOL | INF | NAN;
@@ -32,8 +32,10 @@ const Allow = {
 };
 
 // The JSON string segment was unable to be parsed completely
+// oxlint-disable-next-line unicorn/custom-error-definition -- preserve the vendored exported class name
 class PartialJSON extends Error {}
 
+// oxlint-disable-next-line unicorn/custom-error-definition -- preserve the vendored exported class name
 class MalformedJSON extends Error {}
 
 /**
@@ -68,10 +70,18 @@ const _parseJSON = (jsonString: string, allow: number) => {
 
   const parseAny: () => any = () => {
     skipBlank();
-    if (index >= length) markPartialJSON('Unexpected end of input');
-    if (jsonString[index] === '"') return parseStr();
-    if (jsonString[index] === '{') return parseObj();
-    if (jsonString[index] === '[') return parseArr();
+    if (index >= length) {
+      markPartialJSON('Unexpected end of input');
+    }
+    if (jsonString[index] === '"') {
+      return parseStr();
+    }
+    if (jsonString[index] === '{') {
+      return parseObj();
+    }
+    if (jsonString[index] === '[') {
+      return parseArr();
+    }
     if (
       jsonString.substring(index, index + 4) === 'null' ||
       (Allow.NULL & allow && length - index < 4 && 'null'.startsWith(jsonString.substring(index)))
@@ -103,7 +113,7 @@ const _parseJSON = (jsonString: string, allow: number) => {
     if (
       jsonString.substring(index, index + 9) === '-Infinity' ||
       (Allow.MINUS_INFINITY & allow &&
-        1 < length - index &&
+        length - index > 1 &&
         length - index < 9 &&
         '-Infinity'.startsWith(jsonString.substring(index)))
     ) {
@@ -115,7 +125,7 @@ const _parseJSON = (jsonString: string, allow: number) => {
       (Allow.NAN & allow && length - index < 3 && 'NaN'.startsWith(jsonString.substring(index)))
     ) {
       index += 3;
-      return NaN;
+      return Number.NaN;
     }
     return parseNum();
   };
@@ -128,7 +138,7 @@ const _parseJSON = (jsonString: string, allow: number) => {
       escape = jsonString[index] === '\\' ? !escape : false;
       index++;
     }
-    if (jsonString.charAt(index) == '"') {
+    if (jsonString.charAt(index) === '"') {
       try {
         return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
       } catch (e) {
@@ -137,7 +147,7 @@ const _parseJSON = (jsonString: string, allow: number) => {
     } else if (Allow.STR & allow) {
       try {
         return JSON.parse(jsonString.substring(start, index - Number(escape)) + '"');
-      } catch (e) {
+      } catch {
         // SyntaxError: Invalid escape sequence
         return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf('\\')) + '"');
       }
@@ -152,7 +162,9 @@ const _parseJSON = (jsonString: string, allow: number) => {
     try {
       while (jsonString[index] !== '}') {
         skipBlank();
-        if (index >= length && Allow.OBJ & allow) return obj;
+        if (index >= length && Allow.OBJ & allow) {
+          return obj;
+        }
         const key = parseStr();
         skipBlank();
         index++; // skip colon
@@ -160,15 +172,21 @@ const _parseJSON = (jsonString: string, allow: number) => {
           const value = parseAny();
           Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
         } catch (e) {
-          if (Allow.OBJ & allow) return obj;
-          else throw e;
+          if (Allow.OBJ & allow) {
+            return obj;
+          }
+          throw e;
         }
         skipBlank();
-        if (jsonString[index] === ',') index++; // skip comma
+        if (jsonString[index] === ',') {
+          index++;
+        } // skip comma
+      }
+    } catch {
+      if (Allow.OBJ & allow) {
+        return obj;
       }
-    } catch (e) {
-      if (Allow.OBJ & allow) return obj;
-      else markPartialJSON("Expected '}' at end of object");
+      markPartialJSON("Expected '}' at end of object");
     }
     index++; // skip final brace
     return obj;
@@ -185,7 +203,7 @@ const _parseJSON = (jsonString: string, allow: number) => {
           index++; // skip comma
         }
       }
-    } catch (e) {
+    } catch {
       if (Allow.ARR & allow) {
         return arr;
       }
@@ -197,16 +215,21 @@ const _parseJSON = (jsonString: string, allow: number) => {
 
   const parseNum = () => {
     if (index === 0) {
-      if (jsonString === '-' && Allow.NUM & allow) markPartialJSON("Not sure what '-' is");
+      if (jsonString === '-' && Allow.NUM & allow) {
+        markPartialJSON("Not sure what '-' is");
+      }
       try {
         return JSON.parse(jsonString);
       } catch (e) {
         if (Allow.NUM & allow) {
           try {
-            if ('.' === jsonString[jsonString.length - 1])
+            if (jsonString[jsonString.length - 1] === '.') {
               return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf('.')));
+            }
             return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf('e')));
-          } catch (e) {}
+          } catch {
+            // Fall through to report malformed input below.
+          }
         }
         throwMalformedError(String(e));
       }
@@ -214,16 +237,23 @@ const _parseJSON = (jsonString: string, allow: number) => {
 
     const start = index;
 
-    if (jsonString[index] === '-') index++;
-    while (jsonString[index] && !',]}'.includes(jsonString[index]!)) index++;
+    if (jsonString[index] === '-') {
+      index++;
+    }
+    while (jsonString[index] && !',]}'.includes(jsonString[index]!)) {
+      index++;
+    }
 
-    if (index == length && !(Allow.NUM & allow)) markPartialJSON('Unterminated number literal');
+    if (index === length && !(Allow.NUM & allow)) {
+      markPartialJSON('Unterminated number literal');
+    }
 
     try {
       return JSON.parse(jsonString.substring(start, index));
-    } catch (e) {
-      if (jsonString.substring(start, index) === '-' && Allow.NUM & allow)
+    } catch {
+      if (jsonString.substring(start, index) === '-' && Allow.NUM & allow) {
         markPartialJSON("Not sure what '-' is");
+      }
       try {
         return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf('e')));
       } catch (e) {

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

@@ -1,6 +1,6 @@
-import { ZodSchema, ZodTypeDef } from 'zod/v3';
-import { Refs, Seen } from './Refs';
-import { JsonSchema7Type } from './parseDef';
+import type { ZodSchema, ZodTypeDef } from 'zod/v3';
+import type { Refs, Seen } from './Refs';
+import type { JsonSchema7Type } from './parseDef';
 
 export type Targets = 'jsonSchema7' | 'jsonSchema2019-09' | 'openApi3';
 
@@ -61,20 +61,32 @@ const defaultOptions: Omit<Options, 'definitions' | 'basePath'> = {
 
 export const getDefaultOptions = <Target extends Targets>(
   options: Partial<Options<Target>> | string | undefined,
-) => {
+): Options<Target> => {
   // We need to add `definitions` here as we may mutate it
-  return (
-    typeof options === 'string' ?
-      {
-        ...defaultOptions,
-        basePath: ['#'],
-        definitions: {},
-        name: options,
-      }
-    : {
-        ...defaultOptions,
-        basePath: ['#'],
-        definitions: {},
-        ...options,
-      }) as Options<Target>;
+  const resolvedOptions = (
+    typeof options === 'string'
+      ? {
+          ...defaultOptions,
+          basePath: ['#'],
+          definitions: {},
+          name: options,
+        }
+      : {
+          ...defaultOptions,
+          basePath: ['#'],
+          definitions: {},
+          ...options,
+        }
+  ) as Options<Target>;
+
+  if (
+    typeof options !== 'string' &&
+    options?.definitions &&
+    resolvedOptions.$refStrategy === 'extract-to-root' &&
+    resolvedOptions.nameStrategy === 'duplicate-ref'
+  ) {
+    resolvedOptions.definitions = { ...options.definitions };
+  }
+
+  return resolvedOptions;
 };

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

@@ -1,6 +1,7 @@
 import type { ZodTypeDef } from 'zod/v3';
-import { getDefaultOptions, Options, Targets } from './Options';
-import { JsonSchema7Type } from './parseDef';
+import type { Options, Targets } from './Options';
+import { getDefaultOptions } from './Options';
+import type { JsonSchema7Type } from './parseDef';
 import { zodDef } from './util';
 
 export type Refs = {
@@ -24,12 +25,12 @@ export type Seen = {
 export const getRefs = (options?: string | Partial<Options<Targets>>): Refs => {
   const _options = getDefaultOptions(options);
   const currentPath =
-    _options.name !== undefined ?
-      [..._options.basePath, _options.definitionPath, _options.name]
-    : _options.basePath;
+    _options.name === undefined
+      ? _options.basePath
+      : [..._options.basePath, _options.definitionPath, _options.name];
   return {
     ..._options,
-    currentPath: currentPath,
+    currentPath,
     propertyPath: undefined,
     seenRefs: new Set(),
     seen: new Map(

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

@@ -1,5 +1,5 @@
-import { JsonSchema7TypeUnion } from './parseDef';
-import { Refs } from './Refs';
+import type { JsonSchema7TypeUnion } from './parseDef';
+import type { Refs } from './Refs';
 
 export type ErrorMessages<T extends JsonSchema7TypeUnion, OmitProperties extends string = ''> = Partial<
   Omit<{ [key in keyof T]: string }, OmitProperties | 'type' | 'errorMessages'>
@@ -11,7 +11,9 @@ export function addErrorMessage<T extends { errorMessage?: ErrorMessages<any> }>
   errorMessage: string | undefined,
   refs: Refs,
 ) {
-  if (!refs?.errorMessages) return;
+  if (!refs?.errorMessages) {
+    return;
+  }
   if (errorMessage) {
     res.errorMessage = {
       ...res.errorMessage,

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

@@ -1,3 +1,5 @@
+import { zodToJsonSchema } from './zodToJsonSchema';
+
 export * from './Options';
 export * from './Refs';
 export * from './errorMessages';
@@ -33,5 +35,5 @@ export * from './parsers/undefined';
 export * from './parsers/union';
 export * from './parsers/unknown';
 export * from './zodToJsonSchema';
-import { zodToJsonSchema } from './zodToJsonSchema';
+
 export default zodToJsonSchema;

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

@@ -1,36 +1,61 @@
-import { ZodFirstPartyTypeKind, ZodTypeDef } from 'zod/v3';
-import { JsonSchema7AnyType, parseAnyDef } from './parsers/any';
-import { JsonSchema7ArrayType, parseArrayDef } from './parsers/array';
-import { JsonSchema7BigintType, parseBigintDef } from './parsers/bigint';
-import { JsonSchema7BooleanType, parseBooleanDef } from './parsers/boolean';
+import type { ZodTypeDef } from 'zod/v3';
+import { ZodFirstPartyTypeKind } from 'zod/v3';
+import { hasOwn } from '../../internal/utils/values';
+import type { JsonSchema7AnyType } from './parsers/any';
+import { parseAnyDef } from './parsers/any';
+import type { JsonSchema7ArrayType } from './parsers/array';
+import { parseArrayDef } from './parsers/array';
+import type { JsonSchema7BigintType } from './parsers/bigint';
+import { parseBigintDef } from './parsers/bigint';
+import type { JsonSchema7BooleanType } from './parsers/boolean';
+import { parseBooleanDef } from './parsers/boolean';
 import { parseBrandedDef } from './parsers/branded';
 import { parseCatchDef } from './parsers/catch';
-import { JsonSchema7DateType, parseDateDef } from './parsers/date';
+import type { JsonSchema7DateType } from './parsers/date';
+import { parseDateDef } from './parsers/date';
 import { parseDefaultDef } from './parsers/default';
 import { parseEffectsDef } from './parsers/effects';
-import { JsonSchema7EnumType, parseEnumDef } from './parsers/enum';
-import { JsonSchema7AllOfType, parseIntersectionDef } from './parsers/intersection';
-import { JsonSchema7LiteralType, parseLiteralDef } from './parsers/literal';
-import { JsonSchema7MapType, parseMapDef } from './parsers/map';
-import { JsonSchema7NativeEnumType, parseNativeEnumDef } from './parsers/nativeEnum';
-import { JsonSchema7NeverType, parseNeverDef } from './parsers/never';
-import { JsonSchema7NullType, parseNullDef } from './parsers/null';
-import { JsonSchema7NullableType, parseNullableDef } from './parsers/nullable';
-import { JsonSchema7NumberType, parseNumberDef } from './parsers/number';
-import { JsonSchema7ObjectType, parseObjectDef } from './parsers/object';
+import type { JsonSchema7EnumType } from './parsers/enum';
+import { parseEnumDef } from './parsers/enum';
+import type { JsonSchema7AllOfType } from './parsers/intersection';
+import { parseIntersectionDef } from './parsers/intersection';
+import type { JsonSchema7LiteralType } from './parsers/literal';
+import { parseLiteralDef } from './parsers/literal';
+import type { JsonSchema7MapType } from './parsers/map';
+import { parseMapDef } from './parsers/map';
+import type { JsonSchema7NativeEnumType } from './parsers/nativeEnum';
+import { parseNativeEnumDef } from './parsers/nativeEnum';
+import type { JsonSchema7NeverType } from './parsers/never';
+import { parseNeverDef } from './parsers/never';
+import type { JsonSchema7NullType } from './parsers/null';
+import { parseNullDef } from './parsers/null';
+import type { JsonSchema7NullableType } from './parsers/nullable';
+import { parseNullableDef } from './parsers/nullable';
+import type { JsonSchema7NumberType } from './parsers/number';
+import { parseNumberDef } from './parsers/number';
+import type { JsonSchema7ObjectType } from './parsers/object';
+import { parseObjectDef } from './parsers/object';
 import { parseOptionalDef } from './parsers/optional';
 import { parsePipelineDef } from './parsers/pipeline';
 import { parsePromiseDef } from './parsers/promise';
-import { JsonSchema7RecordType, parseRecordDef } from './parsers/record';
-import { JsonSchema7SetType, parseSetDef } from './parsers/set';
-import { JsonSchema7StringType, parseStringDef } from './parsers/string';
-import { JsonSchema7TupleType, parseTupleDef } from './parsers/tuple';
-import { JsonSchema7UndefinedType, parseUndefinedDef } from './parsers/undefined';
-import { JsonSchema7UnionType, parseUnionDef } from './parsers/union';
-import { JsonSchema7UnknownType, parseUnknownDef } from './parsers/unknown';
-import { Refs, Seen } from './Refs';
+import type { JsonSchema7RecordType } from './parsers/record';
+import { parseRecordDef } from './parsers/record';
+import type { JsonSchema7SetType } from './parsers/set';
+import { parseSetDef } from './parsers/set';
+import type { JsonSchema7StringType } from './parsers/string';
+import { parseStringDef } from './parsers/string';
+import type { JsonSchema7TupleType } from './parsers/tuple';
+import { parseTupleDef } from './parsers/tuple';
+import type { JsonSchema7UndefinedType } from './parsers/undefined';
+import { parseUndefinedDef } from './parsers/undefined';
+import type { JsonSchema7UnionType } from './parsers/union';
+import { parseUnionDef } from './parsers/union';
+import type { JsonSchema7UnknownType } from './parsers/unknown';
+import { parseUnknownDef } from './parsers/unknown';
+import type { Refs, Seen } from './Refs';
 import { parseReadonlyDef } from './parsers/readonly';
 import { ignoreOverride } from './Options';
+import { zodDef } from './util';
 
 type JsonSchema7RefType = { $ref: string };
 type JsonSchema7Meta = {
@@ -128,8 +153,9 @@ const get$ref = (
   | {}
   | undefined => {
   switch (refs.$refStrategy) {
-    case 'root':
+    case 'root': {
       return { $ref: item.path.join('/') };
+    }
     // this case is needed as OpenAI strict mode doesn't support top-level `$ref`s, i.e.
     // the top-level schema *must* be `{"type": "object", "properties": {...}}` but if we ever
     // need to define a `$ref`, relative `$ref`s aren't supported, so we need to extract
@@ -138,24 +164,48 @@ const get$ref = (
     // e.g. if we need to reference a schema at
     // `["#","definitions","contactPerson","properties","person1","properties","name"]`
     // then we'll extract it out to `contactPerson_properties_person1_properties_name`
-    case 'extract-to-root':
-      const name = item.path
+    case 'extract-to-root': {
+      const baseName = item.path
         .slice(refs.basePath.length + 1)
         // The first part is either the root schema name or an extracted definition
         // name that is being materialized. Keep it stable so recursive definitions
         // do not generate a new name each time they are resolved.
         .map((part, index) => (index === 0 ? part : encodeDefinitionPathPart(part)))
         .join('_');
+      let name = baseName;
 
       // we don't need to extract the root schema in this case, as it's already
       // been added to the definitions
-      if (name !== refs.name && refs.nameStrategy === 'duplicate-ref') {
-        refs.definitions[name] = item.def;
+      const isRootSchema =
+        name === refs.name &&
+        item.path.length === refs.basePath.length + 2 &&
+        item.path[refs.basePath.length] === refs.definitionPath;
+
+      if (!isRootSchema && refs.nameStrategy === 'duplicate-ref') {
+        const hasDifferentDefinition = (definitionName: string): boolean => {
+          if (!hasOwn(refs.definitions, definitionName)) {
+            return false;
+          }
+
+          const existingDefinition = refs.definitions[definitionName];
+          return existingDefinition === undefined || zodDef(existingDefinition) !== item.def;
+        };
+        let suffix = 0;
+        while (name === refs.name || hasDifferentDefinition(name)) {
+          suffix += 1;
+          name = `${baseName}_${suffix}`;
+        }
+
+        if (!hasOwn(refs.definitions, name)) {
+          refs.definitions[name] = item.def;
+        }
       }
 
       return { $ref: [...refs.basePath, refs.definitionPath, name].join('/') };
-    case 'relative':
+    }
+    case 'relative': {
       return { $ref: getRelativePath(refs.currentPath, item.path) };
+    }
     case 'none':
     case 'seen': {
       if (
@@ -181,6 +231,7 @@ const encodeDefinitionPathPart = (part: string) => {
 
   let encoded = encodedDefinitionPathPartPrefix;
   for (let i = 0; i < part.length; i++) {
+    // oxlint-disable-next-line unicorn/prefer-code-point -- preserve UTF-16 code-unit encoding
     encoded += part.charCodeAt(i).toString(16).padStart(4, '0');
   }
   return encoded;
@@ -189,7 +240,9 @@ const encodeDefinitionPathPart = (part: string) => {
 const getRelativePath = (pathA: string[], pathB: string[]) => {
   let i = 0;
   for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i]) break;
+    if (pathA[i] !== pathB[i]) {
+      break;
+    }
   }
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join('/');
 };
@@ -201,76 +254,109 @@ const selectParser = (
   forceResolution: boolean,
 ): JsonSchema7Type | undefined => {
   switch (typeName) {
-    case ZodFirstPartyTypeKind.ZodString:
+    case ZodFirstPartyTypeKind.ZodString: {
       return parseStringDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodNumber:
+    }
+    case ZodFirstPartyTypeKind.ZodNumber: {
       return parseNumberDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodObject:
+    }
+    case ZodFirstPartyTypeKind.ZodObject: {
       return parseObjectDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBigInt:
+    }
+    case ZodFirstPartyTypeKind.ZodBigInt: {
       return parseBigintDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBoolean:
+    }
+    case ZodFirstPartyTypeKind.ZodBoolean: {
       return parseBooleanDef();
-    case ZodFirstPartyTypeKind.ZodDate:
+    }
+    case ZodFirstPartyTypeKind.ZodDate: {
       return parseDateDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodUndefined:
+    }
+    case ZodFirstPartyTypeKind.ZodUndefined: {
       return parseUndefinedDef();
-    case ZodFirstPartyTypeKind.ZodNull:
+    }
+    case ZodFirstPartyTypeKind.ZodNull: {
       return parseNullDef(refs);
-    case ZodFirstPartyTypeKind.ZodArray:
+    }
+    case ZodFirstPartyTypeKind.ZodArray: {
       return parseArrayDef(def, refs);
+    }
     case ZodFirstPartyTypeKind.ZodUnion:
-    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
       return parseUnionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodIntersection:
+    }
+    case ZodFirstPartyTypeKind.ZodIntersection: {
       return parseIntersectionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodTuple:
+    }
+    case ZodFirstPartyTypeKind.ZodTuple: {
       return parseTupleDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodRecord:
+    }
+    case ZodFirstPartyTypeKind.ZodRecord: {
       return parseRecordDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLiteral:
+    }
+    case ZodFirstPartyTypeKind.ZodLiteral: {
       return parseLiteralDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodEnum:
+    }
+    case ZodFirstPartyTypeKind.ZodEnum: {
       return parseEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNativeEnum:
+    }
+    case ZodFirstPartyTypeKind.ZodNativeEnum: {
       return parseNativeEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNullable:
+    }
+    case ZodFirstPartyTypeKind.ZodNullable: {
       return parseNullableDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodOptional:
+    }
+    case ZodFirstPartyTypeKind.ZodOptional: {
       return parseOptionalDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodMap:
+    }
+    case ZodFirstPartyTypeKind.ZodMap: {
       return parseMapDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodSet:
+    }
+    case ZodFirstPartyTypeKind.ZodSet: {
       return parseSetDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLazy:
+    }
+    case ZodFirstPartyTypeKind.ZodLazy: {
       return parseDef(def.getter()._def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodPromise:
+    }
+    case ZodFirstPartyTypeKind.ZodPromise: {
       return parsePromiseDef(def, refs, forceResolution);
+    }
     case ZodFirstPartyTypeKind.ZodNaN:
-    case ZodFirstPartyTypeKind.ZodNever:
+    case ZodFirstPartyTypeKind.ZodNever: {
       return parseNeverDef();
-    case ZodFirstPartyTypeKind.ZodEffects:
+    }
+    case ZodFirstPartyTypeKind.ZodEffects: {
       return parseEffectsDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodAny:
+    }
+    case ZodFirstPartyTypeKind.ZodAny: {
       return parseAnyDef();
-    case ZodFirstPartyTypeKind.ZodUnknown:
+    }
+    case ZodFirstPartyTypeKind.ZodUnknown: {
       return parseUnknownDef();
-    case ZodFirstPartyTypeKind.ZodDefault:
+    }
+    case ZodFirstPartyTypeKind.ZodDefault: {
       return parseDefaultDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodBranded:
+    }
+    case ZodFirstPartyTypeKind.ZodBranded: {
       return parseBrandedDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodReadonly:
+    }
+    case ZodFirstPartyTypeKind.ZodReadonly: {
       return parseReadonlyDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodCatch:
+    }
+    case ZodFirstPartyTypeKind.ZodCatch: {
       return parseCatchDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodPipeline:
+    }
+    case ZodFirstPartyTypeKind.ZodPipeline: {
       return parsePipelineDef(def, refs, forceResolution);
+    }
     case ZodFirstPartyTypeKind.ZodFunction:
     case ZodFirstPartyTypeKind.ZodVoid:
-    case ZodFirstPartyTypeKind.ZodSymbol:
+    case ZodFirstPartyTypeKind.ZodSymbol: {
       return undefined;
-    default:
+    }
+    default: {
       return ((_: never) => undefined)(typeName);
+    }
   }
 };
 

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

@@ -1,7 +1,10 @@
-import { ZodArrayDef, ZodFirstPartyTypeKind } from 'zod/v3';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
+import type { ZodArrayDef } from 'zod/v3';
+import { ZodFirstPartyTypeKind } 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 JsonSchema7ArrayType = {
   type: 'array';
@@ -15,7 +18,7 @@ export function parseArrayDef(def: ZodArrayDef, refs: Refs) {
   const res: JsonSchema7ArrayType = {
     type: 'array',
   };
-  if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+  if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny || refs.openaiStrictMode) {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, 'items'],