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

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

@@ -1 +1 @@
-{"version":3,"file":"hitl.d.ts","names":["z","contextSchema","ZodString","ZodBoolean","ZodOptional","ZodTypeAny","ZodObject","ZodRecord","ZodDefault","Record","humanInTheLoopMiddleware","input","___types_js0","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/hitl.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\ndeclare const contextSchema: z.ZodObject<{\n    toolConfigs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{\n        requireApproval: z.ZodOptional<z.ZodBoolean>;\n        description: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>>>;\n    messagePrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    toolConfigs: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>;\n    messagePrefix: string;\n}, {\n    toolConfigs?: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    messagePrefix?: string | undefined;\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 * ## 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.toolConfigs - Per-tool configuration mapping tool names to their settings\n * @param options.toolConfigs[toolName].requireApproval - Whether the tool requires human approval\n * @param options.toolConfigs[toolName].description - Custom approval message for the tool\n * @param options.messagePrefix - Default prefix for approval messages (default: \"Tool execution requires approval\")\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 *   toolConfigs: {\n *     \"write_file\": {\n *       requireApproval: true,\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     \"read_file\": {\n *       requireApproval: false  // Safe operation, no approval needed\n *     }\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 { 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 * const state = await agent.graph.getState(config);\n * if (state.next?.length > 0) {\n *   // Get interrupt details\n *   const task = state.tasks?.[0];\n *   const requests = task?.interrupts?.[0]?.value;\n *\n *   // Show tool call details to user\n *   console.log(\"Tool:\", requests[0].action);\n *   console.log(\"Args:\", requests[0].args);\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: \"ignore\" }] })\n *\n * // Provide manual response\n * new Command({\n *   resume: [{\n *     type: \"response\",\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 *   toolConfigs: {\n *     \"execute_sql\": {\n *       requireApproval: true,\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": {\n *       requireApproval: false  // Reading metadata is safe\n *     },\n *     \"delete_records\": {\n *       requireApproval: 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 declare function humanInTheLoopMiddleware(options?: z.input<typeof contextSchema>): import(\"../types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    toolConfigs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{\n        requireApproval: z.ZodOptional<z.ZodBoolean>;\n        description: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>>>;\n    messagePrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    toolConfigs: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>;\n    messagePrefix: string;\n}, {\n    toolConfigs?: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    messagePrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;cAEcC,eAAeD,CAAAA,CAAEM;eACdN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,UAAUP,CAAAA,CAAEE,WAAWF,CAAAA,CAAEM;IAD3CL,eAwBZ,EAtBuBD,CAAAA,CAAEI,WAsBzB,CAtBqCJ,CAAAA,CAAEG,UAsBvC,CAAA;IAAA,WAAA,EArBmBH,CAAAA,CAAEI,WAqBrB,CArBiCJ,CAAAA,CAAEE,SAqBnC,CAAA;EAAA,CAAA,EAvBwCF,OAAEE,EAG5BF,CAAAA,CAAEK,UAH0BH,EAAAA;IACLF,eAAEG,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IAAhBH,WAAEI,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAW,CAAA,EACHJ;IAAdA,eAAEI,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IACPJ,WAAEK,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA,CAH2BL,CAAAA;EAAW,aAAlCO,EAUbP,CAAAA,CAAEQ,UAVWD,CAUAP,CAAAA,CAAEE,SAVFK,CAAAA;CAAS,EAAA,OAAtBC,EAWPR,CAAAA,CAAEK,UAXKG,EAAAA;EAAU,WAUKN,EAEjBO,MAFiBP,CAAAA,MAAAA,EAAAA;IAAfF,eAAEQ,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IACTR,WAAEK,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA;EACD,aAMLI,EAAAA,MAAAA;CAAM,EAAA;EAnBgB,WAAA,CAAA,EAmBtBA,MAnBsB,CAAA,MAAA,EAAA;IAuKhBC,eAAAA,CAAAA,EAAAA,OAAwB,GAAA,SAAA;IAAA,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,CAAA,CAAA,GAA0BT,SAAAA;EAAa,aAA1BU,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;CAAK,CAAA;;;;;;;;;;;;;;;;AAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAxGD,wBAAAA,WAAmCV,CAAAA,CAAEW,aAAaV,iBAA6E,2BAAXD,CAAAA,CAAEM;eAC7HN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,UAAUP,CAAAA,CAAEE,WAAWF,CAAAA,CAAEM;qBAChCN,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;iBACpBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEE;cACrBF,CAAAA,CAAEK;;;;;;;iBAOCL,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEE;YACtBF,CAAAA,CAAEK;eACGI;;;;;;gBAMCA"}
+{"version":3,"file":"hitl.d.ts","names":["z","AIMessage","InferInteropZodInput","AgentBuiltInState","Runtime","ToolConfigSchema","ZodBoolean","ZodOptional","ZodString","ZodUnknown","ZodTuple","ZodFunction","ZodUnion","ZodTypeAny","ZodObject","input","ToolCall","NonNullable","DescriptionFactory","State","Promise","HumanInTheLoopConfig","Omit","ActionRequest","Record","HumanInTheLoopRequest","AcceptPayload","ResponsePayload","EditPayload","HumanInTheLoopMiddlewareHumanResponse","ToolConfig","contextSchema","ZodRecord","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","__index_js2","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/hitl.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { AIMessage } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../types.js\";\ndeclare const ToolConfigSchema: z.ZodObject<{\n    /**\n     * Whether the human can approve the current action without changes\n     */\n    allowAccept: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * Whether the human can reject the current action with feedback\n     */\n    allowEdit: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * Whether the human can approve the current action with edited content\n     */\n    allowRespond: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * The description attached to the request for human input.\n     * Can be either:\n     * - A static string describing the approval request\n     * - A callable that dynamically generates the description based on agent state,\n     *   runtime, and tool call information\n     *\n     * @example\n     * Static string description\n     * ```typescript\n     * const config: ToolConfig = {\n     *   allowAccept: true,\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: ToolConfig = {\n     *   allowAccept: true,\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>]>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowAccept?: boolean | undefined;\n    allowEdit?: boolean | undefined;\n    allowRespond?: boolean | undefined;\n    description?: string | ((...args: unknown[]) => unknown) | undefined;\n}, {\n    allowAccept?: boolean | undefined;\n    allowEdit?: boolean | undefined;\n    allowRespond?: boolean | undefined;\n    description?: string | ((...args: unknown[]) => unknown) | undefined;\n}>;\ntype ToolConfigSchema = z.input<typeof ToolConfigSchema>;\ntype ToolCall = NonNullable<AIMessage[\"tool_calls\"]>[number];\n/**\n * Function type that dynamically generates a description based on agent state,\n * runtime, and tool call information.\n */\nexport type DescriptionFactory<State extends AgentBuiltInState = AgentBuiltInState> = (toolCall: ToolCall, state: State, runtime: Runtime<unknown>) => string | Promise<string>;\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 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 * 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 * Response when a human approves the agent-requested action.\n */\nexport interface AcceptPayload {\n    type: \"accept\";\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 * 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}\nexport type HumanInTheLoopMiddlewareHumanResponse = AcceptPayload | ResponsePayload | EditPayload;\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     * Can be either:\n     * - A static string describing the approval request\n     * - A callable that dynamically generates the description based on agent state,\n     *   runtime, and tool call information\n     */\n    description?: string | DescriptionFactory;\n}\ndeclare const contextSchema: z.ZodObject<{\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.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * Whether the human can approve the current action without changes\n         */\n        allowAccept: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * Whether the human can reject the current action with feedback\n         */\n        allowEdit: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * Whether the human can approve the current action with edited content\n         */\n        allowRespond: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * const config: ToolConfig = {\n         *   allowAccept: true,\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: ToolConfig = {\n         *   allowAccept: true,\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>]>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | ((...args: unknown[]) => unknown) | undefined;\n    }, {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | ((...args: unknown[]) => unknown) | undefined;\n    }>]>>>;\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.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | ((...args: unknown[]) => unknown) | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | ((...args: unknown[]) => unknown) | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>;\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\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\";\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. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\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\";\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\";\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 * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory } from \"langchain\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowAccept: true,\n *       allowEdit: true,\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowAccept: true,\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\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 declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): import(\"./index.js\").AgentMiddleware<undefined, z.ZodObject<{\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.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * Whether the human can approve the current action without changes\n         */\n        allowAccept: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * Whether the human can reject the current action with feedback\n         */\n        allowEdit: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * Whether the human can approve the current action with edited content\n         */\n        allowRespond: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * The description attached to the request for human input.\n         * Can be either:\n         * - A static string describing the approval request\n         * - A callable that dynamically generates the description based on agent state,\n         *   runtime, and tool call information\n         *\n         * @example\n         * Static string description\n         * ```typescript\n         * const config: ToolConfig = {\n         *   allowAccept: true,\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: ToolConfig = {\n         *   allowAccept: true,\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>]>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | ((...args: unknown[]) => unknown) | undefined;\n    }, {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | ((...args: unknown[]) => unknown) | undefined;\n    }>]>>>;\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.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | ((...args: unknown[]) => unknown) | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | ((...args: unknown[]) => unknown) | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":"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"}

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

@@ -1,16 +1,19 @@
 import { createMiddleware } from "../middleware.js";
-import { AIMessage, ToolMessage, isAIMessage } from "@langchain/core/messages";
+import { AIMessage, ToolMessage } from "@langchain/core/messages";
 import { interrupt } from "@langchain/langgraph";
+import { interopParse } from "@langchain/core/utils/types";
 import { z } from "zod/v3";
-import { v4 } from "uuid";
 
 //#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.union([z.string(), z.function()]).optional()
+});
 const contextSchema = z.object({
-	toolConfigs: z.record(z.object({
-		requireApproval: z.boolean().optional(),
-		description: z.string().optional()
-	})).default({}),
-	messagePrefix: z.string().default("Tool execution requires approval")
+	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.
@@ -19,6 +22,37 @@ const contextSchema = 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
@@ -35,28 +69,31 @@ const contextSchema = 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
 *   }
 * });
 *
@@ -70,6 +107,7 @@ const contextSchema = z.object({
 * @example
 * Handling approval requests
 * ```typescript
+* import { type HumanInTheLoopRequest, type Interrupt } from "langchain";
 * import { Command } from "@langchain/langgraph";
 *
 * // Initial agent invocation
@@ -78,15 +116,14 @@ const contextSchema = 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(
@@ -111,12 +148,13 @@ const contextSchema = 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"
 *   }]
 * })
@@ -126,16 +164,16 @@ const contextSchema = 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"
 *     }
 *   },
@@ -143,6 +181,36 @@ const contextSchema = 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
@@ -154,77 +222,115 @@ const contextSchema = z.object({
 * @see {@link Command} for resuming interrupted execution
 * @public
 */
-function humanInTheLoopMiddleware(options = {}) {
+function humanInTheLoopMiddleware(options) {
 	return createMiddleware({
 		name: "HumanInTheLoopMiddleware",
 		contextSchema,
-		afterModel: async (state, runtime, controls) => {
-			const config = {
-				...contextSchema.parse(options),
-				...runtime.context
-			};
+		afterModelJumpTo: ["model"],
+		afterModel: async (state, runtime) => {
+			const config = interopParse(contextSchema, {
+				...options,
+				...runtime.context || {}
+			});
+			if (!config) return;
 			const { messages } = state;
 			if (!messages.length) return;
-			const lastMessage = messages[messages.length - 1];
-			if (!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) => 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 || 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 interrupt(requests);
-			for (let i = 0; i < responses.length; i++) {
-				const response = responses[i];
+			}));
+			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];
-				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 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 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 AIMessage({
-				content: lastMessage.content,
-				tool_calls: approvedToolCalls,
-				id: lastMessage.id
+			/**
+			* 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;
 			});
-			return { messages: [...state.messages.slice(0, -1), updatedMessage] };
+			if (approvedToolCalls.length > 0) return { messages: [...state.messages, ...artificialToolMessages] };
+			return {
+				jumpTo: "model",
+				messages: [...state.messages, ...artificialToolMessages]
+			};
 		}
 	});
 }

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

@@ -1 +1 @@
-{"version":3,"file":"hitl.js","names":["options: z.input<typeof contextSchema>","interruptToolCalls: ToolCall[]","autoApprovedToolCalls: ToolCall[]","normalizedToolCall: ToolCall","uuid","requests: ToolApprovalRequest[]"],"sources":["../../../../src/agents/middlewareAgent/middleware/hitl.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { v4 as uuid } from \"uuid\";\nimport { AIMessage, ToolMessage, isAIMessage } from \"@langchain/core/messages\";\nimport { interrupt } from \"@langchain/langgraph\";\n\nimport { createMiddleware } from \"../middleware.js\";\nimport type { ToolCall } from \"../types.js\";\nimport { HumanResponse } from \"../../interrupt.js\";\n\n/**\n * Interrupt request for tool approval\n */\ninterface ToolApprovalRequest {\n  action: string;\n  args: Record<string, any>;\n  toolCallId: string;\n  description?: string;\n}\n\nconst contextSchema = z.object({\n  toolConfigs: z\n    .record(\n      z.object({\n        requireApproval: z.boolean().optional(),\n        description: z.string().optional(),\n      })\n    )\n    .default({}),\n  messagePrefix: z.string().default(\"Tool execution requires approval\"),\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 * ## 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.toolConfigs - Per-tool configuration mapping tool names to their settings\n * @param options.toolConfigs[toolName].requireApproval - Whether the tool requires human approval\n * @param options.toolConfigs[toolName].description - Custom approval message for the tool\n * @param options.messagePrefix - Default prefix for approval messages (default: \"Tool execution requires approval\")\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 *   toolConfigs: {\n *     \"write_file\": {\n *       requireApproval: true,\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     \"read_file\": {\n *       requireApproval: false  // Safe operation, no approval needed\n *     }\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 { 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 * const state = await agent.graph.getState(config);\n * if (state.next?.length > 0) {\n *   // Get interrupt details\n *   const task = state.tasks?.[0];\n *   const requests = task?.interrupts?.[0]?.value;\n *\n *   // Show tool call details to user\n *   console.log(\"Tool:\", requests[0].action);\n *   console.log(\"Args:\", requests[0].args);\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: \"ignore\" }] })\n *\n * // Provide manual response\n * new Command({\n *   resume: [{\n *     type: \"response\",\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 *   toolConfigs: {\n *     \"execute_sql\": {\n *       requireApproval: true,\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": {\n *       requireApproval: false  // Reading metadata is safe\n *     },\n *     \"delete_records\": {\n *       requireApproval: 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: z.input<typeof contextSchema> = {}\n) {\n  return createMiddleware({\n    name: \"HumanInTheLoopMiddleware\",\n    contextSchema,\n    afterModel: async (state, runtime, controls) => {\n      const config = { ...contextSchema.parse(options), ...runtime.context };\n      const { messages } = state;\n\n      if (!messages.length) {\n        return;\n      }\n\n      const lastMessage = messages[messages.length - 1];\n\n      // Check if it's an AI message with tool calls\n      if (!isAIMessage(lastMessage) || !lastMessage.tool_calls?.length) {\n        return;\n      }\n\n      // Separate tool calls that need interrupts from those that don't\n      const interruptToolCalls: ToolCall[] = [];\n      const autoApprovedToolCalls: ToolCall[] = [];\n\n      for (const toolCall of lastMessage.tool_calls) {\n        // Ensure tool call has an ID\n        const normalizedToolCall: ToolCall = {\n          id: toolCall.id || uuid(),\n          name: toolCall.name,\n          args: toolCall.args,\n        };\n\n        const toolConfig = config.toolConfigs[normalizedToolCall.name];\n\n        if (toolConfig?.requireApproval) {\n          interruptToolCalls.push(normalizedToolCall);\n        } else {\n          autoApprovedToolCalls.push(normalizedToolCall);\n        }\n      }\n\n      // If no interrupts needed, return early\n      if (!interruptToolCalls.length) {\n        return;\n      }\n\n      const approvedToolCalls = [...autoApprovedToolCalls];\n\n      // Process tool calls that need interrupts\n      const requests: ToolApprovalRequest[] = interruptToolCalls.map(\n        (toolCall) => {\n          const toolConfig = config.toolConfigs[toolCall.name];\n          const description =\n            toolConfig?.description ||\n            `${config.messagePrefix}\\n\\nTool: ${\n              toolCall.name\n            }\\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;\n\n          return {\n            action: toolCall.name,\n            args: toolCall.args,\n            toolCallId: toolCall.id,\n            description,\n          };\n        }\n      );\n\n      // Interrupt and wait for human responses\n      const responses = (await interrupt(requests)) as HumanResponse[];\n\n      // Process responses\n      for (let i = 0; i < responses.length; i++) {\n        const response = responses[i];\n        const toolCall = interruptToolCalls[i];\n\n        switch (response.type) {\n          case \"accept\":\n            approvedToolCalls.push(toolCall);\n            break;\n\n          case \"edit\":\n            // For edit, args is an ActionRequest with updated args\n            if (\n              response.args &&\n              typeof response.args === \"object\" &&\n              \"args\" in response.args\n            ) {\n              approvedToolCalls.push({\n                ...toolCall,\n                args: (\n                  response.args as { action: string; args: Record<string, any> }\n                ).args,\n              });\n            }\n            break;\n\n          case \"ignore\":\n            // Skip to end - terminate the agent\n            return controls.terminate();\n\n          case \"response\": {\n            // Return manual tool response and jump back to model\n            // For response, args is a string\n            const toolMessage = new ToolMessage({\n              content: typeof response.args === \"string\" ? response.args : \"\",\n              tool_call_id: toolCall.id,\n            });\n            return {\n              messages: [...state.messages, toolMessage],\n              jump_to: \"model\",\n            };\n          }\n          default:\n            throw new Error(`Unknown response type: ${(response as any).type}`);\n        }\n      }\n\n      // Update the last message with approved tool calls\n      const updatedMessage = new AIMessage({\n        content: lastMessage.content,\n        tool_calls: approvedToolCalls,\n        id: lastMessage.id,\n      });\n\n      // Replace the last message with the updated one\n      return {\n        messages: [...state.messages.slice(0, -1), updatedMessage],\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;;AAoBA,MAAM,gBAAgB,EAAE,OAAO;CAC7B,aAAa,EACV,OACC,EAAE,OAAO;EACP,iBAAiB,EAAE,SAAS,CAAC,UAAU;EACvC,aAAa,EAAE,QAAQ,CAAC,UAAU;CACnC,EAAC,CACH,CACA,QAAQ,CAAE,EAAC;CACd,eAAe,EAAE,QAAQ,CAAC,QAAQ,mCAAmC;AACtE,EAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgJF,SAAgB,yBACdA,UAAyC,CAAE,GAC3C;AACA,QAAO,iBAAiB;EACtB,MAAM;EACN;EACA,YAAY,OAAO,OAAO,SAAS,aAAa;GAC9C,MAAM,SAAS;IAAE,GAAG,cAAc,MAAM,QAAQ;IAAE,GAAG,QAAQ;GAAS;GACtE,MAAM,EAAE,UAAU,GAAG;AAErB,OAAI,CAAC,SAAS,OACZ;GAGF,MAAM,cAAc,SAAS,SAAS,SAAS;AAG/C,OAAI,CAAC,YAAY,YAAY,IAAI,CAAC,YAAY,YAAY,OACxD;GAIF,MAAMC,qBAAiC,CAAE;GACzC,MAAMC,wBAAoC,CAAE;AAE5C,QAAK,MAAM,YAAY,YAAY,YAAY;IAE7C,MAAMC,qBAA+B;KACnC,IAAI,SAAS,MAAMC,IAAM;KACzB,MAAM,SAAS;KACf,MAAM,SAAS;IAChB;IAED,MAAM,aAAa,OAAO,YAAY,mBAAmB;AAEzD,QAAI,YAAY,iBACd,mBAAmB,KAAK,mBAAmB;SAE3C,sBAAsB,KAAK,mBAAmB;GAEjD;AAGD,OAAI,CAAC,mBAAmB,OACtB;GAGF,MAAM,oBAAoB,CAAC,GAAG,qBAAsB;GAGpD,MAAMC,WAAkC,mBAAmB,IACzD,CAAC,aAAa;IACZ,MAAM,aAAa,OAAO,YAAY,SAAS;IAC/C,MAAM,cACJ,YAAY,eACZ,GAAG,OAAO,cAAc,UAAU,EAChC,SAAS,KACV,QAAQ,EAAE,KAAK,UAAU,SAAS,MAAM,MAAM,EAAE,EAAE;AAErD,WAAO;KACL,QAAQ,SAAS;KACjB,MAAM,SAAS;KACf,YAAY,SAAS;KACrB;IACD;GACF,EACF;GAGD,MAAM,YAAa,MAAM,UAAU,SAAS;AAG5C,QAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;IACzC,MAAM,WAAW,UAAU;IAC3B,MAAM,WAAW,mBAAmB;AAEpC,YAAQ,SAAS,MAAjB;KACE,KAAK;MACH,kBAAkB,KAAK,SAAS;AAChC;KAEF,KAAK;AAEH,UACE,SAAS,QACT,OAAO,SAAS,SAAS,YACzB,UAAU,SAAS,MAEnB,kBAAkB,KAAK;OACrB,GAAG;OACH,MACE,SAAS,KACT;MACH,EAAC;AAEJ;KAEF,KAAK,SAEH,QAAO,SAAS,WAAW;KAE7B,KAAK,YAAY;MAGf,MAAM,cAAc,IAAI,YAAY;OAClC,SAAS,OAAO,SAAS,SAAS,WAAW,SAAS,OAAO;OAC7D,cAAc,SAAS;MACxB;AACD,aAAO;OACL,UAAU,CAAC,GAAG,MAAM,UAAU,WAAY;OAC1C,SAAS;MACV;KACF;KACD,QACE,OAAM,IAAI,MAAM,CAAC,uBAAuB,EAAG,SAAiB,MAAM;IACrE;GACF;GAGD,MAAM,iBAAiB,IAAI,UAAU;IACnC,SAAS,YAAY;IACrB,YAAY;IACZ,IAAI,YAAY;GACjB;AAGD,UAAO,EACL,UAAU,CAAC,GAAG,MAAM,SAAS,MAAM,GAAG,GAAG,EAAE,cAAe,EAC3D;EACF;CACF,EAAC;AACH"}
+{"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\";\nimport type { AgentBuiltInState, Runtime } from \"../types.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   * Can be either:\n   * - A static string describing the approval request\n   * - A callable that dynamically generates the description based on agent state,\n   *   runtime, and tool call information\n   *\n   * @example\n   * Static string description\n   * ```typescript\n   * const config: ToolConfig = {\n   *   allowAccept: true,\n   *   description: \"Please review this tool execution\"\n   * };\n   * ```\n   *\n   * @example\n   * Dynamic callable description\n   * ```typescript\n   * const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {\n   *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n   * };\n   *\n   * const config: ToolConfig = {\n   *   allowAccept: true,\n   *   description: formatToolDescription\n   * };\n   * ```\n   */\n  description: z.union([z.string(), z.function()]).optional(),\n});\n\ntype ToolConfigSchema = z.input<typeof ToolConfigSchema>;\ntype ToolCall = NonNullable<AIMessage[\"tool_calls\"]>[number];\n\n/**\n * Function type that dynamically generates a description based on agent state,\n * runtime, and tool call information.\n */\nexport type DescriptionFactory<\n  State extends AgentBuiltInState = AgentBuiltInState\n> = (\n  toolCall: ToolCall,\n  state: State,\n  runtime: Runtime<unknown>\n) => string | Promise<string>;\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   * Can be either:\n   * - A static string describing the approval request\n   * - A callable that dynamically generates the description based on agent state,\n   *   runtime, and tool call information\n   */\n  description?: string | DescriptionFactory;\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\";\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. Can be either a static string or a callable that dynamically generates the description based on agent state, runtime, and tool call information\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\";\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\";\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 * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory } from \"langchain\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n * };\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"write_file\": {\n *       allowAccept: true,\n *       allowEdit: true,\n *       // Use dynamic description that can access tool call, state, and runtime\n *       description: formatToolDescription\n *     },\n *     // Or use an inline function\n *     \"send_email\": {\n *       allowAccept: true,\n *       description: (toolCall, state, runtime) => {\n *         const { to, subject } = toolCall.args;\n *         return `Email to ${to}\\nSubject: ${subject}\\n\\nRequires approval before sending`;\n *       }\n *     }\n *   }\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 as 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[] = await Promise.all(\n        interruptToolCalls.map(async (toolCall) => {\n          const toolConfig = resolvedToolConfigs[toolCall.name]!;\n          const description = toolConfig.description\n            ? typeof toolConfig.description === \"function\"\n              ? /**\n                 * If description is a function, call it with the required parameters\n                 */\n                await toolConfig.description(toolCall, state, runtime)\n              : /**\n                 * Otherwise, use the static string\n                 */\n                toolConfig.description\n            : /**\n               * Fall back to the default description\n               */\n              `${config.descriptionPrefix}\\n\\nTool: ${\n                toolCall.name\n              }\\nArgs: ${JSON.stringify(toolCall.args, null, 2)}`;\n\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,26 +1,52 @@
 const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_utils = require('./utils.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_llmToolSelector = require('./llmToolSelector.cjs');
+const require_piiRedaction = require('./piiRedaction.cjs');
+const require_contextEditing = require('./contextEditing.cjs');
+const require_toolCallLimit = require('./toolCallLimit.cjs');
+const require_callLimit = require('./callLimit.cjs');
+const require_modelFallback = require('./modelFallback.cjs');
 
 //#region src/agents/middlewareAgent/middleware/index.ts
 var middleware_exports = {};
 require_rolldown_runtime.__export(middleware_exports, {
+	ClearToolUsesEdit: () => require_contextEditing.ClearToolUsesEdit,
+	ToolCallLimitExceededError: () => require_toolCallLimit.ToolCallLimitExceededError,
 	anthropicPromptCachingMiddleware: () => require_promptCaching.anthropicPromptCachingMiddleware,
-	countTokensApproximately: () => require_summarization.countTokensApproximately,
+	contextEditingMiddleware: () => require_contextEditing.contextEditingMiddleware,
+	countTokensApproximately: () => require_utils.countTokensApproximately,
+	dynamicSystemPromptMiddleware: () => require_dynamicSystemPrompt.dynamicSystemPromptMiddleware,
 	humanInTheLoopMiddleware: () => require_hitl.humanInTheLoopMiddleware,
-	summarizationMiddleware: () => require_summarization.summarizationMiddleware
+	llmToolSelectorMiddleware: () => require_llmToolSelector.llmToolSelectorMiddleware,
+	modelCallLimitMiddleware: () => require_callLimit.modelCallLimitMiddleware,
+	modelFallbackMiddleware: () => require_modelFallback.modelFallbackMiddleware,
+	piiRedactionMiddleware: () => require_piiRedaction.piiRedactionMiddleware,
+	summarizationMiddleware: () => require_summarization.summarizationMiddleware,
+	toolCallLimitMiddleware: () => require_toolCallLimit.toolCallLimitMiddleware
 });
 
 //#endregion
+exports.ClearToolUsesEdit = require_contextEditing.ClearToolUsesEdit;
+exports.ToolCallLimitExceededError = require_toolCallLimit.ToolCallLimitExceededError;
 exports.anthropicPromptCachingMiddleware = require_promptCaching.anthropicPromptCachingMiddleware;
-exports.countTokensApproximately = require_summarization.countTokensApproximately;
+exports.contextEditingMiddleware = require_contextEditing.contextEditingMiddleware;
+exports.countTokensApproximately = require_utils.countTokensApproximately;
+exports.dynamicSystemPromptMiddleware = require_dynamicSystemPrompt.dynamicSystemPromptMiddleware;
 exports.humanInTheLoopMiddleware = require_hitl.humanInTheLoopMiddleware;
+exports.llmToolSelectorMiddleware = require_llmToolSelector.llmToolSelectorMiddleware;
 Object.defineProperty(exports, 'middleware_exports', {
   enumerable: true,
   get: function () {
     return middleware_exports;
   }
 });
+exports.modelCallLimitMiddleware = require_callLimit.modelCallLimitMiddleware;
+exports.modelFallbackMiddleware = require_modelFallback.modelFallbackMiddleware;
+exports.piiRedactionMiddleware = require_piiRedaction.piiRedactionMiddleware;
 exports.summarizationMiddleware = require_summarization.summarizationMiddleware;
+exports.toolCallLimitMiddleware = require_toolCallLimit.toolCallLimitMiddleware;
 //# sourceMappingURL=index.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../../../src/agents/middlewareAgent/middleware/index.ts"],"sourcesContent":["export {\n  summarizationMiddleware,\n  countTokensApproximately,\n} from \"./summarization.js\";\nexport { humanInTheLoopMiddleware } from \"./hitl.js\";\nexport { anthropicPromptCachingMiddleware } from \"./promptCaching.js\";\n"],"mappings":""}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../../src/agents/middlewareAgent/middleware/index.ts"],"sourcesContent":["export {\n  summarizationMiddleware,\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 \"./llmToolSelector.js\";\nexport {\n  piiRedactionMiddleware,\n  type PIIRedactionMiddlewareConfig,\n} from \"./piiRedaction.js\";\nexport {\n  contextEditingMiddleware,\n  ClearToolUsesEdit,\n  type ContextEditingMiddlewareConfig,\n  type ContextEdit,\n  type ClearToolUsesEditConfig,\n  type TokenCounter,\n} from \"./contextEditing.js\";\nexport {\n  toolCallLimitMiddleware,\n  ToolCallLimitExceededError,\n  type ToolCallLimitConfig,\n} from \"./toolCallLimit.js\";\nexport {\n  modelCallLimitMiddleware,\n  type ModelCallLimitMiddlewareConfig,\n} from \"./callLimit.js\";\nexport { modelFallbackMiddleware } from \"./modelFallback.js\";\nexport { type AgentMiddleware } from \"../types.js\";\nexport { countTokensApproximately } from \"./utils.js\";\n"],"mappings":""}