langchain 1.0.0-alpha.6 → 1.0.0-alpha.7

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

@@ -1,32 +1,179 @@
 import { AgentMiddleware } from "../types.cjs";
+import { InferInteropZodInput } from "@langchain/core/utils/types";
 import { z } from "zod/v3";
 
 //#region src/agents/middlewareAgent/middleware/hitl.d.ts
+declare const ToolConfigSchema: z.ZodObject<{
+  /**
+   * Whether the human can approve the current action without changes
+   */
+  allowAccept: z.ZodOptional<z.ZodBoolean>;
+  /**
+   * Whether the human can reject the current action with feedback
+   */
+  allowEdit: z.ZodOptional<z.ZodBoolean>;
+  /**
+   * Whether the human can approve the current action with edited content
+   */
+  allowRespond: z.ZodOptional<z.ZodBoolean>;
+  /**
+   * The description attached to the request for human input
+   */
+  description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  allowAccept?: boolean | undefined;
+  allowEdit?: boolean | undefined;
+  allowRespond?: boolean | undefined;
+  description?: string | undefined;
+}, {
+  allowAccept?: boolean | undefined;
+  allowEdit?: boolean | undefined;
+  allowRespond?: boolean | undefined;
+  description?: string | undefined;
+}>;
+type ToolConfigSchema = z.input<typeof ToolConfigSchema>;
+/**
+ * Represents information about an interrupt.
+ */
+
+/**
+ * Configuration that defines which reviewer response types are permitted during a human interrupt.
+ * These flags control what the human reviewer may do (e.g., accept/edit/respond),
+ * not the tool action the agent has requested.
+ */
+interface HumanInTheLoopConfig extends Omit<ToolConfigSchema, "description"> {}
+/**
+ * Describes the agent-requested tool action (name and arguments).
+ * This is what the AI intends to execute, subject to human review.
+ */
+interface ActionRequest {
+  /**
+   * The tool/action name requested by the agent (e.g., "send_email").
+   */
+  action: string;
+  /**
+   * Arguments for the requested tool call (e.g., {"a": 1, "b": 2}).
+   */
+  args: Record<string, any>;
+}
+/**
+ * Represents an interrupt triggered by the graph that requires human intervention
+ * to approve, edit, or respond to an agent-requested tool action.
+ *
+ * @example
+ * ```ts
+ * const hitlRequest: HumanInTheLoopRequest = {
+ *   actionRequest: { action: "Approve XYZ action", args: { ... } },
+ *   config: { allowAccept: true, allowEdit: true, allowRespond: true },
+ *   description: "Please review the command before execution"
+ * };
+ * response = interrupt([request])[0]
+ * ```
+ */
+interface HumanInTheLoopRequest {
+  /**
+   * The agent-requested tool action to be reviewed.
+   */
+  actionRequest: ActionRequest;
+  /**
+   * Which reviewer responses are allowed (accept/edit/respond).
+   */
+  config: HumanInTheLoopConfig;
+  /**
+   * Optional human-facing description shown in the approval prompt.
+   */
+  description?: string;
+}
+/**
+ * Response when a human approves the agent-requested action.
+ */
+interface AcceptPayload {
+  type: "accept";
+}
+/**
+ * Response when a human provides a manual response instead of executing
+ * the agent-requested action.
+ */
+interface ResponsePayload {
+  type: "response";
+  args?: string;
+}
+/**
+ * Response when a human edits the agent-requested action (tool name and/or args).
+ */
+interface EditPayload {
+  type: "edit";
+  args: ActionRequest;
+}
+type HumanInTheLoopMiddlewareHumanResponse = AcceptPayload | ResponsePayload | EditPayload;
+/**
+ * Configuration for a tool requiring human in the loop.
+ */
+
 declare const contextSchema: z.ZodObject<{
-  toolConfigs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-    requireApproval: z.ZodOptional<z.ZodBoolean>;
+  /**
+   * Mapping of tool name to allowed reviewer responses.
+   * If a tool doesn't have an entry, it's auto-approved by default.
+   *
+   * - `true` -> pause for approval and allow accept/edit/respond
+   * - `false` -> auto-approve (no human review)
+   * - `ToolConfig` -> explicitly specify which reviewer responses are allowed for this tool
+   */
+  interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+    /**
+     * Whether the human can approve the current action without changes
+     */
+    allowAccept: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether the human can reject the current action with feedback
+     */
+    allowEdit: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether the human can approve the current action with edited content
+     */
+    allowRespond: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * The description attached to the request for human input
+     */
     description: z.ZodOptional<z.ZodString>;
   }, "strip", z.ZodTypeAny, {
-    requireApproval?: boolean | undefined;
+    allowAccept?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowRespond?: boolean | undefined;
     description?: string | undefined;
   }, {
-    requireApproval?: boolean | undefined;
+    allowAccept?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowRespond?: boolean | undefined;
     description?: string | undefined;
-  }>>>;
-  messagePrefix: z.ZodDefault<z.ZodString>;
+  }>]>>>;
+  /**
+   * Prefix used when constructing human-facing approval messages.
+   * Provides context about the tool call being reviewed; does not change the underlying action.
+   *
+   * Note: This prefix is only applied for tools that do not provide a custom
+   * `description` via their {@link ToolConfig}. If a tool specifies a custom
+   * `description`, that per-tool text is used and this prefix is ignored.
+   */
+  descriptionPrefix: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-  toolConfigs: Record<string, {
-    requireApproval?: boolean | undefined;
+  interruptOn?: Record<string, boolean | {
+    allowAccept?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowRespond?: boolean | undefined;
     description?: string | undefined;
-  }>;
-  messagePrefix: string;
+  }> | undefined;
+  descriptionPrefix: string;
 }, {
-  toolConfigs?: Record<string, {
-    requireApproval?: boolean | undefined;
+  interruptOn?: Record<string, boolean | {
+    allowAccept?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowRespond?: boolean | undefined;
     description?: string | undefined;
   }> | undefined;
-  messagePrefix?: string | undefined;
+  descriptionPrefix?: string | undefined;
 }>;
+type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;
 /**
  * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.
  *
@@ -34,6 +181,37 @@ declare const contextSchema: z.ZodObject<{
  * capabilities before execution. It enables selective approval workflows where certain tools
  * require human intervention while others can execute automatically.
  *
+ * A invocation result that has been interrupted by the middleware will have a `__interrupt__`
+ * property that contains the interrupt request. You can loop over the request to determine
+ * which tools were interrupted, and how to handle them separately.
+ *
+ * ```ts
+ * import { type ToolApprovalRequest, type HumanInTheLoopMiddlewareHumanResponse } from "langchain/middleware";
+ * import { type Interrupt } from "langchain";
+ *
+ * const result = await agent.invoke(request);
+ * const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<
+ *   ToolApprovalRequest[]
+ * >;
+ * const resume: HumanInTheLoopMiddlewareHumanResponse[] =
+ *   interruptRequest.value.map((request) => {
+ *     if (request.action === "calculator") {
+ *       return { id: request.toolCallId, type: "accept" };
+ *     } else if (request.action === "write_file") {
+ *       return {
+ *         id: request.toolCallId,
+ *         type: "edit",
+ *         args: { filename: "safe.txt", content: "Safe content" },
+ *       };
+ *     }
+ *
+ *     throw new Error(`Unknown action: ${request.action}`);
+ *   });
+ *
+ * // Resume with approval
+ * await agent.invoke(new Command({ resume }), config);
+ * ```
+ *
  * ## Features
  *
  * - **Selective Tool Approval**: Configure which tools require human approval
@@ -50,10 +228,12 @@ declare const contextSchema: z.ZodObject<{
  * - `response`: Provide a manual response instead of executing the tool
  *
  * @param options - Configuration options for the middleware
- * @param options.toolConfigs - Per-tool configuration mapping tool names to their settings
- * @param options.toolConfigs[toolName].requireApproval - Whether the tool requires human approval
- * @param options.toolConfigs[toolName].description - Custom approval message for the tool
- * @param options.messagePrefix - Default prefix for approval messages (default: "Tool execution requires approval")
+ * @param options.interruptOn - Per-tool configuration mapping tool names to their settings
+ * @param options.interruptOn[toolName].allowAccept - Whether the human can approve the current action without changes
+ * @param options.interruptOn[toolName].allowEdit - Whether the human can reject the current action with feedback
+ * @param options.interruptOn[toolName].allowRespond - Whether the human can approve the current action with edited content
+ * @param options.interruptOn[toolName].description - Custom approval message for the tool
+ * @param options.messagePrefix - Default prefix for approval messages (default: "Tool execution requires approval"). Only used for tools that do not define a custom `description` in their ToolConfig.
  *
  * @returns A middleware instance that can be passed to `createAgent`
  *
@@ -64,14 +244,15 @@ declare const contextSchema: z.ZodObject<{
  * import { createAgent } from "langchain";
  *
  * const hitlMiddleware = humanInTheLoopMiddleware({
- *   toolConfigs: {
+ *   interruptOn: {
+ *     // Interrupt write_file tool and allow edits or accepts
  *     "write_file": {
- *       requireApproval: true,
+ *       allowEdit: true,
+ *       allowAccept: true,
  *       description: "⚠️ File write operation requires approval"
  *     },
- *     "read_file": {
- *       requireApproval: false  // Safe operation, no approval needed
- *     }
+ *     // Auto-approve read_file tool
+ *     "read_file": false
  *   }
  * });
  *
@@ -85,6 +266,7 @@ declare const contextSchema: z.ZodObject<{
  * @example
  * Handling approval requests
  * ```typescript
+ * import { type HumanInTheLoopRequest, type Interrupt } from "langchain/middleware";
  * import { Command } from "@langchain/langgraph";
  *
  * // Initial agent invocation
@@ -93,15 +275,14 @@ declare const contextSchema: z.ZodObject<{
  * }, config);
  *
  * // Check if agent is paused for approval
- * const state = await agent.graph.getState(config);
- * if (state.next?.length > 0) {
- *   // Get interrupt details
- *   const task = state.tasks?.[0];
- *   const requests = task?.interrupts?.[0]?.value;
+ * if (result.__interrupt__) {
+ *   const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<
+ *     HumanInTheLoopRequest[]
+ *   >;
  *
  *   // Show tool call details to user
- *   console.log("Tool:", requests[0].action);
- *   console.log("Args:", requests[0].args);
+ *   console.log("Tool:", interruptRequest.value[0].actionRequest);
+ *   console.log("Allowed actions:", interruptRequest.value[0].config);
  *
  *   // Resume with approval
  *   await agent.invoke(
@@ -126,12 +307,13 @@ declare const contextSchema: z.ZodObject<{
  * })
  *
  * // Skip tool and terminate agent
- * new Command({ resume: [{ type: "ignore" }] })
+ * new Command({ resume: [{ type: "response" }] })
  *
  * // Provide manual response
  * new Command({
  *   resume: [{
  *     type: "response",
+ *     // this must be a string
  *     args: "File operation not allowed in demo mode"
  *   }]
  * })
@@ -141,16 +323,16 @@ declare const contextSchema: z.ZodObject<{
  * Production use case with database operations
  * ```typescript
  * const hitlMiddleware = humanInTheLoopMiddleware({
- *   toolConfigs: {
+ *   interruptOn: {
  *     "execute_sql": {
- *       requireApproval: true,
+ *       allowAccept: true,
+ *       allowEdit: true,
+ *       allowRespond: true,
  *       description: "🚨 SQL query requires DBA approval\nPlease review for safety and performance"
  *     },
- *     "read_schema": {
- *       requireApproval: false  // Reading metadata is safe
- *     },
+ *     "read_schema": false  // Reading metadata is safe
  *     "delete_records": {
- *       requireApproval: true,
+ *       allowAccept: true,
  *       description: "⛔ DESTRUCTIVE OPERATION - Requires manager approval"
  *     }
  *   },
@@ -169,31 +351,69 @@ declare const contextSchema: z.ZodObject<{
  * @see {@link Command} for resuming interrupted execution
  * @public
  */
-declare function humanInTheLoopMiddleware(options?: z.input<typeof contextSchema>): AgentMiddleware<undefined, z.ZodObject<{
-  toolConfigs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-    requireApproval: z.ZodOptional<z.ZodBoolean>;
+declare function humanInTheLoopMiddleware(options: NonNullable<HumanInTheLoopMiddlewareConfig>): AgentMiddleware<undefined, z.ZodObject<{
+  /**
+   * Mapping of tool name to allowed reviewer responses.
+   * If a tool doesn't have an entry, it's auto-approved by default.
+   *
+   * - `true` -> pause for approval and allow accept/edit/respond
+   * - `false` -> auto-approve (no human review)
+   * - `ToolConfig` -> explicitly specify which reviewer responses are allowed for this tool
+   */
+  interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+    /**
+     * Whether the human can approve the current action without changes
+     */
+    allowAccept: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether the human can reject the current action with feedback
+     */
+    allowEdit: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Whether the human can approve the current action with edited content
+     */
+    allowRespond: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * The description attached to the request for human input
+     */
     description: z.ZodOptional<z.ZodString>;
   }, "strip", z.ZodTypeAny, {
-    requireApproval?: boolean | undefined;
+    allowAccept?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowRespond?: boolean | undefined;
     description?: string | undefined;
   }, {
-    requireApproval?: boolean | undefined;
+    allowAccept?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowRespond?: boolean | undefined;
     description?: string | undefined;
-  }>>>;
-  messagePrefix: z.ZodDefault<z.ZodString>;
+  }>]>>>;
+  /**
+   * Prefix used when constructing human-facing approval messages.
+   * Provides context about the tool call being reviewed; does not change the underlying action.
+   *
+   * Note: This prefix is only applied for tools that do not provide a custom
+   * `description` via their {@link ToolConfig}. If a tool specifies a custom
+   * `description`, that per-tool text is used and this prefix is ignored.
+   */
+  descriptionPrefix: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-  toolConfigs: Record<string, {
-    requireApproval?: boolean | undefined;
+  interruptOn?: Record<string, boolean | {
+    allowAccept?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowRespond?: boolean | undefined;
     description?: string | undefined;
-  }>;
-  messagePrefix: string;
+  }> | undefined;
+  descriptionPrefix: string;
 }, {
-  toolConfigs?: Record<string, {
-    requireApproval?: boolean | undefined;
+  interruptOn?: Record<string, boolean | {
+    allowAccept?: boolean | undefined;
+    allowEdit?: boolean | undefined;
+    allowRespond?: boolean | undefined;
     description?: string | undefined;
   }> | undefined;
-  messagePrefix?: string | undefined;
+  descriptionPrefix?: string | undefined;
 }>, any>;
 //#endregion
-export { humanInTheLoopMiddleware };
+export { ActionRequest, HumanInTheLoopMiddlewareConfig, HumanInTheLoopMiddlewareHumanResponse, HumanInTheLoopRequest, humanInTheLoopMiddleware };
 //# sourceMappingURL=hitl.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hitl.d.cts","names":["z","contextSchema","ZodString","ZodBoolean","ZodOptional","ZodTypeAny","ZodObject","ZodRecord","ZodDefault","Record","humanInTheLoopMiddleware","input","___types_js0","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/hitl.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\ndeclare const contextSchema: z.ZodObject<{\n    toolConfigs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{\n        requireApproval: z.ZodOptional<z.ZodBoolean>;\n        description: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>>>;\n    messagePrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    toolConfigs: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>;\n    messagePrefix: string;\n}, {\n    toolConfigs?: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    messagePrefix?: string | undefined;\n}>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Response Types**: Accept, edit, ignore, or manually respond to tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Response Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `accept`: Execute the tool with original arguments\n * - `edit`: Modify the tool arguments before execution\n * - `ignore`: Skip the tool and terminate the agent\n * - `response`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.toolConfigs - Per-tool configuration mapping tool names to their settings\n * @param options.toolConfigs[toolName].requireApproval - Whether the tool requires human approval\n * @param options.toolConfigs[toolName].description - Custom approval message for the tool\n * @param options.messagePrefix - Default prefix for approval messages (default: \"Tool execution requires approval\")\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   toolConfigs: {\n *     \"write_file\": {\n *       requireApproval: true,\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     \"read_file\": {\n *       requireApproval: false  // Safe operation, no approval needed\n *     }\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * const state = await agent.graph.getState(config);\n * if (state.next?.length > 0) {\n *   // Get interrupt details\n *   const task = state.tasks?.[0];\n *   const requests = task?.interrupts?.[0]?.value;\n *\n *   // Show tool call details to user\n *   console.log(\"Tool:\", requests[0].action);\n *   console.log(\"Args:\", requests[0].args);\n *\n *   // Resume with approval\n *   await agent.invoke(\n *     new Command({ resume: [{ type: \"accept\" }] }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different response types\n * ```typescript\n * // Accept the tool call as-is\n * new Command({ resume: [{ type: \"accept\" }] })\n *\n * // Edit the tool arguments\n * new Command({\n *   resume: [{\n *     type: \"edit\",\n *     args: { action: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * })\n *\n * // Skip tool and terminate agent\n * new Command({ resume: [{ type: \"ignore\" }] })\n *\n * // Provide manual response\n * new Command({\n *   resume: [{\n *     type: \"response\",\n *     args: \"File operation not allowed in demo mode\"\n *   }]\n * })\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   toolConfigs: {\n *     \"execute_sql\": {\n *       requireApproval: true,\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": {\n *       requireApproval: false  // Reading metadata is safe\n *     },\n *     \"delete_records\": {\n *       requireApproval: true,\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   messagePrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport declare function humanInTheLoopMiddleware(options?: z.input<typeof contextSchema>): import(\"../types.js\").AgentMiddleware<undefined, z.ZodObject<{\n    toolConfigs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{\n        requireApproval: z.ZodOptional<z.ZodBoolean>;\n        description: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>>>;\n    messagePrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    toolConfigs: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }>;\n    messagePrefix: string;\n}, {\n    toolConfigs?: Record<string, {\n        requireApproval?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    messagePrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":";;;;cAEcC,eAAeD,CAAAA,CAAEM;eACdN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,UAAUP,CAAAA,CAAEE,WAAWF,CAAAA,CAAEM;IAD3CL,eAwBZ,EAtBuBD,CAAAA,CAAEI,WAsBzB,CAtBqCJ,CAAAA,CAAEG,UAsBvC,CAAA;IAAA,WAAA,EArBmBH,CAAAA,CAAEI,WAqBrB,CArBiCJ,CAAAA,CAAEE,SAqBnC,CAAA;EAAA,CAAA,EAvBwCF,OAAEE,EAG5BF,CAAAA,CAAEK,UAH0BH,EAAAA;IACLF,eAAEG,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IAAhBH,WAAEI,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAW,CAAA,EACHJ;IAAdA,eAAEI,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IACPJ,WAAEK,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA,CAH2BL,CAAAA;EAAW,aAAlCO,EAUbP,CAAAA,CAAEQ,UAVWD,CAUAP,CAAAA,CAAEE,SAVFK,CAAAA;CAAS,EAAA,OAAtBC,EAWPR,CAAAA,CAAEK,UAXKG,EAAAA;EAAU,WAUKN,EAEjBO,MAFiBP,CAAAA,MAAAA,EAAAA;IAAfF,eAAEQ,CAAAA,EAAAA,OAAAA,GAAAA,SAAAA;IACTR,WAAEK,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA;EACD,aAMLI,EAAAA,MAAAA;CAAM,EAAA;EAnBgB,WAAA,CAAA,EAmBtBA,MAnBsB,CAAA,MAAA,EAAA;IAuKhBC,eAAAA,CAAAA,EAAAA,OAAwB,GAAA,SAAA;IAAA,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,CAAA,CAAA,GAA0BT,SAAAA;EAAa,aAA1BU,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;CAAK,CAAA;;;;;;;;;;;;;;;;AAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAxGD,wBAAAA,WAAmCV,CAAAA,CAAEW,aAAaV,iBAA6E,2BAAXD,CAAAA,CAAEM;eAC7HN,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEO,UAAUP,CAAAA,CAAEE,WAAWF,CAAAA,CAAEM;qBAChCN,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEG;iBACpBH,CAAAA,CAAEI,YAAYJ,CAAAA,CAAEE;cACrBF,CAAAA,CAAEK;;;;;;;iBAOCL,CAAAA,CAAEQ,WAAWR,CAAAA,CAAEE;YACtBF,CAAAA,CAAEK;eACGI;;;;;;gBAMCA"}
+{"version":3,"file":"hitl.d.cts","names":["z","InferInteropZodInput","ToolConfigSchema","ZodBoolean","ZodOptional","ZodString","ZodTypeAny","ZodObject","input","Interrupt","TValue","HumanInTheLoopConfig","Omit","ActionRequest","Record","HumanInTheLoopRequest","AcceptPayload","ResponsePayload","EditPayload","HumanInTheLoopMiddlewareHumanResponse","ToolConfig","contextSchema","ZodUnion","ZodRecord","ZodDefault","HumanInTheLoopMiddlewareConfig","humanInTheLoopMiddleware","NonNullable","___types_js0","AgentMiddleware"],"sources":["../../../../src/agents/middlewareAgent/middleware/hitl.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { z } from \"zod/v3\";\nimport { InferInteropZodInput } from \"@langchain/core/utils/types\";\ndeclare const ToolConfigSchema: z.ZodObject<{\n    /**\n     * Whether the human can approve the current action without changes\n     */\n    allowAccept: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * Whether the human can reject the current action with feedback\n     */\n    allowEdit: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * Whether the human can approve the current action with edited content\n     */\n    allowRespond: z.ZodOptional<z.ZodBoolean>;\n    /**\n     * The description attached to the request for human input\n     */\n    description: z.ZodOptional<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    allowAccept?: boolean | undefined;\n    allowEdit?: boolean | undefined;\n    allowRespond?: boolean | undefined;\n    description?: string | undefined;\n}, {\n    allowAccept?: boolean | undefined;\n    allowEdit?: boolean | undefined;\n    allowRespond?: boolean | undefined;\n    description?: string | undefined;\n}>;\ntype ToolConfigSchema = z.input<typeof ToolConfigSchema>;\n/**\n * Represents information about an interrupt.\n */\nexport interface Interrupt<TValue = unknown> {\n    /**\n     * The ID of the interrupt.\n     */\n    id: string;\n    /**\n     * The requests for human input.\n     */\n    value: TValue;\n}\n/**\n * Configuration that defines which reviewer response types are permitted during a human interrupt.\n * These flags control what the human reviewer may do (e.g., accept/edit/respond),\n * not the tool action the agent has requested.\n */\nexport interface HumanInTheLoopConfig extends Omit<ToolConfigSchema, \"description\"> {\n}\n/**\n * Describes the agent-requested tool action (name and arguments).\n * This is what the AI intends to execute, subject to human review.\n */\nexport interface ActionRequest {\n    /**\n     * The tool/action name requested by the agent (e.g., \"send_email\").\n     */\n    action: string;\n    /**\n     * Arguments for the requested tool call (e.g., {\"a\": 1, \"b\": 2}).\n     */\n    args: Record<string, any>;\n}\n/**\n * Represents an interrupt triggered by the graph that requires human intervention\n * to approve, edit, or respond to an agent-requested tool action.\n *\n * @example\n * ```ts\n * const hitlRequest: HumanInTheLoopRequest = {\n *   actionRequest: { action: \"Approve XYZ action\", args: { ... } },\n *   config: { allowAccept: true, allowEdit: true, allowRespond: true },\n *   description: \"Please review the command before execution\"\n * };\n * response = interrupt([request])[0]\n * ```\n */\nexport interface HumanInTheLoopRequest {\n    /**\n     * The agent-requested tool action to be reviewed.\n     */\n    actionRequest: ActionRequest;\n    /**\n     * Which reviewer responses are allowed (accept/edit/respond).\n     */\n    config: HumanInTheLoopConfig;\n    /**\n     * Optional human-facing description shown in the approval prompt.\n     */\n    description?: string;\n}\n/**\n * Response when a human approves the agent-requested action.\n */\nexport interface AcceptPayload {\n    type: \"accept\";\n}\n/**\n * Response when a human provides a manual response instead of executing\n * the agent-requested action.\n */\nexport interface ResponsePayload {\n    type: \"response\";\n    args?: string;\n}\n/**\n * Response when a human edits the agent-requested action (tool name and/or args).\n */\nexport interface EditPayload {\n    type: \"edit\";\n    args: ActionRequest;\n}\nexport type HumanInTheLoopMiddlewareHumanResponse = AcceptPayload | ResponsePayload | EditPayload;\n/**\n * Configuration for a tool requiring human in the loop.\n */\nexport interface ToolConfig extends HumanInTheLoopConfig {\n    /**\n     * Human-facing description shown in the approval request.\n     */\n    description?: string;\n}\ndeclare const contextSchema: z.ZodObject<{\n    /**\n     * Mapping of tool name to allowed reviewer responses.\n     * If a tool doesn't have an entry, it's auto-approved by default.\n     *\n     * - `true` -> pause for approval and allow accept/edit/respond\n     * - `false` -> auto-approve (no human review)\n     * - `ToolConfig` -> explicitly specify which reviewer responses are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * Whether the human can approve the current action without changes\n         */\n        allowAccept: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * Whether the human can reject the current action with feedback\n         */\n        allowEdit: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * Whether the human can approve the current action with edited content\n         */\n        allowRespond: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * The description attached to the request for human input\n         */\n        description: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | undefined;\n    }, {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link ToolConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>;\nexport type HumanInTheLoopMiddlewareConfig = InferInteropZodInput<typeof contextSchema>;\n/**\n * Creates a Human-in-the-Loop (HITL) middleware for tool approval and oversight.\n *\n * This middleware intercepts tool calls made by an AI agent and provides human oversight\n * capabilities before execution. It enables selective approval workflows where certain tools\n * require human intervention while others can execute automatically.\n *\n * A invocation result that has been interrupted by the middleware will have a `__interrupt__`\n * property that contains the interrupt request. You can loop over the request to determine\n * which tools were interrupted, and how to handle them separately.\n *\n * ```ts\n * import { type ToolApprovalRequest, type HumanInTheLoopMiddlewareHumanResponse } from \"langchain/middleware\";\n * import { type Interrupt } from \"langchain\";\n *\n * const result = await agent.invoke(request);\n * const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<\n *   ToolApprovalRequest[]\n * >;\n * const resume: HumanInTheLoopMiddlewareHumanResponse[] =\n *   interruptRequest.value.map((request) => {\n *     if (request.action === \"calculator\") {\n *       return { id: request.toolCallId, type: \"accept\" };\n *     } else if (request.action === \"write_file\") {\n *       return {\n *         id: request.toolCallId,\n *         type: \"edit\",\n *         args: { filename: \"safe.txt\", content: \"Safe content\" },\n *       };\n *     }\n *\n *     throw new Error(`Unknown action: ${request.action}`);\n *   });\n *\n * // Resume with approval\n * await agent.invoke(new Command({ resume }), config);\n * ```\n *\n * ## Features\n *\n * - **Selective Tool Approval**: Configure which tools require human approval\n * - **Multiple Response Types**: Accept, edit, ignore, or manually respond to tool calls\n * - **Asynchronous Workflow**: Uses LangGraph's interrupt mechanism for non-blocking approval\n * - **Custom Approval Messages**: Provide context-specific descriptions for approval requests\n *\n * ## Response Types\n *\n * When a tool requires approval, the human operator can respond with:\n * - `accept`: Execute the tool with original arguments\n * - `edit`: Modify the tool arguments before execution\n * - `ignore`: Skip the tool and terminate the agent\n * - `response`: Provide a manual response instead of executing the tool\n *\n * @param options - Configuration options for the middleware\n * @param options.interruptOn - Per-tool configuration mapping tool names to their settings\n * @param options.interruptOn[toolName].allowAccept - Whether the human can approve the current action without changes\n * @param options.interruptOn[toolName].allowEdit - Whether the human can reject the current action with feedback\n * @param options.interruptOn[toolName].allowRespond - Whether the human can approve the current action with edited content\n * @param options.interruptOn[toolName].description - Custom approval message for the tool\n * @param options.messagePrefix - Default prefix for approval messages (default: \"Tool execution requires approval\"). Only used for tools that do not define a custom `description` in their ToolConfig.\n *\n * @returns A middleware instance that can be passed to `createAgent`\n *\n * @example\n * Basic usage with selective tool approval\n * ```typescript\n * import { humanInTheLoopMiddleware } from \"langchain/middleware\";\n * import { createAgent } from \"langchain\";\n *\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     // Interrupt write_file tool and allow edits or accepts\n *     \"write_file\": {\n *       allowEdit: true,\n *       allowAccept: true,\n *       description: \"⚠️ File write operation requires approval\"\n *     },\n *     // Auto-approve read_file tool\n *     \"read_file\": false\n *   }\n * });\n *\n * const agent = createAgent({\n *   model: \"openai:gpt-4\",\n *   tools: [writeFileTool, readFileTool],\n *   middleware: [hitlMiddleware]\n * });\n * ```\n *\n * @example\n * Handling approval requests\n * ```typescript\n * import { type HumanInTheLoopRequest, type Interrupt } from \"langchain/middleware\";\n * import { Command } from \"@langchain/langgraph\";\n *\n * // Initial agent invocation\n * const result = await agent.invoke({\n *   messages: [new HumanMessage(\"Write 'Hello' to output.txt\")]\n * }, config);\n *\n * // Check if agent is paused for approval\n * if (result.__interrupt__) {\n *   const interruptRequest = initialResult.__interrupt__?.[0] as Interrupt<\n *     HumanInTheLoopRequest[]\n *   >;\n *\n *   // Show tool call details to user\n *   console.log(\"Tool:\", interruptRequest.value[0].actionRequest);\n *   console.log(\"Allowed actions:\", interruptRequest.value[0].config);\n *\n *   // Resume with approval\n *   await agent.invoke(\n *     new Command({ resume: [{ type: \"accept\" }] }),\n *     config\n *   );\n * }\n * ```\n *\n * @example\n * Different response types\n * ```typescript\n * // Accept the tool call as-is\n * new Command({ resume: [{ type: \"accept\" }] })\n *\n * // Edit the tool arguments\n * new Command({\n *   resume: [{\n *     type: \"edit\",\n *     args: { action: \"write_file\", args: { filename: \"safe.txt\", content: \"Modified\" } }\n *   }]\n * })\n *\n * // Skip tool and terminate agent\n * new Command({ resume: [{ type: \"response\" }] })\n *\n * // Provide manual response\n * new Command({\n *   resume: [{\n *     type: \"response\",\n *     // this must be a string\n *     args: \"File operation not allowed in demo mode\"\n *   }]\n * })\n * ```\n *\n * @example\n * Production use case with database operations\n * ```typescript\n * const hitlMiddleware = humanInTheLoopMiddleware({\n *   interruptOn: {\n *     \"execute_sql\": {\n *       allowAccept: true,\n *       allowEdit: true,\n *       allowRespond: true,\n *       description: \"🚨 SQL query requires DBA approval\\nPlease review for safety and performance\"\n *     },\n *     \"read_schema\": false  // Reading metadata is safe\n *     \"delete_records\": {\n *       allowAccept: true,\n *       description: \"⛔ DESTRUCTIVE OPERATION - Requires manager approval\"\n *     }\n *   },\n *   messagePrefix: \"Database operation pending approval\"\n * });\n * ```\n *\n * @remarks\n * - Tool calls are processed in the order they appear in the AI message\n * - Auto-approved tools execute immediately without interruption\n * - Multiple tools requiring approval are bundled into a single interrupt\n * - The middleware operates in the `afterModel` phase, intercepting before tool execution\n * - Requires a checkpointer to maintain state across interruptions\n *\n * @see {@link createAgent} for agent creation\n * @see {@link Command} for resuming interrupted execution\n * @public\n */\nexport 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 accept/edit/respond\n     * - `false` -> auto-approve (no human review)\n     * - `ToolConfig` -> explicitly specify which reviewer responses are allowed for this tool\n     */\n    interruptOn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{\n        /**\n         * Whether the human can approve the current action without changes\n         */\n        allowAccept: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * Whether the human can reject the current action with feedback\n         */\n        allowEdit: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * Whether the human can approve the current action with edited content\n         */\n        allowRespond: z.ZodOptional<z.ZodBoolean>;\n        /**\n         * The description attached to the request for human input\n         */\n        description: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | undefined;\n    }, {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | undefined;\n    }>]>>>;\n    /**\n     * Prefix used when constructing human-facing approval messages.\n     * Provides context about the tool call being reviewed; does not change the underlying action.\n     *\n     * Note: This prefix is only applied for tools that do not provide a custom\n     * `description` via their {@link ToolConfig}. If a tool specifies a custom\n     * `description`, that per-tool text is used and this prefix is ignored.\n     */\n    descriptionPrefix: z.ZodDefault<z.ZodString>;\n}, \"strip\", z.ZodTypeAny, {\n    interruptOn?: Record<string, boolean | {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    descriptionPrefix: string;\n}, {\n    interruptOn?: Record<string, boolean | {\n        allowAccept?: boolean | undefined;\n        allowEdit?: boolean | undefined;\n        allowRespond?: boolean | undefined;\n        description?: string | undefined;\n    }> | undefined;\n    descriptionPrefix?: string | undefined;\n}>, any>;\nexport {};\n"],"mappings":"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"}