langchain 0.0.138 → 0.0.140

package/dist/experimental/chat_models/anthropic_functions.cjs

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicFunctions = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const index_js_1 = require("../../schema/index.cjs");
+const anthropic_js_1 = require("../../chat_models/anthropic.cjs");
+const prompt_js_1 = require("../../prompts/prompt.cjs");
+const convert_to_openai_js_1 = require("../../tools/convert_to_openai.cjs");
+const TOOL_SYSTEM_PROMPT = 
+/* #__PURE__ */
+prompt_js_1.PromptTemplate.fromTemplate(`In addition to responding, you can use tools.
+You have access to the following tools.
+
+{tools}
+
+In order to use a tool, you can use <tool></tool> to specify the name,
+and the <tool_input></tool_input> tags to specify the parameters.
+Each parameter should be passed in as <$param_name>$value</$param_name>,
+Where $param_name is the name of the specific parameter, and $value
+is the value for that parameter.
+
+You will then get back a response in the form <observation></observation>
+For example, if you have a tool called 'search' that accepts a single
+parameter 'query' that could run a google search, in order to search
+for the weather in SF you would respond:
+
+<tool>search</tool><tool_input><query>weather in SF</query></tool_input>
+<observation>64 degrees</observation>`);
+class AnthropicFunctions extends anthropic_js_1.ChatAnthropic {
+    static lc_name() {
+        return "AnthropicFunctions";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+    }
+    async _generate(messages, options, runManager) {
+        let promptMessages = messages;
+        let forced = false;
+        let functionCall;
+        if (options.tools) {
+            // eslint-disable-next-line no-param-reassign
+            options.functions = (options.functions ?? []).concat(options.tools.map(convert_to_openai_js_1.formatToOpenAIFunction));
+        }
+        if (options.functions !== undefined && options.functions.length > 0) {
+            const content = await TOOL_SYSTEM_PROMPT.format({
+                tools: JSON.stringify(options.functions, null, 2),
+            });
+            const systemMessage = new index_js_1.SystemMessage({ content });
+            promptMessages = [systemMessage].concat(promptMessages);
+            const stopSequences = options?.stop?.concat(anthropic_js_1.DEFAULT_STOP_SEQUENCES) ??
+                this.stopSequences ??
+                anthropic_js_1.DEFAULT_STOP_SEQUENCES;
+            // eslint-disable-next-line no-param-reassign
+            options.stop = stopSequences.concat(["</tool_input>"]);
+            if (options.function_call) {
+                if (typeof options.function_call === "string") {
+                    functionCall = JSON.parse(options.function_call).name;
+                }
+                else {
+                    functionCall = options.function_call.name;
+                }
+                forced = true;
+                const matchingFunction = options.functions.find((tool) => tool.name === functionCall);
+                if (!matchingFunction) {
+                    throw new Error(`No matching function found for passed "function_call"`);
+                }
+                promptMessages = promptMessages.concat([
+                    new index_js_1.AIMessage({
+                        content: `<tool>${functionCall}</tool>`,
+                    }),
+                ]);
+                // eslint-disable-next-line no-param-reassign
+                delete options.function_call;
+            }
+            // eslint-disable-next-line no-param-reassign
+            delete options.functions;
+        }
+        else if (options.function_call !== undefined) {
+            throw new Error(`If "function_call" is provided, "functions" must also be.`);
+        }
+        const chatResult = await super._generate(promptMessages, options, runManager);
+        const chatGenerationContent = chatResult.generations[0].message.content;
+        if (forced) {
+            const parser = new fast_xml_parser_1.XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            const responseMessageWithFunctions = new index_js_1.AIMessage({
+                content: "",
+                additional_kwargs: {
+                    function_call: {
+                        name: functionCall,
+                        arguments: result.tool_input
+                            ? JSON.stringify(result.tool_input)
+                            : "",
+                    },
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        else if (chatGenerationContent.includes("<tool>")) {
+            const parser = new fast_xml_parser_1.XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            const responseMessageWithFunctions = new index_js_1.AIMessage({
+                content: chatGenerationContent.split("<tool>")[0],
+                additional_kwargs: {
+                    function_call: {
+                        name: result.tool,
+                        arguments: result.tool_input
+                            ? JSON.stringify(result.tool_input)
+                            : "",
+                    },
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        return chatResult;
+    }
+    _llmType() {
+        return "anthropic_functions";
+    }
+    /** @ignore */
+    _combineLLMOutput() {
+        return [];
+    }
+}
+exports.AnthropicFunctions = AnthropicFunctions;

package/dist/experimental/chat_models/anthropic_functions.d.ts

@@ -0,0 +1,20 @@
+import type { ChatCompletionFunctions, CreateChatCompletionRequestFunctionCall } from "openai";
+import { BaseChatModelParams } from "../../chat_models/base.js";
+import { CallbackManagerForLLMRun } from "../../callbacks/manager.js";
+import { BaseMessage, ChatResult } from "../../schema/index.js";
+import { ChatAnthropic, type AnthropicInput } from "../../chat_models/anthropic.js";
+import { BaseLanguageModelCallOptions } from "../../base_language/index.js";
+import { StructuredTool } from "../../tools/base.js";
+export interface ChatAnthropicFunctionsCallOptions extends BaseLanguageModelCallOptions {
+    function_call?: CreateChatCompletionRequestFunctionCall;
+    functions?: ChatCompletionFunctions[];
+    tools?: StructuredTool[];
+}
+export declare class AnthropicFunctions extends ChatAnthropic<ChatAnthropicFunctionsCallOptions> {
+    static lc_name(): string;
+    constructor(fields?: Partial<AnthropicInput> & BaseChatModelParams);
+    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
+    _llmType(): string;
+    /** @ignore */
+    _combineLLMOutput(): never[];
+}

package/dist/experimental/chat_models/anthropic_functions.js

@@ -0,0 +1,125 @@
+import { XMLParser } from "fast-xml-parser";
+import { AIMessage, SystemMessage, } from "../../schema/index.js";
+import { ChatAnthropic, DEFAULT_STOP_SEQUENCES, } from "../../chat_models/anthropic.js";
+import { PromptTemplate } from "../../prompts/prompt.js";
+import { formatToOpenAIFunction } from "../../tools/convert_to_openai.js";
+const TOOL_SYSTEM_PROMPT = 
+/* #__PURE__ */
+PromptTemplate.fromTemplate(`In addition to responding, you can use tools.
+You have access to the following tools.
+
+{tools}
+
+In order to use a tool, you can use <tool></tool> to specify the name,
+and the <tool_input></tool_input> tags to specify the parameters.
+Each parameter should be passed in as <$param_name>$value</$param_name>,
+Where $param_name is the name of the specific parameter, and $value
+is the value for that parameter.
+
+You will then get back a response in the form <observation></observation>
+For example, if you have a tool called 'search' that accepts a single
+parameter 'query' that could run a google search, in order to search
+for the weather in SF you would respond:
+
+<tool>search</tool><tool_input><query>weather in SF</query></tool_input>
+<observation>64 degrees</observation>`);
+export class AnthropicFunctions extends ChatAnthropic {
+    static lc_name() {
+        return "AnthropicFunctions";
+    }
+    constructor(fields) {
+        super(fields ?? {});
+    }
+    async _generate(messages, options, runManager) {
+        let promptMessages = messages;
+        let forced = false;
+        let functionCall;
+        if (options.tools) {
+            // eslint-disable-next-line no-param-reassign
+            options.functions = (options.functions ?? []).concat(options.tools.map(formatToOpenAIFunction));
+        }
+        if (options.functions !== undefined && options.functions.length > 0) {
+            const content = await TOOL_SYSTEM_PROMPT.format({
+                tools: JSON.stringify(options.functions, null, 2),
+            });
+            const systemMessage = new SystemMessage({ content });
+            promptMessages = [systemMessage].concat(promptMessages);
+            const stopSequences = options?.stop?.concat(DEFAULT_STOP_SEQUENCES) ??
+                this.stopSequences ??
+                DEFAULT_STOP_SEQUENCES;
+            // eslint-disable-next-line no-param-reassign
+            options.stop = stopSequences.concat(["</tool_input>"]);
+            if (options.function_call) {
+                if (typeof options.function_call === "string") {
+                    functionCall = JSON.parse(options.function_call).name;
+                }
+                else {
+                    functionCall = options.function_call.name;
+                }
+                forced = true;
+                const matchingFunction = options.functions.find((tool) => tool.name === functionCall);
+                if (!matchingFunction) {
+                    throw new Error(`No matching function found for passed "function_call"`);
+                }
+                promptMessages = promptMessages.concat([
+                    new AIMessage({
+                        content: `<tool>${functionCall}</tool>`,
+                    }),
+                ]);
+                // eslint-disable-next-line no-param-reassign
+                delete options.function_call;
+            }
+            // eslint-disable-next-line no-param-reassign
+            delete options.functions;
+        }
+        else if (options.function_call !== undefined) {
+            throw new Error(`If "function_call" is provided, "functions" must also be.`);
+        }
+        const chatResult = await super._generate(promptMessages, options, runManager);
+        const chatGenerationContent = chatResult.generations[0].message.content;
+        if (forced) {
+            const parser = new XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            const responseMessageWithFunctions = new AIMessage({
+                content: "",
+                additional_kwargs: {
+                    function_call: {
+                        name: functionCall,
+                        arguments: result.tool_input
+                            ? JSON.stringify(result.tool_input)
+                            : "",
+                    },
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        else if (chatGenerationContent.includes("<tool>")) {
+            const parser = new XMLParser();
+            const result = parser.parse(`${chatGenerationContent}</tool_input>`);
+            const responseMessageWithFunctions = new AIMessage({
+                content: chatGenerationContent.split("<tool>")[0],
+                additional_kwargs: {
+                    function_call: {
+                        name: result.tool,
+                        arguments: result.tool_input
+                            ? JSON.stringify(result.tool_input)
+                            : "",
+                    },
+                },
+            });
+            return {
+                generations: [{ message: responseMessageWithFunctions, text: "" }],
+            };
+        }
+        return chatResult;
+    }
+    _llmType() {
+        return "anthropic_functions";
+    }
+    /** @ignore */
+    _combineLLMOutput() {
+        return [];
+    }
+}

package/dist/hub.d.ts

@@ -1,4 +1,4 @@
 import { ClientConfiguration, HubPushOptions } from "langchainhub";
 import { Runnable } from "./schema/runnable.js";
-export declare function push(repoFullName: string, runnable: Runnable, options?: HubPushOptions & ClientConfiguration): Promise<any>;
+export declare function push(repoFullName: string, runnable: Runnable, options?: HubPushOptions & ClientConfiguration): Promise<string>;
 export declare function pull<T extends Runnable>(ownerRepoCommit: string, options?: ClientConfiguration): Promise<T>;

package/dist/llms/sagemaker_endpoint.cjs

@@ -64,7 +64,7 @@ class SageMakerEndpoint extends base_js_1.LLM {
     get lc_secrets() {
         return {
             "clientOptions.credentials.accessKeyId": "AWS_ACCESS_KEY_ID",
-            "clientOptions.credentials.secretAccessKey": "AWS_SECRETE_ACCESS_KEY",
+            "clientOptions.credentials.secretAccessKey": "AWS_SECRET_ACCESS_KEY",
             "clientOptions.credentials.sessionToken": "AWS_SESSION_TOKEN",
         };
     }

package/dist/llms/sagemaker_endpoint.js

@@ -60,7 +60,7 @@ export class SageMakerEndpoint extends LLM {
     get lc_secrets() {
         return {
             "clientOptions.credentials.accessKeyId": "AWS_ACCESS_KEY_ID",
-            "clientOptions.credentials.secretAccessKey": "AWS_SECRETE_ACCESS_KEY",
+            "clientOptions.credentials.secretAccessKey": "AWS_SECRET_ACCESS_KEY",
             "clientOptions.credentials.sessionToken": "AWS_SESSION_TOKEN",
         };
     }

package/dist/load/import_constants.cjs

@@ -121,4 +121,5 @@ exports.optionalImportEntrypoints = [
     "langchain/storage/ioredis",
     "langchain/hub",
     "langchain/experimental/multimodal_embeddings/googlevertexai",
+    "langchain/experimental/chat_models/anthropic_functions",
 ];

package/dist/load/import_constants.js

@@ -118,4 +118,5 @@ export const optionalImportEntrypoints = [
     "langchain/storage/ioredis",
     "langchain/hub",
     "langchain/experimental/multimodal_embeddings/googlevertexai",
+    "langchain/experimental/chat_models/anthropic_functions",
 ];

package/dist/schema/output_parser.cjs

@@ -79,7 +79,7 @@ class BaseTransformOutputParser extends BaseOutputParser {
      * @returns An asynchronous generator of parsed output.
      */
     async *transform(inputGenerator, options) {
-        yield* this._streamWithConfig(this._transform(inputGenerator), {
+        yield* this._transformStreamWithConfig(inputGenerator, this._transform.bind(this), {
             ...options,
             runType: "parser",
         });

package/dist/schema/output_parser.js

@@ -74,7 +74,7 @@ export class BaseTransformOutputParser extends BaseOutputParser {
      * @returns An asynchronous generator of parsed output.
      */
     async *transform(inputGenerator, options) {
-        yield* this._streamWithConfig(this._transform(inputGenerator), {
+        yield* this._transformStreamWithConfig(inputGenerator, this._transform.bind(this), {
             ...options,
             runType: "parser",
         });

package/dist/schema/runnable.cjs

@@ -122,37 +122,73 @@ class Runnable extends serializable_js_1.Serializable {
         await runManager?.handleChainEnd(_coerceToDict(output, "output"));
         return output;
     }
-    async *_streamWithConfig(generator, options) {
+    /**
+     * Helper method to transform an Iterator of Input values into an Iterator of
+     * Output values, with callbacks.
+     * Use this to implement `stream()` or `transform()` in Runnable subclasses.
+     */
+    async *_transformStreamWithConfig(inputGenerator, transformer, options) {
+        let finalInput;
+        let finalInputSupported = true;
+        let finalOutput;
+        let finalOutputSupported = true;
         const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        // TODO: Find a way to pass the entire streamed value into the callback.
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict("<streamed value>", "input"), undefined, options?.runType);
-        let output;
-        let concatSupported = true;
+        let runManager;
+        const serializedRepresentation = this.toJSON();
+        async function* wrapInputForTracing() {
+            for await (const chunk of inputGenerator) {
+                if (!runManager) {
+                    // Start the run manager AFTER the iterator starts to preserve
+                    // tracing order
+                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType);
+                }
+                if (finalInputSupported) {
+                    if (finalInput === undefined) {
+                        finalInput = chunk;
+                    }
+                    else {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            finalInput = finalInput.concat(chunk);
+                        }
+                        catch {
+                            finalInput = undefined;
+                            finalInputSupported = false;
+                        }
+                    }
+                }
+                yield chunk;
+            }
+        }
+        const wrappedInputGenerator = wrapInputForTracing();
         try {
-            for await (const chunk of generator) {
+            const outputIterator = transformer(wrappedInputGenerator, runManager, options);
+            for await (const chunk of outputIterator) {
                 yield chunk;
-                if (concatSupported) {
-                    if (output === undefined) {
-                        output = chunk;
+                if (finalOutputSupported) {
+                    if (finalOutput === undefined) {
+                        finalOutput = chunk;
                     }
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            output = output.concat(chunk);
+                            finalOutput = finalOutput.concat(chunk);
                         }
-                        catch (e) {
-                            output = undefined;
-                            concatSupported = false;
+                        catch {
+                            finalOutput = undefined;
+                            finalOutputSupported = false;
                         }
                     }
                 }
             }
         }
         catch (e) {
-            await runManager?.handleChainError(e);
+            await runManager?.handleChainError(e, undefined, undefined, undefined, {
+                inputs: _coerceToDict(finalInput, "input"),
+            });
             throw e;
         }
-        await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+        await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
     _patchConfig(config = {}, callbackManager = undefined) {
         return { ...config, callbacks: callbackManager };
@@ -411,6 +447,9 @@ exports.RunnableMap = RunnableMap;
  * A runnable that runs a callable.
  */
 class RunnableLambda extends Runnable {
+    static lc_name() {
+        return "RunnableLambda";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/schema/runnable.d.ts

@@ -1,4 +1,4 @@
-import { BaseCallbackConfig, CallbackManager } from "../callbacks/manager.js";
+import { BaseCallbackConfig, CallbackManager, CallbackManagerForChainRun } from "../callbacks/manager.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream } from "../util/stream.js";
 export type RunnableConfig = BaseCallbackConfig;
@@ -58,9 +58,14 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
     protected _callWithConfig<T extends RunInput>(func: (input: T) => Promise<RunOutput>, input: T, options?: RunnableConfig & {
         runType?: string;
     }): Promise<RunOutput>;
-    protected _streamWithConfig<T extends RunOutput>(generator: AsyncGenerator<T>, options?: RunnableConfig & {
+    /**
+     * Helper method to transform an Iterator of Input values into an Iterator of
+     * Output values, with callbacks.
+     * Use this to implement `stream()` or `transform()` in Runnable subclasses.
+     */
+    protected _transformStreamWithConfig<I extends RunInput, O extends RunOutput>(inputGenerator: AsyncGenerator<I>, transformer: (generator: AsyncGenerator<I>, runManager?: CallbackManagerForChainRun, options?: Partial<RunnableConfig>) => AsyncGenerator<O>, options?: RunnableConfig & {
         runType?: string;
-    }): AsyncGenerator<Awaited<T>, void, unknown>;
+    }): AsyncGenerator<O>;
     _patchConfig(config?: Partial<CallOptions>, callbackManager?: CallbackManager | undefined): Partial<CallOptions>;
     /**
      * Create a new runnable sequence that runs each individual runnable in series,
@@ -126,6 +131,7 @@ export declare class RunnableMap<RunInput> extends Runnable<RunInput, Record<str
  * A runnable that runs a callable.
  */
 export declare class RunnableLambda<RunInput, RunOutput> extends Runnable<RunInput, RunOutput> {
+    static lc_name(): string;
     lc_namespace: string[];
     protected func: RunnableFunc<RunInput, RunOutput>;
     constructor(fields: {

package/dist/schema/runnable.js

@@ -1,4 +1,4 @@
-import { CallbackManager } from "../callbacks/manager.js";
+import { CallbackManager, } from "../callbacks/manager.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream } from "../util/stream.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -119,37 +119,73 @@ export class Runnable extends Serializable {
         await runManager?.handleChainEnd(_coerceToDict(output, "output"));
         return output;
     }
-    async *_streamWithConfig(generator, options) {
+    /**
+     * Helper method to transform an Iterator of Input values into an Iterator of
+     * Output values, with callbacks.
+     * Use this to implement `stream()` or `transform()` in Runnable subclasses.
+     */
+    async *_transformStreamWithConfig(inputGenerator, transformer, options) {
+        let finalInput;
+        let finalInputSupported = true;
+        let finalOutput;
+        let finalOutputSupported = true;
         const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        // TODO: Find a way to pass the entire streamed value into the callback.
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict("<streamed value>", "input"), undefined, options?.runType);
-        let output;
-        let concatSupported = true;
+        let runManager;
+        const serializedRepresentation = this.toJSON();
+        async function* wrapInputForTracing() {
+            for await (const chunk of inputGenerator) {
+                if (!runManager) {
+                    // Start the run manager AFTER the iterator starts to preserve
+                    // tracing order
+                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType);
+                }
+                if (finalInputSupported) {
+                    if (finalInput === undefined) {
+                        finalInput = chunk;
+                    }
+                    else {
+                        try {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            finalInput = finalInput.concat(chunk);
+                        }
+                        catch {
+                            finalInput = undefined;
+                            finalInputSupported = false;
+                        }
+                    }
+                }
+                yield chunk;
+            }
+        }
+        const wrappedInputGenerator = wrapInputForTracing();
         try {
-            for await (const chunk of generator) {
+            const outputIterator = transformer(wrappedInputGenerator, runManager, options);
+            for await (const chunk of outputIterator) {
                 yield chunk;
-                if (concatSupported) {
-                    if (output === undefined) {
-                        output = chunk;
+                if (finalOutputSupported) {
+                    if (finalOutput === undefined) {
+                        finalOutput = chunk;
                     }
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            output = output.concat(chunk);
+                            finalOutput = finalOutput.concat(chunk);
                         }
-                        catch (e) {
-                            output = undefined;
-                            concatSupported = false;
+                        catch {
+                            finalOutput = undefined;
+                            finalOutputSupported = false;
                         }
                     }
                 }
             }
         }
         catch (e) {
-            await runManager?.handleChainError(e);
+            await runManager?.handleChainError(e, undefined, undefined, undefined, {
+                inputs: _coerceToDict(finalInput, "input"),
+            });
             throw e;
         }
-        await runManager?.handleChainEnd(_coerceToDict(output, "output"));
+        await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
     _patchConfig(config = {}, callbackManager = undefined) {
         return { ...config, callbacks: callbackManager };
@@ -405,6 +441,9 @@ export class RunnableMap extends Runnable {
  * A runnable that runs a callable.
  */
 export class RunnableLambda extends Runnable {
+    static lc_name() {
+        return "RunnableLambda";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/sql_db.cjs

@@ -66,7 +66,6 @@ class SqlDatabase extends serializable_js_1.Serializable {
         this.ignoreTables = fields?.ignoreTables ?? [];
         this.sampleRowsInTableInfo =
             fields?.sampleRowsInTableInfo ?? this.sampleRowsInTableInfo;
-        this.customDescription = Object.fromEntries(Object.entries(fields?.customDescription ?? {}).filter(([key, _]) => this.allTables.map((table) => table.tableName).includes(key)));
     }
     static async fromDataSourceParams(fields) {
         const sqlDatabase = new SqlDatabase(fields);
@@ -74,6 +73,9 @@ class SqlDatabase extends serializable_js_1.Serializable {
             await sqlDatabase.appDataSource.initialize();
         }
         sqlDatabase.allTables = await (0, sql_utils_js_1.getTableAndColumnsName)(sqlDatabase.appDataSource);
+        sqlDatabase.customDescription = Object.fromEntries(Object.entries(fields?.customDescription ?? {}).filter(([key, _]) => sqlDatabase.allTables
+            .map((table) => table.tableName)
+            .includes(key)));
         (0, sql_utils_js_1.verifyIncludeTablesExistInDatabase)(sqlDatabase.allTables, sqlDatabase.includesTables);
         (0, sql_utils_js_1.verifyIgnoreTablesExistInDatabase)(sqlDatabase.allTables, sqlDatabase.ignoreTables);
         return sqlDatabase;

package/dist/sql_db.js

@@ -63,7 +63,6 @@ export class SqlDatabase extends Serializable {
         this.ignoreTables = fields?.ignoreTables ?? [];
         this.sampleRowsInTableInfo =
             fields?.sampleRowsInTableInfo ?? this.sampleRowsInTableInfo;
-        this.customDescription = Object.fromEntries(Object.entries(fields?.customDescription ?? {}).filter(([key, _]) => this.allTables.map((table) => table.tableName).includes(key)));
     }
     static async fromDataSourceParams(fields) {
         const sqlDatabase = new SqlDatabase(fields);
@@ -71,6 +70,9 @@ export class SqlDatabase extends Serializable {
             await sqlDatabase.appDataSource.initialize();
         }
         sqlDatabase.allTables = await getTableAndColumnsName(sqlDatabase.appDataSource);
+        sqlDatabase.customDescription = Object.fromEntries(Object.entries(fields?.customDescription ?? {}).filter(([key, _]) => sqlDatabase.allTables
+            .map((table) => table.tableName)
+            .includes(key)));
         verifyIncludeTablesExistInDatabase(sqlDatabase.allTables, sqlDatabase.includesTables);
         verifyIgnoreTablesExistInDatabase(sqlDatabase.allTables, sqlDatabase.ignoreTables);
         return sqlDatabase;

package/experimental/chat_models/anthropic_functions.cjs

@@ -0,0 +1 @@
+module.exports = require('../../dist/experimental/chat_models/anthropic_functions.cjs');

package/experimental/chat_models/anthropic_functions.d.ts

@@ -0,0 +1 @@
+export * from '../../dist/experimental/chat_models/anthropic_functions.js'

package/experimental/chat_models/anthropic_functions.js

@@ -0,0 +1 @@
+export * from '../../dist/experimental/chat_models/anthropic_functions.js'