langchain 0.1.27 → 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,
+    });
 }

package/dist/agents/react/index.cjs

@@ -5,6 +5,7 @@ const runnables_1 = require("@langchain/core/runnables");
 const render_js_1 = require("../../tools/render.cjs");
 const log_js_1 = require("../format_scratchpad/log.cjs");
 const output_parser_js_1 = require("./output_parser.cjs");
+const agent_js_1 = require("../agent.cjs");
 /**
  * Create an agent that uses ReAct prompting.
  * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
@@ -48,7 +49,7 @@ const output_parser_js_1 = require("./output_parser.cjs");
  * });
  * ```
  */
-async function createReactAgent({ llm, tools, prompt, }) {
+async function createReactAgent({ llm, tools, prompt, streamRunnable, }) {
     const missingVariables = ["tools", "tool_names", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
     if (missingVariables.length > 0) {
         throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
@@ -72,6 +73,10 @@ async function createReactAgent({ llm, tools, prompt, }) {
             toolNames,
         }),
     ]);
-    return agent;
+    return new agent_js_1.RunnableSingleActionAgent({
+        runnable: agent,
+        defaultRunName: "ReactAgent",
+        streamRunnable,
+    });
 }
 exports.createReactAgent = createReactAgent;

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

@@ -1,8 +1,7 @@
 import type { ToolInterface } from "@langchain/core/tools";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import type { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-import { RunnableSequence } from "@langchain/core/runnables";
-import { AgentStep } from "@langchain/core/agents";
+import { RunnableSingleActionAgent } from "../agent.js";
 /**
  * Params used by the createXmlAgent function.
  */
@@ -16,6 +15,11 @@ export type CreateReactAgentParams = {
      * `tools`, `tool_names`, and `agent_scratchpad`.
      */
     prompt: BasePromptTemplate;
+    /**
+     * Whether to invoke the underlying model in streaming mode,
+     * allowing streaming of intermediate steps. Defaults to true.
+     */
+    streamRunnable?: boolean;
 };
 /**
  * Create an agent that uses ReAct prompting.
@@ -60,6 +64,4 @@ export type CreateReactAgentParams = {
  * });
  * ```
  */
-export declare function createReactAgent({ llm, tools, prompt, }: CreateReactAgentParams): Promise<RunnableSequence<{
-    steps: AgentStep[];
-}, import("@langchain/core/agents").AgentAction | import("@langchain/core/agents").AgentFinish>>;
+export declare function createReactAgent({ llm, tools, prompt, streamRunnable, }: CreateReactAgentParams): Promise<RunnableSingleActionAgent>;

package/dist/agents/react/index.js

@@ -2,6 +2,7 @@ import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnable
 import { renderTextDescription } from "../../tools/render.js";
 import { formatLogToString } from "../format_scratchpad/log.js";
 import { ReActSingleInputOutputParser } from "./output_parser.js";
+import { RunnableSingleActionAgent } from "../agent.js";
 /**
  * Create an agent that uses ReAct prompting.
  * @param params Params required to create the agent. Includes an LLM, tools, and prompt.
@@ -45,7 +46,7 @@ import { ReActSingleInputOutputParser } from "./output_parser.js";
  * });
  * ```
  */
-export async function createReactAgent({ llm, tools, prompt, }) {
+export async function createReactAgent({ llm, tools, prompt, streamRunnable, }) {
     const missingVariables = ["tools", "tool_names", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
     if (missingVariables.length > 0) {
         throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
@@ -69,5 +70,9 @@ export async function createReactAgent({ llm, tools, prompt, }) {
             toolNames,
         }),
     ]);
-    return agent;
+    return new RunnableSingleActionAgent({
+        runnable: agent,
+        defaultRunName: "ReactAgent",
+        streamRunnable,
+    });
 }

package/dist/agents/structured_chat/index.cjs

@@ -210,7 +210,7 @@ exports.StructuredChatAgent = StructuredChatAgent;
  * });
  * ```
  */
-async function createStructuredChatAgent({ llm, tools, prompt, }) {
+async function createStructuredChatAgent({ llm, tools, prompt, streamRunnable, }) {
     const missingVariables = ["tools", "tool_names", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
     if (missingVariables.length > 0) {
         throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
@@ -234,6 +234,10 @@ async function createStructuredChatAgent({ llm, tools, prompt, }) {
             toolNames,
         }),
     ]);
-    return agent;
+    return new agent_js_1.RunnableSingleActionAgent({
+        runnable: agent,
+        defaultRunName: "StructuredChatAgent",
+        streamRunnable,
+    });
 }
 exports.createStructuredChatAgent = createStructuredChatAgent;

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

@@ -1,11 +1,10 @@
 import type { StructuredToolInterface } from "@langchain/core/tools";
 import type { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-import { RunnableSequence } from "@langchain/core/runnables";
 import type { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseMessagePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
 import { AgentStep } from "@langchain/core/agents";
 import { Optional } from "../../types/type-utils.js";
-import { Agent, AgentArgs, OutputParserArgs } from "../agent.js";
+import { Agent, AgentArgs, OutputParserArgs, RunnableSingleActionAgent } from "../agent.js";
 import { AgentInput } from "../types.js";
 import { StructuredChatOutputParserWithRetries } from "./outputParser.js";
 /**
@@ -106,6 +105,11 @@ export type CreateStructuredChatAgentParams = {
      * `tools`, `tool_names`, and `agent_scratchpad`.
      */
     prompt: BasePromptTemplate;
+    /**
+     * Whether to invoke the underlying model in streaming mode,
+     * allowing streaming of intermediate steps. Defaults to true.
+     */
+    streamRunnable?: boolean;
 };
 /**
  * Create an agent aimed at supporting tools with multiple inputs.
@@ -163,6 +167,4 @@ export type CreateStructuredChatAgentParams = {
  * });
  * ```
  */
-export declare function createStructuredChatAgent({ llm, tools, prompt, }: CreateStructuredChatAgentParams): Promise<RunnableSequence<{
-    steps: AgentStep[];
-}, import("@langchain/core/agents").AgentAction | import("@langchain/core/agents").AgentFinish>>;
+export declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable, }: CreateStructuredChatAgentParams): Promise<RunnableSingleActionAgent>;

package/dist/agents/structured_chat/index.js

@@ -2,7 +2,7 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate, PromptTemplate, } from "@langchain/core/prompts";
 import { LLMChain } from "../../chains/llm_chain.js";
-import { Agent } from "../agent.js";
+import { Agent, RunnableSingleActionAgent, } from "../agent.js";
 import { StructuredChatOutputParserWithRetries } from "./outputParser.js";
 import { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from "./prompt.js";
 import { renderTextDescriptionAndArgs } from "../../tools/render.js";
@@ -206,7 +206,7 @@ export class StructuredChatAgent extends Agent {
  * });
  * ```
  */
-export async function createStructuredChatAgent({ llm, tools, prompt, }) {
+export async function createStructuredChatAgent({ llm, tools, prompt, streamRunnable, }) {
     const missingVariables = ["tools", "tool_names", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
     if (missingVariables.length > 0) {
         throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
@@ -230,5 +230,9 @@ export async function createStructuredChatAgent({ llm, tools, prompt, }) {
             toolNames,
         }),
     ]);
-    return agent;
+    return new RunnableSingleActionAgent({
+        runnable: agent,
+        defaultRunName: "StructuredChatAgent",
+        streamRunnable,
+    });
 }

package/dist/agents/types.d.ts

@@ -16,16 +16,34 @@ export interface AgentInput {
     allowedTools?: string[];
 }
 /**
- * Interface defining the input for creating an agent that uses runnables.
- * It includes the Runnable instance, and an optional list of stop strings.
+ * Interface defining the input for creating a single action agent
+ * that uses runnables.
  */
-export interface RunnableAgentInput {
+export interface RunnableSingleActionAgentInput {
+    runnable: Runnable<ChainValues & {
+        agent_scratchpad?: string | BaseMessage[];
+        stop?: string[];
+    }, AgentAction | AgentFinish>;
+    streamRunnable?: boolean;
+    defaultRunName?: string;
+}
+/**
+ * Interface defining the input for creating a multi-action agent that uses
+ * runnables. It includes the Runnable instance, and an optional list of
+ * stop strings.
+ */
+export interface RunnableMultiActionAgentInput {
     runnable: Runnable<ChainValues & {
         agent_scratchpad?: string | BaseMessage[];
         stop?: string[];
     }, AgentAction[] | AgentAction | AgentFinish>;
+    streamRunnable?: boolean;
+    defaultRunName?: string;
     stop?: string[];
 }
+/** @deprecated Renamed to RunnableMultiActionAgentInput. */
+export interface RunnableAgentInput extends RunnableMultiActionAgentInput {
+}
 /**
  * Abstract class representing an output parser specifically for agent
  * actions and finishes in LangChain. It extends the `BaseOutputParser`

package/dist/agents/xml/index.cjs

@@ -156,7 +156,7 @@ exports.XMLAgent = XMLAgent;
  * });
  * ```
  */
-async function createXmlAgent({ llm, tools, prompt, }) {
+async function createXmlAgent({ llm, tools, prompt, streamRunnable, }) {
     const missingVariables = ["tools", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
     if (missingVariables.length > 0) {
         throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
@@ -176,6 +176,10 @@ async function createXmlAgent({ llm, tools, prompt, }) {
         llmWithStop,
         new output_parser_js_1.XMLAgentOutputParser(),
     ]);
-    return agent;
+    return new agent_js_1.RunnableSingleActionAgent({
+        runnable: agent,
+        defaultRunName: "XMLAgent",
+        streamRunnable,
+    });
 }
 exports.createXmlAgent = createXmlAgent;

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

@@ -1,13 +1,12 @@
 import type { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import type { ToolInterface } from "@langchain/core/tools";
-import { RunnableSequence } from "@langchain/core/runnables";
 import type { BasePromptTemplate } from "@langchain/core/prompts";
 import { AgentStep, AgentAction, AgentFinish } from "@langchain/core/agents";
 import { ChainValues } from "@langchain/core/utils/types";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { CallbackManager } from "@langchain/core/callbacks/manager";
 import { LLMChain } from "../../chains/llm_chain.js";
-import { AgentArgs, BaseSingleActionAgent } from "../agent.js";
+import { AgentArgs, BaseSingleActionAgent, RunnableSingleActionAgent } from "../agent.js";
 import { XMLAgentOutputParser } from "./output_parser.js";
 /**
  * Interface for the input to the XMLAgent class.
@@ -62,6 +61,11 @@ export type CreateXmlAgentParams = {
      * `tools` and `agent_scratchpad`.
      */
     prompt: BasePromptTemplate;
+    /**
+     * Whether to invoke the underlying model in streaming mode,
+     * allowing streaming of intermediate steps. Defaults to true.
+     */
+    streamRunnable?: boolean;
 };
 /**
  * Create an agent that uses XML to format its logic.
@@ -113,6 +117,4 @@ export type CreateXmlAgentParams = {
  * });
  * ```
  */
-export declare function createXmlAgent({ llm, tools, prompt, }: CreateXmlAgentParams): Promise<RunnableSequence<{
-    steps: AgentStep[];
-}, AgentAction | AgentFinish>>;
+export declare function createXmlAgent({ llm, tools, prompt, streamRunnable, }: CreateXmlAgentParams): Promise<RunnableSingleActionAgent>;

package/dist/agents/xml/index.js

@@ -1,7 +1,7 @@
 import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
 import { AIMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, } from "@langchain/core/prompts";
 import { LLMChain } from "../../chains/llm_chain.js";
-import { BaseSingleActionAgent } from "../agent.js";
+import { BaseSingleActionAgent, RunnableSingleActionAgent, } from "../agent.js";
 import { AGENT_INSTRUCTIONS } from "./prompt.js";
 import { XMLAgentOutputParser } from "./output_parser.js";
 import { renderTextDescription } from "../../tools/render.js";
@@ -152,7 +152,7 @@ export class XMLAgent extends BaseSingleActionAgent {
  * });
  * ```
  */
-export async function createXmlAgent({ llm, tools, prompt, }) {
+export async function createXmlAgent({ llm, tools, prompt, streamRunnable, }) {
     const missingVariables = ["tools", "agent_scratchpad"].filter((v) => !prompt.inputVariables.includes(v));
     if (missingVariables.length > 0) {
         throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
@@ -172,5 +172,9 @@ export async function createXmlAgent({ llm, tools, prompt, }) {
         llmWithStop,
         new XMLAgentOutputParser(),
     ]);
-    return agent;
+    return new RunnableSingleActionAgent({
+        runnable: agent,
+        defaultRunName: "XMLAgent",
+        streamRunnable,
+    });
 }

package/dist/document_loaders/fs/unstructured.cjs

@@ -116,6 +116,30 @@ class UnstructuredLoader extends base_js_1.BaseDocumentLoader {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "multiPageSections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "combineUnderNChars", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "newAfterNChars", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxCharacters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         // Temporary shim to avoid breaking existing users
         // Remove when API keys are enforced by Unstructured and existing code will break anyway
         const isLegacySyntax = typeof optionsOrLegacyFilePath === "string";
@@ -138,6 +162,10 @@ class UnstructuredLoader extends base_js_1.BaseDocumentLoader {
             this.hiResModelName = options.hiResModelName;
             this.includePageBreaks = options.includePageBreaks;
             this.chunkingStrategy = options.chunkingStrategy;
+            this.multiPageSections = options.multiPageSections;
+            this.combineUnderNChars = options.combineUnderNChars;
+            this.newAfterNChars = options.newAfterNChars;
+            this.maxCharacters = options.maxCharacters;
         }
     }
     async _partition() {
@@ -177,6 +205,18 @@ class UnstructuredLoader extends base_js_1.BaseDocumentLoader {
         if (this.chunkingStrategy) {
             formData.append("chunking_strategy", this.chunkingStrategy);
         }
+        if (this.multiPageSections !== undefined) {
+            formData.append("multipage_sections", this.multiPageSections ? "true" : "false");
+        }
+        if (this.combineUnderNChars !== undefined) {
+            formData.append("combine_under_n_chars", String(this.combineUnderNChars));
+        }
+        if (this.newAfterNChars !== undefined) {
+            formData.append("new_after_n_chars", String(this.newAfterNChars));
+        }
+        if (this.maxCharacters !== undefined) {
+            formData.append("max_characters", String(this.maxCharacters));
+        }
         const headers = {
             "UNSTRUCTURED-API-KEY": this.apiKey ?? "",
         };

package/dist/document_loaders/fs/unstructured.d.ts

@@ -54,6 +54,10 @@ export type UnstructuredLoaderOptions = {
     hiResModelName?: StringWithAutocomplete<HiResModelName>;
     includePageBreaks?: boolean;
     chunkingStrategy?: StringWithAutocomplete<ChunkingStrategy>;
+    multiPageSections?: boolean;
+    combineUnderNChars?: number;
+    newAfterNChars?: number;
+    maxCharacters?: number;
 };
 type UnstructuredDirectoryLoaderOptions = UnstructuredLoaderOptions & {
     recursive?: boolean;
@@ -81,6 +85,10 @@ export declare class UnstructuredLoader extends BaseDocumentLoader {
     private hiResModelName?;
     private includePageBreaks?;
     private chunkingStrategy?;
+    private multiPageSections?;
+    private combineUnderNChars?;
+    private newAfterNChars?;
+    private maxCharacters?;
     constructor(filePathOrLegacyApiUrl: string, optionsOrLegacyFilePath?: UnstructuredLoaderOptions | string);
     _partition(): Promise<Element[]>;
     load(): Promise<Document[]>;

package/dist/document_loaders/fs/unstructured.js

@@ -112,6 +112,30 @@ export class UnstructuredLoader extends BaseDocumentLoader {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "multiPageSections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "combineUnderNChars", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "newAfterNChars", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maxCharacters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         // Temporary shim to avoid breaking existing users
         // Remove when API keys are enforced by Unstructured and existing code will break anyway
         const isLegacySyntax = typeof optionsOrLegacyFilePath === "string";
@@ -134,6 +158,10 @@ export class UnstructuredLoader extends BaseDocumentLoader {
             this.hiResModelName = options.hiResModelName;
             this.includePageBreaks = options.includePageBreaks;
             this.chunkingStrategy = options.chunkingStrategy;
+            this.multiPageSections = options.multiPageSections;
+            this.combineUnderNChars = options.combineUnderNChars;
+            this.newAfterNChars = options.newAfterNChars;
+            this.maxCharacters = options.maxCharacters;
         }
     }
     async _partition() {
@@ -173,6 +201,18 @@ export class UnstructuredLoader extends BaseDocumentLoader {
         if (this.chunkingStrategy) {
             formData.append("chunking_strategy", this.chunkingStrategy);
         }
+        if (this.multiPageSections !== undefined) {
+            formData.append("multipage_sections", this.multiPageSections ? "true" : "false");
+        }
+        if (this.combineUnderNChars !== undefined) {
+            formData.append("combine_under_n_chars", String(this.combineUnderNChars));
+        }
+        if (this.newAfterNChars !== undefined) {
+            formData.append("new_after_n_chars", String(this.newAfterNChars));
+        }
+        if (this.maxCharacters !== undefined) {
+            formData.append("max_characters", String(this.maxCharacters));
+        }
         const headers = {
             "UNSTRUCTURED-API-KEY": this.apiKey ?? "",
         };

package/dist/output_parsers/fix.cjs

@@ -4,6 +4,9 @@ exports.OutputFixingParser = void 0;
 const output_parsers_1 = require("@langchain/core/output_parsers");
 const llm_chain_js_1 = require("../chains/llm_chain.cjs");
 const prompts_js_1 = require("./prompts.cjs");
+function isLLMChain(x) {
+    return (x.prompt !== undefined && x.llm !== undefined);
+}
 /**
  * Class that extends the BaseOutputParser to handle situations where the
  * initial parsing attempt fails. It contains a retryChain for retrying
@@ -70,13 +73,22 @@ class OutputFixingParser extends output_parsers_1.BaseOutputParser {
         catch (e) {
             // eslint-disable-next-line no-instanceof/no-instanceof
             if (e instanceof output_parsers_1.OutputParserException) {
-                const result = await this.retryChain.call({
+                const retryInput = {
                     instructions: this.parser.getFormatInstructions(),
                     completion,
                     error: e,
-                }, callbacks);
-                const newCompletion = result[this.retryChain.outputKey];
-                return this.parser.parse(newCompletion);
+                };
+                if (isLLMChain(this.retryChain)) {
+                    const result = await this.retryChain.call(retryInput, callbacks);
+                    const newCompletion = result[this.retryChain.outputKey];
+                    return this.parser.parse(newCompletion, callbacks);
+                }
+                else {
+                    const result = await this.retryChain.invoke(retryInput, {
+                        callbacks,
+                    });
+                    return result;
+                }
             }
             throw e;
         }

package/dist/output_parsers/fix.d.ts

@@ -1,8 +1,14 @@
 import type { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { Callbacks } from "@langchain/core/callbacks/manager";
-import { BaseOutputParser } from "@langchain/core/output_parsers";
+import { BaseOutputParser, OutputParserException } from "@langchain/core/output_parsers";
 import { BasePromptTemplate } from "@langchain/core/prompts";
+import { Runnable } from "@langchain/core/runnables";
 import { LLMChain } from "../chains/llm_chain.js";
+interface OutputFixingParserRetryInput {
+    instructions: string;
+    completion: string;
+    error: OutputParserException;
+}
 /**
  * Class that extends the BaseOutputParser to handle situations where the
  * initial parsing attempt fails. It contains a retryChain for retrying
@@ -13,7 +19,7 @@ export declare class OutputFixingParser<T> extends BaseOutputParser<T> {
     lc_namespace: string[];
     lc_serializable: boolean;
     parser: BaseOutputParser<T>;
-    retryChain: LLMChain;
+    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;
     /**
      * Static method to create a new instance of OutputFixingParser using a
      * given language model, parser, and optional fields.
@@ -27,7 +33,7 @@ export declare class OutputFixingParser<T> extends BaseOutputParser<T> {
     }): OutputFixingParser<T>;
     constructor({ parser, retryChain, }: {
         parser: BaseOutputParser<T>;
-        retryChain: LLMChain;
+        retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;
     });
     /**
      * Method to parse the completion using the parser. If the initial parsing
@@ -44,3 +50,4 @@ export declare class OutputFixingParser<T> extends BaseOutputParser<T> {
      */
     getFormatInstructions(): string;
 }
+export {};

package/dist/output_parsers/fix.js

@@ -1,6 +1,9 @@
 import { BaseOutputParser, OutputParserException, } from "@langchain/core/output_parsers";
 import { LLMChain } from "../chains/llm_chain.js";
 import { NAIVE_FIX_PROMPT } from "./prompts.js";
+function isLLMChain(x) {
+    return (x.prompt !== undefined && x.llm !== undefined);
+}
 /**
  * Class that extends the BaseOutputParser to handle situations where the
  * initial parsing attempt fails. It contains a retryChain for retrying
@@ -67,13 +70,22 @@ export class OutputFixingParser extends BaseOutputParser {
         catch (e) {
             // eslint-disable-next-line no-instanceof/no-instanceof
             if (e instanceof OutputParserException) {
-                const result = await this.retryChain.call({
+                const retryInput = {
                     instructions: this.parser.getFormatInstructions(),
                     completion,
                     error: e,
-                }, callbacks);
-                const newCompletion = result[this.retryChain.outputKey];
-                return this.parser.parse(newCompletion);
+                };
+                if (isLLMChain(this.retryChain)) {
+                    const result = await this.retryChain.call(retryInput, callbacks);
+                    const newCompletion = result[this.retryChain.outputKey];
+                    return this.parser.parse(newCompletion, callbacks);
+                }
+                else {
+                    const result = await this.retryChain.invoke(retryInput, {
+                        callbacks,
+                    });
+                    return result;
+                }
             }
             throw e;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "Typescript bindings for langchain",
   "type": "module",
   "engines": {