中断

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

async function approvalNode(state: State) {
    // 暂停并请求批准
    const approved = interrupt("你批准这个操作吗？");

    // Command({ resume: ... }) 提供的值会返回到这个变量中
    return { approved };
}

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

// 初次运行 - 触发中断并暂停
// thread_id 是指回已保存检查点的持久化指针
const config = { configurable: { thread_id: "thread-1" } };
const result = await graph.invoke({ input: "data" }, config);

// 检查被中断的内容
// __interrupt__ 镜像了你传递给 interrupt() 的每个有效负载
console.log(result.__interrupt__);
// [{ value: '你批准这个操作吗？', ... }]

// 使用人类的响应恢复
// Command({ resume }) 会在节点中将该值从 interrupt() 返回
await graph.invoke(new Command({ resume: true }), config);

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

let streamInput: Record<string, unknown> | Command = initialInput;

while (true) {
  const stream = await graph.streamEvents(streamInput, {
    ...config,
    version: "v3",
  });

  // Stream LLM message chunks (including any in subgraphs) as they arrive.
  for await (const message of stream.messages) {
    for await (const token of message.text) {
      displayStreamingContent(token);
    }
  }

  // After the run finishes (or pauses), check for interrupts and resume.
  if (!stream.interrupted) {
    const finalState = await stream.output;
    break;
  }

  const interruptInfo = stream.interrupts[0].value;
  const userResponse = await getUserInput(interruptInfo);
  streamInput = new Command({ resume: userResponse });
}

import {
  Annotation,
  Command,
  END,
  INTERRUPT,
  MemorySaver,
  START,
  StateGraph,
  interrupt,
  isInterrupted,
} from "@langchain/langgraph";

const State = Annotation.Root({
  vals: Annotation<string[]>({
    reducer: (left, right) =>
      left.concat(Array.isArray(right) ? right : [right]),
    default: () => [],
  }),
});

function nodeA(_state: typeof State.State) {
  const answer = interrupt("question_a") as string;
  return { vals: [`a:${answer}`] };
}

function nodeB(_state: typeof State.State) {
  const answer = interrupt("question_b") as string;
  return { vals: [`b:${answer}`] };
}

const graph = new StateGraph(State)
  .addNode("a", nodeA)
  .addNode("b", nodeB)
  .addEdge(START, "a")
  .addEdge(START, "b")
  .addEdge("a", END)
  .addEdge("b", END)
  .compile({ checkpointer: new MemorySaver() });

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

async function main() {
  // 步骤 1: 调用 - 两个并行节点都触发 interrupt() 并暂停
  const interruptedResult = await graph.invoke({ vals: [] }, config);
  console.log(interruptedResult);
  /*
  {
    vals: [],
    __interrupt__: [
      { id: '...', value: 'question_a' },
      { id: '...', value: 'question_b' }
    ]
  }
  */

  // 步骤 2: 一次性恢复所有挂起的中断
  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);

  console.log("Final state:", result);
  //> Final state: { vals: ['a:answer for question_a', 'b:answer for question_b'] }
}

main().catch(console.error);

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

const approvalNode: typeof State.Node = (state) => {
  // 暂停执行；有效负载会暴露在 result.__interrupt__ 中
  const isApproved = interrupt({
    question: "是否继续？",
    details: state.actionDetails
  });

  // 根据响应进行路由
  if (isApproved) {
    return new Command({ goto: "proceed" }); // 在提供恢复有效负载后执行
  } else {
    return new Command({ goto: "cancel" });
  }
}

// 批准
await graph.invoke(new Command({ resume: true }), config);

// 拒绝
await graph.invoke(new Command({ resume: false }), config);

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

const reviewNode: typeof State.Node = (state) => {
  // 暂停并显示当前内容以供审查（有效负载会暴露在 result.__interrupt__ 中）
  const editedContent = interrupt({
    instruction: "审查并编辑此内容",
    content: state.generatedText
  });

  // 用编辑后的版本更新状态
  return { generatedText: editedContent };
}

await graph.invoke(
  new Command({ resume: "已编辑和改进的文本" }), // 该值将成为 interrupt() 的返回值
  config
);

import { tool } from "@langchain/core/tools";
import { interrupt } from "@langchain/langgraph";
import * as z from "zod";

const sendEmailTool = tool(
  async ({ to, subject, body }) => {
    // 发送前暂停；有效负载会暴露在 result.__interrupt__ 中
    const response = interrupt({
      action: "send_email",
      to,
      subject,
      body,
      message: "批准发送这封邮件吗？",
    });

    if (response?.action === "approve") {
      // 恢复值可以在执行前覆盖输入
      const finalTo = response.to ?? to;
      const finalSubject = response.subject ?? subject;
      const finalBody = response.body ?? body;
      return `邮件已发送至 ${finalTo}，主题为 '${finalSubject}'`;
    }
    return "用户取消了邮件";
  },
  {
    name: "send_email",
    description: "Send an email to a recipient",
    schema: z.object({
      to: z.string(),
      subject: z.string(),
      body: z.string(),
    }),
  },
);

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

const getAgeNode: typeof State.Node = (state) => {
  let prompt = "你的年龄是多少？";

  while (true) {
    const answer = interrupt(prompt); // 有效负载会暴露在 result.__interrupt__ 中

    // 验证输入
    if (typeof answer === "number" && answer > 0) {
      // 有效输入 - 继续
      return { age: answer };
    } else {
      // 无效输入 - 用更具体的提示再次询问
      prompt = `'${answer}' 不是一个有效的年龄。请输入一个正数。`;
    }
  }
}

async function nodeA(state: State) {
    // ❌ 糟糕的做法：在裸 try/catch 中包裹中断会捕获中断异常
    try {
        const name = interrupt("你叫什么名字？");
    } catch (err) {
        console.error(error);
    }
    return state;
}

async function nodeA(state: State) {
    // ✅ 好的做法：中断调用每次都以相同的顺序发生
    const name = interrupt("你叫什么名字？");
    const age = interrupt("你的年龄是多少？");
    const city = interrupt("你住在哪个城市？");

    return {
        name,
        age,
        city
    };
}

async function nodeInParentGraph(state: State) {
    someCode(); // <-- 恢复时将重新执行这部分
    // 以函数形式调用子图。
    // 该子图包含一个 `interrupt` 调用。
    const subgraphResult = await subgraph.invoke(someInput);
    // ...
}

async function nodeInSubgraph(state: State) {
    someOtherCode(); // <-- 恢复时这也将重新执行
    const result = interrupt("你叫什么名字？");
    // ...
}