langchain 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/agents/nodes/AfterAgentNode.cjs

@@ -0,0 +1,27 @@
+const require_middleware = require('./middleware.cjs');
+
+//#region src/agents/nodes/AfterAgentNode.ts
+/**
+* Node for executing a single middleware's afterAgent hook.
+*/
+var AfterAgentNode = class extends require_middleware.MiddlewareNode {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"afterAgentNodes"
+	];
+	constructor(middleware, options) {
+		super({
+			name: `AfterAgentNode_${middleware.name}`,
+			func: async (state, config) => this.invokeMiddleware(state, config)
+		}, options);
+		this.middleware = middleware;
+	}
+	runHook(state, runtime) {
+		return this.middleware.afterAgent(state, runtime);
+	}
+};
+
+//#endregion
+exports.AfterAgentNode = AfterAgentNode;
+//# sourceMappingURL=AfterAgentNode.cjs.map

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

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

package/dist/agents/nodes/AfterAgentNode.js

@@ -0,0 +1,27 @@
+import { MiddlewareNode } from "./middleware.js";
+
+//#region src/agents/nodes/AfterAgentNode.ts
+/**
+* Node for executing a single middleware's afterAgent hook.
+*/
+var AfterAgentNode = class extends MiddlewareNode {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"afterAgentNodes"
+	];
+	constructor(middleware, options) {
+		super({
+			name: `AfterAgentNode_${middleware.name}`,
+			func: async (state, config) => this.invokeMiddleware(state, config)
+		}, options);
+		this.middleware = middleware;
+	}
+	runHook(state, runtime) {
+		return this.middleware.afterAgent(state, runtime);
+	}
+};
+
+//#endregion
+export { AfterAgentNode };
+//# sourceMappingURL=AfterAgentNode.js.map

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

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

package/dist/agents/nodes/AfterModelNode.cjs

@@ -0,0 +1,27 @@
+const require_middleware = require('./middleware.cjs');
+
+//#region src/agents/nodes/AfterModelNode.ts
+/**
+* Node for executing a single middleware's afterModel hook.
+*/
+var AfterModelNode = class extends require_middleware.MiddlewareNode {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"afterModelNodes"
+	];
+	constructor(middleware, options) {
+		super({
+			name: `AfterModelNode_${middleware.name}`,
+			func: async (state, config) => this.invokeMiddleware(state, config)
+		}, options);
+		this.middleware = middleware;
+	}
+	runHook(state, runtime) {
+		return this.middleware.afterModel(state, runtime);
+	}
+};
+
+//#endregion
+exports.AfterModelNode = AfterModelNode;
+//# sourceMappingURL=AfterModelNode.cjs.map

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

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

package/dist/agents/nodes/AfterModelNode.js

@@ -0,0 +1,27 @@
+import { MiddlewareNode } from "./middleware.js";
+
+//#region src/agents/nodes/AfterModelNode.ts
+/**
+* Node for executing a single middleware's afterModel hook.
+*/
+var AfterModelNode = class extends MiddlewareNode {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"afterModelNodes"
+	];
+	constructor(middleware, options) {
+		super({
+			name: `AfterModelNode_${middleware.name}`,
+			func: async (state, config) => this.invokeMiddleware(state, config)
+		}, options);
+		this.middleware = middleware;
+	}
+	runHook(state, runtime) {
+		return this.middleware.afterModel(state, runtime);
+	}
+};
+
+//#endregion
+export { AfterModelNode };
+//# sourceMappingURL=AfterModelNode.js.map

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

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

package/dist/agents/nodes/AgentNode.cjs

@@ -8,11 +8,13 @@ const require_withAgentName = require('../withAgentName.cjs');
 const require_responses = require('../responses.cjs');
 const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
 const __langchain_langgraph = require_rolldown_runtime.__toESM(require("@langchain/langgraph"));
+const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
 const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
 
 //#region src/agents/nodes/AgentNode.ts
 var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 	#options;
+	#runState = { runModelCallCount: 0 };
 	constructor(options) {
 		super({
 			name: options.name ?? "model",
@@ -59,19 +61,29 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 		* Check if we just executed a returnDirect tool
 		* If so, we should generate structured response (if needed) and stop
 		*/
-		const lastMessage = state.messages[state.messages.length - 1];
-		if (__langchain_core_messages.ToolMessage.isInstance(lastMessage) && lastMessage.name && this.#options.shouldReturnDirect.has(lastMessage.name))
+		const lastMessage = state.messages.at(-1);
+		if (lastMessage && __langchain_core_messages.ToolMessage.isInstance(lastMessage) && lastMessage.name && this.#options.shouldReturnDirect.has(lastMessage.name))
  /**
 		* return directly without invoking the model again
 		*/
-		return { messages: [] };
+		return {
+			messages: [],
+			_privateState: this.getState()._privateState
+		};
+		const privateState = this.getState()._privateState;
 		const response = await this.#invokeModel(state, config);
+		this.#runState.runModelCallCount++;
+		const _privateState = {
+			...privateState,
+			threadLevelCallCount: privateState.threadLevelCallCount + 1
+		};
 		/**
 		* if we were able to generate a structured response, return it
 		*/
 		if ("structuredResponse" in response) return {
 			messages: [...state.messages, ...response.messages || []],
-			structuredResponse: response.structuredResponse
+			structuredResponse: response.structuredResponse,
+			_privateState
 		};
 		/**
 		* if we need to direct the agent to the model, return the update
@@ -79,12 +91,18 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 		if (response instanceof __langchain_langgraph.Command) return response;
 		response.name = this.name;
 		response.lc_kwargs.name = this.name;
-		if (this.#areMoreStepsNeeded(state, response)) return { messages: [new __langchain_core_messages.AIMessage({
-			content: "Sorry, need more steps to process this request.",
-			name: this.name,
-			id: response.id
-		})] };
-		return { messages: [response] };
+		if (this.#areMoreStepsNeeded(state, response)) return {
+			messages: [new __langchain_core_messages.AIMessage({
+				content: "Sorry, need more steps to process this request.",
+				name: this.name,
+				id: response.id
+			})],
+			_privateState
+		};
+		return {
+			messages: [response],
+			_privateState
+		};
 	}
 	/**
 	* Derive the model from the options.
@@ -92,60 +110,152 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 	* @param config - The config of the agent.
 	* @returns The model.
 	*/
-	#deriveModel(state, config) {
-		if (this.#options.model) {
-			if (typeof this.#options.model === "string") return require_chat_models_universal.initChatModel(this.#options.model);
-			throw new Error("`model` option must be a string.");
-		}
-		const model = this.#options.llm;
-		/**
-		* If the model is a function, call it to get the model.
-		*/
-		if (typeof model === "function") return model(state, config);
-		if (model) return model;
-		throw new Error("No model option was provided, either via `model` or via `llm` option.");
+	#deriveModel() {
+		if (typeof this.#options.model === "string") return require_chat_models_universal.initChatModel(this.#options.model);
+		if (this.#options.model) return this.#options.model;
+		throw new Error("No model option was provided, either via `model` option.");
 	}
 	async #invokeModel(state, config, options = {}) {
-		const model = await this.#deriveModel(state, config);
+		const model = await this.#deriveModel();
+		const lgConfig = config;
 		/**
-		* Check if the LLM already has bound tools and throw if it does.
+		* Create the base handler that performs the actual model invocation
 		*/
-		require_utils.validateLLMHasNoBoundTools(model);
-		const structuredResponseFormat = this.#getResponseFormat(model);
-		const modelWithTools = await this.#bindTools(model, structuredResponseFormat);
-		const modelInput = this.#getModelInputState(state);
-		const signal = require_utils$1.mergeAbortSignals(this.#options.signal, config.signal);
-		const invokeConfig = {
-			...config,
-			signal
+		const baseHandler = async (request) => {
+			/**
+			* Check if the LLM already has bound tools and throw if it does.
+			*/
+			require_utils.validateLLMHasNoBoundTools(request.model);
+			const structuredResponseFormat = this.#getResponseFormat(request.model);
+			const modelWithTools = await this.#bindTools(request.model, request, structuredResponseFormat);
+			let modelInput = this.#getModelInputState(state);
+			modelInput = {
+				...modelInput,
+				messages: request.messages
+			};
+			const signal = require_utils$1.mergeAbortSignals(this.#options.signal, config.signal);
+			const invokeConfig = {
+				...config,
+				signal
+			};
+			const response = await modelWithTools.invoke(modelInput, invokeConfig);
+			/**
+			* if the user requests a native schema output, try to parse the response
+			* and return the structured response if it is valid
+			*/
+			if (structuredResponseFormat?.type === "native") {
+				const structuredResponse = structuredResponseFormat.strategy.parse(response);
+				if (structuredResponse) return {
+					structuredResponse,
+					messages: [response]
+				};
+				return response;
+			}
+			if (!structuredResponseFormat || !response.tool_calls) return response;
+			const toolCalls = response.tool_calls.filter((call) => call.name in structuredResponseFormat.tools);
+			/**
+			* if there were not structured tool calls, we can return the response
+			*/
+			if (toolCalls.length === 0) return response;
+			/**
+			* if there were multiple structured tool calls, we should throw an error as this
+			* scenario is not defined/supported.
+			*/
+			if (toolCalls.length > 1) return this.#handleMultipleStructuredOutputs(response, toolCalls, structuredResponseFormat);
+			const toolStrategy = structuredResponseFormat.tools[toolCalls[0].name];
+			const toolMessageContent = toolStrategy?.options?.toolMessageContent;
+			return this.#handleSingleStructuredOutput(response, toolCalls[0], structuredResponseFormat, toolMessageContent ?? options.lastMessage);
 		};
-		const response = await modelWithTools.invoke(modelInput, invokeConfig);
+		const wrapperMiddleware = this.#options.wrapModelCallHookMiddleware ?? [];
+		let wrappedHandler = baseHandler;
 		/**
-		* if the user requests a native schema output, try to parse the response
-		* and return the structured response if it is valid
+		* Build composed handler from last to first so first middleware becomes outermost
 		*/
-		if (structuredResponseFormat?.type === "native") {
-			const structuredResponse = structuredResponseFormat.strategy.parse(response);
-			if (structuredResponse) return {
-				structuredResponse,
-				messages: [response]
-			};
-			return response;
+		for (let i = wrapperMiddleware.length - 1; i >= 0; i--) {
+			const [middleware, getMiddlewareState] = wrapperMiddleware[i];
+			if (middleware.wrapModelCall) {
+				const innerHandler = wrappedHandler;
+				const currentMiddleware = middleware;
+				const currentGetState = getMiddlewareState;
+				wrappedHandler = async (request) => {
+					/**
+					* Merge context with default context of middleware
+					*/
+					const context = currentMiddleware.contextSchema ? (0, __langchain_core_utils_types.interopParse)(currentMiddleware.contextSchema, lgConfig?.context || {}) : lgConfig?.context;
+					/**
+					* Create runtime
+					*/
+					const privateState = this.getState()._privateState;
+					const runtime = Object.freeze({
+						...privateState,
+						context,
+						writer: lgConfig.writer,
+						interrupt: lgConfig.interrupt,
+						signal: lgConfig.signal
+					});
+					/**
+					* Create the request with state and runtime
+					*/
+					const requestWithStateAndRuntime = {
+						...request,
+						state: {
+							...currentGetState(),
+							messages: state.messages
+						},
+						runtime
+					};
+					/**
+					* Create handler that validates tools and calls the inner handler
+					*/
+					const handlerWithValidation = async (req) => {
+						/**
+						* Verify that the user didn't add any new tools.
+						* We can't allow this as the ToolNode is already initiated with given tools.
+						*/
+						const modifiedTools = req.tools ?? [];
+						const newTools = modifiedTools.filter((tool) => require_utils.isClientTool(tool) && !this.#options.toolClasses.some((t) => t.name === tool.name));
+						if (newTools.length > 0) throw new Error(`You have added a new tool in "wrapModelCall" hook of middleware "${currentMiddleware.name}": ${newTools.map((tool) => tool.name).join(", ")}. This is not supported.`);
+						/**
+						* Verify that user has not added or modified a tool with the same name.
+						* We can't allow this as the ToolNode is already initiated with given tools.
+						*/
+						const invalidTools = modifiedTools.filter((tool) => require_utils.isClientTool(tool) && this.#options.toolClasses.every((t) => t !== tool));
+						if (invalidTools.length > 0) throw new Error(`You have modified a tool in "wrapModelCall" hook of middleware "${currentMiddleware.name}": ${invalidTools.map((tool) => tool.name).join(", ")}. This is not supported.`);
+						return innerHandler(req);
+					};
+					if (!currentMiddleware.wrapModelCall) return handlerWithValidation(requestWithStateAndRuntime);
+					try {
+						const middlewareResponse = await currentMiddleware.wrapModelCall(requestWithStateAndRuntime, handlerWithValidation);
+						/**
+						* Validate that this specific middleware returned a valid AIMessage
+						*/
+						if (!__langchain_core_messages.AIMessage.isInstance(middlewareResponse)) throw new Error(`Invalid response from "wrapModelCall" in middleware "${currentMiddleware.name}": expected AIMessage, got ${typeof middlewareResponse}`);
+						return middlewareResponse;
+					} catch (error) {
+						if (error instanceof Error && !error.message.includes(`middleware "${currentMiddleware.name}"`)) error.message = `Error in middleware "${currentMiddleware.name}": ${error.message}`;
+						throw error;
+					}
+				};
+			}
 		}
-		if (!structuredResponseFormat || !response.tool_calls) return response;
-		const toolCalls = response.tool_calls.filter((call) => call.name in structuredResponseFormat.tools);
-		/**
-		* if there were not structured tool calls, we can return the response
-		*/
-		if (toolCalls.length === 0) return response;
 		/**
-		* if there were multiple structured tool calls, we should throw an error as this
-		* scenario is not defined/supported.
+		* Execute the wrapped handler with the initial request
 		*/
-		if (toolCalls.length > 1) return this.#handleMultipleStructuredOutputs(response, toolCalls, structuredResponseFormat);
-		const toolStrategy = structuredResponseFormat.tools[toolCalls[0].name];
-		const toolMessageContent = toolStrategy?.options?.toolMessageContent;
-		return this.#handleSingleStructuredOutput(response, toolCalls[0], structuredResponseFormat, toolMessageContent ?? options.lastMessage);
+		const initialRequest = {
+			model,
+			systemPrompt: this.#options.systemPrompt,
+			messages: state.messages,
+			tools: this.#options.toolClasses,
+			state: { messages: state.messages },
+			runtime: Object.freeze({
+				...this.getState()._privateState,
+				context: lgConfig?.context,
+				writer: lgConfig.writer,
+				interrupt: lgConfig.interrupt,
+				signal: lgConfig.signal
+			})
+		};
+		return wrappedHandler(initialRequest);
 	}
 	/**
 	* If the model returns multiple structured outputs, we need to handle it.
@@ -153,21 +263,17 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 	* @param toolCalls - The tool calls that were made
 	* @returns The response from the model
 	*/
-	#handleMultipleStructuredOutputs(response, toolCalls, structuredResponseFormat) {
-		/**
-		* the following should never happen, let's throw an error if it does
-		*/
-		if (this.#options.responseFormat instanceof require_responses.ProviderStrategy) throw new Error("Multiple structured outputs should not apply to native structured output responses");
+	#handleMultipleStructuredOutputs(response, toolCalls, responseFormat) {
 		const multipleStructuredOutputsError = new require_errors.MultipleStructuredOutputsError(toolCalls.map((call) => call.name));
-		return this.#handleToolStrategyError(multipleStructuredOutputsError, response, toolCalls[0], structuredResponseFormat);
+		return this.#handleToolStrategyError(multipleStructuredOutputsError, response, toolCalls[0], responseFormat);
 	}
 	/**
 	* If the model returns a single structured output, we need to handle it.
 	* @param toolCall - The tool call that was made
 	* @returns The structured response and a message to the LLM if needed
 	*/
-	#handleSingleStructuredOutput(response, toolCall, structuredResponseFormat, lastMessage) {
-		const tool = structuredResponseFormat.tools[toolCall.name];
+	#handleSingleStructuredOutput(response, toolCall, responseFormat, lastMessage) {
+		const tool = responseFormat.tools[toolCall.name];
 		try {
 			const structuredResponse = tool.parse(toolCall.args);
 			return {
@@ -175,10 +281,10 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 				messages: [response, new __langchain_core_messages.AIMessage(lastMessage ?? `Returning structured response: ${JSON.stringify(structuredResponse)}`)]
 			};
 		} catch (error) {
-			return this.#handleToolStrategyError(error, response, toolCall, structuredResponseFormat);
+			return this.#handleToolStrategyError(error, response, toolCall, responseFormat);
 		}
 	}
-	async #handleToolStrategyError(error, response, toolCall, structuredResponseFormat) {
+	async #handleToolStrategyError(error, response, toolCall, responseFormat) {
 		/**
 		* Using the `errorHandler` option of the first `ToolStrategy` entry is sufficient here.
 		* There is technically only one `ToolStrategy` entry in `structuredToolInfo` if the user
@@ -186,7 +292,7 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 		* schema objects, these will be transformed into multiple `ToolStrategy` entries but all
 		* with the same `handleError` option.
 		*/
-		const errorHandler = Object.values(structuredResponseFormat.tools).at(0)?.options?.handleError;
+		const errorHandler = Object.values(responseFormat.tools).at(0)?.options?.handleError;
 		const toolCallId = toolCall.id;
 		if (!toolCallId) throw new Error("Tool call ID is required to handle tool output errors. Please provide a tool call ID.");
 		/**
@@ -231,7 +337,7 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 	#areMoreStepsNeeded(state, response) {
 		const allToolsReturnDirect = __langchain_core_messages.AIMessage.isInstance(response) && response.tool_calls?.every((call) => this.#options.shouldReturnDirect.has(call.name));
 		const remainingSteps = "remainingSteps" in state ? state.remainingSteps : void 0;
-		return Boolean(remainingSteps && (remainingSteps < 1 && allToolsReturnDirect || remainingSteps < 2 && require_utils.hasToolCalls(state.messages)));
+		return Boolean(remainingSteps && (remainingSteps < 1 && allToolsReturnDirect || remainingSteps < 2 && require_utils.hasToolCalls(state.messages.at(-1))));
 	}
 	#getModelInputState(state) {
 		const { messages, llmInputMessages,...rest } = state;
@@ -244,15 +350,18 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 			...rest
 		};
 	}
-	async #bindTools(model, structuredResponseFormat) {
+	async #bindTools(model, preparedOptions, structuredResponseFormat) {
 		const options = {};
-		const structuredTools = structuredResponseFormat?.type === "tool" ? Object.values(structuredResponseFormat.tools) : [];
-		const allTools = this.#options.toolClasses.concat(...structuredTools.map((toolStrategy) => toolStrategy.tool));
+		const structuredTools = Object.values(structuredResponseFormat && "tools" in structuredResponseFormat ? structuredResponseFormat.tools : {});
+		/**
+		* Use tools from preparedOptions if provided, otherwise use default tools
+		*/
+		const allTools = [...preparedOptions?.tools ?? this.#options.toolClasses, ...structuredTools.map((toolStrategy) => toolStrategy.tool)];
 		/**
 		* If there are structured tools, we need to set the tool choice to "any"
 		* so that the model can choose to use a structured tool or not.
 		*/
-		const toolChoice = structuredTools.length > 0 ? "any" : void 0;
+		const toolChoice = preparedOptions?.toolChoice || (structuredTools.length > 0 ? "any" : void 0);
 		/**
 		* check if the user requests a native schema output
 		*/
@@ -289,9 +398,31 @@ var AgentNode = class extends require_RunnableCallable.RunnableCallable {
 		/**
 		* Create a model runnable with the prompt and agent name
 		*/
-		const modelRunnable = require_utils.getPromptRunnable(this.#options.prompt).pipe(this.#options.includeAgentName === "inline" ? require_withAgentName.withAgentName(modelWithTools, this.#options.includeAgentName) : modelWithTools);
+		const modelRunnable = require_utils.getPromptRunnable(preparedOptions?.systemPrompt ?? this.#options.systemPrompt).pipe(this.#options.includeAgentName === "inline" ? require_withAgentName.withAgentName(modelWithTools, this.#options.includeAgentName) : modelWithTools);
 		return modelRunnable;
 	}
+	static get nodeOptions() {
+		return { input: zod_v3.z.object({
+			messages: zod_v3.z.array(zod_v3.z.custom()),
+			_privateState: zod_v3.z.object({ threadLevelCallCount: zod_v3.z.number() })
+		}) };
+	}
+	getState() {
+		const state = super.getState();
+		const origState = state && !(state instanceof __langchain_langgraph.Command) ? state : { _privateState: {
+			threadLevelCallCount: 0,
+			runModelCallCount: 0
+		} };
+		return {
+			messages: [],
+			...origState,
+			_privateState: {
+				threadLevelCallCount: 0,
+				...origState._privateState ?? {},
+				...this.#runState
+			}
+		};
+	}
 };
 
 //#endregion