#Step 13 — Human-in-the-Loop

import { Command, END, MemorySaver, START, StateGraph, interrupt, isInterrupted } from "@langchain/langgraph";
import * as z from "zod";

let sideEffectCount = 0;

const ApprovalState = z.object({
  amount: z.number(),
  status: z.string().nullable().default(() => null),
});

const approvalGraph = new StateGraph(ApprovalState)
  .addNode("charge", (state) => {
    // ⚠️ interrupt 이전의 코드입니다. 재개할 때 "다시" 실행됩니다.
    sideEffectCount += 1;
    console.log(`[interrupt 이전 코드 실행] 누적 ${sideEffectCount}회`);

    // 여기서 실행이 멈춥니다. 아래 코드는 지금 실행되지 않습니다.
    const decision = interrupt({
      question: `${state.amount}원을 결제할까요?`,
      amount: state.amount,
    });

    return { status: decision === true ? "결제완료" : "취소됨" };
  })
  .addEdge(START, "charge")
  .addEdge("charge", END)
  .compile({ checkpointer: new MemorySaver() }); // ← 없으면 에러

const chargeConfig = { configurable: { thread_id: "charge-1" } };

const paused = await approvalGraph.invoke({ amount: 50_000 }, chargeConfig);
if (isInterrupted(paused)) {
  console.log(JSON.stringify(paused.__interrupt__, null, 2));
}
console.log("status =", paused.status);

const resumed = await approvalGraph.invoke(new Command({ resume: true }), chargeConfig);
console.log("재개 후 status =", resumed.status);
console.log(`부수효과 ${sideEffectCount}회`);

const noCheckpointerGraph = new StateGraph(ApprovalState)
  .addNode("ask", () => {
    interrupt("승인해 주세요");
    return {};
  })
  .addEdge(START, "ask")
  .addEdge("ask", END)
  .compile(); // ← checkpointer 를 일부러 뺐습니다

try {
  await noCheckpointerGraph.invoke({ amount: 1000 });
} catch (error) {
  console.log((error as Error).constructor.name);
  console.log((error as Error).message.split("\n")[0]);
}

const swallowGraph = new StateGraph(ApprovalState)
  .addNode("ask", () => {
    try {
      const decision = interrupt("승인해 주세요");
      return { status: `승인값=${String(decision)}` };
    } catch (error) {
      // ⚠️ 중단 신호를 잡아 버렸습니다.
      console.log(`interrupt 를 잡아버렸습니다: ${(error as Error).name}`);
      return { status: "삼켜짐" };
    }
  })
  .addEdge(START, "ask")
  .addEdge("ask", END)
  .compile({ checkpointer: new MemorySaver() });

const swallowed = await swallowGraph.invoke({ amount: 1000 }, { configurable: { thread_id: "sw" } });
console.log("status =", swallowed.status);
console.log("__interrupt__ 있음?", "__interrupt__" in swallowed);

const twoGraph = new StateGraph(TwoState)
  .addNode("askTwice", () => {
    const first = interrupt("첫 번째 질문");
    const second = interrupt("두 번째 질문");
    return { answers: [`1=${String(first)}`, `2=${String(second)}`] };
  })
  // ...
  .compile({ checkpointer: new MemorySaver() });

const t1 = await twoGraph.invoke({}, twoConfig);                              // "첫 번째 질문"
const t2 = await twoGraph.invoke(new Command({ resume: "답변A" }), twoConfig); // "두 번째 질문"
const t3 = await twoGraph.invoke(new Command({ resume: "답변B" }), twoConfig); // 완료

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import { MemorySaver } from "@langchain/langgraph";
import * as z from "zod";

const sendEmail = tool(
  async ({ to, subject, body }) => {
    console.log(`📧 [실제 발송] to=${to}`);
    return `${to} 에게 메일을 보냈습니다.`;
  },
  {
    name: "send_email",
    description: "지정한 수신자에게 이메일을 발송합니다. 되돌릴 수 없습니다.",
    schema: z.object({
      to: z.string().describe("수신자 이메일 주소"),
      subject: z.string().describe("메일 제목"),
      body: z.string().describe("메일 본문"),
    }),
  },
);

const emailAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  // OpenAI 를 쓰려면: model: "openai:gpt-5.5"
  tools: [sendEmail, searchContact],
  systemPrompt: "당신은 사용자를 대신해 메일을 보내는 비서입니다.",
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        send_email: {
          allowedDecisions: ["approve", "edit", "reject"],
          description: "🚨 메일이 실제로 발송됩니다. 수신자와 내용을 확인하세요.",
        },
        search_contact: false, // 읽기 전용은 막지 않습니다
      },
      descriptionPrefix: "실행 승인이 필요합니다",
    }),
  ],
  checkpointer: new MemorySaver(), // ← HITL 미들웨어도 checkpointer 필수
});

const agentConfig = { configurable: { thread_id: "email-1" } };
const step1 = await emailAgent.invoke(
  { messages: [{ role: "user", content: "김민수에게 '내일 회의 확인' 이라는 제목으로 메일 보내줘." }] },
  agentConfig,
);
console.log("실제 발송된 메일 수:", sentLog.length); // → 0

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

const approved = await emailAgent.invoke(
  new Command({ resume: { decisions: [{ type: "approve" }] } }),
  agentConfig, // ← 같은 thread_id 여야 합니다
);
console.log("실제 발송된 메일 수:", sentLog.length); // → 1

new Command({
  resume: {
    decisions: [ /* 도구 호출 하나당 결정 하나 */ ],
  },
})

// 그래프 예제에서는 맞았던 형식
await wrongAgent.invoke(new Command({ resume: true }), wrongConfig);

// "accept" 는 존재하지 않습니다. 올바른 이름은 "approve" 입니다.
await wrongAgent.invoke(new Command({ resume: { decisions: [{ type: "accept" }] } }), wrongConfig);

// 도구 호출은 1개인데 결정을 2개 보내면
await agent.invoke(new Command({ resume: { decisions: [{ type: "approve" }, { type: "approve" }] } }), config);

// node_modules/langchain/dist/agents/middleware/hitl.d.ts 에서 확인
declare const DecisionType: z.ZodEnum<["approve", "edit", "reject"]>;

interface ApproveDecision { type: "approve"; }
interface EditDecision { type: "edit"; editedAction: Action; }   // Action = { name, args }
interface RejectDecision { type: "reject"; message?: string; }
type Decision = ApproveDecision | EditDecision | RejectDecision;

const editAction = (editPaused.__interrupt__?.[0]?.value as HITLValue).actionRequests[0];
console.log("모델이 요청한 인자:", JSON.stringify(editAction?.args));

const edited = await editAgent.invoke(
  new Command({
    resume: {
      decisions: [{
        type: "edit",
        editedAction: {
          name: "send_email",
          args: {
            to: "correct@example.com",                  // ← 사람이 고친 값
            subject: editAction?.args.subject ?? "초안", // ← 나머지는 원래 값 그대로
            body: editAction?.args.body ?? "본문",
          },
        },
      }],
    },
  }),
  editConfig,
);

const rejected = await rejectAgent.invoke(
  new Command({
    resume: {
      decisions: [{
        type: "reject",
        message: "발송을 거부했습니다. 이 메일은 보내면 안 됩니다. 다시 시도하지 마세요.",
      }],
    },
  }),
  rejectConfig,
);

const step1 = await emailAgent.invoke({ messages: [/* ... */] }, agentConfig);
console.log(JSON.stringify(step1.__interrupt__, null, 2));

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

type ActionRequest = { name: string; args: Record<string, unknown>; description?: string };
type ReviewConfig = { actionName: string; allowedDecisions: string[] };
type HITLValue = { actionRequests: ActionRequest[]; reviewConfigs: ReviewConfig[] };

function describeInterrupt(result: unknown): void {
  if (!isInterrupted(result)) {
    console.log("중단되지 않았습니다.");
    return;
  }

  for (const item of result.__interrupt__) {
    const value = item.value as HITLValue;
    for (const [i, action] of value.actionRequests.entries()) {
      // 인덱스가 아니라 actionName 으로 짝짓습니다
      const review = value.reviewConfigs.find((r) => r.actionName === action.name);
      console.log(`── 승인 요청 #${i + 1} ──`);
      console.log(`도구      : ${action.name}`);
      console.log(`인자      : ${JSON.stringify(action.args, null, 2)}`);
      console.log(`설명      : ${action.description ?? "(없음)"}`);
      console.log(`가능한 결정: ${review?.allowedDecisions.join(" / ") ?? "?"}`);
    }
  }
}

const asyncConfig = { configurable: { thread_id: "async-1" } };

await asyncAgent.invoke(
  { messages: [{ role: "user", content: "later@example.com 으로 '나중에' 메일 보내줘." }] },
  asyncConfig,
);
console.log("승인 요청을 큐에 넣었습니다.");

// 이 사이에 서버가 재시작돼도, 체크포인터가 영속이라면 재개됩니다.
await new Promise((resolve) => setTimeout(resolve, 3000));

const late = await asyncAgent.invoke(
  new Command({ resume: { decisions: [{ type: "approve" }] } }),
  asyncConfig, // thread_id 만 있으면 재개됩니다
);

import * as readline from "node:readline/promises";
import { isInterrupted } from "@langchain/langgraph";

const cliAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [sendEmail, searchContact],
  systemPrompt: "당신은 메일 비서입니다. 연락처를 찾은 뒤 메일을 발송하세요.",
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        send_email: {
          allowedDecisions: ["approve", "edit", "reject"],
          description: "메일이 실제로 발송됩니다.",
        },
      },
    }),
  ],
  checkpointer: new MemorySaver(),
});

const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
const cliConfig = { configurable: { thread_id: "cli-1" } };

// 첫 입력은 사용자 메시지, 이후부터는 Command 입니다. 타입이 갈리므로 유니온으로 받습니다.
let next: { messages: Array<{ role: string; content: string }> } | Command = {
  messages: [{ role: "user", content: "이지은에게 '점심 같이 먹어요' 라는 제목으로 메일 보내줘." }],
};

// 중단이 여러 번 날 수 있으므로 루프를 돕니다.
while (true) {
  const result = await cliAgent.invoke(next, cliConfig);

  if (!isInterrupted(result)) {
    console.log("\n── 최종 답변 ──");
    printMessages(result.messages.slice(-1));
    break;
  }

  const value = result.__interrupt__[0]?.value as HITLValue;
  const action = value.actionRequests[0];

  console.log("\n┌─ 승인 요청 ─────────────────────────");
  console.log(`│ 도구: ${action?.name}`);
  console.log(`│ 인자: ${JSON.stringify(action?.args)}`);
  console.log("└─────────────────────────────────────");

  const answer = (await rl.question("승인하시겠습니까? [y=승인 / n=거부 / e=수정]: ")).trim().toLowerCase();

  if (answer === "y") {
    next = new Command({ resume: { decisions: [{ type: "approve" }] } });
  } else if (answer === "e") {
    const newTo = await rl.question("새 수신자: ");
    next = new Command({
      resume: {
        decisions: [{
          type: "edit",
          editedAction: {
            name: action?.name ?? "send_email",
            args: { ...action?.args, to: newTo },  // 기존 인자를 펼치고 바꿀 것만 덮어씀
          },
        }],
      },
    });
  } else {
    const reason = await rl.question("거부 이유: ");
    next = new Command({
      resume: { decisions: [{ type: "reject", message: reason || "사용자가 거부했습니다." }] },
    });
  }
}

rl.close();

/**
 * Step 13 — Human-in-the-Loop
 * 실행: npx tsx docs/reference/langchain/step-13-hitl/practice.ts
 *
 * 본문 13-1 ~ 13-8 의 예제를 순서대로 담았습니다.
 * [13-2] 와 [13-6] 의 일부는 모델 없이 도는 그래프 예제라 API 키 없이도 실행됩니다.
 * [13-3] 이후는 실제 모델을 호출하므로 ANTHROPIC_API_KEY 가 필요합니다.
 *
 * 마지막 [13-8] 은 터미널에서 y/n 입력을 받습니다. 파일을 통째로 실행하면
 * 앞 절의 출력이 다 지나간 뒤 프롬프트가 뜹니다.
 */
import "dotenv/config";

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import {
  Command,
  END,
  MemorySaver,
  START,
  StateGraph,
  interrupt,
  isInterrupted,
} from "@langchain/langgraph";
import * as readline from "node:readline/promises";
import * as z from "zod";

import { printSection, printMessages, printJson } from "../project/src/lib/print.js";

/* ===== [13-1] 왜 사람이 끼어들어야 하나 ===== */

// 이 절은 개념 설명이라 실행할 코드가 없습니다.
// 다만 "되돌릴 수 없는 행동"이 무엇인지 코드로 표시해 두면 감이 옵니다.
//
// 아래 도구는 이 파일 전체에서 재사용합니다. 실제로 메일을 보내지는 않고
// 콘솔에 찍기만 하지만, sentLog 에 흔적을 남깁니다.
// "승인 없이 실행되었는가"를 이 배열로 검증할 겁니다.

const sentLog: string[] = [];

const sendEmail = tool(
  async ({ to, subject, body }) => {
    // 실제 서비스라면 여기서 SMTP 로 진짜 메일이 나갑니다. 되돌릴 수 없습니다.
    sentLog.push(to);
    console.log(`   📧 [실제 발송] to=${to} subject=${subject} body=${body.slice(0, 30)}...`);
    return `${to} 에게 메일을 보냈습니다.`;
  },
  {
    name: "send_email",
    description: "지정한 수신자에게 이메일을 발송합니다. 되돌릴 수 없습니다.",
    schema: z.object({
      to: z.string().describe("수신자 이메일 주소"),
      subject: z.string().describe("메일 제목"),
      body: z.string().describe("메일 본문"),
    }),
  },
);

// 읽기 전용 도구 — 되돌릴 수 있으므로 승인이 필요 없습니다.
const searchContact = tool(
  async ({ name }) => {
    const book: Record<string, string> = {
      김민수: "minsu@example.com",
      이지은: "jieun@example.com",
    };
    return book[name] ?? "연락처를 찾지 못했습니다.";
  },
  {
    name: "search_contact",
    description: "이름으로 이메일 주소를 찾습니다.",
    schema: z.object({ name: z.string().describe("찾을 사람 이름") }),
  },
);

/* ===== [13-2] interrupt() 의 동작 원리 ===== */

printSection("[13-2] interrupt() — 실행이 멈추고 체크포인트에 저장된다");

// 모델 없이 순수 그래프로 interrupt 의 동작만 관찰합니다.
// 부수효과가 몇 번 실행되는지 세기 위한 카운터입니다.
let sideEffectCount = 0;

const ApprovalState = z.object({
  amount: z.number(),
  status: z.string().nullable().default(() => null),
});

const approvalGraph = new StateGraph(ApprovalState)
  .addNode("charge", (state) => {
    // ⚠️ interrupt 이전의 코드입니다. 재개할 때 "다시" 실행됩니다.
    sideEffectCount += 1;
    console.log(`   [interrupt 이전 코드 실행] 누적 ${sideEffectCount}회`);

    // 여기서 실행이 멈춥니다. 아래 코드는 지금 시점에 실행되지 않습니다.
    const decision = interrupt({
      question: `${state.amount}원을 결제할까요?`,
      amount: state.amount,
    });

    return { status: decision === true ? "결제완료" : "취소됨" };
  })
  .addEdge(START, "charge")
  .addEdge("charge", END)
  .compile({ checkpointer: new MemorySaver() }); // ← checkpointer 없으면 interrupt 가 에러

const chargeConfig = { configurable: { thread_id: "charge-1" } };

const paused = await approvalGraph.invoke({ amount: 50_000 }, chargeConfig);

console.log("\n   멈춘 뒤 돌아온 결과:");
// isInterrupted 는 타입 가드입니다. 직접 만든 그래프의 상태 타입에는
// __interrupt__ 가 선언돼 있지 않아서, 이 가드를 통과해야 tsc 가 읽게 해 줍니다.
if (isInterrupted(paused)) {
  printJson("   __interrupt__", paused.__interrupt__);
}
console.log("   status =", paused.status, "(아직 노드가 끝나지 않아 null 입니다)");

// 재개. Command 의 resume 값이 곧 interrupt() 의 반환값이 됩니다.
const resumed = await approvalGraph.invoke(new Command({ resume: true }), chargeConfig);
console.log("\n   재개 후 status =", resumed.status);
console.log(`   ⚠️ 부수효과는 총 ${sideEffectCount}회 실행되었습니다 (1회가 아닙니다!)`);

/* ===== [13-2b] checkpointer 없이 interrupt 하면 ===== */

printSection("[13-2b] checkpointer 없이 interrupt 하면 무슨 일이 일어나나");

const noCheckpointerGraph = new StateGraph(ApprovalState)
  .addNode("ask", () => {
    interrupt("승인해 주세요");
    return {};
  })
  .addEdge(START, "ask")
  .addEdge("ask", END)
  .compile(); // ← checkpointer 를 일부러 뺐습니다

try {
  await noCheckpointerGraph.invoke({ amount: 1000 });
  console.log("   여기에 도달하면 안 됩니다.");
} catch (error) {
  // GraphValueError: No checkpointer set
  console.log(`   ✅ 예상대로 에러: ${(error as Error).constructor.name}`);
  console.log(`   메시지: ${(error as Error).message.split("\n")[0]}`);
}

/* ===== [13-2c] interrupt 를 try/catch 로 감싸면 ===== */

printSection("[13-2c] interrupt 를 try/catch 로 감싸면 — 조용히 삼켜진다");

const swallowGraph = new StateGraph(ApprovalState)
  .addNode("ask", () => {
    try {
      const decision = interrupt("승인해 주세요");
      return { status: `승인값=${String(decision)}` };
    } catch (error) {
      // ⚠️ GraphInterrupt 는 "예외처럼" 던져집니다.
      //    여기서 잡으면 중단 신호가 그래프까지 전달되지 않습니다.
      console.log(`   😱 interrupt 를 잡아버렸습니다: ${(error as Error).name}`);
      return { status: "삼켜짐" };
    }
  })
  .addEdge(START, "ask")
  .addEdge("ask", END)
  .compile({ checkpointer: new MemorySaver() });

const swallowed = await swallowGraph.invoke({ amount: 1000 }, { configurable: { thread_id: "sw" } });
console.log("   status =", swallowed.status);
console.log("   __interrupt__ 있음?", "__interrupt__" in swallowed, "← 중단이 사라졌습니다");

/* ===== [13-2d] 노드 안에 interrupt 가 여러 개면 ===== */

printSection("[13-2d] 한 노드에 interrupt 가 두 개 — 순서(index)로 매칭된다");

const TwoState = z.object({ answers: z.array(z.string()).default(() => []) });

const twoGraph = new StateGraph(TwoState)
  .addNode("askTwice", () => {
    const first = interrupt("첫 번째 질문");
    const second = interrupt("두 번째 질문");
    return { answers: [`1=${String(first)}`, `2=${String(second)}`] };
  })
  .addEdge(START, "askTwice")
  .addEdge("askTwice", END)
  .compile({ checkpointer: new MemorySaver() });

const twoConfig = { configurable: { thread_id: "two" } };

const t1 = await twoGraph.invoke({}, twoConfig);
const firstId = isInterrupted(t1) ? t1.__interrupt__[0]?.id : undefined;
console.log("   1차 중단:", isInterrupted(t1) ? JSON.stringify(t1.__interrupt__[0]?.value) : "없음");

const t2 = await twoGraph.invoke(new Command({ resume: "답변A" }), twoConfig);
const secondId = isInterrupted(t2) ? t2.__interrupt__[0]?.id : undefined;
console.log("   2차 중단:", isInterrupted(t2) ? JSON.stringify(t2.__interrupt__[0]?.value) : "없음");
// 두 interrupt 는 id 가 같습니다. 구분되는 건 id 가 아니라 "노드 안에서의 순서"입니다.
console.log("   ⚠️ id 가 1차와 같습니다:", firstId === secondId);

const t3 = await twoGraph.invoke(new Command({ resume: "답변B" }), twoConfig);
console.log("   최종:", JSON.stringify(t3.answers));

/* ===== [13-3] humanInTheLoopMiddleware — 특정 도구만 승인 요구 ===== */

printSection("[13-3] humanInTheLoopMiddleware — interruptOn 으로 도구를 골라 막는다");

const emailAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  // OpenAI 를 쓰려면: model: "openai:gpt-5.5"
  tools: [sendEmail, searchContact],
  systemPrompt: "당신은 사용자를 대신해 메일을 보내는 비서입니다. 연락처를 먼저 찾고 메일을 보내세요.",
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        // 도구 이름은 tool() 에 준 name 과 "정확히" 같아야 합니다.
        send_email: {
          allowedDecisions: ["approve", "edit", "reject"],
          description: "🚨 메일이 실제로 발송됩니다. 수신자와 내용을 확인하세요.",
        },
        // 읽기 전용 도구는 막지 않습니다. false 는 생략해도 같습니다
        // (interruptOn 에 없는 도구는 자동 승인).
        search_contact: false,
      },
      descriptionPrefix: "실행 승인이 필요합니다",
    }),
  ],
  checkpointer: new MemorySaver(), // ← HITL 미들웨어도 checkpointer 가 필수입니다
});

const agentConfig = { configurable: { thread_id: "email-1" } };

const step1 = await emailAgent.invoke(
  { messages: [{ role: "user", content: "김민수에게 '내일 회의 확인' 이라는 제목으로 메일 보내줘." }] },
  agentConfig,
);

console.log("\n   에이전트가 멈췄습니다. 지금까지의 메시지:");
printMessages(step1.messages);
console.log("\n   실제 발송된 메일 수:", sentLog.length, "← 아직 0 이어야 합니다");

/* ===== [13-6] __interrupt__ 읽기 ===== */

printSection("[13-6] __interrupt__ 읽기 — 무엇을 승인해달라는지 꺼내 보기");

printJson("   __interrupt__ 전문", step1.__interrupt__);

// 사람에게 보여줄 형태로 가공하는 함수. 13-8 의 CLI 에서도 씁니다.
type ActionRequest = { name: string; args: Record<string, unknown>; description?: string };
type ReviewConfig = { actionName: string; allowedDecisions: string[] };
type HITLValue = { actionRequests: ActionRequest[]; reviewConfigs: ReviewConfig[] };

function describeInterrupt(result: unknown): void {
  // isInterrupted 는 타입 가드입니다. __interrupt__ 를 직접 뒤지는 것보다 안전합니다.
  if (!isInterrupted(result)) {
    console.log("   중단되지 않았습니다.");
    return;
  }

  for (const item of result.__interrupt__) {
    const value = item.value as HITLValue;
    for (const [i, action] of value.actionRequests.entries()) {
      const review = value.reviewConfigs.find((r) => r.actionName === action.name);
      console.log(`\n   ── 승인 요청 #${i + 1} ─────────────────────`);
      console.log(`   도구      : ${action.name}`);
      console.log(`   인자      : ${JSON.stringify(action.args, null, 2).replace(/\n/g, "\n              ")}`);
      console.log(`   설명      : ${action.description ?? "(없음)"}`);
      console.log(`   가능한 결정: ${review?.allowedDecisions.join(" / ") ?? "?"}`);
    }
  }
}

describeInterrupt(step1);

/* ===== [13-4] 재개 — Command({ resume }) ===== */

printSection("[13-4] Command({ resume }) 로 승인하기");

const approved = await emailAgent.invoke(
  new Command({ resume: { decisions: [{ type: "approve" }] } }),
  agentConfig, // ← 같은 thread_id 여야 합니다. 다르면 재개가 아니라 새 대화입니다.
);

printMessages(approved.messages.slice(-3));
console.log("\n   실제 발송된 메일 수:", sentLog.length, "← 이제 1 입니다");

/* ===== [13-4b] 잘못된 resume 형식 ===== */

printSection("[13-4b] resume 형식이 틀리면 — 조용히 무시되지 않고 에러가 납니다");

const wrongAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [sendEmail],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { send_email: true } })],
  checkpointer: new MemorySaver(),
});
const wrongConfig = { configurable: { thread_id: "wrong-1" } };

await wrongAgent.invoke(
  { messages: [{ role: "user", content: "test@example.com 으로 '안녕' 메일 보내줘." }] },
  wrongConfig,
);

// 그래프 예제([13-2])에서는 resume: true 가 맞았지만,
// HITL 미들웨어는 { decisions: [...] } 형태만 받습니다.
try {
  await wrongAgent.invoke(new Command({ resume: true }), wrongConfig);
} catch (error) {
  console.log(`   ✅ 에러: ${(error as Error).message}`);
}

// 없는 결정 타입을 주면 어떤 에러가 나는지도 봅시다.
try {
  await wrongAgent.invoke(
    // "accept" 는 존재하지 않습니다. 올바른 이름은 "approve" 입니다.
    new Command({ resume: { decisions: [{ type: "accept" }] } }),
    wrongConfig,
  );
} catch (error) {
  console.log(`   ✅ 에러: ${(error as Error).message.split("\n")[0]}`);
}

/* ===== [13-5] 승인 패턴 — approve / edit / reject ===== */

printSection("[13-5] edit — 사람이 인자를 고쳐서 실행");

const editAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [sendEmail],
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: { send_email: { allowedDecisions: ["approve", "edit", "reject"] } },
    }),
  ],
  checkpointer: new MemorySaver(),
});

const editConfig = { configurable: { thread_id: "edit-1" } };
const editPaused = await editAgent.invoke(
  { messages: [{ role: "user", content: "wrong@example.com 으로 '초안' 메일 보내줘." }] },
  editConfig,
);

const editAction = (editPaused.__interrupt__?.[0]?.value as HITLValue).actionRequests[0];
console.log("   모델이 요청한 인자:", JSON.stringify(editAction?.args));

const edited = await editAgent.invoke(
  new Command({
    resume: {
      decisions: [
        {
          type: "edit",
          // editedAction 은 "통째로 교체"입니다. 부분 병합이 아니므로
          // 바꾸지 않을 인자도 전부 다시 적어야 합니다.
          editedAction: {
            name: "send_email",
            args: {
              to: "correct@example.com", // ← 사람이 수신자를 고쳤습니다
              subject: editAction?.args.subject ?? "초안",
              body: editAction?.args.body ?? "본문",
            },
          },
        },
      ],
    },
  }),
  editConfig,
);
printMessages(edited.messages.slice(-2));
console.log("   발송 로그:", sentLog);

printSection("[13-5b] reject — 거부하고 모델에게 이유를 알려주기");

const rejectAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [sendEmail],
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: { send_email: { allowedDecisions: ["approve", "reject"] } },
    }),
  ],
  checkpointer: new MemorySaver(),
});

const rejectConfig = { configurable: { thread_id: "reject-1" } };
await rejectAgent.invoke(
  { messages: [{ role: "user", content: "boss@example.com 으로 '퇴사합니다' 메일 보내줘." }] },
  rejectConfig,
);

const rejected = await rejectAgent.invoke(
  new Command({
    resume: {
      decisions: [
        {
          type: "reject",
          // 이 message 가 ToolMessage 내용이 되어 모델에게 전달됩니다.
          message: "발송을 거부했습니다. 이 메일은 보내면 안 됩니다. 다시 시도하지 마세요.",
        },
      ],
    },
  }),
  rejectConfig,
);
printMessages(rejected.messages.slice(-2));

/* ===== [13-3b] 함정: interruptOn 의 도구 이름 오타 ===== */

printSection("[13-3b] ⚠️ interruptOn 의 도구 이름을 틀리면 — 조용히 실행된다");

const typoAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [sendEmail],
  middleware: [
    humanInTheLoopMiddleware({
      // 실제 도구 이름은 "send_email" 인데 "sendEmail" 이라고 적었습니다.
      // 에러도, 경고도, 중단도 없습니다. 메일이 그냥 나갑니다.
      interruptOn: { sendEmail: true },
    }),
  ],
  checkpointer: new MemorySaver(),
});

const before = sentLog.length;
const typoResult = await typoAgent.invoke(
  { messages: [{ role: "user", content: "typo@example.com 으로 '테스트' 메일 보내줘." }] },
  { configurable: { thread_id: "typo-1" } },
);

console.log("   중단됐나요?", isInterrupted(typoResult), "← false 입니다");
console.log(`   승인 없이 발송된 메일: ${sentLog.length - before}건 😱`);

/* ===== [13-7] 비동기 승인 — 프로세스가 죽어도 되는 이유 ===== */

printSection("[13-7] 비동기 승인 — 체크포인터가 상태를 들고 있다");

// MemorySaver 는 프로세스 메모리에만 있으므로 "같은 프로세스 안에서 나중에"만 됩니다.
// 아래는 3초 뒤에 승인이 오는 상황을 흉내 냅니다.
const asyncAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [sendEmail],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { send_email: true } })],
  checkpointer: new MemorySaver(),
});

const asyncConfig = { configurable: { thread_id: "async-1" } };
await asyncAgent.invoke(
  { messages: [{ role: "user", content: "later@example.com 으로 '나중에' 메일 보내줘." }] },
  asyncConfig,
);
console.log("   승인 요청을 큐에 넣었습니다. 에이전트 객체는 이제 아무것도 붙들고 있지 않습니다.");

// 이 사이에 서버가 재시작돼도, 체크포인터가 영속(Postgres/SQLite)이라면 재개됩니다.
await new Promise((resolve) => setTimeout(resolve, 3000));
console.log("   ...3초 후, 승인이 도착했습니다.");

const late = await asyncAgent.invoke(
  new Command({ resume: { decisions: [{ type: "approve" }] } }),
  asyncConfig, // thread_id 만 있으면 재개됩니다
);
printMessages(late.messages.slice(-2));

/* ===== [13-8] 실전 — 승인 게이트가 달린 CLI 이메일 에이전트 ===== */

printSection("[13-8] 실전 — CLI 로 y/n 승인 받기");

const cliAgent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [sendEmail, searchContact],
  systemPrompt: "당신은 메일 비서입니다. 연락처를 찾은 뒤 메일을 발송하세요.",
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        send_email: {
          allowedDecisions: ["approve", "edit", "reject"],
          description: "메일이 실제로 발송됩니다.",
        },
      },
    }),
  ],
  checkpointer: new MemorySaver(),
});

const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
const cliConfig = { configurable: { thread_id: "cli-1" } };

// 첫 입력은 사용자 메시지, 이후부터는 Command 를 넣습니다.
// 타입이 갈리므로 유니온으로 받습니다.
let next: { messages: Array<{ role: string; content: string }> } | Command = {
  messages: [{ role: "user", content: "이지은에게 '점심 같이 먹어요' 라는 제목으로 메일 보내줘." }],
};

// 중단이 여러 번 날 수 있으므로 루프를 돕니다.
// (도구를 두 번 부르면 승인도 두 번 필요합니다.)
while (true) {
  const result = await cliAgent.invoke(next, cliConfig);

  if (!isInterrupted(result)) {
    console.log("\n   ── 최종 답변 ──");
    printMessages(result.messages.slice(-1));
    break;
  }

  const value = result.__interrupt__[0]?.value as HITLValue;
  const action = value.actionRequests[0];

  console.log("\n   ┌─ 승인 요청 ─────────────────────────");
  console.log(`   │ 도구: ${action?.name}`);
  console.log(`   │ 인자: ${JSON.stringify(action?.args)}`);
  console.log("   └─────────────────────────────────────");

  const answer = (await rl.question("   승인하시겠습니까? [y=승인 / n=거부 / e=수정]: ")).trim().toLowerCase();

  if (answer === "y") {
    next = new Command({ resume: { decisions: [{ type: "approve" }] } });
  } else if (answer === "e") {
    const newTo = await rl.question("   새 수신자: ");
    next = new Command({
      resume: {
        decisions: [
          {
            type: "edit",
            editedAction: {
              name: action?.name ?? "send_email",
              // 기존 인자를 펼치고 바꿀 것만 덮어씁니다.
              args: { ...action?.args, to: newTo },
            },
          },
        ],
      },
    });
  } else {
    const reason = await rl.question("   거부 이유: ");
    next = new Command({
      resume: { decisions: [{ type: "reject", message: reason || "사용자가 거부했습니다." }] },
    });
  }
}

rl.close();

console.log("\n최종 발송 로그:", sentLog);

/**
 * Step 13 — Human-in-the-Loop / 연습문제
 * 실행: npx tsx docs/reference/langchain/step-13-hitl/exercise.ts
 *
 * 각 [문제 N] 블록 아래를 직접 채우세요.
 * 정답은 solution.ts 에 있습니다. 먼저 스스로 풀어 본 뒤에 열어 보세요.
 *
 * 문제 1~3 은 모델 없이 그래프만으로 풀 수 있어 API 키가 없어도 됩니다.
 * 문제 4~8 은 ANTHROPIC_API_KEY 가 필요합니다.
 */
import "dotenv/config";

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import { Command, END, MemorySaver, START, StateGraph, interrupt, isInterrupted } from "@langchain/langgraph";
import * as z from "zod";

/* ===== 공용: 이 파일 전체에서 쓰는 도구 ===== */

// 승인 없이 실행되면 여기에 흔적이 남습니다. 검증용입니다.
export const deleteLog: string[] = [];

const deleteFile = tool(
  async ({ path }) => {
    deleteLog.push(path);
    return `${path} 를 삭제했습니다.`;
  },
  {
    name: "delete_file",
    description: "파일을 삭제합니다. 되돌릴 수 없습니다.",
    schema: z.object({ path: z.string().describe("삭제할 파일 경로") }),
  },
);

const listFiles = tool(async () => "a.txt, b.txt, /etc/passwd", {
  name: "list_files",
  description: "파일 목록을 봅니다.",
  schema: z.object({}),
});

/* ===== [문제 1] interrupt 와 checkpointer ===== */
/*
 * 아래 그래프는 `interrupt()` 를 쓰는데 checkpointer 가 없습니다.
 * 1) 그대로 실행해서 어떤 에러가 나는지 확인하고, 에러 클래스 이름과
 *    메시지 첫 줄을 주석으로 적으세요.
 * 2) checkpointer 를 붙여서 정상 동작하게 고치세요.
 * 3) thread_id 를 주지 않고 invoke 하면 어떻게 되는지도 확인해 보세요.
 */

const Q1State = z.object({ result: z.string().nullable().default(() => null) });

const q1Graph = new StateGraph(Q1State)
  .addNode("ask", () => {
    const answer = interrupt("계속할까요?");
    return { result: String(answer) };
  })
  .addEdge(START, "ask")
  .addEdge("ask", END)
  .compile(/* 여기를 채우세요 */);

// 여기에 실행 코드를 작성하세요.

// → 에러 클래스 이름:
// → 에러 메시지 첫 줄:

/* ===== [문제 2] 부수효과 재실행 ===== */
/*
 * 아래 노드는 interrupt 앞에서 카운터를 올립니다.
 * 1) 한 번 중단시키고 재개한 뒤, counter 값이 몇인지 확인하세요. 왜 그럴까요?
 * 2) 이 노드를 고쳐서, 재개해도 부수효과가 "한 번만" 일어난 것과 같은 결과가
 *    되게 만드세요. (힌트: 멱등하게 만들거나, interrupt 를 부수효과보다 앞으로 옮기거나,
 *    부수효과를 별도 노드로 분리하는 세 가지 길이 있습니다)
 */

export let q2Counter = 0;

const Q2State = z.object({ done: z.boolean().default(() => false) });

const q2Graph = new StateGraph(Q2State)
  .addNode("work", () => {
    q2Counter += 1; // ← 이게 두 번 실행됩니다
    const ok = interrupt("승인?");
    return { done: ok === true };
  })
  .addEdge(START, "work")
  .addEdge("work", END)
  .compile({ checkpointer: new MemorySaver() });

// 여기에 실행 코드와 개선된 그래프를 작성하세요.

/* ===== [문제 3] try/catch 함정 ===== */
/*
 * 아래 노드는 interrupt 를 try/catch 로 감싸고 있어 중단이 동작하지 않습니다.
 * 1) 실행해서 __interrupt__ 가 없다는 것을 확인하세요.
 * 2) 잡힌 예외의 name 이 무엇인지 출력해 보세요.
 * 3) "DB 에러는 잡되 interrupt 는 통과시키는" 형태로 고치세요.
 *    (힌트: @langchain/langgraph 가 내보내는 isGraphInterrupt 를 찾아보거나,
 *     예외의 name 을 검사해서 다시 throw 하세요)
 */

const Q3State = z.object({ status: z.string().nullable().default(() => null) });

const q3Graph = new StateGraph(Q3State)
  .addNode("risky", () => {
    try {
      const ok = interrupt("승인?");
      return { status: `승인=${String(ok)}` };
    } catch (error) {
      return { status: "에러를 삼켰습니다" };
    }
  })
  .addEdge(START, "risky")
  .addEdge("risky", END)
  .compile({ checkpointer: new MemorySaver() });

// 여기에 실행 코드와 개선된 노드를 작성하세요.

/* ===== [문제 4] interruptOn 으로 위험한 도구만 막기 ===== */
/*
 * deleteFile 과 listFiles 를 가진 에이전트를 만드세요.
 * - delete_file 은 approve / reject 만 허용
 * - list_files 는 승인 없이 통과
 * - description 은 "🚨 파일이 영구 삭제됩니다" 로
 * 그리고 "a.txt 지워줘" 를 시켜서 중단이 걸리는지 확인하세요.
 */

// 여기에 작성하세요.

/* ===== [문제 5] __interrupt__ 읽어서 사람에게 보여주기 ===== */
/*
 * 문제 4 의 결과에서 __interrupt__ 를 읽어,
 * "도구이름 / 인자 / 허용된 결정" 세 줄로 출력하는 함수 renderApproval(result) 를 만드세요.
 * - isInterrupted 타입 가드를 쓰세요.
 * - actionRequests 와 reviewConfigs 를 actionName 으로 짝지으세요.
 * - 중단이 아니면 "중단 없음" 을 출력하세요.
 */

// 여기에 작성하세요.

/* ===== [문제 6] 세 가지 결정 전부 써 보기 ===== */
/*
 * 같은 요청("a.txt 지워줘")을 서로 다른 thread_id 로 세 번 실행하고,
 * 각각 approve / edit / reject 로 재개해서 결과를 비교하세요.
 * - edit 로는 삭제 대상을 "b.txt" 로 바꾸세요.
 * - reject 의 message 가 ToolMessage 로 어떻게 들어가는지 확인하세요.
 * - 마지막에 deleteLog 를 출력해서 실제로 무엇이 지워졌는지 검증하세요.
 *   (approve 는 a.txt, edit 는 b.txt, reject 는 아무것도 없어야 합니다)
 */

// 여기에 작성하세요.

/* ===== [문제 7] 오타 함정 재현하기 ===== */
/*
 * interruptOn 의 키를 "deleteFile"(잘못된 이름)로 주는 에이전트를 만들고,
 * "a.txt 지워줘" 를 시키세요.
 * 1) 중단이 걸리나요?
 * 2) deleteLog 에 무엇이 남았나요?
 * 3) 이 사고를 컴파일 타임에 막으려면 어떻게 해야 할까요?
 *    도구 이름을 상수로 뽑아 쓰는 코드로 고쳐 보세요.
 */

// 여기에 작성하세요.

/* ===== [문제 8] when 으로 조건부 승인 ===== */
/*
 * delete_file 을 이렇게 만드세요:
 * - 경로가 "/etc" 로 시작하면 승인을 요구한다
 * - 그 외 경로는 승인 없이 바로 지운다
 * (힌트: interruptOn 의 InterruptOnConfig 에는 when 이라는 술어(predicate)가 있습니다.
 *  true 를 반환하면 중단, false 면 자동 승인입니다.
 *  술어는 request.toolCall.args 로 인자를 볼 수 있습니다.)
 *
 * "a.txt 지워줘" 와 "/etc/passwd 지워줘" 를 각각 시켜서 동작 차이를 확인하세요.
 */

// 여기에 작성하세요.

/**
 * Step 13 — Human-in-the-Loop / 정답과 해설
 * 실행: npx tsx docs/reference/langchain/step-13-hitl/solution.ts
 *
 * exercise.ts 를 스스로 풀어 본 뒤에 열어 보세요.
 * 각 정답 위 주석에 "왜 그런가" 와 기대 출력이 적혀 있습니다.
 */
import "dotenv/config";

import { createAgent, humanInTheLoopMiddleware, tool } from "langchain";
import {
  Command,
  END,
  MemorySaver,
  START,
  StateGraph,
  interrupt,
  isInterrupted,
} from "@langchain/langgraph";
import * as z from "zod";

/* ===== 공용 도구 ===== */

const deleteLog: string[] = [];

const deleteFile = tool(
  async ({ path }) => {
    deleteLog.push(path);
    return `${path} 를 삭제했습니다.`;
  },
  {
    name: "delete_file",
    description: "파일을 삭제합니다. 되돌릴 수 없습니다.",
    schema: z.object({ path: z.string().describe("삭제할 파일 경로") }),
  },
);

const listFiles = tool(async () => "a.txt, b.txt, /etc/passwd", {
  name: "list_files",
  description: "파일 목록을 봅니다.",
  schema: z.object({}),
});

const MODEL = "anthropic:claude-sonnet-4-6";

/* ===== [정답 1] interrupt 와 checkpointer ===== */
/*
 * 핵심: interrupt 는 "멈춘 지점"을 어딘가에 적어 둬야 재개할 수 있습니다.
 * 그 저장소가 checkpointer 입니다. 없으면 멈출 수가 없으니 에러입니다.
 *
 * → 에러 클래스 이름: GraphValueError
 * → 에러 메시지 첫 줄: No checkpointer set
 *
 * 이 함정은 다행히 "요란하게" 실패합니다. 조용히 통과했다면 훨씬 위험했을 겁니다.
 * thread_id 를 빼먹으면 다른 에러가 납니다 — 체크포인터는 있는데 어느 대화에
 * 저장할지 모르기 때문입니다. 둘은 항상 짝으로 다닙니다.
 */

console.log("=== [정답 1] checkpointer 없이 interrupt ===");

const Q1State = z.object({ result: z.string().nullable().default(() => null) });

const q1Nodes = (builder: StateGraph<typeof Q1State>) =>
  builder
    .addNode("ask", () => {
      const answer = interrupt("계속할까요?");
      return { result: String(answer) };
    })
    .addEdge(START, "ask")
    .addEdge("ask", END);

// (1) 고장난 버전 — checkpointer 없음
const q1Broken = q1Nodes(new StateGraph(Q1State)).compile();

try {
  await q1Broken.invoke({});
} catch (error) {
  console.log("  에러 클래스:", (error as Error).constructor.name);
  console.log("  메시지 첫 줄:", (error as Error).message.split("\n")[0]);
}

// (2) 고친 버전 — checkpointer 를 붙입니다
const q1Fixed = q1Nodes(new StateGraph(Q1State)).compile({ checkpointer: new MemorySaver() });
const q1Config = { configurable: { thread_id: "q1" } };

const q1Paused = await q1Fixed.invoke({}, q1Config);
// 직접 만든 그래프의 상태 타입에는 __interrupt__ 가 없습니다.
// isInterrupted 타입 가드를 통과해야 tsc 가 읽게 해 줍니다.
console.log("  중단됨:", isInterrupted(q1Paused) ? JSON.stringify(q1Paused.__interrupt__[0]?.value) : "아니오");
const q1Done = await q1Fixed.invoke(new Command({ resume: "네" }), q1Config);
console.log("  재개 결과:", q1Done.result);

/* ===== [정답 2] 부수효과 재실행 ===== */
/*
 * counter 는 2 가 됩니다. 1 이 아닙니다.
 *
 * 이유: interrupt 는 노드를 "일시정지" 시키는 게 아니라 노드 실행을 통째로
 * 중단시킵니다. 재개하면 그 노드가 처음부터 다시 돌고, 이미 답이 있는
 * interrupt 만 저장된 값을 즉시 반환합니다. 그래서 interrupt "앞"의 코드는
 * 항상 두 번(또는 중단 횟수+1번) 실행됩니다.
 *
 * 이게 왜 무서운가: 그 자리에 결제나 메일 발송이 있으면 두 번 나갑니다.
 *
 * 해결책 세 가지:
 *  (a) 부수효과를 멱등(idempotent)하게 만든다 — 같은 키로 두 번 호출해도 한 번만
 *      먹히게. 결제 API 의 idempotency key 가 정확히 이걸 위한 장치입니다.
 *  (b) interrupt 를 부수효과보다 "앞"으로 옮긴다 — 아래에서 택한 방법.
 *  (c) 부수효과를 별도 노드로 분리한다 — 승인 노드와 실행 노드를 나누면
 *      승인 노드만 재실행되고 실행 노드는 한 번만 돕니다.
 */

console.log("\n=== [정답 2] 부수효과 재실행 ===");

let q2Counter = 0;

const Q2State = z.object({ done: z.boolean().default(() => false) });

// (1) 문제 재현
const q2Broken = new StateGraph(Q2State)
  .addNode("work", () => {
    q2Counter += 1;
    const ok = interrupt("승인?");
    return { done: ok === true };
  })
  .addEdge(START, "work")
  .addEdge("work", END)
  .compile({ checkpointer: new MemorySaver() });

const q2Config = { configurable: { thread_id: "q2" } };
await q2Broken.invoke({}, q2Config);
await q2Broken.invoke(new Command({ resume: true }), q2Config);
console.log("  고장난 버전 counter =", q2Counter, "(2 입니다 — 부수효과가 두 번!)");

// (2) 해결책 (b): interrupt 를 맨 앞으로. 승인받기 전엔 아무 일도 하지 않습니다.
let q2FixedCounter = 0;

const q2Fixed = new StateGraph(Q2State)
  .addNode("work", () => {
    const ok = interrupt("승인?"); // ← 부수효과보다 먼저 멈춥니다
    if (ok !== true) return { done: false };
    q2FixedCounter += 1; // ← 재개 후 딱 한 번만 실행됩니다
    return { done: true };
  })
  .addEdge(START, "work")
  .addEdge("work", END)
  .compile({ checkpointer: new MemorySaver() });

const q2FixedConfig = { configurable: { thread_id: "q2-fixed" } };
await q2Fixed.invoke({}, q2FixedConfig);
await q2Fixed.invoke(new Command({ resume: true }), q2FixedConfig);
console.log("  고친 버전 counter =", q2FixedCounter, "(1 입니다)");

/* ===== [정답 3] try/catch 함정 ===== */
/*
 * interrupt 는 GraphInterrupt 예외를 throw 해서 실행을 빠져나갑니다.
 * "예외처럼 생겼지만 에러가 아니라 제어 흐름"입니다.
 * 그래서 넓은 try/catch 는 중단 신호를 삼켜 버리고,
 * 노드는 catch 블록으로 흘러가 아무 일 없었다는 듯 끝납니다.
 * 결과에 __interrupt__ 가 없으니 호출자는 중단을 알아챌 방법이 없습니다.
 *
 * → 잡힌 예외의 name: "GraphInterrupt"
 *
 * 고치는 법: interrupt 는 try 밖에 두는 게 가장 깔끔합니다.
 * 부득이하게 감싸야 하면 name 을 검사해 다시 throw 하세요.
 */

console.log("\n=== [정답 3] try/catch 함정 ===");

const Q3State = z.object({ status: z.string().nullable().default(() => null) });

// (1) 문제 재현
const q3Broken = new StateGraph(Q3State)
  .addNode("risky", () => {
    try {
      const ok = interrupt("승인?");
      return { status: `승인=${String(ok)}` };
    } catch (error) {
      console.log("  잡힌 예외의 name:", (error as Error).name);
      return { status: "에러를 삼켰습니다" };
    }
  })
  .addEdge(START, "risky")
  .addEdge("risky", END)
  .compile({ checkpointer: new MemorySaver() });

const q3BrokenResult = await q3Broken.invoke({}, { configurable: { thread_id: "q3" } });
console.log("  __interrupt__ 있음?", "__interrupt__" in q3BrokenResult, "← 중단이 사라졌습니다");
console.log("  status =", q3BrokenResult.status);

// (2) 고친 버전 — GraphInterrupt 면 다시 throw 합니다.
const q3Fixed = new StateGraph(Q3State)
  .addNode("risky", () => {
    try {
      // 진짜 DB 작업이 여기 있다고 칩시다.
      const ok = interrupt("승인?");
      return { status: `승인=${String(ok)}` };
    } catch (error) {
      // 중단 신호는 에러가 아닙니다. 그대로 통과시켜야 합니다.
      if (error instanceof Error && error.name === "GraphInterrupt") throw error;
      return { status: "DB 에러를 처리했습니다" };
    }
  })
  .addEdge(START, "risky")
  .addEdge("risky", END)
  .compile({ checkpointer: new MemorySaver() });

const q3FixedResult = await q3Fixed.invoke({}, { configurable: { thread_id: "q3-fixed" } });
console.log("  고친 버전 __interrupt__ 있음?", isInterrupted(q3FixedResult), "← 중단이 살아났습니다");

/* ===== [정답 4] interruptOn 으로 위험한 도구만 막기 ===== */
/*
 * 핵심은 "이름을 정확히" 쓰는 것과, 안전한 도구를 굳이 막지 않는 것입니다.
 * list_files 는 interruptOn 에 아예 안 적어도 자동 승인되지만,
 * false 로 명시해 두면 "검토했고 일부러 열어 뒀다"는 의도가 코드에 남습니다.
 */

console.log("\n=== [정답 4] interruptOn ===");

const q4Agent = createAgent({
  model: MODEL,
  tools: [deleteFile, listFiles],
  systemPrompt: "당신은 파일 관리 비서입니다.",
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        delete_file: {
          allowedDecisions: ["approve", "reject"],
          description: "🚨 파일이 영구 삭제됩니다",
        },
        list_files: false,
      },
    }),
  ],
  checkpointer: new MemorySaver(),
});

const q4Config = { configurable: { thread_id: "q4" } };
const q4Result = await q4Agent.invoke(
  { messages: [{ role: "user", content: "a.txt 지워줘." }] },
  q4Config,
);
console.log("  중단됨?", isInterrupted(q4Result));

/* ===== [정답 5] __interrupt__ 읽어서 보여주기 ===== */
/*
 * __interrupt__ 는 배열입니다. 항목마다 { id, value } 를 갖고,
 * HITL 미들웨어가 넣는 value 는 { actionRequests, reviewConfigs } 입니다.
 *
 * 주의: actionRequests 의 인자 필드 이름은 `args` 입니다 (`arguments` 아님).
 * reviewConfigs 는 actionRequests 와 인덱스가 아니라 actionName 으로 짝지어야
 * 정확합니다 — 같은 도구를 두 번 부르면 actionRequests 는 2개인데
 * reviewConfigs 는 1개일 수 있기 때문입니다.
 */

console.log("\n=== [정답 5] __interrupt__ 렌더링 ===");

type ActionRequest = { name: string; args: Record<string, unknown>; description?: string };
type ReviewConfig = { actionName: string; allowedDecisions: string[] };
type HITLValue = { actionRequests: ActionRequest[]; reviewConfigs: ReviewConfig[] };

function renderApproval(result: unknown): void {
  if (!isInterrupted(result)) {
    console.log("  중단 없음");
    return;
  }
  for (const item of result.__interrupt__) {
    const value = item.value as HITLValue;
    for (const action of value.actionRequests) {
      const review = value.reviewConfigs.find((r) => r.actionName === action.name);
      console.log(`  도구      : ${action.name}`);
      console.log(`  인자      : ${JSON.stringify(action.args)}`);
      console.log(`  가능한 결정: ${review?.allowedDecisions.join(" / ") ?? "(알 수 없음)"}`);
    }
  }
}

renderApproval(q4Result);

/* ===== [정답 6] 세 가지 결정 전부 ===== */
/*
 * 기대 결과:
 *  - approve → deleteLog 에 "a.txt"
 *  - edit    → deleteLog 에 "b.txt" (모델이 요청한 a.txt 가 아니라)
 *  - reject  → deleteLog 에 아무것도 안 남고, reject 의 message 가
 *              ToolMessage 내용이 되어 모델에게 전달됨
 *
 * editedAction 은 "통째로 교체"입니다. 부분 병합이 아니므로 args 를 전부 다시
 * 줘야 합니다. 인자가 많으면 { ...action.args, path: "b.txt" } 로 펼쳐 쓰세요.
 *
 * 그리고 allowedDecisions 에 없는 타입을 보내면 에러가 납니다 —
 * edit 를 쓰려면 allowedDecisions 에 "edit" 이 있어야 합니다.
 */

console.log("\n=== [정답 6] approve / edit / reject ===");

const makeQ6Agent = () =>
  createAgent({
    model: MODEL,
    tools: [deleteFile],
    middleware: [
      humanInTheLoopMiddleware({
        interruptOn: { delete_file: { allowedDecisions: ["approve", "edit", "reject"] } },
      }),
    ],
    checkpointer: new MemorySaver(),
  });

deleteLog.length = 0;

// (a) approve
const q6a = makeQ6Agent();
const q6aConfig = { configurable: { thread_id: "q6-approve" } };
await q6a.invoke({ messages: [{ role: "user", content: "a.txt 지워줘." }] }, q6aConfig);
await q6a.invoke(new Command({ resume: { decisions: [{ type: "approve" }] } }), q6aConfig);
console.log("  approve 후 deleteLog =", JSON.stringify(deleteLog));

// (b) edit
const q6b = makeQ6Agent();
const q6bConfig = { configurable: { thread_id: "q6-edit" } };
const q6bPaused = await q6b.invoke({ messages: [{ role: "user", content: "a.txt 지워줘." }] }, q6bConfig);
const q6bAction = (q6bPaused.__interrupt__?.[0]?.value as HITLValue).actionRequests[0];
await q6b.invoke(
  new Command({
    resume: {
      decisions: [
        {
          type: "edit",
          editedAction: {
            name: "delete_file",
            args: { ...q6bAction?.args, path: "b.txt" },
          },
        },
      ],
    },
  }),
  q6bConfig,
);
console.log("  edit 후 deleteLog =", JSON.stringify(deleteLog), "← b.txt 가 추가됐습니다");

// (c) reject
const q6c = makeQ6Agent();
const q6cConfig = { configurable: { thread_id: "q6-reject" } };
await q6c.invoke({ messages: [{ role: "user", content: "a.txt 지워줘." }] }, q6cConfig);
const q6cDone = await q6c.invoke(
  new Command({
    resume: {
      decisions: [{ type: "reject", message: "이 파일은 지우면 안 됩니다. 다시 시도하지 마세요." }],
    },
  }),
  q6cConfig,
);
const q6cToolMsg = q6cDone.messages.filter((m) => m.getType() === "tool").at(-1);
console.log("  reject 가 만든 ToolMessage =", JSON.stringify(q6cToolMsg?.text));
console.log("  reject 후 deleteLog =", JSON.stringify(deleteLog), "← 늘지 않았습니다");

/* ===== [정답 7] 오타 함정 ===== */
/*
 * 1) 중단이 걸리지 않습니다.
 * 2) deleteLog 에 "a.txt" 가 남습니다 — 승인 없이 지워졌습니다.
 * 3) interruptOn 은 Record<string, ...> 이라 아무 문자열 키나 받습니다.
 *    타입 시스템이 "그런 도구 없다"고 말해 주지 않습니다.
 *
 * 방어법: 도구 이름을 상수로 뽑고, tool() 정의와 interruptOn 양쪽에서
 * 그 상수를 쓰세요. 오타를 내면 tsc 가 잡아 줍니다.
 * as const 로 리터럴 타입을 고정하는 게 핵심입니다.
 */

console.log("\n=== [정답 7] 오타 함정 ===");

deleteLog.length = 0;

const q7Agent = createAgent({
  model: MODEL,
  tools: [deleteFile],
  middleware: [humanInTheLoopMiddleware({ interruptOn: { deleteFile: true } })], // 오타!
  checkpointer: new MemorySaver(),
});

const q7Result = await q7Agent.invoke(
  { messages: [{ role: "user", content: "a.txt 지워줘." }] },
  { configurable: { thread_id: "q7" } },
);
console.log("  중단됨?", isInterrupted(q7Result), "← false");
console.log("  deleteLog =", JSON.stringify(deleteLog), "← 승인 없이 지워졌습니다 😱");

// 방어 버전: 이름을 상수로 고정합니다.
const TOOL_NAMES = { deleteFile: "delete_file", listFiles: "list_files" } as const;

const safeDeleteFile = tool(
  async ({ path }) => {
    deleteLog.push(path);
    return `${path} 를 삭제했습니다.`;
  },
  {
    name: TOOL_NAMES.deleteFile, // ← 같은 상수
    description: "파일을 삭제합니다.",
    schema: z.object({ path: z.string() }),
  },
);

const q7Safe = createAgent({
  model: MODEL,
  tools: [safeDeleteFile],
  middleware: [
    humanInTheLoopMiddleware({
      // 오타를 내면 여기서 tsc 가 잡습니다.
      interruptOn: { [TOOL_NAMES.deleteFile]: true },
    }),
  ],
  checkpointer: new MemorySaver(),
});

deleteLog.length = 0;
const q7SafeResult = await q7Safe.invoke(
  { messages: [{ role: "user", content: "a.txt 지워줘." }] },
  { configurable: { thread_id: "q7-safe" } },
);
console.log("  방어 버전 중단됨?", isInterrupted(q7SafeResult), "← true");
console.log("  deleteLog =", JSON.stringify(deleteLog), "← 비어 있습니다");

/* ===== [정답 8] when 으로 조건부 승인 ===== */
/*
 * when 은 도구 호출마다 불리는 술어입니다. true 를 반환하면 중단,
 * false 면 자동 승인입니다. 인자를 보고 판단할 수 있어서
 * "위험한 경로만", "금액이 10만원 넘을 때만" 같은 정책을 표현하기 좋습니다.
 *
 * 주의: when 이 던지는 예외는 승인 자체를 망가뜨립니다.
 * 인자가 예상과 다른 모양일 수 있으니(모델이 만들어 낸 값입니다)
 * 반드시 방어적으로 읽으세요. 아래에서 typeof 로 확인하는 이유입니다.
 *
 * 또 하나: 판단이 애매하면 "중단하는 쪽"이 안전합니다.
 * 아래는 path 를 못 읽으면 true(중단)를 반환합니다 — fail-safe.
 */

console.log("\n=== [정답 8] when 으로 조건부 승인 ===");

const q8Agent = createAgent({
  model: MODEL,
  tools: [deleteFile],
  systemPrompt: "당신은 파일 관리 비서입니다. 사용자가 지우라는 파일을 지우세요.",
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        delete_file: {
          allowedDecisions: ["approve", "reject"],
          description: "🚨 시스템 경로를 지우려 합니다",
          when: (request) => {
            const path = request.toolCall.args.path;
            if (typeof path !== "string") return true; // 모르면 막는다
            return path.startsWith("/etc");
          },
        },
      },
    }),
  ],
  checkpointer: new MemorySaver(),
});

deleteLog.length = 0;

// (a) 안전한 경로 → 중단 없이 실행
const q8Safe = await q8Agent.invoke(
  { messages: [{ role: "user", content: "a.txt 지워줘." }] },
  { configurable: { thread_id: "q8-safe" } },
);
console.log("  a.txt → 중단됨?", isInterrupted(q8Safe), "← false, 바로 실행");

// (b) 위험한 경로 → 중단
const q8Danger = await q8Agent.invoke(
  { messages: [{ role: "user", content: "/etc/passwd 지워줘." }] },
  { configurable: { thread_id: "q8-danger" } },
);
console.log("  /etc/passwd → 중단됨?", isInterrupted(q8Danger), "← true, 승인 필요");
console.log("  deleteLog =", JSON.stringify(deleteLog));