langchain 0.0.211 → 0.0.213

package/dist/agents/openai_tools/output_parser.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIToolsAgentOutputParser = void 0;
+const index_js_1 = require("../../schema/index.cjs");
+const types_js_1 = require("../types.cjs");
+const output_parser_js_1 = require("../../schema/output_parser.cjs");
+/**
+ * @example
+ * ```typescript
+ *
+ * const prompt = ChatPromptTemplate.fromMessages([
+ *   ["ai", "You are a helpful assistant"],
+ *   ["human", "{input}"],
+ *   new MessagesPlaceholder("agent_scratchpad"),
+ * ]);
+ *
+ * const runnableAgent = RunnableSequence.from([
+ *   {
+ *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,
+ *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>
+ *       formatToOpenAIToolMessages(i.steps),
+ *   },
+ *   prompt,
+ *   new ChatOpenAI({
+ *     modelName: "gpt-3.5-turbo-1106",
+ *     temperature: 0,
+ *   }).bind({ tools: tools.map(formatToOpenAITool) }),
+ *   new OpenAIToolsAgentOutputParser(),
+ * ]).withConfig({ runName: "OpenAIToolsAgent" });
+ *
+ * const result = await runnableAgent.invoke({
+ *   input:
+ *     "What is the sum of the current temperature in San Francisco, New York, and Tokyo?",
+ * });
+ *
+ * ```
+ */
+class OpenAIToolsAgentOutputParser extends types_js_1.AgentMultiActionOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "openai"]
+        });
+    }
+    static lc_name() {
+        return "OpenAIToolsAgentOutputParser";
+    }
+    async parse(text) {
+        throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
+    }
+    async parseResult(generations) {
+        if ("message" in generations[0] && (0, index_js_1.isBaseMessage)(generations[0].message)) {
+            return this.parseAIMessage(generations[0].message);
+        }
+        throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
+    }
+    /**
+     * Parses the output message into a ToolsAgentAction[] or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A ToolsAgentAction[] or AgentFinish object.
+     */
+    parseAIMessage(message) {
+        if (message.content && typeof message.content !== "string") {
+            throw new Error("This agent cannot parse non-string model responses.");
+        }
+        if (message.additional_kwargs.tool_calls) {
+            const toolCalls = message.additional_kwargs.tool_calls;
+            try {
+                return toolCalls.map((toolCall, i) => {
+                    const toolInput = toolCall.function.arguments
+                        ? JSON.parse(toolCall.function.arguments)
+                        : {};
+                    const messageLog = i === 0 ? [message] : [];
+                    return {
+                        tool: toolCall.function.name,
+                        toolInput,
+                        toolCallId: toolCall.id,
+                        log: `Invoking "${toolCall.function.name}" with ${toolCall.function.arguments ?? "{}"}\n${message.content}`,
+                        messageLog,
+                    };
+                });
+            }
+            catch (error) {
+                throw new output_parser_js_1.OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${error}`);
+            }
+        }
+        else {
+            return {
+                returnValues: { output: message.content },
+                log: message.content,
+            };
+        }
+    }
+    getFormatInstructions() {
+        throw new Error("getFormatInstructions not implemented inside OpenAIToolsAgentOutputParser.");
+    }
+}
+exports.OpenAIToolsAgentOutputParser = OpenAIToolsAgentOutputParser;

package/dist/agents/openai_tools/output_parser.d.ts

@@ -0,0 +1,57 @@
+import { AgentAction, AgentFinish, AgentStep, BaseMessage, ChatGeneration } from "../../schema/index.js";
+import { AgentMultiActionOutputParser } from "../types.js";
+/**
+ * Type that represents an agent action with an optional message log.
+ */
+export type ToolsAgentAction = AgentAction & {
+    toolCallId: string;
+    messageLog?: BaseMessage[];
+};
+export type ToolsAgentStep = AgentStep & {
+    action: ToolsAgentAction;
+};
+/**
+ * @example
+ * ```typescript
+ *
+ * const prompt = ChatPromptTemplate.fromMessages([
+ *   ["ai", "You are a helpful assistant"],
+ *   ["human", "{input}"],
+ *   new MessagesPlaceholder("agent_scratchpad"),
+ * ]);
+ *
+ * const runnableAgent = RunnableSequence.from([
+ *   {
+ *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,
+ *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>
+ *       formatToOpenAIToolMessages(i.steps),
+ *   },
+ *   prompt,
+ *   new ChatOpenAI({
+ *     modelName: "gpt-3.5-turbo-1106",
+ *     temperature: 0,
+ *   }).bind({ tools: tools.map(formatToOpenAITool) }),
+ *   new OpenAIToolsAgentOutputParser(),
+ * ]).withConfig({ runName: "OpenAIToolsAgent" });
+ *
+ * const result = await runnableAgent.invoke({
+ *   input:
+ *     "What is the sum of the current temperature in San Francisco, New York, and Tokyo?",
+ * });
+ *
+ * ```
+ */
+export declare class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser {
+    lc_namespace: string[];
+    static lc_name(): string;
+    parse(text: string): Promise<AgentAction[] | AgentFinish>;
+    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | ToolsAgentAction[]>;
+    /**
+     * Parses the output message into a ToolsAgentAction[] or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A ToolsAgentAction[] or AgentFinish object.
+     */
+    parseAIMessage(message: BaseMessage): ToolsAgentAction[] | AgentFinish;
+    getFormatInstructions(): string;
+}

package/dist/agents/openai_tools/output_parser.js

@@ -0,0 +1,98 @@
+import { isBaseMessage, } from "../../schema/index.js";
+import { AgentMultiActionOutputParser } from "../types.js";
+import { OutputParserException } from "../../schema/output_parser.js";
+/**
+ * @example
+ * ```typescript
+ *
+ * const prompt = ChatPromptTemplate.fromMessages([
+ *   ["ai", "You are a helpful assistant"],
+ *   ["human", "{input}"],
+ *   new MessagesPlaceholder("agent_scratchpad"),
+ * ]);
+ *
+ * const runnableAgent = RunnableSequence.from([
+ *   {
+ *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,
+ *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>
+ *       formatToOpenAIToolMessages(i.steps),
+ *   },
+ *   prompt,
+ *   new ChatOpenAI({
+ *     modelName: "gpt-3.5-turbo-1106",
+ *     temperature: 0,
+ *   }).bind({ tools: tools.map(formatToOpenAITool) }),
+ *   new OpenAIToolsAgentOutputParser(),
+ * ]).withConfig({ runName: "OpenAIToolsAgent" });
+ *
+ * const result = await runnableAgent.invoke({
+ *   input:
+ *     "What is the sum of the current temperature in San Francisco, New York, and Tokyo?",
+ * });
+ *
+ * ```
+ */
+export class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "openai"]
+        });
+    }
+    static lc_name() {
+        return "OpenAIToolsAgentOutputParser";
+    }
+    async parse(text) {
+        throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
+    }
+    async parseResult(generations) {
+        if ("message" in generations[0] && isBaseMessage(generations[0].message)) {
+            return this.parseAIMessage(generations[0].message);
+        }
+        throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
+    }
+    /**
+     * Parses the output message into a ToolsAgentAction[] or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A ToolsAgentAction[] or AgentFinish object.
+     */
+    parseAIMessage(message) {
+        if (message.content && typeof message.content !== "string") {
+            throw new Error("This agent cannot parse non-string model responses.");
+        }
+        if (message.additional_kwargs.tool_calls) {
+            const toolCalls = message.additional_kwargs.tool_calls;
+            try {
+                return toolCalls.map((toolCall, i) => {
+                    const toolInput = toolCall.function.arguments
+                        ? JSON.parse(toolCall.function.arguments)
+                        : {};
+                    const messageLog = i === 0 ? [message] : [];
+                    return {
+                        tool: toolCall.function.name,
+                        toolInput,
+                        toolCallId: toolCall.id,
+                        log: `Invoking "${toolCall.function.name}" with ${toolCall.function.arguments ?? "{}"}\n${message.content}`,
+                        messageLog,
+                    };
+                });
+            }
+            catch (error) {
+                throw new OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${error}`);
+            }
+        }
+        else {
+            return {
+                returnValues: { output: message.content },
+                log: message.content,
+            };
+        }
+    }
+    getFormatInstructions() {
+        throw new Error("getFormatInstructions not implemented inside OpenAIToolsAgentOutputParser.");
+    }
+}

package/dist/agents/react/index.cjs

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactAgent = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const render_js_1 = require("../../tools/render.cjs");
+const log_js_1 = require("../format_scratchpad/log.cjs");
+const output_parser_js_1 = require("./output_parser.cjs");
+/**
+ * Create an agent that uses ReAct prompting.
+ * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+ * @returns A runnable sequence representing an agent. It takes as input all the same input
+ *     variables as the prompt passed in does. It returns as output either an
+ *     AgentAction or AgentFinish.
+ *
+ * @example
+ * ```typescript
+ * import { AgentExecutor, createReactAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { PromptTemplate } from "@langchain/core/prompts";
+ *
+ * import { OpenAI } from "@langchain/openai";
+ *
+ * // Define the tools the agent will have access to.
+ * const tools = [...];
+ *
+ * // Get the prompt to use - you can modify this!
+ * const prompt = await pull<PromptTemplate>("hwchase17/react");
+ *
+ * const llm = new OpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createReactAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ * ```
+ */
+async function createReactAgent({ llm, tools, prompt, }) {
+    const missingVariables = ["tools", "tool_names", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
+    if (missingVariables.length > 0) {
+        throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
+    }
+    const toolNames = tools.map((tool) => tool.name);
+    const partialedPrompt = await prompt.partial({
+        tools: (0, render_js_1.renderTextDescription)(tools),
+        tool_names: toolNames.join(", "),
+    });
+    // TODO: Add .bind to core runnable interface.
+    const llmWithStop = llm.bind({
+        stop: ["\nObservation:"],
+    });
+    const agent = runnables_1.RunnableSequence.from([
+        runnables_1.RunnablePassthrough.assign({
+            agent_scratchpad: (input) => (0, log_js_1.formatLogToString)(input.steps),
+        }),
+        partialedPrompt,
+        llmWithStop,
+        new output_parser_js_1.ReActSingleInputOutputParser({
+            toolNames,
+        }),
+    ]);
+    return agent;
+}
+exports.createReactAgent = createReactAgent;

package/dist/agents/react/index.d.ts

@@ -0,0 +1,60 @@
+import type { ToolInterface } from "@langchain/core/tools";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import type { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { RunnableSequence } from "@langchain/core/runnables";
+/**
+ * Params used by the createXmlAgent function.
+ */
+export type CreateReactAgentParams = {
+    /** LLM to use for the agent. */
+    llm: BaseLanguageModelInterface;
+    /** Tools this agent has access to. */
+    tools: ToolInterface[];
+    /**
+     * The prompt to use. Must have input keys for
+     * `tools`, `tool_names`, and `agent_scratchpad`.
+     */
+    prompt: BasePromptTemplate;
+};
+/**
+ * Create an agent that uses ReAct prompting.
+ * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+ * @returns A runnable sequence representing an agent. It takes as input all the same input
+ *     variables as the prompt passed in does. It returns as output either an
+ *     AgentAction or AgentFinish.
+ *
+ * @example
+ * ```typescript
+ * import { AgentExecutor, createReactAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { PromptTemplate } from "@langchain/core/prompts";
+ *
+ * import { OpenAI } from "@langchain/openai";
+ *
+ * // Define the tools the agent will have access to.
+ * const tools = [...];
+ *
+ * // Get the prompt to use - you can modify this!
+ * const prompt = await pull<PromptTemplate>("hwchase17/react");
+ *
+ * const llm = new OpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createReactAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ * ```
+ */
+export declare function createReactAgent({ llm, tools, prompt, }: CreateReactAgentParams): Promise<RunnableSequence<Record<string, unknown>, import("@langchain/core/agents").AgentAction | import("@langchain/core/agents").AgentFinish>>;

package/dist/agents/react/index.js

@@ -0,0 +1,71 @@
+import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
+import { renderTextDescription } from "../../tools/render.js";
+import { formatLogToString } from "../format_scratchpad/log.js";
+import { ReActSingleInputOutputParser } from "./output_parser.js";
+/**
+ * Create an agent that uses ReAct prompting.
+ * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+ * @returns A runnable sequence representing an agent. It takes as input all the same input
+ *     variables as the prompt passed in does. It returns as output either an
+ *     AgentAction or AgentFinish.
+ *
+ * @example
+ * ```typescript
+ * import { AgentExecutor, createReactAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { PromptTemplate } from "@langchain/core/prompts";
+ *
+ * import { OpenAI } from "@langchain/openai";
+ *
+ * // Define the tools the agent will have access to.
+ * const tools = [...];
+ *
+ * // Get the prompt to use - you can modify this!
+ * const prompt = await pull<PromptTemplate>("hwchase17/react");
+ *
+ * const llm = new OpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createReactAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ * ```
+ */
+export async function createReactAgent({ llm, tools, prompt, }) {
+    const missingVariables = ["tools", "tool_names", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
+    if (missingVariables.length > 0) {
+        throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
+    }
+    const toolNames = tools.map((tool) => tool.name);
+    const partialedPrompt = await prompt.partial({
+        tools: renderTextDescription(tools),
+        tool_names: toolNames.join(", "),
+    });
+    // TODO: Add .bind to core runnable interface.
+    const llmWithStop = llm.bind({
+        stop: ["\nObservation:"],
+    });
+    const agent = RunnableSequence.from([
+        RunnablePassthrough.assign({
+            agent_scratchpad: (input) => formatLogToString(input.steps),
+        }),
+        partialedPrompt,
+        llmWithStop,
+        new ReActSingleInputOutputParser({
+            toolNames,
+        }),
+    ]);
+    return agent;
+}

package/dist/agents/react/output_parser.cjs

@@ -43,7 +43,6 @@ const FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = "Parsing LLM output produ
  * const result = await agent.invoke({
  *   input: "whats the weather in pomfret?",
  * });
- *
  * ```
  */
 class ReActSingleInputOutputParser extends types_js_1.AgentActionOutputParser {

package/dist/agents/react/output_parser.d.ts

@@ -37,7 +37,6 @@ import { AgentAction, AgentFinish } from "../../schema/index.js";
  * const result = await agent.invoke({
  *   input: "whats the weather in pomfret?",
  * });
- *
  * ```
  */
 export declare class ReActSingleInputOutputParser extends AgentActionOutputParser {

package/dist/agents/react/output_parser.js

@@ -40,7 +40,6 @@ const FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = "Parsing LLM output produ
  * const result = await agent.invoke({
  *   input: "whats the weather in pomfret?",
  * });
- *
  * ```
  */
 export class ReActSingleInputOutputParser extends AgentActionOutputParser {

package/dist/agents/structured_chat/index.cjs

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StructuredChatAgent = void 0;
+exports.createStructuredChatAgent = exports.StructuredChatAgent = void 0;
 const zod_to_json_schema_1 = require("zod-to-json-schema");
+const runnables_1 = require("@langchain/core/runnables");
 const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
 const prompt_js_1 = require("../../prompts/prompt.cjs");
 const chat_js_1 = require("../../prompts/chat.cjs");
 const agent_js_1 = require("../agent.cjs");
 const outputParser_js_1 = require("./outputParser.cjs");
 const prompt_js_2 = require("./prompt.cjs");
+const render_js_1 = require("../../tools/render.cjs");
+const log_js_1 = require("../format_scratchpad/log.cjs");
 /**
  * Agent that interoperates with Structured Tools using React logic.
  * @augments Agent
@@ -151,3 +154,84 @@ class StructuredChatAgent extends agent_js_1.Agent {
     }
 }
 exports.StructuredChatAgent = StructuredChatAgent;
+/**
+ * Create an agent aimed at supporting tools with multiple inputs.
+ * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+ * @returns A runnable sequence representing an agent. It takes as input all the same input
+ *     variables as the prompt passed in does. It returns as output either an
+ *     AgentAction or AgentFinish.
+ *
+ * @example
+ * ```typescript
+ * import { AgentExecutor, createStructuredChatAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { ChatPromptTemplate } from "@langchain/core/prompts";
+ * import { AIMessage, HumanMessage } from "@langchain/core/messages";
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * // Define the tools the agent will have access to.
+ * const tools = [...];
+ *
+ * // Get the prompt to use - you can modify this!
+ * const prompt = await pull<ChatPromptTemplate>(
+ *   "hwchase17/structured-chat-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ *   modelName: "gpt-3.5-turbo-1106",
+ * });
+ *
+ * const agent = await createStructuredChatAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ *
+ * // With chat history
+ * const result2 = await agentExecutor.invoke({
+ *   input: "what's my name?",
+ *   chat_history: [
+ *     new HumanMessage("hi! my name is cob"),
+ *     new AIMessage("Hello Cob! How can I assist you today?"),
+ *   ],
+ * });
+ * ```
+ */
+async function createStructuredChatAgent({ llm, tools, prompt, }) {
+    const missingVariables = ["tools", "tool_names", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
+    if (missingVariables.length > 0) {
+        throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
+    }
+    const toolNames = tools.map((tool) => tool.name);
+    const partialedPrompt = await prompt.partial({
+        tools: (0, render_js_1.renderTextDescriptionAndArgs)(tools),
+        tool_names: toolNames.join(", "),
+    });
+    // TODO: Add .bind to core runnable interface.
+    const llmWithStop = llm.bind({
+        stop: ["Observation"],
+    });
+    const agent = runnables_1.RunnableSequence.from([
+        runnables_1.RunnablePassthrough.assign({
+            agent_scratchpad: (input) => (0, log_js_1.formatLogToString)(input.steps),
+        }),
+        partialedPrompt,
+        llmWithStop,
+        outputParser_js_1.StructuredChatOutputParserWithRetries.fromLLM(llm, {
+            toolNames,
+        }),
+    ]);
+    return agent;
+}
+exports.createStructuredChatAgent = createStructuredChatAgent;

package/dist/agents/structured_chat/index.d.ts

@@ -1,5 +1,7 @@
 import type { StructuredToolInterface } from "@langchain/core/tools";
 import type { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { RunnableSequence } from "@langchain/core/runnables";
+import type { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseMessagePromptTemplate, ChatPromptTemplate } from "../../prompts/chat.js";
 import { AgentStep } from "../../schema/index.js";
 import { Optional } from "../../types/type-utils.js";
@@ -90,3 +92,72 @@ export declare class StructuredChatAgent extends Agent {
      */
     static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs & AgentArgs): StructuredChatAgent;
 }
+/**
+ * Params used by the createStructuredChatAgent function.
+ */
+export type CreateStructuredChatAgentParams = {
+    /** LLM to use as the agent. */
+    llm: BaseLanguageModelInterface;
+    /** Tools this agent has access to. */
+    tools: StructuredToolInterface[];
+    /**
+     * The prompt to use. Must have input keys for
+     * `tools`, `tool_names`, and `agent_scratchpad`.
+     */
+    prompt: BasePromptTemplate;
+};
+/**
+ * Create an agent aimed at supporting tools with multiple inputs.
+ * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+ * @returns A runnable sequence representing an agent. It takes as input all the same input
+ *     variables as the prompt passed in does. It returns as output either an
+ *     AgentAction or AgentFinish.
+ *
+ * @example
+ * ```typescript
+ * import { AgentExecutor, createStructuredChatAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { ChatPromptTemplate } from "@langchain/core/prompts";
+ * import { AIMessage, HumanMessage } from "@langchain/core/messages";
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * // Define the tools the agent will have access to.
+ * const tools = [...];
+ *
+ * // Get the prompt to use - you can modify this!
+ * const prompt = await pull<ChatPromptTemplate>(
+ *   "hwchase17/structured-chat-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ *   modelName: "gpt-3.5-turbo-1106",
+ * });
+ *
+ * const agent = await createStructuredChatAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ *
+ * // With chat history
+ * const result2 = await agentExecutor.invoke({
+ *   input: "what's my name?",
+ *   chat_history: [
+ *     new HumanMessage("hi! my name is cob"),
+ *     new AIMessage("Hello Cob! How can I assist you today?"),
+ *   ],
+ * });
+ * ```
+ */
+export declare function createStructuredChatAgent({ llm, tools, prompt, }: CreateStructuredChatAgentParams): Promise<RunnableSequence<Record<string, unknown>, import("../../schema/index.js").AgentAction | import("../../schema/index.js").AgentFinish>>;