langchain 0.0.131 → 0.0.132

package/dist/experimental/generative_agents/generative_agent_memory.js

@@ -3,6 +3,13 @@ import { PromptTemplate } from "../../prompts/index.js";
 import { BaseChain } from "../../chains/base.js";
 import { Document } from "../../document.js";
 import { BaseMemory } from "../../memory/base.js";
+/**
+ * Class that manages the memory of a generative agent in LangChain. It
+ * extends the `BaseChain` class and has methods for adding observations
+ * or memories to the agent's memory, scoring the importance of a memory,
+ * reflecting on recent events to add synthesized memories, and generating
+ * insights on a topic of reflection based on pertinent memories.
+ */
 class GenerativeAgentMemoryChain extends BaseChain {
     static lc_name() {
         return "GenerativeAgentMemoryChain";
@@ -66,6 +73,11 @@ class GenerativeAgentMemoryChain extends BaseChain {
     get outputKeys() {
         return ["output"];
     }
+    /**
+     * Method that creates a new LLMChain with the given prompt.
+     * @param prompt The PromptTemplate to use for the new LLMChain.
+     * @returns A new LLMChain instance.
+     */
     chain(prompt) {
         const chain = new LLMChain({
             llm: this.llm,
@@ -102,6 +114,13 @@ class GenerativeAgentMemoryChain extends BaseChain {
         }
         return { output: importanceScore };
     }
+    /**
+     * Method that pauses the agent to reflect on recent events and generate
+     * new insights.
+     * @param now The current date.
+     * @param runManager The CallbackManagerForChainRun to use for the reflection.
+     * @returns An array of new insights as strings.
+     */
     async pauseToReflect(now, runManager) {
         if (this.verbose) {
             console.log("Pausing to reflect...");
@@ -124,6 +143,12 @@ class GenerativeAgentMemoryChain extends BaseChain {
         }
         return newInsights;
     }
+    /**
+     * Method that scores the importance of a given memory.
+     * @param memoryContent The content of the memory to score.
+     * @param runManager The CallbackManagerForChainRun to use for scoring.
+     * @returns The importance score of the memory as a number.
+     */
     async scoreMemoryImportance(memoryContent, runManager) {
         // score the absolute importance of a given memory
         const prompt = PromptTemplate.fromTemplate("On the scale of 1 to 10, where 1 is purely mundane" +
@@ -148,6 +173,13 @@ class GenerativeAgentMemoryChain extends BaseChain {
             return 0.0;
         }
     }
+    /**
+     * Method that retrieves the topics of reflection based on the last K
+     * memories.
+     * @param lastK The number of most recent memories to consider for generating topics.
+     * @param runManager The CallbackManagerForChainRun to use for retrieving topics.
+     * @returns An array of topics of reflection as strings.
+     */
     async getTopicsOfReflection(lastK, runManager) {
         const prompt = PromptTemplate.fromTemplate("{observations}\n\n" +
             "Given only the information above, what are the 3 most salient" +
@@ -160,6 +192,14 @@ class GenerativeAgentMemoryChain extends BaseChain {
         const result = await this.chain(prompt).run(observationStr, runManager?.getChild("reflection_topics"));
         return GenerativeAgentMemoryChain.parseList(result);
     }
+    /**
+     * Method that generates insights on a given topic of reflection based on
+     * pertinent memories.
+     * @param topic The topic of reflection.
+     * @param now The current date.
+     * @param runManager The CallbackManagerForChainRun to use for generating insights.
+     * @returns An array of insights as strings.
+     */
     async getInsightsOnTopic(topic, now, runManager) {
         // generate insights on a topic of reflection, based on pertinent memories
         const prompt = PromptTemplate.fromTemplate("Statements about {topic}\n" +
@@ -176,15 +216,34 @@ class GenerativeAgentMemoryChain extends BaseChain {
         }, runManager?.getChild("reflection_insights"));
         return GenerativeAgentMemoryChain.parseList(result.output); // added output
     }
+    /**
+     * Method that parses a newline-separated string into a list of strings.
+     * @param text The newline-separated string to parse.
+     * @returns An array of strings.
+     */
     static parseList(text) {
         // parse a newine seperates string into a list of strings
         return text.split("\n").map((s) => s.trim());
     }
     // TODO: Mock "now" to simulate different times
+    /**
+     * Method that fetches memories related to a given observation.
+     * @param observation The observation to fetch memories for.
+     * @param _now The current date.
+     * @param runManager The CallbackManagerForChainRun to use for fetching memories.
+     * @returns An array of Document instances representing the fetched memories.
+     */
     async fetchMemories(observation, _now, runManager) {
         return this.memoryRetriever.getRelevantDocuments(observation, runManager?.getChild("memory_retriever"));
     }
 }
+/**
+ * Class that manages the memory of a generative agent in LangChain. It
+ * extends the `BaseMemory` class and has methods for adding a memory,
+ * formatting memories, getting memories until a token limit is reached,
+ * loading memory variables, saving the context of a model run to memory,
+ * and clearing memory contents.
+ */
 export class GenerativeAgentMemory extends BaseMemory {
     constructor(llm, memoryRetriever, config) {
         super();
@@ -277,15 +336,31 @@ export class GenerativeAgentMemory extends BaseMemory {
             importanceWeight: config?.importanceWeight,
         });
     }
+    /**
+     * Method that returns the key for relevant memories.
+     * @returns The key for relevant memories as a string.
+     */
     getRelevantMemoriesKey() {
         return this.relevantMemoriesKey;
     }
+    /**
+     * Method that returns the key for the most recent memories token.
+     * @returns The key for the most recent memories token as a string.
+     */
     getMostRecentMemoriesTokenKey() {
         return this.mostRecentMemoriesTokenKey;
     }
+    /**
+     * Method that returns the key for adding a memory.
+     * @returns The key for adding a memory as a string.
+     */
     getAddMemoryKey() {
         return this.addMemoryKey;
     }
+    /**
+     * Method that returns the key for the current time.
+     * @returns The key for the current time as a string.
+     */
     getCurrentTimeKey() {
         return this.nowKey;
     }
@@ -293,9 +368,22 @@ export class GenerativeAgentMemory extends BaseMemory {
         // Return an array of memory keys
         return [this.relevantMemoriesKey, this.mostRecentMemoriesKey];
     }
+    /**
+     * Method that adds a memory to the agent's memory.
+     * @param memoryContent The content of the memory to add.
+     * @param now The current date.
+     * @param metadata The metadata for the memory.
+     * @param callbacks The Callbacks to use for adding the memory.
+     * @returns The result of the memory addition.
+     */
     async addMemory(memoryContent, now, metadata, callbacks) {
         return this.memoryChain.call({ memory_content: memoryContent, now, memory_metadata: metadata }, callbacks);
     }
+    /**
+     * Method that formats the given relevant memories in detail.
+     * @param relevantMemories The relevant memories to format.
+     * @returns The formatted memories as a string.
+     */
     formatMemoriesDetail(relevantMemories) {
         if (!relevantMemories.length) {
             return "No relevant information.";
@@ -320,12 +408,22 @@ export class GenerativeAgentMemory extends BaseMemory {
         const joinedContent = content.map((mem) => `${mem}`).join("\n");
         return joinedContent;
     }
+    /**
+     * Method that formats the given relevant memories in a simple manner.
+     * @param relevantMemories The relevant memories to format.
+     * @returns The formatted memories as a string.
+     */
     formatMemoriesSimple(relevantMemories) {
         const joinedContent = relevantMemories
             .map((mem) => `${mem.pageContent}`)
             .join("; ");
         return joinedContent;
     }
+    /**
+     * Method that retrieves memories until a token limit is reached.
+     * @param consumedTokens The number of tokens consumed so far.
+     * @returns The memories as a string.
+     */
     async getMemoriesUntilLimit(consumedTokens) {
         // reduce the number of tokens in the documents
         const result = [];
@@ -351,6 +449,11 @@ export class GenerativeAgentMemory extends BaseMemory {
         // input keys this memory class will load dynamically
         return [];
     }
+    /**
+     * Method that loads memory variables based on the given inputs.
+     * @param inputs The inputs to use for loading memory variables.
+     * @returns An object containing the loaded memory variables.
+     */
     async loadMemoryVariables(inputs) {
         const queries = inputs[this.queriesKey];
         const now = inputs[this.nowKey];
@@ -369,6 +472,12 @@ export class GenerativeAgentMemory extends BaseMemory {
         }
         return {};
     }
+    /**
+     * Method that saves the context of a model run to memory.
+     * @param _inputs The inputs of the model run.
+     * @param outputs The outputs of the model run.
+     * @returns Nothing.
+     */
     async saveContext(_inputs, outputs) {
         // save the context of this model run to memory
         const mem = outputs[this.addMemoryKey];
@@ -377,6 +486,10 @@ export class GenerativeAgentMemory extends BaseMemory {
             await this.addMemory(mem, now, {});
         }
     }
+    /**
+     * Method that clears the memory contents.
+     * @returns Nothing.
+     */
     clear() {
         // TODO: clear memory contents
     }

package/dist/experimental/multimodal_embeddings/googlevertexai.cjs

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoogleVertexAIMultimodalEmbeddings = void 0;
 const base_js_1 = require("../../embeddings/base.cjs");
 const googlevertexai_connection_js_1 = require("../../util/googlevertexai-connection.cjs");
+/**
+ * Class for generating embeddings for text and images using Google's
+ * Vertex AI. It extends the Embeddings base class and implements the
+ * GoogleVertexAIMultimodalEmbeddingsParams interface.
+ */
 class GoogleVertexAIMultimodalEmbeddings extends base_js_1.Embeddings {
     constructor(fields) {
         super(fields ?? {});
@@ -21,6 +26,12 @@ class GoogleVertexAIMultimodalEmbeddings extends base_js_1.Embeddings {
         this.model = fields?.model ?? this.model;
         this.connection = new googlevertexai_connection_js_1.GoogleVertexAIConnection({ ...fields, ...this }, this.caller);
     }
+    /**
+     * Converts media (text or image) to an instance that can be used for
+     * generating embeddings.
+     * @param media The media (text or image) to be converted.
+     * @returns An instance of media that can be used for generating embeddings.
+     */
     mediaToInstance(media) {
         const ret = {};
         if (media?.text) {
@@ -33,16 +44,31 @@ class GoogleVertexAIMultimodalEmbeddings extends base_js_1.Embeddings {
         }
         return ret;
     }
+    /**
+     * Converts the response from Google Vertex AI to embeddings.
+     * @param response The response from Google Vertex AI.
+     * @returns An array of media embeddings.
+     */
     responseToEmbeddings(response) {
         return response.data.predictions.map((r) => ({
             text: r.textEmbedding,
             image: r.imageEmbedding,
         }));
     }
+    /**
+     * Generates embeddings for multiple media instances.
+     * @param media An array of media instances.
+     * @returns A promise that resolves to an array of media embeddings.
+     */
     async embedMedia(media) {
         // Only one media embedding request is allowed
         return Promise.all(media.map((m) => this.embedMediaQuery(m)));
     }
+    /**
+     * Generates embeddings for a single media instance.
+     * @param media A single media instance.
+     * @returns A promise that resolves to a media embedding.
+     */
     async embedMediaQuery(media) {
         const instance = this.mediaToInstance(media);
         const instances = [instance];
@@ -52,17 +78,37 @@ class GoogleVertexAIMultimodalEmbeddings extends base_js_1.Embeddings {
         const result = this.responseToEmbeddings(responses);
         return result[0];
     }
+    /**
+     * Generates embeddings for multiple images.
+     * @param images An array of images.
+     * @returns A promise that resolves to an array of image embeddings.
+     */
     async embedImage(images) {
         return this.embedMedia(images.map((image) => ({ image }))).then((embeddings) => embeddings.map((e) => e.image ?? []));
     }
+    /**
+     * Generates embeddings for a single image.
+     * @param image A single image.
+     * @returns A promise that resolves to an image embedding.
+     */
     async embedImageQuery(image) {
         return this.embedMediaQuery({
             image,
         }).then((embeddings) => embeddings.image ?? []);
     }
+    /**
+     * Generates embeddings for multiple text documents.
+     * @param documents An array of text documents.
+     * @returns A promise that resolves to an array of text document embeddings.
+     */
     async embedDocuments(documents) {
         return this.embedMedia(documents.map((text) => ({ text }))).then((embeddings) => embeddings.map((e) => e.text ?? []));
     }
+    /**
+     * Generates embeddings for a single text document.
+     * @param document A single text document.
+     * @returns A promise that resolves to a text document embedding.
+     */
     async embedQuery(document) {
         return this.embedMediaQuery({
             text: document,

package/dist/experimental/multimodal_embeddings/googlevertexai.d.ts

@@ -1,14 +1,26 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Embeddings, EmbeddingsParams } from "../../embeddings/base.js";
 import { GoogleVertexAIBasePrediction, GoogleVertexAIConnectionParams, GoogleVertexAILLMResponse } from "../../types/googlevertexai-types.js";
+/**
+ * Parameters for the GoogleVertexAIMultimodalEmbeddings class, extending
+ * both EmbeddingsParams and GoogleVertexAIConnectionParams.
+ */
 export interface GoogleVertexAIMultimodalEmbeddingsParams extends EmbeddingsParams, GoogleVertexAIConnectionParams {
 }
+/**
+ * An instance of media (text or image) that can be used for generating
+ * embeddings.
+ */
 interface GoogleVertexAIMultimodalEmbeddingsInstance {
     text?: string;
     image?: {
         bytesBase64Encoded: string;
     };
 }
+/**
+ * The results of generating embeddings, extending
+ * GoogleVertexAIBasePrediction. It includes text and image embeddings.
+ */
 interface GoogleVertexAIMultimodalEmbeddingsResults extends GoogleVertexAIBasePrediction {
     textEmbedding?: number[];
     imageEmbedding?: number[];
@@ -27,17 +39,63 @@ export type MediaEmbeddings = {
     text?: number[];
     image?: number[];
 };
+/**
+ * Class for generating embeddings for text and images using Google's
+ * Vertex AI. It extends the Embeddings base class and implements the
+ * GoogleVertexAIMultimodalEmbeddingsParams interface.
+ */
 export declare class GoogleVertexAIMultimodalEmbeddings extends Embeddings implements GoogleVertexAIMultimodalEmbeddingsParams {
     model: string;
     private connection;
     constructor(fields?: GoogleVertexAIMultimodalEmbeddingsParams);
+    /**
+     * Converts media (text or image) to an instance that can be used for
+     * generating embeddings.
+     * @param media The media (text or image) to be converted.
+     * @returns An instance of media that can be used for generating embeddings.
+     */
     mediaToInstance(media: GoogleVertexAIMedia): GoogleVertexAIMultimodalEmbeddingsInstance;
+    /**
+     * Converts the response from Google Vertex AI to embeddings.
+     * @param response The response from Google Vertex AI.
+     * @returns An array of media embeddings.
+     */
     responseToEmbeddings(response: GoogleVertexAILLMResponse<GoogleVertexAIMultimodalEmbeddingsResults>): MediaEmbeddings[];
+    /**
+     * Generates embeddings for multiple media instances.
+     * @param media An array of media instances.
+     * @returns A promise that resolves to an array of media embeddings.
+     */
     embedMedia(media: GoogleVertexAIMedia[]): Promise<MediaEmbeddings[]>;
+    /**
+     * Generates embeddings for a single media instance.
+     * @param media A single media instance.
+     * @returns A promise that resolves to a media embedding.
+     */
     embedMediaQuery(media: GoogleVertexAIMedia): Promise<MediaEmbeddings>;
+    /**
+     * Generates embeddings for multiple images.
+     * @param images An array of images.
+     * @returns A promise that resolves to an array of image embeddings.
+     */
     embedImage(images: Buffer[]): Promise<number[][]>;
+    /**
+     * Generates embeddings for a single image.
+     * @param image A single image.
+     * @returns A promise that resolves to an image embedding.
+     */
     embedImageQuery(image: Buffer): Promise<number[]>;
+    /**
+     * Generates embeddings for multiple text documents.
+     * @param documents An array of text documents.
+     * @returns A promise that resolves to an array of text document embeddings.
+     */
     embedDocuments(documents: string[]): Promise<number[][]>;
+    /**
+     * Generates embeddings for a single text document.
+     * @param document A single text document.
+     * @returns A promise that resolves to a text document embedding.
+     */
     embedQuery(document: string): Promise<number[]>;
 }
 export {};

package/dist/experimental/multimodal_embeddings/googlevertexai.js

@@ -1,5 +1,10 @@
 import { Embeddings } from "../../embeddings/base.js";
 import { GoogleVertexAIConnection } from "../../util/googlevertexai-connection.js";
+/**
+ * Class for generating embeddings for text and images using Google's
+ * Vertex AI. It extends the Embeddings base class and implements the
+ * GoogleVertexAIMultimodalEmbeddingsParams interface.
+ */
 export class GoogleVertexAIMultimodalEmbeddings extends Embeddings {
     constructor(fields) {
         super(fields ?? {});
@@ -18,6 +23,12 @@ export class GoogleVertexAIMultimodalEmbeddings extends Embeddings {
         this.model = fields?.model ?? this.model;
         this.connection = new GoogleVertexAIConnection({ ...fields, ...this }, this.caller);
     }
+    /**
+     * Converts media (text or image) to an instance that can be used for
+     * generating embeddings.
+     * @param media The media (text or image) to be converted.
+     * @returns An instance of media that can be used for generating embeddings.
+     */
     mediaToInstance(media) {
         const ret = {};
         if (media?.text) {
@@ -30,16 +41,31 @@ export class GoogleVertexAIMultimodalEmbeddings extends Embeddings {
         }
         return ret;
     }
+    /**
+     * Converts the response from Google Vertex AI to embeddings.
+     * @param response The response from Google Vertex AI.
+     * @returns An array of media embeddings.
+     */
     responseToEmbeddings(response) {
         return response.data.predictions.map((r) => ({
             text: r.textEmbedding,
             image: r.imageEmbedding,
         }));
     }
+    /**
+     * Generates embeddings for multiple media instances.
+     * @param media An array of media instances.
+     * @returns A promise that resolves to an array of media embeddings.
+     */
     async embedMedia(media) {
         // Only one media embedding request is allowed
         return Promise.all(media.map((m) => this.embedMediaQuery(m)));
     }
+    /**
+     * Generates embeddings for a single media instance.
+     * @param media A single media instance.
+     * @returns A promise that resolves to a media embedding.
+     */
     async embedMediaQuery(media) {
         const instance = this.mediaToInstance(media);
         const instances = [instance];
@@ -49,17 +75,37 @@ export class GoogleVertexAIMultimodalEmbeddings extends Embeddings {
         const result = this.responseToEmbeddings(responses);
         return result[0];
     }
+    /**
+     * Generates embeddings for multiple images.
+     * @param images An array of images.
+     * @returns A promise that resolves to an array of image embeddings.
+     */
     async embedImage(images) {
         return this.embedMedia(images.map((image) => ({ image }))).then((embeddings) => embeddings.map((e) => e.image ?? []));
     }
+    /**
+     * Generates embeddings for a single image.
+     * @param image A single image.
+     * @returns A promise that resolves to an image embedding.
+     */
     async embedImageQuery(image) {
         return this.embedMediaQuery({
             image,
         }).then((embeddings) => embeddings.image ?? []);
     }
+    /**
+     * Generates embeddings for multiple text documents.
+     * @param documents An array of text documents.
+     * @returns A promise that resolves to an array of text document embeddings.
+     */
     async embedDocuments(documents) {
         return this.embedMedia(documents.map((text) => ({ text }))).then((embeddings) => embeddings.map((e) => e.text ?? []));
     }
+    /**
+     * Generates embeddings for a single text document.
+     * @param document A single text document.
+     * @returns A promise that resolves to a text document embedding.
+     */
     async embedQuery(document) {
         return this.embedMediaQuery({
             text: document,

package/dist/experimental/plan_and_execute/agent_executor.cjs

@@ -8,6 +8,12 @@ const prompt_js_1 = require("./prompt.cjs");
 const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
 const outputParser_js_1 = require("./outputParser.cjs");
 const index_js_1 = require("../../agents/chat/index.cjs");
+/**
+ * Class representing a plan-and-execute agent executor. This agent
+ * decides on the full sequence of actions upfront, then executes them all
+ * without updating the plan. This is suitable for complex or long-running
+ * tasks that require maintaining long-term objectives and focus.
+ */
 class PlanAndExecuteAgentExecutor extends base_js_1.BaseChain {
     static lc_name() {
         return "PlanAndExecuteAgentExecutor";
@@ -56,6 +62,13 @@ class PlanAndExecuteAgentExecutor extends base_js_1.BaseChain {
     get outputKeys() {
         return [this.outputKey];
     }
+    /**
+     * Static method that returns a default planner for the agent. It creates
+     * a new LLMChain with a given LLM and a fixed prompt, and uses it to
+     * create a new LLMPlanner with a PlanOutputParser.
+     * @param llm The Large Language Model (LLM) used to generate responses.
+     * @returns A new LLMPlanner instance.
+     */
     static getDefaultPlanner({ llm }) {
         const plannerLlmChain = new llm_chain_js_1.LLMChain({
             llm,
@@ -63,6 +76,15 @@ class PlanAndExecuteAgentExecutor extends base_js_1.BaseChain {
         });
         return new base_js_2.LLMPlanner(plannerLlmChain, new outputParser_js_1.PlanOutputParser());
     }
+    /**
+     * Static method that returns a default step executor for the agent. It
+     * creates a new ChatAgent from a given LLM and a set of tools, and uses
+     * it to create a new ChainStepExecutor.
+     * @param llm The Large Language Model (LLM) used to generate responses.
+     * @param tools The set of tools used by the agent.
+     * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.
+     * @returns A new ChainStepExecutor instance.
+     */
     static getDefaultStepExecutor({ llm, tools, humanMessageTemplate = prompt_js_1.DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE, }) {
         const agent = index_js_1.ChatAgent.fromLLMAndTools(llm, tools, {
             humanMessageTemplate,
@@ -72,6 +94,16 @@ class PlanAndExecuteAgentExecutor extends base_js_1.BaseChain {
             tools,
         }));
     }
+    /**
+     * Static method that creates a new PlanAndExecuteAgentExecutor from a
+     * given LLM, a set of tools, and optionally a human message template. It
+     * uses the getDefaultPlanner and getDefaultStepExecutor methods to create
+     * the planner and step executor for the new agent executor.
+     * @param llm The Large Language Model (LLM) used to generate responses.
+     * @param tools The set of tools used by the agent.
+     * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.
+     * @returns A new PlanAndExecuteAgentExecutor instance.
+     */
     static fromLLMAndTools({ llm, tools, humanMessageTemplate, }) {
         const executor = new PlanAndExecuteAgentExecutor({
             planner: PlanAndExecuteAgentExecutor.getDefaultPlanner({ llm }),

package/dist/experimental/plan_and_execute/agent_executor.d.ts

@@ -5,6 +5,11 @@ import { BaseLanguageModel } from "../../base_language/index.js";
 import { CallbackManagerForChainRun } from "../../callbacks/manager.js";
 import { Tool } from "../../tools/base.js";
 import { SerializedLLMChain } from "../../chains/serde.js";
+/**
+ * Interface for the input to the PlanAndExecuteAgentExecutor class. It
+ * extends ChainInputs and includes additional properties for the planner,
+ * step executor, step container, and input and output keys.
+ */
 export interface PlanAndExecuteAgentExecutorInput extends ChainInputs {
     planner: BasePlanner;
     stepExecutor: BaseStepExecutor;
@@ -12,6 +17,12 @@ export interface PlanAndExecuteAgentExecutorInput extends ChainInputs {
     inputKey?: string;
     outputKey?: string;
 }
+/**
+ * Class representing a plan-and-execute agent executor. This agent
+ * decides on the full sequence of actions upfront, then executes them all
+ * without updating the plan. This is suitable for complex or long-running
+ * tasks that require maintaining long-term objectives and focus.
+ */
 export declare class PlanAndExecuteAgentExecutor extends BaseChain {
     static lc_name(): string;
     private planner;
@@ -22,14 +33,40 @@ export declare class PlanAndExecuteAgentExecutor extends BaseChain {
     constructor(input: PlanAndExecuteAgentExecutorInput);
     get inputKeys(): string[];
     get outputKeys(): string[];
+    /**
+     * Static method that returns a default planner for the agent. It creates
+     * a new LLMChain with a given LLM and a fixed prompt, and uses it to
+     * create a new LLMPlanner with a PlanOutputParser.
+     * @param llm The Large Language Model (LLM) used to generate responses.
+     * @returns A new LLMPlanner instance.
+     */
     static getDefaultPlanner({ llm }: {
         llm: BaseLanguageModel;
     }): LLMPlanner;
+    /**
+     * Static method that returns a default step executor for the agent. It
+     * creates a new ChatAgent from a given LLM and a set of tools, and uses
+     * it to create a new ChainStepExecutor.
+     * @param llm The Large Language Model (LLM) used to generate responses.
+     * @param tools The set of tools used by the agent.
+     * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.
+     * @returns A new ChainStepExecutor instance.
+     */
     static getDefaultStepExecutor({ llm, tools, humanMessageTemplate, }: {
         llm: BaseLanguageModel;
         tools: Tool[];
         humanMessageTemplate?: string;
     }): ChainStepExecutor;
+    /**
+     * Static method that creates a new PlanAndExecuteAgentExecutor from a
+     * given LLM, a set of tools, and optionally a human message template. It
+     * uses the getDefaultPlanner and getDefaultStepExecutor methods to create
+     * the planner and step executor for the new agent executor.
+     * @param llm The Large Language Model (LLM) used to generate responses.
+     * @param tools The set of tools used by the agent.
+     * @param humanMessageTemplate The template for human messages. If not provided, a default template is used.
+     * @returns A new PlanAndExecuteAgentExecutor instance.
+     */
     static fromLLMAndTools({ llm, tools, humanMessageTemplate, }: {
         llm: BaseLanguageModel;
         tools: Tool[];