@langchain/classic 1.0.0-alpha.1

package/dist/agents/openai_functions/index.cjs

@@ -0,0 +1,217 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_agent = require('../agent.cjs');
+const require_llm_chain = require('../../chains/llm_chain.cjs');
+const require_prompt = require('./prompt.cjs');
+const require_output_parser = require('./output_parser.cjs');
+require('../openai/output_parser.cjs');
+const require_agents_format_scratchpad_openai_functions = require('../format_scratchpad/openai_functions.cjs');
+const __langchain_core_prompts = require_rolldown_runtime.__toESM(require("@langchain/core/prompts"));
+const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
+const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+const __langchain_core_utils_function_calling = require_rolldown_runtime.__toESM(require("@langchain/core/utils/function_calling"));
+
+//#region src/agents/openai_functions/index.ts
+/**
+* Checks if the given action is a FunctionsAgentAction.
+* @param action The action to check.
+* @returns True if the action is a FunctionsAgentAction, false otherwise.
+*/
+function isFunctionsAgentAction(action) {
+	return action.messageLog !== void 0;
+}
+function _convertAgentStepToMessages(action, observation) {
+	if (isFunctionsAgentAction(action) && action.messageLog !== void 0) return action.messageLog?.concat(new __langchain_core_messages.FunctionMessage(observation, action.tool));
+	else return [new __langchain_core_messages.AIMessage(action.log)];
+}
+function _formatIntermediateSteps(intermediateSteps) {
+	return intermediateSteps.flatMap(({ action, observation }) => _convertAgentStepToMessages(action, observation));
+}
+/**
+* Class representing an agent for the OpenAI chat model in LangChain. It
+* extends the Agent class and provides additional functionality specific
+* to the OpenAIAgent type.
+*/
+var OpenAIAgent = class OpenAIAgent extends require_agent.Agent {
+	static lc_name() {
+		return "OpenAIAgent";
+	}
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"openai"
+	];
+	_agentType() {
+		return "openai-functions";
+	}
+	observationPrefix() {
+		return "Observation: ";
+	}
+	llmPrefix() {
+		return "Thought:";
+	}
+	_stop() {
+		return ["Observation:"];
+	}
+	tools;
+	outputParser = new require_output_parser.OpenAIFunctionsAgentOutputParser();
+	constructor(input) {
+		super({
+			...input,
+			outputParser: void 0
+		});
+		this.tools = input.tools;
+	}
+	/**
+	* Creates a prompt for the OpenAIAgent using the provided tools and
+	* fields.
+	* @param _tools The tools to be used in the prompt.
+	* @param fields Optional fields for creating the prompt.
+	* @returns A BasePromptTemplate object representing the created prompt.
+	*/
+	static createPrompt(_tools, fields) {
+		const { prefix = require_prompt.PREFIX } = fields || {};
+		return __langchain_core_prompts.ChatPromptTemplate.fromMessages([
+			__langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate(prefix),
+			new __langchain_core_prompts.MessagesPlaceholder("chat_history"),
+			__langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate("{input}"),
+			new __langchain_core_prompts.MessagesPlaceholder("agent_scratchpad")
+		]);
+	}
+	/**
+	* Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.
+	* @param llm The BaseLanguageModel to use.
+	* @param tools The tools to be used by the agent.
+	* @param args Optional arguments for creating the agent.
+	* @returns An instance of OpenAIAgent.
+	*/
+	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 require_llm_chain.LLMChain({
+			prompt,
+			llm,
+			callbacks: args?.callbacks
+		});
+		return new OpenAIAgent({
+			llmChain: chain,
+			allowedTools: tools.map((t) => t.name),
+			tools
+		});
+	}
+	/**
+	* Constructs a scratch pad from a list of agent steps.
+	* @param steps The steps to include in the scratch pad.
+	* @returns A string or a list of BaseMessages representing the constructed scratch pad.
+	*/
+	async constructScratchPad(steps) {
+		return _formatIntermediateSteps(steps);
+	}
+	/**
+	* Plans the next action or finish state of the agent based on the
+	* provided steps, inputs, and optional callback manager.
+	* @param steps The steps to consider in planning.
+	* @param inputs The inputs to consider in planning.
+	* @param callbackManager Optional CallbackManager to use in planning.
+	* @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+	*/
+	async plan(steps, inputs, callbackManager) {
+		const thoughts = await this.constructScratchPad(steps);
+		const newInputs = {
+			...inputs,
+			agent_scratchpad: thoughts
+		};
+		if (this._stop().length !== 0) newInputs.stop = this._stop();
+		const llm = this.llmChain.llm;
+		const valuesForPrompt = { ...newInputs };
+		const valuesForLLM = { functions: this.tools.map((tool) => (0, __langchain_core_utils_function_calling.convertToOpenAIFunction)(tool)) };
+		const callKeys = "callKeys" in this.llmChain.llm ? this.llmChain.llm.callKeys : [];
+		for (const key of callKeys) if (key in inputs) {
+			valuesForLLM[key] = inputs[key];
+			delete valuesForPrompt[key];
+		}
+		const promptValue = await this.llmChain.prompt.formatPromptValue(valuesForPrompt);
+		const message = await llm.invoke(promptValue.toChatMessages(), {
+			...valuesForLLM,
+			callbacks: callbackManager
+		});
+		return this.outputParser.parseAIMessage(message);
+	}
+};
+/**
+* Create an agent that uses OpenAI-style function calling.
+* @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+* @returns A runnable sequence representing an agent. It takes as input all the same input
+*     variables as the prompt passed in does. It returns as output either an
+*     AgentAction or AgentFinish.
+*
+* @example
+* ```typescript
+* import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";
+* import { pull } from "langchain/hub";
+* import type { ChatPromptTemplate } from "@langchain/core/prompts";
+* import { AIMessage, HumanMessage } from "@langchain/core/messages";
+*
+* import { ChatOpenAI } from "@langchain/openai";
+*
+* // Define the tools the agent will have access to.
+* const tools = [...];
+*
+* // Get the prompt to use - you can modify this!
+* // If you want to see the prompt in full, you can at:
+* // https://smith.langchain.com/hub/hwchase17/openai-functions-agent
+* const prompt = await pull<ChatPromptTemplate>(
+*   "hwchase17/openai-functions-agent"
+* );
+*
+* const llm = new ChatOpenAI({
+*   model: "gpt-4o-mini",
+*   temperature: 0,
+* });
+*
+* const agent = await createOpenAIFunctionsAgent({
+*   llm,
+*   tools,
+*   prompt,
+* });
+*
+* const agentExecutor = new AgentExecutor({
+*   agent,
+*   tools,
+* });
+*
+* const result = await agentExecutor.invoke({
+*   input: "what is LangChain?",
+* });
+*
+* // With chat history
+* const result2 = await agentExecutor.invoke({
+*   input: "what's my name?",
+*   chat_history: [
+*     new HumanMessage("hi! my name is cob"),
+*     new AIMessage("Hello Cob! How can I assist you today?"),
+*   ],
+* });
+* ```
+*/
+async function createOpenAIFunctionsAgent({ llm, tools, prompt, 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) => (0, __langchain_core_utils_function_calling.convertToOpenAIFunction)(tool)) });
+	const agent = require_agent.AgentRunnableSequence.fromRunnables([
+		__langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_agents_format_scratchpad_openai_functions.formatToOpenAIFunctionMessages(input.steps) }),
+		prompt,
+		llmWithTools,
+		new require_output_parser.OpenAIFunctionsAgentOutputParser()
+	], {
+		name: "OpenAIFunctionsAgent",
+		streamRunnable,
+		singleAction: true
+	});
+	return agent;
+}
+
+//#endregion
+exports.OpenAIAgent = OpenAIAgent;
+exports._formatIntermediateSteps = _formatIntermediateSteps;
+exports.createOpenAIFunctionsAgent = createOpenAIFunctionsAgent;
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["action: AgentAction | FunctionsAgentAction","observation: string","FunctionMessage","AIMessage","intermediateSteps: AgentStep[]","Agent","OpenAIFunctionsAgentOutputParser","input: Omit<OpenAIAgentInput, \"outputParser\">","_tools: StructuredToolInterface[]","fields?: OpenAIAgentCreatePromptArgs","PREFIX","ChatPromptTemplate","SystemMessagePromptTemplate","MessagesPlaceholder","HumanMessagePromptTemplate","llm: BaseLanguageModelInterface","tools: StructuredToolInterface[]","args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">","LLMChain","steps: AgentStep[]","steps: Array<AgentStep>","inputs: ChainValues","callbackManager?: CallbackManager","newInputs: ChainValues","valuesForLLM: CallOptionsIfAvailable<typeof llm>","AgentRunnableSequence","RunnablePassthrough","input: { steps: AgentStep[] }","formatToOpenAIFunctionMessages"],"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 = await this.llmChain.prompt.formatPromptValue(\n      valuesForPrompt\n    );\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":"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"}

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

@@ -0,0 +1,162 @@
+import { AgentInput } from "../types.cjs";
+import { Agent, AgentArgs, AgentRunnableSequence } from "../agent.cjs";
+import { OpenAIFunctionsAgentOutputParser } from "./output_parser.cjs";
+import { AgentAction, AgentFinish, AgentStep } from "@langchain/core/agents";
+import { BaseMessage, SystemMessage } from "@langchain/core/messages";
+import { ChainValues } from "@langchain/core/utils/types";
+import { BasePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
+import { BaseFunctionCallOptions, BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { StructuredToolInterface } from "@langchain/core/tools";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+
+//#region src/agents/openai_functions/index.d.ts
+
+/**
+ * Interface for the input data required to create an OpenAIAgent.
+ */
+interface OpenAIAgentInput extends AgentInput {
+  tools: StructuredToolInterface[];
+}
+/**
+ * Interface for the arguments required to create a prompt for an
+ * OpenAIAgent.
+ */
+interface OpenAIAgentCreatePromptArgs {
+  prefix?: string;
+  systemMessage?: SystemMessage;
+}
+/**
+ * Class representing an agent for the OpenAI chat model in LangChain. It
+ * extends the Agent class and provides additional functionality specific
+ * to the OpenAIAgent type.
+ */
+declare class OpenAIAgent extends Agent {
+  static lc_name(): string;
+  lc_namespace: string[];
+  _agentType(): "openai-functions";
+  observationPrefix(): string;
+  llmPrefix(): string;
+  _stop(): string[];
+  tools: StructuredToolInterface[];
+  outputParser: OpenAIFunctionsAgentOutputParser;
+  constructor(input: Omit<OpenAIAgentInput, "outputParser">);
+  /**
+   * Creates a prompt for the OpenAIAgent using the provided tools and
+   * fields.
+   * @param _tools The tools to be used in the prompt.
+   * @param fields Optional fields for creating the prompt.
+   * @returns A BasePromptTemplate object representing the created prompt.
+   */
+  static createPrompt(_tools: StructuredToolInterface[], fields?: OpenAIAgentCreatePromptArgs): BasePromptTemplate;
+  /**
+   * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.
+   * @param llm The BaseLanguageModel to use.
+   * @param tools The tools to be used by the agent.
+   * @param args Optional arguments for creating the agent.
+   * @returns An instance of OpenAIAgent.
+   */
+  static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, "callbacks">): OpenAIAgent;
+  /**
+   * Constructs a scratch pad from a list of agent steps.
+   * @param steps The steps to include in the scratch pad.
+   * @returns A string or a list of BaseMessages representing the constructed scratch pad.
+   */
+  constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;
+  /**
+   * Plans the next action or finish state of the agent based on the
+   * provided steps, inputs, and optional callback manager.
+   * @param steps The steps to consider in planning.
+   * @param inputs The inputs to consider in planning.
+   * @param callbackManager Optional CallbackManager to use in planning.
+   * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+   */
+  plan(steps: Array<AgentStep>, inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;
+}
+/**
+ * Params used by the createOpenAIFunctionsAgent function.
+ */
+type CreateOpenAIFunctionsAgentParams = {
+  /**
+   * LLM to use as the agent. Should work with OpenAI function calling,
+   * so must either be an OpenAI model that supports that or a wrapper of
+   * a different model that adds in equivalent support.
+   */
+  llm: BaseChatModel<BaseFunctionCallOptions>;
+  /** Tools this agent has access to. */
+  tools: StructuredToolInterface[];
+  /** The prompt to use, must have an input key for `agent_scratchpad`. */
+  prompt: ChatPromptTemplate;
+  /**
+   * Whether to invoke the underlying model in streaming mode,
+   * allowing streaming of intermediate steps. Defaults to true.
+   */
+  streamRunnable?: boolean;
+};
+/**
+ * Create an agent that uses OpenAI-style function calling.
+ * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+ * @returns A runnable sequence representing an agent. It takes as input all the same input
+ *     variables as the prompt passed in does. It returns as output either an
+ *     AgentAction or AgentFinish.
+ *
+ * @example
+ * ```typescript
+ * import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { ChatPromptTemplate } from "@langchain/core/prompts";
+ * import { AIMessage, HumanMessage } from "@langchain/core/messages";
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * // Define the tools the agent will have access to.
+ * const tools = [...];
+ *
+ * // Get the prompt to use - you can modify this!
+ * // If you want to see the prompt in full, you can at:
+ * // https://smith.langchain.com/hub/hwchase17/openai-functions-agent
+ * const prompt = await pull<ChatPromptTemplate>(
+ *   "hwchase17/openai-functions-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   model: "gpt-4o-mini",
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createOpenAIFunctionsAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ *
+ * // With chat history
+ * const result2 = await agentExecutor.invoke({
+ *   input: "what's my name?",
+ *   chat_history: [
+ *     new HumanMessage("hi! my name is cob"),
+ *     new AIMessage("Hello Cob! How can I assist you today?"),
+ *   ],
+ * });
+ * ```
+ */
+declare function createOpenAIFunctionsAgent({
+  llm,
+  tools,
+  prompt,
+  streamRunnable
+}: CreateOpenAIFunctionsAgentParams): Promise<AgentRunnableSequence<{
+  steps: AgentStep[];
+}, AgentAction | AgentFinish>>;
+//#endregion
+export { CreateOpenAIFunctionsAgentParams, OpenAIAgent, OpenAIAgentCreatePromptArgs, OpenAIAgentInput, createOpenAIFunctionsAgent };
+//# sourceMappingURL=index.d.cts.map

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

@@ -0,0 +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"],"mappings":";;;;;;;;;;;;;;;AAeA;;AACWE,UADMiB,gBAAAA,SAAyBH,UAC/Bd,CAAAA;EAAuB,KADQc,EAC/Bd,uBAD+Bc,EAAAA;AAAU;AAOpD;AASA;;;AAQkBC,UAjBDG,2BAAAA,CAiBCH;EAAgC,MACtBE,CAAAA,EAAAA,MAAAA;EAAgB,aAArBG,CAAAA,EAhBHd,aAgBGc;;;;;;;AAgBiHR,cAzBnHO,WAAAA,SAAoBR,KAAAA,CAyB+FC;EAAS,OAAdS,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAI,YAA2BF,EAAAA,MAAAA,EAAAA;EAAW,UAM9If,CAAAA,CAAAA,EAAAA,kBAAAA;EAAS,iBAAsBC,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,SAA5BiB,CAAAA,CAAAA,EAAAA,MAAAA;EAAO,KAS9BlB,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAS,KAAfmB,EAjCLvB,uBAiCKuB,EAAAA;EAAK,YAAqBhB,EAhCxBQ,gCAgCwBR;EAAW,WAAoBG,CAAAA,KAAAA,EA/BlDU,IA+BkDV,CA/B7CO,gBA+B6CP,EAAAA,cAAAA,CAAAA;EAAe;;;;AAxC1C;AA6C9C;;EAA4C,OAMrBX,YAAAA,CAAAA,MAAAA,EAlCSC,uBAkCTD,EAAAA,EAAAA,MAAAA,CAAAA,EAlC6CmB,2BAkC7CnB,CAAAA,EAlC2EU,kBAkC3EV;EAAuB;;;AAIhB;AA+D9B;;;EAAwD,OAAE4B,eAAAA,CAAAA,GAAAA,EA7F1B7B,0BA6F0B6B,EAAAA,KAAAA,EA7FS3B,uBA6FT2B,EAAAA,EAAAA,IAAAA,CAAAA,EA7F2CT,2BA6F3CS,GA7FyEN,IA6FzEM,CA7F8Ef,SA6F9Ee,EAAAA,WAAAA,CAAAA,CAAAA,EA7FwGR,WA6FxGQ;EAAK;;;;;EAEjD,mBAAGxB,CAAAA,KAAAA,EAzFcC,SAyFdD,EAAAA,CAAAA,EAzF4BmB,OAyF5BnB,CAAAA,MAAAA,GAzF6CE,WAyF7CF,EAAAA,CAAAA;EAAW;;AAFyG;;;;;;cA9ErHoB,MAAMnB,oBAAoBG,+BAA+BG,kBAAkBY,QAAQpB,cAAcC;;;;;KAKrGqB,gCAAAA;;;;;;OAMHvB,cAAcF;;SAEZC;;UAECQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYiB,0BAAAA;;;;;GAAmED,mCAAmCF,QAAQT;SAC3HT;GACRF,cAAcC"}

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

@@ -0,0 +1,162 @@
+import { AgentInput } from "../types.js";
+import { Agent, AgentArgs, AgentRunnableSequence } from "../agent.js";
+import { OpenAIFunctionsAgentOutputParser } from "./output_parser.js";
+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.
+ */
+interface OpenAIAgentInput extends AgentInput {
+  tools: StructuredToolInterface[];
+}
+/**
+ * Interface for the arguments required to create a prompt for an
+ * OpenAIAgent.
+ */
+interface OpenAIAgentCreatePromptArgs {
+  prefix?: string;
+  systemMessage?: SystemMessage;
+}
+/**
+ * Class representing an agent for the OpenAI chat model in LangChain. It
+ * extends the Agent class and provides additional functionality specific
+ * to the OpenAIAgent type.
+ */
+declare class OpenAIAgent extends Agent {
+  static lc_name(): string;
+  lc_namespace: string[];
+  _agentType(): "openai-functions";
+  observationPrefix(): string;
+  llmPrefix(): string;
+  _stop(): string[];
+  tools: StructuredToolInterface[];
+  outputParser: OpenAIFunctionsAgentOutputParser;
+  constructor(input: Omit<OpenAIAgentInput, "outputParser">);
+  /**
+   * Creates a prompt for the OpenAIAgent using the provided tools and
+   * fields.
+   * @param _tools The tools to be used in the prompt.
+   * @param fields Optional fields for creating the prompt.
+   * @returns A BasePromptTemplate object representing the created prompt.
+   */
+  static createPrompt(_tools: StructuredToolInterface[], fields?: OpenAIAgentCreatePromptArgs): BasePromptTemplate;
+  /**
+   * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.
+   * @param llm The BaseLanguageModel to use.
+   * @param tools The tools to be used by the agent.
+   * @param args Optional arguments for creating the agent.
+   * @returns An instance of OpenAIAgent.
+   */
+  static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, "callbacks">): OpenAIAgent;
+  /**
+   * Constructs a scratch pad from a list of agent steps.
+   * @param steps The steps to include in the scratch pad.
+   * @returns A string or a list of BaseMessages representing the constructed scratch pad.
+   */
+  constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;
+  /**
+   * Plans the next action or finish state of the agent based on the
+   * provided steps, inputs, and optional callback manager.
+   * @param steps The steps to consider in planning.
+   * @param inputs The inputs to consider in planning.
+   * @param callbackManager Optional CallbackManager to use in planning.
+   * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.
+   */
+  plan(steps: Array<AgentStep>, inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;
+}
+/**
+ * Params used by the createOpenAIFunctionsAgent function.
+ */
+type CreateOpenAIFunctionsAgentParams = {
+  /**
+   * LLM to use as the agent. Should work with OpenAI function calling,
+   * so must either be an OpenAI model that supports that or a wrapper of
+   * a different model that adds in equivalent support.
+   */
+  llm: BaseChatModel<BaseFunctionCallOptions>;
+  /** Tools this agent has access to. */
+  tools: StructuredToolInterface[];
+  /** The prompt to use, must have an input key for `agent_scratchpad`. */
+  prompt: ChatPromptTemplate;
+  /**
+   * Whether to invoke the underlying model in streaming mode,
+   * allowing streaming of intermediate steps. Defaults to true.
+   */
+  streamRunnable?: boolean;
+};
+/**
+ * Create an agent that uses OpenAI-style function calling.
+ * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+ * @returns A runnable sequence representing an agent. It takes as input all the same input
+ *     variables as the prompt passed in does. It returns as output either an
+ *     AgentAction or AgentFinish.
+ *
+ * @example
+ * ```typescript
+ * import { AgentExecutor, createOpenAIFunctionsAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { ChatPromptTemplate } from "@langchain/core/prompts";
+ * import { AIMessage, HumanMessage } from "@langchain/core/messages";
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * // Define the tools the agent will have access to.
+ * const tools = [...];
+ *
+ * // Get the prompt to use - you can modify this!
+ * // If you want to see the prompt in full, you can at:
+ * // https://smith.langchain.com/hub/hwchase17/openai-functions-agent
+ * const prompt = await pull<ChatPromptTemplate>(
+ *   "hwchase17/openai-functions-agent"
+ * );
+ *
+ * const llm = new ChatOpenAI({
+ *   model: "gpt-4o-mini",
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createOpenAIFunctionsAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ *
+ * // With chat history
+ * const result2 = await agentExecutor.invoke({
+ *   input: "what's my name?",
+ *   chat_history: [
+ *     new HumanMessage("hi! my name is cob"),
+ *     new AIMessage("Hello Cob! How can I assist you today?"),
+ *   ],
+ * });
+ * ```
+ */
+declare function createOpenAIFunctionsAgent({
+  llm,
+  tools,
+  prompt,
+  streamRunnable
+}: CreateOpenAIFunctionsAgentParams): Promise<AgentRunnableSequence<{
+  steps: AgentStep[];
+}, AgentAction | AgentFinish>>;
+//#endregion
+export { CreateOpenAIFunctionsAgentParams, OpenAIAgent, OpenAIAgentCreatePromptArgs, OpenAIAgentInput, createOpenAIFunctionsAgent };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"],"mappings":";;;;;;;;;;;;;;;AAeA;;AACWE,UADMiB,gBAAAA,SAAyBH,UAC/Bd,CAAAA;EAAuB,KADQc,EAC/Bd,uBAD+Bc,EAAAA;AAAU;AAOpD;AASA;;;AAQkBC,UAjBDG,2BAAAA,CAiBCH;EAAgC,MACtBE,CAAAA,EAAAA,MAAAA;EAAgB,aAArBG,CAAAA,EAhBHd,aAgBGc;;;;;;;AAgBiHR,cAzBnHO,WAAAA,SAAoBR,KAAAA,CAyB+FC;EAAS,OAAdS,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAI,YAA2BF,EAAAA,MAAAA,EAAAA;EAAW,UAM9If,CAAAA,CAAAA,EAAAA,kBAAAA;EAAS,iBAAsBC,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,SAA5BiB,CAAAA,CAAAA,EAAAA,MAAAA;EAAO,KAS9BlB,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAS,KAAfmB,EAjCLvB,uBAiCKuB,EAAAA;EAAK,YAAqBhB,EAhCxBQ,gCAgCwBR;EAAW,WAAoBG,CAAAA,KAAAA,EA/BlDU,IA+BkDV,CA/B7CO,gBA+B6CP,EAAAA,cAAAA,CAAAA;EAAe;;;;AAxC1C;AA6C9C;;EAA4C,OAMrBX,YAAAA,CAAAA,MAAAA,EAlCSC,uBAkCTD,EAAAA,EAAAA,MAAAA,CAAAA,EAlC6CmB,2BAkC7CnB,CAAAA,EAlC2EU,kBAkC3EV;EAAuB;;;AAIhB;AA+D9B;;;EAAwD,OAAE4B,eAAAA,CAAAA,GAAAA,EA7F1B7B,0BA6F0B6B,EAAAA,KAAAA,EA7FS3B,uBA6FT2B,EAAAA,EAAAA,IAAAA,CAAAA,EA7F2CT,2BA6F3CS,GA7FyEN,IA6FzEM,CA7F8Ef,SA6F9Ee,EAAAA,WAAAA,CAAAA,CAAAA,EA7FwGR,WA6FxGQ;EAAK;;;;;EAEjD,mBAAGxB,CAAAA,KAAAA,EAzFcC,SAyFdD,EAAAA,CAAAA,EAzF4BmB,OAyF5BnB,CAAAA,MAAAA,GAzF6CE,WAyF7CF,EAAAA,CAAAA;EAAW;;AAFyG;;;;;;cA9ErHoB,MAAMnB,oBAAoBG,+BAA+BG,kBAAkBY,QAAQpB,cAAcC;;;;;KAKrGqB,gCAAAA;;;;;;OAMHvB,cAAcF;;SAEZC;;UAECQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYiB,0BAAAA;;;;;GAAmED,mCAAmCF,QAAQT;SAC3HT;GACRF,cAAcC"}