langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.cts

@@ -0,0 +1,46 @@
+import { AgentBuiltInState, AgentMiddleware, Runtime } from "../types.cjs";
+
+//#region src/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts
+type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<TContextSchema>) => string | Promise<string>;
+/**
+ * Dynamic System Prompt Middleware
+ *
+ * Allows setting the system prompt dynamically right before each model invocation.
+ * Useful when the prompt depends on the current agent state or per-invocation context.
+ *
+ * @typeParam TContextSchema - The shape of the runtime context available at invocation time.
+ * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety
+ * for `runtime.context`.
+ *
+ * @param fn - Function that receives the current agent `state` and `runtime`, and
+ * returns the system prompt for the next model call as a string.
+ *
+ * @returns A middleware instance that sets `systemPrompt` for the next model call.
+ *
+ * @example Basic usage with typed context
+ * ```ts
+ * import { z } from "zod";
+ * import { dynamicSystemPrompt } from "langchain";
+ * import { createAgent, SystemMessage } from "langchain";
+ *
+ * const contextSchema = z.object({ region: z.string().optional() });
+ *
+ * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(
+ *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? "n/a"}`
+ * );
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   contextSchema,
+ *   middleware: [middleware],
+ * });
+ *
+ * await agent.invoke({ messages }, { context: { region: "EU" } });
+ * ```
+ *
+ * @public
+ */
+declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): AgentMiddleware<undefined, undefined, any>;
+//#endregion
+export { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware };
+//# sourceMappingURL=dynamicSystemPrompt.d.cts.map

package/dist/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicSystemPrompt.d.cts","names":["Runtime","AgentBuiltInState","DynamicSystemPromptMiddlewareConfig","TContextSchema","Promise","dynamicSystemPromptMiddleware","__index_js0","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts"],"sourcesContent":["import type { Runtime, AgentBuiltInState } from \"../types.js\";\nexport type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<TContextSchema>) => string | Promise<string>;\n/**\n * Dynamic System Prompt Middleware\n *\n * Allows setting the system prompt dynamically right before each model invocation.\n * Useful when the prompt depends on the current agent state or per-invocation context.\n *\n * @typeParam TContextSchema - The shape of the runtime context available at invocation time.\n * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety\n * for `runtime.context`.\n *\n * @param fn - Function that receives the current agent `state` and `runtime`, and\n * returns the system prompt for the next model call as a string.\n *\n * @returns A middleware instance that sets `systemPrompt` for the next model call.\n *\n * @example Basic usage with typed context\n * ```ts\n * import { z } from \"zod\";\n * import { dynamicSystemPrompt } from \"langchain\";\n * import { createAgent, SystemMessage } from \"langchain\";\n *\n * const contextSchema = z.object({ region: z.string().optional() });\n *\n * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(\n *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? \"n/a\"}`\n * );\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   contextSchema,\n *   middleware: [middleware],\n * });\n *\n * await agent.invoke({ messages }, { context: { region: \"EU\" } });\n * ```\n *\n * @public\n */\nexport declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): import(\"./index.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;KACYE,8DAA8DD,4BAA4BD,QAAQG,6BAA6BC;;AAA3I;;;;;;AAAkJ;AAuClJ;;;;;AAA8K;;;;;;;;;;;;;;;;;;;;;;;;;iBAAtJC,4DAA4DH,oCAAoCC,kBAAD"}

package/dist/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts

@@ -0,0 +1,46 @@
+import { AgentBuiltInState, AgentMiddleware, Runtime } from "../types.js";
+
+//#region src/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts
+type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<TContextSchema>) => string | Promise<string>;
+/**
+ * Dynamic System Prompt Middleware
+ *
+ * Allows setting the system prompt dynamically right before each model invocation.
+ * Useful when the prompt depends on the current agent state or per-invocation context.
+ *
+ * @typeParam TContextSchema - The shape of the runtime context available at invocation time.
+ * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety
+ * for `runtime.context`.
+ *
+ * @param fn - Function that receives the current agent `state` and `runtime`, and
+ * returns the system prompt for the next model call as a string.
+ *
+ * @returns A middleware instance that sets `systemPrompt` for the next model call.
+ *
+ * @example Basic usage with typed context
+ * ```ts
+ * import { z } from "zod";
+ * import { dynamicSystemPrompt } from "langchain";
+ * import { createAgent, SystemMessage } from "langchain";
+ *
+ * const contextSchema = z.object({ region: z.string().optional() });
+ *
+ * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(
+ *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? "n/a"}`
+ * );
+ *
+ * const agent = createAgent({
+ *   model: "anthropic:claude-3-5-sonnet",
+ *   contextSchema,
+ *   middleware: [middleware],
+ * });
+ *
+ * await agent.invoke({ messages }, { context: { region: "EU" } });
+ * ```
+ *
+ * @public
+ */
+declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): AgentMiddleware<undefined, undefined, any>;
+//#endregion
+export { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware };
+//# sourceMappingURL=dynamicSystemPrompt.d.ts.map

package/dist/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicSystemPrompt.d.ts","names":["Runtime","AgentBuiltInState","DynamicSystemPromptMiddlewareConfig","TContextSchema","Promise","dynamicSystemPromptMiddleware","__index_js0","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/dynamicSystemPrompt.d.ts"],"sourcesContent":["import type { Runtime, AgentBuiltInState } from \"../types.js\";\nexport type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (state: AgentBuiltInState, runtime: Runtime<TContextSchema>) => string | Promise<string>;\n/**\n * Dynamic System Prompt Middleware\n *\n * Allows setting the system prompt dynamically right before each model invocation.\n * Useful when the prompt depends on the current agent state or per-invocation context.\n *\n * @typeParam TContextSchema - The shape of the runtime context available at invocation time.\n * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety\n * for `runtime.context`.\n *\n * @param fn - Function that receives the current agent `state` and `runtime`, and\n * returns the system prompt for the next model call as a string.\n *\n * @returns A middleware instance that sets `systemPrompt` for the next model call.\n *\n * @example Basic usage with typed context\n * ```ts\n * import { z } from \"zod\";\n * import { dynamicSystemPrompt } from \"langchain\";\n * import { createAgent, SystemMessage } from \"langchain\";\n *\n * const contextSchema = z.object({ region: z.string().optional() });\n *\n * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(\n *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? \"n/a\"}`\n * );\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   contextSchema,\n *   middleware: [middleware],\n * });\n *\n * await agent.invoke({ messages }, { context: { region: \"EU\" } });\n * ```\n *\n * @public\n */\nexport declare function dynamicSystemPromptMiddleware<TContextSchema = unknown>(fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>): import(\"./index.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;KACYE,8DAA8DD,4BAA4BD,QAAQG,6BAA6BC;;AAA3I;;;;;;AAAkJ;AAuClJ;;;;;AAA8K;;;;;;;;;;;;;;;;;;;;;;;;;iBAAtJC,4DAA4DH,oCAAoCC,kBAAD"}

package/dist/agents/middlewareAgent/middleware/dynamicSystemPrompt.js

@@ -0,0 +1,58 @@
+import { createMiddleware } from "../middleware.js";
+
+//#region src/agents/middlewareAgent/middleware/dynamicSystemPrompt.ts
+/**
+* Dynamic System Prompt Middleware
+*
+* Allows setting the system prompt dynamically right before each model invocation.
+* Useful when the prompt depends on the current agent state or per-invocation context.
+*
+* @typeParam TContextSchema - The shape of the runtime context available at invocation time.
+* If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety
+* for `runtime.context`.
+*
+* @param fn - Function that receives the current agent `state` and `runtime`, and
+* returns the system prompt for the next model call as a string.
+*
+* @returns A middleware instance that sets `systemPrompt` for the next model call.
+*
+* @example Basic usage with typed context
+* ```ts
+* import { z } from "zod";
+* import { dynamicSystemPrompt } from "langchain";
+* import { createAgent, SystemMessage } from "langchain";
+*
+* const contextSchema = z.object({ region: z.string().optional() });
+*
+* const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(
+*   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? "n/a"}`
+* );
+*
+* const agent = createAgent({
+*   model: "anthropic:claude-3-5-sonnet",
+*   contextSchema,
+*   middleware: [middleware],
+* });
+*
+* await agent.invoke({ messages }, { context: { region: "EU" } });
+* ```
+*
+* @public
+*/
+function dynamicSystemPromptMiddleware(fn) {
+	return createMiddleware({
+		name: "DynamicSystemPromptMiddleware",
+		modifyModelRequest: async (options, state, runtime) => {
+			const systemPrompt = await fn(state, runtime);
+			if (typeof systemPrompt !== "string") throw new Error("dynamicSystemPromptMiddleware function must return a string");
+			return {
+				...options,
+				systemPrompt
+			};
+		}
+	});
+}
+
+//#endregion
+export { dynamicSystemPromptMiddleware };
+//# sourceMappingURL=dynamicSystemPrompt.js.map

package/dist/agents/middlewareAgent/middleware/dynamicSystemPrompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicSystemPrompt.js","names":["fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>"],"sources":["../../../../src/agents/middlewareAgent/middleware/dynamicSystemPrompt.ts"],"sourcesContent":["import { createMiddleware } from \"../middleware.js\";\nimport type { Runtime, AgentBuiltInState } from \"../types.js\";\n\nexport type DynamicSystemPromptMiddlewareConfig<TContextSchema> = (\n  state: AgentBuiltInState,\n  runtime: Runtime<TContextSchema>\n) => string | Promise<string>;\n\n/**\n * Dynamic System Prompt Middleware\n *\n * Allows setting the system prompt dynamically right before each model invocation.\n * Useful when the prompt depends on the current agent state or per-invocation context.\n *\n * @typeParam TContextSchema - The shape of the runtime context available at invocation time.\n * If your agent defines a `contextSchema`, pass the inferred type here to get full type-safety\n * for `runtime.context`.\n *\n * @param fn - Function that receives the current agent `state` and `runtime`, and\n * returns the system prompt for the next model call as a string.\n *\n * @returns A middleware instance that sets `systemPrompt` for the next model call.\n *\n * @example Basic usage with typed context\n * ```ts\n * import { z } from \"zod\";\n * import { dynamicSystemPrompt } from \"langchain\";\n * import { createAgent, SystemMessage } from \"langchain\";\n *\n * const contextSchema = z.object({ region: z.string().optional() });\n *\n * const middleware = dynamicSystemPrompt<z.infer<typeof contextSchema>>(\n *   (_state, runtime) => `You are a helpful assistant. Region: ${runtime.context.region ?? \"n/a\"}`\n * );\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   contextSchema,\n *   middleware: [middleware],\n * });\n *\n * await agent.invoke({ messages }, { context: { region: \"EU\" } });\n * ```\n *\n * @public\n */\nexport function dynamicSystemPromptMiddleware<TContextSchema = unknown>(\n  fn: DynamicSystemPromptMiddlewareConfig<TContextSchema>\n) {\n  return createMiddleware({\n    name: \"DynamicSystemPromptMiddleware\",\n    modifyModelRequest: async (options, state, runtime) => {\n      const systemPrompt = await fn(\n        state as AgentBuiltInState,\n        runtime as Runtime<TContextSchema>\n      );\n\n      if (typeof systemPrompt !== \"string\") {\n        throw new Error(\n          \"dynamicSystemPromptMiddleware function must return a string\"\n        );\n      }\n\n      return { ...options, systemPrompt };\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,8BACdA,IACA;AACA,QAAO,iBAAiB;EACtB,MAAM;EACN,oBAAoB,OAAO,SAAS,OAAO,YAAY;GACrD,MAAM,eAAe,MAAM,GACzB,OACA,QACD;AAED,OAAI,OAAO,iBAAiB,SAC1B,OAAM,IAAI,MACR;AAIJ,UAAO;IAAE,GAAG;IAAS;GAAc;EACpC;CACF,EAAC;AACH"}

package/dist/agents/middlewareAgent/middleware/hitl.cjs

@@ -2,16 +2,19 @@ const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs
 const require_middleware = require('../middleware.cjs');
 const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
 const __langchain_langgraph = require_rolldown_runtime.__toESM(require("@langchain/langgraph"));
+const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
 const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
-const uuid = require_rolldown_runtime.__toESM(require("uuid"));
 
 //#region src/agents/middlewareAgent/middleware/hitl.ts
+const ToolConfigSchema = zod_v3.z.object({
+	allowAccept: zod_v3.z.boolean().optional(),
+	allowEdit: zod_v3.z.boolean().optional(),
+	allowRespond: zod_v3.z.boolean().optional(),
+	description: zod_v3.z.union([zod_v3.z.string(), zod_v3.z.function()]).optional()
+});
 const contextSchema = zod_v3.z.object({
-	toolConfigs: zod_v3.z.record(zod_v3.z.object({
-		requireApproval: zod_v3.z.boolean().optional(),
-		description: zod_v3.z.string().optional()
-	})).default({}),
-	messagePrefix: zod_v3.z.string().default("Tool execution requires approval")
+	interruptOn: zod_v3.z.record(zod_v3.z.union([zod_v3.z.boolean(), ToolConfigSchema])).optional(),
+	descriptionPrefix: zod_v3.z.string().default("Tool execution requires approval")
 });
 /**
 * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.
@@ -20,6 +23,37 @@ const contextSchema = zod_v3.z.object({
 * capabilities before execution. It enables selective approval workflows where certain tools
 * require human intervention while others can execute automatically.
 *
+* A invocation result that has been interrupted by the middleware will have a `__interrupt__`
+* property that contains the interrupt request. You can loop over the request to determine
+* which tools were interrupted, and how to handle them separately.
+*
+* ```ts
+* import { type ToolApprovalRequest, type HumanInTheLoopMiddlewareHumanResponse } from "langchain";
+* import { type Interrupt } from "langchain";
+*
+* const result = await agent.invoke(request);
+* const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<
+*   ToolApprovalRequest[]
+* >;
+* const resume: HumanInTheLoopMiddlewareHumanResponse[] =
+*   interruptRequest.value.map((request) => {
+*     if (request.action === "calculator") {
+*       return { id: request.toolCallId, type: "accept" };
+*     } else if (request.action === "write_file") {
+*       return {
+*         id: request.toolCallId,
+*         type: "edit",
+*         args: { filename: "safe.txt", content: "Safe content" },
+*       };
+*     }
+*
+*     throw new Error(`Unknown action: ${request.action}`);
+*   });
+*
+* // Resume with approval
+* await agent.invoke(new Command({ resume }), config);
+* ```
+*
 * ## Features
 *
 * - **Selective Tool Approval**: Configure which tools require human approval
@@ -36,28 +70,31 @@ const contextSchema = zod_v3.z.object({
 * - `response`: Provide a manual response instead of executing the tool
 *
 * @param options - Configuration options for the middleware
-* @param options.toolConfigs - Per-tool configuration mapping tool names to their settings
-* @param options.toolConfigs[toolName].requireApproval - Whether the tool requires human approval
-* @param options.toolConfigs[toolName].description - Custom approval message for the tool
-* @param options.messagePrefix - Default prefix for approval messages (default: "Tool execution requires approval")
+* @param options.interruptOn - Per-tool configuration mapping tool names to their settings
+* @param options.interruptOn[toolName].allowAccept - Whether the human can approve the current action without changes
+* @param options.interruptOn[toolName].allowEdit - Whether the human can reject the current action with feedback
+* @param options.interruptOn[toolName].allowRespond - Whether the human can approve the current action with edited content
+* @param options.interruptOn[toolName].description - Custom approval message for the tool. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information
+* @param options.messagePrefix - Default prefix for approval messages (default: "Tool execution requires approval"). Only used for tools that do not define a custom `description` in their ToolConfig.
 *
 * @returns A middleware instance that can be passed to `createAgent`
 *
 * @example
 * Basic usage with selective tool approval
 * ```typescript
-* import { humanInTheLoopMiddleware } from "langchain/middleware";
+* import { humanInTheLoopMiddleware } from "langchain";
 * import { createAgent } from "langchain";
 *
 * const hitlMiddleware = humanInTheLoopMiddleware({
-*   toolConfigs: {
+*   interruptOn: {
+*     // Interrupt write_file tool and allow edits or accepts
 *     "write_file": {
-*       requireApproval: true,
+*       allowEdit: true,
+*       allowAccept: true,
 *       description: "⚠️ File write operation requires approval"
 *     },
-*     "read_file": {
-*       requireApproval: false  // Safe operation, no approval needed
-*     }
+*     // Auto-approve read_file tool
+*     "read_file": false
 *   }
 * });
 *
@@ -71,6 +108,7 @@ const contextSchema = zod_v3.z.object({
 * @example
 * Handling approval requests
 * ```typescript
+* import { type HumanInTheLoopRequest, type Interrupt } from "langchain";
 * import { Command } from "@langchain/langgraph";
 *
 * // Initial agent invocation
@@ -79,15 +117,14 @@ const contextSchema = zod_v3.z.object({
 * }, config);
 *
 * // Check if agent is paused for approval
-* const state = await agent.graph.getState(config);
-* if (state.next?.length > 0) {
-*   // Get interrupt details
-*   const task = state.tasks?.[0];
-*   const requests = task?.interrupts?.[0]?.value;
+* if (result.__interrupt__) {
+*   const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<
+*     HumanInTheLoopRequest[]
+*   >;
 *
 *   // Show tool call details to user
-*   console.log("Tool:", requests[0].action);
-*   console.log("Args:", requests[0].args);
+*   console.log("Tool:", interruptRequest.value[0].actionRequest);
+*   console.log("Allowed actions:", interruptRequest.value[0].config);
 *
 *   // Resume with approval
 *   await agent.invoke(
@@ -112,12 +149,13 @@ const contextSchema = zod_v3.z.object({
 * })
 *
 * // Skip tool and terminate agent
-* new Command({ resume: [{ type: "ignore" }] })
+* new Command({ resume: [{ type: "response" }] })
 *
 * // Provide manual response
 * new Command({
 *   resume: [{
 *     type: "response",
+*     // this must be a string
 *     args: "File operation not allowed in demo mode"
 *   }]
 * })
@@ -127,16 +165,16 @@ const contextSchema = zod_v3.z.object({
 * Production use case with database operations
 * ```typescript
 * const hitlMiddleware = humanInTheLoopMiddleware({
-*   toolConfigs: {
+*   interruptOn: {
 *     "execute_sql": {
-*       requireApproval: true,
+*       allowAccept: true,
+*       allowEdit: true,
+*       allowRespond: true,
 *       description: "🚨 SQL query requires DBA approval\nPlease review for safety and performance"
 *     },
-*     "read_schema": {
-*       requireApproval: false  // Reading metadata is safe
-*     },
+*     "read_schema": false  // Reading metadata is safe
 *     "delete_records": {
-*       requireApproval: true,
+*       allowAccept: true,
 *       description: "⛔ DESTRUCTIVE OPERATION - Requires manager approval"
 *     }
 *   },
@@ -144,6 +182,36 @@ const contextSchema = zod_v3.z.object({
 * });
 * ```
 *
+* @example
+* Using dynamic callable descriptions
+* ```typescript
+* import { type DescriptionFactory } from "langchain";
+*
+* // Define a dynamic description factory
+* const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {
+*   return `Tool: ${toolCall.name}\nArguments:\n${JSON.stringify(toolCall.args, null, 2)}`;
+* };
+*
+* const hitlMiddleware = humanInTheLoopMiddleware({
+*   interruptOn: {
+*     "write_file": {
+*       allowAccept: true,
+*       allowEdit: true,
+*       // Use dynamic description that can access tool call, state, and runtime
+*       description: formatToolDescription
+*     },
+*     // Or use an inline function
+*     "send_email": {
+*       allowAccept: true,
+*       description: (toolCall, state, runtime) => {
+*         const { to, subject } = toolCall.args;
+*         return `Email to ${to}\nSubject: ${subject}\n\nRequires approval before sending`;
+*       }
+*     }
+*   }
+* });
+* ```
+*
 * @remarks
 * - Tool calls are processed in the order they appear in the AI message
 * - Auto-approved tools execute immediately without interruption
@@ -155,77 +223,115 @@ const contextSchema = zod_v3.z.object({
 * @see {@link Command} for resuming interrupted execution
 * @public
 */
-function humanInTheLoopMiddleware(options = {}) {
+function humanInTheLoopMiddleware(options) {
 	return require_middleware.createMiddleware({
 		name: "HumanInTheLoopMiddleware",
 		contextSchema,
-		afterModel: async (state, runtime, controls) => {
-			const config = {
-				...contextSchema.parse(options),
-				...runtime.context
-			};
+		afterModelJumpTo: ["model"],
+		afterModel: async (state, runtime) => {
+			const config = (0, __langchain_core_utils_types.interopParse)(contextSchema, {
+				...options,
+				...runtime.context || {}
+			});
+			if (!config) return;
 			const { messages } = state;
 			if (!messages.length) return;
-			const lastMessage = messages[messages.length - 1];
-			if (!(0, __langchain_core_messages.isAIMessage)(lastMessage) || !lastMessage.tool_calls?.length) return;
+			/**
+			* Don't do anything if the last message isn't an AI message with tool calls.
+			*/
+			const lastMessage = [...messages].reverse().find((msg) => __langchain_core_messages.AIMessage.isInstance(msg));
+			if (!lastMessage || !lastMessage.tool_calls?.length) return;
+			/**
+			* If the user omits the interruptOn config, we don't do anything.
+			*/
+			if (!config.interruptOn) return;
+			const resolvedToolConfigs = {};
+			for (const [toolName, toolConfig] of Object.entries(config.interruptOn)) if (typeof toolConfig === "boolean") {
+				if (toolConfig === true) resolvedToolConfigs[toolName] = {
+					allowAccept: true,
+					allowEdit: true,
+					allowRespond: true
+				};
+			} else resolvedToolConfigs[toolName] = toolConfig;
 			const interruptToolCalls = [];
 			const autoApprovedToolCalls = [];
-			for (const toolCall of lastMessage.tool_calls) {
-				const normalizedToolCall = {
-					id: toolCall.id || (0, uuid.v4)(),
-					name: toolCall.name,
-					args: toolCall.args
-				};
-				const toolConfig = config.toolConfigs[normalizedToolCall.name];
-				if (toolConfig?.requireApproval) interruptToolCalls.push(normalizedToolCall);
-				else autoApprovedToolCalls.push(normalizedToolCall);
-			}
+			for (const toolCall of lastMessage.tool_calls) if (toolCall.name in resolvedToolConfigs) interruptToolCalls.push(toolCall);
+			else autoApprovedToolCalls.push(toolCall);
+			/**
+			* No interrupt tool calls, so we can just return.
+			*/
 			if (!interruptToolCalls.length) return;
-			const approvedToolCalls = [...autoApprovedToolCalls];
-			const requests = interruptToolCalls.map((toolCall) => {
-				const toolConfig = config.toolConfigs[toolCall.name];
-				const description = toolConfig?.description || `${config.messagePrefix}\n\nTool: ${toolCall.name}\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;
+			const hitlRequests = await Promise.all(interruptToolCalls.map(async (toolCall) => {
+				const toolConfig = resolvedToolConfigs[toolCall.name];
+				const description = toolConfig.description ? typeof toolConfig.description === "function" ? await toolConfig.description(toolCall, state, runtime) : toolConfig.description : `${config.descriptionPrefix}\n\nTool: ${toolCall.name}\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;
 				return {
-					action: toolCall.name,
-					args: toolCall.args,
-					toolCallId: toolCall.id,
+					actionRequest: {
+						action: toolCall.name,
+						args: toolCall.args
+					},
+					config: toolConfig,
 					description
 				};
-			});
-			const responses = await (0, __langchain_langgraph.interrupt)(requests);
-			for (let i = 0; i < responses.length; i++) {
-				const response = responses[i];
+			}));
+			const responses = await (0, __langchain_langgraph.interrupt)(hitlRequests);
+			if (responses.length !== interruptToolCalls.length) throw new Error(`Number of human responses (${responses.length}) does not match number of hanging tool calls (${interruptToolCalls.length}).`);
+			const approvedToolCalls = [...autoApprovedToolCalls];
+			const artificialToolMessages = [];
+			for (const [i, response] of responses.entries()) {
 				const toolCall = interruptToolCalls[i];
-				switch (response.type) {
-					case "accept":
-						approvedToolCalls.push(toolCall);
-						break;
-					case "edit":
-						if (response.args && typeof response.args === "object" && "args" in response.args) approvedToolCalls.push({
-							...toolCall,
-							args: response.args.args
-						});
-						break;
-					case "ignore": return controls.terminate();
-					case "response": {
-						const toolMessage = new __langchain_core_messages.ToolMessage({
-							content: typeof response.args === "string" ? response.args : "",
-							tool_call_id: toolCall.id
-						});
-						return {
-							messages: [...state.messages, toolMessage],
-							jump_to: "model"
-						};
-					}
-					default: throw new Error(`Unknown response type: ${response.type}`);
+				const toolConfig = resolvedToolConfigs[toolCall.name];
+				if (response.type === "accept" && toolConfig?.allowAccept) {
+					approvedToolCalls.push(toolCall);
+					continue;
+				}
+				if (response.type === "edit" && toolConfig?.allowEdit) {
+					const edited = response.args;
+					approvedToolCalls.push({
+						id: toolCall.id,
+						name: edited.action,
+						args: edited.args
+					});
+					continue;
 				}
+				if (response.type === "response" && toolConfig?.allowRespond) {
+					const content = response.args ?? `User rejected the tool call for \`${toolCall.name}\` with id ${toolCall.id}`;
+					/**
+					* Providing a meaningful error message for this case that should never happen.
+					*/
+					if (!toolCall.id) throw new Error(`Can't provide custom tool response for tool call without an ID: ${toolCall.name}!\nThis use case is not expected to happen, please report this as a bug.`);
+					/**
+					* ToolMessage expects a string, so we need to throw an error if it's not a string
+					* as we currently have no way to proper type responses from users through the
+					* Command object.
+					*/
+					if (typeof content !== "string") throw new Error(`Tool call response for "${toolCall.name}" must be a string, got ${typeof content}`);
+					artificialToolMessages.push(new __langchain_core_messages.ToolMessage({
+						content,
+						name: toolCall.name,
+						tool_call_id: toolCall.id,
+						status: "error"
+					}));
+					continue;
+				}
+				const allowedActions = [
+					toolConfig?.allowAccept && "accept",
+					toolConfig?.allowEdit && "edit",
+					toolConfig?.allowRespond && "response"
+				].filter(Boolean).join("\", \"");
+				throw new Error(`Unexpected human response: ${JSON.stringify(response)}. Response action '${response.type}' is not allowed for tool '${toolCall.name}'. Expected one of: "${allowedActions}", based on the tool's configuration.`);
 			}
-			const updatedMessage = new __langchain_core_messages.AIMessage({
-				content: lastMessage.content,
-				tool_calls: approvedToolCalls,
-				id: lastMessage.id
+			/**
+			* Replace the tool calls with the approved tool calls
+			*/
+			if (__langchain_core_messages.AIMessage.isInstance(lastMessage)) lastMessage.tool_calls = lastMessage.tool_calls?.map((tc) => {
+				const approvedToolCall = approvedToolCalls.find((atc) => atc.id === tc.id);
+				return approvedToolCall ?? tc;
 			});
-			return { messages: [...state.messages.slice(0, -1), updatedMessage] };
+			if (approvedToolCalls.length > 0) return { messages: [...state.messages, ...artificialToolMessages] };
+			return {
+				jumpTo: "model",
+				messages: [...state.messages, ...artificialToolMessages]
+			};
 		}
 	});
 }