@langchain/classic 1.0.17 → 1.0.18

package/dist/agents/openai_functions/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["BaseLanguageModelInterface","BaseFunctionCallOptions","StructuredToolInterface","BaseChatModel","AgentAction","AgentFinish","AgentStep","BaseMessage","SystemMessage","ChainValues","ChatPromptTemplate","BasePromptTemplate","CallbackManager","Agent","AgentArgs","AgentRunnableSequence","AgentInput","OpenAIFunctionsAgentOutputParser","_formatIntermediateSteps","OpenAIAgentInput","OpenAIAgentCreatePromptArgs","OpenAIAgent","Omit","Pick","Promise","Array","CreateOpenAIFunctionsAgentParams","createOpenAIFunctionsAgent","llm","tools","prompt","streamRunnable"],"sources":["../../../src/agents/openai_functions/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface, BaseFunctionCallOptions } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatPromptTemplate, BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { Agent, AgentArgs, AgentRunnableSequence } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { OpenAIFunctionsAgentOutputParser } from \"../openai/output_parser.js\";\nexport declare function _formatIntermediateSteps(intermediateSteps: AgentStep[]): BaseMessage[];\n/**\n * Interface for the input data required to create an OpenAIAgent.\n */\nexport interface OpenAIAgentInput extends AgentInput {\n    tools: StructuredToolInterface[];\n}\n/**\n * Interface for the arguments required to create a prompt for an\n * OpenAIAgent.\n */\nexport interface OpenAIAgentCreatePromptArgs {\n    prefix?: string;\n    systemMessage?: SystemMessage;\n}\n/**\n * Class representing an agent for the OpenAI chat model in LangChain. It\n * extends the Agent class and provides additional functionality specific\n * to the OpenAIAgent type.\n */\nexport declare class OpenAIAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    _agentType(): \"openai-functions\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    tools: StructuredToolInterface[];\n    outputParser: OpenAIFunctionsAgentOutputParser;\n    constructor(input: Omit<OpenAIAgentInput, \"outputParser\">);\n    /**\n     * Creates a prompt for the OpenAIAgent using the provided tools and\n     * fields.\n     * @param _tools The tools to be used in the prompt.\n     * @param fields Optional fields for creating the prompt.\n     * @returns A BasePromptTemplate object representing the created prompt.\n     */\n    static createPrompt(_tools: StructuredToolInterface[], fields?: OpenAIAgentCreatePromptArgs): BasePromptTemplate;\n    /**\n     * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.\n     * @param llm The BaseLanguageModel to use.\n     * @param tools The tools to be used by the agent.\n     * @param args Optional arguments for creating the agent.\n     * @returns An instance of OpenAIAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">): OpenAIAgent;\n    /**\n     * Constructs a scratch pad from a list of agent steps.\n     * @param steps The steps to include in the scratch pad.\n     * @returns A string or a list of BaseMessages representing the constructed scratch pad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;\n    /**\n     * Plans the next action or finish state of the agent based on the\n     * provided steps, inputs, and optional callback manager.\n     * @param steps The steps to consider in planning.\n     * @param inputs The inputs to consider in planning.\n     * @param callbackManager Optional CallbackManager to use in planning.\n     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.\n     */\n    plan(steps: Array<AgentStep>, inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;\n}\n/**\n * Params used by the createOpenAIFunctionsAgent function.\n */\nexport type CreateOpenAIFunctionsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI function calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: BaseChatModel<BaseFunctionCallOptions>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[];\n    /** The prompt to use, must have an input key for `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses OpenAI-style function calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIFunctionsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-functions-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-functions-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n * });\n *\n * const agent = await createOpenAIFunctionsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIFunctionsAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, AgentAction | AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;;AAeA;AAOA;AASqBqB,UAhBJF,gBAAAA,SAAyBH,UAgBV,CAAA;EAOrBd,KAAAA,EAtBAA,uBAsBAA,EAAAA;;;;;;AAUuFS,UA1BjFS,2BAAAA,CA0BiFT;EAQlEX,MAAAA,CAAAA,EAAAA,MAAAA;EAAmCE,aAAAA,CAAAA,EAhC/CM,aAgC+CN;;;;;;;AAMtBsB,cA/BxBH,WAAAA,SAAoBR,KAAAA,CA+BIW;EASvBlB,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAANmB,YAAAA,EAAAA,MAAAA,EAAAA;EAA0BhB,UAAAA,CAAAA,CAAAA,EAAAA,kBAAAA;EAA+BG,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0BR,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAcC,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAtBmB,KAAAA,EAjChFtB,uBAiCgFsB,EAAAA;EAxClDX,YAAAA,EAQvBI,gCARuBJ;EAAK,WAAA,CAAA,KAAA,EASvBS,IATuB,CASlBH,gBATkB,EAAA,cAAA,CAAA;EA6ClCO;;;;;AAUkB;AA+D9B;EAAqDE,OAAAA,YAAAA,CAAAA,MAAAA,EArGrB1B,uBAqGqB0B,EAAAA,EAAAA,MAAAA,CAAAA,EArGeR,2BAqGfQ,CAAAA,EArG6CjB,kBAqG7CiB;EAAKC;;;;;;;EAA4Ed,OAAAA,eAAAA,CAAAA,GAAAA,EA7FtGf,0BA6FsGe,EAAAA,KAAAA,EA7FnEb,uBA6FmEa,EAAAA,EAAAA,IAAAA,CAAAA,EA7FjCK,2BA6FiCL,GA7FHQ,IA6FGR,CA7FED,SA6FFC,EAAAA,WAAAA,CAAAA,CAAAA,EA7F4BM,WA6F5BN;EAARS;AAAO;;;;6BAvFtGlB,cAAckB,iBAAiBjB;;;;;;;;;cAS9CkB,MAAMnB,oBAAoBG,+BAA+BG,kBAAkBY,QAAQpB,cAAcC;;;;;KAKrGqB,gCAAAA;;;;;;OAMHvB,cAAcF;;SAEZC;;UAECQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYiB,0BAAAA;;;;;GAAmED,mCAAmCF,QAAQT;SAC3HT;GACRF,cAAcC"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/openai_functions/index.ts"],"mappings":";;;;;;;;;;;;;;AA+EA;;UAAiB,gBAAA,SAAyB,UAAA;EACxC,KAAA,EAAO,uBAAA;AAAA;;;;;UAOQ,2BAAA;EACf,MAAA;EACA,aAAA,GAAgB,aAAA;AAAA;;;;;;cAQL,WAAA,SAAoB,KAAA;EAAA,OACxB,OAAA,CAAA;EAIP,YAAA;EAEA,UAAA,CAAA;EAIA,iBAAA,CAAA;EAIA,SAAA,CAAA;EAIA,KAAA,CAAA;EAIA,KAAA,EAAO,uBAAA;EAEP,YAAA,EAAc,gCAAA;EAGd,WAAA,CAAY,KAAA,EAAO,IAAA,CAAK,gBAAA;EAiCjB;;;;;;;EAAA,OArBA,YAAA,CACL,MAAA,EAAQ,uBAAA,IACR,MAAA,GAAS,2BAAA,GACR,kBAAA;EA8CA;;;;;;;EAAA,OA7BI,eAAA,CACL,GAAA,EAAK,0BAAA,EACL,KAAA,EAAO,uBAAA,IACP,IAAA,GAAO,2BAAA,GAA8B,IAAA,CAAK,SAAA,iBAAuB,WAAA;EA/DpC;;;;;EAuFzB,mBAAA,CACJ,KAAA,EAAO,SAAA,KACN,OAAA,UAAiB,WAAA;EAlFpB;;;;;;;;EA8FM,IAAA,CACJ,KAAA,EAAO,KAAA,CAAM,SAAA,GACb,MAAA,EAAQ,WAAA,EACR,eAAA,GAAkB,eAAA,GACjB,OAAA,CAAQ,WAAA,GAAc,WAAA;AAAA;;;;KAsDf,gCAAA;EAtHR;;;;;EA4HF,GAAA,EAAK,aAAA,CAAc,uBAAA,GAxGjB;EA0GF,KAAA,EAAO,uBAAA,IAzGL;EA2GF,MAAA,EAAQ,kBAAA;EA1G+B;;;;EA+GvC,cAAA;AAAA;;;;;;;;;;;;;;;;;AAfF;;;;;;;;;;;;;;;;;;;AA0EA;;;;;;;;;;;;;;;;;;;;;iBAAsB,0BAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,gCAAA,GAAgC,OAAA,CAAA,qBAAA"}

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

@@ -2,17 +2,16 @@ import { AgentInput } from "../types.js";
 import { Agent, AgentArgs, AgentRunnableSequence } from "../agent.js";
 import { OpenAIFunctionsAgentOutputParser } from "./output_parser.js";
 import "../openai/output_parser.js";
+import { BaseMessage, SystemMessage } from "@langchain/core/messages";
 import { BasePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseFunctionCallOptions, BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { CallbackManager } from "@langchain/core/callbacks/manager";
-import { BaseMessage, SystemMessage } from "@langchain/core/messages";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { AgentAction, AgentFinish, AgentStep } from "@langchain/core/agents";
 
 //#region src/agents/openai_functions/index.d.ts
-
 /**
  * Interface for the input data required to create an OpenAIAgent.
  */
@@ -83,10 +82,8 @@ type CreateOpenAIFunctionsAgentParams = {
    * 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`. */
+  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;
   /**
    * Whether to invoke the underlying model in streaming mode,

package/dist/agents/openai_functions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["BaseLanguageModelInterface","BaseFunctionCallOptions","StructuredToolInterface","BaseChatModel","AgentAction","AgentFinish","AgentStep","BaseMessage","SystemMessage","ChainValues","ChatPromptTemplate","BasePromptTemplate","CallbackManager","Agent","AgentArgs","AgentRunnableSequence","AgentInput","OpenAIFunctionsAgentOutputParser","_formatIntermediateSteps","OpenAIAgentInput","OpenAIAgentCreatePromptArgs","OpenAIAgent","Omit","Pick","Promise","Array","CreateOpenAIFunctionsAgentParams","createOpenAIFunctionsAgent","llm","tools","prompt","streamRunnable"],"sources":["../../../src/agents/openai_functions/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface, BaseFunctionCallOptions } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatPromptTemplate, BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { Agent, AgentArgs, AgentRunnableSequence } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { OpenAIFunctionsAgentOutputParser } from \"../openai/output_parser.js\";\nexport declare function _formatIntermediateSteps(intermediateSteps: AgentStep[]): BaseMessage[];\n/**\n * Interface for the input data required to create an OpenAIAgent.\n */\nexport interface OpenAIAgentInput extends AgentInput {\n    tools: StructuredToolInterface[];\n}\n/**\n * Interface for the arguments required to create a prompt for an\n * OpenAIAgent.\n */\nexport interface OpenAIAgentCreatePromptArgs {\n    prefix?: string;\n    systemMessage?: SystemMessage;\n}\n/**\n * Class representing an agent for the OpenAI chat model in LangChain. It\n * extends the Agent class and provides additional functionality specific\n * to the OpenAIAgent type.\n */\nexport declare class OpenAIAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    _agentType(): \"openai-functions\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    tools: StructuredToolInterface[];\n    outputParser: OpenAIFunctionsAgentOutputParser;\n    constructor(input: Omit<OpenAIAgentInput, \"outputParser\">);\n    /**\n     * Creates a prompt for the OpenAIAgent using the provided tools and\n     * fields.\n     * @param _tools The tools to be used in the prompt.\n     * @param fields Optional fields for creating the prompt.\n     * @returns A BasePromptTemplate object representing the created prompt.\n     */\n    static createPrompt(_tools: StructuredToolInterface[], fields?: OpenAIAgentCreatePromptArgs): BasePromptTemplate;\n    /**\n     * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.\n     * @param llm The BaseLanguageModel to use.\n     * @param tools The tools to be used by the agent.\n     * @param args Optional arguments for creating the agent.\n     * @returns An instance of OpenAIAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">): OpenAIAgent;\n    /**\n     * Constructs a scratch pad from a list of agent steps.\n     * @param steps The steps to include in the scratch pad.\n     * @returns A string or a list of BaseMessages representing the constructed scratch pad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;\n    /**\n     * Plans the next action or finish state of the agent based on the\n     * provided steps, inputs, and optional callback manager.\n     * @param steps The steps to consider in planning.\n     * @param inputs The inputs to consider in planning.\n     * @param callbackManager Optional CallbackManager to use in planning.\n     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.\n     */\n    plan(steps: Array<AgentStep>, inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;\n}\n/**\n * Params used by the createOpenAIFunctionsAgent function.\n */\nexport type CreateOpenAIFunctionsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI function calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: BaseChatModel<BaseFunctionCallOptions>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[];\n    /** The prompt to use, must have an input key for `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses OpenAI-style function calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIFunctionsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-functions-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-functions-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n * });\n *\n * const agent = await createOpenAIFunctionsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIFunctionsAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, AgentAction | AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;;;;AAeA;AAOiBoB,UAPAD,gBAAAA,SAAyBH,UAStBR,CAAAA;EAOCa,KAAAA,EAfVnB,uBAeqB,EAAA;;;;;;AAiBoCkB,UA1BnDA,2BAAAA,CA0BmDA;EAA8BT,MAAAA,CAAAA,EAAAA,MAAAA;EAQlEX,aAAAA,CAAAA,EAhCZQ,aAgCYR;;;;;;;AAM8BO,cA/BzCc,WAAAA,SAAoBR,KAAAA,CA+BqBN;EAAjBiB,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EASvBlB,YAAAA,EAAAA,MAAAA,EAAAA;EAANmB,UAAAA,CAAAA,CAAAA,EAAAA,kBAAAA;EAA0BhB,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA+BG,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0BR,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAcC,KAAAA,EAjCtGH,uBAiCsGG,EAAAA;EAAtBmB,YAAAA,EAhCzEP,gCAgCyEO;EAxClDX,WAAAA,CAAAA,KAAAA,EASlBS,IATkBT,CASbM,gBATaN,EAAAA,cAAAA,CAAAA;EAAK;AA6C9C;;;;;AAU8B;EA+DNc,OAAAA,YAAAA,CAAAA,MAAAA,EArGQzB,uBAqGkB,EAAA,EAAA,MAAA,CAAA,EArGkBkB,2BAqGlB,CAAA,EArGgDT,kBAqGhD;EAAGiB;;;;;;;EAEpCvB,OAAAA,eAAAA,CAAAA,GAAAA,EA/FeL,0BA+FfK,EAAAA,KAAAA,EA/FkDH,uBA+FlDG,EAAAA,EAAAA,IAAAA,CAAAA,EA/FoFe,2BA+FpFf,GA/FkHkB,IA+FlHlB,CA/FuHS,SA+FvHT,EAAAA,WAAAA,CAAAA,CAAAA,EA/FiJgB,WA+FjJhB;EAFqHU;;AAAD;;;6BAvFtGT,cAAckB,iBAAiBjB;;;;;;;;;cAS9CkB,MAAMnB,oBAAoBG,+BAA+BG,kBAAkBY,QAAQpB,cAAcC;;;;;KAKrGqB,gCAAAA;;;;;;OAMHvB,cAAcF;;SAEZC;;UAECQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYiB,0BAAAA;;;;;GAAmED,mCAAmCF,QAAQT;SAC3HT;GACRF,cAAcC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/openai_functions/index.ts"],"mappings":";;;;;;;;;;;;;;;;AA+EA;UAAiB,gBAAA,SAAyB,UAAA;EACxC,KAAA,EAAO,uBAAA;AAAA;;;;;UAOQ,2BAAA;EACf,MAAA;EACA,aAAA,GAAgB,aAAA;AAAA;;;;;;cAQL,WAAA,SAAoB,KAAA;EAAA,OACxB,OAAA,CAAA;EAIP,YAAA;EAEA,UAAA,CAAA;EAIA,iBAAA,CAAA;EAIA,SAAA,CAAA;EAIA,KAAA,CAAA;EAIA,KAAA,EAAO,uBAAA;EAEP,YAAA,EAAc,gCAAA;EAGd,WAAA,CAAY,KAAA,EAAO,IAAA,CAAK,gBAAA;EAerB;;;;;;;EAAA,OAHI,YAAA,CACL,MAAA,EAAQ,uBAAA,IACR,MAAA,GAAS,2BAAA,GACR,kBAAA;EA8CiB;;;;;;;EAAA,OA7Bb,eAAA,CACL,GAAA,EAAK,0BAAA,EACL,KAAA,EAAO,uBAAA,IACP,IAAA,GAAO,2BAAA,GAA8B,IAAA,CAAK,SAAA,iBAAuB,WAAA;EA0ChE;;;;;EAlBG,mBAAA,CACJ,KAAA,EAAO,SAAA,KACN,OAAA,UAAiB,WAAA;EApFpB;;;;;;;;EAgGM,IAAA,CACJ,KAAA,EAAO,KAAA,CAAM,SAAA,GACb,MAAA,EAAQ,WAAA,EACR,eAAA,GAAkB,eAAA,GACjB,OAAA,CAAQ,WAAA,GAAc,WAAA;AAAA;;;;KAsDf,gCAAA;EAtHA;;;;;EA4HV,GAAA,EAAK,aAAA,CAAc,uBAAA,GAxGZ;EA0GP,KAAA,EAAO,uBAAA,IAzGE;EA2GT,MAAA,EAAQ,kBAAA;EA1GC;;;;EA+GT,cAAA;AAAA;;;;;;;;;;;;;;;;;;AAfF;;;;;;;;;;;;;;;;;;;AA0EA;;;;;;;;;;;;;;;;;;;;iBAAsB,0BAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,gCAAA,GAAgC,OAAA,CAAA,qBAAA"}

package/dist/agents/openai_functions/index.js

@@ -1,12 +1,12 @@
+import { formatToOpenAIFunctionMessages } from "../format_scratchpad/openai_functions.js";
 import { Agent, AgentRunnableSequence } from "../agent.js";
 import { LLMChain } from "../../chains/llm_chain.js";
 import { PREFIX } from "./prompt.js";
 import { OpenAIFunctionsAgentOutputParser } from "./output_parser.js";
 import "../openai/output_parser.js";
-import { formatToOpenAIFunctionMessages } from "../format_scratchpad/openai_functions.js";
+import { AIMessage, FunctionMessage } from "@langchain/core/messages";
 import { ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate } from "@langchain/core/prompts";
 import { RunnablePassthrough } from "@langchain/core/runnables";
-import { AIMessage, FunctionMessage } from "@langchain/core/messages";
 import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
 
 //#region src/agents/openai_functions/index.ts
@@ -86,14 +86,12 @@ var OpenAIAgent = class OpenAIAgent extends Agent {
 	static fromLLMAndTools(llm, tools, args) {
 		OpenAIAgent.validateTools(tools);
 		if (llm._modelType() !== "base_chat_model" || llm._llmType() !== "openai") throw new Error("OpenAIAgent requires an OpenAI chat model");
-		const prompt = OpenAIAgent.createPrompt(tools, args);
-		const chain = new LLMChain({
-			prompt,
-			llm,
-			callbacks: args?.callbacks
-		});
 		return new OpenAIAgent({
-			llmChain: chain,
+			llmChain: new LLMChain({
+				prompt: OpenAIAgent.createPrompt(tools, args),
+				llm,
+				callbacks: args?.callbacks
+			}),
 			allowedTools: tools.map((t) => t.name),
 			tools
 		});
@@ -196,7 +194,7 @@ var OpenAIAgent = class OpenAIAgent extends Agent {
 async function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable }) {
 	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.bindTools ? llm.bindTools(tools) : llm.withConfig({ functions: tools.map((tool) => convertToOpenAIFunction(tool)) });
-	const agent = AgentRunnableSequence.fromRunnables([
+	return AgentRunnableSequence.fromRunnables([
 		RunnablePassthrough.assign({ agent_scratchpad: (input) => formatToOpenAIFunctionMessages(input.steps) }),
 		prompt,
 		llmWithTools,
@@ -206,7 +204,6 @@ async function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable }
 		streamRunnable,
 		singleAction: true
 	});
-	return agent;
 }
 
 //#endregion

package/dist/agents/openai_functions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["action: AgentAction | FunctionsAgentAction","observation: string","intermediateSteps: AgentStep[]","input: Omit<OpenAIAgentInput, \"outputParser\">","_tools: StructuredToolInterface[]","fields?: OpenAIAgentCreatePromptArgs","llm: BaseLanguageModelInterface","tools: StructuredToolInterface[]","args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">","steps: AgentStep[]","steps: Array<AgentStep>","inputs: ChainValues","callbackManager?: CallbackManager","newInputs: ChainValues","valuesForLLM: CallOptionsIfAvailable<typeof llm>","input: { steps: AgentStep[] }"],"sources":["../../../src/agents/openai_functions/index.ts"],"sourcesContent":["import type {\n  BaseLanguageModelInterface,\n  BaseLanguageModelInput,\n  BaseFunctionCallOptions,\n} from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { Runnable, RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { ChatOpenAI, ChatOpenAICallOptions } from \"@langchain/openai\";\nimport type {\n  AgentAction,\n  AgentFinish,\n  AgentStep,\n} from \"@langchain/core/agents\";\nimport { convertToOpenAIFunction } from \"@langchain/core/utils/function_calling\";\nimport {\n  AIMessage,\n  BaseMessage,\n  FunctionMessage,\n  SystemMessage,\n  BaseMessageChunk,\n} from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport {\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  MessagesPlaceholder,\n  SystemMessagePromptTemplate,\n  BasePromptTemplate,\n} from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { Agent, AgentArgs, AgentRunnableSequence } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { PREFIX } from \"./prompt.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport {\n  FunctionsAgentAction,\n  OpenAIFunctionsAgentOutputParser,\n} from \"../openai/output_parser.js\";\nimport { formatToOpenAIFunctionMessages } from \"../format_scratchpad/openai_functions.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CallOptionsIfAvailable<T> = T extends { CallOptions: infer CO } ? CO : any;\n\n/**\n * Checks if the given action is a FunctionsAgentAction.\n * @param action The action to check.\n * @returns True if the action is a FunctionsAgentAction, false otherwise.\n */\nfunction isFunctionsAgentAction(\n  action: AgentAction | FunctionsAgentAction\n): action is FunctionsAgentAction {\n  return (action as FunctionsAgentAction).messageLog !== undefined;\n}\n\nfunction _convertAgentStepToMessages(\n  action: AgentAction | FunctionsAgentAction,\n  observation: string\n) {\n  if (isFunctionsAgentAction(action) && action.messageLog !== undefined) {\n    return action.messageLog?.concat(\n      new FunctionMessage(observation, action.tool)\n    );\n  } else {\n    return [new AIMessage(action.log)];\n  }\n}\n\nexport function _formatIntermediateSteps(\n  intermediateSteps: AgentStep[]\n): BaseMessage[] {\n  return intermediateSteps.flatMap(({ action, observation }) =>\n    _convertAgentStepToMessages(action, observation)\n  );\n}\n\n/**\n * Interface for the input data required to create an OpenAIAgent.\n */\nexport interface OpenAIAgentInput extends AgentInput {\n  tools: StructuredToolInterface[];\n}\n\n/**\n * Interface for the arguments required to create a prompt for an\n * OpenAIAgent.\n */\nexport interface OpenAIAgentCreatePromptArgs {\n  prefix?: string;\n  systemMessage?: SystemMessage;\n}\n\n/**\n * Class representing an agent for the OpenAI chat model in LangChain. It\n * extends the Agent class and provides additional functionality specific\n * to the OpenAIAgent type.\n */\nexport class OpenAIAgent extends Agent {\n  static lc_name() {\n    return \"OpenAIAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  _agentType() {\n    return \"openai-functions\" as const;\n  }\n\n  observationPrefix() {\n    return \"Observation: \";\n  }\n\n  llmPrefix() {\n    return \"Thought:\";\n  }\n\n  _stop(): string[] {\n    return [\"Observation:\"];\n  }\n\n  tools: StructuredToolInterface[];\n\n  outputParser: OpenAIFunctionsAgentOutputParser =\n    new OpenAIFunctionsAgentOutputParser();\n\n  constructor(input: Omit<OpenAIAgentInput, \"outputParser\">) {\n    super({ ...input, outputParser: undefined });\n    this.tools = input.tools;\n  }\n\n  /**\n   * Creates a prompt for the OpenAIAgent using the provided tools and\n   * fields.\n   * @param _tools The tools to be used in the prompt.\n   * @param fields Optional fields for creating the prompt.\n   * @returns A BasePromptTemplate object representing the created prompt.\n   */\n  static createPrompt(\n    _tools: StructuredToolInterface[],\n    fields?: OpenAIAgentCreatePromptArgs\n  ): BasePromptTemplate {\n    const { prefix = PREFIX } = fields || {};\n    return ChatPromptTemplate.fromMessages([\n      SystemMessagePromptTemplate.fromTemplate(prefix),\n      new MessagesPlaceholder(\"chat_history\"),\n      HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n      new MessagesPlaceholder(\"agent_scratchpad\"),\n    ]);\n  }\n\n  /**\n   * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.\n   * @param llm The BaseLanguageModel to use.\n   * @param tools The tools to be used by the agent.\n   * @param args Optional arguments for creating the agent.\n   * @returns An instance of OpenAIAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: StructuredToolInterface[],\n    args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">\n  ) {\n    OpenAIAgent.validateTools(tools);\n    if (llm._modelType() !== \"base_chat_model\" || llm._llmType() !== \"openai\") {\n      throw new Error(\"OpenAIAgent requires an OpenAI chat model\");\n    }\n    const prompt = OpenAIAgent.createPrompt(tools, args);\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks,\n    });\n    return new OpenAIAgent({\n      llmChain: chain,\n      allowedTools: tools.map((t) => t.name),\n      tools,\n    });\n  }\n\n  /**\n   * Constructs a scratch pad from a list of agent steps.\n   * @param steps The steps to include in the scratch pad.\n   * @returns A string or a list of BaseMessages representing the constructed scratch pad.\n   */\n  async constructScratchPad(\n    steps: AgentStep[]\n  ): Promise<string | BaseMessage[]> {\n    return _formatIntermediateSteps(steps);\n  }\n\n  /**\n   * Plans the next action or finish state of the agent based on the\n   * provided steps, inputs, and optional callback manager.\n   * @param steps The steps to consider in planning.\n   * @param inputs The inputs to consider in planning.\n   * @param callbackManager Optional CallbackManager to use in planning.\n   * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.\n   */\n  async plan(\n    steps: Array<AgentStep>,\n    inputs: ChainValues,\n    callbackManager?: CallbackManager\n  ): Promise<AgentAction | AgentFinish> {\n    // Add scratchpad and stop to inputs\n    const thoughts = await this.constructScratchPad(steps);\n    const newInputs: ChainValues = {\n      ...inputs,\n      agent_scratchpad: thoughts,\n    };\n    if (this._stop().length !== 0) {\n      newInputs.stop = this._stop();\n    }\n\n    // Split inputs between prompt and llm\n    const llm = this.llmChain.llm as\n      | ChatOpenAI\n      | Runnable<\n          BaseLanguageModelInput,\n          BaseMessageChunk,\n          ChatOpenAICallOptions\n        >;\n\n    const valuesForPrompt = { ...newInputs };\n    const valuesForLLM: CallOptionsIfAvailable<typeof llm> = {\n      functions: this.tools.map((tool) => convertToOpenAIFunction(tool)),\n    };\n    const callKeys =\n      \"callKeys\" in this.llmChain.llm ? this.llmChain.llm.callKeys : [];\n    for (const key of callKeys) {\n      if (key in inputs) {\n        valuesForLLM[key as keyof CallOptionsIfAvailable<typeof llm>] =\n          inputs[key];\n        delete valuesForPrompt[key];\n      }\n    }\n\n    const promptValue =\n      await this.llmChain.prompt.formatPromptValue(valuesForPrompt);\n\n    const message = await (\n      llm as Runnable<\n        BaseLanguageModelInput,\n        BaseMessageChunk,\n        ChatOpenAICallOptions\n      >\n    ).invoke(promptValue.toChatMessages(), {\n      ...valuesForLLM,\n      callbacks: callbackManager,\n    });\n    return this.outputParser.parseAIMessage(message);\n  }\n}\n\n/**\n * Params used by the createOpenAIFunctionsAgent function.\n */\nexport type CreateOpenAIFunctionsAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI function calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: BaseChatModel<BaseFunctionCallOptions>;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[];\n  /** The prompt to use, must have an input key for `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses OpenAI-style function calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIFunctionsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-functions-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-functions-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n * });\n *\n * const agent = await createOpenAIFunctionsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport async function createOpenAIFunctionsAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateOpenAIFunctionsAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  const llmWithTools = llm.bindTools\n    ? llm.bindTools(tools)\n    : llm.withConfig({\n        functions: tools.map((tool) => convertToOpenAIFunction(tool)),\n      });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: AgentStep[] }) =>\n          formatToOpenAIFunctionMessages(input.steps),\n      }),\n      prompt,\n      llmWithTools,\n      new OpenAIFunctionsAgentOutputParser(),\n    ],\n    {\n      name: \"OpenAIFunctionsAgent\",\n      streamRunnable,\n      singleAction: true,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiDA,SAAS,uBACPA,QACgC;AAChC,QAAQ,OAAgC,eAAe;AACxD;AAED,SAAS,4BACPA,QACAC,aACA;AACA,KAAI,uBAAuB,OAAO,IAAI,OAAO,eAAe,OAC1D,QAAO,OAAO,YAAY,OACxB,IAAI,gBAAgB,aAAa,OAAO,MACzC;KAED,QAAO,CAAC,IAAI,UAAU,OAAO,IAAK;AAErC;AAED,SAAgB,yBACdC,mBACe;AACf,QAAO,kBAAkB,QAAQ,CAAC,EAAE,QAAQ,aAAa,KACvD,4BAA4B,QAAQ,YAAY,CACjD;AACF;;;;;;AAuBD,IAAa,cAAb,MAAa,oBAAoB,MAAM;CACrC,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAa;EAAU;CAAS;CAEhD,aAAa;AACX,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO;CACR;CAED,YAAY;AACV,SAAO;CACR;CAED,QAAkB;AAChB,SAAO,CAAC,cAAe;CACxB;CAED;CAEA,eACE,IAAI;CAEN,YAAYC,OAA+C;EACzD,MAAM;GAAE,GAAG;GAAO,cAAc;EAAW,EAAC;EAC5C,KAAK,QAAQ,MAAM;CACpB;;;;;;;;CASD,OAAO,aACLC,QACAC,QACoB;EACpB,MAAM,EAAE,SAAS,QAAQ,GAAG,UAAU,CAAE;AACxC,SAAO,mBAAmB,aAAa;GACrC,4BAA4B,aAAa,OAAO;GAChD,IAAI,oBAAoB;GACxB,2BAA2B,aAAa,UAAU;GAClD,IAAI,oBAAoB;EACzB,EAAC;CACH;;;;;;;;CASD,OAAO,gBACLC,KACAC,OACAC,MACA;EACA,YAAY,cAAc,MAAM;AAChC,MAAI,IAAI,YAAY,KAAK,qBAAqB,IAAI,UAAU,KAAK,SAC/D,OAAM,IAAI,MAAM;EAElB,MAAM,SAAS,YAAY,aAAa,OAAO,KAAK;EACpD,MAAM,QAAQ,IAAI,SAAS;GACzB;GACA;GACA,WAAW,MAAM;EAClB;AACD,SAAO,IAAI,YAAY;GACrB,UAAU;GACV,cAAc,MAAM,IAAI,CAAC,MAAM,EAAE,KAAK;GACtC;EACD;CACF;;;;;;CAOD,MAAM,oBACJC,OACiC;AACjC,SAAO,yBAAyB,MAAM;CACvC;;;;;;;;;CAUD,MAAM,KACJC,OACAC,QACAC,iBACoC;EAEpC,MAAM,WAAW,MAAM,KAAK,oBAAoB,MAAM;EACtD,MAAMC,YAAyB;GAC7B,GAAG;GACH,kBAAkB;EACnB;AACD,MAAI,KAAK,OAAO,CAAC,WAAW,GAC1B,UAAU,OAAO,KAAK,OAAO;EAI/B,MAAM,MAAM,KAAK,SAAS;EAQ1B,MAAM,kBAAkB,EAAE,GAAG,UAAW;EACxC,MAAMC,eAAmD,EACvD,WAAW,KAAK,MAAM,IAAI,CAAC,SAAS,wBAAwB,KAAK,CAAC,CACnE;EACD,MAAM,WACJ,cAAc,KAAK,SAAS,MAAM,KAAK,SAAS,IAAI,WAAW,CAAE;AACnE,OAAK,MAAM,OAAO,SAChB,KAAI,OAAO,QAAQ;GACjB,aAAa,OACX,OAAO;GACT,OAAO,gBAAgB;EACxB;EAGH,MAAM,cACJ,MAAM,KAAK,SAAS,OAAO,kBAAkB,gBAAgB;EAE/D,MAAM,UAAU,MACd,IAKA,OAAO,YAAY,gBAAgB,EAAE;GACrC,GAAG;GACH,WAAW;EACZ,EAAC;AACF,SAAO,KAAK,aAAa,eAAe,QAAQ;CACjD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+ED,eAAsB,2BAA2B,EAC/C,KACA,OACA,QACA,gBACiC,EAAE;AACnC,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,CAAC,4DAA4D,CAAC,EAC9D,CAAC,MAAM,EAAE,KAAK,UAAU,OAAO,eAAe,CAAC,SAAS,CAAC,AAC1D,EAAC,KAAK,KAAK;CAGhB,MAAM,eAAe,IAAI,YACrB,IAAI,UAAU,MAAM,GACpB,IAAI,WAAW,EACb,WAAW,MAAM,IAAI,CAAC,SAAS,wBAAwB,KAAK,CAAC,CAC9D,EAAC;CACN,MAAM,QAAQ,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,kBAAkB,CAACC,UACjB,+BAA+B,MAAM,MAAM,CAC9C,EAAC;EACF;EACA;EACA,IAAI;CACL,GACD;EACE,MAAM;EACN;EACA,cAAc;CACf,EACF;AACD,QAAO;AACR"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/agents/openai_functions/index.ts"],"sourcesContent":["import type {\n  BaseLanguageModelInterface,\n  BaseLanguageModelInput,\n  BaseFunctionCallOptions,\n} from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { Runnable, RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { ChatOpenAI, ChatOpenAICallOptions } from \"@langchain/openai\";\nimport type {\n  AgentAction,\n  AgentFinish,\n  AgentStep,\n} from \"@langchain/core/agents\";\nimport { convertToOpenAIFunction } from \"@langchain/core/utils/function_calling\";\nimport {\n  AIMessage,\n  BaseMessage,\n  FunctionMessage,\n  SystemMessage,\n  BaseMessageChunk,\n} from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport {\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  MessagesPlaceholder,\n  SystemMessagePromptTemplate,\n  BasePromptTemplate,\n} from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { Agent, AgentArgs, AgentRunnableSequence } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { PREFIX } from \"./prompt.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport {\n  FunctionsAgentAction,\n  OpenAIFunctionsAgentOutputParser,\n} from \"../openai/output_parser.js\";\nimport { formatToOpenAIFunctionMessages } from \"../format_scratchpad/openai_functions.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CallOptionsIfAvailable<T> = T extends { CallOptions: infer CO } ? CO : any;\n\n/**\n * Checks if the given action is a FunctionsAgentAction.\n * @param action The action to check.\n * @returns True if the action is a FunctionsAgentAction, false otherwise.\n */\nfunction isFunctionsAgentAction(\n  action: AgentAction | FunctionsAgentAction\n): action is FunctionsAgentAction {\n  return (action as FunctionsAgentAction).messageLog !== undefined;\n}\n\nfunction _convertAgentStepToMessages(\n  action: AgentAction | FunctionsAgentAction,\n  observation: string\n) {\n  if (isFunctionsAgentAction(action) && action.messageLog !== undefined) {\n    return action.messageLog?.concat(\n      new FunctionMessage(observation, action.tool)\n    );\n  } else {\n    return [new AIMessage(action.log)];\n  }\n}\n\nexport function _formatIntermediateSteps(\n  intermediateSteps: AgentStep[]\n): BaseMessage[] {\n  return intermediateSteps.flatMap(({ action, observation }) =>\n    _convertAgentStepToMessages(action, observation)\n  );\n}\n\n/**\n * Interface for the input data required to create an OpenAIAgent.\n */\nexport interface OpenAIAgentInput extends AgentInput {\n  tools: StructuredToolInterface[];\n}\n\n/**\n * Interface for the arguments required to create a prompt for an\n * OpenAIAgent.\n */\nexport interface OpenAIAgentCreatePromptArgs {\n  prefix?: string;\n  systemMessage?: SystemMessage;\n}\n\n/**\n * Class representing an agent for the OpenAI chat model in LangChain. It\n * extends the Agent class and provides additional functionality specific\n * to the OpenAIAgent type.\n */\nexport class OpenAIAgent extends Agent {\n  static lc_name() {\n    return \"OpenAIAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  _agentType() {\n    return \"openai-functions\" as const;\n  }\n\n  observationPrefix() {\n    return \"Observation: \";\n  }\n\n  llmPrefix() {\n    return \"Thought:\";\n  }\n\n  _stop(): string[] {\n    return [\"Observation:\"];\n  }\n\n  tools: StructuredToolInterface[];\n\n  outputParser: OpenAIFunctionsAgentOutputParser =\n    new OpenAIFunctionsAgentOutputParser();\n\n  constructor(input: Omit<OpenAIAgentInput, \"outputParser\">) {\n    super({ ...input, outputParser: undefined });\n    this.tools = input.tools;\n  }\n\n  /**\n   * Creates a prompt for the OpenAIAgent using the provided tools and\n   * fields.\n   * @param _tools The tools to be used in the prompt.\n   * @param fields Optional fields for creating the prompt.\n   * @returns A BasePromptTemplate object representing the created prompt.\n   */\n  static createPrompt(\n    _tools: StructuredToolInterface[],\n    fields?: OpenAIAgentCreatePromptArgs\n  ): BasePromptTemplate {\n    const { prefix = PREFIX } = fields || {};\n    return ChatPromptTemplate.fromMessages([\n      SystemMessagePromptTemplate.fromTemplate(prefix),\n      new MessagesPlaceholder(\"chat_history\"),\n      HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n      new MessagesPlaceholder(\"agent_scratchpad\"),\n    ]);\n  }\n\n  /**\n   * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.\n   * @param llm The BaseLanguageModel to use.\n   * @param tools The tools to be used by the agent.\n   * @param args Optional arguments for creating the agent.\n   * @returns An instance of OpenAIAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: StructuredToolInterface[],\n    args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">\n  ) {\n    OpenAIAgent.validateTools(tools);\n    if (llm._modelType() !== \"base_chat_model\" || llm._llmType() !== \"openai\") {\n      throw new Error(\"OpenAIAgent requires an OpenAI chat model\");\n    }\n    const prompt = OpenAIAgent.createPrompt(tools, args);\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks,\n    });\n    return new OpenAIAgent({\n      llmChain: chain,\n      allowedTools: tools.map((t) => t.name),\n      tools,\n    });\n  }\n\n  /**\n   * Constructs a scratch pad from a list of agent steps.\n   * @param steps The steps to include in the scratch pad.\n   * @returns A string or a list of BaseMessages representing the constructed scratch pad.\n   */\n  async constructScratchPad(\n    steps: AgentStep[]\n  ): Promise<string | BaseMessage[]> {\n    return _formatIntermediateSteps(steps);\n  }\n\n  /**\n   * Plans the next action or finish state of the agent based on the\n   * provided steps, inputs, and optional callback manager.\n   * @param steps The steps to consider in planning.\n   * @param inputs The inputs to consider in planning.\n   * @param callbackManager Optional CallbackManager to use in planning.\n   * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.\n   */\n  async plan(\n    steps: Array<AgentStep>,\n    inputs: ChainValues,\n    callbackManager?: CallbackManager\n  ): Promise<AgentAction | AgentFinish> {\n    // Add scratchpad and stop to inputs\n    const thoughts = await this.constructScratchPad(steps);\n    const newInputs: ChainValues = {\n      ...inputs,\n      agent_scratchpad: thoughts,\n    };\n    if (this._stop().length !== 0) {\n      newInputs.stop = this._stop();\n    }\n\n    // Split inputs between prompt and llm\n    const llm = this.llmChain.llm as\n      | ChatOpenAI\n      | Runnable<\n          BaseLanguageModelInput,\n          BaseMessageChunk,\n          ChatOpenAICallOptions\n        >;\n\n    const valuesForPrompt = { ...newInputs };\n    const valuesForLLM: CallOptionsIfAvailable<typeof llm> = {\n      functions: this.tools.map((tool) => convertToOpenAIFunction(tool)),\n    };\n    const callKeys =\n      \"callKeys\" in this.llmChain.llm ? this.llmChain.llm.callKeys : [];\n    for (const key of callKeys) {\n      if (key in inputs) {\n        valuesForLLM[key as keyof CallOptionsIfAvailable<typeof llm>] =\n          inputs[key];\n        delete valuesForPrompt[key];\n      }\n    }\n\n    const promptValue =\n      await this.llmChain.prompt.formatPromptValue(valuesForPrompt);\n\n    const message = await (\n      llm as Runnable<\n        BaseLanguageModelInput,\n        BaseMessageChunk,\n        ChatOpenAICallOptions\n      >\n    ).invoke(promptValue.toChatMessages(), {\n      ...valuesForLLM,\n      callbacks: callbackManager,\n    });\n    return this.outputParser.parseAIMessage(message);\n  }\n}\n\n/**\n * Params used by the createOpenAIFunctionsAgent function.\n */\nexport type CreateOpenAIFunctionsAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI function calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: BaseChatModel<BaseFunctionCallOptions>;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[];\n  /** The prompt to use, must have an input key for `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses OpenAI-style function calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIFunctionsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-functions-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-functions-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n * });\n *\n * const agent = await createOpenAIFunctionsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport async function createOpenAIFunctionsAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateOpenAIFunctionsAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  const llmWithTools = llm.bindTools\n    ? llm.bindTools(tools)\n    : llm.withConfig({\n        functions: tools.map((tool) => convertToOpenAIFunction(tool)),\n      });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: AgentStep[] }) =>\n          formatToOpenAIFunctionMessages(input.steps),\n      }),\n      prompt,\n      llmWithTools,\n      new OpenAIFunctionsAgentOutputParser(),\n    ],\n    {\n      name: \"OpenAIFunctionsAgent\",\n      streamRunnable,\n      singleAction: true,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiDA,SAAS,uBACP,QACgC;AAChC,QAAQ,OAAgC,eAAe;;AAGzD,SAAS,4BACP,QACA,aACA;AACA,KAAI,uBAAuB,OAAO,IAAI,OAAO,eAAe,OAC1D,QAAO,OAAO,YAAY,OACxB,IAAI,gBAAgB,aAAa,OAAO,KAAK,CAC9C;KAED,QAAO,CAAC,IAAI,UAAU,OAAO,IAAI,CAAC;;AAItC,SAAgB,yBACd,mBACe;AACf,QAAO,kBAAkB,SAAS,EAAE,QAAQ,kBAC1C,4BAA4B,QAAQ,YAAY,CACjD;;;;;;;AAwBH,IAAa,cAAb,MAAa,oBAAoB,MAAM;CACrC,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAU;EAAS;CAEhD,aAAa;AACX,SAAO;;CAGT,oBAAoB;AAClB,SAAO;;CAGT,YAAY;AACV,SAAO;;CAGT,QAAkB;AAChB,SAAO,CAAC,eAAe;;CAGzB;CAEA,eACE,IAAI,kCAAkC;CAExC,YAAY,OAA+C;AACzD,QAAM;GAAE,GAAG;GAAO,cAAc;GAAW,CAAC;AAC5C,OAAK,QAAQ,MAAM;;;;;;;;;CAUrB,OAAO,aACL,QACA,QACoB;EACpB,MAAM,EAAE,SAAS,WAAW,UAAU,EAAE;AACxC,SAAO,mBAAmB,aAAa;GACrC,4BAA4B,aAAa,OAAO;GAChD,IAAI,oBAAoB,eAAe;GACvC,2BAA2B,aAAa,UAAU;GAClD,IAAI,oBAAoB,mBAAmB;GAC5C,CAAC;;;;;;;;;CAUJ,OAAO,gBACL,KACA,OACA,MACA;AACA,cAAY,cAAc,MAAM;AAChC,MAAI,IAAI,YAAY,KAAK,qBAAqB,IAAI,UAAU,KAAK,SAC/D,OAAM,IAAI,MAAM,4CAA4C;AAQ9D,SAAO,IAAI,YAAY;GACrB,UANY,IAAI,SAAS;IACzB,QAFa,YAAY,aAAa,OAAO,KAAK;IAGlD;IACA,WAAW,MAAM;IAClB,CAAC;GAGA,cAAc,MAAM,KAAK,MAAM,EAAE,KAAK;GACtC;GACD,CAAC;;;;;;;CAQJ,MAAM,oBACJ,OACiC;AACjC,SAAO,yBAAyB,MAAM;;;;;;;;;;CAWxC,MAAM,KACJ,OACA,QACA,iBACoC;EAEpC,MAAM,WAAW,MAAM,KAAK,oBAAoB,MAAM;EACtD,MAAM,YAAyB;GAC7B,GAAG;GACH,kBAAkB;GACnB;AACD,MAAI,KAAK,OAAO,CAAC,WAAW,EAC1B,WAAU,OAAO,KAAK,OAAO;EAI/B,MAAM,MAAM,KAAK,SAAS;EAQ1B,MAAM,kBAAkB,EAAE,GAAG,WAAW;EACxC,MAAM,eAAmD,EACvD,WAAW,KAAK,MAAM,KAAK,SAAS,wBAAwB,KAAK,CAAC,EACnE;EACD,MAAM,WACJ,cAAc,KAAK,SAAS,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;AACnE,OAAK,MAAM,OAAO,SAChB,KAAI,OAAO,QAAQ;AACjB,gBAAa,OACX,OAAO;AACT,UAAO,gBAAgB;;EAI3B,MAAM,cACJ,MAAM,KAAK,SAAS,OAAO,kBAAkB,gBAAgB;EAE/D,MAAM,UAAU,MACd,IAKA,OAAO,YAAY,gBAAgB,EAAE;GACrC,GAAG;GACH,WAAW;GACZ,CAAC;AACF,SAAO,KAAK,aAAa,eAAe,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFpD,eAAsB,2BAA2B,EAC/C,KACA,OACA,QACA,kBACmC;AACnC,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,gEACA,SAAS,KAAK,UAAU,OAAO,eAAe,CAAC,WAChD,CAAC,KAAK,KAAK,CACb;CAEH,MAAM,eAAe,IAAI,YACrB,IAAI,UAAU,MAAM,GACpB,IAAI,WAAW,EACb,WAAW,MAAM,KAAK,SAAS,wBAAwB,KAAK,CAAC,EAC9D,CAAC;AAiBN,QAhBc,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,mBAAmB,UACjB,+BAA+B,MAAM,MAAM,EAC9C,CAAC;EACF;EACA;EACA,IAAI,kCAAkC;EACvC,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CACF"}

package/dist/agents/openai_functions/output_parser.cjs

@@ -1,7 +1,7 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_types = require('../types.cjs');
-const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
-const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+let _langchain_core_messages = require("@langchain/core/messages");
+let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 
 //#region src/agents/openai_functions/output_parser.ts
 /**
@@ -49,7 +49,7 @@ var OpenAIFunctionsAgentOutputParser = class extends require_types.AgentActionOu
 		throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
 	}
 	async parseResult(generations) {
-		if ("message" in generations[0] && (0, __langchain_core_messages.isBaseMessage)(generations[0].message)) return this.parseAIMessage(generations[0].message);
+		if ("message" in generations[0] && (0, _langchain_core_messages.isBaseMessage)(generations[0].message)) return this.parseAIMessage(generations[0].message);
 		throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
 	}
 	/**
@@ -71,7 +71,7 @@ var OpenAIFunctionsAgentOutputParser = class extends require_types.AgentActionOu
 					messageLog: [message]
 				};
 			} catch (error) {
-				throw new __langchain_core_output_parsers.OutputParserException(`Failed to parse function arguments from chat model response. Text: "${function_call.arguments}". ${error}`);
+				throw new _langchain_core_output_parsers.OutputParserException(`Failed to parse function arguments from chat model response. Text: "${function_call.arguments}". ${error}`);
 			}
 		} else return {
 			returnValues: { output: message.content },

package/dist/agents/openai_functions/output_parser.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"output_parser.cjs","names":["AgentActionOutputParser","text: string","generations: ChatGeneration[]","message: BaseMessage","function_call: OpenAIClient.Chat.ChatCompletionMessage.FunctionCall","OutputParserException"],"sources":["../../../src/agents/openai_functions/output_parser.ts"],"sourcesContent":["import type { OpenAIClient } from \"@langchain/openai\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage, isBaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type FunctionsAgentAction = AgentAction & {\n  messageLog?: BaseMessage[];\n};\n\n/**\n * @example\n * ```typescript\n *\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const modelWithFunctions = new ChatOpenAI({\n *   model: \"gpt-4\",\n *   temperature: 0,\n * }).bindTools(tools);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i) => i.input,\n *     agent_scratchpad: (i) => formatAgentSteps(i.steps),\n *   },\n *   prompt,\n *   modelWithFunctions,\n *   new OpenAIFunctionsAgentOutputParser(),\n * ]);\n *\n * const result = await runnableAgent.invoke({\n *   input: \"What is the weather in New York?\",\n *   steps: agentSteps,\n * });\n *\n * ```\n */\nexport class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  static lc_name() {\n    return \"OpenAIFunctionsAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    throw new Error(\n      `OpenAIFunctionsAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return this.parseAIMessage(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  /**\n   * Parses the output message into a FunctionsAgentAction or AgentFinish\n   * object.\n   * @param message The BaseMessage to parse.\n   * @returns A FunctionsAgentAction or AgentFinish object.\n   */\n  parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish {\n    if (message.content && typeof message.content !== \"string\") {\n      throw new Error(\"This agent cannot parse non-string model responses.\");\n    }\n    if (message.additional_kwargs.function_call) {\n      const function_call: OpenAIClient.Chat.ChatCompletionMessage.FunctionCall =\n        message.additional_kwargs.function_call;\n      try {\n        const toolInput = function_call.arguments\n          ? JSON.parse(function_call.arguments)\n          : {};\n        return {\n          tool: function_call.name as string,\n          toolInput,\n          log: `Invoking \"${function_call.name}\" with ${\n            function_call.arguments ?? \"{}\"\n          }\\n${message.content}`,\n          messageLog: [message],\n        };\n      } catch (error) {\n        throw new OutputParserException(\n          `Failed to parse function arguments from chat model response. Text: \"${function_call.arguments}\". ${error}`\n        );\n      }\n    } else {\n      return {\n        returnValues: { output: message.content },\n        log: message.content,\n      };\n    }\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,IAAa,mCAAb,cAAsDA,sCAAwB;CAC5E,eAAe;EAAC;EAAa;EAAU;CAAS;CAEhD,OAAO,UAAU;AACf,SAAO;CACR;CAED,MAAM,MAAMC,MAAkD;AAC5D,QAAM,IAAI,MACR,CAAC,yEAAyE,EAAE,MAAM;CAErF;CAED,MAAM,YAAYC,aAA+B;AAC/C,MAAI,aAAa,YAAY,mDAAoB,YAAY,GAAG,QAAQ,CACtE,QAAO,KAAK,eAAe,YAAY,GAAG,QAAQ;AAEpD,QAAM,IAAI,MACR;CAEH;;;;;;;CAQD,eAAeC,SAA0D;AACvE,MAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,SAChD,OAAM,IAAI,MAAM;AAElB,MAAI,QAAQ,kBAAkB,eAAe;GAC3C,MAAMC,gBACJ,QAAQ,kBAAkB;AAC5B,OAAI;IACF,MAAM,YAAY,cAAc,YAC5B,KAAK,MAAM,cAAc,UAAU,GACnC,CAAE;AACN,WAAO;KACL,MAAM,cAAc;KACpB;KACA,KAAK,CAAC,UAAU,EAAE,cAAc,KAAK,OAAO,EAC1C,cAAc,aAAa,KAC5B,EAAE,EAAE,QAAQ,SAAS;KACtB,YAAY,CAAC,OAAQ;IACtB;GACF,SAAQ,OAAO;AACd,UAAM,IAAIC,sDACR,CAAC,oEAAoE,EAAE,cAAc,UAAU,GAAG,EAAE,OAAO;GAE9G;EACF,MACC,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,QAAS;GACzC,KAAK,QAAQ;EACd;CAEJ;CAED,wBAAgC;AAC9B,QAAM,IAAI,MACR;CAEH;AACF"}
+{"version":3,"file":"output_parser.cjs","names":["AgentActionOutputParser","OutputParserException"],"sources":["../../../src/agents/openai_functions/output_parser.ts"],"sourcesContent":["import type { OpenAIClient } from \"@langchain/openai\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage, isBaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type FunctionsAgentAction = AgentAction & {\n  messageLog?: BaseMessage[];\n};\n\n/**\n * @example\n * ```typescript\n *\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const modelWithFunctions = new ChatOpenAI({\n *   model: \"gpt-4\",\n *   temperature: 0,\n * }).bindTools(tools);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i) => i.input,\n *     agent_scratchpad: (i) => formatAgentSteps(i.steps),\n *   },\n *   prompt,\n *   modelWithFunctions,\n *   new OpenAIFunctionsAgentOutputParser(),\n * ]);\n *\n * const result = await runnableAgent.invoke({\n *   input: \"What is the weather in New York?\",\n *   steps: agentSteps,\n * });\n *\n * ```\n */\nexport class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  static lc_name() {\n    return \"OpenAIFunctionsAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    throw new Error(\n      `OpenAIFunctionsAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return this.parseAIMessage(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  /**\n   * Parses the output message into a FunctionsAgentAction or AgentFinish\n   * object.\n   * @param message The BaseMessage to parse.\n   * @returns A FunctionsAgentAction or AgentFinish object.\n   */\n  parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish {\n    if (message.content && typeof message.content !== \"string\") {\n      throw new Error(\"This agent cannot parse non-string model responses.\");\n    }\n    if (message.additional_kwargs.function_call) {\n      const function_call: OpenAIClient.Chat.ChatCompletionMessage.FunctionCall =\n        message.additional_kwargs.function_call;\n      try {\n        const toolInput = function_call.arguments\n          ? JSON.parse(function_call.arguments)\n          : {};\n        return {\n          tool: function_call.name as string,\n          toolInput,\n          log: `Invoking \"${function_call.name}\" with ${\n            function_call.arguments ?? \"{}\"\n          }\\n${message.content}`,\n          messageLog: [message],\n        };\n      } catch (error) {\n        throw new OutputParserException(\n          `Failed to parse function arguments from chat model response. Text: \"${function_call.arguments}\". ${error}`\n        );\n      }\n    } else {\n      return {\n        returnValues: { output: message.content },\n        log: message.content,\n      };\n    }\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,IAAa,mCAAb,cAAsDA,sCAAwB;CAC5E,eAAe;EAAC;EAAa;EAAU;EAAS;CAEhD,OAAO,UAAU;AACf,SAAO;;CAGT,MAAM,MAAM,MAAkD;AAC5D,QAAM,IAAI,MACR,4EAA4E,OAC7E;;CAGH,MAAM,YAAY,aAA+B;AAC/C,MAAI,aAAa,YAAY,kDAAoB,YAAY,GAAG,QAAQ,CACtE,QAAO,KAAK,eAAe,YAAY,GAAG,QAAQ;AAEpD,QAAM,IAAI,MACR,sFACD;;;;;;;;CASH,eAAe,SAA0D;AACvE,MAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,SAChD,OAAM,IAAI,MAAM,sDAAsD;AAExE,MAAI,QAAQ,kBAAkB,eAAe;GAC3C,MAAM,gBACJ,QAAQ,kBAAkB;AAC5B,OAAI;IACF,MAAM,YAAY,cAAc,YAC5B,KAAK,MAAM,cAAc,UAAU,GACnC,EAAE;AACN,WAAO;KACL,MAAM,cAAc;KACpB;KACA,KAAK,aAAa,cAAc,KAAK,SACnC,cAAc,aAAa,KAC5B,IAAI,QAAQ;KACb,YAAY,CAAC,QAAQ;KACtB;YACM,OAAO;AACd,UAAM,IAAIC,qDACR,uEAAuE,cAAc,UAAU,KAAK,QACrG;;QAGH,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,SAAS;GACzC,KAAK,QAAQ;GACd;;CAIL,wBAAgC;AAC9B,QAAM,IAAI,MACR,iFACD"}

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

@@ -4,7 +4,6 @@ import { BaseMessage } from "@langchain/core/messages";
 import { ChatGeneration } from "@langchain/core/outputs";
 
 //#region src/agents/openai_functions/output_parser.d.ts
-
 /**
  * Type that represents an agent action with an optional message log.
  */

package/dist/agents/openai_functions/output_parser.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"output_parser.d.cts","names":["AgentAction","AgentFinish","BaseMessage","ChatGeneration","AgentActionOutputParser","FunctionsAgentAction","OpenAIFunctionsAgentOutputParser","Promise"],"sources":["../../../src/agents/openai_functions/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentActionOutputParser } from \"../types.js\";\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type FunctionsAgentAction = AgentAction & {\n    messageLog?: BaseMessage[];\n};\n/**\n * @example\n * ```typescript\n *\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const modelWithFunctions = new ChatOpenAI({\n *   model: \"gpt-4\",\n *   temperature: 0,\n * }).bindTools(tools);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i) => i.input,\n *     agent_scratchpad: (i) => formatAgentSteps(i.steps),\n *   },\n *   prompt,\n *   modelWithFunctions,\n *   new OpenAIFunctionsAgentOutputParser(),\n * ]);\n *\n * const result = await runnableAgent.invoke({\n *   input: \"What is the weather in New York?\",\n *   steps: agentSteps,\n * });\n *\n * ```\n */\nexport declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | FunctionsAgentAction>;\n    /**\n     * Parses the output message into a FunctionsAgentAction or AgentFinish\n     * object.\n     * @param message The BaseMessage to parse.\n     * @returns A FunctionsAgentAction or AgentFinish object.\n     */\n    parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAmCqBM,KAnCTD,oBAAAA,GAAuBL,WAmCkB,GAAA;EAGpBA,UAAAA,CAAAA,EArChBE,WAqCgBF,EAAAA;CAAcC;;;;;;;;;;AAHsC;;;;;;;;;;;;;;;;;;;;;;;cAAhEK,gCAAAA,SAAyCF,uBAAAA;;;uBAGrCG,QAAQP,cAAcC;2BAClBE,mBAAmBI,QAAQN,cAAcI;;;;;;;0BAO1CH,cAAcG,uBAAuBJ"}
+{"version":3,"file":"output_parser.d.cts","names":[],"sources":["../../../src/agents/openai_functions/output_parser.ts"],"mappings":";;;;;;;;AAUA;KAAY,oBAAA,GAAuB,WAAA;EACjC,UAAA,GAAa,WAAA;AAAA;;;;;;AAmCf;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,gCAAA,SAAyC,uBAAA;EACpD,YAAA;EAAA,OAEO,OAAA,CAAA;EAID,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,GAAc,WAAA;EAM3C,WAAA,CAAY,WAAA,EAAa,cAAA,KAAgB,OAAA,CAAA,WAAA,GAAA,oBAAA;EAehC;;;;;;EAAf,cAAA,CAAe,OAAA,EAAS,WAAA,GAAc,oBAAA,GAAuB,WAAA;EAgC7D,qBAAA,CAAA;AAAA"}

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

@@ -1,10 +1,9 @@
 import { AgentActionOutputParser } from "../types.js";
-import { ChatGeneration } from "@langchain/core/outputs";
 import { BaseMessage } from "@langchain/core/messages";
+import { ChatGeneration } from "@langchain/core/outputs";
 import { AgentAction, AgentFinish } from "@langchain/core/agents";
 
 //#region src/agents/openai_functions/output_parser.d.ts
-
 /**
  * Type that represents an agent action with an optional message log.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.d.ts","names":["AgentAction","AgentFinish","BaseMessage","ChatGeneration","AgentActionOutputParser","FunctionsAgentAction","OpenAIFunctionsAgentOutputParser","Promise"],"sources":["../../../src/agents/openai_functions/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentActionOutputParser } from \"../types.js\";\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type FunctionsAgentAction = AgentAction & {\n    messageLog?: BaseMessage[];\n};\n/**\n * @example\n * ```typescript\n *\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const modelWithFunctions = new ChatOpenAI({\n *   model: \"gpt-4\",\n *   temperature: 0,\n * }).bindTools(tools);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i) => i.input,\n *     agent_scratchpad: (i) => formatAgentSteps(i.steps),\n *   },\n *   prompt,\n *   modelWithFunctions,\n *   new OpenAIFunctionsAgentOutputParser(),\n * ]);\n *\n * const result = await runnableAgent.invoke({\n *   input: \"What is the weather in New York?\",\n *   steps: agentSteps,\n * });\n *\n * ```\n */\nexport declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | FunctionsAgentAction>;\n    /**\n     * Parses the output message into a FunctionsAgentAction or AgentFinish\n     * object.\n     * @param message The BaseMessage to parse.\n     * @returns A FunctionsAgentAction or AgentFinish object.\n     */\n    parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAmCqBM,KAnCTD,oBAAAA,GAAuBL,WAmCkB,GAAA;EAGpBA,UAAAA,CAAAA,EArChBE,WAqCgBF,EAAAA;CAAcC;;;;;;;;;;AAHsC;;;;;;;;;;;;;;;;;;;;;;;cAAhEK,gCAAAA,SAAyCF,uBAAAA;;;uBAGrCG,QAAQP,cAAcC;2BAClBE,mBAAmBI,QAAQN,cAAcI;;;;;;;0BAO1CH,cAAcG,uBAAuBJ"}
+{"version":3,"file":"output_parser.d.ts","names":[],"sources":["../../../src/agents/openai_functions/output_parser.ts"],"mappings":";;;;;;;;AAUA;KAAY,oBAAA,GAAuB,WAAA;EACjC,UAAA,GAAa,WAAA;AAAA;;;;;;AAmCf;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,gCAAA,SAAyC,uBAAA;EACpD,YAAA;EAAA,OAEO,OAAA,CAAA;EAID,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,GAAc,WAAA;EAM3C,WAAA,CAAY,WAAA,EAAa,cAAA,KAAgB,OAAA,CAAA,WAAA,GAAA,oBAAA;EAehC;;;;;;EAAf,cAAA,CAAe,OAAA,EAAS,WAAA,GAAc,oBAAA,GAAuB,WAAA;EAgC7D,qBAAA,CAAA;AAAA"}

package/dist/agents/openai_functions/output_parser.js

@@ -1,6 +1,6 @@
 import { AgentActionOutputParser } from "../types.js";
-import { OutputParserException } from "@langchain/core/output_parsers";
 import { isBaseMessage } from "@langchain/core/messages";
+import { OutputParserException } from "@langchain/core/output_parsers";
 
 //#region src/agents/openai_functions/output_parser.ts
 /**

package/dist/agents/openai_functions/output_parser.js.map

@@ -1 +1 @@
-{"version":3,"file":"output_parser.js","names":["text: string","generations: ChatGeneration[]","message: BaseMessage","function_call: OpenAIClient.Chat.ChatCompletionMessage.FunctionCall"],"sources":["../../../src/agents/openai_functions/output_parser.ts"],"sourcesContent":["import type { OpenAIClient } from \"@langchain/openai\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage, isBaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type FunctionsAgentAction = AgentAction & {\n  messageLog?: BaseMessage[];\n};\n\n/**\n * @example\n * ```typescript\n *\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const modelWithFunctions = new ChatOpenAI({\n *   model: \"gpt-4\",\n *   temperature: 0,\n * }).bindTools(tools);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i) => i.input,\n *     agent_scratchpad: (i) => formatAgentSteps(i.steps),\n *   },\n *   prompt,\n *   modelWithFunctions,\n *   new OpenAIFunctionsAgentOutputParser(),\n * ]);\n *\n * const result = await runnableAgent.invoke({\n *   input: \"What is the weather in New York?\",\n *   steps: agentSteps,\n * });\n *\n * ```\n */\nexport class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  static lc_name() {\n    return \"OpenAIFunctionsAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    throw new Error(\n      `OpenAIFunctionsAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return this.parseAIMessage(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  /**\n   * Parses the output message into a FunctionsAgentAction or AgentFinish\n   * object.\n   * @param message The BaseMessage to parse.\n   * @returns A FunctionsAgentAction or AgentFinish object.\n   */\n  parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish {\n    if (message.content && typeof message.content !== \"string\") {\n      throw new Error(\"This agent cannot parse non-string model responses.\");\n    }\n    if (message.additional_kwargs.function_call) {\n      const function_call: OpenAIClient.Chat.ChatCompletionMessage.FunctionCall =\n        message.additional_kwargs.function_call;\n      try {\n        const toolInput = function_call.arguments\n          ? JSON.parse(function_call.arguments)\n          : {};\n        return {\n          tool: function_call.name as string,\n          toolInput,\n          log: `Invoking \"${function_call.name}\" with ${\n            function_call.arguments ?? \"{}\"\n          }\\n${message.content}`,\n          messageLog: [message],\n        };\n      } catch (error) {\n        throw new OutputParserException(\n          `Failed to parse function arguments from chat model response. Text: \"${function_call.arguments}\". ${error}`\n        );\n      }\n    } else {\n      return {\n        returnValues: { output: message.content },\n        log: message.content,\n      };\n    }\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,IAAa,mCAAb,cAAsD,wBAAwB;CAC5E,eAAe;EAAC;EAAa;EAAU;CAAS;CAEhD,OAAO,UAAU;AACf,SAAO;CACR;CAED,MAAM,MAAMA,MAAkD;AAC5D,QAAM,IAAI,MACR,CAAC,yEAAyE,EAAE,MAAM;CAErF;CAED,MAAM,YAAYC,aAA+B;AAC/C,MAAI,aAAa,YAAY,MAAM,cAAc,YAAY,GAAG,QAAQ,CACtE,QAAO,KAAK,eAAe,YAAY,GAAG,QAAQ;AAEpD,QAAM,IAAI,MACR;CAEH;;;;;;;CAQD,eAAeC,SAA0D;AACvE,MAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,SAChD,OAAM,IAAI,MAAM;AAElB,MAAI,QAAQ,kBAAkB,eAAe;GAC3C,MAAMC,gBACJ,QAAQ,kBAAkB;AAC5B,OAAI;IACF,MAAM,YAAY,cAAc,YAC5B,KAAK,MAAM,cAAc,UAAU,GACnC,CAAE;AACN,WAAO;KACL,MAAM,cAAc;KACpB;KACA,KAAK,CAAC,UAAU,EAAE,cAAc,KAAK,OAAO,EAC1C,cAAc,aAAa,KAC5B,EAAE,EAAE,QAAQ,SAAS;KACtB,YAAY,CAAC,OAAQ;IACtB;GACF,SAAQ,OAAO;AACd,UAAM,IAAI,sBACR,CAAC,oEAAoE,EAAE,cAAc,UAAU,GAAG,EAAE,OAAO;GAE9G;EACF,MACC,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,QAAS;GACzC,KAAK,QAAQ;EACd;CAEJ;CAED,wBAAgC;AAC9B,QAAM,IAAI,MACR;CAEH;AACF"}
+{"version":3,"file":"output_parser.js","names":[],"sources":["../../../src/agents/openai_functions/output_parser.ts"],"sourcesContent":["import type { OpenAIClient } from \"@langchain/openai\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage, isBaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type FunctionsAgentAction = AgentAction & {\n  messageLog?: BaseMessage[];\n};\n\n/**\n * @example\n * ```typescript\n *\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const modelWithFunctions = new ChatOpenAI({\n *   model: \"gpt-4\",\n *   temperature: 0,\n * }).bindTools(tools);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i) => i.input,\n *     agent_scratchpad: (i) => formatAgentSteps(i.steps),\n *   },\n *   prompt,\n *   modelWithFunctions,\n *   new OpenAIFunctionsAgentOutputParser(),\n * ]);\n *\n * const result = await runnableAgent.invoke({\n *   input: \"What is the weather in New York?\",\n *   steps: agentSteps,\n * });\n *\n * ```\n */\nexport class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  static lc_name() {\n    return \"OpenAIFunctionsAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    throw new Error(\n      `OpenAIFunctionsAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return this.parseAIMessage(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  /**\n   * Parses the output message into a FunctionsAgentAction or AgentFinish\n   * object.\n   * @param message The BaseMessage to parse.\n   * @returns A FunctionsAgentAction or AgentFinish object.\n   */\n  parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish {\n    if (message.content && typeof message.content !== \"string\") {\n      throw new Error(\"This agent cannot parse non-string model responses.\");\n    }\n    if (message.additional_kwargs.function_call) {\n      const function_call: OpenAIClient.Chat.ChatCompletionMessage.FunctionCall =\n        message.additional_kwargs.function_call;\n      try {\n        const toolInput = function_call.arguments\n          ? JSON.parse(function_call.arguments)\n          : {};\n        return {\n          tool: function_call.name as string,\n          toolInput,\n          log: `Invoking \"${function_call.name}\" with ${\n            function_call.arguments ?? \"{}\"\n          }\\n${message.content}`,\n          messageLog: [message],\n        };\n      } catch (error) {\n        throw new OutputParserException(\n          `Failed to parse function arguments from chat model response. Text: \"${function_call.arguments}\". ${error}`\n        );\n      }\n    } else {\n      return {\n        returnValues: { output: message.content },\n        log: message.content,\n      };\n    }\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside OpenAIFunctionsAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,IAAa,mCAAb,cAAsD,wBAAwB;CAC5E,eAAe;EAAC;EAAa;EAAU;EAAS;CAEhD,OAAO,UAAU;AACf,SAAO;;CAGT,MAAM,MAAM,MAAkD;AAC5D,QAAM,IAAI,MACR,4EAA4E,OAC7E;;CAGH,MAAM,YAAY,aAA+B;AAC/C,MAAI,aAAa,YAAY,MAAM,cAAc,YAAY,GAAG,QAAQ,CACtE,QAAO,KAAK,eAAe,YAAY,GAAG,QAAQ;AAEpD,QAAM,IAAI,MACR,sFACD;;;;;;;;CASH,eAAe,SAA0D;AACvE,MAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,SAChD,OAAM,IAAI,MAAM,sDAAsD;AAExE,MAAI,QAAQ,kBAAkB,eAAe;GAC3C,MAAM,gBACJ,QAAQ,kBAAkB;AAC5B,OAAI;IACF,MAAM,YAAY,cAAc,YAC5B,KAAK,MAAM,cAAc,UAAU,GACnC,EAAE;AACN,WAAO;KACL,MAAM,cAAc;KACpB;KACA,KAAK,aAAa,cAAc,KAAK,SACnC,cAAc,aAAa,KAC5B,IAAI,QAAQ;KACb,YAAY,CAAC,QAAQ;KACtB;YACM,OAAO;AACd,UAAM,IAAI,sBACR,uEAAuE,cAAc,UAAU,KAAK,QACrG;;QAGH,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,SAAS;GACzC,KAAK,QAAQ;GACd;;CAIL,wBAAgC;AAC9B,QAAM,IAAI,MACR,iFACD"}

package/dist/agents/openai_functions/prompt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/agents/openai_functions/prompt.ts"],"sourcesContent":["export const PREFIX = `You are a helpful AI assistant.`;\nexport const SUFFIX = ``;\n"],"mappings":";;AAAA,MAAa,SAAS,CAAC,+BAA+B,CAAC"}
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/agents/openai_functions/prompt.ts"],"sourcesContent":["export const PREFIX = `You are a helpful AI assistant.`;\nexport const SUFFIX = ``;\n"],"mappings":";;AAAA,MAAa,SAAS"}

package/dist/agents/openai_functions/prompt.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/agents/openai_functions/prompt.ts"],"sourcesContent":["export const PREFIX = `You are a helpful AI assistant.`;\nexport const SUFFIX = ``;\n"],"mappings":";AAAA,MAAa,SAAS,CAAC,+BAA+B,CAAC"}
+{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/agents/openai_functions/prompt.ts"],"sourcesContent":["export const PREFIX = `You are a helpful AI assistant.`;\nexport const SUFFIX = ``;\n"],"mappings":";AAAA,MAAa,SAAS"}

package/dist/agents/openai_tools/index.cjs

@@ -1,10 +1,10 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const require_agent = require('../agent.cjs');
-const require_output_parser = require('./output_parser.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_tool_calling = require('../format_scratchpad/tool_calling.cjs');
 require('../format_scratchpad/openai_tools.cjs');
-const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
-const __langchain_core_utils_function_calling = require_rolldown_runtime.__toESM(require("@langchain/core/utils/function_calling"));
+const require_agent = require('../agent.cjs');
+const require_output_parser = require('./output_parser.cjs');
+let _langchain_core_runnables = require("@langchain/core/runnables");
+let _langchain_core_utils_function_calling = require("@langchain/core/utils/function_calling");
 
 //#region src/agents/openai_tools/index.ts
 /**
@@ -65,9 +65,9 @@ const __langchain_core_utils_function_calling = require_rolldown_runtime.__toESM
 */
 async function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }) {
 	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.bindTools ? llm.bindTools(tools) : llm.withConfig({ tools: tools.map((tool) => (0, __langchain_core_utils_function_calling.convertToOpenAITool)(tool)) });
-	const agent = require_agent.AgentRunnableSequence.fromRunnables([
-		__langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_tool_calling.formatToToolMessages(input.steps) }),
+	const modelWithTools = llm.bindTools ? llm.bindTools(tools) : llm.withConfig({ tools: tools.map((tool) => (0, _langchain_core_utils_function_calling.convertToOpenAITool)(tool)) });
+	return require_agent.AgentRunnableSequence.fromRunnables([
+		_langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_tool_calling.formatToToolMessages(input.steps) }),
 		prompt,
 		modelWithTools,
 		new require_output_parser.OpenAIToolsAgentOutputParser()
@@ -76,7 +76,6 @@ async function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }) {
 		streamRunnable,
 		singleAction: false
 	});
-	return agent;
 }
 
 //#endregion

package/dist/agents/openai_tools/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["AgentRunnableSequence","RunnablePassthrough","input: { steps: ToolsAgentStep[] }","formatToOpenAIToolMessages","OpenAIToolsAgentOutputParser"],"sources":["../../../src/agents/openai_tools/index.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { convertToOpenAITool } from \"@langchain/core/utils/function_calling\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { formatToOpenAIToolMessages } from \"../format_scratchpad/openai_tools.js\";\nimport {\n  OpenAIToolsAgentOutputParser,\n  type ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI tool calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: BaseChatModel<\n    BaseChatModelCallOptions & {\n      tools?:\n        | StructuredToolInterface[]\n        | OpenAIClient.ChatCompletionTool[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        | any[];\n    }\n  >;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[] | ToolDefinition[];\n  /** The prompt to use, must have an input key of `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport async function createOpenAIToolsAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateOpenAIToolsAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  const modelWithTools = llm.bindTools\n    ? llm.bindTools(tools)\n    : llm.withConfig({\n        tools: tools.map((tool) => convertToOpenAITool(tool)),\n      });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToOpenAIToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new OpenAIToolsAgentOutputParser(),\n    ],\n    {\n      name: \"OpenAIToolsAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,eAAsB,uBAAuB,EAC3C,KACA,OACA,QACA,gBAC6B,EAAE;AAC/B,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,CAAC,4DAA4D,CAAC,EAC9D,CAAC,MAAM,EAAE,KAAK,UAAU,OAAO,eAAe,CAAC,SAAS,CAAC,AAC1D,EAAC,KAAK,KAAK;CAGhB,MAAM,iBAAiB,IAAI,YACvB,IAAI,UAAU,MAAM,GACpB,IAAI,WAAW,EACb,OAAO,MAAM,IAAI,CAAC,0EAA6B,KAAK,CAAC,CACtD,EAAC;CACN,MAAM,QAAQA,oCAAsB,cAClC;EACEC,+CAAoB,OAAO,EACzB,kBAAkB,CAACC,UACjBC,0CAA2B,MAAM,MAAM,CAC1C,EAAC;EACF;EACA;EACA,IAAIC;CACL,GACD;EACE,MAAM;EACN;EACA,cAAc;CACf,EACF;AACD,QAAO;AACR"}
+{"version":3,"file":"index.cjs","names":["AgentRunnableSequence","RunnablePassthrough","formatToOpenAIToolMessages","OpenAIToolsAgentOutputParser"],"sources":["../../../src/agents/openai_tools/index.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { convertToOpenAITool } from \"@langchain/core/utils/function_calling\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { formatToOpenAIToolMessages } from \"../format_scratchpad/openai_tools.js\";\nimport {\n  OpenAIToolsAgentOutputParser,\n  type ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI tool calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: BaseChatModel<\n    BaseChatModelCallOptions & {\n      tools?:\n        | StructuredToolInterface[]\n        | OpenAIClient.ChatCompletionTool[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        | any[];\n    }\n  >;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[] | ToolDefinition[];\n  /** The prompt to use, must have an input key of `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport async function createOpenAIToolsAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateOpenAIToolsAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  const modelWithTools = llm.bindTools\n    ? llm.bindTools(tools)\n    : llm.withConfig({\n        tools: tools.map((tool) => convertToOpenAITool(tool)),\n      });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToOpenAIToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new OpenAIToolsAgentOutputParser(),\n    ],\n    {\n      name: \"OpenAIToolsAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,eAAsB,uBAAuB,EAC3C,KACA,OACA,QACA,kBAC+B;AAC/B,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,gEACA,SAAS,KAAK,UAAU,OAAO,eAAe,CAAC,WAChD,CAAC,KAAK,KAAK,CACb;CAEH,MAAM,iBAAiB,IAAI,YACvB,IAAI,UAAU,MAAM,GACpB,IAAI,WAAW,EACb,OAAO,MAAM,KAAK,yEAA6B,KAAK,CAAC,EACtD,CAAC;AAiBN,QAhBcA,oCAAsB,cAClC;EACEC,8CAAoB,OAAO,EACzB,mBAAmB,UACjBC,0CAA2B,MAAM,MAAM,EAC1C,CAAC;EACF;EACA;EACA,IAAIC,oDAA8B;EACnC,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CACF"}

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

@@ -1,7 +1,7 @@
 import { ToolsAgentStep } from "../tool_calling/output_parser.cjs";
 import { AgentRunnableSequence } from "../agent.cjs";
 import { OpenAIToolsAgentOutputParser } from "./output_parser.cjs";
-import * as _langchain_core_agents1 from "@langchain/core/agents";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
@@ -20,10 +20,8 @@ type CreateOpenAIToolsAgentParams = {
    */
   llm: BaseChatModel<BaseChatModelCallOptions & {
     tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];
-  }>;
-  /** Tools this agent has access to. */
-  tools: StructuredToolInterface[] | ToolDefinition[];
-  /** The prompt to use, must have an input key of `agent_scratchpad`. */
+  }>; /** Tools this agent has access to. */
+  tools: StructuredToolInterface[] | ToolDefinition[]; /** The prompt to use, must have an input key of `agent_scratchpad`. */
   prompt: ChatPromptTemplate;
   /**
    * Whether to invoke the underlying model in streaming mode,
@@ -94,7 +92,7 @@ declare function createOpenAIToolsAgent({
   streamRunnable
 }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _langchain_core_agents1.AgentFinish | _langchain_core_agents1.AgentAction[]>>;
+}, _langchain_core_agents0.AgentFinish | _langchain_core_agents0.AgentAction[]>>;
 //#endregion
 export { CreateOpenAIToolsAgentParams, createOpenAIToolsAgent };
 //# sourceMappingURL=index.d.cts.map

package/dist/agents/openai_tools/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentFinish","AgentAction","Promise"],"sources":["../../../src/agents/openai_tools/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel, BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: BaseChatModel<BaseChatModelCallOptions & {\n        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];\n    }>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAMjBP;;;;;EAIgBG,GAAAA,EAJ9BJ,aAI8BI,CAJhBH,wBAIgBG,GAAAA;IAE3BF,KAAAA,CAAAA,EALIH,uBAKJG,EAAAA,GALgCC,YAAAA,CAAaM,kBAK7CP,EAAAA,GAAAA,GAAAA,EAAAA;EAAkB,CAAA,CAAA;EA+DNQ;EAAyBC,KAAAA,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAKC;EAAOC,MAAAA,EA/DjDX,kBA+DiDW;EAAQC;;;;EAEtBC,cAAAA,CAAAA,EAAAA,OAAoCE;CAF2CV;;AAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGG,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAcS,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/openai_tools/index.ts"],"mappings":";;;;;;;;;;;;;;KAsBY,4BAAA;EAA4B;;;;;EAMtC,GAAA,EAAK,aAAA,CACH,wBAAA;IACE,KAAA,GACI,uBAAA,KACA,YAAA,CAAa,kBAAA;EAAA,IAQb;EAFR,KAAA,EAAO,uBAAA,KAA4B,cAAA,IAET;EAA1B,MAAA,EAAQ,kBAAA;EAZH;;;;EAiBL,cAAA;AAAA;;;;;;;;;AA2DF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,sBAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,4BAAA,GAA4B,OAAA,CAAA,qBAAA"}

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

@@ -6,7 +6,7 @@ import { StructuredToolInterface } from "@langchain/core/tools";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 import { OpenAIClient } from "@langchain/openai";
 import { BaseChatModel, BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
-import * as _langchain_core_agents1 from "@langchain/core/agents";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 
 //#region src/agents/openai_tools/index.d.ts
 /**
@@ -20,10 +20,8 @@ type CreateOpenAIToolsAgentParams = {
    */
   llm: BaseChatModel<BaseChatModelCallOptions & {
     tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];
-  }>;
-  /** Tools this agent has access to. */
-  tools: StructuredToolInterface[] | ToolDefinition[];
-  /** The prompt to use, must have an input key of `agent_scratchpad`. */
+  }>; /** Tools this agent has access to. */
+  tools: StructuredToolInterface[] | ToolDefinition[]; /** The prompt to use, must have an input key of `agent_scratchpad`. */
   prompt: ChatPromptTemplate;
   /**
    * Whether to invoke the underlying model in streaming mode,
@@ -94,7 +92,7 @@ declare function createOpenAIToolsAgent({
   streamRunnable
 }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _langchain_core_agents1.AgentFinish | _langchain_core_agents1.AgentAction[]>>;
+}, _langchain_core_agents0.AgentFinish | _langchain_core_agents0.AgentAction[]>>;
 //#endregion
 export { CreateOpenAIToolsAgentParams, createOpenAIToolsAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentFinish","AgentAction","Promise"],"sources":["../../../src/agents/openai_tools/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel, BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: BaseChatModel<BaseChatModelCallOptions & {\n        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];\n    }>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAMjBP;;;;;EAIgBG,GAAAA,EAJ9BJ,aAI8BI,CAJhBH,wBAIgBG,GAAAA;IAE3BF,KAAAA,CAAAA,EALIH,uBAKJG,EAAAA,GALgCC,YAAAA,CAAaM,kBAK7CP,EAAAA,GAAAA,GAAAA,EAAAA;EAAkB,CAAA,CAAA;EA+DNQ;EAAyBC,KAAAA,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAKC;EAAOC,MAAAA,EA/DjDX,kBA+DiDW;EAAQC;;;;EAEtBC,cAAAA,CAAAA,EAAAA,OAAoCE;CAF2CV;;AAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGG,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAcS,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/openai_tools/index.ts"],"mappings":";;;;;;;;;;;;;;KAsBY,4BAAA;EAA4B;;;;;EAMtC,GAAA,EAAK,aAAA,CACH,wBAAA;IACE,KAAA,GACI,uBAAA,KACA,YAAA,CAAa,kBAAA;EAAA,IAQb;EAFR,KAAA,EAAO,uBAAA,KAA4B,cAAA,IAET;EAA1B,MAAA,EAAQ,kBAAA;EAZH;;;;EAiBL,cAAA;AAAA;;;;;;;;;AA2DF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,sBAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,4BAAA,GAA4B,OAAA,CAAA,qBAAA"}

package/dist/agents/openai_tools/index.js

@@ -1,7 +1,7 @@
-import { AgentRunnableSequence } from "../agent.js";
-import { OpenAIToolsAgentOutputParser } from "./output_parser.js";
 import { formatToToolMessages } from "../format_scratchpad/tool_calling.js";
 import "../format_scratchpad/openai_tools.js";
+import { AgentRunnableSequence } from "../agent.js";
+import { OpenAIToolsAgentOutputParser } from "./output_parser.js";
 import { RunnablePassthrough } from "@langchain/core/runnables";
 import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
 
@@ -65,7 +65,7 @@ import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
 async function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }) {
 	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.bindTools ? llm.bindTools(tools) : llm.withConfig({ tools: tools.map((tool) => convertToOpenAITool(tool)) });
-	const agent = AgentRunnableSequence.fromRunnables([
+	return AgentRunnableSequence.fromRunnables([
 		RunnablePassthrough.assign({ agent_scratchpad: (input) => formatToToolMessages(input.steps) }),
 		prompt,
 		modelWithTools,
@@ -75,7 +75,6 @@ async function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }) {
 		streamRunnable,
 		singleAction: false
 	});
-	return agent;
 }
 
 //#endregion