langchain 0.0.131 → 0.0.132

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];

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];

package/dist/callbacks/base.js

@@ -1,7 +1,18 @@
 import * as uuid from "uuid";
 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];

package/dist/callbacks/handlers/console.cjs

@@ -27,6 +27,11 @@ function elapsed(run) {
     return `${(elapsed / 1000).toFixed(2)}s`;
 }
 const { color } = ansi_styles_1.default;
+/**
+ * A tracer that logs all events to the console. It extends from the
+ * `BaseTracer` class and overrides its methods to provide custom logging
+ * functionality.
+ */
 class ConsoleCallbackHandler extends tracer_js_1.BaseTracer {
     constructor() {
         super(...arguments);
@@ -37,10 +42,21 @@ class ConsoleCallbackHandler extends tracer_js_1.BaseTracer {
             value: "console_callback_handler"
         });
     }
+    /**
+     * Method used to persist the run. In this case, it simply returns a
+     * resolved promise as there's no persistence logic.
+     * @param _run The run to persist.
+     * @returns A resolved promise.
+     */
     persistRun(_run) {
         return Promise.resolve();
     }
     // utility methods
+    /**
+     * Method used to get all the parent runs of a given run.
+     * @param run The run whose parents are to be retrieved.
+     * @returns An array of parent runs.
+     */
     getParents(run) {
         const parents = [];
         let currentRun = run;
@@ -56,6 +72,12 @@ class ConsoleCallbackHandler extends tracer_js_1.BaseTracer {
         }
         return parents;
     }
+    /**
+     * Method used to get a string representation of the run's lineage, which
+     * is used in logging.
+     * @param run The run whose lineage is to be retrieved.
+     * @returns A string representation of the run's lineage.
+     */
     getBreadcrumbs(run) {
         const parents = this.getParents(run).reverse();
         const string = [...parents, run]
@@ -67,18 +89,38 @@ class ConsoleCallbackHandler extends tracer_js_1.BaseTracer {
         return wrap(color.grey, string);
     }
     // logging methods
+    /**
+     * Method used to log the start of a chain run.
+     * @param run The chain run that has started.
+     * @returns void
+     */
     onChainStart(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.green, "[chain/start]")} [${crumbs}] Entering Chain run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`);
     }
+    /**
+     * Method used to log the end of a chain run.
+     * @param run The chain run that has ended.
+     * @returns void
+     */
     onChainEnd(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.cyan, "[chain/end]")} [${crumbs}] [${elapsed(run)}] Exiting Chain run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`);
     }
+    /**
+     * Method used to log any errors of a chain run.
+     * @param run The chain run that has errored.
+     * @returns void
+     */
     onChainError(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.red, "[chain/error]")} [${crumbs}] [${elapsed(run)}] Chain run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
+    /**
+     * Method used to log the start of an LLM run.
+     * @param run The LLM run that has started.
+     * @returns void
+     */
     onLLMStart(run) {
         const crumbs = this.getBreadcrumbs(run);
         const inputs = "prompts" in run.inputs
@@ -86,38 +128,83 @@ class ConsoleCallbackHandler extends tracer_js_1.BaseTracer {
             : run.inputs;
         console.log(`${wrap(color.green, "[llm/start]")} [${crumbs}] Entering LLM run with input: ${tryJsonStringify(inputs, "[inputs]")}`);
     }
+    /**
+     * Method used to log the end of an LLM run.
+     * @param run The LLM run that has ended.
+     * @returns void
+     */
     onLLMEnd(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.cyan, "[llm/end]")} [${crumbs}] [${elapsed(run)}] Exiting LLM run with output: ${tryJsonStringify(run.outputs, "[response]")}`);
     }
+    /**
+     * Method used to log any errors of an LLM run.
+     * @param run The LLM run that has errored.
+     * @returns void
+     */
     onLLMError(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.red, "[llm/error]")} [${crumbs}] [${elapsed(run)}] LLM run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
+    /**
+     * Method used to log the start of a tool run.
+     * @param run The tool run that has started.
+     * @returns void
+     */
     onToolStart(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.inputs.input?.trim()}"`);
     }
+    /**
+     * Method used to log the end of a tool run.
+     * @param run The tool run that has ended.
+     * @returns void
+     */
     onToolEnd(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.cyan, "[tool/end]")} [${crumbs}] [${elapsed(run)}] Exiting Tool run with output: "${run.outputs?.output?.trim()}"`);
     }
+    /**
+     * Method used to log any errors of a tool run.
+     * @param run The tool run that has errored.
+     * @returns void
+     */
     onToolError(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.red, "[tool/error]")} [${crumbs}] [${elapsed(run)}] Tool run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
+    /**
+     * Method used to log the start of a retriever run.
+     * @param run The retriever run that has started.
+     * @returns void
+     */
     onRetrieverStart(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.green, "[retriever/start]")} [${crumbs}] Entering Retriever run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`);
     }
+    /**
+     * Method used to log the end of a retriever run.
+     * @param run The retriever run that has ended.
+     * @returns void
+     */
     onRetrieverEnd(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.cyan, "[retriever/end]")} [${crumbs}] [${elapsed(run)}] Exiting Retriever run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`);
     }
+    /**
+     * Method used to log any errors of a retriever run.
+     * @param run The retriever run that has errored.
+     * @returns void
+     */
     onRetrieverError(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.red, "[retriever/error]")} [${crumbs}] [${elapsed(run)}] Retriever run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
+    /**
+     * Method used to log the action selected by the agent.
+     * @param run The run in which the agent action occurred.
+     * @returns void
+     */
     onAgentAction(run) {
         const agentRun = run;
         const crumbs = this.getBreadcrumbs(run);

package/dist/callbacks/handlers/console.d.ts

@@ -1,20 +1,107 @@
 import { BaseTracer, Run } from "./tracer.js";
+/**
+ * A tracer that logs all events to the console. It extends from the
+ * `BaseTracer` class and overrides its methods to provide custom logging
+ * functionality.
+ */
 export declare class ConsoleCallbackHandler extends BaseTracer {
     name: "console_callback_handler";
+    /**
+     * Method used to persist the run. In this case, it simply returns a
+     * resolved promise as there's no persistence logic.
+     * @param _run The run to persist.
+     * @returns A resolved promise.
+     */
     protected persistRun(_run: Run): Promise<void>;
+    /**
+     * Method used to get all the parent runs of a given run.
+     * @param run The run whose parents are to be retrieved.
+     * @returns An array of parent runs.
+     */
     getParents(run: Run): Run[];
+    /**
+     * Method used to get a string representation of the run's lineage, which
+     * is used in logging.
+     * @param run The run whose lineage is to be retrieved.
+     * @returns A string representation of the run's lineage.
+     */
     getBreadcrumbs(run: Run): string;
+    /**
+     * Method used to log the start of a chain run.
+     * @param run The chain run that has started.
+     * @returns void
+     */
     onChainStart(run: Run): void;
+    /**
+     * Method used to log the end of a chain run.
+     * @param run The chain run that has ended.
+     * @returns void
+     */
     onChainEnd(run: Run): void;
+    /**
+     * Method used to log any errors of a chain run.
+     * @param run The chain run that has errored.
+     * @returns void
+     */
     onChainError(run: Run): void;
+    /**
+     * Method used to log the start of an LLM run.
+     * @param run The LLM run that has started.
+     * @returns void
+     */
     onLLMStart(run: Run): void;
+    /**
+     * Method used to log the end of an LLM run.
+     * @param run The LLM run that has ended.
+     * @returns void
+     */
     onLLMEnd(run: Run): void;
+    /**
+     * Method used to log any errors of an LLM run.
+     * @param run The LLM run that has errored.
+     * @returns void
+     */
     onLLMError(run: Run): void;
+    /**
+     * Method used to log the start of a tool run.
+     * @param run The tool run that has started.
+     * @returns void
+     */
     onToolStart(run: Run): void;
+    /**
+     * Method used to log the end of a tool run.
+     * @param run The tool run that has ended.
+     * @returns void
+     */
     onToolEnd(run: Run): void;
+    /**
+     * Method used to log any errors of a tool run.
+     * @param run The tool run that has errored.
+     * @returns void
+     */
     onToolError(run: Run): void;
+    /**
+     * Method used to log the start of a retriever run.
+     * @param run The retriever run that has started.
+     * @returns void
+     */
     onRetrieverStart(run: Run): void;
+    /**
+     * Method used to log the end of a retriever run.
+     * @param run The retriever run that has ended.
+     * @returns void
+     */
     onRetrieverEnd(run: Run): void;
+    /**
+     * Method used to log any errors of a retriever run.
+     * @param run The retriever run that has errored.
+     * @returns void
+     */
     onRetrieverError(run: Run): void;
+    /**
+     * Method used to log the action selected by the agent.
+     * @param run The run in which the agent action occurred.
+     * @returns void
+     */
     onAgentAction(run: Run): void;
 }