openai 4.53.2 → 4.55.0

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

@@ -0,0 +1,49 @@
+import { ZodNullableDef } from 'zod';
+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') {
+      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';
+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,63 @@
+import { ZodObjectDef } from 'zod';
+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 parsedDef = parseDef(propDef._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, 'properties', propName],
+          propertyPath: [...refs.currentPath, 'properties', propName],
+        });
+        if (parsedDef === undefined) return acc;
+        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,25 @@
+import { ZodOptionalDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export const parseOptionalDef = (def: ZodOptionalDef, refs: Refs): JsonSchema7Type | undefined => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef(def.innerType._def, refs);
+  }
+
+  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';
+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';
+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';
+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';
+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';
+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;
+}