langchain 1.0.0-alpha.8 → 1.0.1

package/dist/agents/{middlewareAgent/nodes/BeforeModalNode.cjs → nodes/BeforeModelNode.cjs}

@@ -1,6 +1,7 @@
+const require_utils = require('../middleware/utils.cjs');
 const require_middleware = require('./middleware.cjs');
 
-//#region src/agents/middlewareAgent/nodes/BeforeModalNode.ts
+//#region src/agents/nodes/BeforeModelNode.ts
 /**
 * Node for executing a single middleware's beforeModel hook.
 */
@@ -8,7 +9,7 @@ var BeforeModelNode = class extends require_middleware.MiddlewareNode {
 	lc_namespace = [
 		"langchain",
 		"agents",
-		"beforeModalNodes"
+		"beforeModelNodes"
 	];
 	constructor(middleware, options) {
 		super({
@@ -18,10 +19,11 @@ var BeforeModelNode = class extends require_middleware.MiddlewareNode {
 		this.middleware = middleware;
 	}
 	runHook(state, runtime) {
-		return this.middleware.beforeModel(state, runtime);
+		const fn = require_utils.getHookFunction(this.middleware.beforeModel);
+		return fn(state, runtime);
 	}
 };
 
 //#endregion
 exports.BeforeModelNode = BeforeModelNode;
-//# sourceMappingURL=BeforeModalNode.cjs.map
+//# sourceMappingURL=BeforeModelNode.cjs.map

package/dist/agents/nodes/BeforeModelNode.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeforeModelNode.cjs","names":["MiddlewareNode","middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >","options: MiddlewareNodeOptions","state: TStateSchema","config?: RunnableConfig<TContextSchema>","runtime: Runtime<TContextSchema>","getHookFunction"],"sources":["../../../src/agents/nodes/BeforeModelNode.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport { MiddlewareNode, type MiddlewareNodeOptions } from \"./middleware.js\";\nimport type { AgentMiddleware, MiddlewareResult } from \"../middleware/types.js\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\nimport { getHookFunction } from \"../middleware/utils.js\";\n\n/**\n * Node for executing a single middleware's beforeModel hook.\n */\nexport class BeforeModelNode<\n  TStateSchema extends Record<string, unknown> = Record<string, unknown>,\n  TContextSchema extends Record<string, unknown> = Record<string, unknown>\n> extends MiddlewareNode<TStateSchema, TContextSchema> {\n  lc_namespace = [\"langchain\", \"agents\", \"beforeModelNodes\"];\n\n  constructor(\n    public middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >,\n    options: MiddlewareNodeOptions\n  ) {\n    super(\n      {\n        name: `BeforeModelNode_${middleware.name}`,\n        func: async (\n          state: TStateSchema,\n          config?: RunnableConfig<TContextSchema>\n        ) => this.invokeMiddleware(state, config),\n      },\n      options\n    );\n  }\n\n  runHook(state: TStateSchema, runtime: Runtime<TContextSchema>) {\n    const fn = getHookFunction(this.middleware.beforeModel!);\n    return fn(\n      state as Record<string, unknown> & AgentBuiltInState,\n      runtime as Runtime<unknown>\n    ) as Promise<MiddlewareResult<TStateSchema>>;\n  }\n}\n"],"mappings":";;;;;;;AAUA,IAAa,kBAAb,cAGUA,kCAA6C;CACrD,eAAe;EAAC;EAAa;EAAU;CAAmB;CAE1D,YACSC,YAIPC,SACA;EACA,MACE;GACE,MAAM,CAAC,gBAAgB,EAAE,WAAW,MAAM;GAC1C,MAAM,OACJC,OACAC,WACG,KAAK,iBAAiB,OAAO,OAAO;EAC1C,GACD,QACD;EAfM;CAgBR;CAED,QAAQD,OAAqBE,SAAkC;EAC7D,MAAM,KAAKC,8BAAgB,KAAK,WAAW,YAAa;AACxD,SAAO,GACL,OACA,QACD;CACF;AACF"}

package/dist/agents/{middlewareAgent/nodes/BeforeModalNode.js → nodes/BeforeModelNode.js}

@@ -1,6 +1,7 @@
+import { getHookFunction } from "../middleware/utils.js";
 import { MiddlewareNode } from "./middleware.js";
 
-//#region src/agents/middlewareAgent/nodes/BeforeModalNode.ts
+//#region src/agents/nodes/BeforeModelNode.ts
 /**
 * Node for executing a single middleware's beforeModel hook.
 */
@@ -8,7 +9,7 @@ var BeforeModelNode = class extends MiddlewareNode {
 	lc_namespace = [
 		"langchain",
 		"agents",
-		"beforeModalNodes"
+		"beforeModelNodes"
 	];
 	constructor(middleware, options) {
 		super({
@@ -18,10 +19,11 @@ var BeforeModelNode = class extends MiddlewareNode {
 		this.middleware = middleware;
 	}
 	runHook(state, runtime) {
-		return this.middleware.beforeModel(state, runtime);
+		const fn = getHookFunction(this.middleware.beforeModel);
+		return fn(state, runtime);
 	}
 };
 
 //#endregion
 export { BeforeModelNode };
-//# sourceMappingURL=BeforeModalNode.js.map
+//# sourceMappingURL=BeforeModelNode.js.map

package/dist/agents/nodes/BeforeModelNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeforeModelNode.js","names":["middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >","options: MiddlewareNodeOptions","state: TStateSchema","config?: RunnableConfig<TContextSchema>","runtime: Runtime<TContextSchema>"],"sources":["../../../src/agents/nodes/BeforeModelNode.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport { MiddlewareNode, type MiddlewareNodeOptions } from \"./middleware.js\";\nimport type { AgentMiddleware, MiddlewareResult } from \"../middleware/types.js\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\nimport { getHookFunction } from \"../middleware/utils.js\";\n\n/**\n * Node for executing a single middleware's beforeModel hook.\n */\nexport class BeforeModelNode<\n  TStateSchema extends Record<string, unknown> = Record<string, unknown>,\n  TContextSchema extends Record<string, unknown> = Record<string, unknown>\n> extends MiddlewareNode<TStateSchema, TContextSchema> {\n  lc_namespace = [\"langchain\", \"agents\", \"beforeModelNodes\"];\n\n  constructor(\n    public middleware: AgentMiddleware<\n      z.ZodObject<z.ZodRawShape>,\n      z.ZodObject<z.ZodRawShape>\n    >,\n    options: MiddlewareNodeOptions\n  ) {\n    super(\n      {\n        name: `BeforeModelNode_${middleware.name}`,\n        func: async (\n          state: TStateSchema,\n          config?: RunnableConfig<TContextSchema>\n        ) => this.invokeMiddleware(state, config),\n      },\n      options\n    );\n  }\n\n  runHook(state: TStateSchema, runtime: Runtime<TContextSchema>) {\n    const fn = getHookFunction(this.middleware.beforeModel!);\n    return fn(\n      state as Record<string, unknown> & AgentBuiltInState,\n      runtime as Runtime<unknown>\n    ) as Promise<MiddlewareResult<TStateSchema>>;\n  }\n}\n"],"mappings":";;;;;;;AAUA,IAAa,kBAAb,cAGU,eAA6C;CACrD,eAAe;EAAC;EAAa;EAAU;CAAmB;CAE1D,YACSA,YAIPC,SACA;EACA,MACE;GACE,MAAM,CAAC,gBAAgB,EAAE,WAAW,MAAM;GAC1C,MAAM,OACJC,OACAC,WACG,KAAK,iBAAiB,OAAO,OAAO;EAC1C,GACD,QACD;EAfM;CAgBR;CAED,QAAQD,OAAqBE,SAAkC;EAC7D,MAAM,KAAK,gBAAgB,KAAK,WAAW,YAAa;AACxD,SAAO,GACL,OACA,QACD;CACF;AACF"}

package/dist/agents/nodes/ToolNode.cjs

@@ -7,10 +7,35 @@ const __langchain_core_tools = require_rolldown_runtime.__toESM(require("@langch
 const __langchain_langgraph = require_rolldown_runtime.__toESM(require("@langchain/langgraph"));
 
 //#region src/agents/nodes/ToolNode.ts
-const isBaseMessageArray = (input) => Array.isArray(input) && input.every(__langchain_core_messages.isBaseMessage);
+const isBaseMessageArray = (input) => Array.isArray(input) && input.every(__langchain_core_messages.BaseMessage.isInstance);
 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;
 /**
+* Default error handler for tool errors.
+*
+* This is applied to errors from baseHandler (tool execution).
+* For errors from wrapToolCall middleware, those are handled separately
+* and will bubble up by default.
+*
+* Catches all tool execution errors and converts them to ToolMessage.
+* This allows the LLM to see the error and potentially retry with different arguments.
+*/
+function defaultHandleToolErrors(error, toolCall) {
+	if (error instanceof require_errors.ToolInvocationError) return new __langchain_core_messages.ToolMessage({
+		content: error.message,
+		tool_call_id: toolCall.id,
+		name: toolCall.name
+	});
+	/**
+	* Catch all other tool errors and convert to ToolMessage
+	*/
+	return new __langchain_core_messages.ToolMessage({
+		content: `${error}\n Please fix your mistakes.`,
+		tool_call_id: toolCall.id,
+		name: toolCall.name
+	});
+}
+/**
 * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.
 * It works seamlessly with `createAgent`, offering advanced tool execution control, built
 * in parallelism, and error handling.
@@ -58,9 +83,11 @@ var ToolNode = class extends require_RunnableCallable.RunnableCallable {
 	tools;
 	trace = false;
 	signal;
-	handleToolErrors = true;
+	handleToolErrors = defaultHandleToolErrors;
+	wrapToolCall;
+	getPrivateState;
 	constructor(tools, options) {
-		const { name, tags, handleToolErrors } = options ?? {};
+		const { name, tags, handleToolErrors, wrapToolCall, getPrivateState } = options ?? {};
 		super({
 			name,
 			tags,
@@ -69,66 +96,150 @@ var ToolNode = class extends require_RunnableCallable.RunnableCallable {
 		this.options = options;
 		this.tools = tools;
 		this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
+		this.wrapToolCall = wrapToolCall;
+		this.getPrivateState = getPrivateState;
 		this.signal = options?.signal;
 	}
-	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,
-				signal: require_utils.mergeAbortSignals(this.signal, config.signal)
-			});
-			if (__langchain_core_messages.ToolMessage.isInstance(output) || (0, __langchain_langgraph.isCommand)(output)) return output;
-			return new __langchain_core_messages.ToolMessage({
-				name: tool.name,
-				content: typeof output === "string" ? output : JSON.stringify(output),
-				tool_call_id: call.id
-			});
-		} catch (e) {
+	/**
+	* Handle errors from tool execution or middleware.
+	* @param error - The error to handle
+	* @param call - The tool call that caused the error
+	* @param isMiddlewareError - Whether the error came from wrapToolCall middleware
+	* @returns ToolMessage if error is handled, otherwise re-throws
+	*/
+	#handleError(error, call, isMiddlewareError) {
+		/**
+		* {@link 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`.
+		*/
+		if ((0, __langchain_langgraph.isGraphInterrupt)(error)) throw error;
+		/**
+		* If the signal is aborted, we want to bubble up the error to the invoke caller.
+		*/
+		if (this.signal?.aborted) throw error;
+		/**
+		* If error is from middleware and handleToolErrors is not true, bubble up
+		* (default handler and false both re-raise middleware errors)
+		*/
+		if (isMiddlewareError && this.handleToolErrors !== true) throw error;
+		/**
+		* If handleToolErrors is false, throw all errors
+		*/
+		if (!this.handleToolErrors) throw error;
+		/**
+		* Apply handleToolErrors to the error
+		*/
+		if (typeof this.handleToolErrors === "function") {
+			const result = this.handleToolErrors(error, call);
+			if (result && __langchain_core_messages.ToolMessage.isInstance(result)) return result;
 			/**
-			* If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}
-			*/
-			if (e instanceof __langchain_core_tools.ToolInputParsingException) throw new require_errors.ToolInvocationError(e, call);
-			/**
-			* throw the error if user prefers not to handle tool errors
-			*/
-			if (!this.handleToolErrors) throw e;
-			if ((0, __langchain_langgraph.isGraphInterrupt)(e))
- /**
-			* {@link 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`.
+			* `handleToolErrors` returned undefined - re-raise
 			*/
-			throw e;
-			/**
-			* If the signal is aborted, we want to bubble up the error to the invoke caller.
-			*/
-			if (this.signal?.aborted) throw e;
+			throw error;
+		} else if (this.handleToolErrors) return new __langchain_core_messages.ToolMessage({
+			name: call.name,
+			content: `${error}\n Please fix your mistakes.`,
+			tool_call_id: call.id
+		});
+		/**
+		* Shouldn't reach here, but throw as fallback
+		*/
+		throw error;
+	}
+	async runTool(call, config, state) {
+		/**
+		* Define the base handler that executes the tool.
+		* When wrapToolCall middleware is present, this handler does NOT catch errors
+		* so the middleware can handle them.
+		* When no middleware, errors are caught and handled here.
+		*/
+		const baseHandler = async (request$1) => {
+			const { toolCall } = request$1;
+			const tool$1 = this.tools.find((tool$2) => tool$2.name === toolCall.name);
+			if (tool$1 === void 0) throw new Error(`Tool "${toolCall.name}" not found.`);
+			try {
+				const output = await tool$1.invoke({
+					...toolCall,
+					type: "tool_call"
+				}, {
+					...config,
+					signal: require_utils.mergeAbortSignals(this.signal, config.signal)
+				});
+				if (__langchain_core_messages.ToolMessage.isInstance(output) || (0, __langchain_langgraph.isCommand)(output)) return output;
+				return new __langchain_core_messages.ToolMessage({
+					name: tool$1.name,
+					content: typeof output === "string" ? output : JSON.stringify(output),
+					tool_call_id: toolCall.id
+				});
+			} catch (e) {
+				/**
+				* Handle errors from tool execution (not from wrapToolCall)
+				* If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}
+				*/
+				if (e instanceof __langchain_core_tools.ToolInputParsingException) throw new require_errors.ToolInvocationError(e, toolCall);
+				/**
+				* Re-throw to be handled by caller
+				*/
+				throw e;
+			}
+		};
+		/**
+		* Build runtime from LangGraph config
+		*/
+		const lgConfig = config;
+		/**
+		* Get private state if available
+		*/
+		const privateState = this.getPrivateState?.() || {
+			threadLevelCallCount: 0,
+			runModelCallCount: 0
+		};
+		const runtime = {
+			context: lgConfig?.context,
+			writer: lgConfig?.writer,
+			interrupt: lgConfig?.interrupt,
+			signal: lgConfig?.signal,
+			threadLevelCallCount: privateState.threadLevelCallCount,
+			runModelCallCount: privateState.runModelCallCount
+		};
+		/**
+		* Find the tool instance to include in the request
+		*/
+		const tool = this.tools.find((t) => t.name === call.name);
+		if (!tool) throw new Error(`Tool "${call.name}" not found.`);
+		const request = {
+			toolCall: call,
+			tool,
+			state: state || {},
+			runtime
+		};
+		/**
+		* If wrapToolCall is provided, use it to wrap the tool execution
+		*/
+		if (this.wrapToolCall && state) try {
+			return await this.wrapToolCall(request, baseHandler);
+		} catch (e) {
 			/**
-			* if the user provides a function, call it with the error and tool call
-			* and return the result if it is a {@link ToolMessage}
+			* Handle middleware errors
 			*/
-			if (typeof this.handleToolErrors === "function") {
-				const result = this.handleToolErrors(e, call);
-				if (result && (0, __langchain_core_messages.isToolMessage)(result)) return result;
-			} else if (this.handleToolErrors) return new __langchain_core_messages.ToolMessage({
-				name: call.name,
-				content: `${e}\n Please fix your mistakes.`,
-				tool_call_id: call.id
-			});
+			return this.#handleError(e, call, true);
+		}
+		/**
+		* No wrapToolCall - execute tool directly and handle errors here
+		*/
+		try {
+			return await baseHandler(request);
+		} catch (e) {
 			/**
-			* If the user doesn't handle the error, throw it
+			* Handle tool errors when no middleware provided
 			*/
-			throw e;
+			return this.#handleError(e, call, false);
 		}
 	}
 	async run(state, config) {
 		let outputs;
-		if (isSendInput(state)) outputs = [await this.runTool(state.lg_tool_call, config)];
+		if (isSendInput(state)) outputs = [await this.runTool(state.lg_tool_call, config, state)];
 		else {
 			let messages;
 			if (isBaseMessageArray(state)) messages = state;
@@ -144,7 +255,7 @@ var ToolNode = class extends require_RunnableCallable.RunnableCallable {
 				}
 			}
 			if (!__langchain_core_messages.AIMessage.isInstance(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, state)) ?? []);
 		}
 		if (!outputs.some(__langchain_langgraph.isCommand)) return Array.isArray(state) ? outputs : { messages: outputs };
 		const combinedOutputs = [];

package/dist/agents/nodes/ToolNode.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ToolNode.cjs","names":["input: unknown","isBaseMessage","RunnableCallable","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","config: RunnableConfig","tool","mergeAbortSignals","ToolMessage","e: unknown","ToolInputParsingException","ToolInvocationError","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","AIMessage","isCommand","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","Command","x: unknown","Send"],"sources":["../../../src/agents/nodes/ToolNode.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-instanceof/no-instanceof */\nimport {\n  BaseMessage,\n  ToolMessage,\n  AIMessage,\n  isBaseMessage,\n  isToolMessage,\n} from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport {\n  DynamicTool,\n  StructuredToolInterface,\n  ToolInputParsingException,\n} from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  isCommand,\n  Command,\n  Send,\n  isGraphInterrupt,\n} from \"@langchain/langgraph\";\n\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport {\n  PreHookAnnotation,\n  AnyAnnotationRoot,\n  ToAnnotationRoot,\n} from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport { ToolInvocationError } from \"../errors.js\";\n\nexport interface ToolNodeOptions {\n  /**\n   * The name of the tool node.\n   */\n  name?: string;\n  /**\n   * The tags to add to the tool call.\n   */\n  tags?: string[];\n  /**\n   * The abort signal to cancel the tool call.\n   */\n  signal?: AbortSignal;\n  /**\n   * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n   *\n   * If `true` (default):\n   *   - a tool message with the error will be returned to the LLM\n   *\n   * If `false`:\n   *   - the error will be thrown immediately\n   *\n   * If a function is provided:\n   *   - returns a custom {@link ToolMessage} as result\n   *   - throws an error otherwise\n   *\n   * @default true\n   */\n  handleToolErrors?:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\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 * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod/v3\";\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 */\nexport class ToolNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = any,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = any\n> extends RunnableCallable<StateSchema, ContextSchema> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  trace = false;\n\n  signal?: AbortSignal;\n\n  handleToolErrors:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined) = true;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    public options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors } = options ?? {};\n    super({\n      name,\n      tags,\n      func: (state, config) =>\n        this.run(\n          state as ToAnnotationRoot<StateSchema>[\"State\"] &\n            PreHookAnnotation[\"State\"],\n          config as RunnableConfig\n        ),\n    });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n    this.signal = options?.signal;\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\n      const output = await tool.invoke(\n        { ...call, type: \"tool_call\" },\n        {\n          ...config,\n          signal: mergeAbortSignals(this.signal, config.signal),\n        }\n      );\n\n      if (ToolMessage.isInstance(output) || isCommand(output)) {\n        return output as ToolMessage | Command;\n      }\n\n      return new ToolMessage({\n        name: tool.name,\n        content: typeof output === \"string\" ? output : JSON.stringify(output),\n        tool_call_id: call.id!,\n      });\n    } catch (e: unknown) {\n      /**\n       * If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}\n       */\n      if (e instanceof ToolInputParsingException) {\n        throw new ToolInvocationError(e, call);\n      }\n\n      /**\n       * throw the error if user prefers not to handle tool errors\n       */\n      if (!this.handleToolErrors) {\n        throw e;\n      }\n\n      if (isGraphInterrupt(e)) {\n        /**\n         * {@link 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         */\n        throw e;\n      }\n\n      /**\n       * If the signal is aborted, we want to bubble up the error to the invoke caller.\n       */\n      if (this.signal?.aborted) {\n        throw e;\n      }\n\n      /**\n       * if the user provides a function, call it with the error and tool call\n       * and return the result if it is a {@link ToolMessage}\n       */\n      if (typeof this.handleToolErrors === \"function\") {\n        const result = this.handleToolErrors(e, call);\n        if (result && isToolMessage(result)) {\n          return result;\n        }\n      } else if (this.handleToolErrors) {\n        return new ToolMessage({\n          name: call.name,\n          content: `${e}\\n Please fix your mistakes.`,\n          tool_call_id: call.id!,\n        });\n      }\n\n      /**\n       * If the user doesn't handle the error, throw it\n       */\n      throw e;\n    }\n  }\n\n  protected async run(\n    state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ): Promise<ContextSchema> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(state)) {\n      outputs = [await this.runTool(state.lg_tool_call, config)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(state)) {\n        messages = state;\n      } else if (isMessagesState(state)) {\n        messages = state.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 (AIMessage.isInstance(message)) {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (!AIMessage.isInstance(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(state)\n        ? outputs\n        : { messages: outputs }) as unknown as ContextSchema;\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(state) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as unknown as ContextSchema;\n  }\n}\n\nexport function isSend(x: unknown): x is Send {\n  return x instanceof Send;\n}\n"],"mappings":";;;;;;;;;AAkEA,MAAM,qBAAqB,CAACA,UAC1B,MAAM,QAAQ,MAAM,IAAI,MAAM,MAAMC,wCAAc;AAEpD,MAAM,kBAAkB,CACtBD,UAEA,OAAO,UAAU,YACjB,SAAS,QACT,cAAc,SACd,mBAAmB,MAAM,SAAS;AAEpC,MAAM,cAAc,CAACA,UACnB,OAAO,UAAU,YAAY,SAAS,QAAQ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8ClE,IAAa,WAAb,cAGUE,0CAA6C;CACrD;CAEA,QAAQ;CAER;CAEA,mBAEwE;CAExE,YACEC,OACOC,SACP;EACA,MAAM,EAAE,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAE;EACtD,MAAM;GACJ;GACA;GACA,MAAM,CAAC,OAAO,WACZ,KAAK,IACH,OAEA,OACD;EACJ,EAAC;EAZK;EAaP,KAAK,QAAQ;EACb,KAAK,mBAAmB,oBAAoB,KAAK;EACjD,KAAK,SAAS,SAAS;CACxB;CAED,MAAgB,QACdC,MACAC,QACgC;EAChC,MAAM,OAAO,KAAK,MAAM,KAAK,CAACC,WAASA,OAAK,SAAS,KAAK,KAAK;AAC/D,MAAI;AACF,OAAI,SAAS,OACX,OAAM,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,KAAK,YAAY,CAAC;GAGlD,MAAM,SAAS,MAAM,KAAK,OACxB;IAAE,GAAG;IAAM,MAAM;GAAa,GAC9B;IACE,GAAG;IACH,QAAQC,gCAAkB,KAAK,QAAQ,OAAO,OAAO;GACtD,EACF;AAED,OAAIC,sCAAY,WAAW,OAAO,yCAAc,OAAO,CACrD,QAAO;AAGT,UAAO,IAAIA,sCAAY;IACrB,MAAM,KAAK;IACX,SAAS,OAAO,WAAW,WAAW,SAAS,KAAK,UAAU,OAAO;IACrE,cAAc,KAAK;GACpB;EACF,SAAQC,GAAY;;;;AAInB,OAAI,aAAaC,iDACf,OAAM,IAAIC,mCAAoB,GAAG;;;;AAMnC,OAAI,CAAC,KAAK,iBACR,OAAM;AAGR,mDAAqB,EAAE;;;;;;AAMrB,SAAM;;;;AAMR,OAAI,KAAK,QAAQ,QACf,OAAM;;;;;AAOR,OAAI,OAAO,KAAK,qBAAqB,YAAY;IAC/C,MAAM,SAAS,KAAK,iBAAiB,GAAG,KAAK;AAC7C,QAAI,uDAAwB,OAAO,CACjC,QAAO;GAEV,WAAU,KAAK,iBACd,QAAO,IAAIH,sCAAY;IACrB,MAAM,KAAK;IACX,SAAS,GAAG,EAAE,4BAA4B,CAAC;IAC3C,cAAc,KAAK;GACpB;;;;AAMH,SAAM;EACP;CACF;CAED,MAAgB,IACdI,OACAP,QACwB;EACxB,IAAIQ;AAEJ,MAAI,YAAY,MAAM,EACpB,UAAU,CAAC,MAAM,KAAK,QAAQ,MAAM,cAAc,OAAO,AAAC;OACrD;GACL,IAAIC;AACJ,OAAI,mBAAmB,MAAM,EAC3B,WAAW;YACF,gBAAgB,MAAM,EAC/B,WAAW,MAAM;OAEjB,OAAM,IAAI,MACR;GAIJ,MAAMC,iBAA8B,IAAI,IACtC,SACG,OAAO,CAAC,QAAQ,IAAI,SAAS,KAAK,OAAO,CACzC,IAAI,CAAC,QAAS,IAAoB,aAAa;GAGpD,IAAIC;AACJ,QAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG;IAChD,MAAM,UAAU,SAAS;AACzB,QAAIC,oCAAU,WAAW,QAAQ,EAAE;KACjC,YAAY;AACZ;IACD;GACF;AAED,OAAI,CAACA,oCAAU,WAAW,UAAU,CAClC,OAAM,IAAI,MAAM;GAGlB,UAAU,MAAM,QAAQ,IACtB,UAAU,YACN,OAAO,CAAC,SAAS,KAAK,MAAM,QAAQ,CAAC,eAAe,IAAI,KAAK,GAAG,CAAC,CAClE,IAAI,CAAC,SAAS,KAAK,QAAQ,MAAM,OAAO,CAAC,IAAI,CAAE,EACnD;EACF;AAGD,MAAI,CAAC,QAAQ,KAAKC,gCAAU,CAC1B,QAAQ,MAAM,QAAQ,MAAM,GACxB,UACA,EAAE,UAAU,QAAS;EAI3B,MAAMC,kBAIA,CAAE;EACR,IAAIC,gBAAgC;AAEpC,OAAK,MAAM,UAAU,QACnB,0CAAc,OAAO,CACnB,KACE,OAAO,UAAUC,8BAAQ,UACzB,MAAM,QAAQ,OAAO,KAAK,IAC1B,OAAO,KAAK,MAAM,CAAC,SAAS,OAAO,KAAK,CAAC,CAEzC,KAAI,eACD,cAAc,KAAgB,KAAK,GAAI,OAAO,KAAgB;OAE/D,gBAAgB,IAAIA,8BAAQ;GAC1B,OAAOA,8BAAQ;GACf,MAAM,OAAO;EACd;OAGH,gBAAgB,KAAK,OAAO;OAG9B,gBAAgB,KACd,MAAM,QAAQ,MAAM,GAAG,CAAC,MAAO,IAAG,EAAE,UAAU,CAAC,MAAO,EAAE,EACzD;AAIL,MAAI,eACF,gBAAgB,KAAK,cAAc;AAGrC,SAAO;CACR;AACF;AAED,SAAgB,OAAOC,GAAuB;AAC5C,QAAO,aAAaC;AACrB"}
+{"version":3,"file":"ToolNode.cjs","names":["input: unknown","BaseMessage","error: unknown","toolCall: ToolCall","ToolInvocationError","ToolMessage","RunnableCallable","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","isMiddlewareError: boolean","config: RunnableConfig","state?: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","request: ToolCallRequest","request","tool","mergeAbortSignals","e: unknown","ToolInputParsingException","#handleError","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","AIMessage","isCommand","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","Command","x: unknown","Send"],"sources":["../../../src/agents/nodes/ToolNode.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-instanceof/no-instanceof */\nimport { BaseMessage, ToolMessage, AIMessage } from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport {\n  DynamicTool,\n  StructuredToolInterface,\n  ToolInputParsingException,\n} from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport type { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  isCommand,\n  Command,\n  Send,\n  isGraphInterrupt,\n  type LangGraphRunnableConfig,\n} from \"@langchain/langgraph\";\n\nimport { RunnableCallable } from \"../RunnableCallable.js\";\nimport { PreHookAnnotation } from \"../annotation.js\";\nimport { mergeAbortSignals } from \"./utils.js\";\nimport { ToolInvocationError } from \"../errors.js\";\nimport type { PrivateState } from \"../runtime.js\";\nimport type {\n  AnyAnnotationRoot,\n  WrapToolCallHook,\n  ToolCallRequest,\n  ToAnnotationRoot,\n} from \"../middleware/types.js\";\n\nexport interface ToolNodeOptions {\n  /**\n   * The name of the tool node.\n   */\n  name?: string;\n  /**\n   * The tags to add to the tool call.\n   */\n  tags?: string[];\n  /**\n   * The abort signal to cancel the tool call.\n   */\n  signal?: AbortSignal;\n  /**\n   * Whether to throw the error immediately if the tool fails or handle it by the `onToolError` function or via ToolMessage.\n   *\n   * **Default behavior** (matches Python):\n   *   - Catches only `ToolInvocationError` (invalid arguments from model) and converts to ToolMessage\n   *   - Re-raises all other errors including errors from `wrapToolCall` middleware\n   *\n   * If `true`:\n   *   - Catches all errors and returns a ToolMessage with the error\n   *\n   * If `false`:\n   *   - All errors are thrown immediately\n   *\n   * If a function is provided:\n   *   - If function returns a `ToolMessage`, use it as the result\n   *   - If function returns `undefined`, re-raise the error\n   *\n   * @default A function that only catches ToolInvocationError\n   */\n  handleToolErrors?:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined);\n  /**\n   * Optional wrapper function for tool execution.\n   * Allows middleware to intercept and modify tool calls before execution.\n   * The wrapper receives the tool call request and a handler function to execute the tool.\n   */\n  wrapToolCall?: WrapToolCallHook;\n  /**\n   * Optional function to get the private state (threadLevelCallCount, runModelCallCount).\n   * Used to provide runtime metadata to wrapToolCall middleware.\n   */\n  getPrivateState?: () => PrivateState;\n}\n\nconst isBaseMessageArray = (input: unknown): input is BaseMessage[] =>\n  Array.isArray(input) && input.every(BaseMessage.isInstance);\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 * Default error handler for tool errors.\n *\n * This is applied to errors from baseHandler (tool execution).\n * For errors from wrapToolCall middleware, those are handled separately\n * and will bubble up by default.\n *\n * Catches all tool execution errors and converts them to ToolMessage.\n * This allows the LLM to see the error and potentially retry with different arguments.\n */\nfunction defaultHandleToolErrors(\n  error: unknown,\n  toolCall: ToolCall\n): ToolMessage | undefined {\n  if (error instanceof ToolInvocationError) {\n    return new ToolMessage({\n      content: error.message,\n      tool_call_id: toolCall.id!,\n      name: toolCall.name,\n    });\n  }\n  /**\n   * Catch all other tool errors and convert to ToolMessage\n   */\n  return new ToolMessage({\n    content: `${error}\\n Please fix your mistakes.`,\n    tool_call_id: toolCall.id!,\n    name: toolCall.name,\n  });\n}\n\n/**\n * `ToolNode` is a built-in LangGraph component that handles tool calls within an agent's workflow.\n * It works seamlessly with `createAgent`, offering advanced tool execution control, built\n * in parallelism, and error handling.\n *\n * @example\n * ```ts\n * import { ToolNode, tool, AIMessage } from \"langchain\";\n * import { z } from \"zod/v3\";\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 */\nexport class ToolNode<\n  StateSchema extends AnyAnnotationRoot | InteropZodObject = any,\n  ContextSchema extends AnyAnnotationRoot | InteropZodObject = any\n> extends RunnableCallable<StateSchema, ContextSchema> {\n  tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n\n  trace = false;\n\n  signal?: AbortSignal;\n\n  handleToolErrors:\n    | boolean\n    | ((error: unknown, toolCall: ToolCall) => ToolMessage | undefined) =\n    defaultHandleToolErrors;\n\n  wrapToolCall?: WrapToolCallHook;\n\n  getPrivateState?: () => PrivateState;\n\n  constructor(\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[],\n    public options?: ToolNodeOptions\n  ) {\n    const { name, tags, handleToolErrors, wrapToolCall, getPrivateState } =\n      options ?? {};\n    super({\n      name,\n      tags,\n      func: (state, config) =>\n        this.run(\n          state as ToAnnotationRoot<StateSchema>[\"State\"] &\n            PreHookAnnotation[\"State\"],\n          config as RunnableConfig\n        ),\n    });\n    this.tools = tools;\n    this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;\n    this.wrapToolCall = wrapToolCall;\n    this.getPrivateState = getPrivateState;\n    this.signal = options?.signal;\n  }\n\n  /**\n   * Handle errors from tool execution or middleware.\n   * @param error - The error to handle\n   * @param call - The tool call that caused the error\n   * @param isMiddlewareError - Whether the error came from wrapToolCall middleware\n   * @returns ToolMessage if error is handled, otherwise re-throws\n   */\n  #handleError(\n    error: unknown,\n    call: ToolCall,\n    isMiddlewareError: boolean\n  ): ToolMessage {\n    /**\n     * {@link 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     */\n    if (isGraphInterrupt(error)) {\n      throw error;\n    }\n\n    /**\n     * If the signal is aborted, we want to bubble up the error to the invoke caller.\n     */\n    if (this.signal?.aborted) {\n      throw error;\n    }\n\n    /**\n     * If error is from middleware and handleToolErrors is not true, bubble up\n     * (default handler and false both re-raise middleware errors)\n     */\n    if (isMiddlewareError && this.handleToolErrors !== true) {\n      throw error;\n    }\n\n    /**\n     * If handleToolErrors is false, throw all errors\n     */\n    if (!this.handleToolErrors) {\n      throw error;\n    }\n\n    /**\n     * Apply handleToolErrors to the error\n     */\n    if (typeof this.handleToolErrors === \"function\") {\n      const result = this.handleToolErrors(error, call);\n      if (result && ToolMessage.isInstance(result)) {\n        return result;\n      }\n\n      /**\n       * `handleToolErrors` returned undefined - re-raise\n       */\n      throw error;\n    } else if (this.handleToolErrors) {\n      return new ToolMessage({\n        name: call.name,\n        content: `${error}\\n Please fix your mistakes.`,\n        tool_call_id: call.id!,\n      });\n    }\n\n    /**\n     * Shouldn't reach here, but throw as fallback\n     */\n    throw error;\n  }\n\n  protected async runTool(\n    call: ToolCall,\n    config: RunnableConfig,\n    state?: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]\n  ): Promise<ToolMessage | Command> {\n    /**\n     * Define the base handler that executes the tool.\n     * When wrapToolCall middleware is present, this handler does NOT catch errors\n     * so the middleware can handle them.\n     * When no middleware, errors are caught and handled here.\n     */\n    const baseHandler = async (\n      request: ToolCallRequest\n    ): Promise<ToolMessage | Command> => {\n      const { toolCall } = request;\n      const tool = this.tools.find((tool) => tool.name === toolCall.name);\n      if (tool === undefined) {\n        throw new Error(`Tool \"${toolCall.name}\" not found.`);\n      }\n\n      try {\n        const output = await tool.invoke(\n          { ...toolCall, type: \"tool_call\" },\n          {\n            ...config,\n            signal: mergeAbortSignals(this.signal, config.signal),\n          }\n        );\n\n        if (ToolMessage.isInstance(output) || isCommand(output)) {\n          return output as ToolMessage | Command;\n        }\n\n        return new ToolMessage({\n          name: tool.name,\n          content: typeof output === \"string\" ? output : JSON.stringify(output),\n          tool_call_id: toolCall.id!,\n        });\n      } catch (e: unknown) {\n        /**\n         * Handle errors from tool execution (not from wrapToolCall)\n         * If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}\n         */\n        if (e instanceof ToolInputParsingException) {\n          throw new ToolInvocationError(e, toolCall);\n        }\n        /**\n         * Re-throw to be handled by caller\n         */\n        throw e;\n      }\n    };\n\n    /**\n     * Build runtime from LangGraph config\n     */\n    const lgConfig = config as LangGraphRunnableConfig;\n\n    /**\n     * Get private state if available\n     */\n    const privateState = this.getPrivateState?.() || {\n      threadLevelCallCount: 0,\n      runModelCallCount: 0,\n    };\n\n    const runtime = {\n      context: lgConfig?.context,\n      writer: lgConfig?.writer,\n      interrupt: lgConfig?.interrupt,\n      signal: lgConfig?.signal,\n      threadLevelCallCount: privateState.threadLevelCallCount,\n      runModelCallCount: privateState.runModelCallCount,\n    };\n\n    /**\n     * Find the tool instance to include in the request\n     */\n    const tool = this.tools.find((t) => t.name === call.name);\n    if (!tool) {\n      throw new Error(`Tool \"${call.name}\" not found.`);\n    }\n\n    const request = {\n      toolCall: call,\n      tool,\n      state: state || ({} as any),\n      runtime,\n    };\n\n    /**\n     * If wrapToolCall is provided, use it to wrap the tool execution\n     */\n    if (this.wrapToolCall && state) {\n      try {\n        return await this.wrapToolCall(request, baseHandler);\n      } catch (e: unknown) {\n        /**\n         * Handle middleware errors\n         */\n        return this.#handleError(e, call, true);\n      }\n    }\n\n    /**\n     * No wrapToolCall - execute tool directly and handle errors here\n     */\n    try {\n      return await baseHandler(request);\n    } catch (e: unknown) {\n      /**\n       * Handle tool errors when no middleware provided\n       */\n      return this.#handleError(e, call, false);\n    }\n  }\n\n  protected async run(\n    state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"],\n    config: RunnableConfig\n  ): Promise<ContextSchema> {\n    let outputs: (ToolMessage | Command)[];\n\n    if (isSendInput(state)) {\n      outputs = [await this.runTool(state.lg_tool_call, config, state)];\n    } else {\n      let messages: BaseMessage[];\n      if (isBaseMessageArray(state)) {\n        messages = state;\n      } else if (isMessagesState(state)) {\n        messages = state.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 (AIMessage.isInstance(message)) {\n          aiMessage = message;\n          break;\n        }\n      }\n\n      if (!AIMessage.isInstance(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, state)) ?? []\n      );\n    }\n\n    // Preserve existing behavior for non-command tool outputs for backwards compatibility\n    if (!outputs.some(isCommand)) {\n      return (Array.isArray(state)\n        ? outputs\n        : { messages: outputs }) as unknown as ContextSchema;\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(state) ? [output] : { messages: [output] }\n        );\n      }\n    }\n\n    if (parentCommand) {\n      combinedOutputs.push(parentCommand);\n    }\n\n    return combinedOutputs as unknown as ContextSchema;\n  }\n}\n\nexport function isSend(x: unknown): x is Send {\n  return x instanceof Send;\n}\n"],"mappings":"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"}