langchain 0.0.160 → 0.0.162

package/dist/retrievers/tavily_search_api.js

@@ -0,0 +1,140 @@
+import { Document } from "../document.js";
+import { BaseRetriever } from "../schema/retriever.js";
+import { getEnvironmentVariable } from "../util/env.js";
+/**
+ * A class for retrieving documents related to a given search term
+ * using the Tavily Search API.
+ */
+export class TavilySearchAPIRetriever extends BaseRetriever {
+    static lc_name() {
+        return "TavilySearchAPIRetriever";
+    }
+    get lc_namespace() {
+        return ["langchain", "retrievers", "tavily_search_api"];
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "k", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10
+        });
+        Object.defineProperty(this, "includeGeneratedAnswer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "includeRawContent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "includeImages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "searchDepth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "basic"
+        });
+        Object.defineProperty(this, "includeDomains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "excludeDomains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "kwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.k = fields?.k ?? this.k;
+        this.includeGeneratedAnswer =
+            fields?.includeGeneratedAnswer ?? this.includeGeneratedAnswer;
+        this.includeRawContent =
+            fields?.includeRawContent ?? this.includeRawContent;
+        this.includeImages = fields?.includeImages ?? this.includeImages;
+        this.searchDepth = fields?.searchDepth ?? this.searchDepth;
+        this.includeDomains = fields?.includeDomains ?? this.includeDomains;
+        this.excludeDomains = fields?.excludeDomains ?? this.excludeDomains;
+        this.kwargs = fields?.kwargs ?? this.kwargs;
+        this.apiKey = fields?.apiKey ?? getEnvironmentVariable("TAVILY_API_KEY");
+        if (this.apiKey === undefined) {
+            throw new Error(`No Tavily API key found. Either set an environment variable named "TAVILY_API_KEY" or pass an API key as "apiKey".`);
+        }
+    }
+    async _getRelevantDocuments(query, _runManager) {
+        const body = {
+            query,
+            include_answer: this.includeGeneratedAnswer,
+            include_raw_content: this.includeRawContent,
+            include_images: this.includeImages,
+            max_results: this.k,
+            search_depth: this.searchDepth,
+            api_key: this.apiKey,
+        };
+        if (this.includeDomains) {
+            body.include_domains = this.includeDomains;
+        }
+        if (this.excludeDomains) {
+            body.exclude_domains = this.excludeDomains;
+        }
+        const response = await fetch("https://api.tavily.com/search", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ ...body, ...this.kwargs }),
+        });
+        const json = await response.json();
+        if (!response.ok) {
+            throw new Error(`Request failed with status code ${response.status}: ${json.error}`);
+        }
+        if (!Array.isArray(json.results)) {
+            throw new Error(`Could not parse Tavily results. Please try again.`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const docs = json.results.map((result) => {
+            const pageContent = this.includeRawContent
+                ? result.raw_content
+                : result.content;
+            const metadata = {
+                title: result.title,
+                source: result.url,
+                ...Object.fromEntries(Object.entries(result).filter(([k]) => !["content", "title", "url", "raw_content"].includes(k))),
+                images: json.images,
+            };
+            return new Document({ pageContent, metadata });
+        });
+        if (this.includeGeneratedAnswer) {
+            docs.push(new Document({
+                pageContent: json.answer,
+                metadata: {
+                    title: "Suggested Answer",
+                    source: "https://tavily.com/",
+                },
+            }));
+        }
+        return docs;
+    }
+}

package/dist/schema/retriever.cjs

@@ -64,7 +64,7 @@ class BaseRetriever extends index_js_1.Runnable {
     async getRelevantDocuments(query, config) {
         const parsedConfig = (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);
+        const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
         try {
             const results = await this._getRelevantDocuments(query, runManager);
             await runManager?.handleRetrieverEnd(results);

package/dist/schema/retriever.js

@@ -61,7 +61,7 @@ export class BaseRetriever extends Runnable {
     async getRelevantDocuments(query, config) {
         const parsedConfig = 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);
+        const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
         try {
             const results = await this._getRelevantDocuments(query, runManager);
             await runManager?.handleRetrieverEnd(results);

package/dist/schema/runnable/base.cjs

@@ -143,16 +143,18 @@ class Runnable extends serializable_js_1.Serializable {
             callbacks: options.callbacks,
             tags: options.tags,
             metadata: options.metadata,
+            runName: options.runName,
         };
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;
         delete callOptions.metadata;
+        delete callOptions.runName;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
         const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName);
         let output;
         try {
             output = await func.bind(this)(input, options, runManager);
@@ -176,7 +178,7 @@ class Runnable extends serializable_js_1.Serializable {
     async _batchWithConfig(func, inputs, options, batchOptions) {
         const configs = this._getOptionsList((options ?? {}), inputs.length);
         const callbackManagers = await Promise.all(configs.map(config_js_1.getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, configs[i].runType, undefined, undefined, configs[i].runName)));
         let outputs;
         try {
             outputs = await func(inputs, configs, runManagers, batchOptions);
@@ -206,7 +208,7 @@ class Runnable extends serializable_js_1.Serializable {
                 if (!runManager) {
                     // Start the run manager AFTER the iterator starts to preserve
                     // tracing order
-                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType);
+                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName);
                 }
                 if (finalInputSupported) {
                     if (finalInput === undefined) {
@@ -257,7 +259,16 @@ class Runnable extends serializable_js_1.Serializable {
         await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
     _patchConfig(config = {}, callbackManager = undefined) {
-        return { ...config, callbacks: callbackManager };
+        const newConfig = { ...config };
+        if (callbackManager !== undefined) {
+            /**
+             * If we're replacing callbacks we need to unset runName
+             * since that should apply only to the same run as the original callbacks
+             */
+            delete newConfig.runName;
+            return { ...newConfig, callbacks: callbackManager };
+        }
+        return newConfig;
     }
     /**
      * Create a new runnable sequence that runs each individual runnable in series,
@@ -690,7 +701,7 @@ class RunnableSequence extends Runnable {
     }
     async invoke(input, options) {
         const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         let nextStepInput = input;
         let finalOutput;
         try {
@@ -712,7 +723,7 @@ class RunnableSequence extends Runnable {
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(configList.map(config_js_1.getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let nextStepInputs = inputs;
         let finalOutputs;
@@ -733,7 +744,7 @@ class RunnableSequence extends Runnable {
     }
     async *_streamIterator(input, options) {
         const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         let nextStepInput = input;
         const steps = [this.first, ...this.middle, this.last];
         // Find the index of the last runnable in the sequence that doesn't have an overridden .transform() method
@@ -858,13 +869,16 @@ class RunnableMap extends Runnable {
             this.steps[key] = _coerceToRunnable(value);
         }
     }
+    static from(steps) {
+        return new RunnableMap({ steps });
+    }
     async invoke(input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
         const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
-        });
+        }, undefined, undefined, undefined, undefined, options?.runName);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const output = {};
         try {
@@ -904,6 +918,11 @@ class RunnableLambda extends Runnable {
         });
         this.func = fields.func;
     }
+    static from(func) {
+        return new RunnableLambda({
+            func,
+        });
+    }
     async _invoke(input, config, runManager) {
         let output = await this.func(input);
         if (output && Runnable.isRunnable(output)) {
@@ -960,7 +979,7 @@ class RunnableWithFallbacks extends Runnable {
     }
     async invoke(input, options) {
         const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         let firstError;
         for (const runnable of this.runnables()) {
             try {
@@ -986,7 +1005,7 @@ class RunnableWithFallbacks extends Runnable {
         }
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(configList.map((config) => manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let firstError;
         for (const runnable of this.runnables()) {

package/dist/schema/runnable/base.d.ts

@@ -57,7 +57,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(options: Partial<CallOptions> | Partial<CallOptions>[], length?: number): Partial<CallOptions & {
+        runType?: string;
+    }>[];
     /**
      * Default implementation of batch, which calls invoke N times.
      * Subclasses should override this method if they can batch more efficiently.
@@ -287,6 +289,7 @@ export declare class RunnableMap<RunInput> extends Runnable<RunInput, Record<str
     constructor(fields: {
         steps: Record<string, RunnableLike<RunInput>>;
     });
+    static from<RunInput>(steps: Record<string, RunnableLike<RunInput>>): RunnableMap<RunInput>;
     invoke(input: RunInput, options?: Partial<BaseCallbackConfig>): Promise<Record<string, any>>;
 }
 /**
@@ -299,6 +302,7 @@ export declare class RunnableLambda<RunInput, RunOutput> extends Runnable<RunInp
     constructor(fields: {
         func: RunnableFunc<RunInput, RunOutput>;
     });
+    static from<RunInput, RunOutput>(func: RunnableFunc<RunInput, RunOutput>): RunnableLambda<RunInput, RunOutput>;
     _invoke(input: RunInput, config?: Partial<BaseCallbackConfig>, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;
     invoke(input: RunInput, options?: Partial<BaseCallbackConfig>): Promise<RunOutput>;
 }

package/dist/schema/runnable/base.js

@@ -137,16 +137,18 @@ export class Runnable extends Serializable {
             callbacks: options.callbacks,
             tags: options.tags,
             metadata: options.metadata,
+            runName: options.runName,
         };
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;
         delete callOptions.metadata;
+        delete callOptions.runName;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
         const callbackManager_ = await getCallbackMangerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName);
         let output;
         try {
             output = await func.bind(this)(input, options, runManager);
@@ -170,7 +172,7 @@ export class Runnable extends Serializable {
     async _batchWithConfig(func, inputs, options, batchOptions) {
         const configs = this._getOptionsList((options ?? {}), inputs.length);
         const callbackManagers = await Promise.all(configs.map(getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, configs[i].runType, undefined, undefined, configs[i].runName)));
         let outputs;
         try {
             outputs = await func(inputs, configs, runManagers, batchOptions);
@@ -200,7 +202,7 @@ export class Runnable extends Serializable {
                 if (!runManager) {
                     // Start the run manager AFTER the iterator starts to preserve
                     // tracing order
-                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType);
+                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName);
                 }
                 if (finalInputSupported) {
                     if (finalInput === undefined) {
@@ -251,7 +253,16 @@ export class Runnable extends Serializable {
         await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
     _patchConfig(config = {}, callbackManager = undefined) {
-        return { ...config, callbacks: callbackManager };
+        const newConfig = { ...config };
+        if (callbackManager !== undefined) {
+            /**
+             * If we're replacing callbacks we need to unset runName
+             * since that should apply only to the same run as the original callbacks
+             */
+            delete newConfig.runName;
+            return { ...newConfig, callbacks: callbackManager };
+        }
+        return newConfig;
     }
     /**
      * Create a new runnable sequence that runs each individual runnable in series,
@@ -680,7 +691,7 @@ export class RunnableSequence extends Runnable {
     }
     async invoke(input, options) {
         const callbackManager_ = await getCallbackMangerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         let nextStepInput = input;
         let finalOutput;
         try {
@@ -702,7 +713,7 @@ export class RunnableSequence extends Runnable {
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(configList.map(getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let nextStepInputs = inputs;
         let finalOutputs;
@@ -723,7 +734,7 @@ export class RunnableSequence extends Runnable {
     }
     async *_streamIterator(input, options) {
         const callbackManager_ = await getCallbackMangerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         let nextStepInput = input;
         const steps = [this.first, ...this.middle, this.last];
         // Find the index of the last runnable in the sequence that doesn't have an overridden .transform() method
@@ -847,13 +858,16 @@ export class RunnableMap extends Runnable {
             this.steps[key] = _coerceToRunnable(value);
         }
     }
+    static from(steps) {
+        return new RunnableMap({ steps });
+    }
     async invoke(input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
         const callbackManager_ = await getCallbackMangerForConfig(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
-        });
+        }, undefined, undefined, undefined, undefined, options?.runName);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const output = {};
         try {
@@ -892,6 +906,11 @@ export class RunnableLambda extends Runnable {
         });
         this.func = fields.func;
     }
+    static from(func) {
+        return new RunnableLambda({
+            func,
+        });
+    }
     async _invoke(input, config, runManager) {
         let output = await this.func(input);
         if (output && Runnable.isRunnable(output)) {
@@ -947,7 +966,7 @@ export class RunnableWithFallbacks extends Runnable {
     }
     async invoke(input, options) {
         const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         let firstError;
         for (const runnable of this.runnables()) {
             try {
@@ -973,7 +992,7 @@ export class RunnableWithFallbacks extends Runnable {
         }
         const configList = this._getOptionsList(options ?? {}, inputs.length);
         const callbackManagers = await Promise.all(configList.map((config) => CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let firstError;
         for (const runnable of this.runnables()) {

package/dist/stores/message/dynamodb.cjs

@@ -17,7 +17,7 @@ class DynamoDBChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
             "config.credentials.sessionToken": "AWS_SESSION_TOKEN",
         };
     }
-    constructor({ tableName, sessionId, partitionKey, sortKey, messageAttributeName, config, }) {
+    constructor({ tableName, sessionId, partitionKey, sortKey, messageAttributeName, config, key = {}, }) {
         super();
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
@@ -65,7 +65,7 @@ class DynamoDBChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: {}
         });
         this.tableName = tableName;
         this.sessionId = sessionId;
@@ -74,10 +74,13 @@ class DynamoDBChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
         this.sortKey = sortKey;
         this.messageAttributeName =
             messageAttributeName ?? this.messageAttributeName;
-        this.dynamoKey = {};
-        this.dynamoKey[this.partitionKey] = { S: this.sessionId };
-        if (this.sortKey) {
-            this.dynamoKey[this.sortKey] = { S: this.sortKey };
+        this.dynamoKey = key;
+        // override dynamoKey with partition key and sort key when key not specified
+        if (Object.keys(this.dynamoKey).length === 0) {
+            this.dynamoKey[this.partitionKey] = { S: this.sessionId };
+            if (this.sortKey) {
+                this.dynamoKey[this.sortKey] = { S: this.sortKey };
+            }
         }
     }
     /**

package/dist/stores/message/dynamodb.d.ts

@@ -1,4 +1,4 @@
-import { DynamoDBClientConfig } from "@aws-sdk/client-dynamodb";
+import { DynamoDBClientConfig, AttributeValue } from "@aws-sdk/client-dynamodb";
 import { BaseMessage, BaseListChatMessageHistory } from "../../schema/index.js";
 /**
  * Interface defining the fields required to create an instance of
@@ -13,6 +13,7 @@ export interface DynamoDBChatMessageHistoryFields {
     sortKey?: string;
     messageAttributeName?: string;
     config?: DynamoDBClientConfig;
+    key?: Record<string, AttributeValue>;
 }
 /**
  * Class providing methods to interact with a DynamoDB table to store and
@@ -31,7 +32,7 @@ export declare class DynamoDBChatMessageHistory extends BaseListChatMessageHisto
     private sortKey?;
     private messageAttributeName;
     private dynamoKey;
-    constructor({ tableName, sessionId, partitionKey, sortKey, messageAttributeName, config, }: DynamoDBChatMessageHistoryFields);
+    constructor({ tableName, sessionId, partitionKey, sortKey, messageAttributeName, config, key, }: DynamoDBChatMessageHistoryFields);
     /**
      * Retrieves all messages from the DynamoDB table and returns them as an
      * array of `BaseMessage` instances.

package/dist/stores/message/dynamodb.js

@@ -14,7 +14,7 @@ export class DynamoDBChatMessageHistory extends BaseListChatMessageHistory {
             "config.credentials.sessionToken": "AWS_SESSION_TOKEN",
         };
     }
-    constructor({ tableName, sessionId, partitionKey, sortKey, messageAttributeName, config, }) {
+    constructor({ tableName, sessionId, partitionKey, sortKey, messageAttributeName, config, key = {}, }) {
         super();
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
@@ -62,7 +62,7 @@ export class DynamoDBChatMessageHistory extends BaseListChatMessageHistory {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: {}
         });
         this.tableName = tableName;
         this.sessionId = sessionId;
@@ -71,10 +71,13 @@ export class DynamoDBChatMessageHistory extends BaseListChatMessageHistory {
         this.sortKey = sortKey;
         this.messageAttributeName =
             messageAttributeName ?? this.messageAttributeName;
-        this.dynamoKey = {};
-        this.dynamoKey[this.partitionKey] = { S: this.sessionId };
-        if (this.sortKey) {
-            this.dynamoKey[this.sortKey] = { S: this.sortKey };
+        this.dynamoKey = key;
+        // override dynamoKey with partition key and sort key when key not specified
+        if (Object.keys(this.dynamoKey).length === 0) {
+            this.dynamoKey[this.partitionKey] = { S: this.sessionId };
+            if (this.sortKey) {
+                this.dynamoKey[this.sortKey] = { S: this.sortKey };
+            }
         }
     }
     /**

package/dist/text_splitter.cjs

@@ -76,21 +76,30 @@ class TextSplitter extends document_js_2.BaseDocumentTransformer {
             const text = texts[i];
             let lineCounterIndex = 1;
             let prevChunk = null;
+            let indexPrevChunk = -1;
             for (const chunk of await this.splitText(text)) {
                 let pageContent = chunkHeader;
                 // we need to count the \n that are in the text before getting removed by the splitting
-                let numberOfIntermediateNewLines = 0;
-                if (prevChunk) {
-                    const indexChunk = text.indexOf(chunk);
-                    const indexEndPrevChunk = text.indexOf(prevChunk) + (await this.lengthFunction(prevChunk));
-                    const removedNewlinesFromSplittingText = text.slice(indexEndPrevChunk, indexChunk);
-                    numberOfIntermediateNewLines = (removedNewlinesFromSplittingText.match(/\n/g) || []).length;
+                const indexChunk = text.indexOf(chunk, indexPrevChunk + 1);
+                if (prevChunk === null) {
+                    const newLinesBeforeFirstChunk = this.numberOfNewLines(text, 0, indexChunk);
+                    lineCounterIndex += newLinesBeforeFirstChunk;
+                }
+                else {
+                    const indexEndPrevChunk = indexPrevChunk + (await this.lengthFunction(prevChunk));
+                    if (indexEndPrevChunk < indexChunk) {
+                        const numberOfIntermediateNewLines = this.numberOfNewLines(text, indexEndPrevChunk, indexChunk);
+                        lineCounterIndex += numberOfIntermediateNewLines;
+                    }
+                    else if (indexEndPrevChunk > indexChunk) {
+                        const numberOfIntermediateNewLines = this.numberOfNewLines(text, indexChunk, indexEndPrevChunk);
+                        lineCounterIndex -= numberOfIntermediateNewLines;
+                    }
                     if (appendChunkOverlapHeader) {
                         pageContent += chunkOverlapHeader;
                     }
                 }
-                lineCounterIndex += numberOfIntermediateNewLines;
-                const newLinesCount = (chunk.match(/\n/g) || []).length;
+                const newLinesCount = this.numberOfNewLines(chunk);
                 const loc = _metadatas[i].loc && typeof _metadatas[i].loc === "object"
                     ? { ..._metadatas[i].loc }
                     : {};
@@ -109,10 +118,15 @@ class TextSplitter extends document_js_2.BaseDocumentTransformer {
                 }));
                 lineCounterIndex += newLinesCount;
                 prevChunk = chunk;
+                indexPrevChunk = indexChunk;
             }
         }
         return documents;
     }
+    numberOfNewLines(text, start, end) {
+        const textSection = text.slice(start, end);
+        return (textSection.match(/\n/g) || []).length;
+    }
     async splitDocuments(documents, chunkHeaderOptions = {}) {
         const selectedDocuments = documents.filter((doc) => doc.pageContent !== undefined);
         const texts = selectedDocuments.map((doc) => doc.pageContent);

package/dist/text_splitter.d.ts

@@ -23,6 +23,7 @@ export declare abstract class TextSplitter extends BaseDocumentTransformer imple
     abstract splitText(text: string): Promise<string[]>;
     protected splitOnSeparator(text: string, separator: string): string[];
     createDocuments(texts: string[], metadatas?: Record<string, any>[], chunkHeaderOptions?: TextSplitterChunkHeaderOptions): Promise<Document[]>;
+    private numberOfNewLines;
     splitDocuments(documents: Document[], chunkHeaderOptions?: TextSplitterChunkHeaderOptions): Promise<Document[]>;
     private joinDocs;
     mergeSplits(splits: string[], separator: string): Promise<string[]>;