@langchain/langgraph 1.3.7 → 1.4.1

package/dist/prebuilt/tool_node.js

@@ -122,6 +122,57 @@ const isSendInput = (input) => typeof input === "object" && input != null && "lg
 * }
 * // Returns the messages in the state at each step of execution
 * ```
+*
+* ### Accessing graph state and runtime context from tools
+*
+* Tools executed by a `ToolNode` only receive the arguments produced by the
+* model. To give a tool access to the surrounding graph state or other runtime
+* context, read them from the {@link ToolRuntime} that is passed as the
+* second argument to every tool:
+*
+* - `runtime.state` — the input the `ToolNode` was invoked with. When the
+*   `ToolNode` runs as a graph node (e.g. inside `createReactAgent`), this is
+*   the current graph state. This works in any runtime, including web browsers,
+*   because it does not rely on `node:async_hooks`/`AsyncLocalStorage`.
+* - `runtime.config`, `runtime.context`, `runtime.store`, etc. — other
+*   run-scoped values.
+*
+* @example
+* ```ts
+* import { ToolNode } from "@langchain/langgraph/prebuilt";
+* import { StateGraph, MessagesZodState } from "@langchain/langgraph";
+* import { tool, type ToolRuntime } from "@langchain/core/tools";
+* import { z } from "zod";
+*
+* // Define the graph state with a Zod schema. The extra `userId` key becomes
+* // part of the state that the ToolNode forwards to its tools via `runtime.state`.
+* const AgentState = z.object({
+*   ...MessagesZodState.shape,
+*   userId: z.string(),
+* });
+*
+* const getUserInfo = tool(
+*   async (_input, runtime: ToolRuntime<typeof AgentState>) => {
+*     // Read the current graph state directly from the second argument.
+*     const userId = runtime.state.userId;
+*     return userId === "user_123" ? "User is John Smith" : "Unknown user";
+*   },
+*   {
+*     name: "get_user_info",
+*     description: "Look up user info.",
+*     schema: z.object({}),
+*   }
+* );
+*
+* // Wire the ToolNode into a StateGraph that uses `AgentState`. Because the
+* // node runs with the graph state as its input, the tool can read `userId`.
+* const graph = new StateGraph(AgentState)
+*   .addNode("tools", new ToolNode([getUserInfo]))
+*   .addEdge("__start__", "tools")
+*   .compile();
+*
+* await graph.invoke({ messages: [...], userId: "user_123" });
+* ```
 */
 var ToolNode = class extends RunnableCallable {
 	tools;
@@ -137,14 +188,24 @@ var ToolNode = class extends RunnableCallable {
 		this.tools = tools;
 		this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
 	}
-	async runTool(call, config) {
+	async runTool(call, config, state) {
 		const tool = this.tools.find((tool) => tool.name === call.name);
 		try {
 			if (tool === void 0) throw new Error(`Tool "${call.name}" not found.`);
-			const output = await tool.invoke({
+			const toolCall = {
 				...call,
 				type: "tool_call"
-			}, config);
+			};
+			const runtime = {
+				...config,
+				state,
+				toolCallId: call.id ?? "",
+				config,
+				context: config.context,
+				store: config.store ?? null,
+				writer: config.writer ?? config.configurable?.writer ?? null
+			};
+			const output = await tool.invoke(toolCall, runtime);
 			if (isBaseMessage(output) && output.getType() === "tool" || isCommand(output)) return output;
 			return new ToolMessage({
 				status: "success",
@@ -165,8 +226,10 @@ var ToolNode = class extends RunnableCallable {
 	}
 	async run(input, config) {
 		let outputs;
-		if (isSendInput(input)) outputs = [await this.runTool(input.lg_tool_call, config)];
-		else {
+		if (isSendInput(input)) {
+			const { lg_tool_call: toolCall, ...state } = input;
+			outputs = [await this.runTool(toolCall, config, state)];
+		} else {
 			let messages;
 			if (isBaseMessageArray(input)) messages = input;
 			else if (isMessagesState(input)) messages = input.messages;
@@ -181,7 +244,7 @@ var ToolNode = class extends RunnableCallable {
 				}
 			}
 			if (aiMessage == null || !isAIMessage(aiMessage)) throw new Error("ToolNode only accepts AIMessages as input.");
-			outputs = await Promise.all(aiMessage.tool_calls?.filter((call) => call.id == null || !toolMessageIds.has(call.id)).map((call) => this.runTool(call, config)) ?? []);
+			outputs = await Promise.all(aiMessage.tool_calls?.filter((call) => call.id == null || !toolMessageIds.has(call.id)).map((call) => this.runTool(call, config, input)) ?? []);
 		}
 		if (!outputs.some(isCommand)) return Array.isArray(input) ? outputs : { messages: outputs };
 		const combinedOutputs = [];

package/dist/prebuilt/tool_node.js.map

@@ -1 +1 @@
-{"version":3,"file":"tool_node.js","names":[],"sources":["../../src/prebuilt/tool_node.ts"],"sourcesContent":["import {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isAIMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { RunnableCallable } from \"../utils.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { isGraphInterrupt } from \"../errors.js\";\nimport { END, isCommand, Command, _isSend, Send } from \"../constants.js\";\n\nexport type ToolNodeOptions = {\n  name?: string;\n  tags?: string[];\n  handleToolErrors?: boolean;\n};\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(isBaseMessage);\n\nconst isMessagesState = (\n  input: unknown\n): input is { messages: BaseMessage[] } =>\n  typeof input === \"object\" &&\n  input != null &&\n  \"messages\" in input &&\n  isBaseMessageArray(input.messages);\n\nconst isSendInput = (input: unknown): input is { lg_tool_call: ToolCall } =>\n  typeof input === \"object\" && input != null && \"lg_tool_call\" in input;\n\n/**\n * A node that runs the tools requested in the last AIMessage. It can be used\n * either in StateGraph with a \"messages\" key or in MessageGraph. If multiple\n * tool calls are requested, they will be run in parallel. The output will be\n * a list of ToolMessages, one for each tool call.\n *\n * @example\n * ```ts\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { AIMessage } from \"@langchain/core/messages\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n *\n * @example\n * ```ts\n * import {\n *   StateGraph,\n *   MessagesAnnotation,\n * } from \"@langchain/langgraph\";\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const modelWithTools = new ChatAnthropic({\n *   model: \"claude-3-haiku-20240307\",\n *   temperature: 0\n * }).bindTools(tools);\n *\n * const toolNodeForGraph = new ToolNode(tools)\n *\n * const shouldContinue = (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const lastMessage = messages[messages.length - 1];\n *   if (\"tool_calls\" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {\n *     return \"tools\";\n *   }\n *   return \"__end__\";\n * }\n *\n * const callModel = async (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const response = await modelWithTools.invoke(messages);\n *   return { messages: response };\n * }\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", callModel)\n *   .addNode(\"tools\", toolNodeForGraph)\n *   .addEdge(\"__start__\", \"agent\")\n *   .addConditionalEdges(\"agent\", shouldContinue)\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await graph.stream(inputs, {\n *   streamMode: \"values\",\n * });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class ToolNode<T = any> extends RunnableCallable<T, T> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  handleToolErrors = true;\n\n  trace = false;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({ name, tags, func: (input, config) => this.run(input, config) });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: RunnableConfig\n  ): Promise<ToolMessage | Command> {\n    const tool = this.tools.find((tool) => tool.name === call.name);\n    try {\n      if (tool === undefined) {\n        throw new Error(`Tool \"${call.name}\" not found.`);\n      }\n      const output = await tool.invoke({ ...call, type: \"tool_call\" }, config);\n\n      if (\n        (isBaseMessage(output) && output.getType() === \"tool\") ||\n        isCommand(output)\n      ) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        status: \"success\",\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      if (!this.handleToolErrors) throw e;\n\n      if (isGraphInterrupt(e)) {\n        // `NodeInterrupt` errors are a breakpoint to bring a human into the loop.\n        // As such, they are not recoverable by the agent and shouldn't be fed\n        // back. Instead, re-throw these errors even when `handleToolErrors = true`.\n        throw e;\n      }\n\n      return new ToolMessage({\n        status: \"error\",\n        content: `Error: ${e.message}\\n Please fix your mistakes.`,\n        name: call.name,\n        tool_call_id: call.id ?? \"\",\n      });\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  protected async run(input: unknown, config: RunnableConfig): Promise<T> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(input)) {\n      outputs = [await this.runTool(input.lg_tool_call, config)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(input)) {\n        messages = input;\n      } else if (isMessagesState(input)) {\n        messages = input.messages;\n      } else {\n        throw new Error(\n          \"ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.\"\n        );\n      }\n\n      const toolMessageIds: Set<string> = new Set(\n        messages\n          .filter((msg) => msg.getType() === \"tool\")\n          .map((msg) => (msg as ToolMessage).tool_call_id)\n      );\n\n      let aiMessage: AIMessage | undefined;\n      for (let i = messages.length - 1; i >= 0; i -= 1) {\n        const message = messages[i];\n        if (isAIMessage(message)) {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (aiMessage == null || !isAIMessage(aiMessage)) {\n        throw new Error(\"ToolNode only accepts AIMessages as input.\");\n      }\n\n      outputs = await Promise.all(\n        aiMessage.tool_calls\n          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))\n          .map((call) => this.runTool(call, config)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(input) ? outputs : { messages: outputs }) as T;\n    }\n\n    // Handle mixed Command and non-Command outputs\n    const combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[] = [];\n    let parentCommand: Command | null = null;\n\n    for (const output of outputs) {\n      if (isCommand(output)) {\n        if (\n          output.graph === Command.PARENT &&\n          Array.isArray(output.goto) &&\n          output.goto.every((send) => _isSend(send))\n        ) {\n          if (parentCommand) {\n            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));\n          } else {\n            parentCommand = new Command({\n              graph: Command.PARENT,\n              goto: output.goto,\n            });\n          }\n        } else {\n          combinedOutputs.push(output);\n        }\n      } else {\n        combinedOutputs.push(\n          Array.isArray(input) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as T;\n  }\n}\n\n/**\n * A conditional edge function that determines whether to route to a tools node or end the graph.\n *\n * This function is designed to be used as a conditional edge in a LangGraph state graph to implement\n * the common pattern of checking if an AI message contains tool calls that need to be executed.\n *\n * @param state - The current state of the graph, which can be either:\n *   - An array of `BaseMessage` objects, where the last message is checked for tool calls\n *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array\n *\n * @returns A string indicating the next node to route to:\n *   - `\"tools\"` - If the last message contains tool calls that need to be executed\n *   - `END` - If there are no tool calls, indicating the graph should terminate\n *\n * @example\n * ```typescript\n * import { StateGraph, MessagesAnnotation, END, START } from \"@langchain/langgraph\";\n * import { ToolNode, toolsCondition } from \"@langchain/langgraph/prebuilt\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", agentNode)\n *   .addNode(\"tools\", new ToolNode([searchTool, calculatorTool]))\n *   .addEdge(START, \"agent\")\n *   .addConditionalEdges(\"agent\", toolsCondition, [\"tools\", END])\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n * ```\n *\n * @remarks\n * The function checks the last message in the state for the presence of `tool_calls`.\n * If the message is an `AIMessage` with one or more tool calls, it returns `\"tools\"`,\n * indicating that the graph should route to a tools node (typically a `ToolNode`) to\n * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.\n *\n * This is a common pattern in agentic workflows where an AI model decides whether to\n * use tools or provide a final response.\n */\nexport function toolsCondition(\n  state: BaseMessage[] | typeof MessagesAnnotation.State\n): \"tools\" | typeof END {\n  const message = Array.isArray(state)\n    ? state[state.length - 1]\n    : state.messages[state.messages.length - 1];\n\n  if (\n    message !== undefined &&\n    \"tool_calls\" in message &&\n    ((message as AIMessage).tool_calls?.length ?? 0) > 0\n  ) {\n    return \"tools\";\n  } else {\n    return END;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"tool_node.js","names":[],"sources":["../../src/prebuilt/tool_node.ts"],"sourcesContent":["import {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isAIMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableToolLike } from \"@langchain/core/runnables\";\nimport {\n  DynamicTool,\n  StructuredToolInterface,\n  type ToolRuntime,\n} from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { RunnableCallable } from \"../utils.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { isGraphInterrupt } from \"../errors.js\";\nimport { END, isCommand, Command, _isSend, Send } from \"../constants.js\";\nimport type { LangGraphRunnableConfig } from \"../pregel/runnable_types.js\";\n\nexport type ToolNodeOptions = {\n  name?: string;\n  tags?: string[];\n  handleToolErrors?: boolean;\n};\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(isBaseMessage);\n\nconst isMessagesState = (\n  input: unknown\n): input is { messages: BaseMessage[] } =>\n  typeof input === \"object\" &&\n  input != null &&\n  \"messages\" in input &&\n  isBaseMessageArray(input.messages);\n\nconst isSendInput = (input: unknown): input is { lg_tool_call: ToolCall } =>\n  typeof input === \"object\" && input != null && \"lg_tool_call\" in input;\n\n/**\n * A node that runs the tools requested in the last AIMessage. It can be used\n * either in StateGraph with a \"messages\" key or in MessageGraph. If multiple\n * tool calls are requested, they will be run in parallel. The output will be\n * a list of ToolMessages, one for each tool call.\n *\n * @example\n * ```ts\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { AIMessage } from \"@langchain/core/messages\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n *\n * @example\n * ```ts\n * import {\n *   StateGraph,\n *   MessagesAnnotation,\n * } from \"@langchain/langgraph\";\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const modelWithTools = new ChatAnthropic({\n *   model: \"claude-3-haiku-20240307\",\n *   temperature: 0\n * }).bindTools(tools);\n *\n * const toolNodeForGraph = new ToolNode(tools)\n *\n * const shouldContinue = (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const lastMessage = messages[messages.length - 1];\n *   if (\"tool_calls\" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {\n *     return \"tools\";\n *   }\n *   return \"__end__\";\n * }\n *\n * const callModel = async (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const response = await modelWithTools.invoke(messages);\n *   return { messages: response };\n * }\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", callModel)\n *   .addNode(\"tools\", toolNodeForGraph)\n *   .addEdge(\"__start__\", \"agent\")\n *   .addConditionalEdges(\"agent\", shouldContinue)\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await graph.stream(inputs, {\n *   streamMode: \"values\",\n * });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n *\n * ### Accessing graph state and runtime context from tools\n *\n * Tools executed by a `ToolNode` only receive the arguments produced by the\n * model. To give a tool access to the surrounding graph state or other runtime\n * context, read them from the {@link ToolRuntime} that is passed as the\n * second argument to every tool:\n *\n * - `runtime.state` — the input the `ToolNode` was invoked with. When the\n *   `ToolNode` runs as a graph node (e.g. inside `createReactAgent`), this is\n *   the current graph state. This works in any runtime, including web browsers,\n *   because it does not rely on `node:async_hooks`/`AsyncLocalStorage`.\n * - `runtime.config`, `runtime.context`, `runtime.store`, etc. — other\n *   run-scoped values.\n *\n * @example\n * ```ts\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { StateGraph, MessagesZodState } from \"@langchain/langgraph\";\n * import { tool, type ToolRuntime } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * // Define the graph state with a Zod schema. The extra `userId` key becomes\n * // part of the state that the ToolNode forwards to its tools via `runtime.state`.\n * const AgentState = z.object({\n *   ...MessagesZodState.shape,\n *   userId: z.string(),\n * });\n *\n * const getUserInfo = tool(\n *   async (_input, runtime: ToolRuntime<typeof AgentState>) => {\n *     // Read the current graph state directly from the second argument.\n *     const userId = runtime.state.userId;\n *     return userId === \"user_123\" ? \"User is John Smith\" : \"Unknown user\";\n *   },\n *   {\n *     name: \"get_user_info\",\n *     description: \"Look up user info.\",\n *     schema: z.object({}),\n *   }\n * );\n *\n * // Wire the ToolNode into a StateGraph that uses `AgentState`. Because the\n * // node runs with the graph state as its input, the tool can read `userId`.\n * const graph = new StateGraph(AgentState)\n *   .addNode(\"tools\", new ToolNode([getUserInfo]))\n *   .addEdge(\"__start__\", \"tools\")\n *   .compile();\n *\n * await graph.invoke({ messages: [...], userId: \"user_123\" });\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class ToolNode<T = any> extends RunnableCallable<T, T> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  handleToolErrors = true;\n\n  trace = false;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({ name, tags, func: (input, config) => this.run(input, config) });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: LangGraphRunnableConfig,\n    state: unknown\n  ): Promise<ToolMessage | Command> {\n    const tool = this.tools.find((tool) => tool.name === call.name);\n    try {\n      if (tool === undefined) {\n        throw new Error(`Tool \"${call.name}\" not found.`);\n      }\n      const toolCall = { ...call, type: \"tool_call\" } as ToolCall;\n      const runtime: ToolRuntime = {\n        ...config,\n        state,\n        toolCallId: call.id ?? \"\",\n        config,\n        context: config.context,\n        store: (config.store as ToolRuntime[\"store\"] | undefined) ?? null,\n        writer: config.writer ?? config.configurable?.writer ?? null,\n      };\n      const output = await tool.invoke(toolCall, runtime);\n\n      if (\n        (isBaseMessage(output) && output.getType() === \"tool\") ||\n        isCommand(output)\n      ) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        status: \"success\",\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      if (!this.handleToolErrors) throw e;\n\n      if (isGraphInterrupt(e)) {\n        // `NodeInterrupt` errors are a breakpoint to bring a human into the loop.\n        // As such, they are not recoverable by the agent and shouldn't be fed\n        // back. Instead, re-throw these errors even when `handleToolErrors = true`.\n        throw e;\n      }\n\n      return new ToolMessage({\n        status: \"error\",\n        content: `Error: ${e.message}\\n Please fix your mistakes.`,\n        name: call.name,\n        tool_call_id: call.id ?? \"\",\n      });\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  protected async run(\n    input: unknown,\n    config: LangGraphRunnableConfig\n  ): Promise<T> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(input)) {\n      // Drop the internal `lg_tool_call` routing key so tools only see state.\n      const { lg_tool_call: toolCall, ...state } = input as {\n        lg_tool_call: ToolCall;\n      } & Record<string, unknown>;\n      outputs = [await this.runTool(toolCall, config, state)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(input)) {\n        messages = input;\n      } else if (isMessagesState(input)) {\n        messages = input.messages;\n      } else {\n        throw new Error(\n          \"ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.\"\n        );\n      }\n\n      const toolMessageIds: Set<string> = new Set(\n        messages\n          .filter((msg) => msg.getType() === \"tool\")\n          .map((msg) => (msg as ToolMessage).tool_call_id)\n      );\n\n      let aiMessage: AIMessage | undefined;\n      for (let i = messages.length - 1; i >= 0; i -= 1) {\n        const message = messages[i];\n        if (isAIMessage(message)) {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (aiMessage == null || !isAIMessage(aiMessage)) {\n        throw new Error(\"ToolNode only accepts AIMessages as input.\");\n      }\n\n      outputs = await Promise.all(\n        aiMessage.tool_calls\n          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))\n          .map((call) => this.runTool(call, config, input)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(input) ? outputs : { messages: outputs }) as T;\n    }\n\n    // Handle mixed Command and non-Command outputs\n    const combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[] = [];\n    let parentCommand: Command | null = null;\n\n    for (const output of outputs) {\n      if (isCommand(output)) {\n        if (\n          output.graph === Command.PARENT &&\n          Array.isArray(output.goto) &&\n          output.goto.every((send) => _isSend(send))\n        ) {\n          if (parentCommand) {\n            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));\n          } else {\n            parentCommand = new Command({\n              graph: Command.PARENT,\n              goto: output.goto,\n            });\n          }\n        } else {\n          combinedOutputs.push(output);\n        }\n      } else {\n        combinedOutputs.push(\n          Array.isArray(input) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as T;\n  }\n}\n\n/**\n * A conditional edge function that determines whether to route to a tools node or end the graph.\n *\n * This function is designed to be used as a conditional edge in a LangGraph state graph to implement\n * the common pattern of checking if an AI message contains tool calls that need to be executed.\n *\n * @param state - The current state of the graph, which can be either:\n *   - An array of `BaseMessage` objects, where the last message is checked for tool calls\n *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array\n *\n * @returns A string indicating the next node to route to:\n *   - `\"tools\"` - If the last message contains tool calls that need to be executed\n *   - `END` - If there are no tool calls, indicating the graph should terminate\n *\n * @example\n * ```typescript\n * import { StateGraph, MessagesAnnotation, END, START } from \"@langchain/langgraph\";\n * import { ToolNode, toolsCondition } from \"@langchain/langgraph/prebuilt\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", agentNode)\n *   .addNode(\"tools\", new ToolNode([searchTool, calculatorTool]))\n *   .addEdge(START, \"agent\")\n *   .addConditionalEdges(\"agent\", toolsCondition, [\"tools\", END])\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n * ```\n *\n * @remarks\n * The function checks the last message in the state for the presence of `tool_calls`.\n * If the message is an `AIMessage` with one or more tool calls, it returns `\"tools\"`,\n * indicating that the graph should route to a tools node (typically a `ToolNode`) to\n * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.\n *\n * This is a common pattern in agentic workflows where an AI model decides whether to\n * use tools or provide a final response.\n */\nexport function toolsCondition(\n  state: BaseMessage[] | typeof MessagesAnnotation.State\n): \"tools\" | typeof END {\n  const message = Array.isArray(state)\n    ? state[state.length - 1]\n    : state.messages[state.messages.length - 1];\n\n  if (\n    message !== undefined &&\n    \"tool_calls\" in message &&\n    ((message as AIMessage).tool_calls?.length ?? 0) > 0\n  ) {\n    return \"tools\";\n  } else {\n    return END;\n  }\n}\n"],"mappings":"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"}

package/dist/pregel/algo.cjs

@@ -53,7 +53,13 @@ function _localRead(checkpoint, channels, task, select, fresh = false) {
 	let values;
 	if (fresh && updated.size > 0) {
 		const localChannels = Object.fromEntries(Object.entries(channels).filter(([k, _]) => updated.has(k)));
-		const newCheckpoint = require_base.createCheckpoint(checkpoint, localChannels, -1);
+		const channelsToSnapshot = /* @__PURE__ */ new Set();
+		for (const k in localChannels) {
+			if (!Object.prototype.hasOwnProperty.call(localChannels, k)) continue;
+			const ch = localChannels[k];
+			if (require_base.isDeltaChannel(ch) && ch.isAvailable()) channelsToSnapshot.add(k);
+		}
+		const newCheckpoint = require_base.createCheckpoint(checkpoint, localChannels, -1, { channelsToSnapshot });
 		const newChannels = require_base.emptyChannels(localChannels, newCheckpoint);
 		_applyWrites((0, _langchain_langgraph_checkpoint.copyCheckpoint)(newCheckpoint), newChannels, [task], void 0, void 0);
 		values = require_io.readChannels({
@@ -76,26 +82,34 @@ const IGNORE = new Set([
 	require_constants.RESUME,
 	require_constants.INTERRUPT,
 	require_constants.RETURN,
-	require_constants.ERROR
+	require_constants.ERROR,
+	require_constants.ERROR_SOURCE_NODE
 ]);
+const RESERVED_SET = new Set(require_constants.RESERVED);
 function _applyWrites(checkpoint, channels, tasks, getNextVersion, triggerToNodes) {
+	const pathCache = /* @__PURE__ */ new Map();
+	for (const task of tasks) pathCache.set(task, task.path?.slice(0, 3) || []);
 	tasks.sort((a, b) => {
-		const aPath = a.path?.slice(0, 3) || [];
-		const bPath = b.path?.slice(0, 3) || [];
+		const aPath = pathCache.get(a);
+		const bPath = pathCache.get(b);
 		for (let i = 0; i < Math.min(aPath.length, bPath.length); i += 1) {
 			if (aPath[i] < bPath[i]) return -1;
 			if (aPath[i] > bPath[i]) return 1;
 		}
 		return aPath.length - bPath.length;
 	});
-	const bumpStep = tasks.some((task) => task.triggers.length > 0);
 	const onlyChannels = require_base.getOnlyChannels(channels);
+	let bumpStep = false;
+	const channelsToConsume = /* @__PURE__ */ new Set();
 	for (const task of tasks) {
+		if (task.triggers.length > 0) bumpStep = true;
 		checkpoint.versions_seen[task.name] ??= {};
-		for (const chan of task.triggers) if (chan in checkpoint.channel_versions) checkpoint.versions_seen[task.name][chan] = checkpoint.channel_versions[chan];
+		for (const chan of task.triggers) {
+			if (chan in checkpoint.channel_versions) checkpoint.versions_seen[task.name][chan] = checkpoint.channel_versions[chan];
+			if (!RESERVED_SET.has(chan)) channelsToConsume.add(chan);
+		}
 	}
 	let maxVersion = maxChannelMapVersion(checkpoint.channel_versions);
-	const channelsToConsume = new Set(tasks.flatMap((task) => task.triggers).filter((chan) => !require_constants.RESERVED.includes(chan)));
 	let usedNewVersion = false;
 	for (const chan of channelsToConsume) if (chan in onlyChannels && onlyChannels[chan].consume()) {
 		if (getNextVersion !== void 0) {
@@ -167,22 +181,53 @@ function* candidateNodes(checkpoint, processes, extra) {
 	}
 }
 /**
+* Build an index over pendingWrites for O(1) lookups.
+*
+* @internal Exported for benchmarks and regression tests only.
+*/
+function _indexPendingWrites(pendingWrites) {
+	let nullResume;
+	const resumeByTaskId = /* @__PURE__ */ new Map();
+	const successfulWriteTaskIds = /* @__PURE__ */ new Set();
+	if (pendingWrites) for (const [tid, chan, val] of pendingWrites) {
+		if (tid === "00000000-0000-0000-0000-000000000000" && chan === "__resume__" && nullResume === void 0) nullResume = val;
+		if (chan === "__resume__" && tid !== "00000000-0000-0000-0000-000000000000") {
+			let arr = resumeByTaskId.get(tid);
+			if (!arr) {
+				arr = [];
+				resumeByTaskId.set(tid, arr);
+			}
+			arr.push(val);
+		}
+		if (chan !== "__error__") successfulWriteTaskIds.add(tid);
+	}
+	return {
+		nullResume,
+		resumeByTaskId,
+		successfulWriteTaskIds
+	};
+}
+/**
 * Prepare the set of tasks that will make up the next Pregel step.
 * This is the union of all PUSH tasks (Sends) and PULL tasks (nodes triggered
 * by edges).
 */
 function _prepareNextTasks(checkpoint, pendingWrites, processes, channels, config, forExecution, extra) {
 	const tasks = {};
+	const indexedExtra = extra.pendingWritesIndex ? extra : {
+		...extra,
+		pendingWritesIndex: _indexPendingWrites(pendingWrites)
+	};
 	const tasksChannel = channels[require_constants.TASKS];
 	if (tasksChannel?.isAvailable()) {
 		const len = tasksChannel.get().length;
 		for (let i = 0; i < len; i += 1) {
-			const task = _prepareSingleTask([require_constants.PUSH, i], checkpoint, pendingWrites, processes, channels, config, forExecution, extra);
+			const task = _prepareSingleTask([require_constants.PUSH, i], checkpoint, pendingWrites, processes, channels, config, forExecution, indexedExtra);
 			if (task !== void 0) tasks[task.id] = task;
 		}
 	}
-	for (const name of candidateNodes(checkpoint, processes, extra)) {
-		const task = _prepareSingleTask([require_constants.PULL, name], checkpoint, pendingWrites, processes, channels, config, forExecution, extra);
+	for (const name of candidateNodes(checkpoint, processes, indexedExtra)) {
+		const task = _prepareSingleTask([require_constants.PULL, name], checkpoint, pendingWrites, processes, channels, config, forExecution, indexedExtra);
 		if (task !== void 0) tasks[task.id] = task;
 	}
 	return tasks;
@@ -259,7 +304,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 								taskId: id,
 								currentTaskInput: call.input,
 								resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
-								namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+								namespaceHash: require_hash.XXH3(taskCheckpointNamespace),
+								pendingWritesIndex: extra.pendingWritesIndex
 							}),
 							[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
 							checkpoint_id: void 0,
@@ -277,7 +323,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 				} : void 0,
 				id,
 				path: outputTaskPath,
-				writers: []
+				writers: [],
+				timeout: call.timeout
 			};
 		} else return {
 			id,
@@ -290,7 +337,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 		if (!channels["__pregel_tasks"]?.isAvailable()) return;
 		const sends = channels[require_constants.TASKS].get();
 		if (index < 0 || index >= sends.length) return;
-		const packet = require_constants._isSendInterface(sends[index]) && !require_constants._isSend(sends[index]) ? new require_constants.Send(sends[index].node, sends[index].args) : sends[index];
+		const packet = require_constants._isSendInterface(sends[index]) && !require_constants._isSend(sends[index]) ? new require_constants.Send(sends[index].node, sends[index].args, sends[index].timeout !== void 0 ? { timeout: sends[index].timeout } : void 0) : sends[index];
 		if (!require_constants._isSendInterface(packet)) {
 			console.warn(`Ignoring invalid packet ${JSON.stringify(packet)} in pending sends.`);
 			return;
@@ -367,7 +414,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 									taskId,
 									currentTaskInput: packet.args,
 									resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
-									namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+									namespaceHash: require_hash.XXH3(taskCheckpointNamespace),
+									pendingWritesIndex: extra.pendingWritesIndex
 								}),
 								[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
 								checkpoint_id: void 0,
@@ -389,7 +437,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 					} : void 0,
 					id: taskId,
 					path: taskPath,
-					writers: proc.getWriters()
+					writers: proc.getWriters(),
+					timeout: packet.timeout ?? proc.timeout
 				};
 			}
 		} else return {
@@ -411,7 +460,7 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 				require_constants.PULL,
 				name
 			]), checkpoint.id);
-			if (pendingWrites.some((w) => w[0] === taskId && w[1] !== "__error__")) return;
+			if (extra.pendingWritesIndex ? extra.pendingWritesIndex.successfulWriteTaskIds.has(taskId) : pendingWrites.some((w) => w[0] === taskId && w[1] !== "__error__")) return;
 		}
 		const nullVersion = require_index.getNullChannelVersion(checkpoint.channel_versions);
 		if (nullVersion === void 0) return;
@@ -491,7 +540,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 										taskId,
 										currentTaskInput: val,
 										resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
-										namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+										namespaceHash: require_hash.XXH3(taskCheckpointNamespace),
+										pendingWritesIndex: extra.pendingWritesIndex
 									}),
 									[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
 									checkpoint_id: void 0,
@@ -513,7 +563,8 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 						} : void 0,
 						id: taskId,
 						path: taskPath,
-						writers: proc.getWriters()
+						writers: proc.getWriters(),
+						timeout: proc.timeout
 					};
 				}
 			} else return {
@@ -526,6 +577,115 @@ function _prepareSingleTask(taskPath, checkpoint, pendingWrites, processes, chan
 	}
 }
 /**
+* Prepare an immediate node-level error handler task for a failed task.
+*
+* The handler runs only after the failed node's retry policy is exhausted (the
+* runner schedules it once a non-bubble-up error settles). It is prepared like
+* a PUSH task targeting the auto-generated handler node, receives the failed
+* node's input, and is injected with a {@link NodeError} under
+* {@link CONFIG_KEY_NODE_ERROR} so the handler can inspect the failure
+* provenance (and route via `Command({ goto })`).
+*
+* @internal
+*/
+function _prepareNodeErrorHandlerTask(failedTask, handlerNodeName, error, checkpoint, pendingWrites, processes, channels, config, extra) {
+	const { step, checkpointer, manager } = extra;
+	const proc = processes[handlerNodeName];
+	if (proc === void 0) return;
+	const node = proc.getNode();
+	if (node === void 0) return;
+	const configurable = config.configurable ?? {};
+	const parentNamespace = configurable.checkpoint_ns ?? "";
+	const triggers = [require_constants.PUSH];
+	const checkpointNamespace = parentNamespace === "" ? handlerNodeName : `${parentNamespace}|${handlerNodeName}`;
+	const taskId = (0, _langchain_langgraph_checkpoint.uuid5)(JSON.stringify([
+		checkpointNamespace,
+		step.toString(),
+		handlerNodeName,
+		require_constants.PUSH,
+		"node_error_handler",
+		failedTask.id
+	]), checkpoint.id);
+	const taskCheckpointNamespace = `${checkpointNamespace}:${taskId}`;
+	const taskPath = [
+		require_constants.PUSH,
+		String(failedTask.name),
+		handlerNodeName,
+		false
+	];
+	let metadata = {
+		langgraph_step: step,
+		langgraph_node: handlerNodeName,
+		langgraph_triggers: triggers,
+		langgraph_path: taskPath,
+		langgraph_checkpoint_ns: taskCheckpointNamespace,
+		checkpoint_ns: taskCheckpointNamespace
+	};
+	if (proc.metadata !== void 0) metadata = {
+		...metadata,
+		...proc.metadata
+	};
+	const writes = [];
+	const executionInfo = {
+		checkpointId: checkpoint.id,
+		checkpointNs: taskCheckpointNamespace,
+		taskId,
+		threadId: configurable.thread_id,
+		runId: config.runId != null ? String(config.runId) : void 0,
+		nodeAttempt: 1
+	};
+	return {
+		name: handlerNodeName,
+		input: failedTask.input,
+		proc: node,
+		subgraphs: proc.subgraphs,
+		writes,
+		config: {
+			...(0, _langchain_core_runnables.patchConfig)((0, _langchain_core_runnables.mergeConfigs)(config, {
+				metadata,
+				tags: proc.tags,
+				store: extra.store ?? config.store
+			}), {
+				runName: handlerNodeName,
+				callbacks: manager?.getChild(`graph:step:${step}`),
+				configurable: {
+					[require_constants.CONFIG_KEY_TASK_ID]: taskId,
+					[require_constants.CONFIG_KEY_SEND]: (writes_) => _localWrite((items) => writes.push(...items), processes, writes_),
+					[require_constants.CONFIG_KEY_READ]: (select_, fresh_ = false) => _localRead(checkpoint, channels, {
+						name: handlerNodeName,
+						writes,
+						triggers,
+						path: taskPath
+					}, select_, fresh_),
+					[require_constants.CONFIG_KEY_CHECKPOINTER]: checkpointer ?? configurable["__pregel_checkpointer"],
+					[require_constants.CONFIG_KEY_CHECKPOINT_MAP]: {
+						...configurable[require_constants.CONFIG_KEY_CHECKPOINT_MAP],
+						[parentNamespace]: checkpoint.id
+					},
+					[require_constants.CONFIG_KEY_SCRATCHPAD]: _scratchpad({
+						pendingWrites: pendingWrites ?? [],
+						taskId,
+						currentTaskInput: failedTask.input,
+						resumeMap: config.configurable?.[require_constants.CONFIG_KEY_RESUME_MAP],
+						namespaceHash: require_hash.XXH3(taskCheckpointNamespace)
+					}),
+					[require_constants.CONFIG_KEY_PREVIOUS_STATE]: checkpoint.channel_values[require_constants.PREVIOUS],
+					[require_constants.CONFIG_KEY_NODE_ERROR]: new require_errors.NodeError(String(failedTask.name), error),
+					checkpoint_id: void 0,
+					checkpoint_ns: taskCheckpointNamespace
+				}
+			}),
+			executionInfo
+		},
+		triggers,
+		retry_policy: proc.retryPolicy,
+		cache_key: void 0,
+		id: taskId,
+		path: taskPath,
+		writers: proc.getWriters()
+	};
+}
+/**
 *  Function injected under CONFIG_KEY_READ in task config, to read current state.
 *  Used by conditional edges to read a copy of the state with reflecting the writes
 *  from that node only.
@@ -581,13 +741,13 @@ function sanitizeUntrackedValuesInSend(packet, channels) {
 	}
 	return new require_constants.Send(packet.node, sanitizedArg);
 }
-function _scratchpad({ pendingWrites, taskId, currentTaskInput, resumeMap, namespaceHash }) {
-	const nullResume = pendingWrites.find(([writeTaskId, chan]) => writeTaskId === "00000000-0000-0000-0000-000000000000" && chan === "__resume__")?.[2];
+function _scratchpad({ pendingWrites, taskId, currentTaskInput, resumeMap, namespaceHash, pendingWritesIndex }) {
+	const nullResume = pendingWritesIndex ? pendingWritesIndex.nullResume : pendingWrites.find(([writeTaskId, chan]) => writeTaskId === "00000000-0000-0000-0000-000000000000" && chan === "__resume__")?.[2];
 	const scratchpad = {
 		callCounter: 0,
 		interruptCounter: -1,
 		resume: (() => {
-			const result = pendingWrites.filter(([writeTaskId, chan]) => writeTaskId === taskId && chan === "__resume__").flatMap(([_writeTaskId, _chan, resume]) => resume);
+			const result = pendingWritesIndex ? (pendingWritesIndex.resumeByTaskId.get(taskId) ?? []).flat() : pendingWrites.filter(([writeTaskId, chan]) => writeTaskId === taskId && chan === "__resume__").flatMap(([_writeTaskId, _chan, resume]) => resume);
 			if (resumeMap != null && namespaceHash in resumeMap) {
 				const mappedResume = resumeMap[namespaceHash];
 				result.push(mappedResume);
@@ -611,6 +771,7 @@ function _scratchpad({ pendingWrites, taskId, currentTaskInput, resumeMap, names
 exports._applyWrites = _applyWrites;
 exports._localRead = _localRead;
 exports._prepareNextTasks = _prepareNextTasks;
+exports._prepareNodeErrorHandlerTask = _prepareNodeErrorHandlerTask;
 exports._prepareSingleTask = _prepareSingleTask;
 exports.increment = increment;
 exports.sanitizeUntrackedValuesInSend = sanitizeUntrackedValuesInSend;