langchain 1.0.1 → 1.0.3

package/dist/agents/middleware/contextEditing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextEditing.d.ts","names":["BaseMessage","TokenCounter","Promise","ContextEdit","ClearToolUsesEditConfig","ClearToolUsesEdit","Set","ContextEditingMiddlewareConfig","contextEditingMiddleware","__types_js10","AgentMiddleware"],"sources":["../../../src/agents/middleware/contextEditing.d.ts"],"sourcesContent":["/**\n * Context editing middleware.\n *\n * This middleware mirrors Anthropic's context editing capabilities by clearing\n * older tool results once the conversation grows beyond a configurable token\n * threshold. The implementation is intentionally model-agnostic so it can be used\n * with any LangChain chat model.\n */\nimport type { BaseMessage } from \"@langchain/core/messages\";\n/**\n * Function type for counting tokens in a sequence of messages.\n */\nexport type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;\n/**\n * Protocol describing a context editing strategy.\n *\n * Implement this interface to create custom strategies for managing\n * conversation context size. The `apply` method should modify the\n * messages array in-place and return the updated token count.\n *\n * @example\n * ```ts\n * import { SystemMessage } from \"langchain\";\n *\n * class RemoveOldSystemMessages implements ContextEdit {\n *   async apply({ tokens, messages, countTokens }) {\n *     // Remove old system messages if over limit\n *     if (tokens > 50000) {\n *       messages = messages.filter(SystemMessage.isInstance);\n *       return await countTokens(messages);\n *     }\n *     return tokens;\n *   }\n * }\n * ```\n */\nexport interface ContextEdit {\n    /**\n     * Apply an edit to the message list, returning the new token count.\n     *\n     * This method should:\n     * 1. Check if editing is needed based on `tokens` parameter\n     * 2. Modify the `messages` array in-place (if needed)\n     * 3. Return the new token count after modifications\n     *\n     * @param params - Parameters for the editing operation\n     * @returns The updated token count after applying edits\n     */\n    apply(params: {\n        /**\n         * Current token count of all messages\n         */\n        tokens: number;\n        /**\n         * Array of messages to potentially edit (modify in-place)\n         */\n        messages: BaseMessage[];\n        /**\n         * Function to count tokens in a message array\n         */\n        countTokens: TokenCounter;\n    }): number | Promise<number>;\n}\n/**\n * Configuration for clearing tool outputs when token limits are exceeded.\n */\nexport interface ClearToolUsesEditConfig {\n    /**\n     * Token count that triggers the edit.\n     * @default 100000\n     */\n    triggerTokens?: number;\n    /**\n     * Minimum number of tokens to reclaim when the edit runs.\n     * @default 0\n     */\n    clearAtLeast?: number;\n    /**\n     * Number of most recent tool results that must be preserved.\n     * @default 3\n     */\n    keep?: number;\n    /**\n     * Whether to clear the originating tool call parameters on the AI message.\n     * @default false\n     */\n    clearToolInputs?: boolean;\n    /**\n     * List of tool names to exclude from clearing.\n     * @default []\n     */\n    excludeTools?: string[];\n    /**\n     * Placeholder text inserted for cleared tool outputs.\n     * @default \"[cleared]\"\n     */\n    placeholder?: string;\n}\n/**\n * Strategy for clearing tool outputs when token limits are exceeded.\n *\n * This strategy mirrors Anthropic's `clear_tool_uses_20250919` behavior by\n * replacing older tool results with a placeholder text when the conversation\n * grows too large. It preserves the most recent tool results and can exclude\n * specific tools from being cleared.\n *\n * @example\n * ```ts\n * import { ClearToolUsesEdit } from \"langchain\";\n *\n * const edit = new ClearToolUsesEdit({\n *   triggerTokens: 100000,       // Start clearing at 100K tokens\n *   clearAtLeast: 0,             // Clear as much as needed\n *   keep: 3,                     // Always keep 3 most recent results\n *   excludeTools: [\"important\"], // Never clear \"important\" tool\n *   clearToolInputs: false,      // Keep tool call arguments\n *   placeholder: \"[cleared]\",    // Replacement text\n * });\n * ```\n */\nexport declare class ClearToolUsesEdit implements ContextEdit {\n    #private;\n    triggerTokens: number;\n    clearAtLeast: number;\n    keep: number;\n    clearToolInputs: boolean;\n    excludeTools: Set<string>;\n    placeholder: string;\n    constructor(config?: ClearToolUsesEditConfig);\n    apply(params: {\n        tokens: number;\n        messages: BaseMessage[];\n        countTokens: TokenCounter;\n    }): Promise<number>;\n}\n/**\n * Configuration for the Context Editing Middleware.\n */\nexport interface ContextEditingMiddlewareConfig {\n    /**\n     * Sequence of edit strategies to apply. Defaults to a single\n     * ClearToolUsesEdit mirroring Anthropic defaults.\n     */\n    edits?: ContextEdit[];\n    /**\n     * Whether to use approximate token counting (faster, less accurate)\n     * or exact counting implemented by the chat model (potentially slower, more accurate).\n     * Currently only OpenAI models support exact counting.\n     * @default \"approx\"\n     */\n    tokenCountMethod?: \"approx\" | \"model\";\n}\n/**\n * Middleware that automatically prunes tool results to manage context size.\n *\n * This middleware applies a sequence of edits when the total input token count\n * exceeds configured thresholds. By default, it uses the `ClearToolUsesEdit` strategy\n * which mirrors Anthropic's `clear_tool_uses_20250919` behaviour by clearing older\n * tool results once the conversation exceeds 100,000 tokens.\n *\n * ## Basic Usage\n *\n * Use the middleware with default settings to automatically manage context:\n *\n * @example Basic usage with defaults\n * ```ts\n * import { contextEditingMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   tools: [searchTool, calculatorTool],\n *   middleware: [\n *     contextEditingMiddleware(),\n *   ],\n * });\n * ```\n *\n * The default configuration:\n * - Triggers when context exceeds **100,000 tokens**\n * - Keeps the **3 most recent** tool results\n * - Uses **approximate token counting** (fast)\n * - Does not clear tool call arguments\n *\n * ## Custom Configuration\n *\n * Customize the clearing behavior with `ClearToolUsesEdit`:\n *\n * @example Custom ClearToolUsesEdit configuration\n * ```ts\n * import { contextEditingMiddleware, ClearToolUsesEdit } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   tools: [searchTool, calculatorTool],\n *   middleware: [\n *     contextEditingMiddleware({\n *       edits: [\n *         new ClearToolUsesEdit({\n *           triggerTokens: 50000,      // Clear when exceeding 50K tokens\n *           clearAtLeast: 1000,         // Reclaim at least 1K tokens\n *           keep: 5,                    // Keep 5 most recent tool results\n *           excludeTools: [\"search\"],   // Never clear search results\n *           clearToolInputs: true,      // Also clear tool call arguments\n *         }),\n *       ],\n *       tokenCountMethod: \"approx\",     // Use approximate counting (or \"model\")\n *     }),\n *   ],\n * });\n * ```\n *\n * ## Custom Editing Strategies\n *\n * Implement your own context editing strategy by creating a class that\n * implements the `ContextEdit` interface:\n *\n * @example Custom editing strategy\n * ```ts\n * import { contextEditingMiddleware, type ContextEdit, type TokenCounter } from \"langchain\";\n * import type { BaseMessage } from \"@langchain/core/messages\";\n *\n * class CustomEdit implements ContextEdit {\n *   async apply(params: {\n *     tokens: number;\n *     messages: BaseMessage[];\n *     countTokens: TokenCounter;\n *   }): Promise<number> {\n *     // Implement your custom editing logic here\n *     // and apply it to the messages array, then\n *     // return the new token count after edits\n *     return countTokens(messages);\n *   }\n * }\n * ```\n *\n * @param config - Configuration options for the middleware\n * @returns A middleware instance that can be used with `createAgent`\n */\nexport declare function contextEditingMiddleware(config?: ContextEditingMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;AAoCA;;;AAwBqBC,KAhDTA,YAAAA,GAgDSA,CAAAA,QAAAA,EAhDiBD,WAgDjBC,EAAAA,EAAAA,GAAAA,MAAAA,GAhD4CC,OAgD5CD,CAAAA,MAAAA,CAAAA;;AACG;AAKxB;AAsDA;;;;;;;;AAA6D;AAkB7D;AAqGA;;;;AAA+H;;;;;;UA3M9GE,WAAAA;;;;;;;;;;;;;;;;;;;;cAoBCH;;;;iBAIGC;eACJC;;;;;UAKAE,uBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsDIC,iBAAAA,YAA6BF;;;;;;gBAMhCG;;uBAEOF;;;cAGPJ;iBACGC;MACbC;;;;;UAKSK,8BAAAA;;;;;UAKLJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgGYK,wBAAAA,UAAkCD,iCAA8B"}
+{"version":3,"file":"contextEditing.d.ts","names":["BaseMessage","TokenCounter","Promise","ContextEdit","ClearToolUsesEditConfig","ClearToolUsesEdit","Set","ContextEditingMiddlewareConfig","contextEditingMiddleware","__types_js4","AgentMiddleware"],"sources":["../../../src/agents/middleware/contextEditing.d.ts"],"sourcesContent":["/**\n * Context editing middleware.\n *\n * This middleware mirrors Anthropic's context editing capabilities by clearing\n * older tool results once the conversation grows beyond a configurable token\n * threshold. The implementation is intentionally model-agnostic so it can be used\n * with any LangChain chat model.\n */\nimport type { BaseMessage } from \"@langchain/core/messages\";\n/**\n * Function type for counting tokens in a sequence of messages.\n */\nexport type TokenCounter = (messages: BaseMessage[]) => number | Promise<number>;\n/**\n * Protocol describing a context editing strategy.\n *\n * Implement this interface to create custom strategies for managing\n * conversation context size. The `apply` method should modify the\n * messages array in-place and return the updated token count.\n *\n * @example\n * ```ts\n * import { SystemMessage } from \"langchain\";\n *\n * class RemoveOldSystemMessages implements ContextEdit {\n *   async apply({ tokens, messages, countTokens }) {\n *     // Remove old system messages if over limit\n *     if (tokens > 50000) {\n *       messages = messages.filter(SystemMessage.isInstance);\n *       return await countTokens(messages);\n *     }\n *     return tokens;\n *   }\n * }\n * ```\n */\nexport interface ContextEdit {\n    /**\n     * Apply an edit to the message list, returning the new token count.\n     *\n     * This method should:\n     * 1. Check if editing is needed based on `tokens` parameter\n     * 2. Modify the `messages` array in-place (if needed)\n     * 3. Return the new token count after modifications\n     *\n     * @param params - Parameters for the editing operation\n     * @returns The updated token count after applying edits\n     */\n    apply(params: {\n        /**\n         * Current token count of all messages\n         */\n        tokens: number;\n        /**\n         * Array of messages to potentially edit (modify in-place)\n         */\n        messages: BaseMessage[];\n        /**\n         * Function to count tokens in a message array\n         */\n        countTokens: TokenCounter;\n    }): number | Promise<number>;\n}\n/**\n * Configuration for clearing tool outputs when token limits are exceeded.\n */\nexport interface ClearToolUsesEditConfig {\n    /**\n     * Token count that triggers the edit.\n     * @default 100000\n     */\n    triggerTokens?: number;\n    /**\n     * Minimum number of tokens to reclaim when the edit runs.\n     * @default 0\n     */\n    clearAtLeast?: number;\n    /**\n     * Number of most recent tool results that must be preserved.\n     * @default 3\n     */\n    keep?: number;\n    /**\n     * Whether to clear the originating tool call parameters on the AI message.\n     * @default false\n     */\n    clearToolInputs?: boolean;\n    /**\n     * List of tool names to exclude from clearing.\n     * @default []\n     */\n    excludeTools?: string[];\n    /**\n     * Placeholder text inserted for cleared tool outputs.\n     * @default \"[cleared]\"\n     */\n    placeholder?: string;\n}\n/**\n * Strategy for clearing tool outputs when token limits are exceeded.\n *\n * This strategy mirrors Anthropic's `clear_tool_uses_20250919` behavior by\n * replacing older tool results with a placeholder text when the conversation\n * grows too large. It preserves the most recent tool results and can exclude\n * specific tools from being cleared.\n *\n * @example\n * ```ts\n * import { ClearToolUsesEdit } from \"langchain\";\n *\n * const edit = new ClearToolUsesEdit({\n *   triggerTokens: 100000,       // Start clearing at 100K tokens\n *   clearAtLeast: 0,             // Clear as much as needed\n *   keep: 3,                     // Always keep 3 most recent results\n *   excludeTools: [\"important\"], // Never clear \"important\" tool\n *   clearToolInputs: false,      // Keep tool call arguments\n *   placeholder: \"[cleared]\",    // Replacement text\n * });\n * ```\n */\nexport declare class ClearToolUsesEdit implements ContextEdit {\n    #private;\n    triggerTokens: number;\n    clearAtLeast: number;\n    keep: number;\n    clearToolInputs: boolean;\n    excludeTools: Set<string>;\n    placeholder: string;\n    constructor(config?: ClearToolUsesEditConfig);\n    apply(params: {\n        tokens: number;\n        messages: BaseMessage[];\n        countTokens: TokenCounter;\n    }): Promise<number>;\n}\n/**\n * Configuration for the Context Editing Middleware.\n */\nexport interface ContextEditingMiddlewareConfig {\n    /**\n     * Sequence of edit strategies to apply. Defaults to a single\n     * ClearToolUsesEdit mirroring Anthropic defaults.\n     */\n    edits?: ContextEdit[];\n    /**\n     * Whether to use approximate token counting (faster, less accurate)\n     * or exact counting implemented by the chat model (potentially slower, more accurate).\n     * Currently only OpenAI models support exact counting.\n     * @default \"approx\"\n     */\n    tokenCountMethod?: \"approx\" | \"model\";\n}\n/**\n * Middleware that automatically prunes tool results to manage context size.\n *\n * This middleware applies a sequence of edits when the total input token count\n * exceeds configured thresholds. By default, it uses the `ClearToolUsesEdit` strategy\n * which mirrors Anthropic's `clear_tool_uses_20250919` behaviour by clearing older\n * tool results once the conversation exceeds 100,000 tokens.\n *\n * ## Basic Usage\n *\n * Use the middleware with default settings to automatically manage context:\n *\n * @example Basic usage with defaults\n * ```ts\n * import { contextEditingMiddleware } from \"langchain\";\n * import { createAgent } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   tools: [searchTool, calculatorTool],\n *   middleware: [\n *     contextEditingMiddleware(),\n *   ],\n * });\n * ```\n *\n * The default configuration:\n * - Triggers when context exceeds **100,000 tokens**\n * - Keeps the **3 most recent** tool results\n * - Uses **approximate token counting** (fast)\n * - Does not clear tool call arguments\n *\n * ## Custom Configuration\n *\n * Customize the clearing behavior with `ClearToolUsesEdit`:\n *\n * @example Custom ClearToolUsesEdit configuration\n * ```ts\n * import { contextEditingMiddleware, ClearToolUsesEdit } from \"langchain\";\n *\n * const agent = createAgent({\n *   model: \"anthropic:claude-3-5-sonnet\",\n *   tools: [searchTool, calculatorTool],\n *   middleware: [\n *     contextEditingMiddleware({\n *       edits: [\n *         new ClearToolUsesEdit({\n *           triggerTokens: 50000,      // Clear when exceeding 50K tokens\n *           clearAtLeast: 1000,         // Reclaim at least 1K tokens\n *           keep: 5,                    // Keep 5 most recent tool results\n *           excludeTools: [\"search\"],   // Never clear search results\n *           clearToolInputs: true,      // Also clear tool call arguments\n *         }),\n *       ],\n *       tokenCountMethod: \"approx\",     // Use approximate counting (or \"model\")\n *     }),\n *   ],\n * });\n * ```\n *\n * ## Custom Editing Strategies\n *\n * Implement your own context editing strategy by creating a class that\n * implements the `ContextEdit` interface:\n *\n * @example Custom editing strategy\n * ```ts\n * import { contextEditingMiddleware, type ContextEdit, type TokenCounter } from \"langchain\";\n * import type { BaseMessage } from \"@langchain/core/messages\";\n *\n * class CustomEdit implements ContextEdit {\n *   async apply(params: {\n *     tokens: number;\n *     messages: BaseMessage[];\n *     countTokens: TokenCounter;\n *   }): Promise<number> {\n *     // Implement your custom editing logic here\n *     // and apply it to the messages array, then\n *     // return the new token count after edits\n *     return countTokens(messages);\n *   }\n * }\n * ```\n *\n * @param config - Configuration options for the middleware\n * @returns A middleware instance that can be used with `createAgent`\n */\nexport declare function contextEditingMiddleware(config?: ContextEditingMiddlewareConfig): import(\"./types.js\").AgentMiddleware<undefined, undefined, any>;\n"],"mappings":";;;;;AAoCA;;;AAwBqBC,KAhDTA,YAAAA,GAgDSA,CAAAA,QAAAA,EAhDiBD,WAgDjBC,EAAAA,EAAAA,GAAAA,MAAAA,GAhD4CC,OAgD5CD,CAAAA,MAAAA,CAAAA;;AACG;AAKxB;AAsDA;;;;;;;;AAA6D;AAkB7D;AAqGA;;;;AAA+H;;;;;;UA3M9GE,WAAAA;;;;;;;;;;;;;;;;;;;;cAoBCH;;;;iBAIGC;eACJC;;;;;UAKAE,uBAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsDIC,iBAAAA,YAA6BF;;;;;;gBAMhCG;;uBAEOF;;;cAGPJ;iBACGC;MACbC;;;;;UAKSK,8BAAAA;;;;;UAKLJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgGYK,wBAAAA,UAAkCD,iCAA8B"}

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

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

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

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

package/dist/agents/middleware/hitl.cjs

@@ -380,6 +380,7 @@ function humanInTheLoopMiddleware(options) {
 				if (decisions.length !== interruptToolCalls.length) throw new Error(`Number of human decisions (${decisions.length}) does not match number of hanging tool calls (${interruptToolCalls.length}).`);
 				const revisedToolCalls = [...autoApprovedToolCalls];
 				const artificialToolMessages = [];
+				const hasRejectedToolCalls = decisions.some((decision) => decision.type === "reject");
 				/**
 				* Process each decision using helper method
 				*/
@@ -388,14 +389,18 @@ function humanInTheLoopMiddleware(options) {
 					const toolCall = interruptToolCalls[i];
 					const interruptConfig = resolvedConfigs[toolCall.name];
 					const { revisedToolCall, toolMessage } = processDecision(decision, toolCall, interruptConfig);
-					if (revisedToolCall) revisedToolCalls.push(revisedToolCall);
+					if (revisedToolCall && (!hasRejectedToolCalls || decision.type === "reject")) revisedToolCalls.push(revisedToolCall);
 					if (toolMessage) artificialToolMessages.push(toolMessage);
 				}
 				/**
 				* Update the AI message to only include approved tool calls
 				*/
 				if (__langchain_core_messages.AIMessage.isInstance(lastMessage)) lastMessage.tool_calls = revisedToolCalls;
-				return { messages: [lastMessage, ...artificialToolMessages] };
+				const jumpTo = hasRejectedToolCalls ? "model" : void 0;
+				return {
+					messages: [lastMessage, ...artificialToolMessages],
+					jumpTo
+				};
 			}
 		}
 	});

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

@@ -1 +1 @@
-{"version":3,"file":"hitl.cjs","names":["z","options: NonNullable<HumanInTheLoopMiddlewareConfig>","toolCall: ToolCall","config: InterruptOnConfig","state: AgentBuiltInState","runtime: Runtime<unknown>","description: string","actionRequest: ActionRequest","reviewConfig: ReviewConfig","decision: Decision","ToolMessage","createMiddleware","AIMessage","resolvedConfigs: Record<string, InterruptOnConfig>","interruptToolCalls: ToolCall[]","autoApprovedToolCalls: ToolCall[]","actionRequests: ActionRequest[]","reviewConfigs: ReviewConfig[]","hitlRequest: HITLRequest","revisedToolCalls: ToolCall[]","artificialToolMessages: ToolMessage[]"],"sources":["../../../src/agents/middleware/hitl.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { AIMessage, ToolMessage, ToolCall } 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 \"../runtime.js\";\n\nconst DescriptionFunctionSchema = z\n  .function()\n  .args(\n    z.custom<ToolCall>(), // toolCall\n    z.custom<AgentBuiltInState>(), // state\n    z.custom<Runtime<unknown>>() // runtime\n  )\n  .returns(z.union([z.string(), z.promise(z.string())]));\n\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\n\n/**\n * The type of decision a human can make.\n */\nconst ALLOWED_DECISIONS = [\"approve\", \"edit\", \"reject\"] as const;\nconst DecisionType = z.enum(ALLOWED_DECISIONS);\nexport type DecisionType = z.infer<typeof DecisionType>;\n\nconst InterruptOnConfigSchema = z.object({\n  /**\n   * The decisions that are allowed for this action.\n   */\n  allowedDecisions: z.array(DecisionType),\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   * import type { InterruptOnConfig } from \"langchain\";\n   *\n   * const config: InterruptOnConfig = {\n   *   allowedDecisions: [\"approve\", \"reject\"],\n   *   description: \"Please review this tool execution\"\n   * };\n   * ```\n   *\n   * @example\n   * Dynamic callable description\n   * ```typescript\n   * import type {\n   *   AgentBuiltInState,\n   *   Runtime,\n   *   DescriptionFactory,\n   *   ToolCall,\n   *   InterruptOnConfig\n   * } from \"langchain\";\n   *\n   * const formatToolDescription: DescriptionFactory = (\n   *   toolCall: ToolCall,\n   *   state: AgentBuiltInState,\n   *   runtime: Runtime<unknown>\n   * ) => {\n   *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n   * };\n   *\n   * const config: InterruptOnConfig = {\n   *   allowedDecisions: [\"approve\", \"edit\"],\n   *   description: formatToolDescription\n   * };\n   * ```\n   */\n  description: z.union([z.string(), DescriptionFunctionSchema]).optional(),\n  /**\n   * JSON schema for the arguments associated with the action, if edits are allowed.\n   */\n  argsSchema: z.record(z.any()).optional(),\n});\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n  /**\n   * The type or name of action being requested (e.g., \"add_numbers\").\n   */\n  name: string;\n  /**\n   * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n   */\n  args: Record<string, any>;\n}\n\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n  /**\n   * The name of the action being requested.\n   */\n  name: string;\n  /**\n   * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n   */\n  args: Record<string, any>;\n  /**\n   * The description of the action to be reviewed.\n   */\n  description?: string;\n}\n\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n  /**\n   * Name of the action associated with this review configuration.\n   */\n  actionName: string;\n  /**\n   * The decisions that are allowed for this request.\n   */\n  allowedDecisions: DecisionType[];\n  /**\n   * JSON schema for the arguments associated with the action, if edits are allowed.\n   */\n  argsSchema?: Record<string, any>;\n}\n\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n  /**\n   * A list of agent actions for human review.\n   */\n  actionRequests: ActionRequest[];\n  /**\n   * Review configuration for all possible actions.\n   */\n  reviewConfigs: ReviewConfig[];\n}\n\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n  type: \"approve\";\n}\n\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n  type: \"edit\";\n  /**\n   * Edited action for the agent to perform.\n   * Ex: for a tool call, a human reviewer can edit the tool name and args.\n   */\n  editedAction: Action;\n}\n\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n  type: \"reject\";\n  /**\n   * The message sent to the model explaining why the action was rejected.\n   */\n  message?: string;\n}\n\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n  /**\n   * The decisions made by the human.\n   */\n  decisions: Decision[];\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 approve/edit/reject decisions\n   * - `false` -> auto-approve (no human review)\n   * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n   */\n  interruptOn: z\n    .record(z.union([z.boolean(), InterruptOnConfigSchema]))\n    .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 InterruptOnConfig}. 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.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\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 Decision Types**: Approve, edit, or reject 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 * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: 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].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\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.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\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 approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\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 HITLRequest, type HITLResponse, 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 = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"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 *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\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 *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\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 *       allowedDecisions: [\"approve\", \"edit\"],\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 *       allowedDecisions: [\"approve\", \"reject\"],\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 request\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  const createActionAndConfig = async (\n    toolCall: ToolCall,\n    config: InterruptOnConfig,\n    state: AgentBuiltInState,\n    runtime: Runtime<unknown>\n  ): Promise<{\n    actionRequest: ActionRequest;\n    reviewConfig: ReviewConfig;\n  }> => {\n    const toolName = toolCall.name;\n    const toolArgs = toolCall.args;\n\n    // Generate description using the description field (str or callable)\n    const descriptionValue = config.description;\n    let description: string;\n    if (typeof descriptionValue === \"function\") {\n      description = await descriptionValue(toolCall, state, runtime);\n    } else if (descriptionValue !== undefined) {\n      description = descriptionValue;\n    } else {\n      description = `${\n        options.descriptionPrefix ?? \"Tool execution requires approval\"\n      }\\n\\nTool: ${toolName}\\nArgs: ${JSON.stringify(toolArgs, null, 2)}`;\n    }\n\n    /**\n     * Create ActionRequest with description\n     */\n    const actionRequest: ActionRequest = {\n      name: toolName,\n      args: toolArgs,\n      description,\n    };\n\n    /**\n     * Create ReviewConfig\n     */\n    const reviewConfig: ReviewConfig = {\n      actionName: toolName,\n      allowedDecisions: config.allowedDecisions,\n    };\n\n    if (config.argsSchema) {\n      reviewConfig.argsSchema = config.argsSchema;\n    }\n\n    return { actionRequest, reviewConfig };\n  };\n\n  const processDecision = (\n    decision: Decision,\n    toolCall: ToolCall,\n    config: InterruptOnConfig\n  ): { revisedToolCall: ToolCall | null; toolMessage: ToolMessage | null } => {\n    const allowedDecisions = config.allowedDecisions;\n    if (decision.type === \"approve\" && allowedDecisions.includes(\"approve\")) {\n      return { revisedToolCall: toolCall, toolMessage: null };\n    }\n\n    if (decision.type === \"edit\" && allowedDecisions.includes(\"edit\")) {\n      const editedAction = decision.editedAction;\n\n      /**\n       * Validate edited action structure\n       */\n      if (!editedAction || typeof editedAction.name !== \"string\") {\n        throw new Error(\n          `Invalid edited action for tool \"${toolCall.name}\": name must be a string`\n        );\n      }\n      if (!editedAction.args || typeof editedAction.args !== \"object\") {\n        throw new Error(\n          `Invalid edited action for tool \"${toolCall.name}\": args must be an object`\n        );\n      }\n\n      return {\n        revisedToolCall: {\n          type: \"tool_call\",\n          name: editedAction.name,\n          args: editedAction.args,\n          id: toolCall.id,\n        },\n        toolMessage: null,\n      };\n    }\n\n    if (decision.type === \"reject\" && allowedDecisions.includes(\"reject\")) {\n      /**\n       * Validate that message is a string if provided\n       */\n      if (\n        decision.message !== undefined &&\n        typeof decision.message !== \"string\"\n      ) {\n        throw new Error(\n          `Tool call response for \"${\n            toolCall.name\n          }\" must be a string, got ${typeof decision.message}`\n        );\n      }\n\n      // Create a tool message with the human's text response\n      const content =\n        decision.message ??\n        `User rejected the tool call for \\`${toolCall.name}\\` with id ${toolCall.id}`;\n\n      const toolMessage = new ToolMessage({\n        content,\n        name: toolCall.name,\n        tool_call_id: toolCall.id!,\n        status: \"error\",\n      });\n\n      return { revisedToolCall: toolCall, toolMessage };\n    }\n\n    const msg = `Unexpected human decision: ${JSON.stringify(\n      decision\n    )}. Decision type '${decision.type}' is not allowed for tool '${\n      toolCall.name\n    }'. Expected one of ${JSON.stringify(\n      allowedDecisions\n    )} based on the tool's configuration.`;\n    throw new Error(msg);\n  };\n\n  return createMiddleware({\n    name: \"HumanInTheLoopMiddleware\",\n    contextSchema,\n    afterModel: {\n      canJumpTo: [\"model\"],\n      hook: 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        /**\n         * Resolve per-tool configs (boolean true -> all decisions allowed; false -> auto-approve)\n         */\n        const resolvedConfigs: Record<string, InterruptOnConfig> = {};\n        for (const [toolName, toolConfig] of Object.entries(\n          config.interruptOn\n        )) {\n          if (typeof toolConfig === \"boolean\") {\n            if (toolConfig === true) {\n              resolvedConfigs[toolName] = {\n                allowedDecisions: [...ALLOWED_DECISIONS],\n              };\n            }\n          } else if (toolConfig.allowedDecisions) {\n            resolvedConfigs[toolName] = toolConfig as InterruptOnConfig;\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 resolvedConfigs) {\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        /**\n         * Create action requests and review configs for all tools that need approval\n         */\n        const actionRequests: ActionRequest[] = [];\n        const reviewConfigs: ReviewConfig[] = [];\n\n        for (const toolCall of interruptToolCalls) {\n          const interruptConfig = resolvedConfigs[toolCall.name]!;\n\n          /**\n           * Create ActionRequest and ReviewConfig using helper method\n           */\n          const { actionRequest, reviewConfig } = await createActionAndConfig(\n            toolCall,\n            interruptConfig,\n            state,\n            runtime\n          );\n          actionRequests.push(actionRequest);\n          reviewConfigs.push(reviewConfig);\n        }\n\n        /**\n         * Create single HITLRequest with all actions and configs\n         */\n        const hitlRequest: HITLRequest = {\n          actionRequests,\n          reviewConfigs,\n        };\n\n        /**\n         * Send interrupt and get response\n         */\n        const hitlResponse = (await interrupt(hitlRequest)) as HITLResponse;\n        const decisions = hitlResponse.decisions;\n\n        /**\n         * Validate that decisions is a valid array before checking length\n         */\n        if (!decisions || !Array.isArray(decisions)) {\n          throw new Error(\n            \"Invalid HITLResponse: decisions must be a non-empty array\"\n          );\n        }\n\n        /**\n         * Validate that the number of decisions matches the number of interrupt tool calls\n         */\n        if (decisions.length !== interruptToolCalls.length) {\n          throw new Error(\n            `Number of human decisions (${decisions.length}) does not match number of hanging tool calls (${interruptToolCalls.length}).`\n          );\n        }\n\n        const revisedToolCalls: ToolCall[] = [...autoApprovedToolCalls];\n        const artificialToolMessages: ToolMessage[] = [];\n\n        /**\n         * Process each decision using helper method\n         */\n        for (let i = 0; i < decisions.length; i++) {\n          const decision = decisions[i]!;\n          const toolCall = interruptToolCalls[i]!;\n          const interruptConfig = resolvedConfigs[toolCall.name]!;\n\n          const { revisedToolCall, toolMessage } = processDecision(\n            decision,\n            toolCall,\n            interruptConfig\n          );\n\n          if (revisedToolCall) {\n            revisedToolCalls.push(revisedToolCall);\n          }\n          if (toolMessage) {\n            artificialToolMessages.push(toolMessage);\n          }\n        }\n\n        /**\n         * Update the AI message to only include approved tool calls\n         */\n        if (AIMessage.isInstance(lastMessage)) {\n          lastMessage.tool_calls = revisedToolCalls;\n        }\n\n        return { messages: [lastMessage, ...artificialToolMessages] };\n      },\n    },\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"hitl.cjs","names":["z","options: NonNullable<HumanInTheLoopMiddlewareConfig>","toolCall: ToolCall","config: InterruptOnConfig","state: AgentBuiltInState","runtime: Runtime<unknown>","description: string","actionRequest: ActionRequest","reviewConfig: ReviewConfig","decision: Decision","ToolMessage","createMiddleware","AIMessage","resolvedConfigs: Record<string, InterruptOnConfig>","interruptToolCalls: ToolCall[]","autoApprovedToolCalls: ToolCall[]","actionRequests: ActionRequest[]","reviewConfigs: ReviewConfig[]","hitlRequest: HITLRequest","revisedToolCalls: ToolCall[]","artificialToolMessages: ToolMessage[]","jumpTo: JumpToTarget | undefined"],"sources":["../../../src/agents/middleware/hitl.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { AIMessage, ToolMessage, ToolCall } 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 \"../runtime.js\";\nimport type { JumpToTarget } from \"../constants.js\";\n\nconst DescriptionFunctionSchema = z\n  .function()\n  .args(\n    z.custom<ToolCall>(), // toolCall\n    z.custom<AgentBuiltInState>(), // state\n    z.custom<Runtime<unknown>>() // runtime\n  )\n  .returns(z.union([z.string(), z.promise(z.string())]));\n\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\n\n/**\n * The type of decision a human can make.\n */\nconst ALLOWED_DECISIONS = [\"approve\", \"edit\", \"reject\"] as const;\nconst DecisionType = z.enum(ALLOWED_DECISIONS);\nexport type DecisionType = z.infer<typeof DecisionType>;\n\nconst InterruptOnConfigSchema = z.object({\n  /**\n   * The decisions that are allowed for this action.\n   */\n  allowedDecisions: z.array(DecisionType),\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   * import type { InterruptOnConfig } from \"langchain\";\n   *\n   * const config: InterruptOnConfig = {\n   *   allowedDecisions: [\"approve\", \"reject\"],\n   *   description: \"Please review this tool execution\"\n   * };\n   * ```\n   *\n   * @example\n   * Dynamic callable description\n   * ```typescript\n   * import type {\n   *   AgentBuiltInState,\n   *   Runtime,\n   *   DescriptionFactory,\n   *   ToolCall,\n   *   InterruptOnConfig\n   * } from \"langchain\";\n   *\n   * const formatToolDescription: DescriptionFactory = (\n   *   toolCall: ToolCall,\n   *   state: AgentBuiltInState,\n   *   runtime: Runtime<unknown>\n   * ) => {\n   *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n   * };\n   *\n   * const config: InterruptOnConfig = {\n   *   allowedDecisions: [\"approve\", \"edit\"],\n   *   description: formatToolDescription\n   * };\n   * ```\n   */\n  description: z.union([z.string(), DescriptionFunctionSchema]).optional(),\n  /**\n   * JSON schema for the arguments associated with the action, if edits are allowed.\n   */\n  argsSchema: z.record(z.any()).optional(),\n});\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n  /**\n   * The type or name of action being requested (e.g., \"add_numbers\").\n   */\n  name: string;\n  /**\n   * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n   */\n  args: Record<string, any>;\n}\n\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n  /**\n   * The name of the action being requested.\n   */\n  name: string;\n  /**\n   * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n   */\n  args: Record<string, any>;\n  /**\n   * The description of the action to be reviewed.\n   */\n  description?: string;\n}\n\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n  /**\n   * Name of the action associated with this review configuration.\n   */\n  actionName: string;\n  /**\n   * The decisions that are allowed for this request.\n   */\n  allowedDecisions: DecisionType[];\n  /**\n   * JSON schema for the arguments associated with the action, if edits are allowed.\n   */\n  argsSchema?: Record<string, any>;\n}\n\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n  /**\n   * A list of agent actions for human review.\n   */\n  actionRequests: ActionRequest[];\n  /**\n   * Review configuration for all possible actions.\n   */\n  reviewConfigs: ReviewConfig[];\n}\n\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n  type: \"approve\";\n}\n\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n  type: \"edit\";\n  /**\n   * Edited action for the agent to perform.\n   * Ex: for a tool call, a human reviewer can edit the tool name and args.\n   */\n  editedAction: Action;\n}\n\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n  type: \"reject\";\n  /**\n   * The message sent to the model explaining why the action was rejected.\n   */\n  message?: string;\n}\n\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n  /**\n   * The decisions made by the human.\n   */\n  decisions: Decision[];\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 approve/edit/reject decisions\n   * - `false` -> auto-approve (no human review)\n   * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n   */\n  interruptOn: z\n    .record(z.union([z.boolean(), InterruptOnConfigSchema]))\n    .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 InterruptOnConfig}. 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.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\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 Decision Types**: Approve, edit, or reject 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 * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: 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].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\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.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\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 approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\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 HITLRequest, type HITLResponse, 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 = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"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 *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\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 *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\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 *       allowedDecisions: [\"approve\", \"edit\"],\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 *       allowedDecisions: [\"approve\", \"reject\"],\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 request\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  const createActionAndConfig = async (\n    toolCall: ToolCall,\n    config: InterruptOnConfig,\n    state: AgentBuiltInState,\n    runtime: Runtime<unknown>\n  ): Promise<{\n    actionRequest: ActionRequest;\n    reviewConfig: ReviewConfig;\n  }> => {\n    const toolName = toolCall.name;\n    const toolArgs = toolCall.args;\n\n    // Generate description using the description field (str or callable)\n    const descriptionValue = config.description;\n    let description: string;\n    if (typeof descriptionValue === \"function\") {\n      description = await descriptionValue(toolCall, state, runtime);\n    } else if (descriptionValue !== undefined) {\n      description = descriptionValue;\n    } else {\n      description = `${\n        options.descriptionPrefix ?? \"Tool execution requires approval\"\n      }\\n\\nTool: ${toolName}\\nArgs: ${JSON.stringify(toolArgs, null, 2)}`;\n    }\n\n    /**\n     * Create ActionRequest with description\n     */\n    const actionRequest: ActionRequest = {\n      name: toolName,\n      args: toolArgs,\n      description,\n    };\n\n    /**\n     * Create ReviewConfig\n     */\n    const reviewConfig: ReviewConfig = {\n      actionName: toolName,\n      allowedDecisions: config.allowedDecisions,\n    };\n\n    if (config.argsSchema) {\n      reviewConfig.argsSchema = config.argsSchema;\n    }\n\n    return { actionRequest, reviewConfig };\n  };\n\n  const processDecision = (\n    decision: Decision,\n    toolCall: ToolCall,\n    config: InterruptOnConfig\n  ): { revisedToolCall: ToolCall | null; toolMessage: ToolMessage | null } => {\n    const allowedDecisions = config.allowedDecisions;\n    if (decision.type === \"approve\" && allowedDecisions.includes(\"approve\")) {\n      return { revisedToolCall: toolCall, toolMessage: null };\n    }\n\n    if (decision.type === \"edit\" && allowedDecisions.includes(\"edit\")) {\n      const editedAction = decision.editedAction;\n\n      /**\n       * Validate edited action structure\n       */\n      if (!editedAction || typeof editedAction.name !== \"string\") {\n        throw new Error(\n          `Invalid edited action for tool \"${toolCall.name}\": name must be a string`\n        );\n      }\n      if (!editedAction.args || typeof editedAction.args !== \"object\") {\n        throw new Error(\n          `Invalid edited action for tool \"${toolCall.name}\": args must be an object`\n        );\n      }\n\n      return {\n        revisedToolCall: {\n          type: \"tool_call\",\n          name: editedAction.name,\n          args: editedAction.args,\n          id: toolCall.id,\n        },\n        toolMessage: null,\n      };\n    }\n\n    if (decision.type === \"reject\" && allowedDecisions.includes(\"reject\")) {\n      /**\n       * Validate that message is a string if provided\n       */\n      if (\n        decision.message !== undefined &&\n        typeof decision.message !== \"string\"\n      ) {\n        throw new Error(\n          `Tool call response for \"${\n            toolCall.name\n          }\" must be a string, got ${typeof decision.message}`\n        );\n      }\n\n      // Create a tool message with the human's text response\n      const content =\n        decision.message ??\n        `User rejected the tool call for \\`${toolCall.name}\\` with id ${toolCall.id}`;\n\n      const toolMessage = new ToolMessage({\n        content,\n        name: toolCall.name,\n        tool_call_id: toolCall.id!,\n        status: \"error\",\n      });\n\n      return { revisedToolCall: toolCall, toolMessage };\n    }\n\n    const msg = `Unexpected human decision: ${JSON.stringify(\n      decision\n    )}. Decision type '${decision.type}' is not allowed for tool '${\n      toolCall.name\n    }'. Expected one of ${JSON.stringify(\n      allowedDecisions\n    )} based on the tool's configuration.`;\n    throw new Error(msg);\n  };\n\n  return createMiddleware({\n    name: \"HumanInTheLoopMiddleware\",\n    contextSchema,\n    afterModel: {\n      canJumpTo: [\"model\"],\n      hook: 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        /**\n         * Resolve per-tool configs (boolean true -> all decisions allowed; false -> auto-approve)\n         */\n        const resolvedConfigs: Record<string, InterruptOnConfig> = {};\n        for (const [toolName, toolConfig] of Object.entries(\n          config.interruptOn\n        )) {\n          if (typeof toolConfig === \"boolean\") {\n            if (toolConfig === true) {\n              resolvedConfigs[toolName] = {\n                allowedDecisions: [...ALLOWED_DECISIONS],\n              };\n            }\n          } else if (toolConfig.allowedDecisions) {\n            resolvedConfigs[toolName] = toolConfig as InterruptOnConfig;\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 resolvedConfigs) {\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        /**\n         * Create action requests and review configs for all tools that need approval\n         */\n        const actionRequests: ActionRequest[] = [];\n        const reviewConfigs: ReviewConfig[] = [];\n\n        for (const toolCall of interruptToolCalls) {\n          const interruptConfig = resolvedConfigs[toolCall.name]!;\n\n          /**\n           * Create ActionRequest and ReviewConfig using helper method\n           */\n          const { actionRequest, reviewConfig } = await createActionAndConfig(\n            toolCall,\n            interruptConfig,\n            state,\n            runtime\n          );\n          actionRequests.push(actionRequest);\n          reviewConfigs.push(reviewConfig);\n        }\n\n        /**\n         * Create single HITLRequest with all actions and configs\n         */\n        const hitlRequest: HITLRequest = {\n          actionRequests,\n          reviewConfigs,\n        };\n\n        /**\n         * Send interrupt and get response\n         */\n        const hitlResponse = (await interrupt(hitlRequest)) as HITLResponse;\n        const decisions = hitlResponse.decisions;\n\n        /**\n         * Validate that decisions is a valid array before checking length\n         */\n        if (!decisions || !Array.isArray(decisions)) {\n          throw new Error(\n            \"Invalid HITLResponse: decisions must be a non-empty array\"\n          );\n        }\n\n        /**\n         * Validate that the number of decisions matches the number of interrupt tool calls\n         */\n        if (decisions.length !== interruptToolCalls.length) {\n          throw new Error(\n            `Number of human decisions (${decisions.length}) does not match number of hanging tool calls (${interruptToolCalls.length}).`\n          );\n        }\n\n        const revisedToolCalls: ToolCall[] = [...autoApprovedToolCalls];\n        const artificialToolMessages: ToolMessage[] = [];\n        const hasRejectedToolCalls = decisions.some(\n          (decision) => decision.type === \"reject\"\n        );\n\n        /**\n         * Process each decision using helper method\n         */\n        for (let i = 0; i < decisions.length; i++) {\n          const decision = decisions[i]!;\n          const toolCall = interruptToolCalls[i]!;\n          const interruptConfig = resolvedConfigs[toolCall.name]!;\n\n          const { revisedToolCall, toolMessage } = processDecision(\n            decision,\n            toolCall,\n            interruptConfig\n          );\n\n          if (\n            revisedToolCall &&\n            /**\n             * If any decision is a rejected, we are going back to the model\n             * with only the tool calls that were rejected as we don't know\n             * the results of the approved/updated tool calls at this point.\n             */\n            (!hasRejectedToolCalls || decision.type === \"reject\")\n          ) {\n            revisedToolCalls.push(revisedToolCall);\n          }\n          if (toolMessage) {\n            artificialToolMessages.push(toolMessage);\n          }\n        }\n\n        /**\n         * Update the AI message to only include approved tool calls\n         */\n        if (AIMessage.isInstance(lastMessage)) {\n          lastMessage.tool_calls = revisedToolCalls;\n        }\n\n        const jumpTo: JumpToTarget | undefined = hasRejectedToolCalls\n          ? \"model\"\n          : undefined;\n        return {\n          messages: [lastMessage, ...artificialToolMessages],\n          jumpTo,\n        };\n      },\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/agents/middleware/hitl.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"hitl.d.cts","names":["z","ToolCall","InferInteropZodInput","AgentBuiltInState","Runtime","DescriptionFunctionSchema","Record","ZodTypeDef","ZodType","ZodUnknown","ZodTuple","ZodString","ZodPromise","ZodUnion","ZodFunction","DescriptionFactory","infer","DecisionType","ZodEnum","InterruptOnConfigSchema","ZodArray","ZodOptional","ZodAny","ZodRecord","ZodTypeAny","Promise","ZodObject","InterruptOnConfig","input","Action","ActionRequest","ReviewConfig","HITLRequest","ApproveDecision","EditDecision","RejectDecision","Decision","HITLResponse","contextSchema","ZodBoolean","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","__types_js0","AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { ToolCall } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\ndeclare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\ndeclare const DecisionType: z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>;\nexport type DecisionType = z.infer<typeof DecisionType>;\ndeclare const InterruptOnConfigSchema: z.ZodObject<{\n    /**\n     * The decisions that are allowed for this action.\n     */\n    allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\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     * import type { InterruptOnConfig } from \"langchain\";\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"reject\"],\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * import type {\n     *   AgentBuiltInState,\n     *   Runtime,\n     *   DescriptionFactory,\n     *   ToolCall,\n     *   InterruptOnConfig\n     * } from \"langchain\";\n     *\n     * const formatToolDescription: DescriptionFactory = (\n     *   toolCall: ToolCall,\n     *   state: AgentBuiltInState,\n     *   runtime: Runtime<unknown>\n     * ) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"edit\"],\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}>;\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n    /**\n     * The type or name of action being requested (e.g., \"add_numbers\").\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n    /**\n     * The name of the action being requested.\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n    /**\n     * The description of the action to be reviewed.\n     */\n    description?: string;\n}\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n    /**\n     * Name of the action associated with this review configuration.\n     */\n    actionName: string;\n    /**\n     * The decisions that are allowed for this request.\n     */\n    allowedDecisions: DecisionType[];\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema?: Record<string, any>;\n}\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n    /**\n     * A list of agent actions for human review.\n     */\n    actionRequests: ActionRequest[];\n    /**\n     * Review configuration for all possible actions.\n     */\n    reviewConfigs: ReviewConfig[];\n}\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n    type: \"approve\";\n}\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n    type: \"edit\";\n    /**\n     * Edited action for the agent to perform.\n     * Ex: for a tool call, a human reviewer can edit the tool name and args.\n     */\n    editedAction: Action;\n}\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n    type: \"reject\";\n    /**\n     * The message sent to the model explaining why the action was rejected.\n     */\n    message?: string;\n}\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n    /**\n     * The decisions made by the human.\n     */\n    decisions: Decision[];\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 approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\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         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | 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 InterruptOnConfig}. 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        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | 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.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\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 Decision Types**: Approve, edit, or reject 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 * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: 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].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\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.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\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 approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\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 HITLRequest, type HITLResponse, 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 = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"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 *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\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 *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\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 *       allowedDecisions: [\"approve\", \"edit\"],\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 *       allowedDecisions: [\"approve\", \"reject\"],\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 request\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(\"./types.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 approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\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         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | 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 InterruptOnConfig}. 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        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"hitl.d.cts","names":["z","ToolCall","InferInteropZodInput","AgentBuiltInState","Runtime","DescriptionFunctionSchema","Record","ZodTypeDef","ZodType","ZodUnknown","ZodTuple","ZodString","ZodPromise","ZodUnion","ZodFunction","DescriptionFactory","infer","DecisionType","ZodEnum","InterruptOnConfigSchema","ZodArray","ZodOptional","ZodAny","ZodRecord","ZodTypeAny","Promise","ZodObject","InterruptOnConfig","input","Action","ActionRequest","ReviewConfig","HITLRequest","ApproveDecision","EditDecision","RejectDecision","Decision","HITLResponse","contextSchema","ZodBoolean","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","__types_js2","AgentMiddleware"],"sources":["../../../src/agents/middleware/hitl.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { ToolCall } from \"@langchain/core/messages\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\nimport type { AgentBuiltInState, Runtime } from \"../runtime.js\";\ndeclare const DescriptionFunctionSchema: z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>;\n/**\n * Function type that dynamically generates a description for a tool call approval request.\n *\n * @param toolCall - The tool call being reviewed\n * @param state - The current agent state\n * @param runtime - The agent runtime context\n * @returns A string description or Promise that resolves to a string description\n *\n * @example\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n *\n * const descriptionFactory: DescriptionFactory = (toolCall, state, runtime) => {\n *   return `Please review: ${toolCall.name}(${JSON.stringify(toolCall.args)})`;\n * };\n * ```\n */\nexport type DescriptionFactory = z.infer<typeof DescriptionFunctionSchema>;\ndeclare const DecisionType: z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>;\nexport type DecisionType = z.infer<typeof DecisionType>;\ndeclare const InterruptOnConfigSchema: z.ZodObject<{\n    /**\n     * The decisions that are allowed for this action.\n     */\n    allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\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     * import type { InterruptOnConfig } from \"langchain\";\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"reject\"],\n     *   description: \"Please review this tool execution\"\n     * };\n     * ```\n     *\n     * @example\n     * Dynamic callable description\n     * ```typescript\n     * import type {\n     *   AgentBuiltInState,\n     *   Runtime,\n     *   DescriptionFactory,\n     *   ToolCall,\n     *   InterruptOnConfig\n     * } from \"langchain\";\n     *\n     * const formatToolDescription: DescriptionFactory = (\n     *   toolCall: ToolCall,\n     *   state: AgentBuiltInState,\n     *   runtime: Runtime<unknown>\n     * ) => {\n     *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n     * };\n     *\n     * const config: InterruptOnConfig = {\n     *   allowedDecisions: [\"approve\", \"edit\"],\n     *   description: formatToolDescription\n     * };\n     * ```\n     */\n    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n}, \"strip\", z.ZodTypeAny, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}, {\n    allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n    description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n    argsSchema?: Record<string, any> | undefined;\n}>;\nexport type InterruptOnConfig = z.input<typeof InterruptOnConfigSchema>;\n/**\n * Represents an action with a name and arguments.\n */\nexport interface Action {\n    /**\n     * The type or name of action being requested (e.g., \"add_numbers\").\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an action request with a name, arguments, and description.\n */\nexport interface ActionRequest {\n    /**\n     * The name of the action being requested.\n     */\n    name: string;\n    /**\n     * Key-value pairs of arguments needed for the action (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n    /**\n     * The description of the action to be reviewed.\n     */\n    description?: string;\n}\n/**\n * Policy for reviewing a HITL request.\n */\nexport interface ReviewConfig {\n    /**\n     * Name of the action associated with this review configuration.\n     */\n    actionName: string;\n    /**\n     * The decisions that are allowed for this request.\n     */\n    allowedDecisions: DecisionType[];\n    /**\n     * JSON schema for the arguments associated with the action, if edits are allowed.\n     */\n    argsSchema?: Record<string, any>;\n}\n/**\n * Request for human feedback on a sequence of actions requested by a model.\n *\n * @example\n * ```ts\n * const hitlRequest: HITLRequest = {\n *   actionRequests: [\n *     { name: \"send_email\", args: { to: \"user@example.com\", subject: \"Hello\" } }\n *   ],\n *   reviewConfigs: [\n *     {\n *       actionName: \"send_email\",\n *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\n *       description: \"Please review the email before sending\"\n *     }\n *   ]\n * };\n * const response = interrupt(hitlRequest);\n * ```\n */\nexport interface HITLRequest {\n    /**\n     * A list of agent actions for human review.\n     */\n    actionRequests: ActionRequest[];\n    /**\n     * Review configuration for all possible actions.\n     */\n    reviewConfigs: ReviewConfig[];\n}\n/**\n * Response when a human approves the action.\n */\nexport interface ApproveDecision {\n    type: \"approve\";\n}\n/**\n * Response when a human edits the action.\n */\nexport interface EditDecision {\n    type: \"edit\";\n    /**\n     * Edited action for the agent to perform.\n     * Ex: for a tool call, a human reviewer can edit the tool name and args.\n     */\n    editedAction: Action;\n}\n/**\n * Response when a human rejects the action.\n */\nexport interface RejectDecision {\n    type: \"reject\";\n    /**\n     * The message sent to the model explaining why the action was rejected.\n     */\n    message?: string;\n}\n/**\n * Union of all possible decision types.\n */\nexport type Decision = ApproveDecision | EditDecision | RejectDecision;\n/**\n * Response payload for a HITLRequest.\n */\nexport interface HITLResponse {\n    /**\n     * The decisions made by the human.\n     */\n    decisions: Decision[];\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 approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\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         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | 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 InterruptOnConfig}. 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        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | 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.\n *\n * ```ts\n * import { type HITLRequest, type HITLResponse } from \"langchain\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n * // Examine the action requests and review configs\n * const actionRequests = interruptRequest.value.actionRequests;\n * const reviewConfigs = interruptRequest.value.reviewConfigs;\n *\n * // Create decisions for each action\n * const resume: HITLResponse = {\n *   decisions: actionRequests.map((action, i) => {\n *     if (action.name === \"calculator\") {\n *       return { type: \"approve\" };\n *     } else if (action.name === \"write_file\") {\n *       return {\n *         type: \"edit\",\n *         editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Safe content\" } }\n *       };\n *     }\n *     return { type: \"reject\", message: \"Action not allowed\" };\n *   })\n * };\n *\n * // Resume with decisions\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 Decision Types**: Approve, edit, or reject 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 * ## Decision Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `approve`: Execute the tool with original arguments\n * - `edit`: Modify the tool name and/or arguments before execution\n * - `reject`: 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].allowedDecisions - Array of decision types allowed for this tool (e.g., [\"approve\", \"edit\", \"reject\"])\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.interruptOn[toolName].argsSchema - JSON schema for the arguments associated with the action, if edits are allowed\n * @param options.descriptionPrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their InterruptOnConfig.\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 approvals\n *     \"write_file\": {\n *       allowedDecisions: [\"approve\", \"edit\"],\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 HITLRequest, type HITLResponse, 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 = result.__interrupt__?.[0] as Interrupt<HITLRequest>;\n *\n *   // Show tool call details to user\n *   console.log(\"Actions:\", interruptRequest.value.actionRequests);\n *   console.log(\"Review configs:\", interruptRequest.value.reviewConfigs);\n *\n *   // Resume with approval\n *   const resume: HITLResponse = {\n *     decisions: [{ type: \"approve\" }]\n *   };\n *   await agent.invoke(\n *     new Command({ resume }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different decision types\n * ```typescript\n * import { type HITLResponse } from \"langchain\";\n *\n * // Approve the tool call as-is\n * const resume: HITLResponse = {\n *   decisions: [{ type: \"approve\" }]\n * };\n *\n * // Edit the tool arguments\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"edit\",\n *     editedAction: { name: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * };\n *\n * // Reject with feedback\n * const resume: HITLResponse = {\n *   decisions: [{\n *     type: \"reject\",\n *     message: \"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 *       allowedDecisions: [\"approve\", \"edit\", \"reject\"],\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 *       allowedDecisions: [\"approve\", \"reject\"],\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   descriptionPrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @example\n * Using dynamic callable descriptions\n * ```typescript\n * import { type DescriptionFactory, type ToolCall } from \"langchain\";\n * import type { AgentBuiltInState, Runtime } from \"langchain/agents\";\n *\n * // Define a dynamic description factory\n * const formatToolDescription: DescriptionFactory = (\n *   toolCall: ToolCall,\n *   state: AgentBuiltInState,\n *   runtime: Runtime<unknown>\n * ) => {\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 *       allowedDecisions: [\"approve\", \"edit\"],\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 *       allowedDecisions: [\"approve\", \"reject\"],\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 request\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(\"./types.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 approve/edit/reject decisions\n     * - `false` -> auto-approve (no human review)\n     * - `InterruptOnConfig` -> explicitly specify which decisions are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * The decisions that are allowed for this action.\n         */\n        allowedDecisions: z.ZodArray<z.ZodEnum<[\"approve\", \"edit\", \"reject\"]>, \"many\">;\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         * import type { InterruptOnConfig } from \"langchain\";\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"reject\"],\n         *   description: \"Please review this tool execution\"\n         * };\n         * ```\n         *\n         * @example\n         * Dynamic callable description\n         * ```typescript\n         * import type {\n         *   AgentBuiltInState,\n         *   Runtime,\n         *   DescriptionFactory,\n         *   ToolCall,\n         *   InterruptOnConfig\n         * } from \"langchain\";\n         *\n         * const formatToolDescription: DescriptionFactory = (\n         *   toolCall: ToolCall,\n         *   state: AgentBuiltInState,\n         *   runtime: Runtime<unknown>\n         * ) => {\n         *   return `Tool: ${toolCall.name}\\nArguments:\\n${JSON.stringify(toolCall.args, null, 2)}`;\n         * };\n         *\n         * const config: InterruptOnConfig = {\n         *   allowedDecisions: [\"approve\", \"edit\"],\n         *   description: formatToolDescription\n         * };\n         * ```\n         */\n        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[z.ZodType<ToolCall<string, Record<string, any>>, z.ZodTypeDef, ToolCall<string, Record<string, any>>>, z.ZodType<AgentBuiltInState, z.ZodTypeDef, AgentBuiltInState>, z.ZodType<Runtime<unknown>, z.ZodTypeDef, Runtime<unknown>>], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>]>>;\n        /**\n         * JSON schema for the arguments associated with the action, if edits are allowed.\n         */\n        argsSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }, {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | 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 InterruptOnConfig}. 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        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowedDecisions: (\"approve\" | \"edit\" | \"reject\")[];\n        description?: string | ((args_0: ToolCall<string, Record<string, any>>, args_1: AgentBuiltInState, args_2: Runtime<unknown>, ...args: unknown[]) => string | Promise<string>) | undefined;\n        argsSchema?: Record<string, any> | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":"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"}