@langchain/langgraph 0.4.9 → 1.0.0-alpha.1

package/dist/prebuilt/tool_node.cjs

@@ -1,279 +1,217 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolNode = void 0;
-exports.toolsCondition = toolsCondition;
-const messages_1 = require("@langchain/core/messages");
-const utils_js_1 = require("../utils.cjs");
-const errors_js_1 = require("../errors.cjs");
-const constants_js_1 = require("../constants.cjs");
-const isBaseMessageArray = (input) => Array.isArray(input) && input.every(messages_1.isBaseMessage);
-const isMessagesState = (input) => typeof input === "object" &&
-    input != null &&
-    "messages" in input &&
-    isBaseMessageArray(input.messages);
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_errors = require('../errors.cjs');
+const require_constants = require('../constants.cjs');
+const require_utils = require('../utils.cjs');
+const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+
+//#region src/prebuilt/tool_node.ts
+const isBaseMessageArray = (input) => Array.isArray(input) && input.every(__langchain_core_messages.isBaseMessage);
+const isMessagesState = (input) => typeof input === "object" && input != null && "messages" in input && isBaseMessageArray(input.messages);
 const isSendInput = (input) => typeof input === "object" && input != null && "lg_tool_call" in input;
 /**
- * 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
- * tool calls are requested, they will be run in parallel. The output will be
- * a list of ToolMessages, one for each tool call.
- *
- * @example
- * ```ts
- * import { ToolNode } from "@langchain/langgraph/prebuilt";
- * import { tool } from "@langchain/core/tools";
- * import { z } from "zod";
- * import { AIMessage } from "@langchain/core/messages";
- *
- * const getWeather = tool((input) => {
- *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
- *     return "It's 60 degrees and foggy.";
- *   } else {
- *     return "It's 90 degrees and sunny.";
- *   }
- * }, {
- *   name: "get_weather",
- *   description: "Call to get the current weather.",
- *   schema: z.object({
- *     location: z.string().describe("Location to get the weather for."),
- *   }),
- * });
- *
- * const tools = [getWeather];
- * const toolNode = new ToolNode(tools);
- *
- * const messageWithSingleToolCall = new AIMessage({
- *   content: "",
- *   tool_calls: [
- *     {
- *       name: "get_weather",
- *       args: { location: "sf" },
- *       id: "tool_call_id",
- *       type: "tool_call",
- *     }
- *   ]
- * })
- *
- * await toolNode.invoke({ messages: [messageWithSingleToolCall] });
- * // Returns tool invocation responses as:
- * // { messages: ToolMessage[] }
- * ```
- *
- * @example
- * ```ts
- * import {
- *   StateGraph,
- *   MessagesAnnotation,
- * } from "@langchain/langgraph";
- * import { ToolNode } from "@langchain/langgraph/prebuilt";
- * import { tool } from "@langchain/core/tools";
- * import { z } from "zod";
- * import { ChatAnthropic } from "@langchain/anthropic";
- *
- * const getWeather = tool((input) => {
- *   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
- *     return "It's 60 degrees and foggy.";
- *   } else {
- *     return "It's 90 degrees and sunny.";
- *   }
- * }, {
- *   name: "get_weather",
- *   description: "Call to get the current weather.",
- *   schema: z.object({
- *     location: z.string().describe("Location to get the weather for."),
- *   }),
- * });
- *
- * const tools = [getWeather];
- * const modelWithTools = new ChatAnthropic({
- *   model: "claude-3-haiku-20240307",
- *   temperature: 0
- * }).bindTools(tools);
- *
- * const toolNodeForGraph = new ToolNode(tools)
- *
- * const shouldContinue = (state: typeof MessagesAnnotation.State) => {
- *   const { messages } = state;
- *   const lastMessage = messages[messages.length - 1];
- *   if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {
- *     return "tools";
- *   }
- *   return "__end__";
- * }
- *
- * const callModel = async (state: typeof MessagesAnnotation.State) => {
- *   const { messages } = state;
- *   const response = await modelWithTools.invoke(messages);
- *   return { messages: response };
- * }
- *
- * const graph = new StateGraph(MessagesAnnotation)
- *   .addNode("agent", callModel)
- *   .addNode("tools", toolNodeForGraph)
- *   .addEdge("__start__", "agent")
- *   .addConditionalEdges("agent", shouldContinue)
- *   .addEdge("tools", "agent")
- *   .compile();
- *
- * const inputs = {
- *   messages: [{ role: "user", content: "what is the weather in SF?" }],
- * };
- *
- * const stream = await graph.stream(inputs, {
- *   streamMode: "values",
- * });
- *
- * for await (const { messages } of stream) {
- *   console.log(messages);
- * }
- * // Returns the messages in the state at each step of execution
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-class ToolNode extends utils_js_1.RunnableCallable {
-    constructor(tools, options) {
-        const { name, tags, handleToolErrors } = options ?? {};
-        super({ name, tags, func: (input, config) => this.run(input, config) });
-        Object.defineProperty(this, "tools", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "handleToolErrors", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "trace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this.tools = tools;
-        this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
-    }
-    async runTool(call, config) {
-        const tool = this.tools.find((tool) => tool.name === call.name);
-        try {
-            if (tool === undefined) {
-                throw new Error(`Tool "${call.name}" not found.`);
-            }
-            const output = await tool.invoke({ ...call, type: "tool_call" }, config);
-            if (((0, messages_1.isBaseMessage)(output) && output.getType() === "tool") ||
-                (0, constants_js_1.isCommand)(output)) {
-                return output;
-            }
-            return new messages_1.ToolMessage({
-                status: "success",
-                name: tool.name,
-                content: typeof output === "string" ? output : JSON.stringify(output),
-                tool_call_id: call.id,
-            });
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }
-        catch (e) {
-            if (!this.handleToolErrors)
-                throw e;
-            if ((0, errors_js_1.isGraphInterrupt)(e)) {
-                // `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({
-                status: "error",
-                content: `Error: ${e.message}\n Please fix your mistakes.`,
-                name: call.name,
-                tool_call_id: call.id ?? "",
-            });
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async run(input, config) {
-        let outputs;
-        if (isSendInput(input)) {
-            outputs = [await this.runTool(input.lg_tool_call, config)];
-        }
-        else {
-            let messages;
-            if (isBaseMessageArray(input)) {
-                messages = input;
-            }
-            else if (isMessagesState(input)) {
-                messages = input.messages;
-            }
-            else {
-                throw new Error("ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.");
-            }
-            const toolMessageIds = new Set(messages
-                .filter((msg) => msg.getType() === "tool")
-                .map((msg) => msg.tool_call_id));
-            let aiMessage;
-            for (let i = messages.length - 1; i >= 0; i -= 1) {
-                const message = messages[i];
-                if (message.getType() === "ai") {
-                    aiMessage = message;
-                    break;
-                }
-            }
-            if (aiMessage?.getType() !== "ai") {
-                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)) ?? []);
-        }
-        // Preserve existing behavior for non-command tool outputs for backwards compatibility
-        if (!outputs.some(constants_js_1.isCommand)) {
-            return (Array.isArray(input) ? outputs : { messages: outputs });
-        }
-        // Handle mixed Command and non-Command outputs
-        const combinedOutputs = [];
-        let parentCommand = null;
-        for (const output of outputs) {
-            if ((0, constants_js_1.isCommand)(output)) {
-                if (output.graph === constants_js_1.Command.PARENT &&
-                    Array.isArray(output.goto) &&
-                    output.goto.every((send) => (0, constants_js_1._isSend)(send))) {
-                    if (parentCommand) {
-                        parentCommand.goto.push(...output.goto);
-                    }
-                    else {
-                        parentCommand = new constants_js_1.Command({
-                            graph: constants_js_1.Command.PARENT,
-                            goto: output.goto,
-                        });
-                    }
-                }
-                else {
-                    combinedOutputs.push(output);
-                }
-            }
-            else {
-                combinedOutputs.push(Array.isArray(input) ? [output] : { messages: [output] });
-            }
-        }
-        if (parentCommand) {
-            combinedOutputs.push(parentCommand);
-        }
-        return combinedOutputs;
-    }
-}
-exports.ToolNode = ToolNode;
+* @deprecated `ToolNode` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.
+* Update your import to `import { ToolNode } from "langchain";`
+*
+* 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
+* tool calls are requested, they will be run in parallel. The output will be
+* a list of ToolMessages, one for each tool call.
+*
+* @example
+* ```ts
+* import { ToolNode } from "@langchain/langgraph/prebuilt";
+* import { tool } from "@langchain/core/tools";
+* import { z } from "zod";
+* import { AIMessage } from "@langchain/core/messages";
+*
+* const getWeather = tool((input) => {
+*   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
+*     return "It's 60 degrees and foggy.";
+*   } else {
+*     return "It's 90 degrees and sunny.";
+*   }
+* }, {
+*   name: "get_weather",
+*   description: "Call to get the current weather.",
+*   schema: z.object({
+*     location: z.string().describe("Location to get the weather for."),
+*   }),
+* });
+*
+* const tools = [getWeather];
+* const toolNode = new ToolNode(tools);
+*
+* const messageWithSingleToolCall = new AIMessage({
+*   content: "",
+*   tool_calls: [
+*     {
+*       name: "get_weather",
+*       args: { location: "sf" },
+*       id: "tool_call_id",
+*       type: "tool_call",
+*     }
+*   ]
+* })
+*
+* await toolNode.invoke({ messages: [messageWithSingleToolCall] });
+* // Returns tool invocation responses as:
+* // { messages: ToolMessage[] }
+* ```
+*
+* @example
+* ```ts
+* import {
+*   StateGraph,
+*   MessagesAnnotation,
+* } from "@langchain/langgraph";
+* import { ToolNode } from "@langchain/langgraph/prebuilt";
+* import { tool } from "@langchain/core/tools";
+* import { z } from "zod";
+* import { ChatAnthropic } from "@langchain/anthropic";
+*
+* const getWeather = tool((input) => {
+*   if (["sf", "san francisco"].includes(input.location.toLowerCase())) {
+*     return "It's 60 degrees and foggy.";
+*   } else {
+*     return "It's 90 degrees and sunny.";
+*   }
+* }, {
+*   name: "get_weather",
+*   description: "Call to get the current weather.",
+*   schema: z.object({
+*     location: z.string().describe("Location to get the weather for."),
+*   }),
+* });
+*
+* const tools = [getWeather];
+* const modelWithTools = new ChatAnthropic({
+*   model: "claude-3-haiku-20240307",
+*   temperature: 0
+* }).bindTools(tools);
+*
+* const toolNodeForGraph = new ToolNode(tools)
+*
+* const shouldContinue = (state: typeof MessagesAnnotation.State) => {
+*   const { messages } = state;
+*   const lastMessage = messages[messages.length - 1];
+*   if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {
+*     return "tools";
+*   }
+*   return "__end__";
+* }
+*
+* const callModel = async (state: typeof MessagesAnnotation.State) => {
+*   const { messages } = state;
+*   const response = await modelWithTools.invoke(messages);
+*   return { messages: response };
+* }
+*
+* const graph = new StateGraph(MessagesAnnotation)
+*   .addNode("agent", callModel)
+*   .addNode("tools", toolNodeForGraph)
+*   .addEdge("__start__", "agent")
+*   .addConditionalEdges("agent", shouldContinue)
+*   .addEdge("tools", "agent")
+*   .compile();
+*
+* const inputs = {
+*   messages: [{ role: "user", content: "what is the weather in SF?" }],
+* };
+*
+* const stream = await graph.stream(inputs, {
+*   streamMode: "values",
+* });
+*
+* for await (const { messages } of stream) {
+*   console.log(messages);
+* }
+* // Returns the messages in the state at each step of execution
+* ```
+*/
+var ToolNode = class extends require_utils.RunnableCallable {
+	tools;
+	handleToolErrors = true;
+	trace = false;
+	constructor(tools, options) {
+		const { name, tags, handleToolErrors } = options ?? {};
+		super({
+			name,
+			tags,
+			func: (input, config) => this.run(input, config)
+		});
+		this.tools = tools;
+		this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
+	}
+	async runTool(call, config) {
+		const tool = this.tools.find((tool$1) => tool$1.name === call.name);
+		try {
+			if (tool === void 0) throw new Error(`Tool "${call.name}" not found.`);
+			const output = await tool.invoke({
+				...call,
+				type: "tool_call"
+			}, config);
+			if ((0, __langchain_core_messages.isBaseMessage)(output) && output.getType() === "tool" || require_constants.isCommand(output)) return output;
+			return new __langchain_core_messages.ToolMessage({
+				status: "success",
+				name: tool.name,
+				content: typeof output === "string" ? output : JSON.stringify(output),
+				tool_call_id: call.id
+			});
+		} catch (e) {
+			if (!this.handleToolErrors) throw e;
+			if (require_errors.isGraphInterrupt(e)) throw e;
+			return new __langchain_core_messages.ToolMessage({
+				status: "error",
+				content: `Error: ${e.message}\n Please fix your mistakes.`,
+				name: call.name,
+				tool_call_id: call.id ?? ""
+			});
+		}
+	}
+	async run(input, config) {
+		let outputs;
+		if (isSendInput(input)) outputs = [await this.runTool(input.lg_tool_call, config)];
+		else {
+			let messages;
+			if (isBaseMessageArray(input)) messages = input;
+			else if (isMessagesState(input)) messages = input.messages;
+			else throw new Error("ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.");
+			const toolMessageIds = new Set(messages.filter((msg) => msg.getType() === "tool").map((msg) => msg.tool_call_id));
+			let aiMessage;
+			for (let i = messages.length - 1; i >= 0; i -= 1) {
+				const message = messages[i];
+				if (message.getType() === "ai") {
+					aiMessage = message;
+					break;
+				}
+			}
+			if (aiMessage?.getType() !== "ai") 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)) ?? []);
+		}
+		if (!outputs.some(require_constants.isCommand)) return Array.isArray(input) ? outputs : { messages: outputs };
+		const combinedOutputs = [];
+		let parentCommand = null;
+		for (const output of outputs) if (require_constants.isCommand(output)) if (output.graph === require_constants.Command.PARENT && Array.isArray(output.goto) && output.goto.every((send) => require_constants._isSend(send))) if (parentCommand) parentCommand.goto.push(...output.goto);
+		else parentCommand = new require_constants.Command({
+			graph: require_constants.Command.PARENT,
+			goto: output.goto
+		});
+		else combinedOutputs.push(output);
+		else combinedOutputs.push(Array.isArray(input) ? [output] : { messages: [output] });
+		if (parentCommand) combinedOutputs.push(parentCommand);
+		return combinedOutputs;
+	}
+};
+/**
+* @deprecated Use new `ToolNode` from {@link https://www.npmjs.com/package/langchain langchain} package instead.
+*/
 function toolsCondition(state) {
-    const message = Array.isArray(state)
-        ? state[state.length - 1]
-        : state.messages[state.messages.length - 1];
-    if (message !== undefined &&
-        "tool_calls" in message &&
-        (message.tool_calls?.length ?? 0) > 0) {
-        return "tools";
-    }
-    else {
-        return constants_js_1.END;
-    }
+	const message = Array.isArray(state) ? state[state.length - 1] : state.messages[state.messages.length - 1];
+	if (message !== void 0 && "tool_calls" in message && (message.tool_calls?.length ?? 0) > 0) return "tools";
+	else return require_constants.END;
 }
-//# sourceMappingURL=tool_node.js.map
+
+//#endregion
+exports.ToolNode = ToolNode;
+exports.toolsCondition = toolsCondition;
+//# sourceMappingURL=tool_node.cjs.map

package/dist/prebuilt/tool_node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_node.cjs","names":["isBaseMessage","RunnableCallable","tool","isCommand","ToolMessage","e: any","isGraphInterrupt","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","Command","_isSend","END"],"sources":["../../src/prebuilt/tool_node.ts"],"sourcesContent":["import {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\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 * @deprecated `ToolNode` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { ToolNode } from \"langchain\";`\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 (message.getType() === \"ai\") {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (aiMessage?.getType() !== \"ai\") {\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 * @deprecated Use new `ToolNode` from {@link https://www.npmjs.com/package/langchain langchain} package instead.\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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"}