langchain 0.0.130 → 0.0.132

package/dist/agents/toolkits/zapier/zapier.cjs

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZapierToolKit = void 0;
 const base_js_1 = require("../base.cjs");
 const zapier_js_1 = require("../../../tools/zapier.cjs");
+/**
+ * Represents a toolkit for working with Zapier actions. It extends the
+ * Toolkit class and provides functionality for managing Zapier tools.
+ */
 class ZapierToolKit extends base_js_1.Toolkit {
     constructor() {
         super(...arguments);
@@ -13,6 +17,14 @@ class ZapierToolKit extends base_js_1.Toolkit {
             value: []
         });
     }
+    /**
+     * Creates a ZapierToolKit instance based on a ZapierNLAWrapper instance.
+     * It retrieves the list of available actions from the ZapierNLAWrapper
+     * and creates a ZapierNLARunAction tool for each action. The created
+     * tools are added to the tools property of the ZapierToolKit instance.
+     * @param zapierNLAWrapper The ZapierNLAWrapper instance to create the ZapierToolKit from.
+     * @returns A Promise that resolves to a ZapierToolKit instance.
+     */
     static async fromZapierNLAWrapper(zapierNLAWrapper) {
         const toolkit = new ZapierToolKit();
         const actions = await zapierNLAWrapper.listActions();

package/dist/agents/toolkits/zapier/zapier.d.ts

@@ -1,7 +1,19 @@
 import { Toolkit } from "../base.js";
 import { Tool } from "../../../tools/base.js";
 import { ZapierNLAWrapper } from "../../../tools/zapier.js";
+/**
+ * Represents a toolkit for working with Zapier actions. It extends the
+ * Toolkit class and provides functionality for managing Zapier tools.
+ */
 export declare class ZapierToolKit extends Toolkit {
     tools: Tool[];
+    /**
+     * Creates a ZapierToolKit instance based on a ZapierNLAWrapper instance.
+     * It retrieves the list of available actions from the ZapierNLAWrapper
+     * and creates a ZapierNLARunAction tool for each action. The created
+     * tools are added to the tools property of the ZapierToolKit instance.
+     * @param zapierNLAWrapper The ZapierNLAWrapper instance to create the ZapierToolKit from.
+     * @returns A Promise that resolves to a ZapierToolKit instance.
+     */
     static fromZapierNLAWrapper(zapierNLAWrapper: ZapierNLAWrapper): Promise<ZapierToolKit>;
 }

package/dist/agents/toolkits/zapier/zapier.js

@@ -1,5 +1,9 @@
 import { Toolkit } from "../base.js";
 import { ZapierNLARunAction } from "../../../tools/zapier.js";
+/**
+ * Represents a toolkit for working with Zapier actions. It extends the
+ * Toolkit class and provides functionality for managing Zapier tools.
+ */
 export class ZapierToolKit extends Toolkit {
     constructor() {
         super(...arguments);
@@ -10,6 +14,14 @@ export class ZapierToolKit extends Toolkit {
             value: []
         });
     }
+    /**
+     * Creates a ZapierToolKit instance based on a ZapierNLAWrapper instance.
+     * It retrieves the list of available actions from the ZapierNLAWrapper
+     * and creates a ZapierNLARunAction tool for each action. The created
+     * tools are added to the tools property of the ZapierToolKit instance.
+     * @param zapierNLAWrapper The ZapierNLAWrapper instance to create the ZapierToolKit from.
+     * @returns A Promise that resolves to a ZapierToolKit instance.
+     */
     static async fromZapierNLAWrapper(zapierNLAWrapper) {
         const toolkit = new ZapierToolKit();
         const actions = await zapierNLAWrapper.listActions();

package/dist/agents/types.cjs

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentActionOutputParser = void 0;
 const output_parser_js_1 = require("../schema/output_parser.cjs");
+/**
+ * Abstract class representing an output parser specifically for agent
+ * actions and finishes in LangChain. It extends the `BaseOutputParser`
+ * class.
+ */
 class AgentActionOutputParser extends output_parser_js_1.BaseOutputParser {
 }
 exports.AgentActionOutputParser = AgentActionOutputParser;

package/dist/agents/types.d.ts

@@ -2,14 +2,33 @@ import { LLMChain } from "../chains/llm_chain.js";
 import { SerializedLLMChain } from "../chains/serde.js";
 import { AgentAction, AgentFinish } from "../schema/index.js";
 import { BaseOutputParser } from "../schema/output_parser.js";
+/**
+ * Interface defining the input for creating an agent. It includes the
+ * LLMChain instance, an optional output parser, and an optional list of
+ * allowed tools.
+ */
 export interface AgentInput {
     llmChain: LLMChain;
     outputParser: AgentActionOutputParser | undefined;
     allowedTools?: string[];
 }
+/**
+ * Abstract class representing an output parser specifically for agent
+ * actions and finishes in LangChain. It extends the `BaseOutputParser`
+ * class.
+ */
 export declare abstract class AgentActionOutputParser extends BaseOutputParser<AgentAction | AgentFinish> {
 }
+/**
+ * Type representing the stopping method for an agent. It can be either
+ * 'force' or 'generate'.
+ */
 export type StoppingMethod = "force" | "generate";
+/**
+ * Generic type representing a serialized agent in LangChain. It includes
+ * the type of the agent, the serialized form of the LLMChain, and
+ * additional properties specific to the agent type.
+ */
 export type SerializedAgentT<TType extends string = string, FromLLMInput extends Record<string, unknown> = Record<string, unknown>, ConstructorInput extends AgentInput = AgentInput> = {
     _type: TType;
     llm_chain?: SerializedLLMChain;
@@ -23,5 +42,14 @@ export type SerializedFromLLMAndTools = {
     prefix?: string;
     input_variables?: string[];
 };
+/**
+ * Type representing a serialized ZeroShotAgent in LangChain. It extends
+ * the `SerializedAgentT` type and includes additional properties specific
+ * to the ZeroShotAgent.
+ */
 export type SerializedZeroShotAgent = SerializedAgentT<"zero-shot-react-description", SerializedFromLLMAndTools, AgentInput>;
+/**
+ * Type representing a serialized agent in LangChain. It is currently
+ * synonymous with `SerializedZeroShotAgent`.
+ */
 export type SerializedAgent = SerializedZeroShotAgent;

package/dist/agents/types.js

@@ -1,3 +1,8 @@
 import { BaseOutputParser } from "../schema/output_parser.js";
+/**
+ * Abstract class representing an output parser specifically for agent
+ * actions and finishes in LangChain. It extends the `BaseOutputParser`
+ * class.
+ */
 export class AgentActionOutputParser extends BaseOutputParser {
 }

package/dist/cache/index.cjs

@@ -4,6 +4,9 @@ exports.InMemoryCache = void 0;
 const base_js_1 = require("./base.cjs");
 const index_js_1 = require("../schema/index.cjs");
 const GLOBAL_MAP = new Map();
+/**
+ * A cache for storing LLM generations that stores data in memory.
+ */
 class InMemoryCache extends index_js_1.BaseCache {
     constructor(map) {
         super();
@@ -15,12 +18,30 @@ class InMemoryCache extends index_js_1.BaseCache {
         });
         this.cache = map ?? new Map();
     }
+    /**
+     * Retrieves data from the cache using a prompt and an LLM key. If the
+     * data is not found, it returns null.
+     * @param prompt The prompt used to find the data.
+     * @param llmKey The LLM key used to find the data.
+     * @returns The data corresponding to the prompt and LLM key, or null if not found.
+     */
     lookup(prompt, llmKey) {
         return Promise.resolve(this.cache.get((0, base_js_1.getCacheKey)(prompt, llmKey)) ?? null);
     }
+    /**
+     * Updates the cache with new data using a prompt and an LLM key.
+     * @param prompt The prompt used to store the data.
+     * @param llmKey The LLM key used to store the data.
+     * @param value The data to be stored.
+     */
     async update(prompt, llmKey, value) {
         this.cache.set((0, base_js_1.getCacheKey)(prompt, llmKey), value);
     }
+    /**
+     * Returns a global instance of InMemoryCache using a predefined global
+     * map as the initial cache.
+     * @returns A global instance of InMemoryCache.
+     */
     static global() {
         return new InMemoryCache(GLOBAL_MAP);
     }

package/dist/cache/index.d.ts

@@ -1,8 +1,29 @@
 import { Generation, BaseCache } from "../schema/index.js";
+/**
+ * A cache for storing LLM generations that stores data in memory.
+ */
 export declare class InMemoryCache<T = Generation[]> extends BaseCache<T> {
     private cache;
     constructor(map?: Map<string, T>);
+    /**
+     * Retrieves data from the cache using a prompt and an LLM key. If the
+     * data is not found, it returns null.
+     * @param prompt The prompt used to find the data.
+     * @param llmKey The LLM key used to find the data.
+     * @returns The data corresponding to the prompt and LLM key, or null if not found.
+     */
     lookup(prompt: string, llmKey: string): Promise<T | null>;
+    /**
+     * Updates the cache with new data using a prompt and an LLM key.
+     * @param prompt The prompt used to store the data.
+     * @param llmKey The LLM key used to store the data.
+     * @param value The data to be stored.
+     */
     update(prompt: string, llmKey: string, value: T): Promise<void>;
+    /**
+     * Returns a global instance of InMemoryCache using a predefined global
+     * map as the initial cache.
+     * @returns A global instance of InMemoryCache.
+     */
     static global(): InMemoryCache;
 }

package/dist/cache/index.js

@@ -1,6 +1,9 @@
 import { getCacheKey } from "./base.js";
 import { BaseCache } from "../schema/index.js";
 const GLOBAL_MAP = new Map();
+/**
+ * A cache for storing LLM generations that stores data in memory.
+ */
 export class InMemoryCache extends BaseCache {
     constructor(map) {
         super();
@@ -12,12 +15,30 @@ export class InMemoryCache extends BaseCache {
         });
         this.cache = map ?? new Map();
     }
+    /**
+     * Retrieves data from the cache using a prompt and an LLM key. If the
+     * data is not found, it returns null.
+     * @param prompt The prompt used to find the data.
+     * @param llmKey The LLM key used to find the data.
+     * @returns The data corresponding to the prompt and LLM key, or null if not found.
+     */
     lookup(prompt, llmKey) {
         return Promise.resolve(this.cache.get(getCacheKey(prompt, llmKey)) ?? null);
     }
+    /**
+     * Updates the cache with new data using a prompt and an LLM key.
+     * @param prompt The prompt used to store the data.
+     * @param llmKey The LLM key used to store the data.
+     * @param value The data to be stored.
+     */
     async update(prompt, llmKey, value) {
         this.cache.set(getCacheKey(prompt, llmKey), value);
     }
+    /**
+     * Returns a global instance of InMemoryCache using a predefined global
+     * map as the initial cache.
+     * @returns A global instance of InMemoryCache.
+     */
     static global() {
         return new InMemoryCache(GLOBAL_MAP);
     }

package/dist/cache/ioredis.cjs

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisCache = void 0;
 const index_js_1 = require("../schema/index.cjs");
 const base_js_1 = require("./base.cjs");
+/**
+ * Cache LLM results using Redis.
+ */
 class RedisCache extends index_js_1.BaseCache {
     constructor(redisClient) {
         super();
@@ -14,6 +17,13 @@ class RedisCache extends index_js_1.BaseCache {
         });
         this.redisClient = redisClient;
     }
+    /**
+     * Retrieves data from the Redis server using a prompt and an LLM key. If
+     * the data is not found, it returns null.
+     * @param prompt The prompt used to find the data.
+     * @param llmKey The LLM key used to find the data.
+     * @returns The corresponding data as an array of Generation objects, or null if not found.
+     */
     async lookup(prompt, llmKey) {
         let idx = 0;
         let key = (0, base_js_1.getCacheKey)(prompt, llmKey, String(idx));
@@ -30,6 +40,12 @@ class RedisCache extends index_js_1.BaseCache {
         }
         return generations.length > 0 ? generations : null;
     }
+    /**
+     * Updates the data in the Redis server using a prompt and an LLM key.
+     * @param prompt The prompt used to store the data.
+     * @param llmKey The LLM key used to store the data.
+     * @param value The data to be stored, represented as an array of Generation objects.
+     */
     async update(prompt, llmKey, value) {
         for (let i = 0; i < value.length; i += 1) {
             const key = (0, base_js_1.getCacheKey)(prompt, llmKey, String(i));

package/dist/cache/ioredis.d.ts

@@ -1,8 +1,24 @@
 import { Redis } from "ioredis";
 import { BaseCache, Generation } from "../schema/index.js";
+/**
+ * Cache LLM results using Redis.
+ */
 export declare class RedisCache extends BaseCache {
     private redisClient;
     constructor(redisClient: Redis);
+    /**
+     * Retrieves data from the Redis server using a prompt and an LLM key. If
+     * the data is not found, it returns null.
+     * @param prompt The prompt used to find the data.
+     * @param llmKey The LLM key used to find the data.
+     * @returns The corresponding data as an array of Generation objects, or null if not found.
+     */
     lookup(prompt: string, llmKey: string): Promise<Generation[] | null>;
+    /**
+     * Updates the data in the Redis server using a prompt and an LLM key.
+     * @param prompt The prompt used to store the data.
+     * @param llmKey The LLM key used to store the data.
+     * @param value The data to be stored, represented as an array of Generation objects.
+     */
     update(prompt: string, llmKey: string, value: Generation[]): Promise<void>;
 }

package/dist/cache/ioredis.js

@@ -1,5 +1,8 @@
 import { BaseCache } from "../schema/index.js";
 import { getCacheKey } from "./base.js";
+/**
+ * Cache LLM results using Redis.
+ */
 export class RedisCache extends BaseCache {
     constructor(redisClient) {
         super();
@@ -11,6 +14,13 @@ export class RedisCache extends BaseCache {
         });
         this.redisClient = redisClient;
     }
+    /**
+     * Retrieves data from the Redis server using a prompt and an LLM key. If
+     * the data is not found, it returns null.
+     * @param prompt The prompt used to find the data.
+     * @param llmKey The LLM key used to find the data.
+     * @returns The corresponding data as an array of Generation objects, or null if not found.
+     */
     async lookup(prompt, llmKey) {
         let idx = 0;
         let key = getCacheKey(prompt, llmKey, String(idx));
@@ -27,6 +37,12 @@ export class RedisCache extends BaseCache {
         }
         return generations.length > 0 ? generations : null;
     }
+    /**
+     * Updates the data in the Redis server using a prompt and an LLM key.
+     * @param prompt The prompt used to store the data.
+     * @param llmKey The LLM key used to store the data.
+     * @param value The data to be stored, represented as an array of Generation objects.
+     */
     async update(prompt, llmKey, value) {
         for (let i = 0; i < value.length; i += 1) {
             const key = getCacheKey(prompt, llmKey, String(i));

package/dist/cache/redis.cjs

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisCache = void 0;
 const index_js_1 = require("../schema/index.cjs");
 const base_js_1 = require("./base.cjs");
+/**
+ * Represents a specific implementation of a caching mechanism using Redis
+ * as the underlying storage system. It extends the `BaseCache` class and
+ * overrides its methods to provide the Redis-specific logic.
+ */
 class RedisCache extends index_js_1.BaseCache {
     constructor(redisClient) {
         super();
@@ -14,6 +19,14 @@ class RedisCache extends index_js_1.BaseCache {
         });
         this.redisClient = redisClient;
     }
+    /**
+     * Retrieves data from the cache. It constructs a cache key from the given
+     * `prompt` and `llmKey`, and retrieves the corresponding value from the
+     * Redis database.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @returns An array of Generations if found, null otherwise.
+     */
     async lookup(prompt, llmKey) {
         let idx = 0;
         let key = (0, base_js_1.getCacheKey)(prompt, llmKey, String(idx));
@@ -30,6 +43,14 @@ class RedisCache extends index_js_1.BaseCache {
         }
         return generations.length > 0 ? generations : null;
     }
+    /**
+     * Updates the cache with new data. It constructs a cache key from the
+     * given `prompt` and `llmKey`, and stores the `value` in the Redis
+     * database.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @param value The value to be stored in the cache.
+     */
     async update(prompt, llmKey, value) {
         for (let i = 0; i < value.length; i += 1) {
             const key = (0, base_js_1.getCacheKey)(prompt, llmKey, String(i));

package/dist/cache/redis.d.ts

@@ -1,10 +1,35 @@
 import type { createCluster, createClient } from "redis";
 import { BaseCache, Generation } from "../schema/index.js";
+/**
+ * Represents the type of the Redis client used to interact with the Redis
+ * database.
+ */
 type RedisClientType = ReturnType<typeof createClient> | ReturnType<typeof createCluster>;
+/**
+ * Represents a specific implementation of a caching mechanism using Redis
+ * as the underlying storage system. It extends the `BaseCache` class and
+ * overrides its methods to provide the Redis-specific logic.
+ */
 export declare class RedisCache extends BaseCache {
     private redisClient;
     constructor(redisClient: RedisClientType);
+    /**
+     * Retrieves data from the cache. It constructs a cache key from the given
+     * `prompt` and `llmKey`, and retrieves the corresponding value from the
+     * Redis database.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @returns An array of Generations if found, null otherwise.
+     */
     lookup(prompt: string, llmKey: string): Promise<Generation[] | null>;
+    /**
+     * Updates the cache with new data. It constructs a cache key from the
+     * given `prompt` and `llmKey`, and stores the `value` in the Redis
+     * database.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @param value The value to be stored in the cache.
+     */
     update(prompt: string, llmKey: string, value: Generation[]): Promise<void>;
 }
 export {};

package/dist/cache/redis.js

@@ -1,5 +1,10 @@
 import { BaseCache } from "../schema/index.js";
 import { getCacheKey } from "./base.js";
+/**
+ * Represents a specific implementation of a caching mechanism using Redis
+ * as the underlying storage system. It extends the `BaseCache` class and
+ * overrides its methods to provide the Redis-specific logic.
+ */
 export class RedisCache extends BaseCache {
     constructor(redisClient) {
         super();
@@ -11,6 +16,14 @@ export class RedisCache extends BaseCache {
         });
         this.redisClient = redisClient;
     }
+    /**
+     * Retrieves data from the cache. It constructs a cache key from the given
+     * `prompt` and `llmKey`, and retrieves the corresponding value from the
+     * Redis database.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @returns An array of Generations if found, null otherwise.
+     */
     async lookup(prompt, llmKey) {
         let idx = 0;
         let key = getCacheKey(prompt, llmKey, String(idx));
@@ -27,6 +40,14 @@ export class RedisCache extends BaseCache {
         }
         return generations.length > 0 ? generations : null;
     }
+    /**
+     * Updates the cache with new data. It constructs a cache key from the
+     * given `prompt` and `llmKey`, and stores the `value` in the Redis
+     * database.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @param value The value to be stored in the cache.
+     */
     async update(prompt, llmKey, value) {
         for (let i = 0; i < value.length; i += 1) {
             const key = getCacheKey(prompt, llmKey, String(i));

package/dist/callbacks/base.cjs

@@ -26,8 +26,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCallbackHandler = void 0;
 const uuid = __importStar(require("uuid"));
 const serializable_js_1 = require("../load/serializable.cjs");
+/**
+ * Abstract class that provides a set of optional methods that can be
+ * overridden in derived classes to handle various events during the
+ * execution of a LangChain application.
+ */
 class BaseCallbackHandlerMethodsClass {
 }
+/**
+ * Abstract base class for creating callback handlers in the LangChain
+ * framework. It provides a set of optional methods that can be overridden
+ * in derived classes to handle various events during the execution of a
+ * LangChain application.
+ */
 class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
     get lc_namespace() {
         return ["langchain", "callbacks", this.name];
@@ -41,6 +52,24 @@ class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
     get lc_aliases() {
         return undefined;
     }
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name() {
+        return this.name;
+    }
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id() {
+        return [
+            ...this.lc_namespace,
+            (0, serializable_js_1.get_lc_unique_name)(this.constructor),
+        ];
+    }
     constructor(input) {
         super();
         Object.defineProperty(this, "lc_serializable", {

package/dist/callbacks/base.d.ts

@@ -3,16 +3,30 @@ import { Serializable, Serialized, SerializedNotImplemented } from "../load/seri
 import { SerializedFields } from "../load/map_keys.js";
 import { Document } from "../document.js";
 type Error = any;
+/**
+ * Interface for the input parameters of the BaseCallbackHandler class. It
+ * allows to specify which types of events should be ignored by the
+ * callback handler.
+ */
 export interface BaseCallbackHandlerInput {
     ignoreLLM?: boolean;
     ignoreChain?: boolean;
     ignoreAgent?: boolean;
     ignoreRetriever?: boolean;
 }
+/**
+ * Interface for the indices of a new token produced by an LLM or Chat
+ * Model in streaming mode.
+ */
 export interface NewTokenIndices {
     prompt: number;
     completion: number;
 }
+/**
+ * Abstract class that provides a set of optional methods that can be
+ * overridden in derived classes to handle various events during the
+ * execution of a LangChain application.
+ */
 declare abstract class BaseCallbackHandlerMethodsClass {
     /**
      * Called at the start of an LLM or Chat Model run, with the prompt(s)
@@ -94,6 +108,12 @@ declare abstract class BaseCallbackHandlerMethodsClass {
  * @interface
  */
 export type CallbackHandlerMethods = BaseCallbackHandlerMethodsClass;
+/**
+ * Abstract base class for creating callback handlers in the LangChain
+ * framework. It provides a set of optional methods that can be overridden
+ * in derived classes to handle various events during the execution of a
+ * LangChain application.
+ */
 export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass implements BaseCallbackHandlerInput, Serializable {
     lc_serializable: boolean;
     get lc_namespace(): ["langchain", "callbacks", string];
@@ -106,6 +126,17 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
     get lc_aliases(): {
         [key: string]: string;
     } | undefined;
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name(): string;
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id(): string[];
     lc_kwargs: SerializedFields;
     abstract name: string;
     ignoreLLM: boolean;
@@ -130,6 +161,10 @@ export declare abstract class BaseCallbackHandler extends BaseCallbackHandlerMet
         readonly lc_aliases: {
             [key: string]: string;
         } | undefined;
+        /**
+         * The final serialized identifier for the module.
+         */
+        readonly lc_id: string[];
         lc_kwargs: SerializedFields;
         ignoreLLM: boolean;
         ignoreChain: boolean;

package/dist/callbacks/base.js

@@ -1,7 +1,18 @@
 import * as uuid from "uuid";
-import { Serializable, } from "../load/serializable.js";
+import { Serializable, get_lc_unique_name, } from "../load/serializable.js";
+/**
+ * Abstract class that provides a set of optional methods that can be
+ * overridden in derived classes to handle various events during the
+ * execution of a LangChain application.
+ */
 class BaseCallbackHandlerMethodsClass {
 }
+/**
+ * Abstract base class for creating callback handlers in the LangChain
+ * framework. It provides a set of optional methods that can be overridden
+ * in derived classes to handle various events during the execution of a
+ * LangChain application.
+ */
 export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
     get lc_namespace() {
         return ["langchain", "callbacks", this.name];
@@ -15,6 +26,24 @@ export class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
     get lc_aliases() {
         return undefined;
     }
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name() {
+        return this.name;
+    }
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id() {
+        return [
+            ...this.lc_namespace,
+            get_lc_unique_name(this.constructor),
+        ];
+    }
     constructor(input) {
         super();
         Object.defineProperty(this, "lc_serializable", {