#Step 17 — LangGraph 그래프 API

import {
  StateSchema, MessagesValue, StateGraph, START, END,
  type GraphNode,
} from "@langchain/langgraph";

const State = new StateSchema({
  messages: MessagesValue,
});

const mockLlm: GraphNode<typeof State> = (state) => {
  const last = state.messages.at(-1);
  return { messages: [{ role: "ai", content: `echo: ${last?.content}` }] };
};

const graph = new StateGraph(State)
  .addNode("mock_llm", mockLlm)
  .addEdge(START, "mock_llm")
  .addEdge("mock_llm", END)
  .compile();

const result = await graph.invoke({ messages: [{ role: "user", content: "hi!" }] });

import {
  StateSchema, MessagesValue, ReducedValue, UntrackedValue,
} from "@langchain/langgraph";
import * as z from "zod";

const AgentState = new StateSchema({
  // 1. 평범한 zod 스키마 → 마지막 값이 이긴다 (LastValue)
  currentStep: z.string().default(""),
  retryCount: z.number().default(0),

  // 2. ReducedValue → 합치는 방법을 내가 정한다
  allSteps: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (current, update) => current.concat(update),
  }),

  // 3. MessagesValue → 메시지 전용 프리셋 리듀서
  messages: MessagesValue,

  // 4. UntrackedValue → 체크포인트에 저장되지 않는 임시값
  tempCache: new UntrackedValue(z.record(z.string(), z.unknown())),
});

type State = typeof AgentState.State;   // 노드가 읽는 타입
type Update = typeof AgentState.Update; // 노드가 반환하는 타입

const ReducerDemo = new StateSchema({
  lastOnly: z.string().default(""),                    // 리듀서 없음
  accumulated: new ReducedValue(                        // 리듀서 있음
    z.array(z.string()).default(() => []),
    { reducer: (current: string[], update: string[]) => current.concat(update) },
  ),
});

const graph = new StateGraph(ReducerDemo)
  .addNode("first",  () => ({ lastOnly: "첫 번째", accumulated: ["첫 번째"] }))
  .addNode("second", () => ({ lastOnly: "두 번째", accumulated: ["두 번째"] }))
  .addEdge(START, "first").addEdge("first", "second").addEdge("second", END)
  .compile();

const graph = new StateGraph(new StateSchema({ messages: MessagesValue }))
  .addNode("add",    () => ({ messages: [new AIMessage({ id: "fixed-id", content: "초안" })] }))
  .addNode("revise", () => ({ messages: [new AIMessage({ id: "fixed-id", content: "교체됨 (id 가 같으므로)" })] }))
  .addEdge(START, "add").addEdge("add", "revise").addEdge("revise", END)
  .compile();

await graph.invoke({ messages: [new HumanMessage("안녕")] });

const CounterState = new StateSchema({
  count: z.number().default(0),
  history: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (a: string[], b: string[]) => a.concat(b),
  }),
});

const increment: GraphNode<typeof CounterState> = (state) => ({
  count: state.count + 1,
  history: [`count 를 ${state.count} → ${state.count + 1} 로 올림`],
});

const double: GraphNode<typeof CounterState> = (state) => ({
  count: state.count * 2,
  history: [`count 를 ${state.count} → ${state.count * 2} 로 두 배`],
});

const graph = new StateGraph(CounterState)
  .addNode("increment", increment)
  .addNode("double", double)
  .addEdge(START, "increment")
  .addEdge("increment", "double")
  .addEdge("double", END)
  .compile();

await graph.invoke({ count: 5 });

// state 만 쓰는 평범한 노드
const node: GraphNode<typeof State> = (state) => ({ count: state.count + 1 });

// 두 번째 인자로 config 를 받는다
const withConfig: GraphNode<typeof State> = (state, config) => {
  const step = config.metadata?.langgraph_step;  // 몇 번째 스텝인지
  const nodeName = config.metadata?.langgraph_node;
  return {};
};

const graph = new StateGraph(CounterState)
  .addNode("increment", increment)
  .addEdge(START, "increment")
  .addEdge("increment", END)
  .compile({ checkpointer: new MemorySaver() });

const cfg = { configurable: { thread_id: "thread-A" } };
await graph.invoke({}, cfg);   // count: 1
await graph.invoke({}, cfg);   // count: 2
await graph.invoke({}, cfg);   // count: 3
await graph.invoke({}, { configurable: { thread_id: "thread-B" } });  // count: 1

for await (const chunk of await graph.stream({ count: 1 }, { streamMode: "updates" })) {
  console.log(chunk);
}

const RouteState = new StateSchema({
  input: z.string().default(""),
  category: z.string().default(""),
  output: z.string().default(""),
});

// 라우팅 "노드" — 판단 결과를 상태에 남긴다
const classify: GraphNode<typeof RouteState> = (state) => ({
  category: state.input.includes("환불") ? "refund" : "general",
});

// 라우팅 "함수" — 상태를 읽고 갈 곳만 정한다
const route: ConditionalEdgeRouter<{
  InputSchema: typeof RouteState;
  Nodes: "handleRefund" | "handleGeneral";
}> = (state) => (state.category === "refund" ? "handleRefund" : "handleGeneral");

const graph = new StateGraph(RouteState)
  .addNode("classify", classify)
  .addNode("handleRefund", () => ({ output: "환불 팀으로 연결합니다." }))
  .addNode("handleGeneral", () => ({ output: "일반 상담으로 처리합니다." }))
  .addEdge(START, "classify")
  .addConditionalEdges("classify", route, ["handleRefund", "handleGeneral"])
  .addEdge("handleRefund", END)
  .addEdge("handleGeneral", END)
  .compile();

.addConditionalEdges("classify", route, { refund: "handleRefund", general: "handleGeneral" })
// 이때 route 는 "refund" / "general" 을 반환하고, 매핑이 노드 이름으로 번역해 준다

const BadParallel = new StateSchema({
  value: z.string().default(""),   // ← 리듀서 없음
});

const badGraph = new StateGraph(BadParallel)
  .addNode("branchA", () => ({ value: "A" }))
  .addNode("branchB", () => ({ value: "B" }))
  .addEdge(START, "branchA")
  .addEdge(START, "branchB")
  .addEdge("branchA", END)
  .addEdge("branchB", END)
  .compile();

await badGraph.invoke({});

const GoodParallel = new StateSchema({
  value: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (a: string[], b: string[]) => a.concat(b),
  }),
});

const goodGraph = new StateGraph(GoodParallel)
  .addNode("branchA", () => ({ value: ["A"] }))
  .addNode("branchB", () => ({ value: ["B"] }))
  .addNode("merge", (state) => {
    console.log("fan-in 노드는 두 브랜치가 모두 끝난 뒤 한 번만 실행됩니다:", state.value);
    return {};
  })
  .addEdge(START, "branchA").addEdge(START, "branchB")
  .addEdge("branchA", "merge").addEdge("branchB", "merge")
  .addEdge("merge", END)
  .compile();

const orderGraph = new StateGraph(OrderState)
  .addNode("slow", delayed("slow(50ms)", 50))  // 먼저 선언
  .addNode("fast", delayed("fast(0ms)", 0))    // 나중에 선언
  .addEdge(START, "slow").addEdge(START, "fast")
  .addEdge("slow", END).addEdge("fast", END)
  .compile();

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

const mapReduceGraph = new StateGraph(MapReduce)
  .addNode("worker", worker)
  .addConditionalEdges(
    START,
    (state) => state.subjects.map((s) => new Send("worker", { subject: s })),
    ["worker"],
  )
  .addEdge("worker", END)
  .compile();

await mapReduceGraph.invoke({ subjects: ["고양이", "강아지", "햄스터"] });

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

const evaluate: GraphNode<{
  InputSchema: typeof CmdState;
  Nodes: "pass" | "fail";
}> = (state) => {
  const score = state.score + 60;
  return new Command({
    update: { score },                        // 상태를 갱신하면서
    goto: score >= 60 ? "pass" : "fail",      // 동시에 다음 노드를 정한다
  });
};

const cmdGraph = new StateGraph(CmdState)
  .addNode("evaluate", evaluate, { ends: ["pass", "fail"] })  // ← ends 가 필수
  .addNode("pass", () => ({ verdict: "합격" }))
  .addNode("fail", () => ({ verdict: "불합격" }))
  .addEdge(START, "evaluate")
  .addEdge("pass", END).addEdge("fail", END)
  .compile();

await cmdGraph.invoke({ score: 10 });

const SharedState = new StateSchema({
  messages: MessagesValue,
  note: z.string().default(""),
});

const subgraph = new StateGraph(SharedState)
  .addNode("subWork", () => ({
    note: "서브그래프가 씀",
    messages: [new AIMessage("서브그래프에서 처리했습니다")],
  }))
  .addEdge(START, "subWork").addEdge("subWork", END)
  .compile();

const parentGraph = new StateGraph(SharedState)
  .addNode("child", subgraph)   // ← 컴파일된 그래프가 곧 노드
  .addNode("after", (state) => ({ note: `${state.note} → 부모가 이어받음` }))
  .addEdge(START, "child").addEdge("child", "after").addEdge("after", END)
  .compile();

await parentGraph.invoke({ messages: [new HumanMessage("시작")] });

return new Command({
  update: { foo: "bar" },
  goto: "otherSubgraph",
  graph: Command.PARENT,   // 부모 그래프 기준으로 goto 를 해석
});

const drawable = await graph.getGraphAsync();
console.log(drawable.drawMermaid());     // mermaid 소스 문자열

// PNG 로 저장
import * as fs from "node:fs/promises";
const image = await drawable.drawMermaidPng();
await fs.writeFile("graph.png", new Uint8Array(await image.arrayBuffer()));

import { createAgent, tool } from "langchain";

const getWeather = tool(({ city }: { city: string }) => `${city}: 맑음, 24도`, {
  name: "get_weather",
  description: "도시의 현재 날씨를 조회한다",
  schema: z.object({ city: z.string().describe("도시 이름") }),
});

const packaged = createAgent({ model: "anthropic:claude-sonnet-4-6", tools: [getWeather] });

console.log(packaged.constructor.name);
console.log(Object.keys((await packaged.getGraphAsync()).nodes));
console.log((await packaged.getGraphAsync()).drawMermaid());

import { ToolNode } from "@langchain/langgraph/prebuilt";
import { ChatAnthropic } from "@langchain/anthropic";

const llm = new ChatAnthropic({ model: "claude-sonnet-4-6" });
// OpenAI 를 쓰려면: new ChatOpenAI({ model: "gpt-5.5" })
const llmWithTools = llm.bindTools([getWeather]);

const AgentState = new StateSchema({ messages: MessagesValue });

// 노드 1 — 모델을 부른다
const callModel: GraphNode<typeof AgentState> = async (state) => {
  const response = await llmWithTools.invoke([
    { role: "system", content: "너는 날씨를 알려주는 비서다." },
    ...state.messages,
  ]);
  return { messages: [response] };
};

// 노드 2 — 도구를 실행한다
const toolNode = new ToolNode([getWeather]);

// 엣지 — 도구 호출이 남아 있으면 tools 로, 아니면 END 로
const shouldContinue: ConditionalEdgeRouter<{
  InputSchema: typeof AgentState;
  Nodes: "tools";
}> = (state) => {
  const last = state.messages.at(-1) as AIMessage;
  return last?.tool_calls?.length ? "tools" : END;   // ← END 를 반환하지 않으면 무한 루프
};

const handBuilt = new StateGraph(AgentState)
  .addNode("model_request", callModel)
  .addNode("tools", toolNode)
  .addEdge(START, "model_request")
  .addConditionalEdges("model_request", shouldContinue, ["tools", END])
  .addEdge("tools", "model_request")   // 도구 결과를 들고 모델로 되돌아간다 = 루프
  .compile();

/**
 * Step 17 — LangGraph 그래프 API
 * 실행: npx tsx docs/reference/langchain/step-17-langgraph/practice.ts
 *
 * [17-1] ~ [17-10] 은 API 키 없이 돌아갑니다 (mock 노드로 그래프 역학만 봅니다).
 * [17-11] 만 실제 모델을 호출하므로 ANTHROPIC_API_KEY 가 필요합니다.
 * 키가 없으면 [17-11] 은 자동으로 건너뜁니다.
 */
import "dotenv/config";
import {
  StateGraph,
  StateSchema,
  MessagesValue,
  ReducedValue,
  UntrackedValue,
  Command,
  Send,
  MemorySaver,
  GraphRecursionError,
  START,
  END,
  type GraphNode,
  type ConditionalEdgeRouter,
} from "@langchain/langgraph";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { AIMessage, HumanMessage } from "@langchain/core/messages";
import { createAgent, tool } from "langchain";
import * as z from "zod";

const line = (t: string) => console.log(`\n${"=".repeat(60)}\n${t}\n${"=".repeat(60)}`);

/* ===== [17-1] LangGraph 는 상태 머신 — 가장 작은 그래프 ===== */
line("[17-1] 가장 작은 그래프");

const HelloState = new StateSchema({
  messages: MessagesValue,
});

// 노드는 "상태를 받아 부분 업데이트 객체를 반환하는 함수" 그 이상이 아닙니다.
const mockLlm: GraphNode<typeof HelloState> = (state) => {
  const last = state.messages.at(-1);
  return { messages: [{ role: "ai", content: `echo: ${last?.content}` }] };
};

const helloGraph = new StateGraph(HelloState)
  .addNode("mock_llm", mockLlm)
  .addEdge(START, "mock_llm")
  .addEdge("mock_llm", END)
  .compile(); // ← compile() 을 빼면 invoke 자체가 존재하지 않습니다.

{
  const result = await helloGraph.invoke({
    messages: [{ role: "user", content: "hi!" }],
  });
  console.log(result.messages.map((m) => `${m.getType()}: ${m.content}`));
}

/* ===== [17-2] 3요소: State / Node / Edge ===== */
line("[17-2] State / Node / Edge");

const CounterState = new StateSchema({
  count: z.number().default(0),
  history: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (a: string[], b: string[]) => a.concat(b),
  }),
});

const increment: GraphNode<typeof CounterState> = (state) => ({
  count: state.count + 1,
  history: [`count 를 ${state.count} → ${state.count + 1} 로 올림`],
});

const double: GraphNode<typeof CounterState> = (state) => ({
  count: state.count * 2,
  history: [`count 를 ${state.count} → ${state.count * 2} 로 두 배`],
});

const counterGraph = new StateGraph(CounterState)
  .addNode("increment", increment)
  .addNode("double", double)
  .addEdge(START, "increment")
  .addEdge("increment", "double")
  .addEdge("double", END)
  .compile();

console.log(await counterGraph.invoke({ count: 5 }));

/* ===== [17-3] 상태 스키마와 리듀서 ===== */
line("[17-3] 리듀서 — 없으면 덮어쓰기, 있으면 합치기");

const ReducerDemo = new StateSchema({
  // 리듀서 없음 → LastValue: 마지막 값이 이긴다
  lastOnly: z.string().default(""),
  // 리듀서 있음 → 누적된다
  accumulated: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (current: string[], update: string[]) => current.concat(update),
  }),
  // 체크포인트에 저장되지 않는 임시 값
  scratch: new UntrackedValue(z.string().default("")),
});

const reducerGraph = new StateGraph(ReducerDemo)
  .addNode("first", () => ({ lastOnly: "첫 번째", accumulated: ["첫 번째"], scratch: "임시1" }))
  .addNode("second", () => ({ lastOnly: "두 번째", accumulated: ["두 번째"], scratch: "임시2" }))
  .addEdge(START, "first")
  .addEdge("first", "second")
  .addEdge("second", END)
  .compile();

console.log(await reducerGraph.invoke({}));
// lastOnly 는 "두 번째" 만 남고, accumulated 는 둘 다 남습니다.

// --- messages 리듀서가 특별한 이유: append + 같은 id 는 교체 ---
const MsgState = new StateSchema({ messages: MessagesValue });
const msgGraph = new StateGraph(MsgState)
  .addNode("add", () => ({ messages: [new AIMessage({ id: "fixed-id", content: "초안" })] }))
  .addNode("revise", () => ({
    messages: [new AIMessage({ id: "fixed-id", content: "교체됨 (id 가 같으므로)" })],
  }))
  .addEdge(START, "add")
  .addEdge("add", "revise")
  .addEdge("revise", END)
  .compile();

{
  const r = await msgGraph.invoke({ messages: [new HumanMessage("안녕")] });
  console.log("메시지 2개만 남습니다 (id 가 같은 것은 교체):");
  console.log(r.messages.map((m) => `  ${m.getType()}(${m.id?.slice(0, 8)}): ${m.content}`).join("\n"));
}

/* ===== [17-4] StateGraph — addNode / addEdge / addConditionalEdges ===== */
/* ===== [17-5] 컴파일과 실행 ===== */
line("[17-5] compile({ checkpointer }) 와 스레드");

const checkpointedGraph = new StateGraph(CounterState)
  .addNode("increment", increment)
  .addEdge(START, "increment")
  .addEdge("increment", END)
  .compile({ checkpointer: new MemorySaver() });

{
  // 체크포인터를 달아 놓고 thread_id 를 안 주면 즉시 에러입니다 (조용히 넘어가지 않습니다).
  try {
    await checkpointedGraph.invoke({});
  } catch (error) {
    console.log("thread_id 없이 호출:", (error as Error).message.split(".")[0]);
  }

  const cfg = { configurable: { thread_id: "thread-A" } };
  const first = await checkpointedGraph.invoke({}, cfg);
  console.log("thread-A 첫 번째 호출 count:", first.count);
  const second = await checkpointedGraph.invoke({}, cfg);
  const third = await checkpointedGraph.invoke({}, cfg);
  console.log("thread-A 두 번째 호출 count:", second.count);
  console.log("thread-A 세 번째 호출 count:", third.count, "← 상태가 이어집니다");
  const other = await checkpointedGraph.invoke({}, { configurable: { thread_id: "thread-B" } });
  console.log("thread-B 첫 호출 count:", other.count, "← 다른 스레드는 처음부터");
}

// stream 으로 노드 단위 중간 결과 보기
console.log("\nstream (노드가 끝날 때마다 update 가 흘러나옵니다):");
for await (const chunk of await counterGraph.stream({ count: 1 }, { streamMode: "updates" })) {
  console.log(" ", JSON.stringify(chunk));
}

/* ===== [17-6] 조건부 분기 — 라우팅 노드 ===== */
line("[17-6] 조건부 분기");

const RouteState = new StateSchema({
  input: z.string().default(""),
  category: z.string().default(""),
  output: z.string().default(""),
});

// 라우팅 "노드" 는 판단 결과를 상태에 적고,
// 라우팅 "함수" 는 그 상태를 읽어 다음 노드 이름만 반환합니다. 둘은 역할이 다릅니다.
const classify: GraphNode<typeof RouteState> = (state) => {
  const category = state.input.includes("환불") ? "refund" : "general";
  return { category };
};

const handleRefund: GraphNode<typeof RouteState> = () => ({ output: "환불 팀으로 연결합니다." });
const handleGeneral: GraphNode<typeof RouteState> = () => ({ output: "일반 상담으로 처리합니다." });

// 타입 인자는 `<Schema, Context, Nodes>` 순서입니다. 노드 이름만 좁히고 싶을 땐
// 가운데 Context 를 건너뛸 수 없으므로, 아래처럼 "타입 백(type bag)" 형태가 편합니다.
const route: ConditionalEdgeRouter<{
  InputSchema: typeof RouteState;
  Nodes: "handleRefund" | "handleGeneral";
}> = (state) => (state.category === "refund" ? "handleRefund" : "handleGeneral");

const routeGraph = new StateGraph(RouteState)
  .addNode("classify", classify)
  .addNode("handleRefund", handleRefund)
  .addNode("handleGeneral", handleGeneral)
  .addEdge(START, "classify")
  // 세 번째 인자로 도착 가능한 노드를 명시하면 그림도 정확해지고 타입도 좁혀집니다.
  .addConditionalEdges("classify", route, ["handleRefund", "handleGeneral"])
  .addEdge("handleRefund", END)
  .addEdge("handleGeneral", END)
  .compile();

console.log(await routeGraph.invoke({ input: "환불 해주세요" }));
console.log(await routeGraph.invoke({ input: "영업시간 알려주세요" }));

/* ===== [17-7] 병렬 실행(fan-out / fan-in)과 리듀서의 필요성 ===== */
line("[17-7] 병렬 실행과 리듀서");

// (A) 리듀서 없는 키에 두 노드가 동시에 쓰면 → InvalidUpdateError
const BadParallel = new StateSchema({ value: z.string().default("") });
const badGraph = new StateGraph(BadParallel)
  .addNode("branchA", () => ({ value: "A" }))
  .addNode("branchB", () => ({ value: "B" }))
  .addEdge(START, "branchA")
  .addEdge(START, "branchB")
  .addEdge("branchA", END)
  .addEdge("branchB", END)
  .compile();

try {
  await badGraph.invoke({});
  console.log("여기는 실행되지 않습니다");
} catch (error) {
  console.log("(A) 리듀서 없이 병렬 쓰기:", (error as Error).constructor.name);
  console.log("   ", (error as Error).message.split("\n")[0]);
}

// (B) 리듀서를 주면 두 브랜치의 결과가 합쳐집니다
const GoodParallel = new StateSchema({
  value: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (a: string[], b: string[]) => a.concat(b),
  }),
});
const goodGraph = new StateGraph(GoodParallel)
  .addNode("branchA", () => ({ value: ["A"] }))
  .addNode("branchB", () => ({ value: ["B"] }))
  .addNode("merge", (state) => {
    console.log("    fan-in 노드는 두 브랜치가 모두 끝난 뒤 한 번만 실행됩니다:", state.value);
    return {};
  })
  .addEdge(START, "branchA")
  .addEdge(START, "branchB")
  .addEdge("branchA", "merge")
  .addEdge("branchB", "merge")
  .addEdge("merge", END)
  .compile();

console.log("(B) 리듀서 있음:", await goodGraph.invoke({}));

// (C) 병렬 브랜치의 "실행 순서" 를 가정하면 틀립니다
const OrderState = new StateSchema({
  log: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (a: string[], b: string[]) => a.concat(b),
  }),
});
const delayed = (name: string, ms: number): GraphNode<typeof OrderState> => async () => {
  await new Promise((r) => setTimeout(r, ms));
  return { log: [name] };
};
const orderGraph = new StateGraph(OrderState)
  .addNode("slow", delayed("slow(50ms)", 50)) // 먼저 선언했지만
  .addNode("fast", delayed("fast(0ms)", 0)) // 이쪽이 먼저 끝납니다
  .addEdge(START, "slow")
  .addEdge(START, "fast")
  .addEdge("slow", END)
  .addEdge("fast", END)
  .compile();

console.log("(C) 선언 순서는 slow → fast 지만 결과는:", (await orderGraph.invoke({})).log);

// (D) Send 로 동적 fan-out (map-reduce)
const MapReduce = new StateSchema({
  subjects: z.array(z.string()).default(() => []),
  results: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (a: string[], b: string[]) => a.concat(b),
  }),
});
const WorkerState = new StateSchema({
  subject: z.string().default(""),
  results: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (a: string[], b: string[]) => a.concat(b),
  }),
});
const worker: GraphNode<typeof WorkerState> = (state) => ({
  results: [`${state.subject} 처리 완료`],
});
const mapReduceGraph = new StateGraph(MapReduce)
  .addNode("worker", worker)
  // Send(노드이름, 그 노드에만 줄 상태) — 런타임에 개수가 정해지는 fan-out
  .addConditionalEdges(START, (state) => state.subjects.map((s) => new Send("worker", { subject: s })), [
    "worker",
  ])
  .addEdge("worker", END)
  .compile();

console.log("(D) Send fan-out:", (await mapReduceGraph.invoke({ subjects: ["고양이", "강아지", "햄스터"] })).results);

/* ===== [17-8] Command — 상태 갱신 + 라우팅 동시에 ===== */
line("[17-8] Command");

const CmdState = new StateSchema({ score: z.number().default(0), verdict: z.string().default("") });

// Command 를 반환하는 노드는 goto 대상 이름을 타입으로 좁혀 둘 수 있습니다.
const evaluate: GraphNode<{
  InputSchema: typeof CmdState;
  Nodes: "pass" | "fail";
}> = (state) => {
  const score = state.score + 60;
  return new Command({
    update: { score }, // 상태를 갱신하면서
    goto: score >= 60 ? "pass" : "fail", // 동시에 다음 노드를 정한다
  });
};

const cmdGraph = new StateGraph(CmdState)
  .addNode("evaluate", evaluate, { ends: ["pass", "fail"] }) // ends 를 꼭 알려줘야 그림이 그려집니다
  .addNode("pass", () => ({ verdict: "합격" }))
  .addNode("fail", () => ({ verdict: "불합격" }))
  .addEdge(START, "evaluate")
  .addEdge("pass", END)
  .addEdge("fail", END)
  .compile();

console.log(await cmdGraph.invoke({ score: 10 }));

/* ===== [17-9] 서브그래프 ===== */
line("[17-9] 서브그래프");

const SharedState = new StateSchema({ messages: MessagesValue, note: z.string().default("") });

// 서브그래프도 그냥 컴파일된 그래프입니다 — 부모의 addNode 에 그대로 넣습니다.
const subgraph = new StateGraph(SharedState)
  .addNode("subWork", () => ({
    note: "서브그래프가 씀",
    messages: [new AIMessage("서브그래프에서 처리했습니다")],
  }))
  .addEdge(START, "subWork")
  .addEdge("subWork", END)
  .compile();

const parentGraph = new StateGraph(SharedState)
  .addNode("child", subgraph) // ← 컴파일된 그래프가 곧 노드
  .addNode("after", (state) => ({ note: `${state.note} → 부모가 이어받음` }))
  .addEdge(START, "child")
  .addEdge("child", "after")
  .addEdge("after", END)
  .compile();

{
  const r = await parentGraph.invoke({ messages: [new HumanMessage("시작")] });
  console.log("note:", r.note);
  console.log("messages:", r.messages.map((m) => m.content));
  // 키 이름을 공유하면 부모/자식 상태가 자동으로 이어집니다.
}

/* ===== [17-10] 시각화 ===== */
line("[17-10] 시각화 — drawMermaid()");

console.log("routeGraph 의 mermaid 소스:\n");
console.log((await routeGraph.getGraphAsync()).drawMermaid());
// PNG 로 저장하려면:
//   const image = await (await routeGraph.getGraphAsync()).drawMermaidPng();
//   await fs.writeFile("graph.png", new Uint8Array(await image.arrayBuffer()));

/* ===== [17-11] ReAct 에이전트를 그래프로 직접 구현 → createAgent 와 비교 ===== */
line("[17-11] ReAct 를 손으로 짜기 vs createAgent");

const getWeather = tool(({ city }: { city: string }) => `${city}: 맑음, 24도`, {
  name: "get_weather",
  description: "도시의 현재 날씨를 조회한다",
  schema: z.object({ city: z.string().describe("도시 이름") }),
});

// createAgent 는 "사실 그래프" 입니다. 껍데기를 벗겨 구조를 확인합니다.
const packaged = createAgent({ model: "anthropic:claude-sonnet-4-6", tools: [getWeather] });
console.log("createAgent 가 돌려준 것의 클래스:", packaged.constructor.name);
console.log("createAgent 내부 그래프의 노드:", Object.keys((await (packaged as any).getGraphAsync()).nodes));
console.log("\ncreateAgent 내부 그래프:\n");
console.log((await (packaged as any).getGraphAsync()).drawMermaid());

if (!process.env.ANTHROPIC_API_KEY) {
  console.log("\nANTHROPIC_API_KEY 가 없어 실제 호출은 건너뜁니다.");
  console.log("(위의 구조 출력은 키 없이도 나옵니다 — 그래프 조립에는 모델 호출이 필요 없기 때문입니다.)");
} else {
  const { ChatAnthropic } = await import("@langchain/anthropic");
  const llm = new ChatAnthropic({ model: "claude-sonnet-4-6" });
  // OpenAI 를 쓰려면:
  //   const { ChatOpenAI } = await import("@langchain/openai");
  //   const llm = new ChatOpenAI({ model: "gpt-5.5" });
  const llmWithTools = llm.bindTools([getWeather]);

  const AgentState = new StateSchema({ messages: MessagesValue });

  // 노드 1 — 모델을 부른다
  const callModel: GraphNode<typeof AgentState> = async (state) => {
    const response = await llmWithTools.invoke([
      { role: "system", content: "너는 날씨를 알려주는 비서다." },
      ...state.messages,
    ]);
    return { messages: [response] };
  };

  // 노드 2 — 도구를 실행한다 (ToolMessage 로 tool_call_id 를 맞춰 돌려주는 일을 대신해 줍니다)
  const toolNode = new ToolNode([getWeather]);

  // 엣지 — 도구 호출이 남아 있으면 tools 로, 아니면 END 로
  const shouldContinue: ConditionalEdgeRouter<{
    InputSchema: typeof AgentState;
    Nodes: "tools";
  }> = (state) => {
    const last = state.messages.at(-1) as AIMessage;
    return last?.tool_calls?.length ? "tools" : END; // ← END 를 반환하지 않으면 무한 루프
  };

  const handBuilt = new StateGraph(AgentState)
    .addNode("model_request", callModel)
    .addNode("tools", toolNode)
    .addEdge(START, "model_request")
    .addConditionalEdges("model_request", shouldContinue, ["tools", END])
    .addEdge("tools", "model_request") // 도구 결과를 들고 모델로 되돌아간다 = 루프
    .compile();

  console.log("\n손으로 짠 그래프:\n");
  console.log((await handBuilt.getGraphAsync()).drawMermaid());

  const r = await handBuilt.invoke({ messages: [new HumanMessage("서울 날씨 어때?")] });
  console.log("\n손으로 짠 ReAct 결과 (모델 응답이므로 매번 다릅니다):");
  console.log(r.messages.map((m) => `  ${m.getType()}: ${JSON.stringify(m.content).slice(0, 90)}`).join("\n"));

  const r2 = await packaged.invoke({ messages: [new HumanMessage("서울 날씨 어때?")] });
  console.log("\ncreateAgent 결과 (같은 구조, 같은 흐름):");
  console.log(r2.messages.map((m) => `  ${m.getType()}: ${JSON.stringify(m.content).slice(0, 90)}`).join("\n"));
}

/* ===== [17-12] 무한 루프와 recursionLimit ===== */
line("[17-12] recursionLimit — 그래프의 안전벨트");

const LoopState = new StateSchema({ n: z.number().default(0) });
const loopGraph = new StateGraph(LoopState)
  .addNode("a", (state) => ({ n: state.n + 1 }))
  .addNode("b", (state) => ({ n: state.n + 1 }))
  .addEdge(START, "a")
  .addConditionalEdges("a", () => "b", ["b"]) // END 를 절대 반환하지 않는 라우터
  .addEdge("b", "a")
  .compile();

try {
  await loopGraph.invoke({}, { recursionLimit: 6 });
} catch (error) {
  console.log("END 없는 라우터의 최후:", (error as Error).constructor.name);
  console.log("instanceof GraphRecursionError:", error instanceof GraphRecursionError);
}

console.log("\n끝. 각 절의 [17-x] 주석 번호는 본문 소제목과 1:1 로 대응합니다.");

/**
 * Step 17 — LangGraph 그래프 API — 연습문제
 * 실행: npx tsx docs/reference/langchain/step-17-langgraph/exercise.ts
 *
 * 각 [문제 N] 아래를 직접 채우세요. 전부 API 키 없이 풀 수 있습니다.
 * 정답은 solution.ts 에 있습니다. 먼저 스스로 풀어본 뒤에 열어보세요.
 */
import "dotenv/config";
import {
  StateGraph,
  StateSchema,
  MessagesValue,
  ReducedValue,
  Command,
  Send,
  MemorySaver,
  START,
  END,
  type GraphNode,
  type ConditionalEdgeRouter,
} from "@langchain/langgraph";
import { AIMessage, HumanMessage } from "@langchain/core/messages";
import * as z from "zod";

const line = (t: string) => console.log(`\n${"=".repeat(60)}\n${t}\n${"=".repeat(60)}`);

/* ===== [문제 1] 순차 그래프 =====
 * 상태에 `text: string` 하나를 두고, 노드 3개를 순서대로 연결하세요.
 *   trim    → 앞뒤 공백 제거
 *   upper   → 대문자로
 *   exclaim → 뒤에 "!" 붙이기
 * START → trim → upper → exclaim → END 로 이어서
 * invoke({ text: "  hello graph  " }) 가 { text: "HELLO GRAPH!" } 가 되게 하세요.
 */
line("[문제 1] 순차 그래프");

// 여기에 작성하세요

/* ===== [문제 2] 커스텀 리듀서 =====
 * 상태 키 `maxScore: number` 를 만들되, 리듀서가 "더 큰 값만 살아남게" 동작해야 합니다.
 * (기본 LastValue 는 마지막 값이 이기지만, 이 키는 최댓값이 이겨야 합니다.)
 * 노드 3개가 각각 30, 90, 50 을 쓰고 START 에서 병렬로 fan-out 되게 하세요.
 * 최종 결과가 { maxScore: 90 } 이어야 합니다.
 * 힌트: new ReducedValue(z.number().default(0), { reducer: (a, b) => ... })
 */
line("[문제 2] 커스텀 리듀서");

// 여기에 작성하세요

/* ===== [문제 3] 조건부 분기 =====
 * 상태: { amount: number; tier: string; message: string }
 * classify 노드가 amount 를 보고 tier 를 정합니다 (10000 이상이면 "vip", 아니면 "normal").
 * 라우터가 tier 를 읽어 vipNode / normalNode 로 보냅니다.
 * addConditionalEdges 의 세 번째 인자로 도착 가능한 노드를 명시하세요.
 * invoke({ amount: 50000 }) → message 가 "VIP 혜택 적용", 아니면 "일반 처리".
 */
line("[문제 3] 조건부 분기");

// 여기에 작성하세요

/* ===== [문제 4] 깨진 병렬 그래프 고치기 =====
 * 아래 그래프는 InvalidUpdateError 로 터집니다. 왜 터지는지 확인한 뒤,
 * `logs` 키에 리듀서를 달아 두 브랜치의 결과가 모두 남도록 고치세요.
 * (BrokenState 를 고쳐서 FixedState 를 만들고, 그래프를 다시 조립하면 됩니다.)
 */
line("[문제 4] 깨진 병렬 그래프 고치기");

const BrokenState = new StateSchema({
  logs: z.array(z.string()).default(() => []), // ← 리듀서가 없다
});

const brokenGraph = new StateGraph(BrokenState)
  .addNode("fetchUser", () => ({ logs: ["유저 조회"] }))
  .addNode("fetchOrders", () => ({ logs: ["주문 조회"] }))
  .addEdge(START, "fetchUser")
  .addEdge(START, "fetchOrders")
  .addEdge("fetchUser", END)
  .addEdge("fetchOrders", END)
  .compile();

try {
  console.log(await brokenGraph.invoke({}));
} catch (error) {
  console.log("고치기 전:", (error as Error).constructor.name);
}

// 여기에 고친 버전을 작성하세요 (결과가 logs: ["유저 조회", "주문 조회"] 두 개 다 남아야 함)

/* ===== [문제 5] Command 로 상태 갱신 + 라우팅 =====
 * 상태: { attempts: number; status: string }
 * `tryTask` 노드는 attempts 를 1 늘리면서, 동시에
 *   attempts 가 3 미만이면 자기 자신("tryTask") 으로 되돌아가고
 *   3 이상이면 "giveUp" 으로 가야 합니다.
 * 이걸 addConditionalEdges 없이 Command 하나로만 구현하세요.
 * giveUp 노드는 status 를 "포기"로 설정합니다.
 * 최종 결과: { attempts: 3, status: "포기" }
 * 힌트: addNode 의 세 번째 인자 { ends: [...] } 를 잊지 마세요.
 */
line("[문제 5] Command");

// 여기에 작성하세요

/* ===== [문제 6] Send 로 map-reduce =====
 * 상태: { words: string[]; lengths: number[] (리듀서로 누적) }
 * START 에서 words 각각을 "measure" 노드로 Send 하고,
 * measure 노드는 받은 단어의 길이를 lengths 에 넣습니다.
 * invoke({ words: ["a", "bb", "ccc"] }) → lengths 에 1, 2, 3 이 모두 담겨야 합니다.
 * (순서는 보장되지 않으니 정렬해서 비교하세요.)
 */
line("[문제 6] Send map-reduce");

// 여기에 작성하세요

/* ===== [문제 7] 서브그래프 =====
 * `messages` 와 `summary` 를 공유 상태로 두고:
 *   - 서브그래프: "summarize" 노드가 messages 개수를 세어 summary 에 "메시지 N개" 라고 적는다
 *   - 부모 그래프: 서브그래프를 "child" 노드로 넣고, 그 뒤 "report" 노드가
 *     summary 를 읽어 messages 에 AIMessage 로 덧붙인다
 * invoke({ messages: [HumanMessage("a"), HumanMessage("b")] }) 를 실행해
 * 마지막 메시지가 "메시지 2개" 를 포함하는지 확인하세요.
 */
line("[문제 7] 서브그래프");

// 여기에 작성하세요

/* ===== [문제 8] ReAct 루프를 mock 으로 직접 구현 =====
 * 실제 모델 없이 ReAct 구조만 만듭니다.
 * 상태: { messages: MessagesValue, toolCallsLeft: number }
 * - "model" 노드: toolCallsLeft 가 0 보다 크면 tool_calls 가 있는 AIMessage 를 흉내내고
 *   (messages 에 AIMessage("도구를 부릅니다") 를 추가, toolCallsLeft 를 1 줄임)
 *   0 이면 AIMessage("최종 답변") 을 추가한다.
 * - "tools" 노드: messages 에 AIMessage("도구 결과") 를 추가한다.
 * - 라우터: 마지막 메시지가 "도구를 부릅니다" 면 "tools", 아니면 END.
 * - "tools" → "model" 로 되돌아간다 (루프).
 * invoke({ messages: [HumanMessage("시작")], toolCallsLeft: 2 }) 가
 * 무한 루프에 빠지지 않고 "최종 답변" 으로 끝나는지 확인하세요.
 * 또 라우터에서 END 를 절대 반환하지 않게 바꾸면 어떤 에러가 나는지도 확인하세요.
 */
line("[문제 8] ReAct 루프");

// 여기에 작성하세요

/**
 * Step 17 — LangGraph 그래프 API — 정답과 해설
 * 실행: npx tsx docs/reference/langchain/step-17-langgraph/solution.ts
 *
 * exercise.ts 를 스스로 풀어본 뒤에 열어보세요.
 */
import "dotenv/config";
import {
  StateGraph,
  StateSchema,
  MessagesValue,
  ReducedValue,
  Command,
  Send,
  GraphRecursionError,
  START,
  END,
  type GraphNode,
  type ConditionalEdgeRouter,
} from "@langchain/langgraph";
import { AIMessage, HumanMessage } from "@langchain/core/messages";
import * as z from "zod";

const line = (t: string) => console.log(`\n${"=".repeat(60)}\n${t}\n${"=".repeat(60)}`);

/* ===== [정답 1] 순차 그래프 =====
 * 핵심: 노드는 "상태 전체" 가 아니라 "바뀐 부분만" 담은 객체를 반환합니다.
 * { text: ... } 만 돌려주면 나머지 키는 알아서 유지됩니다.
 * 그리고 state 를 직접 고치면(state.text = ...) 반영되지 않습니다 — 반드시 return.
 */
line("[정답 1] 순차 그래프");

const TextState = new StateSchema({ text: z.string().default("") });

const trim: GraphNode<typeof TextState> = (state) => ({ text: state.text.trim() });
const upper: GraphNode<typeof TextState> = (state) => ({ text: state.text.toUpperCase() });
const exclaim: GraphNode<typeof TextState> = (state) => ({ text: `${state.text}!` });

const textGraph = new StateGraph(TextState)
  .addNode("trim", trim)
  .addNode("upper", upper)
  .addNode("exclaim", exclaim)
  .addEdge(START, "trim")
  .addEdge("trim", "upper")
  .addEdge("upper", "exclaim")
  .addEdge("exclaim", END)
  .compile();

console.log(await textGraph.invoke({ text: "  hello graph  " }));
// → { text: 'HELLO GRAPH!' }

/* ===== [정답 2] 커스텀 리듀서 =====
 * 리듀서 시그니처는 (현재값, 이번 업데이트) => 새 값 입니다.
 * Math.max 를 리듀서로 쓰면 "쓰는 순서와 무관하게" 최댓값이 남습니다.
 * 이게 리듀서의 본질입니다 — 병렬 브랜치의 순서가 보장되지 않아도
 * 결과가 결정적이려면 리듀서가 교환법칙을 만족해야 합니다.
 * (concat 은 순서에 의존하지만 max 는 그렇지 않습니다.)
 */
line("[정답 2] 커스텀 리듀서");

const MaxState = new StateSchema({
  maxScore: new ReducedValue(z.number().default(0), {
    reducer: (current: number, update: number) => Math.max(current, update),
  }),
});

const maxGraph = new StateGraph(MaxState)
  .addNode("scoreA", () => ({ maxScore: 30 }))
  .addNode("scoreB", () => ({ maxScore: 90 }))
  .addNode("scoreC", () => ({ maxScore: 50 }))
  .addEdge(START, "scoreA")
  .addEdge(START, "scoreB")
  .addEdge(START, "scoreC")
  .addEdge("scoreA", END)
  .addEdge("scoreB", END)
  .addEdge("scoreC", END)
  .compile();

console.log(await maxGraph.invoke({}));
// → { maxScore: 90 } — 리듀서가 없었다면 InvalidUpdateError 로 터졌을 그래프입니다.

/* ===== [정답 3] 조건부 분기 =====
 * 함정: 라우터 함수는 "노드 이름" 을 반환할 뿐 상태를 바꾸지 못합니다.
 * 판단 결과(tier)를 상태에 남기고 싶으면 classify "노드" 가 따로 있어야 합니다.
 * 세 번째 인자 ["vipNode", "normalNode"] 는 타입 안전성 + 그림 정확도를 줍니다.
 */
line("[정답 3] 조건부 분기");

const TierState = new StateSchema({
  amount: z.number().default(0),
  tier: z.string().default(""),
  message: z.string().default(""),
});

const classify: GraphNode<typeof TierState> = (state) => ({
  tier: state.amount >= 10000 ? "vip" : "normal",
});

const routeTier: ConditionalEdgeRouter<{
  InputSchema: typeof TierState;
  Nodes: "vipNode" | "normalNode";
}> = (state) => (state.tier === "vip" ? "vipNode" : "normalNode");

const tierGraph = new StateGraph(TierState)
  .addNode("classify", classify)
  .addNode("vipNode", () => ({ message: "VIP 혜택 적용" }))
  .addNode("normalNode", () => ({ message: "일반 처리" }))
  .addEdge(START, "classify")
  .addConditionalEdges("classify", routeTier, ["vipNode", "normalNode"])
  .addEdge("vipNode", END)
  .addEdge("normalNode", END)
  .compile();

console.log(await tierGraph.invoke({ amount: 50000 }));
console.log(await tierGraph.invoke({ amount: 500 }));

/* ===== [정답 4] 깨진 병렬 그래프 고치기 =====
 * 원인: logs 에 리듀서가 없으면 LastValue 채널이 됩니다.
 * LastValue 는 한 스텝에 값을 하나만 받을 수 있는데, fetchUser 와 fetchOrders 가
 * "같은 스텝에" 동시에 쓰므로 InvalidUpdateError 가 납니다.
 * 이건 "마지막 것이 이긴다" 로 조용히 넘어가지 않고 명시적으로 터집니다 — 다행입니다.
 * 해결: 두 값을 어떻게 합칠지(concat) 리듀서로 알려주면 됩니다.
 */
line("[정답 4] 깨진 병렬 그래프 고치기");

const FixedState = new StateSchema({
  logs: new ReducedValue(z.array(z.string()).default(() => []), {
    reducer: (current: string[], update: string[]) => current.concat(update),
  }),
});

const fixedGraph = new StateGraph(FixedState)
  .addNode("fetchUser", () => ({ logs: ["유저 조회"] }))
  .addNode("fetchOrders", () => ({ logs: ["주문 조회"] }))
  .addEdge(START, "fetchUser")
  .addEdge(START, "fetchOrders")
  .addEdge("fetchUser", END)
  .addEdge("fetchOrders", END)
  .compile();

console.log(await fixedGraph.invoke({}));
// → 두 값이 모두 남습니다. 다만 순서는 보장되지 않습니다 —
// 이 파일을 돌려보면 [ '주문 조회', '유저 조회' ] 처럼 선언 순서와 뒤집혀 나오기도 합니다.
// 순서가 중요하면 병렬로 만들지 말고 순차 엣지로 잇거나, 정렬 가능한 값을 함께 넣으세요.

/* ===== [정답 5] Command =====
 * Command 는 update(상태 갱신) 와 goto(다음 노드) 를 한 번에 반환합니다.
 * addConditionalEdges 없이 노드 스스로 다음 행선지를 정하므로 라우팅 로직이
 * 판단에 필요한 데이터 바로 옆에 있게 됩니다.
 * 함정: { ends: [...] } 를 안 주면 그래프가 이 노드에서 어디로 갈 수 있는지 몰라
 * 그림이 비고, 도착지가 연결되지 않습니다.
 */
line("[정답 5] Command");

const RetryState = new StateSchema({
  attempts: z.number().default(0),
  status: z.string().default(""),
});

const tryTask: GraphNode<{
  InputSchema: typeof RetryState;
  Nodes: "tryTask" | "giveUp";
}> = (state) => {
  const attempts = state.attempts + 1;
  return new Command({
    update: { attempts },
    goto: attempts < 3 ? "tryTask" : "giveUp", // 자기 자신으로도 갈 수 있습니다
  });
};

const retryGraph = new StateGraph(RetryState)
  .addNode("tryTask", tryTask, { ends: ["tryTask", "giveUp"] })
  .addNode("giveUp", () => ({ status: "포기" }))
  .addEdge(START, "tryTask")
  .addEdge("giveUp", END)
  .compile();

console.log(await retryGraph.invoke({}));
// → { attempts: 3, status: '포기' }

/* ===== [정답 6] Send map-reduce =====
 * Send(노드이름, 그 노드에게만 줄 상태) 는 "런타임에 개수가 정해지는 fan-out" 입니다.
 * 엣지를 미리 N개 그려둘 수 없을 때(단어 수를 실행 전엔 모름) 쓰는 유일한 방법입니다.
 * 함정: Send 로 보낸 상태는 워커 노드에게만 갑니다. 워커가 전체 상태를 볼 거라
 * 기대하면 틀립니다 — 워커용 스키마를 따로 두는 게 정석입니다.
 * 그리고 워커 N개가 동시에 lengths 에 쓰므로 리듀서가 반드시 필요합니다.
 */
line("[정답 6] Send map-reduce");

const WordState = new StateSchema({
  words: z.array(z.string()).default(() => []),
  lengths: new ReducedValue(z.array(z.number()).default(() => []), {
    reducer: (current: number[], update: number[]) => current.concat(update),
  }),
});

const MeasureState = new StateSchema({
  word: z.string().default(""),
  lengths: new ReducedValue(z.array(z.number()).default(() => []), {
    reducer: (current: number[], update: number[]) => current.concat(update),
  }),
});

const measure: GraphNode<typeof MeasureState> = (state) => ({ lengths: [state.word.length] });

// START 에서 곧바로 Send 를 뿌립니다 (조건부 엣지의 출발점이 START 여도 됩니다).
const wordGraph = new StateGraph(WordState)
  .addNode("measure", measure)
  .addConditionalEdges(START, (state) => state.words.map((w) => new Send("measure", { word: w })), [
    "measure",
  ])
  .addEdge("measure", END)
  .compile();

{
  const result = await wordGraph.invoke({ words: ["a", "bb", "ccc"] });
  console.log("lengths (정렬 전, 순서 보장 없음):", result.lengths);
  console.log("lengths (정렬 후):", [...result.lengths].sort((a, b) => a - b));
}

/* ===== [정답 7] 서브그래프 =====
 * 서브그래프는 그냥 컴파일된 그래프이고, 부모의 addNode 에 함수 대신 넣으면 됩니다.
 * 부모와 자식이 "같은 이름의 키" 를 공유하면 상태가 자동으로 오갑니다.
 * 함정: 키 이름이 다르면 아무것도 전달되지 않는데, 에러가 아니라 조용히
 * 빈 값으로 동작합니다. 공유하려는 키 이름은 정확히 일치해야 합니다.
 */
line("[정답 7] 서브그래프");

const SharedState = new StateSchema({
  messages: MessagesValue,
  summary: z.string().default(""),
});

const summarize: GraphNode<typeof SharedState> = (state) => ({
  summary: `메시지 ${state.messages.length}개`,
});

const summarySubgraph = new StateGraph(SharedState)
  .addNode("summarize", summarize)
  .addEdge(START, "summarize")
  .addEdge("summarize", END)
  .compile();

const report: GraphNode<typeof SharedState> = (state) => ({
  messages: [new AIMessage(`요약 결과: ${state.summary}`)],
});

const reportGraph = new StateGraph(SharedState)
  .addNode("child", summarySubgraph) // 컴파일된 그래프가 곧 노드
  .addNode("report", report)
  .addEdge(START, "child")
  .addEdge("child", "report")
  .addEdge("report", END)
  .compile();

{
  const result = await reportGraph.invoke({
    messages: [new HumanMessage("a"), new HumanMessage("b")],
  });
  console.log("summary:", result.summary);
  console.log("마지막 메시지:", result.messages.at(-1)?.content);
}

/* ===== [정답 8] ReAct 루프 =====
 * 이 구조가 createAgent 가 내부에서 하는 일의 전부입니다:
 *   START → model → (도구 호출 있나?) → tools → model → ... → END
 * 실제 createAgent 의 노드 이름은 model_request / tools 이고 모양이 똑같습니다.
 * 함정: 라우터가 END 를 반환할 조건이 없으면 tools ↔ model 을 영원히 돕니다.
 * recursionLimit(기본 25) 이 GraphRecursionError 로 끊어주지만,
 * 그건 안전벨트일 뿐 종료 조건의 대체재가 아닙니다.
 */
line("[정답 8] ReAct 루프");

const MockAgentState = new StateSchema({
  messages: MessagesValue,
  toolCallsLeft: z.number().default(0),
});

const mockModel: GraphNode<typeof MockAgentState> = (state) => {
  if (state.toolCallsLeft > 0) {
    return {
      messages: [new AIMessage("도구를 부릅니다")],
      toolCallsLeft: state.toolCallsLeft - 1,
    };
  }
  return { messages: [new AIMessage("최종 답변")] };
};

const mockTools: GraphNode<typeof MockAgentState> = () => ({
  messages: [new AIMessage("도구 결과")],
});

const shouldContinue: ConditionalEdgeRouter<{
  InputSchema: typeof MockAgentState;
  Nodes: "tools";
}> = (state) => (state.messages.at(-1)?.content === "도구를 부릅니다" ? "tools" : END);

const reactGraph = new StateGraph(MockAgentState)
  .addNode("model", mockModel)
  .addNode("tools", mockTools)
  .addEdge(START, "model")
  .addConditionalEdges("model", shouldContinue, ["tools", END])
  .addEdge("tools", "model")
  .compile();

{
  const result = await reactGraph.invoke({
    messages: [new HumanMessage("시작")],
    toolCallsLeft: 2,
  });
  console.log("정상 종료:");
  console.log(result.messages.map((m) => `  ${m.getType()}: ${m.content}`).join("\n"));
  console.log("\n그래프 모양:");
  console.log((await reactGraph.getGraphAsync()).drawMermaid());
}

// END 를 절대 반환하지 않는 라우터로 바꾸면?
const neverEnds = new StateGraph(MockAgentState)
  .addNode("model", mockModel)
  .addNode("tools", mockTools)
  .addEdge(START, "model")
  .addConditionalEdges("model", () => "tools", ["tools"]) // END 가 없다
  .addEdge("tools", "model")
  .compile();

try {
  await neverEnds.invoke({ messages: [new HumanMessage("시작")], toolCallsLeft: 1 });
} catch (error) {
  console.log("\nEND 없는 라우터:", (error as Error).constructor.name);
  console.log("instanceof GraphRecursionError:", error instanceof GraphRecursionError);
}