langchain 1.0.0-alpha.8 → 1.0.0-alpha.9

package/dist/agents/nodes/ToolNode.js

@@ -1,15 +1,40 @@
 import { ToolInvocationError } from "../errors.js";
 import { RunnableCallable } from "../RunnableCallable.js";
 import { mergeAbortSignals } from "./utils.js";
-import { AIMessage, ToolMessage, isBaseMessage, isToolMessage } from "@langchain/core/messages";
+import { AIMessage, BaseMessage, ToolMessage } from "@langchain/core/messages";
 import { ToolInputParsingException } from "@langchain/core/tools";
 import { Command, Send, isCommand, isGraphInterrupt } from "@langchain/langgraph";
 
 //#region src/agents/nodes/ToolNode.ts
-const isBaseMessageArray = (input) => Array.isArray(input) && input.every(isBaseMessage);
+const isBaseMessageArray = (input) => Array.isArray(input) && input.every(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 ToolInvocationError) return new ToolMessage({
+		content: error.message,
+		tool_call_id: toolCall.id,
+		name: toolCall.name
+	});
+	/**
+	* Catch all other tool errors and convert to ToolMessage
+	*/
+	return new 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.
@@ -57,9 +82,11 @@ var ToolNode = class extends 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,
@@ -68,66 +95,149 @@ var ToolNode = class extends 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: mergeAbortSignals(this.signal, config.signal)
-			});
-			if (ToolMessage.isInstance(output) || isCommand(output)) return output;
-			return new 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 (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 && ToolMessage.isInstance(result)) return result;
 			/**
-			* If tool invocation fails due to input parsing error, throw a {@link ToolInvocationError}
+			* `handleToolErrors` returned undefined - re-raise
 			*/
-			if (e instanceof ToolInputParsingException) throw new ToolInvocationError(e, call);
+			throw error;
+		} else if (this.handleToolErrors) return new 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 (toolCall) => {
+			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: mergeAbortSignals(this.signal, config.signal)
+				});
+				if (ToolMessage.isInstance(output) || isCommand(output)) return output;
+				return new 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 ToolInputParsingException) throw new ToolInvocationError(e, toolCall);
+				/**
+				* Re-throw to be handled by caller
+				*/
+				throw e;
+			}
+		};
+		/**
+		* If wrapToolCall is provided, use it to wrap the tool execution
+		*/
+		if (this.wrapToolCall && state) try {
 			/**
-			* throw the error if user prefers not to handle tool errors
+			* Build runtime from LangGraph config (similar to MiddlewareNode)
 			*/
-			if (!this.handleToolErrors) throw e;
-			if (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`.
+			const lgConfig = config;
+			/**
+			* Get private state if available
 			*/
-			throw e;
+			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
+			};
 			/**
-			* If the signal is aborted, we want to bubble up the error to the invoke caller.
+			* Find the tool instance to include in the request
 			*/
-			if (this.signal?.aborted) throw e;
+			const tool$1 = this.tools.find((t) => t.name === call.name);
+			if (!tool$1) throw new Error(`Tool "${call.name}" not found.`);
+			const request = {
+				toolCall: call,
+				tool: tool$1,
+				state,
+				runtime
+			};
+			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 && isToolMessage(result)) return result;
-			} else if (this.handleToolErrors) return new 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(call);
+		} 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;
@@ -143,7 +253,7 @@ var ToolNode = class extends RunnableCallable {
 				}
 			}
 			if (!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(isCommand)) return Array.isArray(state) ? outputs : { messages: outputs };
 		const combinedOutputs = [];

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

@@ -1 +1 @@
-{"version":3,"file":"ToolNode.js","names":["input: unknown","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","config: RunnableConfig","tool","e: unknown","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","x: unknown"],"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":"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"}
+{"version":3,"file":"ToolNode.js","names":["input: unknown","error: unknown","toolCall: ToolCall","tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[]","options?: ToolNodeOptions","call: ToolCall","isMiddlewareError: boolean","config: RunnableConfig","state?: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","tool","e: unknown","#handleError","state: ToAnnotationRoot<StateSchema>[\"State\"] & PreHookAnnotation[\"State\"]","outputs: (ToolMessage | Command)[]","messages: BaseMessage[]","toolMessageIds: Set<string>","aiMessage: AIMessage | undefined","combinedOutputs: (\n      | { messages: BaseMessage[] }\n      | BaseMessage[]\n      | Command\n    )[]","parentCommand: Command | null","x: unknown"],"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  ToAnnotationRoot,\n  AnyAnnotationRoot,\n  ToolCallWrapper,\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?: ToolCallWrapper;\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?: ToolCallWrapper;\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      toolCall: ToolCall\n    ): Promise<ToolMessage | Command> => {\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     * If wrapToolCall is provided, use it to wrap the tool execution\n     */\n    if (this.wrapToolCall && state) {\n      try {\n        /**\n         * Build runtime from LangGraph config (similar to MiddlewareNode)\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,\n          runtime,\n        };\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(call);\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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"}

package/dist/agents/{middlewareAgent/nodes → nodes}/middleware.cjs

@@ -1,9 +1,14 @@
-const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
-const require_RunnableCallable = require('../../RunnableCallable.cjs');
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_RunnableCallable = require('../RunnableCallable.cjs');
 const require_utils = require('./utils.cjs');
 const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
 
-//#region src/agents/middlewareAgent/nodes/middleware.ts
+//#region src/agents/nodes/middleware.ts
+/**
+* Named class for context objects to provide better error messages
+*/
+var AgentContext = class {};
+var AgentRuntime = class {};
 var MiddlewareNode = class extends require_RunnableCallable.RunnableCallable {
 	#options;
 	constructor(fields, options) {
@@ -44,10 +49,17 @@ var MiddlewareNode = class extends require_RunnableCallable.RunnableCallable {
 			signal: config?.signal,
 			...this.#options.getPrivateState()
 		};
-		const result = await this.runHook(state, Object.freeze({
-			...runtime,
-			context: filteredContext
-		}));
+		const result = await this.runHook(
+			state,
+			/**
+			* assign runtime and context values into empty named class
+			* instances to create a better error message.
+			*/
+			Object.freeze(Object.assign(new AgentRuntime(), {
+				...runtime,
+				context: Object.freeze(Object.assign(new AgentContext(), filteredContext))
+			}))
+		);
 		delete result?._privateState;
 		/**
 		* If result is undefined, return current state
@@ -59,10 +71,23 @@ var MiddlewareNode = class extends require_RunnableCallable.RunnableCallable {
 		/**
 		* Verify that the jump target is allowed for the middleware
 		*/
-		const jumpToConstraint = this.name?.startsWith("BeforeModelNode_") ? this.middleware.beforeModelJumpTo : this.middleware.afterModelJumpTo;
+		let jumpToConstraint;
+		let constraint;
+		if (this.name?.startsWith("BeforeAgentNode_")) {
+			jumpToConstraint = this.middleware.beforeAgentJumpTo;
+			constraint = "beforeAgentJumpTo";
+		} else if (this.name?.startsWith("BeforeModelNode_")) {
+			jumpToConstraint = this.middleware.beforeModelJumpTo;
+			constraint = "beforeModelJumpTo";
+		} else if (this.name?.startsWith("AfterAgentNode_")) {
+			jumpToConstraint = this.middleware.afterAgentJumpTo;
+			constraint = "afterAgentJumpTo";
+		} else if (this.name?.startsWith("AfterModelNode_")) {
+			jumpToConstraint = this.middleware.afterModelJumpTo;
+			constraint = "afterModelJumpTo";
+		}
 		if (typeof result.jumpTo === "string" && !jumpToConstraint?.includes(result.jumpTo)) {
-			const constraint = this.name?.startsWith("BeforeModelNode_") ? "beforeModelJumpTo" : "afterModelJumpTo";
-			const suggestion = jumpToConstraint && jumpToConstraint.length > 0 ? `must be one of: ${jumpToConstraint?.join(", ")}.` : `no ${constraint} defined in middleware ${this.middleware.name}.`;
+			const suggestion = jumpToConstraint && jumpToConstraint.length > 0 ? `must be one of: ${jumpToConstraint?.join(", ")}.` : constraint ? `no ${constraint} defined in middleware ${this.middleware.name}.` : "";
 			throw new Error(`Invalid jump target: ${result.jumpTo}, ${suggestion}.`);
 		}
 		const jumpTo = require_utils.parseJumpToTarget(result.jumpTo);

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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.cjs","names":["RunnableCallable","fields: RunnableCallableArgs<TStateSchema, NodeOutput<TStateSchema>>","options: MiddlewareNodeOptions","#options","state: TStateSchema","config?: LangGraphRunnableConfig","relevantContext: Record<string, unknown>","runtime: Runtime<TContextSchema>","jumpToConstraint: JumpToTarget[] | undefined","constraint: string | undefined","parseJumpToTarget","derivePrivateState"],"sources":["../../../src/agents/nodes/middleware.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { LangGraphRunnableConfig, Command } from \"@langchain/langgraph\";\nimport { interopParse } from \"@langchain/core/utils/types\";\n\nimport { RunnableCallable, RunnableCallableArgs } from \"../RunnableCallable.js\";\nimport type { JumpToTarget } from \"../constants.js\";\nimport type { Runtime, PrivateState } from \"../runtime.js\";\nimport type { AgentMiddleware, MiddlewareResult } from \"../middleware/types.js\";\nimport { derivePrivateState, parseJumpToTarget } from \"./utils.js\";\n\n/**\n * Named class for context objects to provide better error messages\n */\nclass AgentContext {}\nclass AgentRuntime {}\n\ntype NodeOutput<TStateSchema extends Record<string, any>> =\n  | TStateSchema\n  | Command<any, TStateSchema, string>;\n\nexport interface MiddlewareNodeOptions {\n  getPrivateState: () => PrivateState;\n}\n\nexport abstract class MiddlewareNode<\n  TStateSchema extends Record<string, any>,\n  TContextSchema extends Record<string, any>\n> extends RunnableCallable<TStateSchema, NodeOutput<TStateSchema>> {\n  #options: MiddlewareNodeOptions;\n\n  abstract middleware: AgentMiddleware<\n    z.ZodObject<z.ZodRawShape>,\n    z.ZodObject<z.ZodRawShape>\n  >;\n\n  constructor(\n    fields: RunnableCallableArgs<TStateSchema, NodeOutput<TStateSchema>>,\n    options: MiddlewareNodeOptions\n  ) {\n    super(fields);\n    this.#options = options;\n  }\n\n  abstract runHook(\n    state: TStateSchema,\n    config?: Runtime<TContextSchema>\n  ): Promise<MiddlewareResult<TStateSchema>>;\n\n  async invokeMiddleware(\n    state: TStateSchema,\n    config?: LangGraphRunnableConfig\n  ): Promise<NodeOutput<TStateSchema>> {\n    /**\n     * Filter context based on middleware's contextSchema\n     */\n    let filteredContext = {} as TContextSchema;\n    /**\n     * Parse context using middleware's contextSchema to apply defaults and validation\n     */\n    if (this.middleware.contextSchema) {\n      /**\n       * Extract only the fields relevant to this middleware's schema\n       */\n      const schemaShape = this.middleware.contextSchema?.shape;\n      if (schemaShape) {\n        const relevantContext: Record<string, unknown> = {};\n        const invokeContext = config?.context || {};\n        for (const key of Object.keys(schemaShape)) {\n          if (key in invokeContext) {\n            relevantContext[key] = invokeContext[key];\n          }\n        }\n        /**\n         * Parse to apply defaults and validation, even if relevantContext is empty\n         * This will throw if required fields are missing and no defaults exist\n         */\n        filteredContext = interopParse(\n          this.middleware.contextSchema,\n          relevantContext\n        ) as TContextSchema;\n      }\n    }\n\n    /**\n     * ToDo: implement later\n     */\n    const runtime: Runtime<TContextSchema> = {\n      context: filteredContext,\n      writer: config?.writer,\n      interrupt: config?.interrupt,\n      signal: config?.signal,\n      ...this.#options.getPrivateState(),\n    };\n\n    const result = await this.runHook(\n      state,\n      /**\n       * assign runtime and context values into empty named class\n       * instances to create a better error message.\n       */\n      Object.freeze(\n        Object.assign(new AgentRuntime(), {\n          ...runtime,\n          context: Object.freeze(\n            Object.assign(new AgentContext(), filteredContext)\n          ),\n        })\n      )\n    );\n    delete result?._privateState;\n\n    /**\n     * If result is undefined, return current state\n     */\n    if (!result) {\n      return { ...state, jumpTo: undefined };\n    }\n\n    /**\n     * Verify that the jump target is allowed for the middleware\n     */\n    let jumpToConstraint: JumpToTarget[] | undefined;\n    let constraint: string | undefined;\n\n    if (this.name?.startsWith(\"BeforeAgentNode_\")) {\n      jumpToConstraint = this.middleware.beforeAgentJumpTo;\n      constraint = \"beforeAgentJumpTo\";\n    } else if (this.name?.startsWith(\"BeforeModelNode_\")) {\n      jumpToConstraint = this.middleware.beforeModelJumpTo;\n      constraint = \"beforeModelJumpTo\";\n    } else if (this.name?.startsWith(\"AfterAgentNode_\")) {\n      jumpToConstraint = this.middleware.afterAgentJumpTo;\n      constraint = \"afterAgentJumpTo\";\n    } else if (this.name?.startsWith(\"AfterModelNode_\")) {\n      jumpToConstraint = this.middleware.afterModelJumpTo;\n      constraint = \"afterModelJumpTo\";\n    }\n\n    if (\n      typeof result.jumpTo === \"string\" &&\n      !jumpToConstraint?.includes(result.jumpTo as JumpToTarget)\n    ) {\n      const suggestion =\n        jumpToConstraint && jumpToConstraint.length > 0\n          ? `must be one of: ${jumpToConstraint?.join(\", \")}.`\n          : constraint\n          ? `no ${constraint} defined in middleware ${this.middleware.name}.`\n          : \"\";\n      throw new Error(`Invalid jump target: ${result.jumpTo}, ${suggestion}.`);\n    }\n\n    const jumpTo = parseJumpToTarget(result.jumpTo as string);\n\n    /**\n     * If result is a control action, handle it\n     */\n    if (typeof result === \"object\" && \"type\" in result) {\n      // Handle control actions\n      if (result.type === \"terminate\") {\n        if (result.error) {\n          throw result.error;\n        }\n        return {\n          ...state,\n          ...(result.result || {}),\n          jumpTo,\n        };\n      }\n\n      throw new Error(`Invalid control action: ${JSON.stringify(result)}`);\n    }\n\n    /**\n     * If result is a state update, merge it with current state\n     */\n    return { ...state, ...result, jumpTo };\n  }\n\n  get nodeOptions(): {\n    input: z.ZodObject<TStateSchema>;\n  } {\n    return {\n      input: derivePrivateState(\n        this.middleware.stateSchema\n      ) as z.ZodObject<TStateSchema>,\n    };\n  }\n}\n"],"mappings":";;;;;;;;;AAcA,IAAM,eAAN,MAAmB,CAAE;AACrB,IAAM,eAAN,MAAmB,CAAE;AAUrB,IAAsB,iBAAtB,cAGUA,0CAAyD;CACjE;CAOA,YACEC,QACAC,SACA;EACA,MAAM,OAAO;EACb,KAAKC,WAAW;CACjB;CAOD,MAAM,iBACJC,OACAC,QACmC;;;;EAInC,IAAI,kBAAkB,CAAE;;;;AAIxB,MAAI,KAAK,WAAW,eAAe;;;;GAIjC,MAAM,cAAc,KAAK,WAAW,eAAe;AACnD,OAAI,aAAa;IACf,MAAMC,kBAA2C,CAAE;IACnD,MAAM,gBAAgB,QAAQ,WAAW,CAAE;AAC3C,SAAK,MAAM,OAAO,OAAO,KAAK,YAAY,CACxC,KAAI,OAAO,eACT,gBAAgB,OAAO,cAAc;;;;;IAOzC,iEACE,KAAK,WAAW,eAChB,gBACD;GACF;EACF;;;;EAKD,MAAMC,UAAmC;GACvC,SAAS;GACT,QAAQ,QAAQ;GAChB,WAAW,QAAQ;GACnB,QAAQ,QAAQ;GAChB,GAAG,KAAKJ,SAAS,iBAAiB;EACnC;EAED,MAAM,SAAS,MAAM,KAAK;GACxB;;;;;GAKA,OAAO,OACL,OAAO,OAAO,IAAI,gBAAgB;IAChC,GAAG;IACH,SAAS,OAAO,OACd,OAAO,OAAO,IAAI,gBAAgB,gBAAgB,CACnD;GACF,EAAC,CACH;GACF;EACD,OAAO,QAAQ;;;;AAKf,MAAI,CAAC,OACH,QAAO;GAAE,GAAG;GAAO,QAAQ;EAAW;;;;EAMxC,IAAIK;EACJ,IAAIC;AAEJ,MAAI,KAAK,MAAM,WAAW,mBAAmB,EAAE;GAC7C,mBAAmB,KAAK,WAAW;GACnC,aAAa;EACd,WAAU,KAAK,MAAM,WAAW,mBAAmB,EAAE;GACpD,mBAAmB,KAAK,WAAW;GACnC,aAAa;EACd,WAAU,KAAK,MAAM,WAAW,kBAAkB,EAAE;GACnD,mBAAmB,KAAK,WAAW;GACnC,aAAa;EACd,WAAU,KAAK,MAAM,WAAW,kBAAkB,EAAE;GACnD,mBAAmB,KAAK,WAAW;GACnC,aAAa;EACd;AAED,MACE,OAAO,OAAO,WAAW,YACzB,CAAC,kBAAkB,SAAS,OAAO,OAAuB,EAC1D;GACA,MAAM,aACJ,oBAAoB,iBAAiB,SAAS,IAC1C,CAAC,gBAAgB,EAAE,kBAAkB,KAAK,KAAK,CAAC,CAAC,CAAC,GAClD,aACA,CAAC,GAAG,EAAE,WAAW,uBAAuB,EAAE,KAAK,WAAW,KAAK,CAAC,CAAC,GACjE;AACN,SAAM,IAAI,MAAM,CAAC,qBAAqB,EAAE,OAAO,OAAO,EAAE,EAAE,WAAW,CAAC,CAAC;EACxE;EAED,MAAM,SAASC,gCAAkB,OAAO,OAAiB;;;;AAKzD,MAAI,OAAO,WAAW,YAAY,UAAU,QAAQ;AAElD,OAAI,OAAO,SAAS,aAAa;AAC/B,QAAI,OAAO,MACT,OAAM,OAAO;AAEf,WAAO;KACL,GAAG;KACH,GAAI,OAAO,UAAU,CAAE;KACvB;IACD;GACF;AAED,SAAM,IAAI,MAAM,CAAC,wBAAwB,EAAE,KAAK,UAAU,OAAO,EAAE;EACpE;;;;AAKD,SAAO;GAAE,GAAG;GAAO,GAAG;GAAQ;EAAQ;CACvC;CAED,IAAI,cAEF;AACA,SAAO,EACL,OAAOC,iCACL,KAAK,WAAW,YACjB,CACF;CACF;AACF"}

package/dist/agents/{middlewareAgent/nodes → nodes}/middleware.js

@@ -1,8 +1,13 @@
-import { RunnableCallable } from "../../RunnableCallable.js";
+import { RunnableCallable } from "../RunnableCallable.js";
 import { derivePrivateState, parseJumpToTarget } from "./utils.js";
 import { interopParse } from "@langchain/core/utils/types";
 
-//#region src/agents/middlewareAgent/nodes/middleware.ts
+//#region src/agents/nodes/middleware.ts
+/**
+* Named class for context objects to provide better error messages
+*/
+var AgentContext = class {};
+var AgentRuntime = class {};
 var MiddlewareNode = class extends RunnableCallable {
 	#options;
 	constructor(fields, options) {
@@ -43,10 +48,17 @@ var MiddlewareNode = class extends RunnableCallable {
 			signal: config?.signal,
 			...this.#options.getPrivateState()
 		};
-		const result = await this.runHook(state, Object.freeze({
-			...runtime,
-			context: filteredContext
-		}));
+		const result = await this.runHook(
+			state,
+			/**
+			* assign runtime and context values into empty named class
+			* instances to create a better error message.
+			*/
+			Object.freeze(Object.assign(new AgentRuntime(), {
+				...runtime,
+				context: Object.freeze(Object.assign(new AgentContext(), filteredContext))
+			}))
+		);
 		delete result?._privateState;
 		/**
 		* If result is undefined, return current state
@@ -58,10 +70,23 @@ var MiddlewareNode = class extends RunnableCallable {
 		/**
 		* Verify that the jump target is allowed for the middleware
 		*/
-		const jumpToConstraint = this.name?.startsWith("BeforeModelNode_") ? this.middleware.beforeModelJumpTo : this.middleware.afterModelJumpTo;
+		let jumpToConstraint;
+		let constraint;
+		if (this.name?.startsWith("BeforeAgentNode_")) {
+			jumpToConstraint = this.middleware.beforeAgentJumpTo;
+			constraint = "beforeAgentJumpTo";
+		} else if (this.name?.startsWith("BeforeModelNode_")) {
+			jumpToConstraint = this.middleware.beforeModelJumpTo;
+			constraint = "beforeModelJumpTo";
+		} else if (this.name?.startsWith("AfterAgentNode_")) {
+			jumpToConstraint = this.middleware.afterAgentJumpTo;
+			constraint = "afterAgentJumpTo";
+		} else if (this.name?.startsWith("AfterModelNode_")) {
+			jumpToConstraint = this.middleware.afterModelJumpTo;
+			constraint = "afterModelJumpTo";
+		}
 		if (typeof result.jumpTo === "string" && !jumpToConstraint?.includes(result.jumpTo)) {
-			const constraint = this.name?.startsWith("BeforeModelNode_") ? "beforeModelJumpTo" : "afterModelJumpTo";
-			const suggestion = jumpToConstraint && jumpToConstraint.length > 0 ? `must be one of: ${jumpToConstraint?.join(", ")}.` : `no ${constraint} defined in middleware ${this.middleware.name}.`;
+			const suggestion = jumpToConstraint && jumpToConstraint.length > 0 ? `must be one of: ${jumpToConstraint?.join(", ")}.` : constraint ? `no ${constraint} defined in middleware ${this.middleware.name}.` : "";
 			throw new Error(`Invalid jump target: ${result.jumpTo}, ${suggestion}.`);
 		}
 		const jumpTo = parseJumpToTarget(result.jumpTo);

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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","names":["fields: RunnableCallableArgs<TStateSchema, NodeOutput<TStateSchema>>","options: MiddlewareNodeOptions","#options","state: TStateSchema","config?: LangGraphRunnableConfig","relevantContext: Record<string, unknown>","runtime: Runtime<TContextSchema>","jumpToConstraint: JumpToTarget[] | undefined","constraint: string | undefined"],"sources":["../../../src/agents/nodes/middleware.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { LangGraphRunnableConfig, Command } from \"@langchain/langgraph\";\nimport { interopParse } from \"@langchain/core/utils/types\";\n\nimport { RunnableCallable, RunnableCallableArgs } from \"../RunnableCallable.js\";\nimport type { JumpToTarget } from \"../constants.js\";\nimport type { Runtime, PrivateState } from \"../runtime.js\";\nimport type { AgentMiddleware, MiddlewareResult } from \"../middleware/types.js\";\nimport { derivePrivateState, parseJumpToTarget } from \"./utils.js\";\n\n/**\n * Named class for context objects to provide better error messages\n */\nclass AgentContext {}\nclass AgentRuntime {}\n\ntype NodeOutput<TStateSchema extends Record<string, any>> =\n  | TStateSchema\n  | Command<any, TStateSchema, string>;\n\nexport interface MiddlewareNodeOptions {\n  getPrivateState: () => PrivateState;\n}\n\nexport abstract class MiddlewareNode<\n  TStateSchema extends Record<string, any>,\n  TContextSchema extends Record<string, any>\n> extends RunnableCallable<TStateSchema, NodeOutput<TStateSchema>> {\n  #options: MiddlewareNodeOptions;\n\n  abstract middleware: AgentMiddleware<\n    z.ZodObject<z.ZodRawShape>,\n    z.ZodObject<z.ZodRawShape>\n  >;\n\n  constructor(\n    fields: RunnableCallableArgs<TStateSchema, NodeOutput<TStateSchema>>,\n    options: MiddlewareNodeOptions\n  ) {\n    super(fields);\n    this.#options = options;\n  }\n\n  abstract runHook(\n    state: TStateSchema,\n    config?: Runtime<TContextSchema>\n  ): Promise<MiddlewareResult<TStateSchema>>;\n\n  async invokeMiddleware(\n    state: TStateSchema,\n    config?: LangGraphRunnableConfig\n  ): Promise<NodeOutput<TStateSchema>> {\n    /**\n     * Filter context based on middleware's contextSchema\n     */\n    let filteredContext = {} as TContextSchema;\n    /**\n     * Parse context using middleware's contextSchema to apply defaults and validation\n     */\n    if (this.middleware.contextSchema) {\n      /**\n       * Extract only the fields relevant to this middleware's schema\n       */\n      const schemaShape = this.middleware.contextSchema?.shape;\n      if (schemaShape) {\n        const relevantContext: Record<string, unknown> = {};\n        const invokeContext = config?.context || {};\n        for (const key of Object.keys(schemaShape)) {\n          if (key in invokeContext) {\n            relevantContext[key] = invokeContext[key];\n          }\n        }\n        /**\n         * Parse to apply defaults and validation, even if relevantContext is empty\n         * This will throw if required fields are missing and no defaults exist\n         */\n        filteredContext = interopParse(\n          this.middleware.contextSchema,\n          relevantContext\n        ) as TContextSchema;\n      }\n    }\n\n    /**\n     * ToDo: implement later\n     */\n    const runtime: Runtime<TContextSchema> = {\n      context: filteredContext,\n      writer: config?.writer,\n      interrupt: config?.interrupt,\n      signal: config?.signal,\n      ...this.#options.getPrivateState(),\n    };\n\n    const result = await this.runHook(\n      state,\n      /**\n       * assign runtime and context values into empty named class\n       * instances to create a better error message.\n       */\n      Object.freeze(\n        Object.assign(new AgentRuntime(), {\n          ...runtime,\n          context: Object.freeze(\n            Object.assign(new AgentContext(), filteredContext)\n          ),\n        })\n      )\n    );\n    delete result?._privateState;\n\n    /**\n     * If result is undefined, return current state\n     */\n    if (!result) {\n      return { ...state, jumpTo: undefined };\n    }\n\n    /**\n     * Verify that the jump target is allowed for the middleware\n     */\n    let jumpToConstraint: JumpToTarget[] | undefined;\n    let constraint: string | undefined;\n\n    if (this.name?.startsWith(\"BeforeAgentNode_\")) {\n      jumpToConstraint = this.middleware.beforeAgentJumpTo;\n      constraint = \"beforeAgentJumpTo\";\n    } else if (this.name?.startsWith(\"BeforeModelNode_\")) {\n      jumpToConstraint = this.middleware.beforeModelJumpTo;\n      constraint = \"beforeModelJumpTo\";\n    } else if (this.name?.startsWith(\"AfterAgentNode_\")) {\n      jumpToConstraint = this.middleware.afterAgentJumpTo;\n      constraint = \"afterAgentJumpTo\";\n    } else if (this.name?.startsWith(\"AfterModelNode_\")) {\n      jumpToConstraint = this.middleware.afterModelJumpTo;\n      constraint = \"afterModelJumpTo\";\n    }\n\n    if (\n      typeof result.jumpTo === \"string\" &&\n      !jumpToConstraint?.includes(result.jumpTo as JumpToTarget)\n    ) {\n      const suggestion =\n        jumpToConstraint && jumpToConstraint.length > 0\n          ? `must be one of: ${jumpToConstraint?.join(\", \")}.`\n          : constraint\n          ? `no ${constraint} defined in middleware ${this.middleware.name}.`\n          : \"\";\n      throw new Error(`Invalid jump target: ${result.jumpTo}, ${suggestion}.`);\n    }\n\n    const jumpTo = parseJumpToTarget(result.jumpTo as string);\n\n    /**\n     * If result is a control action, handle it\n     */\n    if (typeof result === \"object\" && \"type\" in result) {\n      // Handle control actions\n      if (result.type === \"terminate\") {\n        if (result.error) {\n          throw result.error;\n        }\n        return {\n          ...state,\n          ...(result.result || {}),\n          jumpTo,\n        };\n      }\n\n      throw new Error(`Invalid control action: ${JSON.stringify(result)}`);\n    }\n\n    /**\n     * If result is a state update, merge it with current state\n     */\n    return { ...state, ...result, jumpTo };\n  }\n\n  get nodeOptions(): {\n    input: z.ZodObject<TStateSchema>;\n  } {\n    return {\n      input: derivePrivateState(\n        this.middleware.stateSchema\n      ) as z.ZodObject<TStateSchema>,\n    };\n  }\n}\n"],"mappings":";;;;;;;;AAcA,IAAM,eAAN,MAAmB,CAAE;AACrB,IAAM,eAAN,MAAmB,CAAE;AAUrB,IAAsB,iBAAtB,cAGU,iBAAyD;CACjE;CAOA,YACEA,QACAC,SACA;EACA,MAAM,OAAO;EACb,KAAKC,WAAW;CACjB;CAOD,MAAM,iBACJC,OACAC,QACmC;;;;EAInC,IAAI,kBAAkB,CAAE;;;;AAIxB,MAAI,KAAK,WAAW,eAAe;;;;GAIjC,MAAM,cAAc,KAAK,WAAW,eAAe;AACnD,OAAI,aAAa;IACf,MAAMC,kBAA2C,CAAE;IACnD,MAAM,gBAAgB,QAAQ,WAAW,CAAE;AAC3C,SAAK,MAAM,OAAO,OAAO,KAAK,YAAY,CACxC,KAAI,OAAO,eACT,gBAAgB,OAAO,cAAc;;;;;IAOzC,kBAAkB,aAChB,KAAK,WAAW,eAChB,gBACD;GACF;EACF;;;;EAKD,MAAMC,UAAmC;GACvC,SAAS;GACT,QAAQ,QAAQ;GAChB,WAAW,QAAQ;GACnB,QAAQ,QAAQ;GAChB,GAAG,KAAKJ,SAAS,iBAAiB;EACnC;EAED,MAAM,SAAS,MAAM,KAAK;GACxB;;;;;GAKA,OAAO,OACL,OAAO,OAAO,IAAI,gBAAgB;IAChC,GAAG;IACH,SAAS,OAAO,OACd,OAAO,OAAO,IAAI,gBAAgB,gBAAgB,CACnD;GACF,EAAC,CACH;GACF;EACD,OAAO,QAAQ;;;;AAKf,MAAI,CAAC,OACH,QAAO;GAAE,GAAG;GAAO,QAAQ;EAAW;;;;EAMxC,IAAIK;EACJ,IAAIC;AAEJ,MAAI,KAAK,MAAM,WAAW,mBAAmB,EAAE;GAC7C,mBAAmB,KAAK,WAAW;GACnC,aAAa;EACd,WAAU,KAAK,MAAM,WAAW,mBAAmB,EAAE;GACpD,mBAAmB,KAAK,WAAW;GACnC,aAAa;EACd,WAAU,KAAK,MAAM,WAAW,kBAAkB,EAAE;GACnD,mBAAmB,KAAK,WAAW;GACnC,aAAa;EACd,WAAU,KAAK,MAAM,WAAW,kBAAkB,EAAE;GACnD,mBAAmB,KAAK,WAAW;GACnC,aAAa;EACd;AAED,MACE,OAAO,OAAO,WAAW,YACzB,CAAC,kBAAkB,SAAS,OAAO,OAAuB,EAC1D;GACA,MAAM,aACJ,oBAAoB,iBAAiB,SAAS,IAC1C,CAAC,gBAAgB,EAAE,kBAAkB,KAAK,KAAK,CAAC,CAAC,CAAC,GAClD,aACA,CAAC,GAAG,EAAE,WAAW,uBAAuB,EAAE,KAAK,WAAW,KAAK,CAAC,CAAC,GACjE;AACN,SAAM,IAAI,MAAM,CAAC,qBAAqB,EAAE,OAAO,OAAO,EAAE,EAAE,WAAW,CAAC,CAAC;EACxE;EAED,MAAM,SAAS,kBAAkB,OAAO,OAAiB;;;;AAKzD,MAAI,OAAO,WAAW,YAAY,UAAU,QAAQ;AAElD,OAAI,OAAO,SAAS,aAAa;AAC/B,QAAI,OAAO,MACT,OAAM,OAAO;AAEf,WAAO;KACL,GAAG;KACH,GAAI,OAAO,UAAU,CAAE;KACvB;IACD;GACF;AAED,SAAM,IAAI,MAAM,CAAC,wBAAwB,EAAE,KAAK,UAAU,OAAO,EAAE;EACpE;;;;AAKD,SAAO;GAAE,GAAG;GAAO,GAAG;GAAQ;EAAQ;CACvC;CAED,IAAI,cAEF;AACA,SAAO,EACL,OAAO,mBACL,KAAK,WAAW,YACjB,CACF;CACF;AACF"}

package/dist/agents/nodes/types.d.cts

@@ -0,0 +1,57 @@
+import { ClientTool, ServerTool } from "../tools.cjs";
+import { AgentBuiltInState, Runtime } from "../runtime.cjs";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+import { BaseMessage } from "@langchain/core/messages";
+
+//#region src/agents/nodes/types.d.ts
+
+/**
+ * Configuration for modifying a model call at runtime.
+ * All fields are optional and only provided fields will override defaults.
+ *
+ * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.
+ * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.
+ */
+interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {
+  /**
+   * The model to use for this step.
+   */
+  model: LanguageModelLike;
+  /**
+   * The messages to send to the model.
+   */
+  messages: BaseMessage[];
+  /**
+   * The system message for this step.
+   */
+  systemPrompt?: string;
+  /**
+   * Tool choice configuration (model-specific format).
+   * Can be one of:
+   * - `"auto"`: means the model can pick between generating a message or calling one or more tools.
+   * - `"none"`: means the model will not call any tool and instead generates a message.
+   * - `"required"`: means the model must call one or more tools.
+   * - `{ type: "function", function: { name: string } }`: The model will use the specified function.
+   */
+  toolChoice?: "auto" | "none" | "required" | {
+    type: "function";
+    function: {
+      name: string;
+    };
+  };
+  /**
+   * The tools to make available for this step.
+   */
+  tools: (ServerTool | ClientTool)[];
+  /**
+   * The current agent state (includes both middleware state and built-in state).
+   */
+  state: TState & AgentBuiltInState;
+  /**
+   * The runtime context containing metadata, signal, writer, interrupt, etc.
+   */
+  runtime: Runtime<TContext>;
+}
+//#endregion
+export { ModelRequest };
+//# sourceMappingURL=types.d.cts.map

package/dist/agents/nodes/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":["LanguageModelLike","BaseMessage","ServerTool","ClientTool","Runtime","AgentBuiltInState","ModelRequest","Record","TState","TContext"],"sources":["../../../src/agents/nodes/types.d.ts"],"sourcesContent":["import type { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { ServerTool, ClientTool } from \"../tools.js\";\nimport type { Runtime, AgentBuiltInState } from \"../runtime.js\";\n/**\n * Configuration for modifying a model call at runtime.\n * All fields are optional and only provided fields will override defaults.\n *\n * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.\n * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.\n */\nexport interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {\n    /**\n     * The model to use for this step.\n     */\n    model: LanguageModelLike;\n    /**\n     * The messages to send to the model.\n     */\n    messages: BaseMessage[];\n    /**\n     * The system message for this step.\n     */\n    systemPrompt?: string;\n    /**\n     * Tool choice configuration (model-specific format).\n     * Can be one of:\n     * - `\"auto\"`: means the model can pick between generating a message or calling one or more tools.\n     * - `\"none\"`: means the model will not call any tool and instead generates a message.\n     * - `\"required\"`: means the model must call one or more tools.\n     * - `{ type: \"function\", function: { name: string } }`: The model will use the specified function.\n     */\n    toolChoice?: \"auto\" | \"none\" | \"required\" | {\n        type: \"function\";\n        function: {\n            name: string;\n        };\n    };\n    /**\n     * The tools to make available for this step.\n     */\n    tools: (ServerTool | ClientTool)[];\n    /**\n     * The current agent state (includes both middleware state and built-in state).\n     */\n    state: TState & AgentBuiltInState;\n    /**\n     * The runtime context containing metadata, signal, writer, interrupt, etc.\n     */\n    runtime: Runtime<TContext>;\n}\n"],"mappings":";;;;;;;;;AAWA;;;;;AAQcC,UARGK,YAQHL,CAAAA,eAR+BM,MAQ/BN,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GARyDM,MAQzDN,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA;EAAW;;;EA0BR,KAAGI,EA9BTL,iBA8BSK;EAAiB;;AAIjB;YA9BNJ;;;;;;;;;;;;;;;;;;;;;;UAsBFC,aAAaC;;;;SAIdK,SAASH;;;;WAIPD,QAAQK"}

package/dist/agents/nodes/types.d.ts

@@ -0,0 +1,57 @@
+import { ClientTool, ServerTool } from "../tools.js";
+import { AgentBuiltInState, Runtime } from "../runtime.js";
+import { BaseMessage } from "@langchain/core/messages";
+import { LanguageModelLike } from "@langchain/core/language_models/base";
+
+//#region src/agents/nodes/types.d.ts
+
+/**
+ * Configuration for modifying a model call at runtime.
+ * All fields are optional and only provided fields will override defaults.
+ *
+ * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.
+ * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.
+ */
+interface ModelRequest<TState extends Record<string, unknown> = Record<string, unknown>, TContext = unknown> {
+  /**
+   * The model to use for this step.
+   */
+  model: LanguageModelLike;
+  /**
+   * The messages to send to the model.
+   */
+  messages: BaseMessage[];
+  /**
+   * The system message for this step.
+   */
+  systemPrompt?: string;
+  /**
+   * Tool choice configuration (model-specific format).
+   * Can be one of:
+   * - `"auto"`: means the model can pick between generating a message or calling one or more tools.
+   * - `"none"`: means the model will not call any tool and instead generates a message.
+   * - `"required"`: means the model must call one or more tools.
+   * - `{ type: "function", function: { name: string } }`: The model will use the specified function.
+   */
+  toolChoice?: "auto" | "none" | "required" | {
+    type: "function";
+    function: {
+      name: string;
+    };
+  };
+  /**
+   * The tools to make available for this step.
+   */
+  tools: (ServerTool | ClientTool)[];
+  /**
+   * The current agent state (includes both middleware state and built-in state).
+   */
+  state: TState & AgentBuiltInState;
+  /**
+   * The runtime context containing metadata, signal, writer, interrupt, etc.
+   */
+  runtime: Runtime<TContext>;
+}
+//#endregion
+export { ModelRequest };
+//# sourceMappingURL=types.d.ts.map