中断与人机交互

没有刹车

智能体在无人监督的情况下自动执行了所有操作——包括那些不该自动执行的操作。

开始之前

核心机制

interrupt() 暂停，Command({ resume }) 恢复

import { interrupt } from "@langchain/langgraph";

async function approvalNode(state) {
    // 暂停并请求审批
    const approved = interrupt("Do you approve this action?");
    // Command({ resume: true }) 传入的值成为 approved
    return { approved };
}

📄 完整代码：08_basic_interrupt.ts

暂停与恢复

完整的中断-恢复代码流程

import { Command } from "@langchain/langgraph";

const config = { configurable: { thread_id: "thread-1" } };

// 第一次运行 — 遇到中断暂停
const result = await graph.invoke({ input: "data" }, config);

// 查看中断内容
console.log(result.__interrupt__);
// [{ value: 'Do you approve this action?', ... }]

// 用人类的响应恢复
await graph.invoke(new Command({ resume: true }), config);

📄 完整代码：08_basic_interrupt.ts

审批模式

interrupt 返回布尔值，决定走哪条路

const approvalNode: typeof State.Node = (state) => {
  const isApproved = interrupt({
    question: "Do you want to proceed?",
    details: state.actionDetails,
  });

  if (isApproved) {
    return new Command({ goto: "proceed" });
  } else {
    return new Command({ goto: "cancel" });
  }
};

// 恢复时传入 true 审批或 false 拒绝
await graph.invoke(new Command({ resume: true }), config);   // 审批
await graph.invoke(new Command({ resume: false }), config);  // 拒绝

📄 完整代码：08_approval_pattern.ts

审查与编辑

人类修改智能体生成的内容后再继续

const reviewNode: typeof State.Node = (state) => {
  const editedContent = interrupt({
    instruction: "Review and edit this content",
    content: state.generatedText,
  });
  return { generatedText: editedContent };
};

// 恢复时提供编辑后的内容
await graph.invoke(
  new Command({ resume: "The edited and improved text" }),
  config
);

📄 完整代码：08_review_edit.ts

工具中的中断

interrupt 不只能在节点里用——工具函数里也能用

import { tool } from "@langchain/core/tools";

const sendEmailTool = tool(
  async ({ to, subject, body }) => {
    const response = interrupt({
      action: "send_email",
      to, subject, body,
      message: "Approve sending this email?",
    });

    if (response?.action === "approve") {
      return `Email sent to ${response.to ?? to}`;
    }
    return "Email cancelled by user";
  },
  {
    name: "send_email",
    description: "Send an email",
    schema: z.object({ to: z.string(), subject: z.string(), body: z.string() }),
  }
);

📄 完整代码：08_tool_interrupt.ts

输入验证

用 while 循环反复询问，直到获得合法输入

const getAgeNode: typeof State.Node = (state) => {
  let prompt = "What is your age?";

  while (true) {
    const answer = interrupt(prompt);
    if (typeof answer === "number" && answer > 0) {
      return { age: answer };
    } else {
      prompt = `'${answer}' is not a valid age. Please enter a positive number.`;
    }
  }
};

📄 完整代码：08_input_validation.ts

多个中断

并行分支各有中断时，用 ID 映射恢复值

import { isInterrupted, INTERRUPT } from "@langchain/langgraph";

// 两个并行节点各有一个 interrupt
const interruptedResult = await graph.invoke({ vals: [] }, config);
// { __interrupt__: [{ id: '...', value: 'question_a' }, { id: '...', value: 'question_b' }] }

// 一次恢复所有中断
const resumeMap: Record<string, string> = {};
if (isInterrupted(interruptedResult)) {
  for (const i of interruptedResult[INTERRUPT]) {
    if (i.id != null) {
      resumeMap[i.id] = `answer for ${i.value}`;
    }
  }
}
const result = await graph.invoke(new Command({ resume: resumeMap }), config);

📄 完整代码：08_multiple_interrupts.ts

五条铁律

违反任何一条都会导致中断行为异常

排错指南

动手练习

构建一个带审批门的文档发布流程

• 节点 1：生成文档内容
• 节点 2：interrupt() 暂停，展示文档给人类审批
• 如果审批通过 → 节点 3：发布文档
• 如果审批拒绝 → 回到节点 1，附带拒绝理由重新生成

参考答案

const State = new StateSchema({
  topic: z.string(),
  content: z.string(),
  feedback: z.string().optional(),
});

// 节点 1：生成文档
const generateDoc: GraphNode<typeof State> = async (state) => {
  const prompt = state.feedback
    ? `Rewrite doc about ${state.topic}. Feedback: ${state.feedback}`
    : `Write a doc about ${state.topic}`;
  const msg = await model.invoke(prompt);
  return { content: msg.content };
};

// 节点 2：审批
const review: GraphNode<typeof State> = (state) => {
  const decision = interrupt({ content: state.content, question: "Approve?" });
  if (decision.approved) return new Command({ goto: "publish" });
  return { feedback: decision.feedback };
};

本章回顾

延伸阅读