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

package/dist/node_modules/@langchain/ollama/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../v4/mini/index.cjs"), exports);

package/dist/node_modules/@langchain/ollama/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.cjs";

package/dist/node_modules/@langchain/ollama/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/dist/node_modules/@langchain/ollama/node_modules/zod/v4-mini/index.js

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [StefanTerdell]

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/.prettierrc.json

@@ -0,0 +1 @@
+{}

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/createIndex.ts

@@ -0,0 +1,32 @@
+import { readdirSync, writeFileSync, statSync } from "fs";
+
+const ignore = ["src/index.ts"];
+
+function checkSrcDir(path: string): string[] {
+  const lines: string[] = [];
+
+  for (const item of readdirSync(path)) {
+    const itemPath = path + "/" + item;
+
+    if (ignore.includes(itemPath)) {
+      continue;
+    }
+
+    if (statSync(itemPath).isDirectory()) {
+      lines.push(...checkSrcDir(itemPath));
+    } else if (item.endsWith(".ts")) {
+      lines.push('export * from "./' + itemPath.slice(4, -2) + 'js"');
+    }
+  }
+
+  return lines;
+}
+
+const lines = checkSrcDir("src");
+
+lines.push(
+  'import { zodToJsonSchema } from "./zodToJsonSchema.js"',
+  "export default zodToJsonSchema;",
+);
+
+writeFileSync("./src/index.ts", lines.join(";\n"));

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/Options.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultOptions = exports.defaultOptions = exports.jsonDescription = exports.ignoreOverride = void 0;
+exports.ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+const jsonDescription = (jsonSchema, def) => {
+    if (def.description) {
+        try {
+            return {
+                ...jsonSchema,
+                ...JSON.parse(def.description),
+            };
+        }
+        catch { }
+    }
+    return jsonSchema;
+};
+exports.jsonDescription = jsonDescription;
+exports.defaultOptions = {
+    name: undefined,
+    $refStrategy: "root",
+    basePath: ["#"],
+    effectStrategy: "input",
+    pipeStrategy: "all",
+    dateStrategy: "format:date-time",
+    mapStrategy: "entries",
+    removeAdditionalStrategy: "passthrough",
+    allowedAdditionalProperties: true,
+    rejectedAdditionalProperties: false,
+    definitionPath: "definitions",
+    target: "jsonSchema7",
+    strictUnions: false,
+    definitions: {},
+    errorMessages: false,
+    markdownDescription: false,
+    patternStrategy: "escape",
+    applyRegexFlags: false,
+    emailStrategy: "format:email",
+    base64Strategy: "contentEncoding:base64",
+    nameStrategy: "ref",
+};
+const getDefaultOptions = (options) => (typeof options === "string"
+    ? {
+        ...exports.defaultOptions,
+        name: options,
+    }
+    : {
+        ...exports.defaultOptions,
+        ...options,
+    });
+exports.getDefaultOptions = getDefaultOptions;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/Refs.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefs = void 0;
+const Options_js_1 = require("./Options.js");
+const getRefs = (options) => {
+    const _options = (0, Options_js_1.getDefaultOptions)(options);
+    const currentPath = _options.name !== undefined
+        ? [..._options.basePath, _options.definitionPath, _options.name]
+        : _options.basePath;
+    return {
+        ..._options,
+        currentPath: currentPath,
+        propertyPath: undefined,
+        seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+            def._def,
+            {
+                def: def._def,
+                path: [..._options.basePath, _options.definitionPath, name],
+                // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+                jsonSchema: undefined,
+            },
+        ])),
+    };
+};
+exports.getRefs = getRefs;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/errorMessages.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setResponseValueAndErrors = exports.addErrorMessage = void 0;
+function addErrorMessage(res, key, errorMessage, refs) {
+    if (!refs?.errorMessages)
+        return;
+    if (errorMessage) {
+        res.errorMessage = {
+            ...res.errorMessage,
+            [key]: errorMessage,
+        };
+    }
+}
+exports.addErrorMessage = addErrorMessage;
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+    res[key] = value;
+    addErrorMessage(res, key, errorMessage, refs);
+}
+exports.setResponseValueAndErrors = setResponseValueAndErrors;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Options.js"), exports);
+__exportStar(require("./Refs.js"), exports);
+__exportStar(require("./errorMessages.js"), exports);
+__exportStar(require("./parseDef.js"), exports);
+__exportStar(require("./parseTypes.js"), exports);
+__exportStar(require("./parsers/any.js"), exports);
+__exportStar(require("./parsers/array.js"), exports);
+__exportStar(require("./parsers/bigint.js"), exports);
+__exportStar(require("./parsers/boolean.js"), exports);
+__exportStar(require("./parsers/branded.js"), exports);
+__exportStar(require("./parsers/catch.js"), exports);
+__exportStar(require("./parsers/date.js"), exports);
+__exportStar(require("./parsers/default.js"), exports);
+__exportStar(require("./parsers/effects.js"), exports);
+__exportStar(require("./parsers/enum.js"), exports);
+__exportStar(require("./parsers/intersection.js"), exports);
+__exportStar(require("./parsers/literal.js"), exports);
+__exportStar(require("./parsers/map.js"), exports);
+__exportStar(require("./parsers/nativeEnum.js"), exports);
+__exportStar(require("./parsers/never.js"), exports);
+__exportStar(require("./parsers/null.js"), exports);
+__exportStar(require("./parsers/nullable.js"), exports);
+__exportStar(require("./parsers/number.js"), exports);
+__exportStar(require("./parsers/object.js"), exports);
+__exportStar(require("./parsers/optional.js"), exports);
+__exportStar(require("./parsers/pipeline.js"), exports);
+__exportStar(require("./parsers/promise.js"), exports);
+__exportStar(require("./parsers/readonly.js"), exports);
+__exportStar(require("./parsers/record.js"), exports);
+__exportStar(require("./parsers/set.js"), exports);
+__exportStar(require("./parsers/string.js"), exports);
+__exportStar(require("./parsers/tuple.js"), exports);
+__exportStar(require("./parsers/undefined.js"), exports);
+__exportStar(require("./parsers/union.js"), exports);
+__exportStar(require("./parsers/unknown.js"), exports);
+__exportStar(require("./selectParser.js"), exports);
+__exportStar(require("./zodToJsonSchema.js"), exports);
+const zodToJsonSchema_js_1 = require("./zodToJsonSchema.js");
+exports.default = zodToJsonSchema_js_1.zodToJsonSchema;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parseDef.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDef = void 0;
+const Options_js_1 = require("./Options.js");
+const selectParser_js_1 = require("./selectParser.js");
+function parseDef(def, refs, forceResolution = false) {
+    const seenItem = refs.seen.get(def);
+    if (refs.override) {
+        const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+        if (overrideResult !== Options_js_1.ignoreOverride) {
+            return overrideResult;
+        }
+    }
+    if (seenItem && !forceResolution) {
+        const seenSchema = get$ref(seenItem, refs);
+        if (seenSchema !== undefined) {
+            return seenSchema;
+        }
+    }
+    const newItem = { def, path: refs.currentPath, jsonSchema: undefined };
+    refs.seen.set(def, newItem);
+    const jsonSchemaOrGetter = (0, selectParser_js_1.selectParser)(def, def.typeName, refs);
+    // If the return was a function, then the inner definition needs to be extracted before a call to parseDef (recursive)
+    const jsonSchema = typeof jsonSchemaOrGetter === "function"
+        ? parseDef(jsonSchemaOrGetter(), refs)
+        : jsonSchemaOrGetter;
+    if (jsonSchema) {
+        addMeta(def, refs, jsonSchema);
+    }
+    if (refs.postProcess) {
+        const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+        newItem.jsonSchema = jsonSchema;
+        return postProcessResult;
+    }
+    newItem.jsonSchema = jsonSchema;
+    return jsonSchema;
+}
+exports.parseDef = parseDef;
+const get$ref = (item, refs) => {
+    switch (refs.$refStrategy) {
+        case "root":
+            return { $ref: item.path.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, pathB) => {
+    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 addMeta = (def, refs, jsonSchema) => {
+    if (def.description) {
+        jsonSchema.description = def.description;
+        if (refs.markdownDescription) {
+            jsonSchema.markdownDescription = def.description;
+        }
+    }
+    return jsonSchema;
+};

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parseTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/any.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAnyDef = void 0;
+function parseAnyDef() {
+    return {};
+}
+exports.parseAnyDef = parseAnyDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/array.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArrayDef = void 0;
+const zod_1 = require("zod");
+const errorMessages_js_1 = require("../errorMessages.js");
+const parseDef_js_1 = require("../parseDef.js");
+function parseArrayDef(def, refs) {
+    const res = {
+        type: "array",
+    };
+    if (def.type?._def &&
+        def.type?._def?.typeName !== zod_1.ZodFirstPartyTypeKind.ZodAny) {
+        res.items = (0, parseDef_js_1.parseDef)(def.type._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "items"],
+        });
+    }
+    if (def.minLength) {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minItems", def.minLength.value, def.minLength.message, refs);
+    }
+    if (def.maxLength) {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+    }
+    if (def.exactLength) {
+        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+    }
+    return res;
+}
+exports.parseArrayDef = parseArrayDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/bigint.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBigintDef = void 0;
+const errorMessages_js_1 = require("../errorMessages.js");
+function parseBigintDef(def, refs) {
+    const res = {
+        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) {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
+                    }
+                    else {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "exclusiveMinimum", check.value, check.message, refs);
+                    }
+                }
+                else {
+                    if (!check.inclusive) {
+                        res.exclusiveMinimum = true;
+                    }
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, check.message, refs);
+                }
+                break;
+            case "max":
+                if (refs.target === "jsonSchema7") {
+                    if (check.inclusive) {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
+                    }
+                    else {
+                        (0, errorMessages_js_1.setResponseValueAndErrors)(res, "exclusiveMaximum", check.value, check.message, refs);
+                    }
+                }
+                else {
+                    if (!check.inclusive) {
+                        res.exclusiveMaximum = true;
+                    }
+                    (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, check.message, refs);
+                }
+                break;
+            case "multipleOf":
+                (0, errorMessages_js_1.setResponseValueAndErrors)(res, "multipleOf", check.value, check.message, refs);
+                break;
+        }
+    }
+    return res;
+}
+exports.parseBigintDef = parseBigintDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/boolean.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBooleanDef = void 0;
+function parseBooleanDef() {
+    return {
+        type: "boolean",
+    };
+}
+exports.parseBooleanDef = parseBooleanDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/branded.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBrandedDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+function parseBrandedDef(_def, refs) {
+    return (0, parseDef_js_1.parseDef)(_def.type._def, refs);
+}
+exports.parseBrandedDef = parseBrandedDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/catch.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCatchDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const parseCatchDef = (def, refs) => {
+    return (0, parseDef_js_1.parseDef)(def.innerType._def, refs);
+};
+exports.parseCatchDef = parseCatchDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/date.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDateDef = void 0;
+const errorMessages_js_1 = require("../errorMessages.js");
+function parseDateDef(def, refs, overrideDateStrategy) {
+    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);
+    }
+}
+exports.parseDateDef = parseDateDef;
+const integerDateParser = (def, refs) => {
+    const res = {
+        type: "integer",
+        format: "unix-time",
+    };
+    if (refs.target === "openApi3") {
+        return res;
+    }
+    for (const check of def.checks) {
+        switch (check.kind) {
+            case "min":
+                (0, errorMessages_js_1.setResponseValueAndErrors)(res, "minimum", check.value, // This is in milliseconds
+                check.message, refs);
+                break;
+            case "max":
+                (0, errorMessages_js_1.setResponseValueAndErrors)(res, "maximum", check.value, // This is in milliseconds
+                check.message, refs);
+                break;
+        }
+    }
+    return res;
+};

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/default.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDefaultDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+function parseDefaultDef(_def, refs) {
+    return {
+        ...(0, parseDef_js_1.parseDef)(_def.innerType._def, refs),
+        default: _def.defaultValue(),
+    };
+}
+exports.parseDefaultDef = parseDefaultDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/effects.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEffectsDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+function parseEffectsDef(_def, refs) {
+    return refs.effectStrategy === "input"
+        ? (0, parseDef_js_1.parseDef)(_def.schema._def, refs)
+        : {};
+}
+exports.parseEffectsDef = parseEffectsDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnumDef = void 0;
+function parseEnumDef(def) {
+    return {
+        type: "string",
+        enum: Array.from(def.values),
+    };
+}
+exports.parseEnumDef = parseEnumDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/intersection.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIntersectionDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const isJsonSchema7AllOfType = (type) => {
+    if ("type" in type && type.type === "string")
+        return false;
+    return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+    const allOf = [
+        (0, parseDef_js_1.parseDef)(def.left._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "allOf", "0"],
+        }),
+        (0, parseDef_js_1.parseDef)(def.right._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, "allOf", "1"],
+        }),
+    ].filter((x) => !!x);
+    let unevaluatedProperties = refs.target === "jsonSchema2019-09"
+        ? { unevaluatedProperties: false }
+        : undefined;
+    const mergedAllOf = [];
+    // 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 = 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;
+}
+exports.parseIntersectionDef = parseIntersectionDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/literal.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLiteralDef = void 0;
+function parseLiteralDef(def, refs) {
+    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],
+        };
+    }
+    return {
+        type: parsedType === "bigint" ? "integer" : parsedType,
+        const: def.value,
+    };
+}
+exports.parseLiteralDef = parseLiteralDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/map.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMapDef = void 0;
+const parseDef_js_1 = require("../parseDef.js");
+const record_js_1 = require("./record.js");
+function parseMapDef(def, refs) {
+    if (refs.mapStrategy === "record") {
+        return (0, record_js_1.parseRecordDef)(def, refs);
+    }
+    const keys = (0, parseDef_js_1.parseDef)(def.keyType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", "items", "0"],
+    }) || {};
+    const values = (0, parseDef_js_1.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,
+        },
+    };
+}
+exports.parseMapDef = parseMapDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/nativeEnum.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNativeEnumDef = void 0;
+function parseNativeEnumDef(def) {
+    const object = def.values;
+    const actualKeys = Object.keys(def.values).filter((key) => {
+        return typeof object[object[key]] !== "number";
+    });
+    const actualValues = actualKeys.map((key) => object[key]);
+    const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+    return {
+        type: parsedTypes.length === 1
+            ? parsedTypes[0] === "string"
+                ? "string"
+                : "number"
+            : ["string", "number"],
+        enum: actualValues,
+    };
+}
+exports.parseNativeEnumDef = parseNativeEnumDef;

package/dist/node_modules/@langchain/ollama/node_modules/zod-to-json-schema/dist/cjs/parsers/never.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNeverDef = void 0;
+function parseNeverDef() {
+    return {
+        not: {},
+    };
+}
+exports.parseNeverDef = parseNeverDef;