@langchain/core 0.1.15 → 0.1.16

package/dist/callbacks/manager.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traceAsGroup = exports.TraceGroup = exports.CallbackManager = exports.CallbackManagerForToolRun = exports.CallbackManagerForChainRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForRetrieverRun = exports.BaseCallbackManager = exports.parseCallbackConfigArg = void 0;
+exports.traceAsGroup = exports.TraceGroup = exports.ensureHandler = exports.CallbackManager = exports.CallbackManagerForToolRun = exports.CallbackManagerForChainRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForRetrieverRun = exports.BaseCallbackManager = exports.parseCallbackConfigArg = void 0;
 const uuid_1 = require("uuid");
 const base_js_1 = require("./base.cjs");
 const console_js_1 = require("../tracers/console.cjs");
@@ -571,6 +571,7 @@ function ensureHandler(handler) {
     }
     return base_js_1.BaseCallbackHandler.fromMethods(handler);
 }
+exports.ensureHandler = ensureHandler;
 /**
  * @example
  * ```typescript

package/dist/callbacks/manager.d.ts

@@ -115,7 +115,7 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
     metadata: Record<string, unknown>;
     inheritableMetadata: Record<string, unknown>;
     name: string;
-    private readonly _parentRunId?;
+    readonly _parentRunId?: string;
     constructor(parentRunId?: string, options?: {
         handlers?: BaseCallbackHandler[];
         inheritableHandlers?: BaseCallbackHandler[];
@@ -140,6 +140,7 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
     static fromHandlers(handlers: CallbackHandlerMethods): CallbackManager;
     static configure(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): Promise<CallbackManager | undefined>;
 }
+export declare function ensureHandler(handler: BaseCallbackHandler | CallbackHandlerMethods): BaseCallbackHandler;
 /**
  * @example
  * ```typescript

package/dist/callbacks/manager.js

@@ -555,7 +555,7 @@ export class CallbackManager extends BaseCallbackManager {
         return callbackManager;
     }
 }
-function ensureHandler(handler) {
+export function ensureHandler(handler) {
     if ("name" in handler) {
         return handler;
     }

package/dist/retrievers.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseRetriever = void 0;
 const manager_js_1 = require("./callbacks/manager.cjs");
 const base_js_1 = require("./runnables/base.cjs");
+const config_js_1 = require("./runnables/config.cjs");
 /**
  * Abstract base class for a Document retrieval system. A retrieval system
  * is defined as something that can take string queries and return the
@@ -62,7 +63,7 @@ class BaseRetriever extends base_js_1.Runnable {
      * @returns A promise that resolves to an array of `Document` objects.
      */
     async getRelevantDocuments(query, config) {
-        const parsedConfig = (0, manager_js_1.parseCallbackConfigArg)(config);
+        const parsedConfig = (0, config_js_1.ensureConfig)((0, manager_js_1.parseCallbackConfigArg)(config));
         const callbackManager_ = await manager_js_1.CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
         const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
         try {

package/dist/retrievers.js

@@ -1,5 +1,6 @@
 import { CallbackManager, parseCallbackConfigArg, } from "./callbacks/manager.js";
 import { Runnable } from "./runnables/base.js";
+import { ensureConfig } from "./runnables/config.js";
 /**
  * Abstract base class for a Document retrieval system. A retrieval system
  * is defined as something that can take string queries and return the
@@ -59,7 +60,7 @@ export class BaseRetriever extends Runnable {
      * @returns A promise that resolves to an array of `Document` objects.
      */
     async getRelevantDocuments(query, config) {
-        const parsedConfig = parseCallbackConfigArg(config);
+        const parsedConfig = ensureConfig(parseCallbackConfigArg(config));
         const callbackManager_ = await CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
         const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
         try {

package/dist/runnables/base.cjs

@@ -111,9 +111,9 @@ class Runnable extends serializable_js_1.Serializable {
             if (options.length !== length) {
                 throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
             }
-            return options;
+            return options.map(config_js_1.ensureConfig);
         }
-        return Array.from({ length }, () => options);
+        return Array.from({ length }, () => (0, config_js_1.ensureConfig)(options));
     }
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
@@ -157,27 +157,32 @@ class Runnable extends serializable_js_1.Serializable {
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(this._streamIterator(input, options));
     }
     _separateRunnableConfigFromCallOptions(options = {}) {
-        const runnableConfig = {
+        const runnableConfig = (0, config_js_1.ensureConfig)({
             callbacks: options.callbacks,
             tags: options.tags,
             metadata: options.metadata,
             runName: options.runName,
             configurable: options.configurable,
-        };
+            recursionLimit: options.recursionLimit,
+            maxConcurrency: options.maxConcurrency,
+        });
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;
         delete callOptions.metadata;
         delete callOptions.runName;
         delete callOptions.configurable;
+        delete callOptions.recursionLimit;
+        delete callOptions.maxConcurrency;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName());
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName());
         let output;
         try {
-            output = await func.bind(this)(input, options, runManager);
+            output = await func.call(this, input, config, runManager);
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -201,7 +206,7 @@ class Runnable extends serializable_js_1.Serializable {
         const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName())));
         let outputs;
         try {
-            outputs = await func(inputs, optionsList, runManagers, batchOptions);
+            outputs = await func.call(this, inputs, optionsList, runManagers, batchOptions);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
@@ -220,7 +225,8 @@ class Runnable extends serializable_js_1.Serializable {
         let finalInputSupported = true;
         let finalOutput;
         let finalOutputSupported = true;
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
         async function* wrapInputForTracing() {
             for await (const chunk of inputGenerator) {
                 if (finalInputSupported) {
@@ -243,7 +249,7 @@ class Runnable extends serializable_js_1.Serializable {
         }
         let runManager;
         try {
-            const pipe = await (0, stream_js_1.pipeGeneratorWithSetup)(transformer, wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName()), options);
+            const pipe = await (0, stream_js_1.pipeGeneratorWithSetup)(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName()), config);
             runManager = pipe.setup;
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
@@ -346,7 +352,7 @@ class Runnable extends serializable_js_1.Serializable {
             ...streamOptions,
             autoClose: false,
         });
-        const config = options ?? {};
+        const config = (0, config_js_1.ensureConfig)(options);
         const { callbacks } = config;
         if (callbacks === undefined) {
             config.callbacks = [stream];
@@ -478,10 +484,8 @@ class RunnableBinding extends Runnable {
     getName(suffix) {
         return this.bound.getName(suffix);
     }
-    async _mergeConfig(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    options) {
-        const config = (0, config_js_1.mergeConfigs)(this.config, options);
+    async _mergeConfig(...options) {
+        const config = (0, config_js_1.mergeConfigs)(this.config, ...options);
         return (0, config_js_1.mergeConfigs)(config, ...(this.configFactories
             ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config)))
             : []));
@@ -511,27 +515,24 @@ class RunnableBinding extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this.bound.invoke(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        return this.bound.invoke(input, await this._mergeConfig(options, this.kwargs));
     }
     async batch(inputs, options, batchOptions) {
         const mergedOptions = Array.isArray(options)
-            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig({
-                ...individualOption,
-                ...this.kwargs,
-            })))
-            : await this._mergeConfig({ ...options, ...this.kwargs });
+            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(individualOption, this.kwargs)))
+            : await this._mergeConfig(options, this.kwargs);
         return this.bound.batch(inputs, mergedOptions, batchOptions);
     }
     async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        yield* this.bound._streamIterator(input, await this._mergeConfig(options, this.kwargs));
     }
     async stream(input, options) {
-        return this.bound.stream(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        return this.bound.stream(input, await this._mergeConfig(options, this.kwargs));
     }
     async *transform(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     generator, options) {
-        yield* this.bound.transform(generator, await this._mergeConfig({ ...options, ...this.kwargs }));
+        yield* this.bound.transform(generator, await this._mergeConfig(options, this.kwargs));
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/runnables/base.d.ts

@@ -82,9 +82,9 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
     withFallbacks(fields: {
         fallbacks: Runnable<RunInput, RunOutput>[];
     }): RunnableWithFallbacks<RunInput, RunOutput>;
-    protected _getOptionsList(options: Partial<CallOptions> | Partial<CallOptions>[], length?: number): Partial<CallOptions & {
+    protected _getOptionsList<O extends CallOptions & {
         runType?: string;
-    }>[];
+    }>(options: Partial<O> | Partial<O>[], length?: number): Partial<O>[];
     /**
      * Default implementation of batch, which calls invoke N times.
      * Subclasses should override this method if they can batch more efficiently.
@@ -212,7 +212,7 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
     configFactories?: Array<(config: RunnableConfig) => RunnableConfig | Promise<RunnableConfig>>;
     constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions>);
     getName(suffix?: string | undefined): string;
-    _mergeConfig(options?: Record<string, any>): Promise<Partial<CallOptions>>;
+    _mergeConfig(...options: (Partial<CallOptions> | RunnableConfig | undefined)[]): Promise<Partial<CallOptions>>;
     bind(kwargs: Partial<CallOptions>): RunnableBinding<RunInput, RunOutput, CallOptions>;
     withConfig(config: RunnableConfig): RunnableBinding<RunInput, RunOutput, CallOptions>;
     withRetry(fields?: {

package/dist/runnables/base.js

@@ -3,7 +3,7 @@ import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLogPatch, } from "../tracers/log_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, } from "../utils/stream.js";
-import { DEFAULT_RECURSION_LIMIT, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
+import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
 import { AsyncCaller } from "../utils/async_caller.js";
 import { RootListenersTracer } from "../tracers/root_listener.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -105,9 +105,9 @@ export class Runnable extends Serializable {
             if (options.length !== length) {
                 throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
             }
-            return options;
+            return options.map(ensureConfig);
         }
-        return Array.from({ length }, () => options);
+        return Array.from({ length }, () => ensureConfig(options));
     }
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
@@ -151,27 +151,32 @@ export class Runnable extends Serializable {
         return IterableReadableStream.fromAsyncGenerator(this._streamIterator(input, options));
     }
     _separateRunnableConfigFromCallOptions(options = {}) {
-        const runnableConfig = {
+        const runnableConfig = ensureConfig({
             callbacks: options.callbacks,
             tags: options.tags,
             metadata: options.metadata,
             runName: options.runName,
             configurable: options.configurable,
-        };
+            recursionLimit: options.recursionLimit,
+            maxConcurrency: options.maxConcurrency,
+        });
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;
         delete callOptions.metadata;
         delete callOptions.runName;
         delete callOptions.configurable;
+        delete callOptions.recursionLimit;
+        delete callOptions.maxConcurrency;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
-        const callbackManager_ = await getCallbackManagerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName());
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName());
         let output;
         try {
-            output = await func.bind(this)(input, options, runManager);
+            output = await func.call(this, input, config, runManager);
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -195,7 +200,7 @@ export class Runnable extends Serializable {
         const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName())));
         let outputs;
         try {
-            outputs = await func(inputs, optionsList, runManagers, batchOptions);
+            outputs = await func.call(this, inputs, optionsList, runManagers, batchOptions);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
@@ -214,7 +219,8 @@ export class Runnable extends Serializable {
         let finalInputSupported = true;
         let finalOutput;
         let finalOutputSupported = true;
-        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
         async function* wrapInputForTracing() {
             for await (const chunk of inputGenerator) {
                 if (finalInputSupported) {
@@ -237,7 +243,7 @@ export class Runnable extends Serializable {
         }
         let runManager;
         try {
-            const pipe = await pipeGeneratorWithSetup(transformer, wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName()), options);
+            const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName()), config);
             runManager = pipe.setup;
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
@@ -340,7 +346,7 @@ export class Runnable extends Serializable {
             ...streamOptions,
             autoClose: false,
         });
-        const config = options ?? {};
+        const config = ensureConfig(options);
         const { callbacks } = config;
         if (callbacks === undefined) {
             config.callbacks = [stream];
@@ -471,10 +477,8 @@ export class RunnableBinding extends Runnable {
     getName(suffix) {
         return this.bound.getName(suffix);
     }
-    async _mergeConfig(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    options) {
-        const config = mergeConfigs(this.config, options);
+    async _mergeConfig(...options) {
+        const config = mergeConfigs(this.config, ...options);
         return mergeConfigs(config, ...(this.configFactories
             ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config)))
             : []));
@@ -504,27 +508,24 @@ export class RunnableBinding extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this.bound.invoke(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        return this.bound.invoke(input, await this._mergeConfig(options, this.kwargs));
     }
     async batch(inputs, options, batchOptions) {
         const mergedOptions = Array.isArray(options)
-            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig({
-                ...individualOption,
-                ...this.kwargs,
-            })))
-            : await this._mergeConfig({ ...options, ...this.kwargs });
+            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(individualOption, this.kwargs)))
+            : await this._mergeConfig(options, this.kwargs);
         return this.bound.batch(inputs, mergedOptions, batchOptions);
     }
     async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        yield* this.bound._streamIterator(input, await this._mergeConfig(options, this.kwargs));
     }
     async stream(input, options) {
-        return this.bound.stream(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        return this.bound.stream(input, await this._mergeConfig(options, this.kwargs));
     }
     async *transform(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     generator, options) {
-        yield* this.bound.transform(generator, await this._mergeConfig({ ...options, ...this.kwargs }));
+        yield* this.bound.transform(generator, await this._mergeConfig(options, this.kwargs));
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/runnables/config.cjs

@@ -7,25 +7,23 @@ async function getCallbackManagerForConfig(config) {
     return manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
 exports.getCallbackManagerForConfig = getCallbackManagerForConfig;
-function mergeConfigs(config, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-options) {
+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)) {
@@ -39,7 +37,7 @@ options) {
                         // baseCallbacks is a manager
                         const manager = baseCallbacks.copy();
                         for (const callback of providedCallbacks) {
-                            manager.addHandler(callback, true);
+                            manager.addHandler((0, manager_js_1.ensureHandler)(callback), true);
                         }
                         copy.callbacks = manager;
                     }
@@ -52,13 +50,13 @@ options) {
                     else if (Array.isArray(baseCallbacks)) {
                         const manager = providedCallbacks.copy();
                         for (const callback of baseCallbacks) {
-                            manager.addHandler(callback, true);
+                            manager.addHandler((0, manager_js_1.ensureHandler)(callback), true);
                         }
                         copy.callbacks = manager;
                     }
                     else {
                         // baseCallbacks is also a manager
-                        copy.callbacks = new manager_js_1.CallbackManager(providedCallbacks.parentRunId, {
+                        copy.callbacks = new manager_js_1.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))),
@@ -72,24 +70,40 @@ options) {
                 }
             }
             else {
-                copy[key] = options[key] ?? copy[key];
+                const typedKey = key;
+                copy[typedKey] = options[typedKey] ?? copy[typedKey];
             }
         }
     }
     return copy;
 }
 exports.mergeConfigs = mergeConfigs;
+const PRIMITIVES = new Set(["string", "number", "boolean"]);
 /**
  * Ensure that a passed config is an object with all required keys present.
  */
 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;
 }
 exports.ensureConfig = ensureConfig;
 /**

package/dist/runnables/config.d.ts

@@ -14,11 +14,11 @@ export interface RunnableConfig extends BaseCallbackConfig {
     maxConcurrency?: number;
 }
 export declare function getCallbackManagerForConfig(config?: RunnableConfig): Promise<CallbackManager | undefined>;
-export declare function mergeConfigs<CallOptions extends RunnableConfig>(config: RunnableConfig, options?: Record<string, any>): Partial<CallOptions>;
+export declare function mergeConfigs<CallOptions extends RunnableConfig>(...configs: (CallOptions | RunnableConfig | undefined | null)[]): Partial<CallOptions>;
 /**
  * Ensure that a passed config is an object with all required keys present.
  */
-export declare function ensureConfig<CallOptions extends RunnableConfig>(config?: CallOptions): Partial<CallOptions>;
+export declare function ensureConfig<CallOptions extends RunnableConfig>(config?: CallOptions): CallOptions;
 /**
  * Helper function that patches runnable configs with updated properties.
  */

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/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.
@@ -406,3 +407,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.
@@ -146,3 +147,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 {};

package/dist/utils/testing/index.js

@@ -9,6 +9,7 @@ import { BaseRetriever } from "../../retrievers.js";
 import { Runnable } from "../../runnables/base.js";
 import { StructuredTool } from "../../tools.js";
 import { BaseTracer } from "../../tracers/base.js";
+import { Embeddings } from "../../embeddings.js";
 /**
  * Parser for comma-separated values. It splits the input text by commas
  * and trims the resulting values.
@@ -392,3 +393,91 @@ export class FakeTool extends StructuredTool {
         return JSON.stringify(arg);
     }
 }
+/**
+ * A class that provides fake embeddings by overriding the embedDocuments
+ * and embedQuery methods to return fixed values.
+ */
+export class FakeEmbeddings extends 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]);
+    }
+}
+/**
+ * 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 class SyntheticEmbeddings extends 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;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -43,8 +43,8 @@
     "p-queue": "^6.6.2",
     "p-retry": "4",
     "uuid": "^9.0.0",
-    "zod": "^3.22.3",
-    "zod-to-json-schema": "3.20.3"
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.22.3"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",