langchain 0.1.26 → 0.1.28

package/dist/agents/agent.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agent = exports.LLMSingleActionAgent = exports.RunnableAgent = exports.BaseMultiActionAgent = exports.BaseSingleActionAgent = exports.BaseAgent = void 0;
+exports.Agent = exports.LLMSingleActionAgent = exports.RunnableAgent = exports.RunnableMultiActionAgent = exports.RunnableSingleActionAgent = exports.isRunnableAgent = exports.BaseMultiActionAgent = exports.BaseSingleActionAgent = exports.BaseAgent = void 0;
 const serializable_1 = require("@langchain/core/load/serializable");
 const runnables_1 = require("@langchain/core/runnables");
 /**
@@ -81,23 +81,106 @@ exports.BaseMultiActionAgent = BaseMultiActionAgent;
 function isAgentAction(input) {
     return !Array.isArray(input) && input?.tool !== undefined;
 }
+function isRunnableAgent(x) {
+    return (x.runnable !==
+        undefined);
+}
+exports.isRunnableAgent = isRunnableAgent;
 /**
- * Class representing a single action agent which accepts runnables.
- * Extends the BaseMultiActionAgent class and provides methods for
+ * Class representing a single-action agent powered by runnables.
+ * Extends the BaseSingleActionAgent class and provides methods for
  * planning agent actions with runnables.
  */
-class RunnableAgent extends BaseMultiActionAgent {
+class RunnableSingleActionAgent extends BaseSingleActionAgent {
     get inputKeys() {
         return [];
     }
     constructor(fields) {
-        super();
-        Object.defineProperty(this, "lc_runnable", {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "runnable"]
+        });
+        Object.defineProperty(this, "runnable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether to stream from the runnable or not.
+         * If true, the underlying LLM is invoked in a streaming fashion to make it
+         * possible to get access to the individual LLM tokens when using
+         * `streamLog` with the Agent Executor. If false then LLM is invoked in a
+         * non-streaming fashion and individual LLM tokens will not be available
+         * in `streamLog`.
+         *
+         * Note that the runnable should still only stream a single action or
+         * finish chunk.
+         */
+        Object.defineProperty(this, "streamRunnable", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "defaultRunName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "RunnableAgent"
+        });
+        this.runnable = fields.runnable;
+        this.defaultRunName = fields.defaultRunName ?? this.defaultRunName;
+        this.streamRunnable = fields.streamRunnable ?? this.streamRunnable;
+    }
+    async plan(steps, inputs, callbackManager, config) {
+        const combinedInput = { ...inputs, steps };
+        const combinedConfig = (0, runnables_1.patchConfig)(config, {
+            callbacks: callbackManager,
+            runName: this.defaultRunName,
+        });
+        if (this.streamRunnable) {
+            const stream = await this.runnable.stream(combinedInput, combinedConfig);
+            let finalOutput;
+            for await (const chunk of stream) {
+                if (finalOutput === undefined) {
+                    finalOutput = chunk;
+                }
+                else {
+                    throw new Error([
+                        `Multiple agent actions/finishes received in streamed agent output.`,
+                        `Set "streamRunnable: false" when initializing the agent to invoke this agent in non-streaming mode.`,
+                    ].join("\n"));
+                }
+            }
+            if (finalOutput === undefined) {
+                throw new Error([
+                    "No streaming output received from underlying runnable.",
+                    `Set "streamRunnable: false" when initializing the agent to invoke this agent in non-streaming mode.`,
+                ].join("\n"));
+            }
+            return finalOutput;
+        }
+        else {
+            return this.runnable.invoke(combinedInput, combinedConfig);
+        }
+    }
+}
+exports.RunnableSingleActionAgent = RunnableSingleActionAgent;
+/**
+ * Class representing a multi-action agent powered by runnables.
+ * Extends the BaseMultiActionAgent class and provides methods for
+ * planning agent actions with runnables.
+ */
+class RunnableMultiActionAgent extends BaseMultiActionAgent {
+    get inputKeys() {
+        return [];
+    }
+    constructor(fields) {
+        super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -111,27 +194,71 @@ class RunnableAgent extends BaseMultiActionAgent {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "defaultRunName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "RunnableAgent"
+        });
         Object.defineProperty(this, "stop", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "streamRunnable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         this.runnable = fields.runnable;
         this.stop = fields.stop;
+        this.defaultRunName = fields.defaultRunName ?? this.defaultRunName;
+        this.streamRunnable = fields.streamRunnable ?? this.streamRunnable;
     }
     async plan(steps, inputs, callbackManager, config) {
-        const invokeInput = { ...inputs, steps };
-        const output = await this.runnable.invoke(invokeInput, (0, runnables_1.patchConfig)(config, {
+        const combinedInput = { ...inputs, steps };
+        const combinedConfig = (0, runnables_1.patchConfig)(config, {
             callbacks: callbackManager,
-            runName: "RunnableAgent",
-        }));
+            runName: this.defaultRunName,
+        });
+        let output;
+        if (this.streamRunnable) {
+            const stream = await this.runnable.stream(combinedInput, combinedConfig);
+            let finalOutput;
+            for await (const chunk of stream) {
+                if (finalOutput === undefined) {
+                    finalOutput = chunk;
+                }
+                else {
+                    throw new Error([
+                        `Multiple agent actions/finishes received in streamed agent output.`,
+                        `Set "streamRunnable: false" when initializing the agent to invoke this agent in non-streaming mode.`,
+                    ].join("\n"));
+                }
+            }
+            if (finalOutput === undefined) {
+                throw new Error([
+                    "No streaming output received from underlying runnable.",
+                    `Set "streamRunnable: false" when initializing the agent to invoke this agent in non-streaming mode.`,
+                ].join("\n"));
+            }
+            output = finalOutput;
+        }
+        else {
+            output = await this.runnable.invoke(combinedInput, combinedConfig);
+        }
         if (isAgentAction(output)) {
             return [output];
         }
         return output;
     }
 }
+exports.RunnableMultiActionAgent = RunnableMultiActionAgent;
+/** @deprecated Renamed to RunnableMultiActionAgent. */
+class RunnableAgent extends RunnableMultiActionAgent {
+}
 exports.RunnableAgent = RunnableAgent;
 /**
  * Class representing a single action agent using a LLMChain in LangChain.

package/dist/agents/agent.d.ts

@@ -8,7 +8,7 @@ import { ChainValues } from "@langchain/core/utils/types";
 import { Serializable } from "@langchain/core/load/serializable";
 import { Runnable, type RunnableConfig } from "@langchain/core/runnables";
 import { LLMChain } from "../chains/llm_chain.js";
-import { AgentActionOutputParser, AgentInput, RunnableAgentInput, SerializedAgent, StoppingMethod } from "./types.js";
+import type { AgentActionOutputParser, AgentInput, RunnableMultiActionAgentInput, RunnableSingleActionAgentInput, SerializedAgent, StoppingMethod } from "./types.js";
 /**
  * Record type for arguments passed to output parsers.
  */
@@ -75,22 +75,54 @@ export declare abstract class BaseMultiActionAgent extends BaseAgent {
      */
     abstract plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction[] | AgentFinish>;
 }
+export declare function isRunnableAgent(x: BaseAgent): boolean;
 /**
- * Class representing a single action agent which accepts runnables.
+ * Class representing a single-action agent powered by runnables.
+ * Extends the BaseSingleActionAgent class and provides methods for
+ * planning agent actions with runnables.
+ */
+export declare class RunnableSingleActionAgent extends BaseSingleActionAgent {
+    lc_namespace: string[];
+    runnable: Runnable<ChainValues & {
+        steps: AgentStep[];
+    }, AgentAction | AgentFinish>;
+    get inputKeys(): string[];
+    /**
+     * Whether to stream from the runnable or not.
+     * If true, the underlying LLM is invoked in a streaming fashion to make it
+     * possible to get access to the individual LLM tokens when using
+     * `streamLog` with the Agent Executor. If false then LLM is invoked in a
+     * non-streaming fashion and individual LLM tokens will not be available
+     * in `streamLog`.
+     *
+     * Note that the runnable should still only stream a single action or
+     * finish chunk.
+     */
+    streamRunnable: boolean;
+    defaultRunName: string;
+    constructor(fields: RunnableSingleActionAgentInput);
+    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction | AgentFinish>;
+}
+/**
+ * Class representing a multi-action agent powered by runnables.
  * Extends the BaseMultiActionAgent class and provides methods for
  * planning agent actions with runnables.
  */
-export declare class RunnableAgent extends BaseMultiActionAgent {
-    protected lc_runnable: boolean;
+export declare class RunnableMultiActionAgent extends BaseMultiActionAgent {
     lc_namespace: string[];
     runnable: Runnable<ChainValues & {
         steps: AgentStep[];
     }, AgentAction[] | AgentAction | AgentFinish>;
+    defaultRunName: string;
     stop?: string[];
+    streamRunnable: boolean;
     get inputKeys(): string[];
-    constructor(fields: RunnableAgentInput);
+    constructor(fields: RunnableMultiActionAgentInput);
     plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction[] | AgentFinish>;
 }
+/** @deprecated Renamed to RunnableMultiActionAgent. */
+export declare class RunnableAgent extends RunnableMultiActionAgent {
+}
 /**
  * Interface for input data for creating a LLMSingleActionAgent.
  */

package/dist/agents/agent.js

@@ -75,23 +75,104 @@ export class BaseMultiActionAgent extends BaseAgent {
 function isAgentAction(input) {
     return !Array.isArray(input) && input?.tool !== undefined;
 }
+export function isRunnableAgent(x) {
+    return (x.runnable !==
+        undefined);
+}
 /**
- * Class representing a single action agent which accepts runnables.
- * Extends the BaseMultiActionAgent class and provides methods for
+ * Class representing a single-action agent powered by runnables.
+ * Extends the BaseSingleActionAgent class and provides methods for
  * planning agent actions with runnables.
  */
-export class RunnableAgent extends BaseMultiActionAgent {
+export class RunnableSingleActionAgent extends BaseSingleActionAgent {
     get inputKeys() {
         return [];
     }
     constructor(fields) {
-        super();
-        Object.defineProperty(this, "lc_runnable", {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "agents", "runnable"]
+        });
+        Object.defineProperty(this, "runnable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether to stream from the runnable or not.
+         * If true, the underlying LLM is invoked in a streaming fashion to make it
+         * possible to get access to the individual LLM tokens when using
+         * `streamLog` with the Agent Executor. If false then LLM is invoked in a
+         * non-streaming fashion and individual LLM tokens will not be available
+         * in `streamLog`.
+         *
+         * Note that the runnable should still only stream a single action or
+         * finish chunk.
+         */
+        Object.defineProperty(this, "streamRunnable", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "defaultRunName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "RunnableAgent"
+        });
+        this.runnable = fields.runnable;
+        this.defaultRunName = fields.defaultRunName ?? this.defaultRunName;
+        this.streamRunnable = fields.streamRunnable ?? this.streamRunnable;
+    }
+    async plan(steps, inputs, callbackManager, config) {
+        const combinedInput = { ...inputs, steps };
+        const combinedConfig = patchConfig(config, {
+            callbacks: callbackManager,
+            runName: this.defaultRunName,
+        });
+        if (this.streamRunnable) {
+            const stream = await this.runnable.stream(combinedInput, combinedConfig);
+            let finalOutput;
+            for await (const chunk of stream) {
+                if (finalOutput === undefined) {
+                    finalOutput = chunk;
+                }
+                else {
+                    throw new Error([
+                        `Multiple agent actions/finishes received in streamed agent output.`,
+                        `Set "streamRunnable: false" when initializing the agent to invoke this agent in non-streaming mode.`,
+                    ].join("\n"));
+                }
+            }
+            if (finalOutput === undefined) {
+                throw new Error([
+                    "No streaming output received from underlying runnable.",
+                    `Set "streamRunnable: false" when initializing the agent to invoke this agent in non-streaming mode.`,
+                ].join("\n"));
+            }
+            return finalOutput;
+        }
+        else {
+            return this.runnable.invoke(combinedInput, combinedConfig);
+        }
+    }
+}
+/**
+ * Class representing a multi-action agent powered by runnables.
+ * Extends the BaseMultiActionAgent class and provides methods for
+ * planning agent actions with runnables.
+ */
+export class RunnableMultiActionAgent extends BaseMultiActionAgent {
+    get inputKeys() {
+        return [];
+    }
+    constructor(fields) {
+        super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -105,27 +186,70 @@ export class RunnableAgent extends BaseMultiActionAgent {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "defaultRunName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "RunnableAgent"
+        });
         Object.defineProperty(this, "stop", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "streamRunnable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         this.runnable = fields.runnable;
         this.stop = fields.stop;
+        this.defaultRunName = fields.defaultRunName ?? this.defaultRunName;
+        this.streamRunnable = fields.streamRunnable ?? this.streamRunnable;
     }
     async plan(steps, inputs, callbackManager, config) {
-        const invokeInput = { ...inputs, steps };
-        const output = await this.runnable.invoke(invokeInput, patchConfig(config, {
+        const combinedInput = { ...inputs, steps };
+        const combinedConfig = patchConfig(config, {
             callbacks: callbackManager,
-            runName: "RunnableAgent",
-        }));
+            runName: this.defaultRunName,
+        });
+        let output;
+        if (this.streamRunnable) {
+            const stream = await this.runnable.stream(combinedInput, combinedConfig);
+            let finalOutput;
+            for await (const chunk of stream) {
+                if (finalOutput === undefined) {
+                    finalOutput = chunk;
+                }
+                else {
+                    throw new Error([
+                        `Multiple agent actions/finishes received in streamed agent output.`,
+                        `Set "streamRunnable: false" when initializing the agent to invoke this agent in non-streaming mode.`,
+                    ].join("\n"));
+                }
+            }
+            if (finalOutput === undefined) {
+                throw new Error([
+                    "No streaming output received from underlying runnable.",
+                    `Set "streamRunnable: false" when initializing the agent to invoke this agent in non-streaming mode.`,
+                ].join("\n"));
+            }
+            output = finalOutput;
+        }
+        else {
+            output = await this.runnable.invoke(combinedInput, combinedConfig);
+        }
         if (isAgentAction(output)) {
             return [output];
         }
         return output;
     }
 }
+/** @deprecated Renamed to RunnableMultiActionAgent. */
+export class RunnableAgent extends RunnableMultiActionAgent {
+}
 /**
  * Class representing a single action agent using a LLMChain in LangChain.
  * Extends the BaseSingleActionAgent class and provides methods for

package/dist/agents/executor.cjs

@@ -282,11 +282,14 @@ class AgentExecutor extends base_js_1.BaseChain {
         let agent;
         let returnOnlyOutputs = true;
         if (runnables_1.Runnable.isRunnable(input.agent)) {
-            agent = new agent_js_1.RunnableAgent({ runnable: input.agent });
+            agent = new agent_js_1.RunnableMultiActionAgent({ runnable: input.agent });
             // TODO: Update BaseChain implementation on breaking change
             returnOnlyOutputs = false;
         }
         else {
+            if ((0, agent_js_1.isRunnableAgent)(input.agent)) {
+                returnOnlyOutputs = false;
+            }
             agent = input.agent;
         }
         super(input);

package/dist/agents/executor.js

@@ -3,7 +3,7 @@ import { Runnable, patchConfig, } from "@langchain/core/runnables";
 import { CallbackManager, } from "@langchain/core/callbacks/manager";
 import { OutputParserException } from "@langchain/core/output_parsers";
 import { Serializable } from "@langchain/core/load/serializable";
-import { RunnableAgent, } from "./agent.js";
+import { RunnableMultiActionAgent, isRunnableAgent, } from "./agent.js";
 import { BaseChain } from "../chains/base.js";
 export class AgentExecutorIterator extends Serializable {
     get finalOutputs() {
@@ -277,11 +277,14 @@ export class AgentExecutor extends BaseChain {
         let agent;
         let returnOnlyOutputs = true;
         if (Runnable.isRunnable(input.agent)) {
-            agent = new RunnableAgent({ runnable: input.agent });
+            agent = new RunnableMultiActionAgent({ runnable: input.agent });
             // TODO: Update BaseChain implementation on breaking change
             returnOnlyOutputs = false;
         }
         else {
+            if (isRunnableAgent(input.agent)) {
+                returnOnlyOutputs = false;
+            }
             agent = input.agent;
         }
         super(input);

package/dist/agents/openai_functions/index.cjs

@@ -219,7 +219,7 @@ exports.OpenAIAgent = OpenAIAgent;
  * });
  * ```
  */
-async function createOpenAIFunctionsAgent({ llm, tools, prompt, }) {
+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".`,
@@ -237,6 +237,10 @@ async function createOpenAIFunctionsAgent({ llm, tools, prompt, }) {
         llmWithTools,
         new output_parser_js_1.OpenAIFunctionsAgentOutputParser(),
     ]);
-    return agent;
+    return new agent_js_1.RunnableSingleActionAgent({
+        runnable: agent,
+        defaultRunName: "OpenAIFunctionsAgent",
+        streamRunnable,
+    });
 }
 exports.createOpenAIFunctionsAgent = createOpenAIFunctionsAgent;

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

@@ -1,13 +1,12 @@
 import type { BaseLanguageModelInterface, BaseFunctionCallOptions } from "@langchain/core/language_models/base";
 import type { StructuredToolInterface } from "@langchain/core/tools";
 import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { RunnableSequence } from "@langchain/core/runnables";
 import type { AgentAction, AgentFinish, AgentStep } from "@langchain/core/agents";
 import { BaseMessage, SystemMessage } from "@langchain/core/messages";
 import { ChainValues } from "@langchain/core/utils/types";
 import { ChatPromptTemplate, BasePromptTemplate } from "@langchain/core/prompts";
 import { CallbackManager } from "@langchain/core/callbacks/manager";
-import { Agent, AgentArgs } from "../agent.js";
+import { Agent, AgentArgs, RunnableSingleActionAgent } from "../agent.js";
 import { AgentInput } from "../types.js";
 import { OpenAIFunctionsAgentOutputParser } from "../openai/output_parser.js";
 export declare function _formatIntermediateSteps(intermediateSteps: AgentStep[]): BaseMessage[];
@@ -88,6 +87,11 @@ export type CreateOpenAIFunctionsAgentParams = {
     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.
@@ -144,6 +148,4 @@ export type CreateOpenAIFunctionsAgentParams = {
  * });
  * ```
  */
-export declare function createOpenAIFunctionsAgent({ llm, tools, prompt, }: CreateOpenAIFunctionsAgentParams): Promise<RunnableSequence<{
-    steps: AgentStep[];
-}, AgentAction | AgentFinish>>;
+export declare function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable, }: CreateOpenAIFunctionsAgentParams): Promise<RunnableSingleActionAgent>;

package/dist/agents/openai_functions/index.js

@@ -2,7 +2,7 @@ import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnable
 import { convertToOpenAIFunction } from "@langchain/core/utils/function_calling";
 import { AIMessage, FunctionMessage, } from "@langchain/core/messages";
 import { ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, } from "@langchain/core/prompts";
-import { Agent } from "../agent.js";
+import { Agent, RunnableSingleActionAgent } from "../agent.js";
 import { PREFIX } from "./prompt.js";
 import { LLMChain } from "../../chains/llm_chain.js";
 import { OpenAIFunctionsAgentOutputParser, } from "../openai/output_parser.js";
@@ -214,7 +214,7 @@ export class OpenAIAgent extends Agent {
  * });
  * ```
  */
-export async function createOpenAIFunctionsAgent({ llm, tools, prompt, }) {
+export 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".`,
@@ -232,5 +232,9 @@ export async function createOpenAIFunctionsAgent({ llm, tools, prompt, }) {
         llmWithTools,
         new OpenAIFunctionsAgentOutputParser(),
     ]);
-    return agent;
+    return new RunnableSingleActionAgent({
+        runnable: agent,
+        defaultRunName: "OpenAIFunctionsAgent",
+        streamRunnable,
+    });
 }

package/dist/agents/openai_tools/index.cjs

@@ -6,6 +6,7 @@ const function_calling_1 = require("@langchain/core/utils/function_calling");
 const openai_tools_js_1 = require("../format_scratchpad/openai_tools.cjs");
 const output_parser_js_1 = require("../openai/output_parser.cjs");
 Object.defineProperty(exports, "OpenAIToolsAgentOutputParser", { enumerable: true, get: function () { return output_parser_js_1.OpenAIToolsAgentOutputParser; } });
+const agent_js_1 = require("../agent.cjs");
 /**
  * Create an agent that uses OpenAI-style tool calling.
  * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
@@ -62,7 +63,7 @@ Object.defineProperty(exports, "OpenAIToolsAgentOutputParser", { enumerable: tru
  * });
  * ```
  */
-async function createOpenAIToolsAgent({ llm, tools, prompt, }) {
+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".`,
@@ -78,6 +79,10 @@ async function createOpenAIToolsAgent({ llm, tools, prompt, }) {
         modelWithTools,
         new output_parser_js_1.OpenAIToolsAgentOutputParser(),
     ]);
-    return agent;
+    return new agent_js_1.RunnableMultiActionAgent({
+        runnable: agent,
+        defaultRunName: "OpenAIToolsAgent",
+        streamRunnable,
+    });
 }
 exports.createOpenAIToolsAgent = createOpenAIToolsAgent;

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

@@ -1,9 +1,9 @@
 import type { StructuredToolInterface } from "@langchain/core/tools";
 import type { BaseChatModel, BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
-import { RunnableSequence } from "@langchain/core/runnables";
 import { OpenAIClient } from "@langchain/openai";
 import { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from "../openai/output_parser.js";
+import { RunnableMultiActionAgent } from "../agent.js";
 export { OpenAIToolsAgentOutputParser, type ToolsAgentStep };
 /**
  * Params used by the createOpenAIToolsAgent function.
@@ -22,6 +22,11 @@ export type CreateOpenAIToolsAgentParams = {
     tools: StructuredToolInterface[];
     /** The prompt to use, must have an input key of `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 tool calling.
@@ -79,6 +84,4 @@ export type CreateOpenAIToolsAgentParams = {
  * });
  * ```
  */
-export declare function createOpenAIToolsAgent({ llm, tools, prompt, }: CreateOpenAIToolsAgentParams): Promise<RunnableSequence<{
-    steps: ToolsAgentStep[];
-}, import("@langchain/core/agents").AgentFinish | import("@langchain/core/agents").AgentAction[]>>;
+export declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable, }: CreateOpenAIToolsAgentParams): Promise<RunnableMultiActionAgent>;

package/dist/agents/openai_tools/index.js

@@ -2,6 +2,7 @@ import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnable
 import { convertToOpenAITool } from "@langchain/core/utils/function_calling";
 import { formatToOpenAIToolMessages } from "../format_scratchpad/openai_tools.js";
 import { OpenAIToolsAgentOutputParser, } from "../openai/output_parser.js";
+import { RunnableMultiActionAgent } from "../agent.js";
 export { OpenAIToolsAgentOutputParser };
 /**
  * Create an agent that uses OpenAI-style tool calling.
@@ -59,7 +60,7 @@ export { OpenAIToolsAgentOutputParser };
  * });
  * ```
  */
-export async function createOpenAIToolsAgent({ llm, tools, prompt, }) {
+export 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".`,
@@ -75,5 +76,9 @@ export async function createOpenAIToolsAgent({ llm, tools, prompt, }) {
         modelWithTools,
         new OpenAIToolsAgentOutputParser(),
     ]);
-    return agent;
+    return new RunnableMultiActionAgent({
+        runnable: agent,
+        defaultRunName: "OpenAIToolsAgent",
+        streamRunnable,
+    });
 }