@nfreeness/clawdbot 0.124.22101 → 0.124.22103

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parseDef.ts

@@ -1,258 +0,0 @@
-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 { parseBrandedDef } from './parsers/branded';
-import { parseCatchDef } from './parsers/catch';
-import { JsonSchema7DateType, 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 { 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 { parseReadonlyDef } from './parsers/readonly';
-import { ignoreOverride } from './Options';
-
-type JsonSchema7RefType = { $ref: string };
-type JsonSchema7Meta = {
-  title?: string;
-  default?: any;
-  description?: string;
-  markdownDescription?: string;
-};
-
-export type JsonSchema7TypeUnion =
-  | JsonSchema7StringType
-  | JsonSchema7ArrayType
-  | JsonSchema7NumberType
-  | JsonSchema7BigintType
-  | JsonSchema7BooleanType
-  | JsonSchema7DateType
-  | JsonSchema7EnumType
-  | JsonSchema7LiteralType
-  | JsonSchema7NativeEnumType
-  | JsonSchema7NullType
-  | JsonSchema7NumberType
-  | JsonSchema7ObjectType
-  | JsonSchema7RecordType
-  | JsonSchema7TupleType
-  | JsonSchema7UnionType
-  | JsonSchema7UndefinedType
-  | JsonSchema7RefType
-  | JsonSchema7NeverType
-  | JsonSchema7MapType
-  | JsonSchema7AnyType
-  | JsonSchema7NullableType
-  | JsonSchema7AllOfType
-  | JsonSchema7UnknownType
-  | JsonSchema7SetType;
-
-export type JsonSchema7Type = JsonSchema7TypeUnion & JsonSchema7Meta;
-
-export function parseDef(
-  def: ZodTypeDef,
-  refs: Refs,
-  forceResolution = false, // Forces a new schema to be instantiated even though its def has been seen. Used for improving refs in definitions. See https://github.com/StefanTerdell/zod-to-json-schema/pull/61.
-): JsonSchema7Type | undefined {
-  const seenItem = refs.seen.get(def);
-
-  if (refs.override) {
-    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
-
-    if (overrideResult !== ignoreOverride) {
-      return overrideResult;
-    }
-  }
-
-  if (seenItem && !forceResolution) {
-    const seenSchema = get$ref(seenItem, refs);
-
-    if (seenSchema !== undefined) {
-      if ('$ref' in seenSchema) {
-        refs.seenRefs.add(seenSchema.$ref);
-      }
-
-      return seenSchema;
-    }
-  }
-
-  const newItem: Seen = { def, path: refs.currentPath, jsonSchema: undefined };
-
-  refs.seen.set(def, newItem);
-
-  const jsonSchema = selectParser(def, (def as any).typeName, refs, forceResolution);
-
-  if (jsonSchema) {
-    addMeta(def, refs, jsonSchema);
-  }
-
-  newItem.jsonSchema = jsonSchema;
-
-  return jsonSchema;
-}
-
-const get$ref = (
-  item: Seen,
-  refs: Refs,
-):
-  | {
-      $ref: string;
-    }
-  | {}
-  | undefined => {
-  switch (refs.$refStrategy) {
-    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
-    // the schema to `#/definitions/` and reference that.
-    //
-    // 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.slice(refs.basePath.length + 1).join('_');
-
-      // 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;
-      }
-
-      return { $ref: [...refs.basePath, refs.definitionPath, name].join('/') };
-    case 'relative':
-      return { $ref: getRelativePath(refs.currentPath, item.path) };
-    case 'none':
-    case 'seen': {
-      if (
-        item.path.length < refs.currentPath.length &&
-        item.path.every((value, index) => refs.currentPath[index] === value)
-      ) {
-        console.warn(`Recursive reference detected at ${refs.currentPath.join('/')}! Defaulting to any`);
-
-        return {};
-      }
-
-      return refs.$refStrategy === 'seen' ? {} : undefined;
-    }
-  }
-};
-
-const getRelativePath = (pathA: string[], pathB: string[]) => {
-  let i = 0;
-  for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i]) break;
-  }
-  return [(pathA.length - i).toString(), ...pathB.slice(i)].join('/');
-};
-
-const selectParser = (
-  def: any,
-  typeName: ZodFirstPartyTypeKind,
-  refs: Refs,
-  forceResolution: boolean,
-): JsonSchema7Type | undefined => {
-  switch (typeName) {
-    case ZodFirstPartyTypeKind.ZodString:
-      return parseStringDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodNumber:
-      return parseNumberDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodObject:
-      return parseObjectDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBigInt:
-      return parseBigintDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBoolean:
-      return parseBooleanDef();
-    case ZodFirstPartyTypeKind.ZodDate:
-      return parseDateDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodUndefined:
-      return parseUndefinedDef();
-    case ZodFirstPartyTypeKind.ZodNull:
-      return parseNullDef(refs);
-    case ZodFirstPartyTypeKind.ZodArray:
-      return parseArrayDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodUnion:
-    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodIntersection:
-      return parseIntersectionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodTuple:
-      return parseTupleDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodRecord:
-      return parseRecordDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLiteral:
-      return parseLiteralDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodEnum:
-      return parseEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNativeEnum:
-      return parseNativeEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNullable:
-      return parseNullableDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodOptional:
-      return parseOptionalDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodMap:
-      return parseMapDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodSet:
-      return parseSetDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLazy:
-      return parseDef(def.getter()._def, refs);
-    case ZodFirstPartyTypeKind.ZodPromise:
-      return parsePromiseDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodNaN:
-    case ZodFirstPartyTypeKind.ZodNever:
-      return parseNeverDef();
-    case ZodFirstPartyTypeKind.ZodEffects:
-      return parseEffectsDef(def, refs, forceResolution);
-    case ZodFirstPartyTypeKind.ZodAny:
-      return parseAnyDef();
-    case ZodFirstPartyTypeKind.ZodUnknown:
-      return parseUnknownDef();
-    case ZodFirstPartyTypeKind.ZodDefault:
-      return parseDefaultDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBranded:
-      return parseBrandedDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodReadonly:
-      return parseReadonlyDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodCatch:
-      return parseCatchDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodPipeline:
-      return parsePipelineDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodFunction:
-    case ZodFirstPartyTypeKind.ZodVoid:
-    case ZodFirstPartyTypeKind.ZodSymbol:
-      return undefined;
-    default:
-      return ((_: never) => undefined)(typeName);
-  }
-};
-
-const addMeta = (def: ZodTypeDef, refs: Refs, jsonSchema: JsonSchema7Type): JsonSchema7Type => {
-  if (def.description) {
-    jsonSchema.description = def.description;
-
-    if (refs.markdownDescription) {
-      jsonSchema.markdownDescription = def.description;
-    }
-  }
-  return jsonSchema;
-};

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/any.ts

@@ -1,5 +0,0 @@
-export type JsonSchema7AnyType = {};
-
-export function parseAnyDef(): JsonSchema7AnyType {
-  return {};
-}

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/array.ts

@@ -1,36 +0,0 @@
-import { ZodArrayDef, ZodFirstPartyTypeKind } from 'zod/v3';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-
-export type JsonSchema7ArrayType = {
-  type: 'array';
-  items?: JsonSchema7Type | undefined;
-  minItems?: number;
-  maxItems?: number;
-  errorMessages?: ErrorMessages<JsonSchema7ArrayType, 'items'>;
-};
-
-export function parseArrayDef(def: ZodArrayDef, refs: Refs) {
-  const res: JsonSchema7ArrayType = {
-    type: 'array',
-  };
-  if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
-    res.items = parseDef(def.type._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, 'items'],
-    });
-  }
-
-  if (def.minLength) {
-    setResponseValueAndErrors(res, 'minItems', def.minLength.value, def.minLength.message, refs);
-  }
-  if (def.maxLength) {
-    setResponseValueAndErrors(res, 'maxItems', def.maxLength.value, def.maxLength.message, refs);
-  }
-  if (def.exactLength) {
-    setResponseValueAndErrors(res, 'minItems', def.exactLength.value, def.exactLength.message, refs);
-    setResponseValueAndErrors(res, 'maxItems', def.exactLength.value, def.exactLength.message, refs);
-  }
-  return res;
-}

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/bigint.ts

@@ -1,60 +0,0 @@
-import { ZodBigIntDef } from 'zod/v3';
-import { Refs } from '../Refs';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-
-export type JsonSchema7BigintType = {
-  type: 'integer';
-  format: 'int64';
-  minimum?: BigInt;
-  exclusiveMinimum?: BigInt;
-  maximum?: BigInt;
-  exclusiveMaximum?: BigInt;
-  multipleOf?: BigInt;
-  errorMessage?: ErrorMessages<JsonSchema7BigintType>;
-};
-
-export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7BigintType {
-  const res: JsonSchema7BigintType = {
-    type: 'integer',
-    format: 'int64',
-  };
-
-  if (!def.checks) return res;
-
-  for (const check of def.checks) {
-    switch (check.kind) {
-      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/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/boolean.ts

@@ -1,9 +0,0 @@
-export type JsonSchema7BooleanType = {
-  type: 'boolean';
-};
-
-export function parseBooleanDef(): JsonSchema7BooleanType {
-  return {
-    type: 'boolean',
-  };
-}

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/branded.ts

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

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/catch.ts

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

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/date.ts

@@ -1,83 +0,0 @@
-import { ZodDateDef } from 'zod/v3';
-import { Refs } from '../Refs';
-import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
-import { JsonSchema7NumberType } from './number';
-import { DateStrategy } from '../Options';
-
-export type JsonSchema7DateType =
-  | {
-      type: 'integer' | 'string';
-      format: 'unix-time' | 'date-time' | 'date';
-      minimum?: number;
-      maximum?: number;
-      errorMessage?: ErrorMessages<JsonSchema7NumberType>;
-    }
-  | {
-      anyOf: JsonSchema7DateType[];
-    };
-
-export function parseDateDef(
-  def: ZodDateDef,
-  refs: Refs,
-  overrideDateStrategy?: DateStrategy,
-): JsonSchema7DateType {
-  const strategy = overrideDateStrategy ?? refs.dateStrategy;
-
-  if (Array.isArray(strategy)) {
-    return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),
-    };
-  }
-
-  switch (strategy) {
-    case 'string':
-    case 'format:date-time':
-      return {
-        type: 'string',
-        format: 'date-time',
-      };
-    case 'format:date':
-      return {
-        type: 'string',
-        format: 'date',
-      };
-    case 'integer':
-      return integerDateParser(def, refs);
-  }
-}
-
-const integerDateParser = (def: ZodDateDef, refs: Refs) => {
-  const res: JsonSchema7DateType = {
-    type: 'integer',
-    format: 'unix-time',
-  };
-
-  if (refs.target === 'openApi3') {
-    return res;
-  }
-
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case 'min':
-        setResponseValueAndErrors(
-          res,
-          'minimum',
-          check.value, // This is in milliseconds
-          check.message,
-          refs,
-        );
-        break;
-      case 'max':
-        setResponseValueAndErrors(
-          res,
-          'maximum',
-          check.value, // This is in milliseconds
-          check.message,
-          refs,
-        );
-        break;
-    }
-  }
-
-  return res;
-};

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/default.ts

@@ -1,10 +0,0 @@
-import { ZodDefaultDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-
-export function parseDefaultDef(_def: ZodDefaultDef, refs: Refs): JsonSchema7Type & { default: any } {
-  return {
-    ...parseDef(_def.innerType._def, refs),
-    default: _def.defaultValue(),
-  };
-}

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/effects.ts

@@ -1,11 +0,0 @@
-import { ZodEffectsDef } from 'zod/v3';
-import { JsonSchema7Type, parseDef } from '../parseDef';
-import { Refs } from '../Refs';
-
-export function parseEffectsDef(
-  _def: ZodEffectsDef,
-  refs: Refs,
-  forceResolution: boolean,
-): JsonSchema7Type | undefined {
-  return refs.effectStrategy === 'input' ? parseDef(_def.schema._def, refs, forceResolution) : {};
-}

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/enum.ts

@@ -1,13 +0,0 @@
-import { ZodEnumDef } from 'zod/v3';
-
-export type JsonSchema7EnumType = {
-  type: 'string';
-  enum: string[];
-};
-
-export function parseEnumDef(def: ZodEnumDef): JsonSchema7EnumType {
-  return {
-    type: 'string',
-    enum: [...def.values],
-  };
-}

package/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/intersection.ts

@@ -1,64 +0,0 @@
-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/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/literal.ts

@@ -1,37 +0,0 @@
-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/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/map.ts

@@ -1,42 +0,0 @@
-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/extensions/memory-lancedb/node_modules/.ignored_openai/src/_vendor/zod-to-json-schema/parsers/nativeEnum.ts

@@ -1,27 +0,0 @@
-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,
-  };
-}