@langchain/core 0.2.19 → 0.2.21

package/dist/runnables/config.cjs

@@ -24,6 +24,31 @@ function mergeConfigs(...configs) {
             else if (key === "configurable") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
+            else if (key === "timeout") {
+                if (copy.timeout === undefined) {
+                    copy.timeout = options.timeout;
+                }
+                else if (options.timeout !== undefined) {
+                    copy.timeout = Math.min(copy.timeout, options.timeout);
+                }
+            }
+            else if (key === "signal") {
+                if (copy.signal === undefined) {
+                    copy.signal = options.signal;
+                }
+                else if (options.signal !== undefined) {
+                    if ("any" in AbortSignal) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        copy.signal = AbortSignal.any([
+                            copy.signal,
+                            options.signal,
+                        ]);
+                    }
+                    else {
+                        copy.signal = options.signal;
+                    }
+                }
+            }
             else if (key === "callbacks") {
                 const baseCallbacks = copy.callbacks;
                 const providedCallbacks = options.callbacks;
@@ -130,6 +155,22 @@ function ensureConfig(config) {
             }
         }
     }
+    if (empty.timeout !== undefined) {
+        if (empty.timeout <= 0) {
+            throw new Error("Timeout must be a positive number");
+        }
+        const timeoutSignal = AbortSignal.timeout(empty.timeout);
+        if (empty.signal !== undefined) {
+            if ("any" in AbortSignal) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                empty.signal = AbortSignal.any([empty.signal, timeoutSignal]);
+            }
+        }
+        else {
+            empty.signal = timeoutSignal;
+        }
+        delete empty.timeout;
+    }
     return empty;
 }
 exports.ensureConfig = ensureConfig;

package/dist/runnables/config.js

@@ -20,6 +20,31 @@ export function mergeConfigs(...configs) {
             else if (key === "configurable") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
+            else if (key === "timeout") {
+                if (copy.timeout === undefined) {
+                    copy.timeout = options.timeout;
+                }
+                else if (options.timeout !== undefined) {
+                    copy.timeout = Math.min(copy.timeout, options.timeout);
+                }
+            }
+            else if (key === "signal") {
+                if (copy.signal === undefined) {
+                    copy.signal = options.signal;
+                }
+                else if (options.signal !== undefined) {
+                    if ("any" in AbortSignal) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        copy.signal = AbortSignal.any([
+                            copy.signal,
+                            options.signal,
+                        ]);
+                    }
+                    else {
+                        copy.signal = options.signal;
+                    }
+                }
+            }
             else if (key === "callbacks") {
                 const baseCallbacks = copy.callbacks;
                 const providedCallbacks = options.callbacks;
@@ -125,6 +150,22 @@ export function ensureConfig(config) {
             }
         }
     }
+    if (empty.timeout !== undefined) {
+        if (empty.timeout <= 0) {
+            throw new Error("Timeout must be a positive number");
+        }
+        const timeoutSignal = AbortSignal.timeout(empty.timeout);
+        if (empty.signal !== undefined) {
+            if ("any" in AbortSignal) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                empty.signal = AbortSignal.any([empty.signal, timeoutSignal]);
+            }
+        }
+        else {
+            empty.signal = timeoutSignal;
+        }
+        delete empty.timeout;
+    }
     return empty;
 }
 /**

package/dist/runnables/remote.cjs

@@ -186,9 +186,10 @@ function deserialize(str) {
     const obj = JSON.parse(str);
     return revive(obj);
 }
-function removeCallbacks(options) {
+function removeCallbacksAndSignal(options) {
     const rest = { ...options };
     delete rest.callbacks;
+    delete rest.signal;
     return rest;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -253,7 +254,7 @@ class RemoteRunnable extends base_js_1.Runnable {
         this.url = url.replace(/\/$/, ""); // remove trailing slash
         this.options = options;
     }
-    async post(path, body) {
+    async post(path, body, signal) {
         return fetch(`${this.url}${path}`, {
             method: "POST",
             body: JSON.stringify(serialize(body)),
@@ -261,16 +262,16 @@ class RemoteRunnable extends base_js_1.Runnable {
                 "Content-Type": "application/json",
                 ...this.options?.headers,
             },
-            signal: AbortSignal.timeout(this.options?.timeout ?? 60000),
+            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
     async _invoke(input, options, _) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const response = await this.post("/invoke", {
             input,
-            config: removeCallbacks(config),
+            config: removeCallbacksAndSignal(config),
             kwargs: kwargs ?? {},
-        });
+        }, config.signal);
         if (!response.ok) {
             throw new Error(`${response.status} Error: ${await response.text()}`);
         }
@@ -291,10 +292,10 @@ class RemoteRunnable extends base_js_1.Runnable {
         const response = await this.post("/batch", {
             inputs,
             config: (configs ?? [])
-                .map(removeCallbacks)
+                .map(removeCallbacksAndSignal)
                 .map((config) => ({ ...config, ...batchOptions })),
             kwargs,
-        });
+        }, options?.[0]?.signal);
         if (!response.ok) {
             throw new Error(`${response.status} Error: ${await response.text()}`);
         }
@@ -319,9 +320,9 @@ class RemoteRunnable extends base_js_1.Runnable {
         try {
             const response = await this.post("/stream", {
                 input,
-                config: removeCallbacks(config),
+                config: removeCallbacksAndSignal(config),
                 kwargs,
-            });
+            }, config.signal);
             if (!response.ok) {
                 const json = await response.json();
                 const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
@@ -378,11 +379,11 @@ class RemoteRunnable extends base_js_1.Runnable {
         try {
             const response = await this.post("/stream_log", {
                 input,
-                config: removeCallbacks(config),
+                config: removeCallbacksAndSignal(config),
                 kwargs,
                 ...camelCaseStreamOptions,
                 diff: false,
-            });
+            }, config.signal);
             const { body, ok } = response;
             if (!ok) {
                 throw new Error(`${response.status} Error: ${await response.text()}`);
@@ -430,11 +431,11 @@ class RemoteRunnable extends base_js_1.Runnable {
             try {
                 const response = await outerThis.post("/stream_events", {
                     input,
-                    config: removeCallbacks(config),
+                    config: removeCallbacksAndSignal(config),
                     kwargs,
                     ...camelCaseStreamOptions,
                     diff: false,
-                });
+                }, config.signal);
                 const { body, ok } = response;
                 if (!ok) {
                     throw new Error(`${response.status} Error: ${await response.text()}`);

package/dist/runnables/remote.js

@@ -183,9 +183,10 @@ function deserialize(str) {
     const obj = JSON.parse(str);
     return revive(obj);
 }
-function removeCallbacks(options) {
+function removeCallbacksAndSignal(options) {
     const rest = { ...options };
     delete rest.callbacks;
+    delete rest.signal;
     return rest;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -250,7 +251,7 @@ export class RemoteRunnable extends Runnable {
         this.url = url.replace(/\/$/, ""); // remove trailing slash
         this.options = options;
     }
-    async post(path, body) {
+    async post(path, body, signal) {
         return fetch(`${this.url}${path}`, {
             method: "POST",
             body: JSON.stringify(serialize(body)),
@@ -258,16 +259,16 @@ export class RemoteRunnable extends Runnable {
                 "Content-Type": "application/json",
                 ...this.options?.headers,
             },
-            signal: AbortSignal.timeout(this.options?.timeout ?? 60000),
+            signal: signal ?? AbortSignal.timeout(this.options?.timeout ?? 60000),
         });
     }
     async _invoke(input, options, _) {
         const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
         const response = await this.post("/invoke", {
             input,
-            config: removeCallbacks(config),
+            config: removeCallbacksAndSignal(config),
             kwargs: kwargs ?? {},
-        });
+        }, config.signal);
         if (!response.ok) {
             throw new Error(`${response.status} Error: ${await response.text()}`);
         }
@@ -288,10 +289,10 @@ export class RemoteRunnable extends Runnable {
         const response = await this.post("/batch", {
             inputs,
             config: (configs ?? [])
-                .map(removeCallbacks)
+                .map(removeCallbacksAndSignal)
                 .map((config) => ({ ...config, ...batchOptions })),
             kwargs,
-        });
+        }, options?.[0]?.signal);
         if (!response.ok) {
             throw new Error(`${response.status} Error: ${await response.text()}`);
         }
@@ -316,9 +317,9 @@ export class RemoteRunnable extends Runnable {
         try {
             const response = await this.post("/stream", {
                 input,
-                config: removeCallbacks(config),
+                config: removeCallbacksAndSignal(config),
                 kwargs,
-            });
+            }, config.signal);
             if (!response.ok) {
                 const json = await response.json();
                 const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
@@ -375,11 +376,11 @@ export class RemoteRunnable extends Runnable {
         try {
             const response = await this.post("/stream_log", {
                 input,
-                config: removeCallbacks(config),
+                config: removeCallbacksAndSignal(config),
                 kwargs,
                 ...camelCaseStreamOptions,
                 diff: false,
-            });
+            }, config.signal);
             const { body, ok } = response;
             if (!ok) {
                 throw new Error(`${response.status} Error: ${await response.text()}`);
@@ -427,11 +428,11 @@ export class RemoteRunnable extends Runnable {
             try {
                 const response = await outerThis.post("/stream_events", {
                     input,
-                    config: removeCallbacks(config),
+                    config: removeCallbacksAndSignal(config),
                     kwargs,
                     ...camelCaseStreamOptions,
                     diff: false,
-                });
+                }, config.signal);
                 const { body, ok } = response;
                 if (!ok) {
                     throw new Error(`${response.status} Error: ${await response.text()}`);

package/dist/runnables/types.d.ts

@@ -53,4 +53,14 @@ export interface RunnableConfig extends BaseCallbackConfig {
     recursionLimit?: number;
     /** Maximum number of parallel calls to make. */
     maxConcurrency?: number;
+    /**
+     * Timeout for this call in milliseconds.
+     */
+    timeout?: number;
+    /**
+     * Abort signal for this call.
+     * If provided, the call will be aborted when the signal is aborted.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+     */
+    signal?: AbortSignal;
 }

package/dist/tools/index.d.ts

@@ -26,8 +26,17 @@ export interface ToolParams extends BaseLangChainParams {
      */
     responseFormat?: ResponseFormat;
 }
+export interface StructuredToolParams extends Pick<StructuredToolInterface, "name" | "schema"> {
+    /**
+     * An optional description of the tool to pass to the model.
+     */
+    description?: string;
+}
 export interface StructuredToolInterface<T extends ZodObjectAny = ZodObjectAny> extends RunnableInterface<(z.output<T> extends string ? string : never) | z.input<T> | ToolCall, ToolReturnType> {
     lc_namespace: string[];
+    /**
+     * A Zod schema representing the parameters of the tool.
+     */
     schema: T | z.ZodEffects<T>;
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
@@ -43,7 +52,13 @@ export interface StructuredToolInterface<T extends ZodObjectAny = ZodObjectAny>
     call(arg: (z.output<T> extends string ? string : never) | z.input<T> | ToolCall, configArg?: Callbacks | RunnableConfig, 
     /** @deprecated */
     tags?: string[]): Promise<ToolReturnType>;
+    /**
+     * The name of the tool.
+     */
     name: string;
+    /**
+     * A description of the tool.
+     */
     description: string;
     returnDirect: boolean;
 }

package/dist/utils/function_calling.cjs

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRunnableToolLike = exports.isStructuredTool = exports.convertToOpenAITool = exports.convertToOpenAIFunction = void 0;
+exports.isLangChainTool = exports.isStructuredToolParams = exports.isRunnableToolLike = exports.isStructuredTool = exports.convertToOpenAITool = exports.convertToOpenAIFunction = void 0;
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const base_js_1 = require("../runnables/base.cjs");
+const is_zod_schema_js_1 = require("./types/is_zod_schema.cjs");
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a format
  * that is compatible with OpenAI function calling. It uses the `zodToJsonSchema`
@@ -12,11 +13,15 @@ const base_js_1 = require("../runnables/base.cjs");
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
-function convertToOpenAIFunction(tool) {
+function convertToOpenAIFunction(tool, fields) {
+    // @TODO 0.3.0 Remove the `number` typing
+    const fieldsCopy = typeof fields === "number" ? undefined : fields;
     return {
         name: tool.name,
         description: tool.description,
         parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema),
+        // Do not include the `strict` field if it is `undefined`.
+        ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),
     };
 }
 exports.convertToOpenAIFunction = convertToOpenAIFunction;
@@ -32,14 +37,23 @@ exports.convertToOpenAIFunction = convertToOpenAIFunction;
  */
 function convertToOpenAITool(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-tool) {
-    if (isStructuredTool(tool) || isRunnableToolLike(tool)) {
-        return {
+tool, fields) {
+    // @TODO 0.3.0 Remove the `number` typing
+    const fieldsCopy = typeof fields === "number" ? undefined : fields;
+    let toolDef;
+    if (isLangChainTool(tool)) {
+        toolDef = {
             type: "function",
             function: convertToOpenAIFunction(tool),
         };
     }
-    return tool;
+    else {
+        toolDef = tool;
+    }
+    if (fieldsCopy?.strict !== undefined) {
+        toolDef.function.strict = fieldsCopy.strict;
+    }
+    return toolDef;
 }
 exports.convertToOpenAITool = convertToOpenAITool;
 /**
@@ -69,3 +83,33 @@ function isRunnableToolLike(tool) {
         tool.constructor.lc_name() === "RunnableToolLike");
 }
 exports.isRunnableToolLike = isRunnableToolLike;
+/**
+ * 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`.
+ */
+function isStructuredToolParams(tool) {
+    return (!!tool &&
+        typeof tool === "object" &&
+        "name" in tool &&
+        "schema" in tool &&
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (0, is_zod_schema_js_1.isZodSchema)(tool.schema));
+}
+exports.isStructuredToolParams = isStructuredToolParams;
+/**
+ * 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.
+ */
+function isLangChainTool(tool) {
+    return (isStructuredToolParams(tool) ||
+        isRunnableToolLike(tool) ||
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        isStructuredTool(tool));
+}
+exports.isLangChainTool = isLangChainTool;

package/dist/utils/function_calling.d.ts

@@ -1,4 +1,4 @@
-import { StructuredToolInterface } from "../tools/index.js";
+import { StructuredToolInterface, StructuredToolParams } from "../tools/index.js";
 import { FunctionDefinition, ToolDefinition } from "../language_models/base.js";
 import { RunnableToolLike } from "../runnables/base.js";
 /**
@@ -10,7 +10,13 @@ import { RunnableToolLike } from "../runnables/base.js";
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
-export declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike): FunctionDefinition;
+export declare function convertToOpenAIFunction(tool: StructuredToolInterface | RunnableToolLike | StructuredToolParams, fields?: {
+    /**
+     * If `true`, model output is guaranteed to exactly match the JSON Schema
+     * provided in the function definition.
+     */
+    strict?: boolean;
+} | number): FunctionDefinition;
 /**
  * Formats a `StructuredTool` or `RunnableToolLike` instance into a
  * format that is compatible with OpenAI tool calling. It uses the
@@ -21,7 +27,13 @@ export declare function convertToOpenAIFunction(tool: StructuredToolInterface |
  * @param {StructuredToolInterface | Record<string, any> | RunnableToolLike} tool The tool to convert to an OpenAI tool.
  * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
  */
-export declare function convertToOpenAITool(tool: StructuredToolInterface | Record<string, any> | RunnableToolLike): ToolDefinition;
+export declare function convertToOpenAITool(tool: StructuredToolInterface | Record<string, any> | RunnableToolLike, fields?: {
+    /**
+     * If `true`, model output is guaranteed to exactly match the JSON Schema
+     * provided in the function definition.
+     */
+    strict?: boolean;
+} | number): ToolDefinition;
 /**
  * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
  *
@@ -36,3 +48,19 @@ export declare function isStructuredTool(tool?: StructuredToolInterface | Record
  * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.
  */
 export declare function isRunnableToolLike(tool?: unknown): tool is 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 declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;
+/**
+ * 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 declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;

package/dist/utils/function_calling.js

@@ -1,5 +1,6 @@
 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. It uses the `zodToJsonSchema`
@@ -9,11 +10,15 @@ import { Runnable } from "../runnables/base.js";
  * @param {StructuredToolInterface | RunnableToolLike} tool The tool to convert to an OpenAI function.
  * @returns {FunctionDefinition} The inputted tool in OpenAI function format.
  */
-export function convertToOpenAIFunction(tool) {
+export function convertToOpenAIFunction(tool, fields) {
+    // @TODO 0.3.0 Remove the `number` typing
+    const fieldsCopy = typeof fields === "number" ? undefined : fields;
     return {
         name: tool.name,
         description: tool.description,
         parameters: zodToJsonSchema(tool.schema),
+        // Do not include the `strict` field if it is `undefined`.
+        ...(fieldsCopy?.strict !== undefined ? { strict: fieldsCopy.strict } : {}),
     };
 }
 /**
@@ -28,14 +33,23 @@ export function convertToOpenAIFunction(tool) {
  */
 export function convertToOpenAITool(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-tool) {
-    if (isStructuredTool(tool) || isRunnableToolLike(tool)) {
-        return {
+tool, fields) {
+    // @TODO 0.3.0 Remove the `number` typing
+    const fieldsCopy = typeof fields === "number" ? undefined : fields;
+    let toolDef;
+    if (isLangChainTool(tool)) {
+        toolDef = {
             type: "function",
             function: convertToOpenAIFunction(tool),
         };
     }
-    return tool;
+    else {
+        toolDef = tool;
+    }
+    if (fieldsCopy?.strict !== undefined) {
+        toolDef.function.strict = fieldsCopy.strict;
+    }
+    return toolDef;
 }
 /**
  * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.
@@ -62,3 +76,31 @@ export function isRunnableToolLike(tool) {
         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/utils/math.cjs

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.maximalMarginalRelevance = exports.euclideanDistance = exports.innerProduct = exports.cosineSimilarity = exports.normalize = exports.matrixFunc = void 0;
-const ml_distance_1 = require("ml-distance");
+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");
 /**
  * Apply a row-wise function between two matrices with the same number of columns.
  *
@@ -45,15 +47,15 @@ exports.normalize = normalize;
  * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
  */
 function cosineSimilarity(X, Y) {
-    return matrixFunc(X, Y, ml_distance_1.similarity.cosine);
+    return matrixFunc(X, Y, similarities_js_1.cosine);
 }
 exports.cosineSimilarity = cosineSimilarity;
 function innerProduct(X, Y) {
-    return matrixFunc(X, Y, ml_distance_1.distance.innerProduct);
+    return matrixFunc(X, Y, distances_js_1.innerProduct);
 }
 exports.innerProduct = innerProduct;
 function euclideanDistance(X, Y) {
-    return matrixFunc(X, Y, ml_distance_1.distance.euclidean);
+    return matrixFunc(X, Y, euclidean_js_1.euclidean);
 }
 exports.euclideanDistance = euclideanDistance;
 /**

package/dist/utils/math.js

@@ -1,4 +1,6 @@
-import { similarity as ml_distance_similarity, distance as ml_distance, } from "ml-distance";
+import { cosine } from "./ml-distance/similarities.js";
+import { innerProduct as innerProductDistance } from "./ml-distance/distances.js";
+import { euclidean } from "./ml-distance-euclidean/euclidean.js";
 /**
  * Apply a row-wise function between two matrices with the same number of columns.
  *
@@ -40,13 +42,13 @@ export function normalize(M, similarity = false) {
  * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
  */
 export function cosineSimilarity(X, Y) {
-    return matrixFunc(X, Y, ml_distance_similarity.cosine);
+    return matrixFunc(X, Y, cosine);
 }
 export function innerProduct(X, Y) {
-    return matrixFunc(X, Y, ml_distance.innerProduct);
+    return matrixFunc(X, Y, innerProductDistance);
 }
 export function euclideanDistance(X, Y) {
-    return matrixFunc(X, Y, ml_distance.euclidean);
+    return matrixFunc(X, Y, euclidean);
 }
 /**
  * This function implements the Maximal Marginal Relevance algorithm

package/dist/utils/ml-distance/distances.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+function innerProduct(a, b) {
+    let ans = 0;
+    for (let i = 0; i < a.length; i++) {
+        ans += a[i] * b[i];
+    }
+    return ans;
+}
+exports.innerProduct = innerProduct;

package/dist/utils/ml-distance/distances.d.ts

@@ -0,0 +1,8 @@
+/**
+ *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)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export declare function innerProduct(a: number[], b: number[]): number;

package/dist/utils/ml-distance/distances.js

@@ -0,0 +1,14 @@
+/**
+ *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)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export function innerProduct(a, b) {
+    let ans = 0;
+    for (let i = 0; i < a.length; i++) {
+        ans += a[i] * b[i];
+    }
+    return ans;
+}