langchain 1.0.0-alpha.6 → 1.0.0-alpha.7

package/dist/agents/interrupt.d.cts

@@ -1,4 +1,17 @@
 //#region src/agents/interrupt.d.ts
+/**
+ * Represents information about an interrupt.
+ */
+interface Interrupt<TValue = unknown> {
+  /**
+   * The ID of the interrupt.
+   */
+  id: string;
+  /**
+   * The requests for human input.
+   */
+  value: TValue;
+}
 /**
  * Configuration interface that defines what actions are allowed for a human interrupt.
  * This controls the available interaction options when the graph is paused for human input.
@@ -75,5 +88,5 @@ type HumanResponse = {
   args: null | string | ActionRequest;
 };
 //#endregion
-export { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse };
+export { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse, Interrupt };
 //# sourceMappingURL=interrupt.d.cts.map

package/dist/agents/interrupt.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"interrupt.d.cts","names":["interrupt","HumanInterruptConfig","ActionRequest","Record","HumanInterrupt","HumanResponse"],"sources":["../../src/agents/interrupt.d.ts"],"sourcesContent":["export { interrupt } from \"@langchain/langgraph\";\n/**\n * Configuration interface that defines what actions are allowed for a human interrupt.\n * This controls the available interaction options when the graph is paused for human input.\n */\nexport interface HumanInterruptConfig {\n    /**\n     * Whether the human can choose to ignore/skip the current step\n     */\n    allow_ignore: boolean;\n    /**\n     * Whether the human can provide a text response/feedback\n     */\n    allow_respond: boolean;\n    /**\n     * Whether the human can edit the provided content/state\n     */\n    allow_edit: boolean;\n    /**\n     * Whether the human can accept/approve the current state\n     */\n    allow_accept: boolean;\n}\n/**\n * Represents a request for human action within the graph execution.\n * Contains the action type and any associated arguments needed for the action.\n */\nexport interface ActionRequest {\n    /**\n     * The type or name of action being requested (e.g., \"Approve XYZ action\")\n     */\n    action: string;\n    /**\n     * Key-value pairs of arguments needed for the action\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    args: Record<string, any>;\n}\n/**\n * Represents an interrupt triggered by the graph that requires human intervention.\n * This is passed to the `interrupt` function when execution is paused for human input.\n */\nexport interface HumanInterrupt {\n    /**\n     * The specific action being requested from the human\n     */\n    action_request: ActionRequest;\n    /**\n     * Configuration defining what actions are allowed\n     */\n    config: HumanInterruptConfig;\n    /**\n     * Optional detailed description of what input is needed\n     */\n    description?: string;\n}\n/**\n * The response provided by a human to an interrupt, which is returned when graph execution resumes.\n */\nexport type HumanResponse = {\n    /**\n     * The type of response:\n     * - \"accept\": Approves the current state without changes\n     * - \"ignore\": Skips/ignores the current step\n     * - \"response\": Provides text feedback or instructions\n     * - \"edit\": Modifies the current state/content\n     */\n    type: \"accept\" | \"ignore\" | \"response\" | \"edit\";\n    /**\n     * The response payload:\n     * - null: For ignore/accept actions\n     * - string: For text responses\n     * - ActionRequest: For edit actions with updated content\n     */\n    args: null | string | ActionRequest;\n};\n"],"mappings":";AAKA;AAsBA;AAeA;;AAIoBE,UAzCHD,oBAAAA,CAyCGC;EAAa;AAID;AAShC;;;;;;;;;;;;;;;;;;;UAhCiBA,aAAAA;;;;;;;;;QASPC;;;;;;UAMOC,cAAAA;;;;kBAIGF;;;;UAIRD;;;;;;;;;KASAI,aAAAA;;;;;;;;;;;;;;;wBAecH"}
+{"version":3,"file":"interrupt.d.cts","names":["interrupt","Interrupt","TValue","HumanInterruptConfig","ActionRequest","Record","HumanInterrupt","HumanResponse"],"sources":["../../src/agents/interrupt.d.ts"],"sourcesContent":["export { interrupt } from \"@langchain/langgraph\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\n/**\n * Configuration interface that defines what actions are allowed for a human interrupt.\n * This controls the available interaction options when the graph is paused for human input.\n */\nexport interface HumanInterruptConfig {\n    /**\n     * Whether the human can choose to ignore/skip the current step\n     */\n    allow_ignore: boolean;\n    /**\n     * Whether the human can provide a text response/feedback\n     */\n    allow_respond: boolean;\n    /**\n     * Whether the human can edit the provided content/state\n     */\n    allow_edit: boolean;\n    /**\n     * Whether the human can accept/approve the current state\n     */\n    allow_accept: boolean;\n}\n/**\n * Represents a request for human action within the graph execution.\n * Contains the action type and any associated arguments needed for the action.\n */\nexport interface ActionRequest {\n    /**\n     * The type or name of action being requested (e.g., \"Approve XYZ action\")\n     */\n    action: string;\n    /**\n     * Key-value pairs of arguments needed for the action\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    args: Record<string, any>;\n}\n/**\n * Represents an interrupt triggered by the graph that requires human intervention.\n * This is passed to the `interrupt` function when execution is paused for human input.\n */\nexport interface HumanInterrupt {\n    /**\n     * The specific action being requested from the human\n     */\n    action_request: ActionRequest;\n    /**\n     * Configuration defining what actions are allowed\n     */\n    config: HumanInterruptConfig;\n    /**\n     * Optional detailed description of what input is needed\n     */\n    description?: string;\n}\n/**\n * The response provided by a human to an interrupt, which is returned when graph execution resumes.\n */\nexport type HumanResponse = {\n    /**\n     * The type of response:\n     * - \"accept\": Approves the current state without changes\n     * - \"ignore\": Skips/ignores the current step\n     * - \"response\": Provides text feedback or instructions\n     * - \"edit\": Modifies the current state/content\n     */\n    type: \"accept\" | \"ignore\" | \"response\" | \"edit\";\n    /**\n     * The response payload:\n     * - null: For ignore/accept actions\n     * - string: For text responses\n     * - ActionRequest: For edit actions with updated content\n     */\n    args: null | string | ActionRequest;\n};\n"],"mappings":";AAIA;AAcA;AAsBA;AAeiBM,UAnDAL,SAmDc,CAAA,SAAA,OAAA,CAAA,CAAA;EAAA;;;EAQC,EAAA,EAAA,MAAA;EASpBM;;;SA5DDL;;;;;;UAMMC,oBAAAA;;;;;;;;;;;;;;;;;;;;;;UAsBAC,aAAAA;;;;;;;;;QASPC;;;;;;UAMOC,cAAAA;;;;kBAIGF;;;;UAIRD;;;;;;;;;KASAI,aAAAA;;;;;;;;;;;;;;;wBAecH"}

package/dist/agents/interrupt.d.ts

@@ -2,6 +2,19 @@ import "@langchain/langgraph";
 
 //#region src/agents/interrupt.d.ts
 
+/**
+ * Represents information about an interrupt.
+ */
+interface Interrupt<TValue = unknown> {
+  /**
+   * The ID of the interrupt.
+   */
+  id: string;
+  /**
+   * The requests for human input.
+   */
+  value: TValue;
+}
 /**
  * Configuration interface that defines what actions are allowed for a human interrupt.
  * This controls the available interaction options when the graph is paused for human input.
@@ -78,5 +91,5 @@ type HumanResponse = {
   args: null | string | ActionRequest;
 };
 //#endregion
-export { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse };
+export { ActionRequest, HumanInterrupt, HumanInterruptConfig, HumanResponse, Interrupt };
 //# sourceMappingURL=interrupt.d.ts.map

package/dist/agents/interrupt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interrupt.d.ts","names":["interrupt","HumanInterruptConfig","ActionRequest","Record","HumanInterrupt","HumanResponse"],"sources":["../../src/agents/interrupt.d.ts"],"sourcesContent":["export { interrupt } from \"@langchain/langgraph\";\n/**\n * Configuration interface that defines what actions are allowed for a human interrupt.\n * This controls the available interaction options when the graph is paused for human input.\n */\nexport interface HumanInterruptConfig {\n    /**\n     * Whether the human can choose to ignore/skip the current step\n     */\n    allow_ignore: boolean;\n    /**\n     * Whether the human can provide a text response/feedback\n     */\n    allow_respond: boolean;\n    /**\n     * Whether the human can edit the provided content/state\n     */\n    allow_edit: boolean;\n    /**\n     * Whether the human can accept/approve the current state\n     */\n    allow_accept: boolean;\n}\n/**\n * Represents a request for human action within the graph execution.\n * Contains the action type and any associated arguments needed for the action.\n */\nexport interface ActionRequest {\n    /**\n     * The type or name of action being requested (e.g., \"Approve XYZ action\")\n     */\n    action: string;\n    /**\n     * Key-value pairs of arguments needed for the action\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    args: Record<string, any>;\n}\n/**\n * Represents an interrupt triggered by the graph that requires human intervention.\n * This is passed to the `interrupt` function when execution is paused for human input.\n */\nexport interface HumanInterrupt {\n    /**\n     * The specific action being requested from the human\n     */\n    action_request: ActionRequest;\n    /**\n     * Configuration defining what actions are allowed\n     */\n    config: HumanInterruptConfig;\n    /**\n     * Optional detailed description of what input is needed\n     */\n    description?: string;\n}\n/**\n * The response provided by a human to an interrupt, which is returned when graph execution resumes.\n */\nexport type HumanResponse = {\n    /**\n     * The type of response:\n     * - \"accept\": Approves the current state without changes\n     * - \"ignore\": Skips/ignores the current step\n     * - \"response\": Provides text feedback or instructions\n     * - \"edit\": Modifies the current state/content\n     */\n    type: \"accept\" | \"ignore\" | \"response\" | \"edit\";\n    /**\n     * The response payload:\n     * - null: For ignore/accept actions\n     * - string: For text responses\n     * - ActionRequest: For edit actions with updated content\n     */\n    args: null | string | ActionRequest;\n};\n"],"mappings":";;;;;;AAKA;AAsBA;AAeiBI,UArCAH,oBAAAA,CAqCc;EAAA;;;EAQC,YAAA,EAAA,OAAA;EASpBI;;;;;;;;;;;;;;;;;UAhCKH,aAAAA;;;;;;;;;QASPC;;;;;;UAMOC,cAAAA;;;;kBAIGF;;;;UAIRD;;;;;;;;;KASAI,aAAAA;;;;;;;;;;;;;;;wBAecH"}
+{"version":3,"file":"interrupt.d.ts","names":["interrupt","Interrupt","TValue","HumanInterruptConfig","ActionRequest","Record","HumanInterrupt","HumanResponse"],"sources":["../../src/agents/interrupt.d.ts"],"sourcesContent":["export { interrupt } from \"@langchain/langgraph\";\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\n/**\n * Configuration interface that defines what actions are allowed for a human interrupt.\n * This controls the available interaction options when the graph is paused for human input.\n */\nexport interface HumanInterruptConfig {\n    /**\n     * Whether the human can choose to ignore/skip the current step\n     */\n    allow_ignore: boolean;\n    /**\n     * Whether the human can provide a text response/feedback\n     */\n    allow_respond: boolean;\n    /**\n     * Whether the human can edit the provided content/state\n     */\n    allow_edit: boolean;\n    /**\n     * Whether the human can accept/approve the current state\n     */\n    allow_accept: boolean;\n}\n/**\n * Represents a request for human action within the graph execution.\n * Contains the action type and any associated arguments needed for the action.\n */\nexport interface ActionRequest {\n    /**\n     * The type or name of action being requested (e.g., \"Approve XYZ action\")\n     */\n    action: string;\n    /**\n     * Key-value pairs of arguments needed for the action\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    args: Record<string, any>;\n}\n/**\n * Represents an interrupt triggered by the graph that requires human intervention.\n * This is passed to the `interrupt` function when execution is paused for human input.\n */\nexport interface HumanInterrupt {\n    /**\n     * The specific action being requested from the human\n     */\n    action_request: ActionRequest;\n    /**\n     * Configuration defining what actions are allowed\n     */\n    config: HumanInterruptConfig;\n    /**\n     * Optional detailed description of what input is needed\n     */\n    description?: string;\n}\n/**\n * The response provided by a human to an interrupt, which is returned when graph execution resumes.\n */\nexport type HumanResponse = {\n    /**\n     * The type of response:\n     * - \"accept\": Approves the current state without changes\n     * - \"ignore\": Skips/ignores the current step\n     * - \"response\": Provides text feedback or instructions\n     * - \"edit\": Modifies the current state/content\n     */\n    type: \"accept\" | \"ignore\" | \"response\" | \"edit\";\n    /**\n     * The response payload:\n     * - null: For ignore/accept actions\n     * - string: For text responses\n     * - ActionRequest: For edit actions with updated content\n     */\n    args: null | string | ActionRequest;\n};\n"],"mappings":";;;;;;AAIA;AAciBG,UAdAF,SAcAE,CAAoB,SAAA,OAAA,CAAA,CAAA;EAsBpBC;AAejB;;EAA+B,EAAA,EAIXA,MAAAA;EAAa;AAID;AAShC;SA5DWF;;;;;;UAMMC,oBAAAA;;;;;;;;;;;;;;;;;;;;;;UAsBAC,aAAAA;;;;;;;;;QASPC;;;;;;UAMOC,cAAAA;;;;kBAIGF;;;;UAIRD;;;;;;;;;KASAI,aAAAA;;;;;;;;;;;;;;;wBAecH"}

package/dist/agents/middlewareAgent/ReactAgent.cjs

@@ -17,18 +17,10 @@ var ReactAgent = class {
 		this.options = options;
 		this.#toolBehaviorVersion = options.version ?? this.#toolBehaviorVersion;
 		/**
-		* Check if the LLM already has bound tools and throw if it does.
+		* define complete list of tools based on options and middleware
 		*/
-		if (options.llm && typeof options.llm !== "function") require_utils.validateLLMHasNoBoundTools(options.llm);
-		/**
-		* validate that model and llm options are not provided together
-		*/
-		if (options.llm && options.model) throw new Error("Cannot provide both `model` and `llm` options.");
-		/**
-		* validate that either model or llm option is provided
-		*/
-		if (!options.llm && !options.model) throw new Error("Either `model` or `llm` option must be provided to create an agent.");
-		const toolClasses = (Array.isArray(options.tools) ? options.tools : options.tools?.tools) ?? [];
+		const middlewareTools = this.options.middleware?.filter((m) => m.tools).flatMap((m) => m.tools) ?? [];
+		const toolClasses = [...(Array.isArray(options.tools) ? options.tools : options.tools?.tools) ?? [], ...middlewareTools];
 		/**
 		* If any of the tools are configured to return_directly after running,
 		* our graph needs to check if these were called
@@ -39,31 +31,36 @@ var ReactAgent = class {
 		const allNodeWorkflows = workflow;
 		const beforeModelNodes = [];
 		const afterModelNodes = [];
-		const prepareModelRequestHookMiddleware = [];
+		const modifyModelRequestHookMiddleware = [];
+		const middlewareNames = /* @__PURE__ */ new Set();
 		const middleware = this.options.middleware ?? [];
 		for (let i = 0; i < middleware.length; i++) {
 			let beforeModelNode;
 			let afterModelNode;
 			const m = middleware[i];
+			if (middlewareNames.has(m.name)) throw new Error(`Middleware ${m.name} is defined multiple times`);
+			middlewareNames.add(m.name);
 			if (m.beforeModel) {
 				beforeModelNode = new require_BeforeModalNode.BeforeModelNode(m);
-				const name = `before_model_${m.name}_${i}`;
+				const name = `${m.name}.before_model`;
 				beforeModelNodes.push({
 					index: i,
-					name
+					name,
+					allowed: m.beforeModelJumpTo
 				});
 				allNodeWorkflows.addNode(name, beforeModelNode, beforeModelNode.nodeOptions);
 			}
 			if (m.afterModel) {
 				afterModelNode = new require_AfterModalNode.AfterModelNode(m);
-				const name = `after_model_${m.name}_${i}`;
+				const name = `${m.name}.after_model`;
 				afterModelNodes.push({
 					index: i,
-					name
+					name,
+					allowed: m.afterModelJumpTo
 				});
 				allNodeWorkflows.addNode(name, afterModelNode, afterModelNode.nodeOptions);
 			}
-			if (m.prepareModelRequest) prepareModelRequestHookMiddleware.push([m, () => ({
+			if (m.modifyModelRequest) modifyModelRequestHookMiddleware.push([m, () => ({
 				...beforeModelNode?.getState(),
 				...afterModelNode?.getState()
 			})]);
@@ -72,9 +69,8 @@ var ReactAgent = class {
 		* Add Nodes
 		*/
 		allNodeWorkflows.addNode("model_request", new require_AgentNode.AgentNode({
-			llm: this.options.llm,
 			model: this.options.model,
-			prompt: this.options.prompt,
+			systemPrompt: this.options.systemPrompt,
 			includeAgentName: this.options.includeAgentName,
 			name: this.options.name,
 			responseFormat: this.options.responseFormat,
@@ -82,7 +78,7 @@ var ReactAgent = class {
 			toolClasses,
 			shouldReturnDirect,
 			signal: this.options.signal,
-			prepareModelRequestHookMiddleware
+			modifyModelRequestHookMiddleware
 		}), require_AgentNode.AgentNode.nodeOptions);
 		/**
 		* add single tool node for all tools
@@ -96,9 +92,18 @@ var ReactAgent = class {
 		*/
 		if (beforeModelNodes.length > 0) allNodeWorkflows.addEdge(__langchain_langgraph.START, beforeModelNodes[0].name);
 		else allNodeWorkflows.addEdge(__langchain_langgraph.START, "model_request");
-		for (let i = 0; i < beforeModelNodes.length - 1; i++) allNodeWorkflows.addEdge(beforeModelNodes[i].name, beforeModelNodes[i + 1].name);
-		const lastBeforeModelNode = beforeModelNodes.at(-1);
-		if (beforeModelNodes.length > 0 && lastBeforeModelNode) allNodeWorkflows.addEdge(lastBeforeModelNode.name, "model_request");
+		for (let i = 0; i < beforeModelNodes.length; i++) {
+			const node = beforeModelNodes[i];
+			const current = node.name;
+			const isLast = i === beforeModelNodes.length - 1;
+			const nextDefault = isLast ? "model_request" : beforeModelNodes[i + 1].name;
+			if (node.allowed && node.allowed.length > 0) {
+				const hasTools = toolClasses.filter(require_utils.isClientTool).length > 0;
+				const allowedMapped = node.allowed.map((t) => require_utils$1.parseJumpToTarget(t)).filter((dest) => dest !== "tools" || hasTools);
+				const destinations = Array.from(new Set([nextDefault, ...allowedMapped]));
+				allNodeWorkflows.addConditionalEdges(current, this.#createBeforeModelRouter(toolClasses.filter(require_utils.isClientTool), nextDefault), destinations);
+			} else allNodeWorkflows.addEdge(current, nextDefault);
+		}
 		const lastAfterModelNode = afterModelNodes.at(-1);
 		if (afterModelNodes.length > 0 && lastAfterModelNode) allNodeWorkflows.addEdge("model_request", lastAfterModelNode.name);
 		else {
@@ -106,12 +111,24 @@ var ReactAgent = class {
 			if (modelPaths.length === 1) allNodeWorkflows.addEdge("model_request", modelPaths[0]);
 			else allNodeWorkflows.addConditionalEdges("model_request", this.#createModelRouter(), modelPaths);
 		}
-		for (let i = afterModelNodes.length - 1; i > 0; i--) allNodeWorkflows.addEdge(afterModelNodes[i].name, afterModelNodes[i - 1].name);
+		for (let i = afterModelNodes.length - 1; i > 0; i--) {
+			const node = afterModelNodes[i];
+			const current = node.name;
+			const nextDefault = afterModelNodes[i - 1].name;
+			if (node.allowed && node.allowed.length > 0) {
+				const hasTools = toolClasses.filter(require_utils.isClientTool).length > 0;
+				const allowedMapped = node.allowed.map((t) => require_utils$1.parseJumpToTarget(t)).filter((dest) => dest !== "tools" || hasTools);
+				const destinations = Array.from(new Set([nextDefault, ...allowedMapped]));
+				allNodeWorkflows.addConditionalEdges(current, this.#createAfterModelSequenceRouter(toolClasses.filter(require_utils.isClientTool), node.allowed, nextDefault), destinations);
+			} else allNodeWorkflows.addEdge(current, nextDefault);
+		}
 		if (afterModelNodes.length > 0) {
-			const firstAfterModelNode = afterModelNodes[0].name;
-			const modelPaths = this.#getModelPaths(toolClasses.filter(require_utils.isClientTool));
-			if (modelPaths.length === 1) allNodeWorkflows.addEdge(firstAfterModelNode, modelPaths[0]);
-			else allNodeWorkflows.addConditionalEdges(firstAfterModelNode, this.#createModelRouter(), modelPaths);
+			const firstAfterModel = afterModelNodes[0];
+			const firstAfterModelNode = firstAfterModel.name;
+			const modelPaths = this.#getModelPaths(toolClasses.filter(require_utils.isClientTool), true).filter((p) => p !== "tools" || toolClasses.filter(require_utils.isClientTool).length > 0);
+			const allowJump = Boolean(firstAfterModel.allowed && firstAfterModel.allowed.length > 0);
+			const destinations = modelPaths;
+			allNodeWorkflows.addConditionalEdges(firstAfterModelNode, this.#createAfterModelRouter(toolClasses.filter(require_utils.isClientTool), allowJump), destinations);
 		}
 		/**
 		* add edges for tools node
@@ -128,15 +145,13 @@ var ReactAgent = class {
 		*/
 		this.#graph = allNodeWorkflows.compile({
 			checkpointer: this.options.checkpointer ?? this.options.checkpointSaver,
-			interruptBefore: this.options.interruptBefore,
-			interruptAfter: this.options.interruptAfter,
 			store: this.options.store,
 			name: this.options.name,
 			description: this.options.description
 		});
 	}
 	/**
-	* Get the compiled graph.
+	* Get the compiled {@link https://docs.langchain.com/oss/javascript/langgraph/use-graph-api | StateGraph}.
 	*/
 	get graph() {
 		return this.#graph;
@@ -144,79 +159,271 @@ var ReactAgent = class {
 	/**
 	* Get possible edge destinations from model node.
 	* @param toolClasses names of tools to call
+	* @param includeModelRequest whether to include "model_request" as a valid path (for jumpTo routing)
 	* @returns list of possible edge destinations
 	*/
-	#getModelPaths(toolClasses) {
+	#getModelPaths(toolClasses, includeModelRequest = false) {
 		const paths = [];
 		if (toolClasses.length > 0) paths.push("tools");
+		if (includeModelRequest) paths.push("model_request");
 		paths.push(__langchain_langgraph.END);
 		return paths;
 	}
 	/**
+	* Create routing function for tools node conditional edges.
+	*/
+	#createToolsRouter(shouldReturnDirect) {
+		/**
+		* ToDo: fix type
+		*/
+		return (state) => {
+			const messages = state.messages;
+			const lastMessage = messages[messages.length - 1];
+			if (__langchain_core_messages.ToolMessage.isInstance(lastMessage) && lastMessage.name && shouldReturnDirect.has(lastMessage.name)) return this.options.responseFormat ? "model_request" : __langchain_langgraph.END;
+			return "model_request";
+		};
+	}
+	/**
 	* Create routing function for model node conditional edges.
 	*/
 	#createModelRouter() {
 		/**
 		* determine if the agent should continue or not
 		*/
-		/**
-		* ToDo: fix type
-		*/
 		return (state) => {
 			const messages = state.messages;
 			const lastMessage = messages.at(-1);
 			if (!__langchain_core_messages.AIMessage.isInstance(lastMessage) || !lastMessage.tool_calls || lastMessage.tool_calls.length === 0) return __langchain_langgraph.END;
+			const hasOnlyStructuredResponseCalls = lastMessage.tool_calls.every((toolCall) => toolCall.name.startsWith("extract-"));
+			if (hasOnlyStructuredResponseCalls) return __langchain_langgraph.END;
 			/**
 			* The tool node processes a single message.
 			*/
 			if (this.#toolBehaviorVersion === "v1") return "tools";
 			/**
-			* Route to tools node
+			* Route to tools node (filter out any structured response tool calls)
 			*/
-			return lastMessage.tool_calls.map((toolCall) => new __langchain_langgraph.Send("tools", {
+			const regularToolCalls = lastMessage.tool_calls.filter((toolCall) => !toolCall.name.startsWith("extract-"));
+			if (regularToolCalls.length === 0) return __langchain_langgraph.END;
+			return regularToolCalls.map((toolCall) => new __langchain_langgraph.Send("tools", {
 				...state,
 				lg_tool_call: toolCall
 			}));
 		};
 	}
 	/**
-	* Create routing function for tools node conditional edges.
+	* Create routing function for jumpTo functionality after afterModel hooks.
+	*
+	* This router checks if the `jumpTo` property is set in the state after afterModel middleware
+	* execution. If set, it routes to the specified target ("model_request" or "tools").
+	* If not set, it falls back to the normal model routing logic for afterModel context.
+	*
+	* The jumpTo property is automatically cleared after use to prevent infinite loops.
+	*
+	* @param toolClasses - Available tool classes for validation
+	* @returns Router function that handles jumpTo logic and normal routing
 	*/
-	#createToolsRouter(shouldReturnDirect) {
-		/**
-		* ToDo: fix type
-		*/
+	#createAfterModelRouter(toolClasses, allowJump) {
+		const hasStructuredResponse = Boolean(this.options.responseFormat);
 		return (state) => {
 			const messages = state.messages;
-			const lastMessage = messages[messages.length - 1];
-			if (__langchain_core_messages.ToolMessage.isInstance(lastMessage) && lastMessage.name && shouldReturnDirect.has(lastMessage.name)) return this.options.responseFormat ? "model_request" : __langchain_langgraph.END;
-			return "model_request";
+			const lastMessage = messages.at(-1);
+			if (__langchain_core_messages.AIMessage.isInstance(lastMessage) && (!lastMessage.tool_calls || lastMessage.tool_calls.length === 0)) return __langchain_langgraph.END;
+			if (allowJump && state.jumpTo) {
+				if (state.jumpTo === __langchain_langgraph.END) return __langchain_langgraph.END;
+				if (state.jumpTo === "tools") {
+					if (toolClasses.length === 0) return __langchain_langgraph.END;
+					return new __langchain_langgraph.Send("tools", {
+						...state,
+						jumpTo: void 0
+					});
+				}
+				return new __langchain_langgraph.Send("model_request", {
+					...state,
+					jumpTo: void 0
+				});
+			}
+			const toolMessages = messages.filter(__langchain_core_messages.ToolMessage.isInstance);
+			const lastAiMessage = messages.filter(__langchain_core_messages.AIMessage.isInstance).at(-1);
+			const pendingToolCalls = lastAiMessage?.tool_calls?.filter((call) => !toolMessages.some((m) => m.tool_call_id === call.id));
+			if (pendingToolCalls && pendingToolCalls.length > 0) return pendingToolCalls.map((toolCall) => new __langchain_langgraph.Send("tools", {
+				...state,
+				lg_tool_call: toolCall
+			}));
+			const hasStructuredResponseCalls = lastAiMessage?.tool_calls?.some((toolCall) => toolCall.name.startsWith("extract-"));
+			if (pendingToolCalls && pendingToolCalls.length === 0 && !hasStructuredResponseCalls && hasStructuredResponse) return "model_request";
+			if (!__langchain_core_messages.AIMessage.isInstance(lastMessage) || !lastMessage.tool_calls || lastMessage.tool_calls.length === 0) return __langchain_langgraph.END;
+			const hasOnlyStructuredResponseCalls = lastMessage.tool_calls.every((toolCall) => toolCall.name.startsWith("extract-"));
+			const hasRegularToolCalls = lastMessage.tool_calls.some((toolCall) => !toolCall.name.startsWith("extract-"));
+			if (hasOnlyStructuredResponseCalls || !hasRegularToolCalls) return __langchain_langgraph.END;
+			/**
+			* For routing from afterModel nodes, always use simple string paths
+			* The Send API is handled at the model_request node level
+			*/
+			return "tools";
+		};
+	}
+	/**
+	* Router for afterModel sequence nodes (connecting later middlewares to earlier ones),
+	* honoring allowed jump targets and defaulting to the next node.
+	*/
+	#createAfterModelSequenceRouter(toolClasses, allowed, nextDefault) {
+		const allowedSet = new Set(allowed.map((t) => require_utils$1.parseJumpToTarget(t)));
+		return (state) => {
+			if (state.jumpTo) {
+				const dest = require_utils$1.parseJumpToTarget(state.jumpTo);
+				if (dest === __langchain_langgraph.END && allowedSet.has(__langchain_langgraph.END)) return __langchain_langgraph.END;
+				if (dest === "tools" && allowedSet.has("tools")) {
+					if (toolClasses.length === 0) return __langchain_langgraph.END;
+					return new __langchain_langgraph.Send("tools", {
+						...state,
+						jumpTo: void 0
+					});
+				}
+				if (dest === "model_request" && allowedSet.has("model_request")) return new __langchain_langgraph.Send("model_request", {
+					...state,
+					jumpTo: void 0
+				});
+			}
+			return nextDefault;
+		};
+	}
+	/**
+	* Create routing function for jumpTo functionality after beforeModel hooks.
+	* Falls back to the default next node if no jumpTo is present.
+	*/
+	#createBeforeModelRouter(toolClasses, nextDefault) {
+		return (state) => {
+			if (!state.jumpTo) return nextDefault;
+			const destination = require_utils$1.parseJumpToTarget(state.jumpTo);
+			if (destination === __langchain_langgraph.END) return __langchain_langgraph.END;
+			if (destination === "tools") {
+				if (toolClasses.length === 0) return __langchain_langgraph.END;
+				return new __langchain_langgraph.Send("tools", {
+					...state,
+					jumpTo: void 0
+				});
+			}
+			return new __langchain_langgraph.Send("model_request", {
+				...state,
+				jumpTo: void 0
+			});
 		};
 	}
 	/**
 	* Initialize middleware states if not already present in the input state.
 	*/
-	#initializeMiddlewareStates(state) {
+	async #initializeMiddlewareStates(state) {
 		if (!this.options.middleware || this.options.middleware.length === 0 || state instanceof __langchain_langgraph.Command || !state) return state;
-		const defaultStates = require_utils$1.initializeMiddlewareStates(this.options.middleware, state);
+		const defaultStates = await require_utils$1.initializeMiddlewareStates(this.options.middleware, state);
 		const updatedState = { ...state };
 		if (!updatedState) return updatedState;
 		for (const [key, value] of Object.entries(defaultStates)) if (!(key in updatedState)) updatedState[key] = value;
 		return updatedState;
 	}
 	/**
-	* @inheritdoc
+	* Executes the agent with the given state and returns the final state after all processing.
+	*
+	* This method runs the agent's entire workflow synchronously, including:
+	* - Processing the input messages through any configured middleware
+	* - Calling the language model to generate responses
+	* - Executing any tool calls made by the model
+	* - Running all middleware hooks (beforeModel, afterModel, etc.)
+	*
+	* @param state - The initial state for the agent execution. Can be:
+	*   - An object containing `messages` array and any middleware-specific state properties
+	*   - A Command object for more advanced control flow
+	*
+	* @param config - Optional runtime configuration including:
+	* @param config.context - The context for the agent execution.
+	* @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.
+	* @param config.store - The store for the agent execution for persisting state, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Memory storage}.
+	* @param config.signal - An optional {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} for the agent execution.
+	* @param config.recursionLimit - The recursion limit for the agent execution.
+	*
+	* @returns A Promise that resolves to the final agent state after execution completes.
+	*          The returned state includes:
+	*          - a `messages` property containing an array with all messages (input, AI responses, tool calls/results)
+	*          - a `structuredResponse` property containing the structured response (if configured)
+	*          - all state values defined in the middleware
+	*
+	* @example
+	* ```typescript
+	* const agent = new ReactAgent({
+	*   llm: myModel,
+	*   tools: [calculator, webSearch],
+	*   responseFormat: z.object({
+	*     weather: z.string(),
+	*   }),
+	* });
+	*
+	* const result = await agent.invoke({
+	*   messages: [{ role: "human", content: "What's the weather in Paris?" }]
+	* });
+	*
+	* console.log(result.structuredResponse.weather); // outputs: "It's sunny and 75°F."
+	* ```
 	*/
-	get invoke() {
-		const invokeFunc = async (state, config) => {
-			const initializedState = this.#initializeMiddlewareStates(state);
-			return this.#graph.invoke(initializedState, config);
-		};
-		return invokeFunc;
+	async invoke(state, config) {
+		const initializedState = await this.#initializeMiddlewareStates(state);
+		return this.#graph.invoke(initializedState, config);
 	}
 	/**
-	* ToDo(@christian-bromann): Add stream and streamEvents methods
+	* Executes the agent with streaming, returning an async iterable of events as they occur.
+	*
+	* This method runs the agent's workflow similar to `invoke`, but instead of waiting for
+	* completion, it streams events in real-time. This allows you to:
+	* - Display intermediate results to users as they're generated
+	* - Monitor the agent's progress through each step
+	* - Handle tool calls and results as they happen
+	* - Update UI with streaming responses from the LLM
+	*
+	* @param state - The initial state for the agent execution. Can be:
+	*   - An object containing `messages` array and any middleware-specific state properties
+	*   - A Command object for more advanced control flow
+	*
+	* @param config - Optional runtime configuration including:
+	* @param config.context - The context for the agent execution.
+	* @param config.configurable - LangGraph configuration options like `thread_id`, `run_id`, etc.
+	* @param config.store - The store for the agent execution for persisting state, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/memory#memory-storage | Memory storage}.
+	* @param config.signal - An optional {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} for the agent execution.
+	* @param config.streamMode - The streaming mode for the agent execution, see more in {@link https://docs.langchain.com/oss/javascript/langgraph/streaming#supported-stream-modes | Supported stream modes}.
+	* @param config.recursionLimit - The recursion limit for the agent execution.
+	*
+	* @returns A Promise that resolves to an IterableReadableStream of events.
+	*          Events include:
+	*          - `on_chat_model_start`: When the LLM begins processing
+	*          - `on_chat_model_stream`: Streaming tokens from the LLM
+	*          - `on_chat_model_end`: When the LLM completes
+	*          - `on_tool_start`: When a tool execution begins
+	*          - `on_tool_end`: When a tool execution completes
+	*          - `on_chain_start`: When middleware chains begin
+	*          - `on_chain_end`: When middleware chains complete
+	*          - And other LangGraph v2 stream events
+	*
+	* @example
+	* ```typescript
+	* const agent = new ReactAgent({
+	*   llm: myModel,
+	*   tools: [calculator, webSearch]
+	* });
+	*
+	* const stream = await agent.stream({
+	*   messages: [{ role: "human", content: "What's 2+2 and the weather in NYC?" }]
+	* });
+	*
+	* for await (const event of stream) {
+	*   //
+	* }
+	* ```
 	*/
+	async stream(state, config) {
+		const initializedState = await this.#initializeMiddlewareStates(state);
+		return this.#graph.streamEvents(initializedState, {
+			...config,
+			version: "v2"
+		});
+	}
 	/**
 	* Visualize the graph as a PNG image.
 	* @param params - Parameters for the drawMermaidPng method.