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

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

@@ -1,310 +0,0 @@
-import { createMiddleware } from "../middleware.js";
-import { AIMessage, ToolMessage } from "@langchain/core/messages";
-import { interrupt } from "@langchain/langgraph";
-import { interopParse } from "@langchain/core/utils/types";
-import { z } from "zod/v3";
-
-//#region src/agents/middlewareAgent/middleware/hitl.ts
-const ToolConfigSchema = z.object({
-	allowAccept: z.boolean().optional(),
-	allowEdit: z.boolean().optional(),
-	allowRespond: z.boolean().optional(),
-	description: z.string().optional()
-});
-const contextSchema = z.object({
-	interruptOn: z.record(z.union([z.boolean(), ToolConfigSchema])).optional(),
-	descriptionPrefix: z.string().default("Tool execution requires approval")
-});
-/**
-* Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.
-*
-* This middleware intercepts tool calls made by an AI agent and provides human oversight
-* 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/middleware";
-* 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
-* - **Multiple Response Types**: Accept, edit, ignore, or manually respond to tool calls
-* - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval
-* - **Custom Approval Messages**: Provide context-specific descriptions for approval requests
-*
-* ## Response Types
-*
-* When a tool requires approval, the human operator can respond with:
-* - `accept`: Execute the tool with original arguments
-* - `edit`: Modify the tool arguments before execution
-* - `ignore`: Skip the tool and terminate the agent
-* - `response`: Provide a manual response instead of executing the tool
-*
-* @param options - Configuration options for the middleware
-* @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
-* @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 { createAgent } from "langchain";
-*
-* const hitlMiddleware = humanInTheLoopMiddleware({
-*   interruptOn: {
-*     // Interrupt write_file tool and allow edits or accepts
-*     "write_file": {
-*       allowEdit: true,
-*       allowAccept: true,
-*       description: "⚠️ File write operation requires approval"
-*     },
-*     // Auto-approve read_file tool
-*     "read_file": false
-*   }
-* });
-*
-* const agent = createAgent({
-*   model: "openai:gpt-4",
-*   tools: [writeFileTool, readFileTool],
-*   middleware: [hitlMiddleware]
-* });
-* ```
-*
-* @example
-* Handling approval requests
-* ```typescript
-* import { type HumanInTheLoopRequest, type Interrupt } from "langchain/middleware";
-* import { Command } from "@langchain/langgraph";
-*
-* // Initial agent invocation
-* const result = await agent.invoke({
-*   messages: [new HumanMessage("Write 'Hello' to output.txt")]
-* }, config);
-*
-* // Check if agent is paused for approval
-* if (result.__interrupt__) {
-*   const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<
-*     HumanInTheLoopRequest[]
-*   >;
-*
-*   // Show tool call details to user
-*   console.log("Tool:", interruptRequest.value[0].actionRequest);
-*   console.log("Allowed actions:", interruptRequest.value[0].config);
-*
-*   // Resume with approval
-*   await agent.invoke(
-*     new Command({ resume: [{ type: "accept" }] }),
-*     config
-*   );
-* }
-* ```
-*
-* @example
-* Different response types
-* ```typescript
-* // Accept the tool call as-is
-* new Command({ resume: [{ type: "accept" }] })
-*
-* // Edit the tool arguments
-* new Command({
-*   resume: [{
-*     type: "edit",
-*     args: { action: "write_file", args: { filename: "safe.txt", content: "Modified" } }
-*   }]
-* })
-*
-* // Skip tool and terminate agent
-* 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"
-*   }]
-* })
-* ```
-*
-* @example
-* Production use case with database operations
-* ```typescript
-* const hitlMiddleware = humanInTheLoopMiddleware({
-*   interruptOn: {
-*     "execute_sql": {
-*       allowAccept: true,
-*       allowEdit: true,
-*       allowRespond: true,
-*       description: "🚨 SQL query requires DBA approval\nPlease review for safety and performance"
-*     },
-*     "read_schema": false  // Reading metadata is safe
-*     "delete_records": {
-*       allowAccept: true,
-*       description: "⛔ DESTRUCTIVE OPERATION - Requires manager approval"
-*     }
-*   },
-*   messagePrefix: "Database operation pending approval"
-* });
-* ```
-*
-* @remarks
-* - Tool calls are processed in the order they appear in the AI message
-* - Auto-approved tools execute immediately without interruption
-* - Multiple tools requiring approval are bundled into a single interrupt
-* - The middleware operates in the `afterModel` phase, intercepting before tool execution
-* - Requires a checkpointer to maintain state across interruptions
-*
-* @see {@link createAgent} for agent creation
-* @see {@link Command} for resuming interrupted execution
-* @public
-*/
-function humanInTheLoopMiddleware(options) {
-	return createMiddleware({
-		name: "HumanInTheLoopMiddleware",
-		contextSchema,
-		afterModelJumpTo: ["model"],
-		afterModel: async (state, runtime) => {
-			const config = interopParse(contextSchema, {
-				...options,
-				...runtime.context || {}
-			});
-			if (!config) return;
-			const { messages } = state;
-			if (!messages.length) return;
-			/**
-			* Don't do anything if the last message isn't an AI message with tool calls.
-			*/
-			const lastMessage = [...messages].reverse().find((msg) => 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) 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 hitlRequests = interruptToolCalls.map((toolCall) => {
-				const toolConfig = resolvedToolConfigs[toolCall.name];
-				const description = toolConfig.description || `${config.descriptionPrefix}\n\nTool: ${toolCall.name}\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;
-				return {
-					actionRequest: {
-						action: toolCall.name,
-						args: toolCall.args
-					},
-					config: toolConfig,
-					description
-				};
-			});
-			const responses = await 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];
-				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 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.`);
-			}
-			/**
-			* Replace the tool calls with the approved tool calls
-			*/
-			if (AIMessage.isInstance(lastMessage)) lastMessage.tool_calls = lastMessage.tool_calls?.map((tc) => {
-				const approvedToolCall = approvedToolCalls.find((atc) => atc.id === tc.id);
-				return approvedToolCall ?? tc;
-			});
-			if (approvedToolCalls.length > 0) return { messages: [...state.messages, ...artificialToolMessages] };
-			return {
-				jumpTo: "model",
-				messages: [...state.messages, ...artificialToolMessages]
-			};
-		}
-	});
-}
-
-//#endregion
-export { humanInTheLoopMiddleware };
-//# sourceMappingURL=hitl.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"hitl.js","names":["options: NonNullable<HumanInTheLoopMiddlewareConfig>","resolvedToolConfigs: Record<string, ToolConfig>","interruptToolCalls: ToolCall[]","autoApprovedToolCalls: ToolCall[]","hitlRequests: HumanInTheLoopRequest[]","approvedToolCalls: ToolCall[]","artificialToolMessages: ToolMessage[]"],"sources":["../../../../src/agents/middlewareAgent/middleware/hitl.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { AIMessage, ToolMessage } from \"@langchain/core/messages\";\nimport {\n  InferInteropZodInput,\n  interopParse,\n} from \"@langchain/core/utils/types\";\nimport { interrupt } from \"@langchain/langgraph\";\n\nimport { createMiddleware } from \"../middleware.js\";\n\nconst ToolConfigSchema = z.object({\n  /**\n   * Whether the human can approve the current action without changes\n   */\n  allowAccept: z.boolean().optional(),\n  /**\n   * Whether the human can reject the current action with feedback\n   */\n  allowEdit: z.boolean().optional(),\n  /**\n   * Whether the human can approve the current action with edited content\n   */\n  allowRespond: z.boolean().optional(),\n  /**\n   * The description attached to the request for human input\n   */\n  description: z.string().optional(),\n});\n\ntype ToolConfigSchema = z.input<typeof ToolConfigSchema>;\ntype ToolCall = NonNullable<AIMessage[\"tool_calls\"]>[number];\n\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/**\n * Configuration that defines which reviewer response types are permitted during a human interrupt.\n * These flags control what the human reviewer may do (e.g., accept/edit/respond),\n * not the tool action the agent has requested.\n */\nexport interface HumanInTheLoopConfig\n  extends Omit<ToolConfigSchema, \"description\"> {}\n\n/**\n * Describes the agent-requested tool action (name and arguments).\n * This is what the AI intends to execute, subject to human review.\n */\nexport interface ActionRequest {\n  /**\n   * The tool/action name requested by the agent (e.g., \"send_email\").\n   */\n  action: string;\n  /**\n   * Arguments for the requested tool call (e.g., {\"a\": 1, \"b\": 2}).\n   */\n  args: Record<string, any>;\n}\n\n/**\n * Represents an interrupt triggered by the graph that requires human intervention\n * to approve, edit, or respond to an agent-requested tool action.\n *\n * @example\n * ```ts\n * const hitlRequest: HumanInTheLoopRequest = {\n *   actionRequest: { action: \"Approve XYZ action\", args: { ... } },\n *   config: { allowAccept: true, allowEdit: true, allowRespond: true },\n *   description: \"Please review the command before execution\"\n * };\n * response = interrupt([request])[0]\n * ```\n */\nexport interface HumanInTheLoopRequest {\n  /**\n   * The agent-requested tool action to be reviewed.\n   */\n  actionRequest: ActionRequest;\n  /**\n   * Which reviewer responses are allowed (accept/edit/respond).\n   */\n  config: HumanInTheLoopConfig;\n  /**\n   * Optional human-facing description shown in the approval prompt.\n   */\n  description?: string;\n}\n\n/**\n * Response when a human approves the agent-requested action.\n */\nexport interface AcceptPayload {\n  type: \"accept\";\n}\n\n/**\n * Response when a human provides a manual response instead of executing\n * the agent-requested action.\n */\nexport interface ResponsePayload {\n  type: \"response\";\n  args?: string;\n}\n\n/**\n * Response when a human edits the agent-requested action (tool name and/or args).\n */\nexport interface EditPayload {\n  type: \"edit\";\n  args: ActionRequest;\n}\n\nexport type HumanInTheLoopMiddlewareHumanResponse =\n  | AcceptPayload\n  | ResponsePayload\n  | EditPayload;\n\n/**\n * Configuration for a tool requiring human in the loop.\n */\nexport interface ToolConfig extends HumanInTheLoopConfig {\n  /**\n   * Human-facing description shown in the approval request.\n   */\n  description?: string;\n}\n\nconst contextSchema = z.object({\n  /**\n   * Mapping of tool name to allowed reviewer responses.\n   * If a tool doesn't have an entry, it's auto-approved by default.\n   *\n   * - `true` -> pause for approval and allow accept/edit/respond\n   * - `false` -> auto-approve (no human review)\n   * - `ToolConfig` -> explicitly specify which reviewer responses are allowed for this tool\n   */\n  interruptOn: z.record(z.union([z.boolean(), ToolConfigSchema])).optional(),\n  /**\n   * Prefix used when constructing human-facing approval messages.\n   * Provides context about the tool call being reviewed; does not change the underlying action.\n   *\n   * Note: This prefix is only applied for tools that do not provide a custom\n   * `description` via their {@link ToolConfig}. If a tool specifies a custom\n   * `description`, that per-tool text is used and this prefix is ignored.\n   */\n  descriptionPrefix: z.string().default(\"Tool execution requires approval\"),\n});\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<\n  typeof contextSchema\n>;\n\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request. You can loop over the request to determine\n * which tools were interrupted, and how to handle them separately.\n *\n * ```ts\n * import { type ToolApprovalRequest, type HumanInTheLoopMiddlewareHumanResponse } from \"langchain/middleware\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<\n *   ToolApprovalRequest[]\n * >;\n * const resume: HumanInTheLoopMiddlewareHumanResponse[] =\n *   interruptRequest.value.map((request) => {\n *     if (request.action === \"calculator\") {\n *       return { id: request.toolCallId, type: \"accept\" };\n *     } else if (request.action === \"write_file\") {\n *       return {\n *         id: request.toolCallId,\n *         type: \"edit\",\n *         args: { filename: \"safe.txt\", content: \"Safe content\" },\n *       };\n *     }\n *\n *     throw new Error(`Unknown action: ${request.action}`);\n *   });\n *\n * // Resume with approval\n * await agent.invoke(new Command({ resume }), config);\n * ```\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Response Types**: Accept, edit, ignore, or manually respond to tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Response Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `accept`: Execute the tool with original arguments\n * - `edit`: Modify the tool arguments before execution\n * - `ignore`: Skip the tool and terminate the agent\n * - `response`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowAccept - Whether the human can approve the current action without changes\n * @param options.interruptOn[toolName].allowEdit - Whether the human can reject the current action with feedback\n * @param options.interruptOn[toolName].allowRespond - Whether the human can approve the current action with edited content\n * @param options.interruptOn[toolName].description - Custom approval message for the tool\n * @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.\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or accepts\n *     \"write_file\": {\n *       allowEdit: true,\n *       allowAccept: true,\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HumanInTheLoopRequest, type Interrupt } from \"langchain/middleware\";\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * if (result.__interrupt__) {\n *   const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<\n *     HumanInTheLoopRequest[]\n *   >;\n *\n *   // Show tool call details to user\n *   console.log(\"Tool:\", interruptRequest.value[0].actionRequest);\n *   console.log(\"Allowed actions:\", interruptRequest.value[0].config);\n *\n *   // Resume with approval\n *   await agent.invoke(\n *     new Command({ resume: [{ type: \"accept\" }] }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different response types\n * ```typescript\n * // Accept the tool call as-is\n * new Command({ resume: [{ type: \"accept\" }] })\n *\n * // Edit the tool arguments\n * new Command({\n *   resume: [{\n *     type: \"edit\",\n *     args: { action: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * })\n *\n * // Skip tool and terminate agent\n * new Command({ resume: [{ type: \"response\" }] })\n *\n * // Provide manual response\n * new Command({\n *   resume: [{\n *     type: \"response\",\n *     // this must be a string\n *     args: \"File operation not allowed in demo mode\"\n *   }]\n * })\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"execute_sql\": {\n *       allowAccept: true,\n *       allowEdit: true,\n *       allowRespond: true,\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowAccept: true,\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   messagePrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport function humanInTheLoopMiddleware(\n  options: NonNullable<HumanInTheLoopMiddlewareConfig>\n) {\n  return createMiddleware({\n    name: \"HumanInTheLoopMiddleware\",\n    contextSchema,\n    afterModelJumpTo: [\"model\"],\n    afterModel: async (state, runtime) => {\n      const config = interopParse(contextSchema, {\n        ...options,\n        ...(runtime.context || {}),\n      });\n      if (!config) {\n        return;\n      }\n\n      const { messages } = state;\n      if (!messages.length) {\n        return;\n      }\n\n      /**\n       * Don't do anything if the last message isn't an AI message with tool calls.\n       */\n      const lastMessage = [...messages]\n        .reverse()\n        .find((msg) => AIMessage.isInstance(msg)) as AIMessage;\n      if (!lastMessage || !lastMessage.tool_calls?.length) {\n        return;\n      }\n\n      /**\n       * If the user omits the interruptOn config, we don't do anything.\n       */\n      if (!config.interruptOn) {\n        return;\n      }\n\n      // Resolve per-tool configs (boolean true -> all actions allowed; false -> auto-approve)\n      const resolvedToolConfigs: Record<string, ToolConfig> = {};\n      for (const [toolName, toolConfig] of Object.entries(config.interruptOn)) {\n        if (typeof toolConfig === \"boolean\") {\n          if (toolConfig === true) {\n            resolvedToolConfigs[toolName] = {\n              allowAccept: true,\n              allowEdit: true,\n              allowRespond: true,\n            };\n          }\n        } else {\n          resolvedToolConfigs[toolName] = toolConfig;\n        }\n      }\n\n      const interruptToolCalls: ToolCall[] = [];\n      const autoApprovedToolCalls: ToolCall[] = [];\n\n      for (const toolCall of lastMessage.tool_calls) {\n        if (toolCall.name in resolvedToolConfigs) {\n          interruptToolCalls.push(toolCall);\n        } else {\n          autoApprovedToolCalls.push(toolCall);\n        }\n      }\n\n      /**\n       * No interrupt tool calls, so we can just return.\n       */\n      if (!interruptToolCalls.length) {\n        return;\n      }\n\n      const hitlRequests: HumanInTheLoopRequest[] = interruptToolCalls.map(\n        (toolCall) => {\n          const toolConfig = resolvedToolConfigs[toolCall.name]!;\n          const description =\n            toolConfig.description ||\n            `${config.descriptionPrefix}\\n\\nTool: ${\n              toolCall.name\n            }\\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;\n          return {\n            actionRequest: { action: toolCall.name, args: toolCall.args },\n            config: toolConfig,\n            description,\n          };\n        }\n      );\n\n      const responses = (await interrupt(\n        hitlRequests\n      )) as HumanInTheLoopMiddlewareHumanResponse[];\n\n      if (responses.length !== interruptToolCalls.length) {\n        throw new Error(\n          `Number of human responses (${responses.length}) does not match number of hanging tool calls (${interruptToolCalls.length}).`\n        );\n      }\n\n      const approvedToolCalls: ToolCall[] = [...autoApprovedToolCalls];\n      const artificialToolMessages: ToolMessage[] = [];\n\n      for (const [i, response] of responses.entries()) {\n        const toolCall = interruptToolCalls[i]!;\n        const toolConfig = resolvedToolConfigs[toolCall.name]!;\n\n        if (response.type === \"accept\" && toolConfig?.allowAccept) {\n          approvedToolCalls.push(toolCall);\n          continue;\n        }\n\n        if (response.type === \"edit\" && toolConfig?.allowEdit) {\n          const edited = response.args;\n          approvedToolCalls.push({\n            id: toolCall.id,\n            name: edited.action,\n            args: edited.args,\n          });\n          continue;\n        }\n\n        if (response.type === \"response\" && toolConfig?.allowRespond) {\n          const content =\n            response.args ??\n            `User rejected the tool call for \\`${toolCall.name}\\` with id ${toolCall.id}`;\n\n          /**\n           * Providing a meaningful error message for this case that should never happen.\n           */\n          if (!toolCall.id) {\n            throw new Error(\n              `Can't provide custom tool response for tool call without an ID: ${toolCall.name}!\\n` +\n                \"This use case is not expected to happen, please report this as a bug.\"\n            );\n          }\n\n          /**\n           * ToolMessage expects a string, so we need to throw an error if it's not a string\n           * as we currently have no way to proper type responses from users through the\n           * Command object.\n           */\n          if (typeof content !== \"string\") {\n            throw new Error(\n              `Tool call response for \"${\n                toolCall.name\n              }\" must be a string, got ${typeof content}`\n            );\n          }\n\n          artificialToolMessages.push(\n            new ToolMessage({\n              content,\n              name: toolCall.name,\n              tool_call_id: toolCall.id,\n              status: \"error\",\n            })\n          );\n          continue;\n        }\n\n        const allowedActions = [\n          toolConfig?.allowAccept && \"accept\",\n          toolConfig?.allowEdit && \"edit\",\n          toolConfig?.allowRespond && \"response\",\n        ]\n          .filter(Boolean)\n          .join('\", \"');\n        throw new Error(\n          `Unexpected human response: ${JSON.stringify(\n            response\n          )}. Response action '${response.type}' is not allowed for tool '${\n            toolCall.name\n          }'. Expected one of: \"${allowedActions}\", based on the tool's configuration.`\n        );\n      }\n\n      /**\n       * Replace the tool calls with the approved tool calls\n       */\n      if (AIMessage.isInstance(lastMessage)) {\n        lastMessage.tool_calls = lastMessage.tool_calls?.map((tc) => {\n          const approvedToolCall = approvedToolCalls.find(\n            (atc) => atc.id === tc.id\n          );\n          return approvedToolCall ?? tc;\n        });\n      }\n\n      if (approvedToolCalls.length > 0) {\n        return { messages: [...state.messages, ...artificialToolMessages] };\n      }\n\n      return {\n        jumpTo: \"model\",\n        messages: [...state.messages, ...artificialToolMessages],\n      };\n    },\n  });\n}\n"],"mappings":"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"}

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

@@ -1,32 +0,0 @@
-const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
-const require_summarization = require('./summarization.cjs');
-const require_hitl = require('./hitl.cjs');
-const require_promptCaching = require('./promptCaching.cjs');
-const require_dynamicSystemPrompt = require('./dynamicSystemPrompt.cjs');
-const require_bigTool = require('./bigTool.cjs');
-
-//#region src/agents/middlewareAgent/middleware/index.ts
-var middleware_exports = {};
-require_rolldown_runtime.__export(middleware_exports, {
-	anthropicPromptCachingMiddleware: () => require_promptCaching.anthropicPromptCachingMiddleware,
-	countTokensApproximately: () => require_summarization.countTokensApproximately,
-	dynamicSystemPromptMiddleware: () => require_dynamicSystemPrompt.dynamicSystemPromptMiddleware,
-	humanInTheLoopMiddleware: () => require_hitl.humanInTheLoopMiddleware,
-	llmToolSelectorMiddleware: () => require_bigTool.llmToolSelectorMiddleware,
-	summarizationMiddleware: () => require_summarization.summarizationMiddleware
-});
-
-//#endregion
-exports.anthropicPromptCachingMiddleware = require_promptCaching.anthropicPromptCachingMiddleware;
-exports.countTokensApproximately = require_summarization.countTokensApproximately;
-exports.dynamicSystemPromptMiddleware = require_dynamicSystemPrompt.dynamicSystemPromptMiddleware;
-exports.humanInTheLoopMiddleware = require_hitl.humanInTheLoopMiddleware;
-exports.llmToolSelectorMiddleware = require_bigTool.llmToolSelectorMiddleware;
-Object.defineProperty(exports, 'middleware_exports', {
-  enumerable: true,
-  get: function () {
-    return middleware_exports;
-  }
-});
-exports.summarizationMiddleware = require_summarization.summarizationMiddleware;
-//# sourceMappingURL=index.cjs.map

package/dist/agents/middlewareAgent/middleware/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../../../src/agents/middlewareAgent/middleware/index.ts"],"sourcesContent":["export {\n  summarizationMiddleware,\n  countTokensApproximately,\n  type SummarizationMiddlewareConfig,\n} from \"./summarization.js\";\nexport {\n  humanInTheLoopMiddleware,\n  type HumanInTheLoopRequest,\n  type HumanInTheLoopMiddlewareHumanResponse,\n  type HumanInTheLoopMiddlewareConfig,\n  type ActionRequest,\n} from \"./hitl.js\";\nexport {\n  anthropicPromptCachingMiddleware,\n  type PromptCachingMiddlewareConfig,\n} from \"./promptCaching.js\";\nexport {\n  dynamicSystemPromptMiddleware,\n  type DynamicSystemPromptMiddlewareConfig,\n} from \"./dynamicSystemPrompt.js\";\nexport {\n  llmToolSelectorMiddleware,\n  type LLMToolSelectorConfig,\n} from \"./bigTool.js\";\n"],"mappings":""}

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

@@ -1,6 +0,0 @@
-import { SummarizationMiddlewareConfig, countTokensApproximately, summarizationMiddleware } from "./summarization.cjs";
-import { ActionRequest, HumanInTheLoopMiddlewareConfig, HumanInTheLoopMiddlewareHumanResponse, HumanInTheLoopRequest, humanInTheLoopMiddleware } from "./hitl.cjs";
-import { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware } from "./promptCaching.cjs";
-import { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware } from "./dynamicSystemPrompt.cjs";
-import { LLMToolSelectorConfig, llmToolSelectorMiddleware } from "./bigTool.cjs";
-export { type ActionRequest, type DynamicSystemPromptMiddlewareConfig, type HumanInTheLoopMiddlewareConfig, type HumanInTheLoopMiddlewareHumanResponse, type HumanInTheLoopRequest, type LLMToolSelectorConfig, type PromptCachingMiddlewareConfig, type SummarizationMiddlewareConfig, anthropicPromptCachingMiddleware, countTokensApproximately, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, summarizationMiddleware };

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

@@ -1,6 +0,0 @@
-import { SummarizationMiddlewareConfig, countTokensApproximately, summarizationMiddleware } from "./summarization.js";
-import { ActionRequest, HumanInTheLoopMiddlewareConfig, HumanInTheLoopMiddlewareHumanResponse, HumanInTheLoopRequest, humanInTheLoopMiddleware } from "./hitl.js";
-import { PromptCachingMiddlewareConfig, anthropicPromptCachingMiddleware } from "./promptCaching.js";
-import { DynamicSystemPromptMiddlewareConfig, dynamicSystemPromptMiddleware } from "./dynamicSystemPrompt.js";
-import { LLMToolSelectorConfig, llmToolSelectorMiddleware } from "./bigTool.js";
-export { type ActionRequest, type DynamicSystemPromptMiddlewareConfig, type HumanInTheLoopMiddlewareConfig, type HumanInTheLoopMiddlewareHumanResponse, type HumanInTheLoopRequest, type LLMToolSelectorConfig, type PromptCachingMiddlewareConfig, type SummarizationMiddlewareConfig, anthropicPromptCachingMiddleware, countTokensApproximately, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, summarizationMiddleware };

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

@@ -1,21 +0,0 @@
-import { __export } from "../../../_virtual/rolldown_runtime.js";
-import { countTokensApproximately, summarizationMiddleware } from "./summarization.js";
-import { humanInTheLoopMiddleware } from "./hitl.js";
-import { anthropicPromptCachingMiddleware } from "./promptCaching.js";
-import { dynamicSystemPromptMiddleware } from "./dynamicSystemPrompt.js";
-import { llmToolSelectorMiddleware } from "./bigTool.js";
-
-//#region src/agents/middlewareAgent/middleware/index.ts
-var middleware_exports = {};
-__export(middleware_exports, {
-	anthropicPromptCachingMiddleware: () => anthropicPromptCachingMiddleware,
-	countTokensApproximately: () => countTokensApproximately,
-	dynamicSystemPromptMiddleware: () => dynamicSystemPromptMiddleware,
-	humanInTheLoopMiddleware: () => humanInTheLoopMiddleware,
-	llmToolSelectorMiddleware: () => llmToolSelectorMiddleware,
-	summarizationMiddleware: () => summarizationMiddleware
-});
-
-//#endregion
-export { anthropicPromptCachingMiddleware, countTokensApproximately, dynamicSystemPromptMiddleware, humanInTheLoopMiddleware, llmToolSelectorMiddleware, middleware_exports, summarizationMiddleware };
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../src/agents/middlewareAgent/middleware/index.ts"],"sourcesContent":["export {\n  summarizationMiddleware,\n  countTokensApproximately,\n  type SummarizationMiddlewareConfig,\n} from \"./summarization.js\";\nexport {\n  humanInTheLoopMiddleware,\n  type HumanInTheLoopRequest,\n  type HumanInTheLoopMiddlewareHumanResponse,\n  type HumanInTheLoopMiddlewareConfig,\n  type ActionRequest,\n} from \"./hitl.js\";\nexport {\n  anthropicPromptCachingMiddleware,\n  type PromptCachingMiddlewareConfig,\n} from \"./promptCaching.js\";\nexport {\n  dynamicSystemPromptMiddleware,\n  type DynamicSystemPromptMiddlewareConfig,\n} from \"./dynamicSystemPrompt.js\";\nexport {\n  llmToolSelectorMiddleware,\n  type LLMToolSelectorConfig,\n} from \"./bigTool.js\";\n"],"mappings":""}

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

@@ -1,198 +0,0 @@
-const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
-const require_middleware = require('../middleware.cjs');
-const zod_v3 = require_rolldown_runtime.__toESM(require("zod/v3"));
-
-//#region src/agents/middlewareAgent/middleware/promptCaching.ts
-const DEFAULT_ENABLE_CACHING = true;
-const DEFAULT_TTL = "5m";
-const DEFAULT_MIN_MESSAGES_TO_CACHE = 3;
-const DEFAULT_UNSUPPORTED_MODEL_BEHAVIOR = "warn";
-const contextSchema = zod_v3.z.object({
-	enableCaching: zod_v3.z.boolean().default(DEFAULT_ENABLE_CACHING),
-	ttl: zod_v3.z.enum(["5m", "1h"]).default(DEFAULT_TTL),
-	minMessagesToCache: zod_v3.z.number().default(DEFAULT_MIN_MESSAGES_TO_CACHE),
-	unsupportedModelBehavior: zod_v3.z.enum([
-		"ignore",
-		"warn",
-		"raise"
-	]).default(DEFAULT_UNSUPPORTED_MODEL_BEHAVIOR)
-});
-var PromptCachingMiddlewareError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "PromptCachingMiddlewareError";
-	}
-};
-/**
-* Creates a prompt caching middleware for Anthropic models to optimize API usage.
-*
-* This middleware automatically adds cache control headers to the last messages when using Anthropic models,
-* enabling their prompt caching feature. This can significantly reduce costs for applications with repetitive
-* prompts, long system messages, or extensive conversation histories.
-*
-* ## How It Works
-*
-* The middleware intercepts model requests and adds cache control metadata that tells Anthropic's
-* API to cache processed prompt prefixes. On subsequent requests with matching prefixes, the
-* cached representations are reused, skipping redundant token processing.
-*
-* ## Benefits
-*
-* - **Cost Reduction**: Avoid reprocessing the same tokens repeatedly (up to 90% savings on cached portions)
-* - **Lower Latency**: Cached prompts are processed faster as embeddings are pre-computed
-* - **Better Scalability**: Reduced computational load enables handling more requests
-* - **Consistent Performance**: Stable response times for repetitive queries
-*
-* @param middlewareOptions - Configuration options for the caching behavior
-* @param middlewareOptions.enableCaching - Whether to enable prompt caching (default: `true`)
-* @param middlewareOptions.ttl - Cache time-to-live: `"5m"` for 5 minutes or `"1h"` for 1 hour (default: `"5m"`)
-* @param middlewareOptions.minMessagesToCache - Minimum number of messages required before caching is applied (default: `3`)
-* @param middlewareOptions.unsupportedModelBehavior - The behavior to take when an unsupported model is used (default: `"warn"`)
-*
-* @returns A middleware instance that can be passed to `createAgent`
-*
-* @throws {Error} If used with non-Anthropic models
-*
-* @example
-* Basic usage with default settings
-* ```typescript
-* import { createAgent } from "langchain";
-* import { anthropicPromptCachingMiddleware } from "langchain/middleware";
-*
-* const agent = createAgent({
-*   model: "anthropic:claude-3-5-sonnet",
-*   middleware: [
-*     anthropicPromptCachingMiddleware()
-*   ]
-* });
-* ```
-*
-* @example
-* Custom configuration for longer conversations
-* ```typescript
-* const cachingMiddleware = anthropicPromptCachingMiddleware({
-*   ttl: "1h",  // Cache for 1 hour instead of default 5 minutes
-*   minMessagesToCache: 5  // Only cache after 5 messages
-* });
-*
-* const agent = createAgent({
-*   model: "anthropic:claude-3-5-sonnet",
-*   systemPrompt: "You are a helpful assistant with deep knowledge of...", // Long system prompt
-*   middleware: [cachingMiddleware]
-* });
-* ```
-*
-* @example
-* Conditional caching based on runtime context
-* ```typescript
-* const agent = createAgent({
-*   model: "anthropic:claude-3-5-sonnet",
-*   middleware: [
-*     anthropicPromptCachingMiddleware({
-*       enableCaching: true,
-*       ttl: "5m"
-*     })
-*   ]
-* });
-*
-* // Disable caching for specific requests
-* await agent.invoke(
-*   { messages: [new HumanMessage("Process this without caching")] },
-*   {
-*     configurable: {
-*       middleware_context: { enableCaching: false }
-*     }
-*   }
-* );
-* ```
-*
-* @example
-* Optimal setup for customer support chatbot
-* ```typescript
-* const supportAgent = createAgent({
-*   model: "anthropic:claude-3-5-sonnet",
-*   systemPrompt: `You are a customer support agent for ACME Corp.
-*
-*     Company policies:
-*     - Always be polite and professional
-*     - Refer to knowledge base for product information
-*     - Escalate billing issues to human agents
-*     ... (extensive policies and guidelines)
-*   `,
-*   tools: [searchKnowledgeBase, createTicket, checkOrderStatus],
-*   middleware: [
-*     anthropicPromptCachingMiddleware({
-*       ttl: "1h",  // Long TTL for stable system prompt
-*       minMessagesToCache: 1  // Cache immediately due to large system prompt
-*     })
-*   ]
-* });
-* ```
-*
-* @remarks
-* - **Anthropic Only**: This middleware only works with Anthropic models and will throw an error if used with other providers
-* - **Automatic Application**: Caching is applied automatically when message count exceeds `minMessagesToCache`
-* - **Cache Scope**: Caches are isolated per API key and cannot be shared across different keys
-* - **TTL Options**: Only supports "5m" (5 minutes) and "1h" (1 hour) as TTL values per Anthropic's API
-* - **Best Use Cases**: Long system prompts, multi-turn conversations, repetitive queries, RAG applications
-* - **Cost Impact**: Cached tokens are billed at 10% of the base input token price, cache writes are billed at 25% of the base
-*
-* @see {@link createAgent} for agent creation
-* @see {@link https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching} Anthropic's prompt caching documentation
-* @public
-*/
-function anthropicPromptCachingMiddleware(middlewareOptions) {
-	return require_middleware.createMiddleware({
-		name: "PromptCachingMiddleware",
-		contextSchema,
-		modifyModelRequest: (options, state, runtime) => {
-			/**
-			* If the runtime values match the schema default values, use the middleware option
-			* values otherwise use the runtime values. This allows to apply general configurations
-			* for all invocations, and override them for specific invocations.
-			*/
-			const enableCaching = runtime.context.enableCaching === DEFAULT_ENABLE_CACHING ? middlewareOptions?.enableCaching ?? runtime.context.enableCaching : runtime.context.enableCaching ?? middlewareOptions?.enableCaching;
-			const ttl = runtime.context.ttl === DEFAULT_TTL ? middlewareOptions?.ttl ?? runtime.context.ttl : runtime.context.ttl ?? middlewareOptions?.ttl;
-			const minMessagesToCache = runtime.context.minMessagesToCache === DEFAULT_MIN_MESSAGES_TO_CACHE ? middlewareOptions?.minMessagesToCache ?? runtime.context.minMessagesToCache : runtime.context.minMessagesToCache ?? middlewareOptions?.minMessagesToCache ?? DEFAULT_MIN_MESSAGES_TO_CACHE;
-			const unsupportedModelBehavior = runtime.context.unsupportedModelBehavior === DEFAULT_UNSUPPORTED_MODEL_BEHAVIOR ? middlewareOptions?.unsupportedModelBehavior ?? runtime.context.unsupportedModelBehavior : runtime.context.unsupportedModelBehavior ?? middlewareOptions?.unsupportedModelBehavior;
-			if (!enableCaching || !options.model) return void 0;
-			const isAnthropicModel = options.model.getName() === "ChatAnthropic" || options.model.getName() === "ConfigurableModel" && options.model._defaultConfig?.modelProvider === "anthropic";
-			if (!isAnthropicModel) {
-				const modelName = options.model.getName();
-				const modelInfo = options.model.getName() === "ConfigurableModel" ? `${modelName} (${options.model._defaultConfig?.modelProvider})` : modelName;
-				const baseMessage = `Unsupported model '${modelInfo}'. Prompt caching requires an Anthropic model`;
-				if (unsupportedModelBehavior === "raise") throw new PromptCachingMiddlewareError(`${baseMessage} (e.g., 'anthropic:claude-4-0-sonnet').`);
-				else if (unsupportedModelBehavior === "warn") console.warn(`PromptCachingMiddleware: Skipping caching for ${modelName}. Consider switching to an Anthropic model for caching benefits.`);
-				return void 0;
-			}
-			const messagesCount = state.messages.length + (options.systemPrompt ? 1 : 0);
-			if (messagesCount < minMessagesToCache) return options;
-			/**
-			* Add cache_control to the last message
-			*/
-			const lastMessage = options.messages.at(-1);
-			if (!lastMessage) return options;
-			if (Array.isArray(lastMessage.content)) lastMessage.content = [...lastMessage.content.slice(0, -1), {
-				...lastMessage.content.at(-1),
-				cache_control: {
-					type: "ephemeral",
-					ttl
-				}
-			}];
-			else if (typeof lastMessage.content === "string") lastMessage.content = [{
-				type: "text",
-				text: lastMessage.content,
-				cache_control: {
-					type: "ephemeral",
-					ttl
-				}
-			}];
-			else throw new PromptCachingMiddlewareError("Last message content is not a string or array");
-			return options;
-		}
-	});
-}
-
-//#endregion
-exports.anthropicPromptCachingMiddleware = anthropicPromptCachingMiddleware;
-//# sourceMappingURL=promptCaching.cjs.map