langchain 0.0.63 → 0.0.64

package/dist/chains/sequential_chain.cjs

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleSequentialChain = exports.SequentialChain = void 0;
+const base_js_1 = require("./base.cjs");
+const set_js_1 = require("../util/set.cjs");
+function formatSet(input) {
+    return Array.from(input)
+        .map((i) => `"${i}"`)
+        .join(", ");
+}
+/**
+ * Chain where the outputs of one chain feed directly into next.
+ */
+class SequentialChain extends base_js_1.BaseChain {
+    get inputKeys() {
+        return this.inputVariables;
+    }
+    get outputKeys() {
+        return this.outputVariables;
+    }
+    constructor(fields) {
+        super(fields.memory, fields.verbose, fields.callbackManager);
+        Object.defineProperty(this, "chains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "outputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "returnAll", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.chains = fields.chains;
+        this.inputVariables = fields.inputVariables;
+        this.outputVariables = fields.outputVariables ?? [];
+        if (this.outputVariables.length > 0 && fields.returnAll) {
+            throw new Error("Either specify variables to return using `outputVariables` or use `returnAll` param. Cannot apply both conditions at the same time.");
+        }
+        this.returnAll = fields.returnAll ?? false;
+        this._validateChains();
+    }
+    /** @ignore */
+    _validateChains() {
+        if (this.chains.length === 0) {
+            throw new Error("Sequential chain must have at least one chain.");
+        }
+        const memoryKeys = this.memory?.memoryKeys ?? [];
+        const inputKeysSet = new Set(this.inputKeys);
+        const memoryKeysSet = new Set(memoryKeys);
+        const keysIntersection = (0, set_js_1.intersection)(inputKeysSet, memoryKeysSet);
+        if (keysIntersection.size > 0) {
+            throw new Error(`The following keys: ${formatSet(keysIntersection)} are overlapping between memory and input keys of the chain variables. This can lead to unexpected behaviour. Please use input and memory keys that don't overlap.`);
+        }
+        const availableKeys = (0, set_js_1.union)(inputKeysSet, memoryKeysSet);
+        for (const chain of this.chains) {
+            const missingKeys = (0, set_js_1.difference)(new Set(chain.inputKeys), availableKeys);
+            if (missingKeys.size > 0) {
+                throw new Error(`Missing variables for chain "${chain._chainType()}": ${formatSet(missingKeys)}. Only got the following variables: ${formatSet(availableKeys)}.`);
+            }
+            const outputKeysSet = new Set(chain.outputKeys);
+            const overlappinOutputKeys = (0, set_js_1.intersection)(availableKeys, outputKeysSet);
+            if (overlappinOutputKeys.size > 0) {
+                throw new Error(`The following output variables for chain "${chain._chainType()}" are overlapping: ${formatSet(overlappinOutputKeys)}. This can lead to unexpected behaviour.`);
+            }
+            for (const outputKey of outputKeysSet) {
+                availableKeys.add(outputKey);
+            }
+        }
+        if (this.outputVariables.length === 0) {
+            if (this.returnAll) {
+                const outputKeys = (0, set_js_1.difference)(availableKeys, inputKeysSet);
+                this.outputVariables = Array.from(outputKeys);
+            }
+            else {
+                this.outputVariables = this.chains[this.chains.length - 1].outputKeys;
+            }
+        }
+        else {
+            const missingKeys = (0, set_js_1.difference)(new Set(this.outputVariables), new Set(availableKeys));
+            if (missingKeys.size > 0) {
+                throw new Error(`The following output variables were expected to be in the final chain output but were not found: ${formatSet(missingKeys)}.`);
+            }
+        }
+    }
+    /** @ignore */
+    async _call(values, runManager) {
+        let input = values;
+        const allChainValues = {};
+        for (const chain of this.chains) {
+            input = await chain.call(input, runManager?.getChild());
+            for (const key of Object.keys(input)) {
+                allChainValues[key] = input[key];
+            }
+        }
+        const output = {};
+        for (const key of this.outputVariables) {
+            output[key] = allChainValues[key];
+        }
+        return output;
+    }
+    _chainType() {
+        return "sequential_chain";
+    }
+    static async deserialize(data) {
+        const chains = [];
+        const inputVariables = data.input_variables;
+        const outputVariables = data.output_variables;
+        const serializedChains = data.chains;
+        for (const serializedChain of serializedChains) {
+            const deserializedChain = await base_js_1.BaseChain.deserialize(serializedChain);
+            chains.push(deserializedChain);
+        }
+        return new SequentialChain({ chains, inputVariables, outputVariables });
+    }
+    serialize() {
+        const chains = [];
+        for (const chain of this.chains) {
+            chains.push(chain.serialize());
+        }
+        return {
+            _type: this._chainType(),
+            input_variables: this.inputVariables,
+            output_variables: this.outputVariables,
+            chains,
+        };
+    }
+}
+exports.SequentialChain = SequentialChain;
+/**
+ * Simple chain where a single string output of one chain is fed directly into the next.
+ * @augments BaseChain
+ * @augments SimpleSequentialChainInput
+ *
+ * @example
+ * ```ts
+ * import { SimpleSequentialChain, LLMChain } from "langchain/chains";
+ * import { OpenAI } from "langchain/llms/openai";
+ * import { PromptTemplate } from "langchain/prompts";
+ *
+ * // This is an LLMChain to write a synopsis given a title of a play.
+ * const llm = new OpenAI({ temperature: 0 });
+ * const template = `You are a playwright. Given the title of play, it is your job to write a synopsis for that title.
+ *
+ * Title: {title}
+ * Playwright: This is a synopsis for the above play:`
+ * const promptTemplate = new PromptTemplate({ template, inputVariables: ["title"] });
+ * const synopsisChain = new LLMChain({ llm, prompt: promptTemplate });
+ *
+ *
+ * // This is an LLMChain to write a review of a play given a synopsis.
+ * const reviewLLM = new OpenAI({ temperature: 0 })
+ * const reviewTemplate = `You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.
+ *
+ * Play Synopsis:
+ * {synopsis}
+ * Review from a New York Times play critic of the above play:`
+ * const reviewPromptTempalte = new PromptTemplate({ template: reviewTemplate, inputVariables: ["synopsis"] });
+ * const reviewChain = new LLMChain({ llm: reviewLLM, prompt: reviewPromptTempalte });
+ *
+ * const overallChain = new SimpleSequentialChain({chains: [synopsisChain, reviewChain], verbose:true})
+ * const review = await overallChain.run("Tragedy at sunset on the beach")
+ * // the variable review contains resulting play review.
+ * ```
+ */
+class SimpleSequentialChain extends base_js_1.BaseChain {
+    get inputKeys() {
+        return [this.inputKey];
+    }
+    get outputKeys() {
+        return [this.outputKey];
+    }
+    constructor(fields) {
+        super(fields.memory, fields.verbose, fields.callbacks ?? fields.callbackManager);
+        Object.defineProperty(this, "chains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "input"
+        });
+        Object.defineProperty(this, "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "output"
+        });
+        Object.defineProperty(this, "trimOutputs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.chains = fields.chains;
+        this.trimOutputs = fields.trimOutputs ?? false;
+        this._validateChains();
+    }
+    /** @ignore */
+    _validateChains() {
+        for (const chain of this.chains) {
+            if (chain.inputKeys.length !== 1) {
+                throw new Error(`Chains used in SimpleSequentialChain should all have one input, got ${chain.inputKeys.length} for ${chain._chainType()}.`);
+            }
+            if (chain.outputKeys.length !== 1) {
+                throw new Error(`Chains used in SimpleSequentialChain should all have one output, got ${chain.outputKeys.length} for ${chain._chainType()}.`);
+            }
+        }
+    }
+    /** @ignore */
+    async _call(values, runManager) {
+        let input = values[this.inputKey];
+        for (const chain of this.chains) {
+            input = await chain.run(input, runManager?.getChild());
+            if (this.trimOutputs) {
+                input = input.trim();
+            }
+            await runManager?.handleText(input);
+        }
+        return { [this.outputKey]: input };
+    }
+    _chainType() {
+        return "simple_sequential_chain";
+    }
+    static async deserialize(data) {
+        const chains = [];
+        const serializedChains = data.chains;
+        for (const serializedChain of serializedChains) {
+            const deserializedChain = await base_js_1.BaseChain.deserialize(serializedChain);
+            chains.push(deserializedChain);
+        }
+        return new SimpleSequentialChain({ chains });
+    }
+    serialize() {
+        const chains = [];
+        for (const chain of this.chains) {
+            chains.push(chain.serialize());
+        }
+        return {
+            _type: this._chainType(),
+            chains,
+        };
+    }
+}
+exports.SimpleSequentialChain = SimpleSequentialChain;

package/dist/chains/{simple_sequential_chain.d.ts → sequential_chain.d.ts}

@@ -1,7 +1,36 @@
 import { BaseChain, ChainInputs } from "./base.js";
 import { ChainValues } from "../schema/index.js";
-import { SerializedSimpleSequentialChain } from "./serde.js";
+import { SerializedSequentialChain, SerializedSimpleSequentialChain } from "./serde.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
+export interface SequentialChainInput extends ChainInputs {
+    /** Array of chains to run as a sequence. The chains are run in order they appear in the array. */
+    chains: BaseChain[];
+    /** Defines which variables should be passed as initial input to the first chain. */
+    inputVariables: string[];
+    /** Which variables should be returned as a result of executing the chain. If not specified, output of the last of the chains is used. */
+    outputVariables?: string[];
+    /** Whether or not to return all intermediate outputs and variables (excluding initial input variables). */
+    returnAll?: boolean;
+}
+/**
+ * Chain where the outputs of one chain feed directly into next.
+ */
+export declare class SequentialChain extends BaseChain implements SequentialChainInput {
+    chains: BaseChain[];
+    inputVariables: string[];
+    outputVariables: string[];
+    returnAll?: boolean | undefined;
+    get inputKeys(): string[];
+    get outputKeys(): string[];
+    constructor(fields: SequentialChainInput);
+    /** @ignore */
+    _validateChains(): void;
+    /** @ignore */
+    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;
+    _chainType(): "sequential_chain";
+    static deserialize(data: SerializedSequentialChain): Promise<SequentialChain>;
+    serialize(): SerializedSequentialChain;
+}
 export interface SimpleSequentialChainInput extends ChainInputs {
     /** Array of chains to run as a sequence. The chains are run in order they appear in the array. */
     chains: Array<BaseChain>;
@@ -55,7 +84,7 @@ export declare class SimpleSequentialChain extends BaseChain implements SimpleSe
     /** @ignore */
     _validateChains(): void;
     /** @ignore */
-    _call(values: ChainValues, runManager: CallbackManagerForChainRun): Promise<ChainValues>;
+    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;
     _chainType(): "simple_sequential_chain";
     static deserialize(data: SerializedSimpleSequentialChain): Promise<SimpleSequentialChain>;
     serialize(): SerializedSimpleSequentialChain;

package/dist/chains/sequential_chain.js

@@ -0,0 +1,257 @@
+import { BaseChain } from "./base.js";
+import { intersection, union, difference } from "../util/set.js";
+function formatSet(input) {
+    return Array.from(input)
+        .map((i) => `"${i}"`)
+        .join(", ");
+}
+/**
+ * Chain where the outputs of one chain feed directly into next.
+ */
+export class SequentialChain extends BaseChain {
+    get inputKeys() {
+        return this.inputVariables;
+    }
+    get outputKeys() {
+        return this.outputVariables;
+    }
+    constructor(fields) {
+        super(fields.memory, fields.verbose, fields.callbackManager);
+        Object.defineProperty(this, "chains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "outputVariables", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "returnAll", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.chains = fields.chains;
+        this.inputVariables = fields.inputVariables;
+        this.outputVariables = fields.outputVariables ?? [];
+        if (this.outputVariables.length > 0 && fields.returnAll) {
+            throw new Error("Either specify variables to return using `outputVariables` or use `returnAll` param. Cannot apply both conditions at the same time.");
+        }
+        this.returnAll = fields.returnAll ?? false;
+        this._validateChains();
+    }
+    /** @ignore */
+    _validateChains() {
+        if (this.chains.length === 0) {
+            throw new Error("Sequential chain must have at least one chain.");
+        }
+        const memoryKeys = this.memory?.memoryKeys ?? [];
+        const inputKeysSet = new Set(this.inputKeys);
+        const memoryKeysSet = new Set(memoryKeys);
+        const keysIntersection = intersection(inputKeysSet, memoryKeysSet);
+        if (keysIntersection.size > 0) {
+            throw new Error(`The following keys: ${formatSet(keysIntersection)} are overlapping between memory and input keys of the chain variables. This can lead to unexpected behaviour. Please use input and memory keys that don't overlap.`);
+        }
+        const availableKeys = union(inputKeysSet, memoryKeysSet);
+        for (const chain of this.chains) {
+            const missingKeys = difference(new Set(chain.inputKeys), availableKeys);
+            if (missingKeys.size > 0) {
+                throw new Error(`Missing variables for chain "${chain._chainType()}": ${formatSet(missingKeys)}. Only got the following variables: ${formatSet(availableKeys)}.`);
+            }
+            const outputKeysSet = new Set(chain.outputKeys);
+            const overlappinOutputKeys = intersection(availableKeys, outputKeysSet);
+            if (overlappinOutputKeys.size > 0) {
+                throw new Error(`The following output variables for chain "${chain._chainType()}" are overlapping: ${formatSet(overlappinOutputKeys)}. This can lead to unexpected behaviour.`);
+            }
+            for (const outputKey of outputKeysSet) {
+                availableKeys.add(outputKey);
+            }
+        }
+        if (this.outputVariables.length === 0) {
+            if (this.returnAll) {
+                const outputKeys = difference(availableKeys, inputKeysSet);
+                this.outputVariables = Array.from(outputKeys);
+            }
+            else {
+                this.outputVariables = this.chains[this.chains.length - 1].outputKeys;
+            }
+        }
+        else {
+            const missingKeys = difference(new Set(this.outputVariables), new Set(availableKeys));
+            if (missingKeys.size > 0) {
+                throw new Error(`The following output variables were expected to be in the final chain output but were not found: ${formatSet(missingKeys)}.`);
+            }
+        }
+    }
+    /** @ignore */
+    async _call(values, runManager) {
+        let input = values;
+        const allChainValues = {};
+        for (const chain of this.chains) {
+            input = await chain.call(input, runManager?.getChild());
+            for (const key of Object.keys(input)) {
+                allChainValues[key] = input[key];
+            }
+        }
+        const output = {};
+        for (const key of this.outputVariables) {
+            output[key] = allChainValues[key];
+        }
+        return output;
+    }
+    _chainType() {
+        return "sequential_chain";
+    }
+    static async deserialize(data) {
+        const chains = [];
+        const inputVariables = data.input_variables;
+        const outputVariables = data.output_variables;
+        const serializedChains = data.chains;
+        for (const serializedChain of serializedChains) {
+            const deserializedChain = await BaseChain.deserialize(serializedChain);
+            chains.push(deserializedChain);
+        }
+        return new SequentialChain({ chains, inputVariables, outputVariables });
+    }
+    serialize() {
+        const chains = [];
+        for (const chain of this.chains) {
+            chains.push(chain.serialize());
+        }
+        return {
+            _type: this._chainType(),
+            input_variables: this.inputVariables,
+            output_variables: this.outputVariables,
+            chains,
+        };
+    }
+}
+/**
+ * Simple chain where a single string output of one chain is fed directly into the next.
+ * @augments BaseChain
+ * @augments SimpleSequentialChainInput
+ *
+ * @example
+ * ```ts
+ * import { SimpleSequentialChain, LLMChain } from "langchain/chains";
+ * import { OpenAI } from "langchain/llms/openai";
+ * import { PromptTemplate } from "langchain/prompts";
+ *
+ * // This is an LLMChain to write a synopsis given a title of a play.
+ * const llm = new OpenAI({ temperature: 0 });
+ * const template = `You are a playwright. Given the title of play, it is your job to write a synopsis for that title.
+ *
+ * Title: {title}
+ * Playwright: This is a synopsis for the above play:`
+ * const promptTemplate = new PromptTemplate({ template, inputVariables: ["title"] });
+ * const synopsisChain = new LLMChain({ llm, prompt: promptTemplate });
+ *
+ *
+ * // This is an LLMChain to write a review of a play given a synopsis.
+ * const reviewLLM = new OpenAI({ temperature: 0 })
+ * const reviewTemplate = `You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.
+ *
+ * Play Synopsis:
+ * {synopsis}
+ * Review from a New York Times play critic of the above play:`
+ * const reviewPromptTempalte = new PromptTemplate({ template: reviewTemplate, inputVariables: ["synopsis"] });
+ * const reviewChain = new LLMChain({ llm: reviewLLM, prompt: reviewPromptTempalte });
+ *
+ * const overallChain = new SimpleSequentialChain({chains: [synopsisChain, reviewChain], verbose:true})
+ * const review = await overallChain.run("Tragedy at sunset on the beach")
+ * // the variable review contains resulting play review.
+ * ```
+ */
+export class SimpleSequentialChain extends BaseChain {
+    get inputKeys() {
+        return [this.inputKey];
+    }
+    get outputKeys() {
+        return [this.outputKey];
+    }
+    constructor(fields) {
+        super(fields.memory, fields.verbose, fields.callbacks ?? fields.callbackManager);
+        Object.defineProperty(this, "chains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "input"
+        });
+        Object.defineProperty(this, "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "output"
+        });
+        Object.defineProperty(this, "trimOutputs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.chains = fields.chains;
+        this.trimOutputs = fields.trimOutputs ?? false;
+        this._validateChains();
+    }
+    /** @ignore */
+    _validateChains() {
+        for (const chain of this.chains) {
+            if (chain.inputKeys.length !== 1) {
+                throw new Error(`Chains used in SimpleSequentialChain should all have one input, got ${chain.inputKeys.length} for ${chain._chainType()}.`);
+            }
+            if (chain.outputKeys.length !== 1) {
+                throw new Error(`Chains used in SimpleSequentialChain should all have one output, got ${chain.outputKeys.length} for ${chain._chainType()}.`);
+            }
+        }
+    }
+    /** @ignore */
+    async _call(values, runManager) {
+        let input = values[this.inputKey];
+        for (const chain of this.chains) {
+            input = await chain.run(input, runManager?.getChild());
+            if (this.trimOutputs) {
+                input = input.trim();
+            }
+            await runManager?.handleText(input);
+        }
+        return { [this.outputKey]: input };
+    }
+    _chainType() {
+        return "simple_sequential_chain";
+    }
+    static async deserialize(data) {
+        const chains = [];
+        const serializedChains = data.chains;
+        for (const serializedChain of serializedChains) {
+            const deserializedChain = await BaseChain.deserialize(serializedChain);
+            chains.push(deserializedChain);
+        }
+        return new SimpleSequentialChain({ chains });
+    }
+    serialize() {
+        const chains = [];
+        for (const chain of this.chains) {
+            chains.push(chain.serialize());
+        }
+        return {
+            _type: this._chainType(),
+            chains,
+        };
+    }
+}

package/dist/chains/serde.d.ts

@@ -6,6 +6,12 @@ export type SerializedLLMChain = {
     llm?: SerializedLLM;
     prompt?: SerializedBasePromptTemplate;
 };
+export type SerializedSequentialChain = {
+    _type: "sequential_chain";
+    input_variables: string[];
+    output_variables: string[];
+    chains: SerializedBaseChain[];
+};
 export type SerializedSimpleSequentialChain = {
     _type: "simple_sequential_chain";
     chains: Array<SerializedBaseChain>;
@@ -44,4 +50,4 @@ export type SerializedAnalyzeDocumentChain = {
     _type: "analyze_document_chain";
     combine_document_chain?: SerializedBaseChain;
 };
-export type SerializedBaseChain = SerializedLLMChain | SerializedSimpleSequentialChain | SerializedVectorDBQAChain | SerializedStuffDocumentsChain | SerializedSqlDatabaseChain | SerializedChatVectorDBQAChain | SerializedMapReduceDocumentsChain | SerializedAnalyzeDocumentChain | SerializedRefineDocumentsChain;
+export type SerializedBaseChain = SerializedLLMChain | SerializedSequentialChain | SerializedSimpleSequentialChain | SerializedVectorDBQAChain | SerializedStuffDocumentsChain | SerializedSqlDatabaseChain | SerializedChatVectorDBQAChain | SerializedMapReduceDocumentsChain | SerializedAnalyzeDocumentChain | SerializedRefineDocumentsChain;

package/dist/chains/sql_db/sql_db_chain.cjs

@@ -63,8 +63,8 @@ class SqlDatabaseChain extends base_js_1.BaseChain {
         this.outputKey = fields.outputKey ?? this.outputKey;
     }
     /** @ignore */
-    async _call(values) {
-        const lLMChain = new llm_chain_js_1.LLMChain({
+    async _call(values, runManager) {
+        const llmChain = new llm_chain_js_1.LLMChain({
             prompt: this.prompt,
             llm: this.llm,
             outputKey: this.outputKey,
@@ -86,7 +86,7 @@ class SqlDatabaseChain extends base_js_1.BaseChain {
         };
         await this.verifyNumberOfTokens(inputText, tableInfo);
         const intermediateStep = [];
-        const sqlCommand = await lLMChain.predict(llmInputs);
+        const sqlCommand = await llmChain.predict(llmInputs, runManager?.getChild());
         intermediateStep.push(sqlCommand);
         let queryResult = "";
         try {
@@ -103,7 +103,9 @@ class SqlDatabaseChain extends base_js_1.BaseChain {
         else {
             inputText += `${+sqlCommand}\nSQLResult: ${JSON.stringify(queryResult)}\nAnswer:`;
             llmInputs.input = inputText;
-            finalResult = { [this.outputKey]: await lLMChain.predict(llmInputs) };
+            finalResult = {
+                [this.outputKey]: await llmChain.predict(llmInputs, runManager?.getChild()),
+            };
         }
         return finalResult;
     }

package/dist/chains/sql_db/sql_db_chain.d.ts

@@ -3,6 +3,7 @@ import type { SqlDatabase } from "../../sql_db.js";
 import { ChainValues } from "../../schema/index.js";
 import { SerializedSqlDatabaseChain } from "../serde.js";
 import { BaseLanguageModel } from "../../base_language/index.js";
+import { CallbackManagerForChainRun } from "../../callbacks/manager.js";
 export interface SqlDatabaseChainInput extends ChainInputs {
     llm: BaseLanguageModel;
     database: SqlDatabase;
@@ -20,7 +21,7 @@ export declare class SqlDatabaseChain extends BaseChain {
     returnDirect: boolean;
     constructor(fields: SqlDatabaseChainInput);
     /** @ignore */
-    _call(values: ChainValues): Promise<ChainValues>;
+    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;
     _chainType(): "sql_database_chain";
     get inputKeys(): string[];
     get outputKeys(): string[];

package/dist/chains/sql_db/sql_db_chain.js

@@ -60,8 +60,8 @@ export class SqlDatabaseChain extends BaseChain {
         this.outputKey = fields.outputKey ?? this.outputKey;
     }
     /** @ignore */
-    async _call(values) {
-        const lLMChain = new LLMChain({
+    async _call(values, runManager) {
+        const llmChain = new LLMChain({
             prompt: this.prompt,
             llm: this.llm,
             outputKey: this.outputKey,
@@ -83,7 +83,7 @@ export class SqlDatabaseChain extends BaseChain {
         };
         await this.verifyNumberOfTokens(inputText, tableInfo);
         const intermediateStep = [];
-        const sqlCommand = await lLMChain.predict(llmInputs);
+        const sqlCommand = await llmChain.predict(llmInputs, runManager?.getChild());
         intermediateStep.push(sqlCommand);
         let queryResult = "";
         try {
@@ -100,7 +100,9 @@ export class SqlDatabaseChain extends BaseChain {
         else {
             inputText += `${+sqlCommand}\nSQLResult: ${JSON.stringify(queryResult)}\nAnswer:`;
             llmInputs.input = inputText;
-            finalResult = { [this.outputKey]: await lLMChain.predict(llmInputs) };
+            finalResult = {
+                [this.outputKey]: await llmChain.predict(llmInputs, runManager?.getChild()),
+            };
         }
         return finalResult;
     }

package/dist/chains/vector_db_qa.cjs

@@ -50,14 +50,14 @@ class VectorDBQAChain extends base_js_1.BaseChain {
             fields.returnSourceDocuments ?? this.returnSourceDocuments;
     }
     /** @ignore */
-    async _call(values) {
+    async _call(values, runManager) {
         if (!(this.inputKey in values)) {
             throw new Error(`Question key ${this.inputKey} not found.`);
         }
         const question = values[this.inputKey];
         const docs = await this.vectorstore.similaritySearch(question, this.k);
         const inputs = { question, input_documents: docs };
-        const result = await this.combineDocumentsChain.call(inputs);
+        const result = await this.combineDocumentsChain.call(inputs, runManager?.getChild());
         if (this.returnSourceDocuments) {
             return {
                 ...result,