@nfreeness/clawdbot 0.124.22101 → 0.124.22103

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

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

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

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

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

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

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

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

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

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

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

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

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