@depup/openai 6.31.0-depup.0

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

@@ -0,0 +1,64 @@
+import { ZodIntersectionDef } from 'zod/v3';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7StringType } from './string';
+
+export type JsonSchema7AllOfType = {
+  allOf: JsonSchema7Type[];
+  unevaluatedProperties?: boolean;
+};
+
+const isJsonSchema7AllOfType = (
+  type: JsonSchema7Type | JsonSchema7StringType,
+): type is JsonSchema7AllOfType => {
+  if ('type' in type && type.type === 'string') return false;
+  return 'allOf' in type;
+};
+
+export function parseIntersectionDef(
+  def: ZodIntersectionDef,
+  refs: Refs,
+): JsonSchema7AllOfType | JsonSchema7Type | undefined {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'allOf', '0'],
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'allOf', '1'],
+    }),
+  ].filter((x): x is JsonSchema7Type => !!x);
+
+  let unevaluatedProperties: Pick<JsonSchema7AllOfType, 'unevaluatedProperties'> | undefined =
+    refs.target === 'jsonSchema2019-09' ? { unevaluatedProperties: false } : undefined;
+
+  const mergedAllOf: JsonSchema7Type[] = [];
+  // If either of the schemas is an allOf, merge them into a single allOf
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === undefined) {
+        // If one of the schemas has no unevaluatedProperties set,
+        // the merged schema should also have no unevaluatedProperties set
+        unevaluatedProperties = undefined;
+      }
+    } else {
+      let nestedSchema: JsonSchema7Type = schema;
+      if ('additionalProperties' in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties
+        unevaluatedProperties = undefined;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ?
+      {
+        allOf: mergedAllOf,
+        ...unevaluatedProperties,
+      }
+    : undefined;
+}

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

@@ -0,0 +1,37 @@
+import { ZodLiteralDef } from 'zod/v3';
+import { Refs } from '../Refs';
+
+export type JsonSchema7LiteralType =
+  | {
+      type: 'string' | 'number' | 'integer' | 'boolean';
+      const: string | number | boolean;
+    }
+  | {
+      type: 'object' | 'array';
+    };
+
+export function parseLiteralDef(def: ZodLiteralDef, refs: Refs): JsonSchema7LiteralType {
+  const parsedType = typeof def.value;
+  if (
+    parsedType !== 'bigint' &&
+    parsedType !== 'number' &&
+    parsedType !== 'boolean' &&
+    parsedType !== 'string'
+  ) {
+    return {
+      type: Array.isArray(def.value) ? 'array' : 'object',
+    };
+  }
+
+  if (refs.target === 'openApi3') {
+    return {
+      type: parsedType === 'bigint' ? 'integer' : parsedType,
+      enum: [def.value],
+    } as any;
+  }
+
+  return {
+    type: parsedType === 'bigint' ? 'integer' : parsedType,
+    const: def.value,
+  };
+}

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

@@ -0,0 +1,42 @@
+import { ZodMapDef } from 'zod/v3';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7RecordType, parseRecordDef } from './record';
+
+export type JsonSchema7MapType = {
+  type: 'array';
+  maxItems: 125;
+  items: {
+    type: 'array';
+    items: [JsonSchema7Type, JsonSchema7Type];
+    minItems: 2;
+    maxItems: 2;
+  };
+};
+
+export function parseMapDef(def: ZodMapDef, refs: Refs): JsonSchema7MapType | JsonSchema7RecordType {
+  if (refs.mapStrategy === 'record') {
+    return parseRecordDef(def, refs);
+  }
+
+  const keys =
+    parseDef(def.keyType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'items', 'items', '0'],
+    }) || {};
+  const values =
+    parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'items', 'items', '1'],
+    }) || {};
+  return {
+    type: 'array',
+    maxItems: 125,
+    items: {
+      type: 'array',
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2,
+    },
+  };
+}

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

@@ -0,0 +1,27 @@
+import { ZodNativeEnumDef } from 'zod/v3';
+
+export type JsonSchema7NativeEnumType = {
+  type: 'string' | 'number' | ['string', 'number'];
+  enum: (string | number)[];
+};
+
+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 actualValues = actualKeys.map((key: string) => object[key]!);
+
+  const parsedTypes = Array.from(new Set(actualValues.map((values: string | number) => typeof values)));
+
+  return {
+    type:
+      parsedTypes.length === 1 ?
+        parsedTypes[0] === 'string' ?
+          'string'
+        : 'number'
+      : ['string', 'number'],
+    enum: actualValues,
+  };
+}

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

@@ -0,0 +1,9 @@
+export type JsonSchema7NeverType = {
+  not: {};
+};
+
+export function parseNeverDef(): JsonSchema7NeverType {
+  return {
+    not: {},
+  };
+}

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

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

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

@@ -0,0 +1,49 @@
+import { ZodNullableDef } from 'zod/v3';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7NullType } from './null';
+import { primitiveMappings } from './union';
+
+export type JsonSchema7NullableType =
+  | {
+      anyOf: [JsonSchema7Type, JsonSchema7NullType];
+    }
+  | {
+      type: [string, 'null'];
+    };
+
+export function parseNullableDef(def: ZodNullableDef, refs: Refs): JsonSchema7NullableType | undefined {
+  if (
+    ['ZodString', 'ZodNumber', 'ZodBigInt', 'ZodBoolean', 'ZodNull'].includes(def.innerType._def.typeName) &&
+    (!def.innerType._def.checks || !def.innerType._def.checks.length)
+  ) {
+    if (refs.target === 'openApi3' || refs.nullableStrategy === 'property') {
+      return {
+        type: primitiveMappings[def.innerType._def.typeName as keyof typeof primitiveMappings],
+        nullable: true,
+      } as any;
+    }
+
+    return {
+      type: [primitiveMappings[def.innerType._def.typeName as keyof typeof primitiveMappings], 'null'],
+    };
+  }
+
+  if (refs.target === 'openApi3') {
+    const base = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath],
+    });
+
+    if (base && '$ref' in base) return { allOf: [base], nullable: true } as any;
+
+    return base && ({ ...base, nullable: true } as any);
+  }
+
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'anyOf', '0'],
+  });
+
+  return base && { anyOf: [base, { type: 'null' }] };
+}

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

@@ -0,0 +1,62 @@
+import { ZodNumberDef } from 'zod/v3';
+import { addErrorMessage, ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { Refs } from '../Refs';
+
+export type JsonSchema7NumberType = {
+  type: 'number' | 'integer';
+  minimum?: number;
+  exclusiveMinimum?: number;
+  maximum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+  errorMessage?: ErrorMessages<JsonSchema7NumberType>;
+};
+
+export function parseNumberDef(def: ZodNumberDef, refs: Refs): JsonSchema7NumberType {
+  const res: JsonSchema7NumberType = {
+    type: 'number',
+  };
+
+  if (!def.checks) return res;
+
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case 'int':
+        res.type = 'integer';
+        addErrorMessage(res, 'type', check.message, refs);
+        break;
+      case 'min':
+        if (refs.target === 'jsonSchema7') {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, 'exclusiveMinimum', check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true as any;
+          }
+          setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
+        }
+        break;
+      case 'max':
+        if (refs.target === 'jsonSchema7') {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, 'exclusiveMaximum', check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true as any;
+          }
+          setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
+        }
+        break;
+      case 'multipleOf':
+        setResponseValueAndErrors(res, 'multipleOf', check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}

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

@@ -0,0 +1,76 @@
+import { ZodObjectDef } from 'zod/v3';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { 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, {
+          ...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;
+  }
+}
+
+export type JsonSchema7ObjectType = {
+  type: 'object';
+  properties: Record<string, JsonSchema7Type>;
+  additionalProperties: boolean | JsonSchema7Type;
+  required?: string[];
+};
+
+export function parseObjectDef(def: ZodObjectDef, refs: Refs) {
+  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: [] },
+    ),
+    additionalProperties: decideAdditionalProperties(def, refs),
+  };
+  if (!result.required!.length) delete result.required;
+  return result;
+}

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

@@ -0,0 +1,28 @@
+import { ZodOptionalDef } from 'zod/v3';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export const parseOptionalDef = (def: ZodOptionalDef, refs: Refs): JsonSchema7Type | undefined => {
+  if (
+    refs.propertyPath &&
+    refs.currentPath.slice(0, refs.propertyPath.length).toString() === refs.propertyPath.toString()
+  ) {
+    return parseDef(def.innerType._def, { ...refs, currentPath: refs.currentPath });
+  }
+
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'anyOf', '1'],
+  });
+
+  return innerSchema ?
+      {
+        anyOf: [
+          {
+            not: {},
+          },
+          innerSchema,
+        ],
+      }
+    : {};
+};

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

@@ -0,0 +1,28 @@
+import { ZodPipelineDef } from 'zod/v3';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7AllOfType } from './intersection';
+
+export const parsePipelineDef = (
+  def: ZodPipelineDef<any, any>,
+  refs: Refs,
+): JsonSchema7AllOfType | JsonSchema7Type | undefined => {
+  if (refs.pipeStrategy === 'input') {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === 'output') {
+    return parseDef(def.out._def, refs);
+  }
+
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'allOf', '0'],
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'allOf', a ? '1' : '0'],
+  });
+
+  return {
+    allOf: [a, b].filter((x): x is JsonSchema7Type => x !== undefined),
+  };
+};

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

@@ -0,0 +1,7 @@
+import { ZodPromiseDef } from 'zod/v3';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export function parsePromiseDef(def: ZodPromiseDef, refs: Refs): JsonSchema7Type | undefined {
+  return parseDef(def.type._def, refs);
+}

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

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

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

@@ -0,0 +1,73 @@
+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';
+
+type JsonSchema7RecordPropertyNamesType =
+  | Omit<JsonSchema7StringType, 'type'>
+  | Omit<JsonSchema7EnumType, 'type'>;
+
+export type JsonSchema7RecordType = {
+  type: 'object';
+  additionalProperties: JsonSchema7Type;
+  propertyNames?: JsonSchema7RecordPropertyNamesType;
+};
+
+export function parseRecordDef(
+  def: ZodRecordDef<ZodTypeAny, ZodTypeAny> | ZodMapDef,
+  refs: Refs,
+): JsonSchema7RecordType {
+  if (refs.target === 'openApi3' && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    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],
+            }) ?? {},
+        }),
+        {},
+      ),
+      additionalProperties: false,
+    } satisfies JsonSchema7ObjectType as any;
+  }
+
+  const schema: JsonSchema7RecordType = {
+    type: 'object',
+    additionalProperties:
+      parseDef(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'additionalProperties'],
+      }) ?? {},
+  };
+
+  if (refs.target === 'openApi3') {
+    return schema;
+  }
+
+  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 }), {});
+
+    return {
+      ...schema,
+      propertyNames: keyType,
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values,
+      },
+    };
+  }
+
+  return schema;
+}

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

@@ -0,0 +1,36 @@
+import { ZodSetDef } from 'zod/v3';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export type JsonSchema7SetType = {
+  type: 'array';
+  uniqueItems: true;
+  items?: JsonSchema7Type | undefined;
+  minItems?: number;
+  maxItems?: number;
+  errorMessage?: ErrorMessages<JsonSchema7SetType>;
+};
+
+export function parseSetDef(def: ZodSetDef, refs: Refs): JsonSchema7SetType {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'items'],
+  });
+
+  const schema: JsonSchema7SetType = {
+    type: 'array',
+    uniqueItems: true,
+    items,
+  };
+
+  if (def.minSize) {
+    setResponseValueAndErrors(schema, 'minItems', def.minSize.value, def.minSize.message, refs);
+  }
+
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, 'maxItems', def.maxSize.value, def.maxSize.message, refs);
+  }
+
+  return schema;
+}