@nocobase/plugin-ai 1.9.36 → 1.9.38

package/dist/node_modules/@langchain/core/dist/utils/function_calling.js

@@ -1,13 +1,11 @@
-import { isLangChainTool, } from "../tools/types.js";
-import { toJsonSchema } from "./json_schema.js";
-// These utility functions were moved to a more appropriate location,
-// but we still export them here for backwards compatibility.
-export { isStructuredTool, isStructuredToolParams, isRunnableToolLike, isLangChainTool, } from "../tools/types.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { Runnable } from "../runnables/base.js";
+import { isZodSchema } from "./types/is_zod_schema.js";
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
- * that is compatible with OpenAI function calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, the output will be converted into a
- * JSON schema, which is then used as the parameters for the OpenAI tool.
+ * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
+ * function to convert the schema of the `StructuredTool` or `RunnableToolLike`
+ * into a JSON schema, which is then used as the parameters for the OpenAI function.
  *
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
@@ -18,16 +16,17 @@ export function convertToOpenAIFunction(tool, fields) {
     return {
         name: tool.name,
         description: tool.description,
-        parameters: toJsonSchema(tool.schema),
+        parameters: zodToJsonSchema(tool.schema),
         // Do not include the `strict` field if it is `undefined`.
         ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),
     };
 }
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
- * format that is compatible with OpenAI tool calling. If `StructuredTool` or
- * `RunnableToolLike` has a zod schema, the output will be converted into a
- * JSON schema, which is then used as the parameters for the OpenAI tool.
+ * format that is compatible with OpenAI tool calling. It uses the
+ * `zodToJsonSchema` function to convert the schema of the `StructuredTool`
+ * or `RunnableToolLike` into a JSON schema, which is then used as the
+ * parameters for the OpenAI tool.
  *
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
@@ -53,3 +52,56 @@ tool, fields) {
     }
     return toolDef;
 }
+/**
+ * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
+ *
+ * @param {StructuredToolInterface | Record<string, any> | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.
+ * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.
+ */
+export function isStructuredTool(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tool) {
+    return (tool !== undefined &&
+        Array.isArray(tool.lc_namespace));
+}
+/**
+ * Confirm whether the inputted tool is an instance of `RunnableToolLike`.
+ *
+ * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.
+ * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
+ */
+export function isRunnableToolLike(tool) {
+    return (tool !== undefined &&
+        Runnable.isRunnable(tool) &&
+        "lc_name" in tool.constructor &&
+        typeof tool.constructor.lc_name === "function" &&
+        tool.constructor.lc_name() === "RunnableToolLike");
+}
+/**
+ * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.
+ *
+ * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.
+ * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.
+ */
+export function isStructuredToolParams(tool) {
+    return (!!tool &&
+        typeof tool === "object" &&
+        "name" in tool &&
+        "schema" in tool &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        isZodSchema(tool.schema));
+}
+/**
+ * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.
+ * It returns `is StructuredToolParams` since that is the most minimal interface of the three,
+ * while still containing the necessary properties to be passed to a LLM for tool calling.
+ *
+ * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.
+ * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.
+ */
+export function isLangChainTool(tool) {
+    return (isStructuredToolParams(tool) ||
+        isRunnableToolLike(tool) ||
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        isStructuredTool(tool));
+}

package/dist/node_modules/@langchain/core/dist/utils/hash.cjs

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha256 = exports.insecureHash = void 0;
+exports.insecureHash = void 0;
 var hash_js_1 = require("./js-sha1/hash.cjs");
 Object.defineProperty(exports, "insecureHash", { enumerable: true, get: function () { return hash_js_1.insecureHash; } });
-var hash_js_2 = require("./js-sha256/hash.cjs");
-Object.defineProperty(exports, "sha256", { enumerable: true, get: function () { return hash_js_2.sha256; } });

package/dist/node_modules/@langchain/core/dist/utils/hash.d.ts

@@ -1,8 +1 @@
 export { insecureHash } from "./js-sha1/hash.js";
-export { sha256 } from "./js-sha256/hash.js";
-/**
- * A function type for encoding hash keys.
- * Accepts any number of string arguments (such as prompt and LLM key)
- * and returns a single string to be used as the hash key.
- */
-export type HashKeyEncoder = (...strings: string[]) => string;

package/dist/node_modules/@langchain/core/dist/utils/hash.js

@@ -1,2 +1 @@
 export { insecureHash } from "./js-sha1/hash.js";
-export { sha256 } from "./js-sha256/hash.js";

package/dist/node_modules/@langchain/core/dist/utils/js-sha1/hash.cjs

@@ -352,24 +352,7 @@ Sha1.prototype.arrayBuffer = function () {
     dataView.setUint32(16, this.h4);
     return buffer;
 };
-let hasLoggedWarning = false;
-/**
- * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.
- * This function will be removed in a future version.
- */
 const insecureHash = (message) => {
-    if (!hasLoggedWarning) {
-        console.warn([
-            `The default method for hashing keys is insecure and will be replaced in a future version,`,
-            `but hasn't been replaced yet as to not break existing caches. It's recommended that you use`,
-            `a more secure hashing algorithm to avoid cache poisoning.`,
-            ``,
-            `See this page for more information:`,
-            `|`,
-            `└> https://js.langchain.com/docs/troubleshooting/warnings/insecure-cache-algorithm`,
-        ].join("\n"));
-        hasLoggedWarning = true;
-    }
     return new Sha1(true).update(message)["hex"]();
 };
 exports.insecureHash = insecureHash;

package/dist/node_modules/@langchain/core/dist/utils/js-sha1/hash.d.ts

@@ -1,5 +1 @@
-/**
- * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.
- * This function will be removed in a future version.
- */
 export declare const insecureHash: (message: any) => any;

package/dist/node_modules/@langchain/core/dist/utils/js-sha1/hash.js

@@ -350,23 +350,6 @@ Sha1.prototype.arrayBuffer = function () {
     dataView.setUint32(16, this.h4);
     return buffer;
 };
-let hasLoggedWarning = false;
-/**
- * @deprecated Use `makeDefaultKeyEncoder()` to create a custom key encoder.
- * This function will be removed in a future version.
- */
 export const insecureHash = (message) => {
-    if (!hasLoggedWarning) {
-        console.warn([
-            `The default method for hashing keys is insecure and will be replaced in a future version,`,
-            `but hasn't been replaced yet as to not break existing caches. It's recommended that you use`,
-            `a more secure hashing algorithm to avoid cache poisoning.`,
-            ``,
-            `See this page for more information:`,
-            `|`,
-            `└> https://js.langchain.com/docs/troubleshooting/warnings/insecure-cache-algorithm`,
-        ].join("\n"));
-        hasLoggedWarning = true;
-    }
     return new Sha1(true).update(message)["hex"]();
 };

package/dist/node_modules/@langchain/core/dist/utils/json.cjs

@@ -1,31 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJsonMarkdown = parseJsonMarkdown;
-exports.parsePartialJson = parsePartialJson;
+exports.parsePartialJson = exports.parseJsonMarkdown = void 0;
 function parseJsonMarkdown(s, parser = parsePartialJson) {
     // eslint-disable-next-line no-param-reassign
     s = s.trim();
-    const firstFenceIndex = s.indexOf("```");
-    if (firstFenceIndex === -1) {
+    const match = /```(json)?(.*)```/s.exec(s);
+    if (!match) {
         return parser(s);
     }
-    let contentAfterFence = s.substring(firstFenceIndex + 3);
-    if (contentAfterFence.startsWith("json\n")) {
-        contentAfterFence = contentAfterFence.substring(5);
-    }
-    else if (contentAfterFence.startsWith("json")) {
-        contentAfterFence = contentAfterFence.substring(4);
-    }
-    else if (contentAfterFence.startsWith("\n")) {
-        contentAfterFence = contentAfterFence.substring(1);
+    else {
+        return parser(match[2]);
     }
-    const closingFenceIndex = contentAfterFence.indexOf("```");
-    let finalContent = contentAfterFence;
-    if (closingFenceIndex !== -1) {
-        finalContent = contentAfterFence.substring(0, closingFenceIndex);
-    }
-    return parser(finalContent.trim());
 }
+exports.parseJsonMarkdown = parseJsonMarkdown;
 // Adapted from https://github.com/KillianLucas/open-interpreter/blob/main/interpreter/core/llm/utils/parse_partial_json.py
 // MIT License
 function parsePartialJson(s) {
@@ -103,3 +90,4 @@ function parsePartialJson(s) {
         return null;
     }
 }
+exports.parsePartialJson = parsePartialJson;

package/dist/node_modules/@langchain/core/dist/utils/json.js

@@ -1,26 +1,13 @@
 export function parseJsonMarkdown(s, parser = parsePartialJson) {
     // eslint-disable-next-line no-param-reassign
     s = s.trim();
-    const firstFenceIndex = s.indexOf("```");
-    if (firstFenceIndex === -1) {
+    const match = /```(json)?(.*)```/s.exec(s);
+    if (!match) {
         return parser(s);
     }
-    let contentAfterFence = s.substring(firstFenceIndex + 3);
-    if (contentAfterFence.startsWith("json\n")) {
-        contentAfterFence = contentAfterFence.substring(5);
+    else {
+        return parser(match[2]);
     }
-    else if (contentAfterFence.startsWith("json")) {
-        contentAfterFence = contentAfterFence.substring(4);
-    }
-    else if (contentAfterFence.startsWith("\n")) {
-        contentAfterFence = contentAfterFence.substring(1);
-    }
-    const closingFenceIndex = contentAfterFence.indexOf("```");
-    let finalContent = contentAfterFence;
-    if (closingFenceIndex !== -1) {
-        finalContent = contentAfterFence.substring(0, closingFenceIndex);
-    }
-    return parser(finalContent.trim());
 }
 // Adapted from https://github.com/KillianLucas/open-interpreter/blob/main/interpreter/core/llm/utils/parse_partial_json.py
 // MIT License

package/dist/node_modules/@langchain/core/dist/utils/json_schema.cjs

@@ -1,98 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validator = exports.deepCompareStrict = void 0;
-exports.toJsonSchema = toJsonSchema;
-exports.validatesOnlyStrings = validatesOnlyStrings;
-const core_1 = require("zod/v4/core");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const json_schema_1 = require("@cfworker/json-schema");
-const zod_js_1 = require("./types/zod.cjs");
-var json_schema_2 = require("@cfworker/json-schema");
-Object.defineProperty(exports, "deepCompareStrict", { enumerable: true, get: function () { return json_schema_2.deepCompareStrict; } });
-Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return json_schema_2.Validator; } });
-/**
- * Converts a Zod schema or JSON schema to a JSON schema.
- * @param schema - The schema to convert.
- * @returns The converted schema.
- */
-function toJsonSchema(schema) {
-    if ((0, zod_js_1.isZodSchemaV4)(schema)) {
-        const inputSchema = (0, zod_js_1.interopZodTransformInputSchema)(schema, true);
-        if ((0, zod_js_1.isZodObjectV4)(inputSchema)) {
-            const strictSchema = (0, zod_js_1.interopZodObjectStrict)(inputSchema, true);
-            return (0, core_1.toJSONSchema)(strictSchema);
-        }
-        else {
-            return (0, core_1.toJSONSchema)(schema);
-        }
-    }
-    if ((0, zod_js_1.isZodSchemaV3)(schema)) {
-        return (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
-    }
-    return schema;
-}
-/**
- * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
- * (like recursive or unresolvable refs).
- *
- * @param schema - The schema to validate.
- * @returns `true` if the schema validates only strings, `false` otherwise.
- */
-function validatesOnlyStrings(schema) {
-    // Null, undefined, or empty schema
-    if (!schema ||
-        typeof schema !== "object" ||
-        Object.keys(schema).length === 0 ||
-        Array.isArray(schema)) {
-        return false; // Validates anything, not just strings
-    }
-    // Explicit type constraint
-    if ("type" in schema) {
-        if (typeof schema.type === "string") {
-            return schema.type === "string";
-        }
-        if (Array.isArray(schema.type)) {
-            // not sure why someone would do `"type": ["string"]` or especially `"type": ["string",
-            // "string", "string", ...]` but we're not here to judge
-            return schema.type.every((t) => t === "string");
-        }
-        return false; // Invalid or non-string type
-    }
-    // Enum with only string values
-    if ("enum" in schema) {
-        return (Array.isArray(schema.enum) &&
-            schema.enum.length > 0 &&
-            schema.enum.every((val) => typeof val === "string"));
-    }
-    // String constant
-    if ("const" in schema) {
-        return typeof schema.const === "string";
-    }
-    // Schema combinations
-    if ("allOf" in schema && Array.isArray(schema.allOf)) {
-        // If any subschema validates only strings, then the overall schema validates only strings
-        return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));
-    }
-    if (("anyOf" in schema && Array.isArray(schema.anyOf)) ||
-        ("oneOf" in schema && Array.isArray(schema.oneOf))) {
-        const subschemas = ("anyOf" in schema ? schema.anyOf : schema.oneOf);
-        // All subschemas must validate only strings
-        return (subschemas.length > 0 &&
-            subschemas.every((subschema) => validatesOnlyStrings(subschema)));
-    }
-    // We're not going to try on this one, it's too complex - we just assume if it has a "not" key and hasn't matched one of the above checks, it's not a string schema.
-    if ("not" in schema) {
-        return false; // The not case can validate non-strings
-    }
-    if ("$ref" in schema && typeof schema.$ref === "string") {
-        const ref = schema.$ref;
-        const resolved = (0, json_schema_1.dereference)(schema);
-        if (resolved[ref]) {
-            return validatesOnlyStrings(resolved[ref]);
-        }
-        return false;
-    }
-    // ignore recursive refs and other cases where type is omitted for now
-    // ignore other cases for now where type is omitted
-    return false;
-}
+var json_schema_1 = require("@cfworker/json-schema");
+Object.defineProperty(exports, "deepCompareStrict", { enumerable: true, get: function () { return json_schema_1.deepCompareStrict; } });
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return json_schema_1.Validator; } });

package/dist/node_modules/@langchain/core/dist/utils/json_schema.d.ts

@@ -1,19 +1 @@
-import { type JsonSchema7Type } from "zod-to-json-schema";
-import { InteropZodType } from "./types/zod.js";
-export type JSONSchema = JsonSchema7Type;
 export { deepCompareStrict, Validator } from "@cfworker/json-schema";
-/**
- * Converts a Zod schema or JSON schema to a JSON schema.
- * @param schema - The schema to convert.
- * @returns The converted schema.
- */
-export declare function toJsonSchema(schema: InteropZodType | JSONSchema): JSONSchema;
-/**
- * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
- * (like recursive or unresolvable refs).
- *
- * @param schema - The schema to validate.
- * @returns `true` if the schema validates only strings, `false` otherwise.
- */
-export declare function validatesOnlyStrings(schema: unknown): boolean;
-export { type JsonSchema7Type, type JsonSchema7ArrayType, type JsonSchema7ObjectType, type JsonSchema7StringType, type JsonSchema7NumberType, type JsonSchema7NullableType, } from "zod-to-json-schema";

package/dist/node_modules/@langchain/core/dist/utils/json_schema.js

@@ -1,91 +1 @@
-import { toJSONSchema } from "zod/v4/core";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { dereference } from "@cfworker/json-schema";
-import { isZodSchemaV3, isZodSchemaV4, interopZodObjectStrict, isZodObjectV4, interopZodTransformInputSchema, } from "./types/zod.js";
 export { deepCompareStrict, Validator } from "@cfworker/json-schema";
-/**
- * Converts a Zod schema or JSON schema to a JSON schema.
- * @param schema - The schema to convert.
- * @returns The converted schema.
- */
-export function toJsonSchema(schema) {
-    if (isZodSchemaV4(schema)) {
-        const inputSchema = interopZodTransformInputSchema(schema, true);
-        if (isZodObjectV4(inputSchema)) {
-            const strictSchema = interopZodObjectStrict(inputSchema, true);
-            return toJSONSchema(strictSchema);
-        }
-        else {
-            return toJSONSchema(schema);
-        }
-    }
-    if (isZodSchemaV3(schema)) {
-        return zodToJsonSchema(schema);
-    }
-    return schema;
-}
-/**
- * Validates if a JSON schema validates only strings. May return false negatives in some edge cases
- * (like recursive or unresolvable refs).
- *
- * @param schema - The schema to validate.
- * @returns `true` if the schema validates only strings, `false` otherwise.
- */
-export function validatesOnlyStrings(schema) {
-    // Null, undefined, or empty schema
-    if (!schema ||
-        typeof schema !== "object" ||
-        Object.keys(schema).length === 0 ||
-        Array.isArray(schema)) {
-        return false; // Validates anything, not just strings
-    }
-    // Explicit type constraint
-    if ("type" in schema) {
-        if (typeof schema.type === "string") {
-            return schema.type === "string";
-        }
-        if (Array.isArray(schema.type)) {
-            // not sure why someone would do `"type": ["string"]` or especially `"type": ["string",
-            // "string", "string", ...]` but we're not here to judge
-            return schema.type.every((t) => t === "string");
-        }
-        return false; // Invalid or non-string type
-    }
-    // Enum with only string values
-    if ("enum" in schema) {
-        return (Array.isArray(schema.enum) &&
-            schema.enum.length > 0 &&
-            schema.enum.every((val) => typeof val === "string"));
-    }
-    // String constant
-    if ("const" in schema) {
-        return typeof schema.const === "string";
-    }
-    // Schema combinations
-    if ("allOf" in schema && Array.isArray(schema.allOf)) {
-        // If any subschema validates only strings, then the overall schema validates only strings
-        return schema.allOf.some((subschema) => validatesOnlyStrings(subschema));
-    }
-    if (("anyOf" in schema && Array.isArray(schema.anyOf)) ||
-        ("oneOf" in schema && Array.isArray(schema.oneOf))) {
-        const subschemas = ("anyOf" in schema ? schema.anyOf : schema.oneOf);
-        // All subschemas must validate only strings
-        return (subschemas.length > 0 &&
-            subschemas.every((subschema) => validatesOnlyStrings(subschema)));
-    }
-    // We're not going to try on this one, it's too complex - we just assume if it has a "not" key and hasn't matched one of the above checks, it's not a string schema.
-    if ("not" in schema) {
-        return false; // The not case can validate non-strings
-    }
-    if ("$ref" in schema && typeof schema.$ref === "string") {
-        const ref = schema.$ref;
-        const resolved = dereference(schema);
-        if (resolved[ref]) {
-            return validatesOnlyStrings(resolved[ref]);
-        }
-        return false;
-    }
-    // ignore recursive refs and other cases where type is omitted for now
-    // ignore other cases for now where type is omitted
-    return false;
-}

package/dist/node_modules/@langchain/core/dist/utils/math.cjs

@@ -1,11 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matrixFunc = matrixFunc;
-exports.normalize = normalize;
-exports.cosineSimilarity = cosineSimilarity;
-exports.innerProduct = innerProduct;
-exports.euclideanDistance = euclideanDistance;
-exports.maximalMarginalRelevance = maximalMarginalRelevance;
+exports.maximalMarginalRelevance = exports.euclideanDistance = exports.innerProduct = exports.cosineSimilarity = exports.normalize = exports.matrixFunc = void 0;
 const similarities_js_1 = require("./ml-distance/similarities.cjs");
 const distances_js_1 = require("./ml-distance/distances.cjs");
 const euclidean_js_1 = require("./ml-distance-euclidean/euclidean.cjs");
@@ -35,10 +30,12 @@ function matrixFunc(X, Y, func) {
     }
     return X.map((xVector) => Y.map((yVector) => func(xVector, yVector)).map((similarity) => Number.isNaN(similarity) ? 0 : similarity));
 }
+exports.matrixFunc = matrixFunc;
 function normalize(M, similarity = false) {
     const max = matrixMaxVal(M);
     return M.map((row) => row.map((val) => (similarity ? 1 - val / max : val / max)));
 }
+exports.normalize = normalize;
 /**
  * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
  *
@@ -52,12 +49,15 @@ function normalize(M, similarity = false) {
 function cosineSimilarity(X, Y) {
     return matrixFunc(X, Y, similarities_js_1.cosine);
 }
+exports.cosineSimilarity = cosineSimilarity;
 function innerProduct(X, Y) {
     return matrixFunc(X, Y, distances_js_1.innerProduct);
 }
+exports.innerProduct = innerProduct;
 function euclideanDistance(X, Y) {
     return matrixFunc(X, Y, euclidean_js_1.euclidean);
 }
+exports.euclideanDistance = euclideanDistance;
 /**
  * This function implements the Maximal Marginal Relevance algorithm
  * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
@@ -98,6 +98,7 @@ function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = 0.5, k
     }
     return selectedEmbeddingsIndexes;
 }
+exports.maximalMarginalRelevance = maximalMarginalRelevance;
 /**
  * Finds the index of the maximum value in the given array.
  * @param {number[]} array - The input array.

package/dist/node_modules/@langchain/core/dist/utils/ml-distance/distances.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.innerProduct = innerProduct;
+exports.innerProduct = void 0;
 /**
  *Returns the Inner Product similarity between vectors a and b
  * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
@@ -15,3 +15,4 @@ function innerProduct(a, b) {
     }
     return ans;
 }
+exports.innerProduct = innerProduct;

package/dist/node_modules/@langchain/core/dist/utils/ml-distance/similarities.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cosine = cosine;
+exports.cosine = void 0;
 /**
  * Returns the average of cosine distances between vectors a and b
  * @param a - first vector
@@ -18,3 +18,4 @@ function cosine(a, b) {
     }
     return p / (Math.sqrt(p2) * Math.sqrt(q2));
 }
+exports.cosine = cosine;

package/dist/node_modules/@langchain/core/dist/utils/ml-distance-euclidean/euclidean.cjs

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.squaredEuclidean = squaredEuclidean;
-exports.euclidean = euclidean;
+exports.euclidean = exports.squaredEuclidean = void 0;
 function squaredEuclidean(p, q) {
     let d = 0;
     for (let i = 0; i < p.length; i++) {
@@ -9,6 +8,8 @@ function squaredEuclidean(p, q) {
     }
     return d;
 }
+exports.squaredEuclidean = squaredEuclidean;
 function euclidean(p, q) {
     return Math.sqrt(squaredEuclidean(p, q));
 }
+exports.euclidean = euclidean;

package/dist/node_modules/@langchain/core/dist/utils/sax-js/sax.cjs

@@ -282,41 +282,41 @@ const initializeSax = function () {
     }
     var S = 0;
     sax.STATE = {
-        BEGIN: S++, // leading byte order mark or whitespace
-        BEGIN_WHITESPACE: S++, // leading whitespace
-        TEXT: S++, // general stuff
-        TEXT_ENTITY: S++, // &amp and such.
-        OPEN_WAKA: S++, // <
-        SGML_DECL: S++, // <!BLARG
-        SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
-        DOCTYPE: S++, // <!DOCTYPE
-        DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
-        DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
-        DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
-        COMMENT_STARTING: S++, // <!-
-        COMMENT: S++, // <!--
-        COMMENT_ENDING: S++, // <!-- blah -
-        COMMENT_ENDED: S++, // <!-- blah --
-        CDATA: S++, // <![CDATA[ something
-        CDATA_ENDING: S++, // ]
-        CDATA_ENDING_2: S++, // ]]
-        PROC_INST: S++, // <?hi
-        PROC_INST_BODY: S++, // <?hi there
-        PROC_INST_ENDING: S++, // <?hi "there" ?
-        OPEN_TAG: S++, // <strong
-        OPEN_TAG_SLASH: S++, // <strong /
-        ATTRIB: S++, // <a
-        ATTRIB_NAME: S++, // <a foo
-        ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
-        ATTRIB_VALUE: S++, // <a foo=
-        ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
-        ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
-        ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
-        ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
-        ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
-        CLOSE_TAG: S++, // </a
-        CLOSE_TAG_SAW_WHITE: S++, // </a   >
-        SCRIPT: S++, // <script> ...
+        BEGIN: S++,
+        BEGIN_WHITESPACE: S++,
+        TEXT: S++,
+        TEXT_ENTITY: S++,
+        OPEN_WAKA: S++,
+        SGML_DECL: S++,
+        SGML_DECL_QUOTED: S++,
+        DOCTYPE: S++,
+        DOCTYPE_QUOTED: S++,
+        DOCTYPE_DTD: S++,
+        DOCTYPE_DTD_QUOTED: S++,
+        COMMENT_STARTING: S++,
+        COMMENT: S++,
+        COMMENT_ENDING: S++,
+        COMMENT_ENDED: S++,
+        CDATA: S++,
+        CDATA_ENDING: S++,
+        CDATA_ENDING_2: S++,
+        PROC_INST: S++,
+        PROC_INST_BODY: S++,
+        PROC_INST_ENDING: S++,
+        OPEN_TAG: S++,
+        OPEN_TAG_SLASH: S++,
+        ATTRIB: S++,
+        ATTRIB_NAME: S++,
+        ATTRIB_NAME_SAW_WHITE: S++,
+        ATTRIB_VALUE: S++,
+        ATTRIB_VALUE_QUOTED: S++,
+        ATTRIB_VALUE_CLOSED: S++,
+        ATTRIB_VALUE_UNQUOTED: S++,
+        ATTRIB_VALUE_ENTITY_Q: S++,
+        ATTRIB_VALUE_ENTITY_U: S++,
+        CLOSE_TAG: S++,
+        CLOSE_TAG_SAW_WHITE: S++,
+        SCRIPT: S++,
         SCRIPT_ENDING: S++, // <script> ... <
     };
     sax.XML_ENTITIES = {