@langchain/langgraph 0.2.26 → 0.2.28

package/dist/graph/state.js

@@ -1,14 +1,14 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { _coerceToRunnable, Runnable, } from "@langchain/core/runnables";
 import { isBaseChannel } from "../channels/base.js";
-import { END, CompiledGraph, Graph, START, } from "./graph.js";
+import { END, CompiledGraph, Graph, START, Branch, } from "./graph.js";
 import { ChannelWrite, PASSTHROUGH, SKIP_WRITE, } from "../pregel/write.js";
 import { ChannelRead, PregelNode } from "../pregel/read.js";
 import { NamedBarrierValue } from "../channels/named_barrier_value.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { RunnableCallable } from "../utils.js";
-import { _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_HIDDEN, } from "../constants.js";
-import { InvalidUpdateError } from "../errors.js";
+import { _isCommand, _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, Command, SELF, TAG_HIDDEN, } from "../constants.js";
+import { InvalidUpdateError, ParentCommand } from "../errors.js";
 import { getChannel, } from "./annotation.js";
 import { isConfiguredManagedValue } from "../managed/base.js";
 import { isPregelLike } from "../pregel/utils/subgraph.js";
@@ -300,6 +300,14 @@ export class StateGraph extends Graph {
         for (const [key, node] of Object.entries(this.nodes)) {
             compiled.attachNode(key, node);
         }
+        compiled.attachBranch(START, SELF, _getControlBranch(), {
+            withReader: false,
+        });
+        for (const [key] of Object.entries(this.nodes)) {
+            compiled.attachBranch(key, SELF, _getControlBranch(), {
+                withReader: false,
+            });
+        }
         for (const [start, end] of this.edges) {
             compiled.attachEdge(start, end);
         }
@@ -335,13 +343,30 @@ function _getChannels(schema) {
 export class CompiledStateGraph extends CompiledGraph {
     attachNode(key, node) {
         const stateKeys = Object.keys(this.builder.channels);
+        function _getRoot(input) {
+            if (_isCommand(input)) {
+                if (input.graph === Command.PARENT) {
+                    return SKIP_WRITE;
+                }
+                return input.update;
+            }
+            return input;
+        }
+        // to avoid name collision below
+        const nodeKey = key;
         function getStateKey(key, input) {
             if (!input) {
                 return SKIP_WRITE;
             }
+            else if (_isCommand(input)) {
+                if (input.graph === Command.PARENT) {
+                    return SKIP_WRITE;
+                }
+                return getStateKey(key, input.update);
+            }
             else if (typeof input !== "object" || Array.isArray(input)) {
                 const typeofInput = Array.isArray(input) ? "array" : typeof input;
-                throw new InvalidUpdateError(`Expected node "${key.toString()}" to return an object, received ${typeofInput}`, {
+                throw new InvalidUpdateError(`Expected node "${nodeKey.toString()}" to return an object, received ${typeofInput}`, {
                     lc_error_code: "INVALID_GRAPH_NODE_RETURN_VALUE",
                 });
             }
@@ -351,7 +376,16 @@ export class CompiledStateGraph extends CompiledGraph {
         }
         // state updaters
         const stateWriteEntries = stateKeys.map((key) => key === ROOT
-            ? { channel: key, value: PASSTHROUGH, skipNone: true }
+            ? {
+                channel: key,
+                value: PASSTHROUGH,
+                skipNone: true,
+                mapper: new RunnableCallable({
+                    func: _getRoot,
+                    trace: false,
+                    recurse: false,
+                }),
+            }
             : {
                 channel: key,
                 value: PASSTHROUGH,
@@ -426,28 +460,29 @@ export class CompiledStateGraph extends CompiledGraph {
             this.nodes[end].triggers.push(start);
         }
     }
-    attachBranch(start, name, branch) {
-        // attach branch publisher
-        this.nodes[start].writers.push(branch.compile(
-        // writer
-        (dests) => {
-            const filteredDests = dests.filter((dest) => dest !== END);
-            if (!filteredDests.length) {
+    attachBranch(start, name, branch, options = { withReader: true }) {
+        const branchWriter = async (packets, config) => {
+            const filteredPackets = packets.filter((p) => p !== END);
+            if (!filteredPackets.length) {
                 return;
             }
-            const writes = filteredDests.map((dest) => {
-                if (_isSend(dest)) {
-                    return dest;
+            const writes = filteredPackets.map((p) => {
+                if (_isSend(p)) {
+                    return p;
                 }
                 return {
-                    channel: `branch:${start}:${name}:${dest}`,
+                    channel: `branch:${start}:${name}:${p}`,
                     value: start,
                 };
             });
-            return new ChannelWrite(writes, [TAG_HIDDEN]);
-        }, 
+            await ChannelWrite.doWrite({ ...config, tags: (config.tags ?? []).concat([TAG_HIDDEN]) }, writes);
+        };
+        // attach branch publisher
+        this.nodes[start].writers.push(branch.run(branchWriter, 
         // reader
-        (config) => ChannelRead.doRead(config, this.streamChannels ?? this.outputChannels, true)));
+        options.withReader
+            ? (config) => ChannelRead.doRead(config, this.streamChannels ?? this.outputChannels, true)
+            : undefined));
         // attach branch subscribers
         const ends = branch.ends
             ? Object.values(branch.ends)
@@ -494,3 +529,28 @@ function isStateGraphArgsWithInputOutputSchemas(obj) {
         obj.input !== undefined &&
         obj.output !== undefined);
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _controlBranch(value) {
+    if (_isSend(value)) {
+        return [value];
+    }
+    if (!_isCommand(value)) {
+        return [];
+    }
+    if (value.graph === Command.PARENT) {
+        throw new ParentCommand(value);
+    }
+    return Array.isArray(value.goto) ? value.goto : [value.goto];
+}
+function _getControlBranch() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const CONTROL_BRANCH_PATH = new RunnableCallable({
+        func: _controlBranch,
+        tags: [TAG_HIDDEN],
+        trace: false,
+        recurse: false,
+    });
+    return new Branch({
+        path: CONTROL_BRANCH_PATH,
+    });
+}

package/dist/prebuilt/index.d.ts

@@ -1,5 +1,5 @@
 export { type AgentExecutorState, createAgentExecutor, } from "./agent_executor.js";
 export { type FunctionCallingExecutorState, createFunctionCallingExecutor, } from "./chat_agent_executor.js";
-export { type AgentState, createReactAgent } from "./react_agent_executor.js";
+export { type AgentState, type CreateReactAgentParams, createReactAgent, } from "./react_agent_executor.js";
 export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition, type ToolNodeOptions } from "./tool_node.js";

package/dist/prebuilt/index.js

@@ -1,5 +1,5 @@
 export { createAgentExecutor, } from "./agent_executor.js";
 export { createFunctionCallingExecutor, } from "./chat_agent_executor.js";
-export { createReactAgent } from "./react_agent_executor.js";
+export { createReactAgent, } from "./react_agent_executor.js";
 export { ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition } from "./tool_node.js";

package/dist/prebuilt/react_agent_executor.cjs

@@ -3,20 +3,70 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReactAgent = void 0;
 const messages_1 = require("@langchain/core/messages");
 const runnables_1 = require("@langchain/core/runnables");
-const prompts_1 = require("@langchain/core/prompts");
 const index_js_1 = require("../graph/index.cjs");
 const messages_annotation_js_1 = require("../graph/messages_annotation.cjs");
 const tool_node_js_1 = require("./tool_node.cjs");
+function _convertMessageModifierToStateModifier(messageModifier) {
+    // Handle string or SystemMessage
+    if (typeof messageModifier === "string" ||
+        ((0, messages_1.isBaseMessage)(messageModifier) && messageModifier._getType() === "system")) {
+        return messageModifier;
+    }
+    // Handle callable function
+    if (typeof messageModifier === "function") {
+        return async (state) => messageModifier(state.messages);
+    }
+    // Handle Runnable
+    if (runnables_1.Runnable.isRunnable(messageModifier)) {
+        return runnables_1.RunnableLambda.from((state) => state.messages).pipe(messageModifier);
+    }
+    throw new Error(`Unexpected type for messageModifier: ${typeof messageModifier}`);
+}
+function _getStateModifierRunnable(stateModifier) {
+    let stateModifierRunnable;
+    if (stateModifier == null) {
+        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => state.messages).withConfig({ runName: "state_modifier" });
+    }
+    else if (typeof stateModifier === "string") {
+        const systemMessage = new messages_1.SystemMessage(stateModifier);
+        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => {
+            return [systemMessage, ...(state.messages ?? [])];
+        }).withConfig({ runName: "state_modifier" });
+    }
+    else if ((0, messages_1.isBaseMessage)(stateModifier) &&
+        stateModifier._getType() === "system") {
+        stateModifierRunnable = runnables_1.RunnableLambda.from((state) => [
+            stateModifier,
+            ...state.messages,
+        ]).withConfig({ runName: "state_modifier" });
+    }
+    else if (typeof stateModifier === "function") {
+        stateModifierRunnable = runnables_1.RunnableLambda.from(stateModifier).withConfig({
+            runName: "state_modifier",
+        });
+    }
+    else if (runnables_1.Runnable.isRunnable(stateModifier)) {
+        stateModifierRunnable = stateModifier;
+    }
+    else {
+        throw new Error(`Got unexpected type for 'stateModifier': ${typeof stateModifier}`);
+    }
+    return stateModifierRunnable;
+}
+function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
+    // Check if both modifiers exist
+    if (stateModifier != null && messageModifier != null) {
+        throw new Error("Expected value for either stateModifier or messageModifier, got values for both");
+    }
+    // Convert message modifier to state modifier if necessary
+    if (stateModifier == null && messageModifier != null) {
+        // eslint-disable-next-line no-param-reassign
+        stateModifier = _convertMessageModifierToStateModifier(messageModifier);
+    }
+    return _getStateModifierRunnable(stateModifier);
+}
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
- * @param params.llm The chat model that can utilize OpenAI-style tool calling.
- * @param params.tools A list of tools or a ToolNode.
- * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
- * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
- * @param params.interruptBefore An optional list of node names to interrupt before running.
- * @param params.interruptAfter An optional list of node names to interrupt after running.
- * @returns A prebuilt compiled graph.
  *
  * @example
  * ```ts
@@ -58,7 +108,7 @@ const tool_node_js_1 = require("./tool_node.cjs");
  * ```
  */
 function createReactAgent(params) {
-    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = params;
+    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -70,7 +120,9 @@ function createReactAgent(params) {
         throw new Error(`llm ${llm} must define bindTools method.`);
     }
     const modelWithTools = llm.bindTools(toolClasses);
-    const modelRunnable = _createModelWrapper(modelWithTools, messageModifier);
+    // we're passing store here for validation
+    const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
+    const modelRunnable = preprocessor.pipe(modelWithTools);
     const shouldContinue = (state) => {
         const { messages } = state;
         const lastMessage = messages[messages.length - 1];
@@ -83,9 +135,8 @@ function createReactAgent(params) {
         }
     };
     const callModel = async (state, config) => {
-        const { messages } = state;
         // TODO: Auto-promote streaming.
-        return { messages: [await modelRunnable.invoke(messages, config)] };
+        return { messages: [await modelRunnable.invoke(state, config)] };
     };
     const workflow = new index_js_1.StateGraph(messages_annotation_js_1.MessagesAnnotation)
         .addNode("agent", callModel)
@@ -100,39 +151,7 @@ function createReactAgent(params) {
         checkpointer: checkpointSaver,
         interruptBefore,
         interruptAfter,
+        store,
     });
 }
 exports.createReactAgent = createReactAgent;
-function _createModelWrapper(modelWithTools, messageModifier) {
-    if (!messageModifier) {
-        return modelWithTools;
-    }
-    const endict = runnables_1.RunnableLambda.from((messages) => ({
-        messages,
-    }));
-    if (typeof messageModifier === "string") {
-        const systemMessage = new messages_1.SystemMessage(messageModifier);
-        const prompt = prompts_1.ChatPromptTemplate.fromMessages([
-            systemMessage,
-            ["placeholder", "{messages}"],
-        ]);
-        return endict.pipe(prompt).pipe(modelWithTools);
-    }
-    if (typeof messageModifier === "function") {
-        const lambda = runnables_1.RunnableLambda.from(messageModifier).withConfig({
-            runName: "message_modifier",
-        });
-        return lambda.pipe(modelWithTools);
-    }
-    if (runnables_1.Runnable.isRunnable(messageModifier)) {
-        return messageModifier.pipe(modelWithTools);
-    }
-    if (messageModifier._getType() === "system") {
-        const prompt = prompts_1.ChatPromptTemplate.fromMessages([
-            messageModifier,
-            ["placeholder", "{messages}"],
-        ]);
-        return endict.pipe(prompt).pipe(modelWithTools);
-    }
-    throw new Error(`Unsupported message modifier type: ${typeof messageModifier}`);
-}

package/dist/prebuilt/react_agent_executor.d.ts

@@ -1,34 +1,88 @@
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { BaseMessage, SystemMessage } from "@langchain/core/messages";
+import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
-import { All, BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
-import { START } from "../graph/index.js";
+import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
+import { START, CompiledStateGraph } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
-import { CompiledStateGraph } from "../graph/state.js";
 import { ToolNode } from "./tool_node.js";
+import { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
 export interface AgentState {
     messages: BaseMessage[];
 }
 export type N = typeof START | "agent" | "tools";
+export type StateModifier = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;
+/** @deprecated Use StateModifier instead. */
+export type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
 export type CreateReactAgentParams = {
+    /** The chat model that can utilize OpenAI-style tool calling. */
     llm: BaseChatModel;
+    /** A list of tools or a ToolNode. */
     tools: ToolNode<typeof MessagesAnnotation.State> | (StructuredToolInterface | RunnableToolLike)[];
-    messageModifier?: SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
+    /**
+     * @deprecated
+     * Use stateModifier instead. stateModifier works the same as
+     * messageModifier in that it runs right before calling the chat model,
+     * but if passed as a function, it takes the full graph state as
+     * input whenever a tool is called rather than a list of messages.
+     *
+     * If a function is passed, it should return a list of messages to
+     * pass directly to the chat model.
+     *
+     * @example
+     * ```ts
+     * import { ChatOpenAI } from "@langchain/openai";
+     * import { MessagesAnnotation } from "@langchain/langgraph";
+     * import { createReactAgent } from "@langchain/langgraph/prebuilt";
+     * import { type BaseMessage, SystemMessage } from "@langchain/core/messages";
+     *
+     * const model = new ChatOpenAI({
+     *   model: "gpt-4o-mini",
+     * });
+     *
+     * const tools = [...];
+     *
+     * // Deprecated style with messageModifier
+     * const deprecated = createReactAgent({
+     *   llm,
+     *   tools,
+     *   messageModifier: async (messages: BaseMessage[]) => {
+     *     return [new SystemMessage("You are a pirate")].concat(messages);
+     *   }
+     * });
+     *
+     * // New style with stateModifier
+     * const agent = createReactAgent({
+     *   llm,
+     *   tools,
+     *   stateModifier: async (state: typeof MessagesAnnotation.State) => {
+     *     return [new SystemMessage("You are a pirate.")].concat(messages);
+     *   }
+     * });
+     * ```
+     */
+    messageModifier?: MessageModifier;
+    /**
+     * An optional state modifier. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.
+     *
+     * Can take a few different forms:
+     *
+     * - SystemMessage: this is added to the beginning of the list of messages in state["messages"].
+     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state["messages"].
+     * - Function: This function should take in full graph state and the output is then passed to the language model.
+     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.
+     */
+    stateModifier?: StateModifier;
+    /** An optional checkpoint saver to persist the agent's state. */
     checkpointSaver?: BaseCheckpointSaver;
+    /** An optional list of node names to interrupt before running. */
     interruptBefore?: N[] | All;
+    /** An optional list of node names to interrupt after running. */
     interruptAfter?: N[] | All;
+    store?: BaseStore;
 };
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
- * @param params.llm The chat model that can utilize OpenAI-style tool calling.
- * @param params.tools A list of tools or a ToolNode.
- * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
- * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
- * @param params.interruptBefore An optional list of node names to interrupt before running.
- * @param params.interruptAfter An optional list of node names to interrupt after running.
- * @returns A prebuilt compiled graph.
  *
  * @example
  * ```ts

package/dist/prebuilt/react_agent_executor.js

@@ -1,19 +1,69 @@
-import { isAIMessage, SystemMessage, } from "@langchain/core/messages";
+import { isAIMessage, isBaseMessage, SystemMessage, } from "@langchain/core/messages";
 import { Runnable, RunnableLambda, } from "@langchain/core/runnables";
-import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { END, START, StateGraph } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { ToolNode } from "./tool_node.js";
+function _convertMessageModifierToStateModifier(messageModifier) {
+    // Handle string or SystemMessage
+    if (typeof messageModifier === "string" ||
+        (isBaseMessage(messageModifier) && messageModifier._getType() === "system")) {
+        return messageModifier;
+    }
+    // Handle callable function
+    if (typeof messageModifier === "function") {
+        return async (state) => messageModifier(state.messages);
+    }
+    // Handle Runnable
+    if (Runnable.isRunnable(messageModifier)) {
+        return RunnableLambda.from((state) => state.messages).pipe(messageModifier);
+    }
+    throw new Error(`Unexpected type for messageModifier: ${typeof messageModifier}`);
+}
+function _getStateModifierRunnable(stateModifier) {
+    let stateModifierRunnable;
+    if (stateModifier == null) {
+        stateModifierRunnable = RunnableLambda.from((state) => state.messages).withConfig({ runName: "state_modifier" });
+    }
+    else if (typeof stateModifier === "string") {
+        const systemMessage = new SystemMessage(stateModifier);
+        stateModifierRunnable = RunnableLambda.from((state) => {
+            return [systemMessage, ...(state.messages ?? [])];
+        }).withConfig({ runName: "state_modifier" });
+    }
+    else if (isBaseMessage(stateModifier) &&
+        stateModifier._getType() === "system") {
+        stateModifierRunnable = RunnableLambda.from((state) => [
+            stateModifier,
+            ...state.messages,
+        ]).withConfig({ runName: "state_modifier" });
+    }
+    else if (typeof stateModifier === "function") {
+        stateModifierRunnable = RunnableLambda.from(stateModifier).withConfig({
+            runName: "state_modifier",
+        });
+    }
+    else if (Runnable.isRunnable(stateModifier)) {
+        stateModifierRunnable = stateModifier;
+    }
+    else {
+        throw new Error(`Got unexpected type for 'stateModifier': ${typeof stateModifier}`);
+    }
+    return stateModifierRunnable;
+}
+function _getModelPreprocessingRunnable(stateModifier, messageModifier) {
+    // Check if both modifiers exist
+    if (stateModifier != null && messageModifier != null) {
+        throw new Error("Expected value for either stateModifier or messageModifier, got values for both");
+    }
+    // Convert message modifier to state modifier if necessary
+    if (stateModifier == null && messageModifier != null) {
+        // eslint-disable-next-line no-param-reassign
+        stateModifier = _convertMessageModifierToStateModifier(messageModifier);
+    }
+    return _getStateModifierRunnable(stateModifier);
+}
 /**
  * Creates a StateGraph agent that relies on a chat model utilizing tool calling.
- * @param params.llm The chat model that can utilize OpenAI-style tool calling.
- * @param params.tools A list of tools or a ToolNode.
- * @param params.messageModifier An optional message modifier to apply to messages before being passed to the LLM.
- * Can be a SystemMessage, string, function that takes and returns a list of messages, or a Runnable.
- * @param params.checkpointer An optional checkpoint saver to persist the agent's state.
- * @param params.interruptBefore An optional list of node names to interrupt before running.
- * @param params.interruptAfter An optional list of node names to interrupt after running.
- * @returns A prebuilt compiled graph.
  *
  * @example
  * ```ts
@@ -55,7 +105,7 @@ import { ToolNode } from "./tool_node.js";
  * ```
  */
 export function createReactAgent(params) {
-    const { llm, tools, messageModifier, checkpointSaver, interruptBefore, interruptAfter, } = params;
+    const { llm, tools, messageModifier, stateModifier, checkpointSaver, interruptBefore, interruptAfter, store, } = params;
     let toolClasses;
     if (!Array.isArray(tools)) {
         toolClasses = tools.tools;
@@ -67,7 +117,9 @@ export function createReactAgent(params) {
         throw new Error(`llm ${llm} must define bindTools method.`);
     }
     const modelWithTools = llm.bindTools(toolClasses);
-    const modelRunnable = _createModelWrapper(modelWithTools, messageModifier);
+    // we're passing store here for validation
+    const preprocessor = _getModelPreprocessingRunnable(stateModifier, messageModifier);
+    const modelRunnable = preprocessor.pipe(modelWithTools);
     const shouldContinue = (state) => {
         const { messages } = state;
         const lastMessage = messages[messages.length - 1];
@@ -80,9 +132,8 @@ export function createReactAgent(params) {
         }
     };
     const callModel = async (state, config) => {
-        const { messages } = state;
         // TODO: Auto-promote streaming.
-        return { messages: [await modelRunnable.invoke(messages, config)] };
+        return { messages: [await modelRunnable.invoke(state, config)] };
     };
     const workflow = new StateGraph(MessagesAnnotation)
         .addNode("agent", callModel)
@@ -97,38 +148,6 @@ export function createReactAgent(params) {
         checkpointer: checkpointSaver,
         interruptBefore,
         interruptAfter,
+        store,
     });
 }
-function _createModelWrapper(modelWithTools, messageModifier) {
-    if (!messageModifier) {
-        return modelWithTools;
-    }
-    const endict = RunnableLambda.from((messages) => ({
-        messages,
-    }));
-    if (typeof messageModifier === "string") {
-        const systemMessage = new SystemMessage(messageModifier);
-        const prompt = ChatPromptTemplate.fromMessages([
-            systemMessage,
-            ["placeholder", "{messages}"],
-        ]);
-        return endict.pipe(prompt).pipe(modelWithTools);
-    }
-    if (typeof messageModifier === "function") {
-        const lambda = RunnableLambda.from(messageModifier).withConfig({
-            runName: "message_modifier",
-        });
-        return lambda.pipe(modelWithTools);
-    }
-    if (Runnable.isRunnable(messageModifier)) {
-        return messageModifier.pipe(modelWithTools);
-    }
-    if (messageModifier._getType() === "system") {
-        const prompt = ChatPromptTemplate.fromMessages([
-            messageModifier,
-            ["placeholder", "{messages}"],
-        ]);
-        return endict.pipe(prompt).pipe(modelWithTools);
-    }
-    throw new Error(`Unsupported message modifier type: ${typeof messageModifier}`);
-}

package/dist/prebuilt/tool_node.cjs

@@ -4,6 +4,7 @@ exports.toolsCondition = exports.ToolNode = void 0;
 const messages_1 = require("@langchain/core/messages");
 const utils_js_1 = require("../utils.cjs");
 const graph_js_1 = require("../graph/graph.cjs");
+const errors_js_1 = require("../errors.cjs");
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple
@@ -178,6 +179,12 @@ class ToolNode extends utils_js_1.RunnableCallable {
                 if (!this.handleToolErrors) {
                     throw e;
                 }
+                if ((0, errors_js_1.isGraphInterrupt)(e.name)) {
+                    // `NodeInterrupt` errors are a breakpoint to bring a human into the loop.
+                    // As such, they are not recoverable by the agent and shouldn't be fed
+                    // back. Instead, re-throw these errors even when `handleToolErrors = true`.
+                    throw e;
+                }
                 return new messages_1.ToolMessage({
                     content: `Error: ${e.message}\n Please fix your mistakes.`,
                     name: call.name,

package/dist/prebuilt/tool_node.js

@@ -1,6 +1,7 @@
 import { ToolMessage, isBaseMessage, } from "@langchain/core/messages";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
+import { isGraphInterrupt } from "../errors.js";
 /**
  * A node that runs the tools requested in the last AIMessage. It can be used
  * either in StateGraph with a "messages" key or in MessageGraph. If multiple
@@ -175,6 +176,12 @@ export class ToolNode extends RunnableCallable {
                 if (!this.handleToolErrors) {
                     throw e;
                 }
+                if (isGraphInterrupt(e.name)) {
+                    // `NodeInterrupt` errors are a breakpoint to bring a human into the loop.
+                    // As such, they are not recoverable by the agent and shouldn't be fed
+                    // back. Instead, re-throw these errors even when `handleToolErrors = true`.
+                    throw e;
+                }
                 return new ToolMessage({
                     content: `Error: ${e.message}\n Please fix your mistakes.`,
                     name: call.name,