langchain 0.0.212 → 0.0.213

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

@@ -1,111 +1,2 @@
-import { AgentAction, AgentFinish, AgentStep, BaseMessage, ChatGeneration } from "../../schema/index.js";
-import { AgentActionOutputParser, AgentMultiActionOutputParser } 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;
-}
-/**
- * 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;
-}
+export * from "../openai_functions/output_parser.js";
+export * from "../openai_tools/output_parser.js";

package/dist/agents/openai/output_parser.js

@@ -1,193 +1,6 @@
-import { isBaseMessage, } from "../../schema/index.js";
-import { AgentActionOutputParser, 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 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.");
-    }
-}
-/**
- * @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.");
-    }
-}
+// console.warn([
+//   `[WARNING]: The root "langchain/agents/openai/output_parser" entrypoint is deprecated.`,
+//   `Please use either "langchain/agents/openai/output_parser" specific entrypoint instead.`
+// ].join("\n"));
+export * from "../openai_functions/output_parser.js";
+export * from "../openai_tools/output_parser.js";

package/dist/agents/{openai → openai_functions}/index.cjs

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIAgent = exports._formatIntermediateSteps = void 0;
+exports.createOpenAIFunctionsAgent = exports.OpenAIAgent = exports._formatIntermediateSteps = void 0;
+const runnables_1 = require("@langchain/core/runnables");
 const index_js_1 = require("../../schema/index.cjs");
 const agent_js_1 = require("../agent.cjs");
 const prompt_js_1 = require("./prompt.cjs");
 const chat_js_1 = require("../../prompts/chat.cjs");
 const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
-const output_parser_js_1 = require("./output_parser.cjs");
+const output_parser_js_1 = require("../openai/output_parser.cjs");
 const convert_to_openai_js_1 = require("../../tools/convert_to_openai.cjs");
+const openai_functions_js_1 = require("../format_scratchpad/openai_functions.cjs");
 /**
  * Checks if the given action is a FunctionsAgentAction.
  * @param action The action to check.
@@ -160,3 +162,77 @@ class OpenAIAgent extends agent_js_1.Agent {
     }
 }
 exports.OpenAIAgent = OpenAIAgent;
+/**
+ * Create an agent that uses OpenAI-style function 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, createOpenAIFunctionsAgent } 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/openai-functions-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createOpenAIFunctionsAgent({
+ *   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 createOpenAIFunctionsAgent({ 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 llmWithTools = llm.bind({
+        functions: tools.map(convert_to_openai_js_1.formatToOpenAIFunction),
+    });
+    const agent = runnables_1.RunnableSequence.from([
+        runnables_1.RunnablePassthrough.assign({
+            agent_scratchpad: (input) => (0, openai_functions_js_1.formatToOpenAIFunctionMessages)(input.steps),
+        }),
+        prompt,
+        llmWithTools,
+        new output_parser_js_1.OpenAIFunctionsAgentOutputParser(),
+    ]);
+    return agent;
+}
+exports.createOpenAIFunctionsAgent = createOpenAIFunctionsAgent;

package/dist/agents/{openai → openai_functions}/index.d.ts

@@ -1,11 +1,14 @@
-import type { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import type { BaseLanguageModelInterface, BaseFunctionCallOptions } from "@langchain/core/language_models/base";
 import type { StructuredToolInterface } from "@langchain/core/tools";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { RunnableSequence } from "@langchain/core/runnables";
 import { CallbackManager } from "../../callbacks/manager.js";
-import { BasePromptTemplate } from "../../prompts/base.js";
+import type { BasePromptTemplate } from "../../prompts/base.js";
 import { AgentAction, AgentFinish, AgentStep, BaseMessage, ChainValues, SystemMessage } from "../../schema/index.js";
 import { Agent, AgentArgs } from "../agent.js";
 import { AgentInput } from "../types.js";
-import { OpenAIFunctionsAgentOutputParser } from "./output_parser.js";
+import { ChatPromptTemplate } from "../../prompts/chat.js";
+import { OpenAIFunctionsAgentOutputParser } from "../openai/output_parser.js";
 export declare function _formatIntermediateSteps(intermediateSteps: AgentStep[]): BaseMessage[];
 /**
  * Interface for the input data required to create an OpenAIAgent.
@@ -68,3 +71,72 @@ export declare class OpenAIAgent extends Agent {
      */
     plan(steps: Array<AgentStep>, inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;
 }
+/**
+ * Params used by the createOpenAIFunctionsAgent function.
+ */
+export type CreateOpenAIFunctionsAgentParams = {
+    /**
+     * LLM to use as the agent. Should work with OpenAI function 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<BaseFunctionCallOptions>;
+    /** Tools this agent has access to. */
+    tools: StructuredToolInterface[];
+    /** The prompt to use, must have an input key for `agent_scratchpad`. */
+    prompt: ChatPromptTemplate;
+};
+/**
+ * Create an agent that uses OpenAI-style function 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, createOpenAIFunctionsAgent } 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/openai-functions-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createOpenAIFunctionsAgent({
+ *   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 createOpenAIFunctionsAgent({ llm, tools, prompt, }: CreateOpenAIFunctionsAgentParams): Promise<RunnableSequence<Record<string, unknown>, AgentAction | AgentFinish>>;

package/dist/agents/{openai → openai_functions}/index.js

@@ -1,10 +1,12 @@
+import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { AIMessage, FunctionMessage, } from "../../schema/index.js";
 import { Agent } from "../agent.js";
 import { PREFIX } from "./prompt.js";
 import { ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, } from "../../prompts/chat.js";
 import { LLMChain } from "../../chains/llm_chain.js";
-import { OpenAIFunctionsAgentOutputParser, } from "./output_parser.js";
+import { OpenAIFunctionsAgentOutputParser, } from "../openai/output_parser.js";
 import { formatToOpenAIFunction } from "../../tools/convert_to_openai.js";
+import { formatToOpenAIFunctionMessages } from "../format_scratchpad/openai_functions.js";
 /**
  * Checks if the given action is a FunctionsAgentAction.
  * @param action The action to check.
@@ -155,3 +157,76 @@ export class OpenAIAgent extends Agent {
         return this.outputParser.parseAIMessage(message);
     }
 }
+/**
+ * Create an agent that uses OpenAI-style function 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, createOpenAIFunctionsAgent } 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/openai-functions-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createOpenAIFunctionsAgent({
+ *   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 createOpenAIFunctionsAgent({ 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 llmWithTools = llm.bind({
+        functions: tools.map(formatToOpenAIFunction),
+    });
+    const agent = RunnableSequence.from([
+        RunnablePassthrough.assign({
+            agent_scratchpad: (input) => formatToOpenAIFunctionMessages(input.steps),
+        }),
+        prompt,
+        llmWithTools,
+        new OpenAIFunctionsAgentOutputParser(),
+    ]);
+    return agent;
+}

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;