langchain 0.0.212 → 0.0.214

package/dist/agents/openai_functions/output_parser.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIFunctionsAgentOutputParser = 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 modelWithFunctions = new ChatOpenAI({
+ *   modelName: "gpt-4",
+ *   temperature: 0,
+ * }).bind({
+ *   functions: tools.map((tool) => formatToOpenAIFunction(tool)),
+ * });
+ *
+ * const runnableAgent = RunnableSequence.from([
+ *   {
+ *     input: (i) => i.input,
+ *     agent_scratchpad: (i) => formatAgentSteps(i.steps),
+ *   },
+ *   prompt,
+ *   modelWithFunctions,
+ *   new OpenAIFunctionsAgentOutputParser(),
+ * ]);
+ *
+ * const result = await runnableAgent.invoke({
+ *   input: "What is the weather in New York?",
+ *   steps: agentSteps,
+ * });
+ *
+ * ```
+ */
+class OpenAIFunctionsAgentOutputParser extends types_js_1.AgentActionOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "openai"]
+        });
+    }
+    static lc_name() {
+        return "OpenAIFunctionsAgentOutputParser";
+    }
+    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 FunctionsAgentAction or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A FunctionsAgentAction 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.function_call) {
+            // eslint-disable-next-line prefer-destructuring
+            const function_call = message.additional_kwargs.function_call;
+            try {
+                const toolInput = function_call.arguments
+                    ? JSON.parse(function_call.arguments)
+                    : {};
+                return {
+                    tool: function_call.name,
+                    toolInput,
+                    log: `Invoking "${function_call.name}" with ${function_call.arguments ?? "{}"}\n${message.content}`,
+                    messageLog: [message],
+                };
+            }
+            catch (error) {
+                throw new output_parser_js_1.OutputParserException(`Failed to parse function arguments from chat model response. Text: "${function_call.arguments}". ${error}`);
+            }
+        }
+        else {
+            return {
+                returnValues: { output: message.content },
+                log: message.content,
+            };
+        }
+    }
+    getFormatInstructions() {
+        throw new Error("getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.");
+    }
+}
+exports.OpenAIFunctionsAgentOutputParser = OpenAIFunctionsAgentOutputParser;

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

@@ -0,0 +1,56 @@
+import { AgentAction, AgentFinish, BaseMessage, ChatGeneration } from "../../schema/index.js";
+import { AgentActionOutputParser } from "../types.js";
+/**
+ * Type that represents an agent action with an optional message log.
+ */
+export type FunctionsAgentAction = AgentAction & {
+    messageLog?: BaseMessage[];
+};
+/**
+ * @example
+ * ```typescript
+ *
+ * const prompt = ChatPromptTemplate.fromMessages([
+ *   ["ai", "You are a helpful assistant"],
+ *   ["human", "{input}"],
+ *   new MessagesPlaceholder("agent_scratchpad"),
+ * ]);
+ *
+ * const modelWithFunctions = new ChatOpenAI({
+ *   modelName: "gpt-4",
+ *   temperature: 0,
+ * }).bind({
+ *   functions: tools.map((tool) => formatToOpenAIFunction(tool)),
+ * });
+ *
+ * const runnableAgent = RunnableSequence.from([
+ *   {
+ *     input: (i) => i.input,
+ *     agent_scratchpad: (i) => formatAgentSteps(i.steps),
+ *   },
+ *   prompt,
+ *   modelWithFunctions,
+ *   new OpenAIFunctionsAgentOutputParser(),
+ * ]);
+ *
+ * const result = await runnableAgent.invoke({
+ *   input: "What is the weather in New York?",
+ *   steps: agentSteps,
+ * });
+ *
+ * ```
+ */
+export declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {
+    lc_namespace: string[];
+    static lc_name(): string;
+    parse(text: string): Promise<AgentAction | AgentFinish>;
+    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | FunctionsAgentAction>;
+    /**
+     * Parses the output message into a FunctionsAgentAction or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A FunctionsAgentAction or AgentFinish object.
+     */
+    parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish;
+    getFormatInstructions(): string;
+}

package/dist/agents/openai_functions/output_parser.js

@@ -0,0 +1,98 @@
+import { isBaseMessage, } from "../../schema/index.js";
+import { AgentActionOutputParser } 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 modelWithFunctions = new ChatOpenAI({
+ *   modelName: "gpt-4",
+ *   temperature: 0,
+ * }).bind({
+ *   functions: tools.map((tool) => formatToOpenAIFunction(tool)),
+ * });
+ *
+ * const runnableAgent = RunnableSequence.from([
+ *   {
+ *     input: (i) => i.input,
+ *     agent_scratchpad: (i) => formatAgentSteps(i.steps),
+ *   },
+ *   prompt,
+ *   modelWithFunctions,
+ *   new OpenAIFunctionsAgentOutputParser(),
+ * ]);
+ *
+ * const result = await runnableAgent.invoke({
+ *   input: "What is the weather in New York?",
+ *   steps: agentSteps,
+ * });
+ *
+ * ```
+ */
+export class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "openai"]
+        });
+    }
+    static lc_name() {
+        return "OpenAIFunctionsAgentOutputParser";
+    }
+    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 FunctionsAgentAction or AgentFinish
+     * object.
+     * @param message The BaseMessage to parse.
+     * @returns A FunctionsAgentAction 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.function_call) {
+            // eslint-disable-next-line prefer-destructuring
+            const function_call = message.additional_kwargs.function_call;
+            try {
+                const toolInput = function_call.arguments
+                    ? JSON.parse(function_call.arguments)
+                    : {};
+                return {
+                    tool: function_call.name,
+                    toolInput,
+                    log: `Invoking "${function_call.name}" with ${function_call.arguments ?? "{}"}\n${message.content}`,
+                    messageLog: [message],
+                };
+            }
+            catch (error) {
+                throw new OutputParserException(`Failed to parse function arguments from chat model response. Text: "${function_call.arguments}". ${error}`);
+            }
+        }
+        else {
+            return {
+                returnValues: { output: message.content },
+                log: message.content,
+            };
+        }
+    }
+    getFormatInstructions() {
+        throw new Error("getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.");
+    }
+}

package/dist/agents/openai_tools/index.cjs

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAIToolsAgent = exports.OpenAIToolsAgentOutputParser = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const openai_tools_js_1 = require("../format_scratchpad/openai_tools.cjs");
+const convert_to_openai_js_1 = require("../../tools/convert_to_openai.cjs");
+const output_parser_js_1 = require("../openai/output_parser.cjs");
+Object.defineProperty(exports, "OpenAIToolsAgentOutputParser", { enumerable: true, get: function () { return output_parser_js_1.OpenAIToolsAgentOutputParser; } });
+/**
+ * Create an agent that uses OpenAI-style tool calling.
+ * @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, createOpenAIToolsAgent } 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!
+ * // If you want to see the prompt in full, you can at:
+ * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent
+ * const prompt = await pull<ChatPromptTemplate>(
+ *   "hwchase17/openai-tools-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ *   modelName: "gpt-3.5-turbo-1106",
+ * });
+ *
+ * const agent = await createOpenAIToolsAgent({
+ *   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 createOpenAIToolsAgent({ llm, tools, prompt, }) {
+    if (!prompt.inputVariables.includes("agent_scratchpad")) {
+        throw new Error([
+            `Prompt must have an input variable named "agent_scratchpad".`,
+            `Found ${JSON.stringify(prompt.inputVariables)} instead.`,
+        ].join("\n"));
+    }
+    const modelWithTools = llm.bind({ tools: tools.map(convert_to_openai_js_1.formatToOpenAITool) });
+    const agent = runnables_1.RunnableSequence.from([
+        runnables_1.RunnablePassthrough.assign({
+            agent_scratchpad: (input) => (0, openai_tools_js_1.formatToOpenAIToolMessages)(input.steps),
+        }),
+        prompt,
+        modelWithTools,
+        new output_parser_js_1.OpenAIToolsAgentOutputParser(),
+    ]);
+    return agent;
+}
+exports.createOpenAIToolsAgent = createOpenAIToolsAgent;

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

@@ -0,0 +1,82 @@
+import type { StructuredToolInterface } from "@langchain/core/tools";
+import type { BaseChatModel, BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { RunnableSequence } from "@langchain/core/runnables";
+import { OpenAIClient } from "@langchain/openai";
+import { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from "../openai/output_parser.js";
+export { OpenAIToolsAgentOutputParser, type ToolsAgentStep };
+/**
+ * Params used by the createOpenAIToolsAgent function.
+ */
+export type CreateOpenAIToolsAgentParams = {
+    /**
+     * LLM to use as the agent. Should work with OpenAI tool calling,
+     * so must either be an OpenAI model that supports that or a wrapper of
+     * a different model that adds in equivalent support.
+     */
+    llm: BaseChatModel<BaseChatModelCallOptions & {
+        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[];
+        tool_choice?: OpenAIClient.ChatCompletionToolChoiceOption;
+    }>;
+    /** Tools this agent has access to. */
+    tools: StructuredToolInterface[];
+    /** The prompt to use, must have an input key of `agent_scratchpad`. */
+    prompt: ChatPromptTemplate;
+};
+/**
+ * Create an agent that uses OpenAI-style tool calling.
+ * @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, createOpenAIToolsAgent } 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!
+ * // If you want to see the prompt in full, you can at:
+ * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent
+ * const prompt = await pull<ChatPromptTemplate>(
+ *   "hwchase17/openai-tools-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ *   modelName: "gpt-3.5-turbo-1106",
+ * });
+ *
+ * const agent = await createOpenAIToolsAgent({
+ *   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 createOpenAIToolsAgent({ llm, tools, prompt, }: CreateOpenAIToolsAgentParams): Promise<RunnableSequence<Record<string, unknown>, import("@langchain/core/agents").AgentFinish | import("@langchain/core/agents").AgentAction[]>>;

package/dist/agents/openai_tools/index.js

@@ -0,0 +1,79 @@
+import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
+import { formatToOpenAIToolMessages } from "../format_scratchpad/openai_tools.js";
+import { formatToOpenAITool } from "../../tools/convert_to_openai.js";
+import { OpenAIToolsAgentOutputParser, } from "../openai/output_parser.js";
+export { OpenAIToolsAgentOutputParser };
+/**
+ * Create an agent that uses OpenAI-style tool calling.
+ * @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, createOpenAIToolsAgent } 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!
+ * // If you want to see the prompt in full, you can at:
+ * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent
+ * const prompt = await pull<ChatPromptTemplate>(
+ *   "hwchase17/openai-tools-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ *   modelName: "gpt-3.5-turbo-1106",
+ * });
+ *
+ * const agent = await createOpenAIToolsAgent({
+ *   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 async function createOpenAIToolsAgent({ llm, tools, prompt, }) {
+    if (!prompt.inputVariables.includes("agent_scratchpad")) {
+        throw new Error([
+            `Prompt must have an input variable named "agent_scratchpad".`,
+            `Found ${JSON.stringify(prompt.inputVariables)} instead.`,
+        ].join("\n"));
+    }
+    const modelWithTools = llm.bind({ tools: tools.map(formatToOpenAITool) });
+    const agent = RunnableSequence.from([
+        RunnablePassthrough.assign({
+            agent_scratchpad: (input) => formatToOpenAIToolMessages(input.steps),
+        }),
+        prompt,
+        modelWithTools,
+        new OpenAIToolsAgentOutputParser(),
+    ]);
+    return agent;
+}

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;
+}