@nocobase/plugin-ai 2.0.0-alpha.9 → 2.0.0-beta.1

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/esm/selectParser.js

@@ -0,0 +1,106 @@
+import { ZodFirstPartyTypeKind } from "zod";
+import { parseAnyDef } from "./parsers/any.js";
+import { parseArrayDef } from "./parsers/array.js";
+import { parseBigintDef } from "./parsers/bigint.js";
+import { parseBooleanDef } from "./parsers/boolean.js";
+import { parseBrandedDef } from "./parsers/branded.js";
+import { parseCatchDef } from "./parsers/catch.js";
+import { parseDateDef } from "./parsers/date.js";
+import { parseDefaultDef } from "./parsers/default.js";
+import { parseEffectsDef } from "./parsers/effects.js";
+import { parseEnumDef } from "./parsers/enum.js";
+import { parseIntersectionDef } from "./parsers/intersection.js";
+import { parseLiteralDef } from "./parsers/literal.js";
+import { parseMapDef } from "./parsers/map.js";
+import { parseNativeEnumDef } from "./parsers/nativeEnum.js";
+import { parseNeverDef } from "./parsers/never.js";
+import { parseNullDef } from "./parsers/null.js";
+import { parseNullableDef } from "./parsers/nullable.js";
+import { parseNumberDef } from "./parsers/number.js";
+import { parseObjectDef } from "./parsers/object.js";
+import { parseOptionalDef } from "./parsers/optional.js";
+import { parsePipelineDef } from "./parsers/pipeline.js";
+import { parsePromiseDef } from "./parsers/promise.js";
+import { parseRecordDef } from "./parsers/record.js";
+import { parseSetDef } from "./parsers/set.js";
+import { parseStringDef } from "./parsers/string.js";
+import { parseTupleDef } from "./parsers/tuple.js";
+import { parseUndefinedDef } from "./parsers/undefined.js";
+import { parseUnionDef } from "./parsers/union.js";
+import { parseUnknownDef } from "./parsers/unknown.js";
+import { parseReadonlyDef } from "./parsers/readonly.js";
+export const selectParser = (def, typeName, refs) => {
+    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 () => def.getter()._def;
+        case ZodFirstPartyTypeKind.ZodPromise:
+            return parsePromiseDef(def, refs);
+        case ZodFirstPartyTypeKind.ZodNaN:
+        case ZodFirstPartyTypeKind.ZodNever:
+            return parseNeverDef();
+        case ZodFirstPartyTypeKind.ZodEffects:
+            return parseEffectsDef(def, refs);
+        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:
+            /* c8 ignore next */
+            return ((_) => undefined)(typeName);
+    }
+};

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js

@@ -0,0 +1,66 @@
+import { parseDef } from "./parseDef.js";
+import { getRefs } from "./Refs.js";
+const zodToJsonSchema = (schema, options) => {
+    const refs = getRefs(options);
+    const definitions = typeof options === "object" && options.definitions
+        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
+            ...acc,
+            [name]: parseDef(schema._def, {
+                ...refs,
+                currentPath: [...refs.basePath, refs.definitionPath, name],
+            }, true) ?? {},
+        }), {})
+        : undefined;
+    const name = typeof options === "string"
+        ? options
+        : options?.nameStrategy === "title"
+            ? undefined
+            : options?.name;
+    const main = parseDef(schema._def, name === undefined
+        ? refs
+        : {
+            ...refs,
+            currentPath: [...refs.basePath, refs.definitionPath, name],
+        }, false) ?? {};
+    const title = typeof options === "object" &&
+        options.name !== undefined &&
+        options.nameStrategy === "title"
+        ? options.name
+        : undefined;
+    if (title !== undefined) {
+        main.title = title;
+    }
+    const combined = name === undefined
+        ? definitions
+            ? {
+                ...main,
+                [refs.definitionPath]: definitions,
+            }
+            : main
+        : {
+            $ref: [
+                ...(refs.$refStrategy === "relative" ? [] : refs.basePath),
+                refs.definitionPath,
+                name,
+            ].join("/"),
+            [refs.definitionPath]: {
+                ...definitions,
+                [name]: main,
+            },
+        };
+    if (refs.target === "jsonSchema7") {
+        combined.$schema = "http://json-schema.org/draft-07/schema#";
+    }
+    else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+    }
+    if (refs.target === "openAi" &&
+        ("anyOf" in combined ||
+            "oneOf" in combined ||
+            "allOf" in combined ||
+            ("type" in combined && Array.isArray(combined.type)))) {
+        console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+    }
+    return combined;
+};
+export { zodToJsonSchema };

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/Options.d.ts

@@ -0,0 +1,36 @@
+import { ZodSchema, ZodTypeDef } from "zod";
+import { Refs, Seen } from "./Refs";
+import { JsonSchema7Type } from "./parseTypes";
+export type Targets = "jsonSchema7" | "jsonSchema2019-09" | "openApi3" | "openAi";
+export type DateStrategy = "format:date-time" | "format:date" | "string" | "integer";
+export declare const ignoreOverride: unique symbol;
+export type OverrideCallback = (def: ZodTypeDef, refs: Refs, seen: Seen | undefined, forceResolution?: boolean) => JsonSchema7Type | undefined | typeof ignoreOverride;
+export type PostProcessCallback = (jsonSchema: JsonSchema7Type | undefined, def: ZodTypeDef, refs: Refs) => JsonSchema7Type | undefined;
+export declare const jsonDescription: PostProcessCallback;
+export type Options<Target extends Targets = "jsonSchema7"> = {
+    name: string | undefined;
+    $refStrategy: "root" | "relative" | "none" | "seen";
+    basePath: string[];
+    effectStrategy: "input" | "any";
+    pipeStrategy: "input" | "output" | "all";
+    dateStrategy: DateStrategy | DateStrategy[];
+    mapStrategy: "entries" | "record";
+    removeAdditionalStrategy: "passthrough" | "strict";
+    allowedAdditionalProperties: true | undefined;
+    rejectedAdditionalProperties: false | undefined;
+    target: Target;
+    strictUnions: boolean;
+    definitionPath: string;
+    definitions: Record<string, ZodSchema>;
+    errorMessages: boolean;
+    markdownDescription: boolean;
+    patternStrategy: "escape" | "preserve";
+    applyRegexFlags: boolean;
+    emailStrategy: "format:email" | "format:idn-email" | "pattern:zod";
+    base64Strategy: "format:binary" | "contentEncoding:base64" | "pattern:zod";
+    nameStrategy: "ref" | "title";
+    override?: OverrideCallback;
+    postProcess?: PostProcessCallback;
+};
+export declare const defaultOptions: Options;
+export declare const getDefaultOptions: <Target extends Targets>(options: string | Partial<Options<Target>> | undefined) => Options<Target>;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/Refs.d.ts

@@ -0,0 +1,14 @@
+import { ZodTypeDef } from "zod";
+import { Options, Targets } from "./Options.js";
+import { JsonSchema7Type } from "./parseTypes.js";
+export type Refs = {
+    seen: Map<ZodTypeDef, Seen>;
+    currentPath: string[];
+    propertyPath: string[] | undefined;
+} & Options<Targets>;
+export type Seen = {
+    def: ZodTypeDef;
+    path: string[];
+    jsonSchema: JsonSchema7Type | undefined;
+};
+export declare const getRefs: (options?: string | Partial<Options<Targets>>) => Refs;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/errorMessages.d.ts

@@ -0,0 +1,11 @@
+import { JsonSchema7TypeUnion } from "./parseTypes.js";
+import { Refs } from "./Refs.js";
+export type ErrorMessages<T extends JsonSchema7TypeUnion, OmitProperties extends string = ""> = Partial<Omit<{
+    [key in keyof T]: string;
+}, OmitProperties | "type" | "errorMessages">>;
+export declare function addErrorMessage<T extends {
+    errorMessage?: ErrorMessages<any>;
+}>(res: T, key: keyof T, errorMessage: string | undefined, refs: Refs): void;
+export declare function setResponseValueAndErrors<Json7Type extends JsonSchema7TypeUnion & {
+    errorMessage?: ErrorMessages<Json7Type>;
+}, Key extends keyof Omit<Json7Type, "errorMessage">>(res: Json7Type, key: Key, value: Json7Type[Key], errorMessage: string | undefined, refs: Refs): void;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/index.d.ts

@@ -0,0 +1,39 @@
+export * from "./Options.js";
+export * from "./Refs.js";
+export * from "./errorMessages.js";
+export * from "./parseDef.js";
+export * from "./parseTypes.js";
+export * from "./parsers/any.js";
+export * from "./parsers/array.js";
+export * from "./parsers/bigint.js";
+export * from "./parsers/boolean.js";
+export * from "./parsers/branded.js";
+export * from "./parsers/catch.js";
+export * from "./parsers/date.js";
+export * from "./parsers/default.js";
+export * from "./parsers/effects.js";
+export * from "./parsers/enum.js";
+export * from "./parsers/intersection.js";
+export * from "./parsers/literal.js";
+export * from "./parsers/map.js";
+export * from "./parsers/nativeEnum.js";
+export * from "./parsers/never.js";
+export * from "./parsers/null.js";
+export * from "./parsers/nullable.js";
+export * from "./parsers/number.js";
+export * from "./parsers/object.js";
+export * from "./parsers/optional.js";
+export * from "./parsers/pipeline.js";
+export * from "./parsers/promise.js";
+export * from "./parsers/readonly.js";
+export * from "./parsers/record.js";
+export * from "./parsers/set.js";
+export * from "./parsers/string.js";
+export * from "./parsers/tuple.js";
+export * from "./parsers/undefined.js";
+export * from "./parsers/union.js";
+export * from "./parsers/unknown.js";
+export * from "./selectParser.js";
+export * from "./zodToJsonSchema.js";
+import { zodToJsonSchema } from "./zodToJsonSchema.js";
+export default zodToJsonSchema;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parseDef.d.ts

@@ -0,0 +1,4 @@
+import { ZodTypeDef } from "zod";
+import { Refs } from "./Refs.js";
+import { JsonSchema7Type } from "./parseTypes.js";
+export declare function parseDef(def: ZodTypeDef, refs: Refs, forceResolution?: boolean): JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parseTypes.d.ts

@@ -0,0 +1,34 @@
+import { JsonSchema7AnyType } from "./parsers/any.js";
+import { JsonSchema7ArrayType } from "./parsers/array.js";
+import { JsonSchema7BigintType } from "./parsers/bigint.js";
+import { JsonSchema7BooleanType } from "./parsers/boolean.js";
+import { JsonSchema7DateType } from "./parsers/date.js";
+import { JsonSchema7EnumType } from "./parsers/enum.js";
+import { JsonSchema7AllOfType } from "./parsers/intersection.js";
+import { JsonSchema7LiteralType } from "./parsers/literal.js";
+import { JsonSchema7MapType } from "./parsers/map.js";
+import { JsonSchema7NativeEnumType } from "./parsers/nativeEnum.js";
+import { JsonSchema7NeverType } from "./parsers/never.js";
+import { JsonSchema7NullType } from "./parsers/null.js";
+import { JsonSchema7NullableType } from "./parsers/nullable.js";
+import { JsonSchema7NumberType } from "./parsers/number.js";
+import { JsonSchema7ObjectType } from "./parsers/object.js";
+import { JsonSchema7RecordType } from "./parsers/record.js";
+import { JsonSchema7SetType } from "./parsers/set.js";
+import { JsonSchema7StringType } from "./parsers/string.js";
+import { JsonSchema7TupleType } from "./parsers/tuple.js";
+import { JsonSchema7UndefinedType } from "./parsers/undefined.js";
+import { JsonSchema7UnionType } from "./parsers/union.js";
+import { JsonSchema7UnknownType } from "./parsers/unknown.js";
+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 {};

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/any.d.ts

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

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/array.d.ts

@@ -0,0 +1,12 @@
+import { ZodArrayDef } from "zod";
+import { ErrorMessages } from "../errorMessages.js";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7ArrayType = {
+    type: "array";
+    items?: JsonSchema7Type;
+    minItems?: number;
+    maxItems?: number;
+    errorMessages?: ErrorMessages<JsonSchema7ArrayType, "items">;
+};
+export declare function parseArrayDef(def: ZodArrayDef, refs: Refs): JsonSchema7ArrayType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/bigint.d.ts

@@ -0,0 +1,14 @@
+import { ZodBigIntDef } from "zod";
+import { Refs } from "../Refs.js";
+import { ErrorMessages } from "../errorMessages.js";
+export type JsonSchema7BigintType = {
+    type: "integer";
+    format: "int64";
+    minimum?: BigInt;
+    exclusiveMinimum?: BigInt;
+    maximum?: BigInt;
+    exclusiveMaximum?: BigInt;
+    multipleOf?: BigInt;
+    errorMessage?: ErrorMessages<JsonSchema7BigintType>;
+};
+export declare function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7BigintType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/boolean.d.ts

@@ -0,0 +1,4 @@
+export type JsonSchema7BooleanType = {
+    type: "boolean";
+};
+export declare function parseBooleanDef(): JsonSchema7BooleanType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/branded.d.ts

@@ -0,0 +1,3 @@
+import { ZodBrandedDef } from "zod";
+import { Refs } from "../Refs.js";
+export declare function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs): import("../parseTypes.js").JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/catch.d.ts

@@ -0,0 +1,3 @@
+import { ZodCatchDef } from "zod";
+import { Refs } from "../Refs.js";
+export declare const parseCatchDef: (def: ZodCatchDef<any>, refs: Refs) => import("../parseTypes.js").JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/date.d.ts

@@ -0,0 +1,15 @@
+import { ZodDateDef } from "zod";
+import { Refs } from "../Refs.js";
+import { ErrorMessages } from "../errorMessages.js";
+import { JsonSchema7NumberType } from "./number.js";
+import { DateStrategy } from "../Options.js";
+export type JsonSchema7DateType = {
+    type: "integer" | "string";
+    format: "unix-time" | "date-time" | "date";
+    minimum?: number;
+    maximum?: number;
+    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
+} | {
+    anyOf: JsonSchema7DateType[];
+};
+export declare function parseDateDef(def: ZodDateDef, refs: Refs, overrideDateStrategy?: DateStrategy): JsonSchema7DateType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/default.d.ts

@@ -0,0 +1,6 @@
+import { ZodDefaultDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export declare function parseDefaultDef(_def: ZodDefaultDef, refs: Refs): JsonSchema7Type & {
+    default: any;
+};

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/effects.d.ts

@@ -0,0 +1,4 @@
+import { ZodEffectsDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export declare function parseEffectsDef(_def: ZodEffectsDef, refs: Refs): JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/enum.d.ts

@@ -0,0 +1,6 @@
+import { ZodEnumDef } from "zod";
+export type JsonSchema7EnumType = {
+    type: "string";
+    enum: string[];
+};
+export declare function parseEnumDef(def: ZodEnumDef): JsonSchema7EnumType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/intersection.d.ts

@@ -0,0 +1,8 @@
+import { ZodIntersectionDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7AllOfType = {
+    allOf: JsonSchema7Type[];
+    unevaluatedProperties?: boolean;
+};
+export declare function parseIntersectionDef(def: ZodIntersectionDef, refs: Refs): JsonSchema7AllOfType | JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/literal.d.ts

@@ -0,0 +1,9 @@
+import { ZodLiteralDef } from "zod";
+import { Refs } from "../Refs.js";
+export type JsonSchema7LiteralType = {
+    type: "string" | "number" | "integer" | "boolean";
+    const: string | number | boolean;
+} | {
+    type: "object" | "array";
+};
+export declare function parseLiteralDef(def: ZodLiteralDef, refs: Refs): JsonSchema7LiteralType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/map.d.ts

@@ -0,0 +1,15 @@
+import { ZodMapDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+import { JsonSchema7RecordType } from "./record.js";
+export type JsonSchema7MapType = {
+    type: "array";
+    maxItems: 125;
+    items: {
+        type: "array";
+        items: [JsonSchema7Type, JsonSchema7Type];
+        minItems: 2;
+        maxItems: 2;
+    };
+};
+export declare function parseMapDef(def: ZodMapDef, refs: Refs): JsonSchema7MapType | JsonSchema7RecordType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/nativeEnum.d.ts

@@ -0,0 +1,6 @@
+import { ZodNativeEnumDef } from "zod";
+export type JsonSchema7NativeEnumType = {
+    type: "string" | "number" | ["string", "number"];
+    enum: (string | number)[];
+};
+export declare function parseNativeEnumDef(def: ZodNativeEnumDef): JsonSchema7NativeEnumType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/never.d.ts

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

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/null.d.ts

@@ -0,0 +1,5 @@
+import { Refs } from "../Refs.js";
+export type JsonSchema7NullType = {
+    type: "null";
+};
+export declare function parseNullDef(refs: Refs): JsonSchema7NullType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/nullable.d.ts

@@ -0,0 +1,10 @@
+import { ZodNullableDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+import { JsonSchema7NullType } from "./null.js";
+export type JsonSchema7NullableType = {
+    anyOf: [JsonSchema7Type, JsonSchema7NullType];
+} | {
+    type: [string, "null"];
+};
+export declare function parseNullableDef(def: ZodNullableDef, refs: Refs): JsonSchema7NullableType | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/number.d.ts

@@ -0,0 +1,13 @@
+import { ZodNumberDef } from "zod";
+import { ErrorMessages } from "../errorMessages.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7NumberType = {
+    type: "number" | "integer";
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
+};
+export declare function parseNumberDef(def: ZodNumberDef, refs: Refs): JsonSchema7NumberType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/object.d.ts

@@ -0,0 +1,10 @@
+import { ZodObjectDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7ObjectType = {
+    type: "object";
+    properties: Record<string, JsonSchema7Type>;
+    additionalProperties?: boolean | JsonSchema7Type;
+    required?: string[];
+};
+export declare function parseObjectDef(def: ZodObjectDef, refs: Refs): JsonSchema7ObjectType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/optional.d.ts

@@ -0,0 +1,4 @@
+import { ZodOptionalDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export declare const parseOptionalDef: (def: ZodOptionalDef, refs: Refs) => JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/pipeline.d.ts

@@ -0,0 +1,5 @@
+import { ZodPipelineDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+import { JsonSchema7AllOfType } from "./intersection.js";
+export declare const parsePipelineDef: (def: ZodPipelineDef<any, any>, refs: Refs) => JsonSchema7AllOfType | JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/promise.d.ts

@@ -0,0 +1,4 @@
+import { ZodPromiseDef } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export declare function parsePromiseDef(def: ZodPromiseDef, refs: Refs): JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/readonly.d.ts

@@ -0,0 +1,3 @@
+import { ZodReadonlyDef } from "zod";
+import { Refs } from "../Refs.js";
+export declare const parseReadonlyDef: (def: ZodReadonlyDef<any>, refs: Refs) => import("../parseTypes.js").JsonSchema7Type | undefined;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/record.d.ts

@@ -0,0 +1,13 @@
+import { ZodMapDef, ZodRecordDef, ZodTypeAny } from "zod";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+import { JsonSchema7EnumType } from "./enum.js";
+import { JsonSchema7StringType } from "./string.js";
+type JsonSchema7RecordPropertyNamesType = Omit<JsonSchema7StringType, "type"> | Omit<JsonSchema7EnumType, "type">;
+export type JsonSchema7RecordType = {
+    type: "object";
+    additionalProperties?: JsonSchema7Type | true;
+    propertyNames?: JsonSchema7RecordPropertyNamesType;
+};
+export declare function parseRecordDef(def: ZodRecordDef<ZodTypeAny, ZodTypeAny> | ZodMapDef, refs: Refs): JsonSchema7RecordType;
+export {};

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/set.d.ts

@@ -0,0 +1,13 @@
+import { ZodSetDef } from "zod";
+import { ErrorMessages } from "../errorMessages.js";
+import { JsonSchema7Type } from "../parseTypes.js";
+import { Refs } from "../Refs.js";
+export type JsonSchema7SetType = {
+    type: "array";
+    uniqueItems: true;
+    items?: JsonSchema7Type;
+    minItems?: number;
+    maxItems?: number;
+    errorMessage?: ErrorMessages<JsonSchema7SetType>;
+};
+export declare function parseSetDef(def: ZodSetDef, refs: Refs): JsonSchema7SetType;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/types/parsers/string.d.ts

@@ -0,0 +1,73 @@
+import { ZodStringDef } from "zod";
+import { ErrorMessages } from "../errorMessages.js";
+import { Refs } from "../Refs.js";
+/**
+ * Generated from the regular expressions found here as of 2024-05-22:
+ * https://github.com/colinhacks/zod/blob/master/src/types.ts.
+ *
+ * Expressions with /i flag have been changed accordingly.
+ */
+export declare const zodPatterns: {
+    /**
+     * `c` was changed to `[cC]` to replicate /i flag
+     */
+    readonly cuid: RegExp;
+    readonly cuid2: RegExp;
+    readonly ulid: RegExp;
+    /**
+     * `a-z` was added to replicate /i flag
+     */
+    readonly email: RegExp;
+    /**
+     * Constructed a valid Unicode RegExp
+     *
+     * Lazily instantiate since this type of regex isn't supported
+     * in all envs (e.g. React Native).
+     *
+     * See:
+     * https://github.com/colinhacks/zod/issues/2433
+     * Fix in Zod:
+     * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+     */
+    readonly emoji: () => RegExp;
+    /**
+     * Unused
+     */
+    readonly uuid: RegExp;
+    /**
+     * Unused
+     */
+    readonly ipv4: RegExp;
+    readonly ipv4Cidr: RegExp;
+    /**
+     * Unused
+     */
+    readonly ipv6: RegExp;
+    readonly ipv6Cidr: RegExp;
+    readonly base64: RegExp;
+    readonly base64url: RegExp;
+    readonly nanoid: RegExp;
+    readonly jwt: RegExp;
+};
+export type JsonSchema7StringType = {
+    type: "string";
+    minLength?: number;
+    maxLength?: number;
+    format?: "email" | "idn-email" | "uri" | "uuid" | "date-time" | "ipv4" | "ipv6" | "date" | "time" | "duration";
+    pattern?: string;
+    allOf?: {
+        pattern: string;
+        errorMessage?: ErrorMessages<{
+            pattern: string;
+        }>;
+    }[];
+    anyOf?: {
+        format: string;
+        errorMessage?: ErrorMessages<{
+            format: string;
+        }>;
+    }[];
+    errorMessage?: ErrorMessages<JsonSchema7StringType>;
+    contentEncoding?: string;
+};
+export declare function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7StringType;