@langchain/core 0.1.15 → 0.1.17-rc.0

package/dist/runnables/config.js

@@ -1,27 +1,25 @@
-import { CallbackManager, } from "../callbacks/manager.js";
+import { CallbackManager, ensureHandler, } from "../callbacks/manager.js";
 export const DEFAULT_RECURSION_LIMIT = 25;
 export async function getCallbackManagerForConfig(config) {
     return CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
-export function mergeConfigs(config, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-options) {
+export function mergeConfigs(...configs) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const copy = { ...config };
-    if (options) {
+    const copy = ensureConfig();
+    for (const options of configs.filter((c) => !!c)) {
         for (const key of Object.keys(options)) {
             if (key === "metadata") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
             else if (key === "tags") {
-                copy[key] = (copy[key] ?? []).concat(options[key] ?? []);
+                copy[key] = [...new Set(copy[key].concat(options[key] ?? []))];
             }
             else if (key === "configurable") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
             else if (key === "callbacks") {
                 const baseCallbacks = copy.callbacks;
-                const providedCallbacks = options.callbacks ?? config.callbacks;
+                const providedCallbacks = options.callbacks;
                 // callbacks can be either undefined, Array<handler> or manager
                 // so merging two callbacks values has 6 cases
                 if (Array.isArray(providedCallbacks)) {
@@ -35,7 +33,7 @@ options) {
                         // baseCallbacks is a manager
                         const manager = baseCallbacks.copy();
                         for (const callback of providedCallbacks) {
-                            manager.addHandler(callback, true);
+                            manager.addHandler(ensureHandler(callback), true);
                         }
                         copy.callbacks = manager;
                     }
@@ -48,13 +46,13 @@ options) {
                     else if (Array.isArray(baseCallbacks)) {
                         const manager = providedCallbacks.copy();
                         for (const callback of baseCallbacks) {
-                            manager.addHandler(callback, true);
+                            manager.addHandler(ensureHandler(callback), true);
                         }
                         copy.callbacks = manager;
                     }
                     else {
                         // baseCallbacks is also a manager
-                        copy.callbacks = new CallbackManager(providedCallbacks.parentRunId, {
+                        copy.callbacks = new CallbackManager(providedCallbacks._parentRunId, {
                             handlers: baseCallbacks.handlers.concat(providedCallbacks.handlers),
                             inheritableHandlers: baseCallbacks.inheritableHandlers.concat(providedCallbacks.inheritableHandlers),
                             tags: Array.from(new Set(baseCallbacks.tags.concat(providedCallbacks.tags))),
@@ -68,23 +66,39 @@ options) {
                 }
             }
             else {
-                copy[key] = options[key] ?? copy[key];
+                const typedKey = key;
+                copy[typedKey] = options[typedKey] ?? copy[typedKey];
             }
         }
     }
     return copy;
 }
+const PRIMITIVES = new Set(["string", "number", "boolean"]);
 /**
  * Ensure that a passed config is an object with all required keys present.
  */
 export function ensureConfig(config) {
-    return {
+    let empty = {
         tags: [],
         metadata: {},
         callbacks: undefined,
         recursionLimit: 25,
-        ...config,
     };
+    if (config) {
+        empty = { ...empty, ...config };
+    }
+    if (config?.configurable) {
+        for (const key of Object.keys(config.configurable)) {
+            if (PRIMITIVES.has(typeof config.configurable[key]) &&
+                !empty.metadata?.[key]) {
+                if (!empty.metadata) {
+                    empty.metadata = {};
+                }
+                empty.metadata[key] = config.configurable[key];
+            }
+        }
+    }
+    return empty;
 }
 /**
  * Helper function that patches runnable configs with updated properties.

package/dist/tools.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
+exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
 const zod_1 = require("zod");
 const manager_js_1 = require("./callbacks/manager.cjs");
 const base_js_1 = require("./language_models/base.cjs");
@@ -109,3 +109,104 @@ class Tool extends StructuredTool {
     }
 }
 exports.Tool = Tool;
+/**
+ * A tool that can be created dynamically from a function, name, and description.
+ */
+class DynamicTool extends Tool {
+    static lc_name() {
+        return "DynamicTool";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.func = fields.func;
+        this.returnDirect = fields.returnDirect ?? this.returnDirect;
+    }
+    async call(arg, configArg) {
+        const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
+        if (config.runName === undefined) {
+            config.runName = this.name;
+        }
+        return super.call(arg, config);
+    }
+    /** @ignore */
+    async _call(input, runManager) {
+        return this.func(input, runManager);
+    }
+}
+exports.DynamicTool = DynamicTool;
+/**
+ * A tool that can be created dynamically from a function, name, and
+ * description, designed to work with structured data. It extends the
+ * StructuredTool class and overrides the _call method to execute the
+ * provided function when the tool is called.
+ */
+class DynamicStructuredTool extends StructuredTool {
+    static lc_name() {
+        return "DynamicStructuredTool";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.func = fields.func;
+        this.returnDirect = fields.returnDirect ?? this.returnDirect;
+        this.schema = fields.schema;
+    }
+    async call(arg, configArg, 
+    /** @deprecated */
+    tags) {
+        const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
+        if (config.runName === undefined) {
+            config.runName = this.name;
+        }
+        return super.call(arg, config, tags);
+    }
+    _call(arg, runManager) {
+        return this.func(arg, runManager);
+    }
+}
+exports.DynamicStructuredTool = DynamicStructuredTool;

package/dist/tools.d.ts

@@ -100,3 +100,52 @@ export declare abstract class Tool extends StructuredTool {
      */
     call(arg: string | undefined | z.input<this["schema"]>, callbacks?: Callbacks | RunnableConfig): Promise<string>;
 }
+export interface BaseDynamicToolInput extends ToolParams {
+    name: string;
+    description: string;
+    returnDirect?: boolean;
+}
+/**
+ * Interface for the input parameters of the DynamicTool class.
+ */
+export interface DynamicToolInput extends BaseDynamicToolInput {
+    func: (input: string, runManager?: CallbackManagerForToolRun) => Promise<string>;
+}
+/**
+ * Interface for the input parameters of the DynamicStructuredTool class.
+ */
+export interface DynamicStructuredToolInput<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends BaseDynamicToolInput {
+    func: (input: z.infer<T>, runManager?: CallbackManagerForToolRun) => Promise<string>;
+    schema: T;
+}
+/**
+ * A tool that can be created dynamically from a function, name, and description.
+ */
+export declare class DynamicTool extends Tool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    func: DynamicToolInput["func"];
+    constructor(fields: DynamicToolInput);
+    call(arg: string | undefined | z.input<this["schema"]>, configArg?: RunnableConfig | Callbacks): Promise<string>;
+    /** @ignore */
+    _call(input: string, runManager?: CallbackManagerForToolRun): Promise<string>;
+}
+/**
+ * A tool that can be created dynamically from a function, name, and
+ * description, designed to work with structured data. It extends the
+ * StructuredTool class and overrides the _call method to execute the
+ * provided function when the tool is called.
+ */
+export declare class DynamicStructuredTool<T extends z.ZodObject<any, any, any, any> = z.ZodObject<any, any, any, any>> extends StructuredTool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    func: DynamicStructuredToolInput["func"];
+    schema: T;
+    constructor(fields: DynamicStructuredToolInput<T>);
+    call(arg: z.output<T>, configArg?: RunnableConfig | Callbacks, 
+    /** @deprecated */
+    tags?: string[]): Promise<string>;
+    protected _call(arg: z.output<T>, runManager?: CallbackManagerForToolRun): Promise<string>;
+}

package/dist/tools.js

@@ -103,3 +103,102 @@ export class Tool extends StructuredTool {
         return super.call(typeof arg === "string" || !arg ? { input: arg } : arg, callbacks);
     }
 }
+/**
+ * A tool that can be created dynamically from a function, name, and description.
+ */
+export class DynamicTool extends Tool {
+    static lc_name() {
+        return "DynamicTool";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.func = fields.func;
+        this.returnDirect = fields.returnDirect ?? this.returnDirect;
+    }
+    async call(arg, configArg) {
+        const config = parseCallbackConfigArg(configArg);
+        if (config.runName === undefined) {
+            config.runName = this.name;
+        }
+        return super.call(arg, config);
+    }
+    /** @ignore */
+    async _call(input, runManager) {
+        return this.func(input, runManager);
+    }
+}
+/**
+ * A tool that can be created dynamically from a function, name, and
+ * description, designed to work with structured data. It extends the
+ * StructuredTool class and overrides the _call method to execute the
+ * provided function when the tool is called.
+ */
+export class DynamicStructuredTool extends StructuredTool {
+    static lc_name() {
+        return "DynamicStructuredTool";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "func", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = fields.name;
+        this.description = fields.description;
+        this.func = fields.func;
+        this.returnDirect = fields.returnDirect ?? this.returnDirect;
+        this.schema = fields.schema;
+    }
+    async call(arg, configArg, 
+    /** @deprecated */
+    tags) {
+        const config = parseCallbackConfigArg(configArg);
+        if (config.runName === undefined) {
+            config.runName = this.name;
+        }
+        return super.call(arg, config, tags);
+    }
+    _call(arg, runManager) {
+        return this.func(arg, runManager);
+    }
+}

package/dist/utils/stream.cjs

@@ -196,7 +196,12 @@ class AsyncGeneratorWithSetup {
         // to each generator is available.
         this.setup = new Promise((resolve, reject) => {
             this.firstResult = generator.next();
-            this.firstResult.then(startSetup).then(resolve, reject);
+            if (startSetup) {
+                this.firstResult.then(startSetup).then(resolve, reject);
+            }
+            else {
+                this.firstResult.then((_result) => resolve(undefined), reject);
+            }
         });
     }
     async next(...args) {

package/dist/utils/stream.d.ts

@@ -17,7 +17,7 @@ export declare class AsyncGeneratorWithSetup<S = unknown, T = unknown, TReturn =
     setup: Promise<S>;
     private firstResult;
     private firstResultUsed;
-    constructor(generator: AsyncGenerator<T>, startSetup: () => Promise<S>);
+    constructor(generator: AsyncGenerator<T>, startSetup?: () => Promise<S>);
     next(...args: [] | [TNext]): Promise<IteratorResult<T>>;
     return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T>>;
     throw(e: Error): Promise<IteratorResult<T>>;

package/dist/utils/stream.js

@@ -190,7 +190,12 @@ export class AsyncGeneratorWithSetup {
         // to each generator is available.
         this.setup = new Promise((resolve, reject) => {
             this.firstResult = generator.next();
-            this.firstResult.then(startSetup).then(resolve, reject);
+            if (startSetup) {
+                this.firstResult.then(startSetup).then(resolve, reject);
+            }
+            else {
+                this.firstResult.then((_result) => resolve(undefined), reject);
+            }
         });
     }
     async next(...args) {

package/dist/utils/testing/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FakeTool = exports.FakeTracer = exports.FakeListChatMessageHistory = exports.FakeChatMessageHistory = exports.FakeListChatModel = exports.FakeRetriever = exports.FakeChatModel = exports.FakeStreamingLLM = exports.FakeLLM = exports.FakeRunnable = exports.FakeSplitIntoListParser = void 0;
+exports.SyntheticEmbeddings = exports.FakeEmbeddings = exports.FakeTool = exports.FakeTracer = exports.FakeListChatMessageHistory = exports.FakeChatMessageHistory = exports.FakeListChatModel = exports.FakeRetriever = exports.FakeChatModel = exports.FakeStreamingLLM = exports.FakeLLM = exports.FakeRunnable = exports.FakeSplitIntoListParser = void 0;
 const chat_history_js_1 = require("../../chat_history.cjs");
 const document_js_1 = require("../../documents/document.cjs");
 const chat_models_js_1 = require("../../language_models/chat_models.cjs");
@@ -12,6 +12,7 @@ const retrievers_js_1 = require("../../retrievers.cjs");
 const base_js_2 = require("../../runnables/base.cjs");
 const tools_js_1 = require("../../tools.cjs");
 const base_js_3 = require("../../tracers/base.cjs");
+const embeddings_js_1 = require("../../embeddings.cjs");
 /**
  * Parser for comma-separated values. It splits the input text by commas
  * and trims the resulting values.
@@ -105,18 +106,31 @@ class FakeStreamingLLM extends llms_js_1.LLM {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "thrownErrorString", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.sleep = fields.sleep ?? this.sleep;
         this.responses = fields.responses;
+        this.thrownErrorString = fields.thrownErrorString;
     }
     _llmType() {
         return "fake";
     }
     async _call(prompt) {
+        if (this.thrownErrorString) {
+            throw new Error(this.thrownErrorString);
+        }
         const response = this.responses?.[0];
         this.responses = this.responses?.slice(1);
         return response ?? prompt;
     }
     async *_streamResponseChunks(input) {
+        if (this.thrownErrorString) {
+            throw new Error(this.thrownErrorString);
+        }
         const response = this.responses?.[0];
         this.responses = this.responses?.slice(1);
         for (const c of response ?? input) {
@@ -406,3 +420,93 @@ class FakeTool extends tools_js_1.StructuredTool {
     }
 }
 exports.FakeTool = FakeTool;
+/**
+ * A class that provides fake embeddings by overriding the embedDocuments
+ * and embedQuery methods to return fixed values.
+ */
+class FakeEmbeddings extends embeddings_js_1.Embeddings {
+    constructor(params) {
+        super(params ?? {});
+    }
+    /**
+     * Generates fixed embeddings for a list of documents.
+     * @param documents List of documents to generate embeddings for.
+     * @returns A promise that resolves with a list of fixed embeddings for each document.
+     */
+    embedDocuments(documents) {
+        return Promise.resolve(documents.map(() => [0.1, 0.2, 0.3, 0.4]));
+    }
+    /**
+     * Generates a fixed embedding for a query.
+     * @param _ The query to generate an embedding for.
+     * @returns A promise that resolves with a fixed embedding for the query.
+     */
+    embedQuery(_) {
+        return Promise.resolve([0.1, 0.2, 0.3, 0.4]);
+    }
+}
+exports.FakeEmbeddings = FakeEmbeddings;
+/**
+ * A class that provides synthetic embeddings by overriding the
+ * embedDocuments and embedQuery methods to generate embeddings based on
+ * the input documents. The embeddings are generated by converting each
+ * document into chunks, calculating a numerical value for each chunk, and
+ * returning an array of these values as the embedding.
+ */
+class SyntheticEmbeddings extends embeddings_js_1.Embeddings {
+    constructor(params) {
+        super(params ?? {});
+        Object.defineProperty(this, "vectorSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.vectorSize = params?.vectorSize ?? 4;
+    }
+    /**
+     * Generates synthetic embeddings for a list of documents.
+     * @param documents List of documents to generate embeddings for.
+     * @returns A promise that resolves with a list of synthetic embeddings for each document.
+     */
+    async embedDocuments(documents) {
+        return Promise.all(documents.map((doc) => this.embedQuery(doc)));
+    }
+    /**
+     * Generates a synthetic embedding for a document. The document is
+     * converted into chunks, a numerical value is calculated for each chunk,
+     * and an array of these values is returned as the embedding.
+     * @param document The document to generate an embedding for.
+     * @returns A promise that resolves with a synthetic embedding for the document.
+     */
+    async embedQuery(document) {
+        let doc = document;
+        // Only use the letters (and space) from the document, and make them lower case
+        doc = doc.toLowerCase().replaceAll(/[^a-z ]/g, "");
+        // Pad the document to make sure it has a divisible number of chunks
+        const padMod = doc.length % this.vectorSize;
+        const padGapSize = padMod === 0 ? 0 : this.vectorSize - padMod;
+        const padSize = doc.length + padGapSize;
+        doc = doc.padEnd(padSize, " ");
+        // Break it into chunks
+        const chunkSize = doc.length / this.vectorSize;
+        const docChunk = [];
+        for (let co = 0; co < doc.length; co += chunkSize) {
+            docChunk.push(doc.slice(co, co + chunkSize));
+        }
+        // Turn each chunk into a number
+        const ret = docChunk.map((s) => {
+            let sum = 0;
+            // Get a total value by adding the value of each character in the string
+            for (let co = 0; co < s.length; co += 1) {
+                sum += s === " " ? 0 : s.charCodeAt(co);
+            }
+            // Reduce this to a number between 0 and 25 inclusive
+            // Then get the fractional number by dividing it by 26
+            const ret = (sum % 26) / 26;
+            return ret;
+        });
+        return ret;
+    }
+}
+exports.SyntheticEmbeddings = SyntheticEmbeddings;

package/dist/utils/testing/index.d.ts

@@ -11,6 +11,7 @@ import { BaseRetriever } from "../../retrievers.js";
 import { Runnable } from "../../runnables/base.js";
 import { StructuredTool, ToolParams } from "../../tools.js";
 import { BaseTracer, Run } from "../../tracers/base.js";
+import { Embeddings, EmbeddingsParams } from "../../embeddings.js";
 /**
  * Parser for comma-separated values. It splits the input text by commas
  * and trims the resulting values.
@@ -41,9 +42,11 @@ export declare class FakeLLM extends LLM {
 export declare class FakeStreamingLLM extends LLM {
     sleep?: number;
     responses?: string[];
+    thrownErrorString?: string;
     constructor(fields: {
         sleep?: number;
         responses?: string[];
+        thrownErrorString?: string;
     } & BaseLLMParams);
     _llmType(): string;
     _call(prompt: string): Promise<string>;
@@ -146,3 +149,55 @@ export declare class FakeTool<T extends z.ZodObject<any, any, any, any> = z.ZodO
     constructor(fields: FakeToolParams<T>);
     protected _call(arg: z.output<T>, _runManager?: CallbackManagerForToolRun): Promise<string>;
 }
+/**
+ * A class that provides fake embeddings by overriding the embedDocuments
+ * and embedQuery methods to return fixed values.
+ */
+export declare class FakeEmbeddings extends Embeddings {
+    constructor(params?: EmbeddingsParams);
+    /**
+     * Generates fixed embeddings for a list of documents.
+     * @param documents List of documents to generate embeddings for.
+     * @returns A promise that resolves with a list of fixed embeddings for each document.
+     */
+    embedDocuments(documents: string[]): Promise<number[][]>;
+    /**
+     * Generates a fixed embedding for a query.
+     * @param _ The query to generate an embedding for.
+     * @returns A promise that resolves with a fixed embedding for the query.
+     */
+    embedQuery(_: string): Promise<number[]>;
+}
+/**
+ * An interface that defines additional parameters specific to the
+ * SyntheticEmbeddings class.
+ */
+interface SyntheticEmbeddingsParams extends EmbeddingsParams {
+    vectorSize: number;
+}
+/**
+ * A class that provides synthetic embeddings by overriding the
+ * embedDocuments and embedQuery methods to generate embeddings based on
+ * the input documents. The embeddings are generated by converting each
+ * document into chunks, calculating a numerical value for each chunk, and
+ * returning an array of these values as the embedding.
+ */
+export declare class SyntheticEmbeddings extends Embeddings implements SyntheticEmbeddingsParams {
+    vectorSize: number;
+    constructor(params?: SyntheticEmbeddingsParams);
+    /**
+     * Generates synthetic embeddings for a list of documents.
+     * @param documents List of documents to generate embeddings for.
+     * @returns A promise that resolves with a list of synthetic embeddings for each document.
+     */
+    embedDocuments(documents: string[]): Promise<number[][]>;
+    /**
+     * Generates a synthetic embedding for a document. The document is
+     * converted into chunks, a numerical value is calculated for each chunk,
+     * and an array of these values is returned as the embedding.
+     * @param document The document to generate an embedding for.
+     * @returns A promise that resolves with a synthetic embedding for the document.
+     */
+    embedQuery(document: string): Promise<number[]>;
+}
+export {};