langchain 0.0.131 → 0.0.132

package/dist/experimental/plan_and_execute/agent_executor.js

@@ -5,6 +5,12 @@ import { DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE, PLANNER_CHAT_PROMPT,
 import { LLMChain } from "../../chains/llm_chain.js";
 import { PlanOutputParser } from "./outputParser.js";
 import { ChatAgent } from "../../agents/chat/index.js";
+/**
+ * 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 class PlanAndExecuteAgentExecutor extends BaseChain {
     static lc_name() {
         return "PlanAndExecuteAgentExecutor";
@@ -53,6 +59,13 @@ export class PlanAndExecuteAgentExecutor extends 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 LLMChain({
             llm,
@@ -60,6 +73,15 @@ export class PlanAndExecuteAgentExecutor extends BaseChain {
         });
         return new LLMPlanner(plannerLlmChain, new 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 = DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE, }) {
         const agent = ChatAgent.fromLLMAndTools(llm, tools, {
             humanMessageTemplate,
@@ -69,6 +91,16 @@ export class PlanAndExecuteAgentExecutor extends 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/base.cjs

@@ -1,15 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChainStepExecutor = exports.LLMPlanner = exports.ListStepContainer = exports.BaseStepContainer = exports.BaseStepExecutor = exports.BasePlanner = void 0;
+/**
+ * Abstract class that defines the structure for a planner. Planners are
+ * responsible for generating a plan based on inputs.
+ */
 class BasePlanner {
 }
 exports.BasePlanner = BasePlanner;
+/**
+ * Abstract class that defines the structure for a step executor. Step
+ * executors are responsible for executing a step based on inputs.
+ */
 class BaseStepExecutor {
 }
 exports.BaseStepExecutor = BaseStepExecutor;
+/**
+ * Abstract class that defines the structure for a step container. Step
+ * containers are responsible for managing steps.
+ */
 class BaseStepContainer {
 }
 exports.BaseStepContainer = BaseStepContainer;
+/**
+ * Class that extends BaseStepContainer and provides an implementation for
+ * its methods. It maintains a list of steps and provides methods to add a
+ * step, get all steps, and get the final response.
+ */
 class ListStepContainer extends BaseStepContainer {
     constructor() {
         super(...arguments);
@@ -31,6 +48,11 @@ class ListStepContainer extends BaseStepContainer {
     }
 }
 exports.ListStepContainer = ListStepContainer;
+/**
+ * Class that extends BasePlanner and provides an implementation for the
+ * plan method. It uses an instance of LLMChain and an output parser to
+ * generate a plan.
+ */
 class LLMPlanner extends BasePlanner {
     constructor(llmChain, outputParser) {
         super();
@@ -53,6 +75,10 @@ class LLMPlanner extends BasePlanner {
     }
 }
 exports.LLMPlanner = LLMPlanner;
+/**
+ * Class that extends BaseStepExecutor and provides an implementation for
+ * the step method. It uses an instance of BaseChain to execute a step.
+ */
 class ChainStepExecutor extends BaseStepExecutor {
     constructor(chain) {
         super();

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

@@ -3,42 +3,80 @@ import { BaseChain } from "../../chains/base.js";
 import { LLMChain } from "../../chains/llm_chain.js";
 import { ChainValues } from "../../schema/index.js";
 import { CallbackManager } from "../../callbacks/manager.js";
+/**
+ * Represents an action to be performed in a step.
+ */
 export type StepAction = {
     text: string;
 };
+/**
+ * Represents the result of a step.
+ */
 export type StepResult = {
     response: string;
 };
+/**
+ * Represents a step, which includes an action and its result.
+ */
 export type Step = {
     action: StepAction;
     result: StepResult;
 };
+/**
+ * Represents a plan, which is a sequence of step actions.
+ */
 export type Plan = {
     steps: StepAction[];
 };
+/**
+ * Abstract class that defines the structure for a planner. Planners are
+ * responsible for generating a plan based on inputs.
+ */
 export declare abstract class BasePlanner {
     abstract plan(inputs: ChainValues, runManager?: CallbackManager): Promise<Plan>;
 }
+/**
+ * Abstract class that defines the structure for a step executor. Step
+ * executors are responsible for executing a step based on inputs.
+ */
 export declare abstract class BaseStepExecutor {
     abstract step(inputs: ChainValues, runManager?: CallbackManager): Promise<StepResult>;
 }
+/**
+ * Abstract class that defines the structure for a step container. Step
+ * containers are responsible for managing steps.
+ */
 export declare abstract class BaseStepContainer {
     abstract addStep(action: StepAction, result: StepResult): void;
     abstract getSteps(): Step[];
     abstract getFinalResponse(): string;
 }
+/**
+ * Class that extends BaseStepContainer and provides an implementation for
+ * its methods. It maintains a list of steps and provides methods to add a
+ * step, get all steps, and get the final response.
+ */
 export declare class ListStepContainer extends BaseStepContainer {
     private steps;
     addStep(action: StepAction, result: StepResult): void;
     getSteps(): Step[];
     getFinalResponse(): string;
 }
+/**
+ * Class that extends BasePlanner and provides an implementation for the
+ * plan method. It uses an instance of LLMChain and an output parser to
+ * generate a plan.
+ */
 export declare class LLMPlanner extends BasePlanner {
     private llmChain;
     private outputParser;
     constructor(llmChain: LLMChain, outputParser: BaseOutputParser<Plan>);
     plan(inputs: ChainValues, runManager?: CallbackManager): Promise<Plan>;
 }
+/**
+ * Class that extends BaseStepExecutor and provides an implementation for
+ * the step method. It uses an instance of BaseChain to execute a step.
+ */
 export declare class ChainStepExecutor extends BaseStepExecutor {
     private chain;
     constructor(chain: BaseChain);

package/dist/experimental/plan_and_execute/base.js

@@ -1,9 +1,26 @@
+/**
+ * Abstract class that defines the structure for a planner. Planners are
+ * responsible for generating a plan based on inputs.
+ */
 export class BasePlanner {
 }
+/**
+ * Abstract class that defines the structure for a step executor. Step
+ * executors are responsible for executing a step based on inputs.
+ */
 export class BaseStepExecutor {
 }
+/**
+ * Abstract class that defines the structure for a step container. Step
+ * containers are responsible for managing steps.
+ */
 export class BaseStepContainer {
 }
+/**
+ * Class that extends BaseStepContainer and provides an implementation for
+ * its methods. It maintains a list of steps and provides methods to add a
+ * step, get all steps, and get the final response.
+ */
 export class ListStepContainer extends BaseStepContainer {
     constructor() {
         super(...arguments);
@@ -24,6 +41,11 @@ export class ListStepContainer extends BaseStepContainer {
         return this.steps[this.steps.length - 1]?.result?.response;
     }
 }
+/**
+ * Class that extends BasePlanner and provides an implementation for the
+ * plan method. It uses an instance of LLMChain and an output parser to
+ * generate a plan.
+ */
 export class LLMPlanner extends BasePlanner {
     constructor(llmChain, outputParser) {
         super();
@@ -45,6 +67,10 @@ export class LLMPlanner extends BasePlanner {
         return this.outputParser.parse(output);
     }
 }
+/**
+ * Class that extends BaseStepExecutor and provides an implementation for
+ * the step method. It uses an instance of BaseChain to execute a step.
+ */
 export class ChainStepExecutor extends BaseStepExecutor {
     constructor(chain) {
         super();

package/dist/experimental/plan_and_execute/outputParser.cjs

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlanOutputParser = void 0;
 const output_parser_js_1 = require("../../schema/output_parser.cjs");
 const prompt_js_1 = require("./prompt.cjs");
+/**
+ * Specific implementation of the `BaseOutputParser` class designed to
+ * parse the output text into a `Plan` object.
+ */
 class PlanOutputParser extends output_parser_js_1.BaseOutputParser {
     constructor() {
         super(...arguments);
@@ -13,6 +17,14 @@ class PlanOutputParser extends output_parser_js_1.BaseOutputParser {
             value: ["langchain", "experimental", "plan_and_execute"]
         });
     }
+    /**
+     * Parses the output text into a `Plan` object. The steps are extracted by
+     * splitting the text on newline followed by a number and a period,
+     * indicating the start of a new step. The `<END_OF_PLAN>` tag is then
+     * removed from each step.
+     * @param text The output text to be parsed.
+     * @returns A `Plan` object consisting of a series of steps.
+     */
     async parse(text) {
         return {
             steps: text
@@ -21,6 +33,12 @@ class PlanOutputParser extends output_parser_js_1.BaseOutputParser {
                 .map((step) => ({ text: step.replace(`<END_OF_PLAN>`, "") })),
         };
     }
+    /**
+     * Returns a string that represents the format instructions for the plan.
+     * This is defined by the `PLANNER_SYSTEM_PROMPT_MESSAGE_TEMPLATE`
+     * constant.
+     * @returns A string representing the format instructions for the plan.
+     */
     getFormatInstructions() {
         return prompt_js_1.PLANNER_SYSTEM_PROMPT_MESSAGE_TEMPLATE;
     }

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

@@ -1,7 +1,25 @@
 import { BaseOutputParser } from "../../schema/output_parser.js";
 import { Plan } from "./base.js";
+/**
+ * Specific implementation of the `BaseOutputParser` class designed to
+ * parse the output text into a `Plan` object.
+ */
 export declare class PlanOutputParser extends BaseOutputParser<Plan> {
     lc_namespace: string[];
+    /**
+     * Parses the output text into a `Plan` object. The steps are extracted by
+     * splitting the text on newline followed by a number and a period,
+     * indicating the start of a new step. The `<END_OF_PLAN>` tag is then
+     * removed from each step.
+     * @param text The output text to be parsed.
+     * @returns A `Plan` object consisting of a series of steps.
+     */
     parse(text: string): Promise<Plan>;
+    /**
+     * Returns a string that represents the format instructions for the plan.
+     * This is defined by the `PLANNER_SYSTEM_PROMPT_MESSAGE_TEMPLATE`
+     * constant.
+     * @returns A string representing the format instructions for the plan.
+     */
     getFormatInstructions(): string;
 }

package/dist/experimental/plan_and_execute/outputParser.js

@@ -1,5 +1,9 @@
 import { BaseOutputParser } from "../../schema/output_parser.js";
 import { PLANNER_SYSTEM_PROMPT_MESSAGE_TEMPLATE } from "./prompt.js";
+/**
+ * Specific implementation of the `BaseOutputParser` class designed to
+ * parse the output text into a `Plan` object.
+ */
 export class PlanOutputParser extends BaseOutputParser {
     constructor() {
         super(...arguments);
@@ -10,6 +14,14 @@ export class PlanOutputParser extends BaseOutputParser {
             value: ["langchain", "experimental", "plan_and_execute"]
         });
     }
+    /**
+     * Parses the output text into a `Plan` object. The steps are extracted by
+     * splitting the text on newline followed by a number and a period,
+     * indicating the start of a new step. The `<END_OF_PLAN>` tag is then
+     * removed from each step.
+     * @param text The output text to be parsed.
+     * @returns A `Plan` object consisting of a series of steps.
+     */
     async parse(text) {
         return {
             steps: text
@@ -18,6 +30,12 @@ export class PlanOutputParser extends BaseOutputParser {
                 .map((step) => ({ text: step.replace(`<END_OF_PLAN>`, "") })),
         };
     }
+    /**
+     * Returns a string that represents the format instructions for the plan.
+     * This is defined by the `PLANNER_SYSTEM_PROMPT_MESSAGE_TEMPLATE`
+     * constant.
+     * @returns A string representing the format instructions for the plan.
+     */
     getFormatInstructions() {
         return PLANNER_SYSTEM_PROMPT_MESSAGE_TEMPLATE;
     }

package/dist/llms/ai21.cjs

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AI21 = void 0;
 const base_js_1 = require("./base.cjs");
 const env_js_1 = require("../util/env.cjs");
+/**
+ * Class representing the AI21 language model. It extends the LLM (Large
+ * Language Model) class, providing a standard interface for interacting
+ * with the AI21 language model.
+ */
 class AI21 extends base_js_1.LLM {
     constructor(fields) {
         super(fields ?? {});
@@ -99,11 +104,19 @@ class AI21 extends base_js_1.LLM {
         this.stop = fields?.stop;
         this.baseUrl = fields?.baseUrl;
     }
+    /**
+     * Method to validate the environment. It checks if the AI21 API key is
+     * set. If not, it throws an error.
+     */
     validateEnvironment() {
         if (!this.ai21ApiKey) {
             throw new Error(`No AI21 API key found. Please set it as "AI21_API_KEY" in your environment variables.`);
         }
     }
+    /**
+     * Static method to get the default penalty data for AI21.
+     * @returns AI21PenaltyData
+     */
     static getDefaultAI21PenaltyData() {
         return {
             scale: 0,

package/dist/llms/ai21.d.ts

@@ -1,4 +1,7 @@
 import { LLM, BaseLLMParams } from "./base.js";
+/**
+ * Type definition for AI21 penalty data.
+ */
 export type AI21PenaltyData = {
     scale: number;
     applyToWhitespaces: boolean;
@@ -7,6 +10,9 @@ export type AI21PenaltyData = {
     applyToStopwords: boolean;
     applyToEmojis: boolean;
 };
+/**
+ * Interface for AI21 input parameters.
+ */
 export interface AI21Input extends BaseLLMParams {
     ai21ApiKey?: string;
     model?: string;
@@ -22,6 +28,11 @@ export interface AI21Input extends BaseLLMParams {
     stop?: string[];
     baseUrl?: string;
 }
+/**
+ * Class representing the AI21 language model. It extends the LLM (Large
+ * Language Model) class, providing a standard interface for interacting
+ * with the AI21 language model.
+ */
 export declare class AI21 extends LLM implements AI21Input {
     model: string;
     temperature: number;
@@ -37,7 +48,15 @@ export declare class AI21 extends LLM implements AI21Input {
     stop?: string[];
     baseUrl?: string;
     constructor(fields?: AI21Input);
+    /**
+     * Method to validate the environment. It checks if the AI21 API key is
+     * set. If not, it throws an error.
+     */
     validateEnvironment(): void;
+    /**
+     * Static method to get the default penalty data for AI21.
+     * @returns AI21PenaltyData
+     */
     static getDefaultAI21PenaltyData(): AI21PenaltyData;
     /** Get the type of LLM. */
     _llmType(): string;

package/dist/llms/ai21.js

@@ -1,5 +1,10 @@
 import { LLM } from "./base.js";
 import { getEnvironmentVariable } from "../util/env.js";
+/**
+ * Class representing the AI21 language model. It extends the LLM (Large
+ * Language Model) class, providing a standard interface for interacting
+ * with the AI21 language model.
+ */
 export class AI21 extends LLM {
     constructor(fields) {
         super(fields ?? {});
@@ -96,11 +101,19 @@ export class AI21 extends LLM {
         this.stop = fields?.stop;
         this.baseUrl = fields?.baseUrl;
     }
+    /**
+     * Method to validate the environment. It checks if the AI21 API key is
+     * set. If not, it throws an error.
+     */
     validateEnvironment() {
         if (!this.ai21ApiKey) {
             throw new Error(`No AI21 API key found. Please set it as "AI21_API_KEY" in your environment variables.`);
         }
     }
+    /**
+     * Static method to get the default penalty data for AI21.
+     * @returns AI21PenaltyData
+     */
     static getDefaultAI21PenaltyData() {
         return {
             scale: 0,

package/dist/llms/aleph_alpha.cjs

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlephAlpha = void 0;
 const base_js_1 = require("./base.cjs");
 const env_js_1 = require("../util/env.cjs");
+/**
+ * Specific implementation of a Large Language Model (LLM) designed to
+ * interact with the Aleph Alpha API. It extends the base LLM class and
+ * includes a variety of parameters for customizing the behavior of the
+ * Aleph Alpha model.
+ */
 class AlephAlpha extends base_js_1.LLM {
     constructor(fields) {
         super(fields ?? {});
@@ -275,6 +281,10 @@ class AlephAlpha extends base_js_1.LLM {
             fields?.aleph_alpha_api_key ?? this.aleph_alpha_api_key;
         this.stop = fields?.stop ?? this.stop;
     }
+    /**
+     * Validates the environment by ensuring the necessary Aleph Alpha API key
+     * is available. Throws an error if the API key is missing.
+     */
     validateEnvironment() {
         if (!this.aleph_alpha_api_key) {
             throw new Error("Aleph Alpha API Key is missing in environment variables.");

package/dist/llms/aleph_alpha.d.ts

@@ -1,4 +1,7 @@
 import { LLM, BaseLLMParams } from "./base.js";
+/**
+ * Interface for the input parameters specific to the Aleph Alpha LLM.
+ */
 export interface AlephAlphaInput extends BaseLLMParams {
     model: string;
     maximum_tokens: number;
@@ -36,6 +39,12 @@ export interface AlephAlphaInput extends BaseLLMParams {
     aleph_alpha_api_key?: string;
     base_url: string;
 }
+/**
+ * Specific implementation of a Large Language Model (LLM) designed to
+ * interact with the Aleph Alpha API. It extends the base LLM class and
+ * includes a variety of parameters for customizing the behavior of the
+ * Aleph Alpha model.
+ */
 export declare class AlephAlpha extends LLM implements AlephAlphaInput {
     model: string;
     maximum_tokens: number;
@@ -73,6 +82,10 @@ export declare class AlephAlpha extends LLM implements AlephAlphaInput {
     stop?: string[];
     base_url: string;
     constructor(fields: Partial<AlephAlpha>);
+    /**
+     * Validates the environment by ensuring the necessary Aleph Alpha API key
+     * is available. Throws an error if the API key is missing.
+     */
     validateEnvironment(): void;
     /** Get the default parameters for calling Aleph Alpha API. */
     get defaultParams(): {

package/dist/llms/aleph_alpha.js

@@ -1,5 +1,11 @@
 import { LLM } from "./base.js";
 import { getEnvironmentVariable } from "../util/env.js";
+/**
+ * Specific implementation of a Large Language Model (LLM) designed to
+ * interact with the Aleph Alpha API. It extends the base LLM class and
+ * includes a variety of parameters for customizing the behavior of the
+ * Aleph Alpha model.
+ */
 export class AlephAlpha extends LLM {
     constructor(fields) {
         super(fields ?? {});
@@ -272,6 +278,10 @@ export class AlephAlpha extends LLM {
             fields?.aleph_alpha_api_key ?? this.aleph_alpha_api_key;
         this.stop = fields?.stop ?? this.stop;
     }
+    /**
+     * Validates the environment by ensuring the necessary Aleph Alpha API key
+     * is available. Throws an error if the API key is missing.
+     */
     validateEnvironment() {
         if (!this.aleph_alpha_api_key) {
             throw new Error("Aleph Alpha API Key is missing in environment variables.");

package/dist/llms/base.cjs

@@ -34,6 +34,14 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
             this.cache = undefined;
         }
     }
+    /**
+     * This method takes an input and options, and returns a string. It
+     * converts the input to a prompt value and generates a result based on
+     * the prompt.
+     * @param input Input for the LLM.
+     * @param options Options for the LLM call.
+     * @returns A string result based on the prompt.
+     */
     async invoke(input, options) {
         const promptValue = BaseLLM._convertInputToPromptValue(input);
         const result = await this.generatePrompt([promptValue], options, options?.callbacks);
@@ -89,6 +97,14 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
             })));
         }
     }
+    /**
+     * This method takes prompt values, options, and callbacks, and generates
+     * a result based on the prompts.
+     * @param promptValues Prompt values for the LLM.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns An LLMResult based on the prompts.
+     */
     async generatePrompt(promptValues, options, callbacks) {
         const prompts = promptValues.map((promptValue) => promptValue.toString());
         return this.generate(prompts, options, callbacks);
@@ -200,9 +216,25 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
         const { generations } = await this.generate([prompt], options, callbacks);
         return generations[0][0].text;
     }
+    /**
+     * This method is similar to `call`, but it's used for making predictions
+     * based on the input text.
+     * @param text Input text for the prediction.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns A prediction based on the input text.
+     */
     async predict(text, options, callbacks) {
         return this.call(text, options, callbacks);
     }
+    /**
+     * This method takes a list of messages, options, and callbacks, and
+     * returns a predicted message.
+     * @param messages A list of messages for the prediction.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns A predicted message based on the list of messages.
+     */
     async predictMessages(messages, options, callbacks) {
         const text = (0, base_js_1.getBufferString)(messages);
         const prediction = await this.call(text, options, callbacks);

package/dist/llms/base.d.ts

@@ -23,10 +23,26 @@ export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = B
     lc_namespace: string[];
     cache?: BaseCache;
     constructor({ cache, concurrency, ...rest }: BaseLLMParams);
+    /**
+     * This method takes an input and options, and returns a string. It
+     * converts the input to a prompt value and generates a result based on
+     * the prompt.
+     * @param input Input for the LLM.
+     * @param options Options for the LLM call.
+     * @returns A string result based on the prompt.
+     */
     invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;
     _streamResponseChunks(_input: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
     protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
     _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;
+    /**
+     * This method takes prompt values, options, and callbacks, and generates
+     * a result based on the prompts.
+     * @param promptValues Prompt values for the LLM.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns An LLMResult based on the prompts.
+     */
     generatePrompt(promptValues: BasePromptValue[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
     /**
      * Run the LLM on the given prompts and input.
@@ -47,7 +63,23 @@ export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = B
      * Convenience wrapper for {@link generate} that takes in a single string prompt and returns a single string output.
      */
     call(prompt: string, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<string>;
+    /**
+     * This method is similar to `call`, but it's used for making predictions
+     * based on the input text.
+     * @param text Input text for the prediction.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns A prediction based on the input text.
+     */
     predict(text: string, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<string>;
+    /**
+     * This method takes a list of messages, options, and callbacks, and
+     * returns a predicted message.
+     * @param messages A list of messages for the prediction.
+     * @param options Options for the LLM call.
+     * @param callbacks Callbacks for the LLM call.
+     * @returns A predicted message based on the list of messages.
+     */
     predictMessages(messages: BaseMessage[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<BaseMessage>;
     /**
      * Get the identifying parameters of the LLM.