Function humanInTheLoopMiddleware

import { type HITLRequest, type HITLResponse } from "langchain";
import { type Interrupt } from "langchain";

const result = await agent.invoke(request);
const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;

// Examine the action requests and review configs
const actionRequests = interruptRequest.value.actionRequests;
const reviewConfigs = interruptRequest.value.reviewConfigs;

// Create decisions for each action
const resume: HITLResponse = {
  decisions: actionRequests.map((action, i) => {
    if (action.name === "calculator") {
      return { type: "approve" };
    } else if (action.name === "write_file") {
      return {
        type: "edit",
        editedAction: { name: "write_file", args: { filename: "safe.txt", content: "Safe content" } }
      };
    }
    return { type: "reject", message: "Action not allowed" };
  })
};

// Resume with decisions
await agent.invoke(new Command({ resume }), config);
Copy

Returns AgentMiddleware<
    undefined,
    ZodObject<
        {
            descriptionPrefix: ZodDefault<ZodString>;
            interruptOn: ZodOptional<
                ZodRecord<
                    ZodString,
                    ZodUnion<
                        [
                            ZodBoolean,
                            ZodObject<
                                {
                                    allowedDecisions: ZodArray<ZodEnum<(...)>, "many">;
                                    argsSchema: ZodOptional<ZodRecord<(...), (...)>>;
                                    description: ZodOptional<ZodUnion<(...)>>;
                                },
                                "strip",
                                ZodTypeAny,
                                {
                                    allowedDecisions: ((...) | (...) | (...))[];
                                    argsSchema?: Record<(...), (...)>;
                                    description?: string | ((...args: ...) => ...);
                                },
                                {
                                    allowedDecisions: ((...) | (...) | (...))[];
                                    argsSchema?: Record<(...), (...)>;
                                    description?: string | ((...args: ...) => ...);
                                },
                            >,
                        ],
                    >,
                >,
            >;
        },
        "strip",
        ZodTypeAny,
        {
            descriptionPrefix: string;
            interruptOn?: Record<
                string,
                | boolean
                | {
                    allowedDecisions: ("approve" | "edit" | "reject")[];
                    argsSchema?: Record<string, any>;
                    description?:
                        | string
                        | (
                            (
                                ...args: [
                                    ToolCall,
                                    AgentBuiltInState,
                                    Runtime<(...)>,
                                    ...unknown[],
                                ],
                            ) => string | Promise<(...)>
                        );
                },
            >;
        },
        {
            descriptionPrefix?: string;
            interruptOn?: Record<
                string,
                | boolean
                | {
                    allowedDecisions: ("approve" | "edit" | "reject")[];
                    argsSchema?: Record<string, any>;
                    description?:
                        | string
                        | (
                            (
                                ...args: [
                                    ToolCall,
                                    AgentBuiltInState,
                                    Runtime<(...)>,
                                    ...unknown[],
                                ],
                            ) => string | Promise<(...)>
                        );
                },
            >;
        },
    >,
    any,
>

A middleware instance that can be passed to createAgent

import { humanInTheLoopMiddleware } from "langchain";
import { createAgent } from "langchain";

const hitlMiddleware = humanInTheLoopMiddleware({
  interruptOn: {
    // Interrupt write_file tool and allow edits or approvals
    "write_file": {
      allowedDecisions: ["approve", "edit"],
      description: "⚠️ File write operation requires approval"
    },
    // Auto-approve read_file tool
    "read_file": false
  }
});

const agent = createAgent({
  model: "openai:gpt-4",
  tools: [writeFileTool, readFileTool],
  middleware: [hitlMiddleware]
});
Copy

import { type HITLRequest, type HITLResponse, type Interrupt } from "langchain";
import { Command } from "@langchain/langgraph";

// Initial agent invocation
const result = await agent.invoke({
  messages: [new HumanMessage("Write 'Hello' to output.txt")]
}, config);

// Check if agent is paused for approval
if (result.__interrupt__) {
  const interruptRequest = result.__interrupt__?.[0] as Interrupt<HITLRequest>;

  // Show tool call details to user
  console.log("Actions:", interruptRequest.value.actionRequests);
  console.log("Review configs:", interruptRequest.value.reviewConfigs);

  // Resume with approval
  const resume: HITLResponse = {
    decisions: [{ type: "approve" }]
  };
  await agent.invoke(
    new Command({ resume }),
    config
  );
}
Copy

import { type HITLResponse } from "langchain";

// Approve the tool call as-is
const resume: HITLResponse = {
  decisions: [{ type: "approve" }]
};

// Edit the tool arguments
const resume: HITLResponse = {
  decisions: [{
    type: "edit",
    editedAction: { name: "write_file", args: { filename: "safe.txt", content: "Modified" } }
  }]
};

// Reject with feedback
const resume: HITLResponse = {
  decisions: [{
    type: "reject",
    message: "File operation not allowed in demo mode"
  }]
};
Copy

const hitlMiddleware = humanInTheLoopMiddleware({
  interruptOn: {
    "execute_sql": {
      allowedDecisions: ["approve", "edit", "reject"],
      description: "🚨 SQL query requires DBA approval\nPlease review for safety and performance"
    },
    "read_schema": false,  // Reading metadata is safe
    "delete_records": {
      allowedDecisions: ["approve", "reject"],
      description: "⛔ DESTRUCTIVE OPERATION - Requires manager approval"
    }
  },
  descriptionPrefix: "Database operation pending approval"
});
Copy

import { type DescriptionFactory, type ToolCall } from "langchain";
import type { AgentBuiltInState, Runtime } from "langchain/agents";

// Define a dynamic description factory
const formatToolDescription: DescriptionFactory = (
  toolCall: ToolCall,
  state: AgentBuiltInState,
  runtime: Runtime<unknown>
) => {
  return `Tool: ${toolCall.name}\nArguments:\n${JSON.stringify(toolCall.args, null, 2)}`;
};

const hitlMiddleware = humanInTheLoopMiddleware({
  interruptOn: {
    "write_file": {
      allowedDecisions: ["approve", "edit"],
      // Use dynamic description that can access tool call, state, and runtime
      description: formatToolDescription
    },
    // Or use an inline function
    "send_email": {
      allowedDecisions: ["approve", "reject"],
      description: (toolCall, state, runtime) => {
        const { to, subject } = toolCall.args;
        return `Email to ${to}\nSubject: ${subject}\n\nRequires approval before sending`;
      }
    }
  }
});
Copy