#Step 10 — 단기 메모리와 스레드

import { createAgent } from "langchain";

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

const first = await agent.invoke({
  messages: [{ role: "user", content: "안녕하세요. 제 이름은 김민수입니다." }],
});

const second = await agent.invoke({
  messages: [{ role: "user", content: "제 이름이 뭐라고 했죠?" }],
});

console.log(first.messages.length);   // 2  — user, ai
console.log(second.messages.length);  // 2  — user, ai  (4가 아닙니다)

const history = [...first.messages];   // user, ai

const manual = await agent.invoke({
  messages: [...history, { role: "user", content: "제 이름이 뭐라고 했죠?" }],
});

import { createAgent } from "langchain";
import { MemorySaver } from "@langchain/langgraph";

const checkpointer = new MemorySaver();

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  checkpointer,            // ← 어디에
});

await agent.invoke(
  { messages: [{ role: "user", content: "제 이름은 김민수입니다." }] },
  { configurable: { thread_id: "ok-thread" } },   // ← 어느 대화로
);

const remembered = await agent.invoke(
  { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
  { configurable: { thread_id: "ok-thread" } },   // ← 같은 대화
);

console.log(remembered.messages.length);  // 4  — user, ai, user, ai

{ configurable: { thread_id: "1" } }
{ configurable: { thread_id: crypto.randomUUID() } }
{ configurable: { thread_id: "user:8821:chat:2026-07-17" } }

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  // checkpointer 를 깜빡했습니다
});

const cfg = { configurable: { thread_id: "trap-thread" } };

await agent.invoke({ messages: [{ role: "user", content: "제 이름은 김민수입니다." }] }, cfg);
const forgot = await agent.invoke({ messages: [{ role: "user", content: "제 이름이 뭐죠?" }] }, cfg);

console.log(forgot.messages.length);  // 2  — 4가 아닙니다

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

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

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [getWeather],
  systemPrompt: "당신은 간결하게 답하는 여행 도우미입니다.",
  checkpointer: new MemorySaver(),
});

const config = { configurable: { thread_id: "trip-2026-07" } };

const turns = [
  "저는 부산에 살고 있어요.",
  "제가 사는 도시 날씨 알려주세요.",   // ← "부산"이라고 안 말했습니다
  "그럼 반팔 입어도 될까요?",
  "제가 어디 산다고 했죠?",
];

for (const [i, text] of turns.entries()) {
  const result = await agent.invoke({ messages: [{ role: "user", content: text }] }, config);
  console.log(`--- 턴 ${i + 1} (누적 messages: ${result.messages.length}) ---`);
  printMessages(result.messages.at(-1)!);
}

const finalState = await agent.getState(config);
printMessages(finalState.values.messages);

const checkpointer = new MemorySaver();
const agent = createAgent({ model: "anthropic:claude-sonnet-4-6", tools: [], checkpointer });

const alice = { configurable: { thread_id: "user-alice" } };
const bob   = { configurable: { thread_id: "user-bob" } };

await agent.invoke({ messages: [{ role: "user", content: "제 이름은 앨리스입니다." }] }, alice);
await agent.invoke({ messages: [{ role: "user", content: "제 이름은 밥입니다." }] }, bob);

const askAlice = await agent.invoke({ messages: [{ role: "user", content: "제 이름이 뭐죠?" }] }, alice);
const askBob   = await agent.invoke({ messages: [{ role: "user", content: "제 이름이 뭐죠?" }] }, bob);

const fresh = await agent.getState({ configurable: { thread_id: "never-used" } });

const snapshot = await agent.getState({ configurable: { thread_id: "inspect-1" } });

printKV({
  "values.messages 개수": snapshot.values.messages.length,
  next: JSON.stringify(snapshot.next),
  "config.checkpoint_id": snapshot.config.configurable?.checkpoint_id,
  "metadata.source": snapshot.metadata?.source,
  "metadata.step": snapshot.metadata?.step,
  createdAt: snapshot.createdAt,
});

// 배열이 아니라 async iterable 입니다. for await 로 돕니다.
const history = [];
for await (const state of agent.getStateHistory(config)) {
  history.push(state);
}

const before = await agent.getState(config);
console.log(before.values.messages.length);   // 2

// "이 메시지 하나로 바꿔치기" 를 의도했습니다
await agent.updateState(config, {
  messages: [{ role: "user", content: "(수동으로 끼워 넣은 메시지)" }],
});

const after = await agent.getState(config);
console.log(after.values.messages.length);    // 3  ← 1이 아닙니다

import { RemoveMessage } from "@langchain/core/messages";
import { REMOVE_ALL_MESSAGES } from "@langchain/langgraph";

await agent.updateState(config, {
  messages: [
    new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),      // ← 먼저 전부 비우고
    { role: "user", content: "이것만 남는다" },            // ← 남길 것을 뒤에
  ],
});

const replaced = await agent.getState(config);
console.log(replaced.values.messages.length);   // 1

const lastId = after.values.messages.at(-1)!.id!;
await agent.updateState(config, {
  messages: [new RemoveMessage({ id: lastId })],
});

// 최신을 가리킴
{ configurable: { thread_id: "1" } }

// 특정 체크포인트를 가리킴
{ configurable: { thread_id: "1", checkpoint_id: "1ef663ba-28fe-6528-8002-5a559208592c" } }

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  systemPrompt: "당신은 한 문장으로만 답합니다.",
  checkpointer: new MemorySaver(),
});
const config = { configurable: { thread_id: "timetravel-1" } };

await agent.invoke({ messages: [{ role: "user", content: "제가 좋아하는 색은 파란색입니다." }] }, config);
await agent.invoke({ messages: [{ role: "user", content: "제가 좋아하는 동물은 고양이입니다." }] }, config);
await agent.invoke({ messages: [{ role: "user", content: "제 취향을 요약해 주세요." }] }, config);

const history = [];
for await (const state of agent.getStateHistory(config)) {
  history.push(state);
}

// 2턴이 끝난 시점: 실행이 멈춰 있고(next=[]) messages 가 4개
const afterTurn2 = history.find(
  (s) => s.next.length === 0 && s.values.messages?.length === 4,
);

const replay = await agent.invoke(
  { messages: [{ role: "user", content: "제가 좋아하는 동물이 뭐죠?" }] },
  afterTurn2.config,        // ← checkpoint_id 가 박힌 config
);
console.log(replay.messages.length);  // 6  — 8이 아닙니다

const forkConfig = await agent.updateState(afterTurn2.config, {
  messages: [{ role: "user", content: "정정합니다. 제가 좋아하는 동물은 강아지입니다." }],
});

const forked = await agent.invoke(
  { messages: [{ role: "user", content: "제가 좋아하는 동물이 뭐죠?" }] },
  forkConfig,               // ← updateState 가 돌려준 config = 새 가지
);

const mainline = await agent.getState(config);
console.log(mainline.values.messages.length);   // 6 — 원래 3턴 대화 그대로

const saverA = new MemorySaver();
const agentA = createAgent({ model: MODEL, tools: [], checkpointer: saverA });
const cfg = { configurable: { thread_id: "restart-demo" } };

await agentA.invoke({ messages: [{ role: "user", content: "제 이름은 김민수입니다." }] }, cfg);
console.log((await agentA.getState(cfg)).values.messages.length);   // 2

// 프로세스 재시작을 흉내: 새 MemorySaver = 새 (빈) 저장소
const saverB = new MemorySaver();
const agentB = createAgent({ model: MODEL, tools: [], checkpointer: saverB });
console.log((await agentB.getState(cfg)).values.messages?.length ?? 0);   // 0

import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";

const checkpointer = SqliteSaver.fromConnString("./checkpoints.sqlite");

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  checkpointer,          // ← MemorySaver 자리에 그냥 끼우면 됩니다
});

import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";

const checkpointer = PostgresSaver.fromConnString(
  "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable",
);

await checkpointer.setup();   // ← 최초 1회. 테이블을 만듭니다.

for (let i = 1; i <= 5; i++) {
  const result = await agent.invoke(
    { messages: [{ role: "user", content: `${i}번째 질문입니다. 아무 말이나 한 문장 해 주세요.` }] },
    config,
  );
  const last = result.messages.at(-1)!;
  const usage = "usage_metadata" in last ? last.usage_metadata : undefined;
  console.log(`턴 ${i}: 입력 토큰 ${usage?.input_tokens}`);
}

import { RemoveMessage } from "@langchain/core/messages";
import { createAgent, createMiddleware } from "langchain";
import { MemorySaver, REMOVE_ALL_MESSAGES } from "@langchain/langgraph";

const trimMessages = createMiddleware({
  name: "TrimMessages",
  beforeModel: (state) => {
    const messages = state.messages;
    if (messages.length <= 3) return;      // 짧으면 손대지 않음

    const firstMsg = messages[0];
    const recentMessages = messages.length % 2 === 0
      ? messages.slice(-3)
      : messages.slice(-4);

    return {
      messages: [
        new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),   // 전부 비우고
        firstMsg,                                          // 첫 메시지는 살리고
        ...recentMessages,                                 // 최근 것만
      ],
    };
  },
});

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  middleware: [trimMessages],
  checkpointer: new MemorySaver(),
});

import { createAgent, summarizationMiddleware } from "langchain";
import { MemorySaver } from "@langchain/langgraph";

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],
  middleware: [
    summarizationMiddleware({
      model: "anthropic:claude-haiku-4-5",   // 요약은 싼 모델로
      trigger: { tokens: 4000 },             // 4000 토큰 넘으면 발동
      keep: { messages: 20 },                // 최근 20개는 원문 유지
    }),
  ],
  checkpointer: new MemorySaver(),
});

// 월요일
await agent.invoke(
  { messages: [{ role: "user", content: "저는 매운 음식을 못 먹습니다. 기억해 주세요." }] },
  { configurable: { thread_id: "chat-monday" } },
);

// 화요일 — 새 대화
const tuesday = await agent.invoke(
  { messages: [{ role: "user", content: "저녁 메뉴 하나만 추천해 주세요. 제 식성 알죠?" }] },
  { configurable: { thread_id: "chat-tuesday" } },
);

import { MemorySaver, MemoryStore } from "@langchain/langgraph";

const checkpointer = new MemorySaver();   // 스레드 안
const store = new MemoryStore();          // 스레드 밖

/**
 * Step 10 — 단기 메모리와 스레드
 * 실행: npx tsx docs/reference/langchain/step-10-memory/practice.ts
 *
 * 이 파일은 본문 10-1 ~ 10-9 의 예제를 순서대로 담고 있습니다.
 * 블록 주석의 [10-x] 번호가 본문 소제목과 1:1 로 대응합니다.
 *
 * 주의: 모델을 실제로 호출하므로 ANTHROPIC_API_KEY 가 필요하고 요금이 발생합니다.
 *       전체 실행에 대략 20~30회의 모델 호출이 들어갑니다.
 */
import "dotenv/config";

import { createAgent, createMiddleware, tool } from "langchain";
import { MemorySaver, REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
import { RemoveMessage, type BaseMessage } from "@langchain/core/messages";
import * as z from "zod";

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

// 이 스텝 전체에서 쓰는 모델. OpenAI 로 바꾸려면 "openai:gpt-5.5" 로만 고치면 됩니다
// (checkpointer 동작은 제공자와 무관합니다 — 저장은 LangGraph 쪽 일이니까요).
const MODEL = "anthropic:claude-sonnet-4-6";

/* ===== [10-1] LLM은 상태가 없다 — 메모리는 네가 만드는 것 ===== */

async function step10_1(): Promise<void> {
  printSection("[10-1] checkpointer 없는 에이전트 — 두 번째 턴에서 이름을 잊는다");

  // checkpointer 를 주지 않았습니다. 이게 기본값입니다.
  const agent = createAgent({
    model: MODEL,
    tools: [],
  });

  const first = await agent.invoke({
    messages: [{ role: "user", content: "안녕하세요. 제 이름은 김민수입니다." }],
  });
  printMessages(first.messages.at(-1)!);

  // 두 번째 invoke. 앞의 대화와 아무 연결이 없습니다.
  const second = await agent.invoke({
    messages: [{ role: "user", content: "제 이름이 뭐라고 했죠?" }],
  });
  printMessages(second.messages.at(-1)!);

  // 반환된 messages 배열의 길이를 보면 "이 호출이 무엇을 봤는지"가 드러납니다.
  printKV({
    "1턴 messages 길이": first.messages.length,
    "2턴 messages 길이": second.messages.length, // 3이 아니라 2입니다
  });

  printSection("[10-1] 직접 히스토리를 이어 붙이면 기억한다 (수동 메모리)");

  // 메모리의 정체는 이겁니다. 마법이 아니라 "배열을 다시 보내는 것".
  const history: BaseMessage[] = [...first.messages];
  const manual = await agent.invoke({
    messages: [...history, { role: "user", content: "제 이름이 뭐라고 했죠?" }],
  });
  printMessages(manual.messages.at(-1)!);
}

/* ===== [10-2] checkpointer와 thread_id — 대화가 저장되는 원리 ===== */

async function step10_2(): Promise<void> {
  printSection("[10-2] thread_id 만 주고 checkpointer 는 안 준 경우 (조용한 실패)");

  const agentWithoutSaver = createAgent({
    model: MODEL,
    tools: [],
    // checkpointer 없음
  });

  const cfg = { configurable: { thread_id: "trap-thread" } };

  await agentWithoutSaver.invoke(
    { messages: [{ role: "user", content: "제 이름은 김민수입니다." }] },
    cfg,
  );

  const forgot = await agentWithoutSaver.invoke(
    { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
    cfg,
  );

  // thread_id 를 줬는데도 기억하지 못합니다. 에러도, 경고도 없습니다.
  printMessages(forgot.messages.at(-1)!);
  printKV({ "messages 길이": forgot.messages.length });

  printSection("[10-2] checkpointer 를 붙이면 저장된다");

  const checkpointer = new MemorySaver();
  const agent = createAgent({
    model: MODEL,
    tools: [],
    checkpointer,
  });

  await agent.invoke(
    { messages: [{ role: "user", content: "제 이름은 김민수입니다." }] },
    { configurable: { thread_id: "ok-thread" } },
  );

  const remembered = await agent.invoke(
    { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
    { configurable: { thread_id: "ok-thread" } },
  );

  printMessages(remembered.messages.at(-1)!);
  // 이번에는 4입니다: user, ai, user, ai — 앞 턴이 되살아났습니다.
  printKV({ "messages 길이": remembered.messages.length });
}

/* ===== [10-3] MemorySaver로 멀티턴 대화 만들기 ===== */

async function step10_3(): Promise<void> {
  printSection("[10-3] 4턴 대화 — 도구까지 섞어서");

  // 도구를 하나 붙여 둡니다. 도구 호출/결과(ToolMessage)도 체크포인트에
  // 그대로 저장된다는 것을 보여주기 위해서입니다.
  const getWeather = tool(
    async ({ city }) => `${city}의 날씨: 맑음, 24도`,
    {
      name: "get_weather",
      description: "도시의 현재 날씨를 조회합니다.",
      schema: z.object({ city: z.string().describe("도시 이름") }),
    },
  );

  const agent = createAgent({
    model: MODEL,
    tools: [getWeather],
    systemPrompt: "당신은 간결하게 답하는 여행 도우미입니다.",
    checkpointer: new MemorySaver(),
  });

  // thread_id 는 문자열이면 무엇이든 됩니다. 실무에서는 uuid 나 "user:123:chat:456" 같은
  // 구조화된 키를 씁니다. PostgresSaver 를 쓸 거라면 255자를 넘기지 마세요.
  const config = { configurable: { thread_id: "trip-2026-07" } };

  const turns = [
    "저는 부산에 살고 있어요.",
    "제가 사는 도시 날씨 알려주세요.",  // ← "부산"이라고 말하지 않았습니다
    "그럼 반팔 입어도 될까요?",
    "제가 어디 산다고 했죠?",
  ];

  for (const [i, text] of turns.entries()) {
    const result = await agent.invoke(
      { messages: [{ role: "user", content: text }] },
      config,
    );
    console.log(`\n--- 턴 ${i + 1} (누적 messages: ${result.messages.length}) ---`);
    printMessages(result.messages.at(-1)!);
  }

  // 마지막에 전체 대화를 통째로 확인합니다.
  printSection("[10-3] 저장된 전체 대화");
  const finalState = await agent.getState(config);
  printMessages(finalState.values.messages as BaseMessage[]);
}

/* ===== [10-4] 스레드 격리 — thread_id를 바꾸면 남남 ===== */

async function step10_4(): Promise<void> {
  printSection("[10-4] 같은 checkpointer, 다른 thread_id");

  // checkpointer 하나가 여러 스레드를 담습니다. 스레드끼리는 서로를 못 봅니다.
  const checkpointer = new MemorySaver();
  const agent = createAgent({ model: MODEL, tools: [], checkpointer });

  const alice = { configurable: { thread_id: "user-alice" } };
  const bob = { configurable: { thread_id: "user-bob" } };

  await agent.invoke(
    { messages: [{ role: "user", content: "제 이름은 앨리스입니다." }] },
    alice,
  );
  await agent.invoke(
    { messages: [{ role: "user", content: "제 이름은 밥입니다." }] },
    bob,
  );

  const askAlice = await agent.invoke(
    { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
    alice,
  );
  const askBob = await agent.invoke(
    { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
    bob,
  );

  console.log("\n[user-alice]");
  printMessages(askAlice.messages.at(-1)!);
  console.log("\n[user-bob]");
  printMessages(askBob.messages.at(-1)!);

  // 존재하지 않는 thread_id 는 에러가 아니라 "빈 스레드"입니다.
  printSection("[10-4] 처음 보는 thread_id 의 상태");
  const fresh = await agent.getState({ configurable: { thread_id: "never-used" } });
  printKV({
    values: JSON.stringify(fresh.values),
    next: JSON.stringify(fresh.next),
    createdAt: String(fresh.createdAt),
    parentConfig: JSON.stringify(fresh.parentConfig),
  });
}

/* ===== [10-5] 상태 조회/조작 — getState, getStateHistory, updateState ===== */

async function step10_5(): Promise<void> {
  printSection("[10-5] getState — 스냅샷의 모양");

  const agent = createAgent({
    model: MODEL,
    tools: [],
    checkpointer: new MemorySaver(),
  });
  const config = { configurable: { thread_id: "inspect-1" } };

  await agent.invoke(
    { messages: [{ role: "user", content: "1부터 5까지 세어 주세요." }] },
    config,
  );

  const snapshot = await agent.getState(config);
  printKV({
    "values.messages 개수": (snapshot.values.messages as BaseMessage[]).length,
    next: JSON.stringify(snapshot.next), // 실행이 끝났으면 []
    "config.thread_id": snapshot.config.configurable?.thread_id,
    "config.checkpoint_id": snapshot.config.configurable?.checkpoint_id,
    "metadata.source": snapshot.metadata?.source,
    "metadata.step": snapshot.metadata?.step,
    createdAt: snapshot.createdAt,
    "parentConfig 있음": String(snapshot.parentConfig !== undefined),
    "tasks 개수": snapshot.tasks.length,
  });

  printSection("[10-5] getStateHistory — 최신이 먼저");

  // getStateHistory 는 배열이 아니라 async iterable 입니다. for await 로 돕니다.
  const history = [];
  for await (const state of agent.getStateHistory(config)) {
    history.push(state);
  }

  console.log(`체크포인트 ${history.length}개 (index 0 이 가장 최신)\n`);
  for (const [i, s] of history.entries()) {
    console.log(
      `[${i}] step=${String(s.metadata?.step).padStart(3)} ` +
        `source=${String(s.metadata?.source).padEnd(6)} ` +
        `next=${JSON.stringify(s.next).padEnd(12)} ` +
        `messages=${(s.values.messages as BaseMessage[] | undefined)?.length ?? 0} ` +
        `checkpoint_id=${String(s.config.configurable?.checkpoint_id).slice(0, 8)}…`,
    );
  }

  printSection("[10-5] updateState — messages 는 덮어쓰기가 아니라 append 된다");

  const before = await agent.getState(config);
  const beforeCount = (before.values.messages as BaseMessage[]).length;

  // "이 한 개로 바꿔치기" 를 의도했지만...
  await agent.updateState(config, {
    messages: [{ role: "user", content: "(수동으로 끼워 넣은 메시지)" }],
  });

  const after = await agent.getState(config);
  const afterCount = (after.values.messages as BaseMessage[]).length;

  printKV({
    "updateState 전": beforeCount,
    "updateState 후": afterCount, // beforeCount + 1 입니다. 1이 아닙니다.
    결론: afterCount === beforeCount + 1 ? "append 되었다 (리듀서가 개입)" : "?",
  });

  printSection("[10-5] 진짜로 지우려면 RemoveMessage");

  // messages 리듀서는 RemoveMessage 라는 특수 메시지를 "삭제 명령"으로 해석합니다.
  const lastId = (after.values.messages as BaseMessage[]).at(-1)!.id!;
  await agent.updateState(config, {
    messages: [new RemoveMessage({ id: lastId })],
  });

  const removed = await agent.getState(config);
  printKV({
    "삭제 후 messages 개수": (removed.values.messages as BaseMessage[]).length,
  });
}

/* ===== [10-6] 타임트래블 — 과거 체크포인트에서 다시 실행하기 ===== */

async function step10_6(): Promise<void> {
  printSection("[10-6] 대화를 3턴 쌓는다");

  const agent = createAgent({
    model: MODEL,
    tools: [],
    systemPrompt: "당신은 한 문장으로만 답합니다.",
    checkpointer: new MemorySaver(),
  });
  const config = { configurable: { thread_id: "timetravel-1" } };

  await agent.invoke(
    { messages: [{ role: "user", content: "제가 좋아하는 색은 파란색입니다." }] },
    config,
  );
  await agent.invoke(
    { messages: [{ role: "user", content: "제가 좋아하는 동물은 고양이입니다." }] },
    config,
  );
  const third = await agent.invoke(
    { messages: [{ role: "user", content: "제 취향을 요약해 주세요." }] },
    config,
  );
  printMessages(third.messages.at(-1)!);

  printSection("[10-6] 히스토리에서 과거 체크포인트 고르기");

  const history = [];
  for await (const state of agent.getStateHistory(config)) {
    history.push(state);
  }

  // 두 번째 턴이 끝난 시점을 찾습니다.
  // 판별 기준: 실행이 멈춰 있고(next 가 비었고) messages 가 4개인 스냅샷.
  const afterTurn2 = history.find(
    (s) =>
      s.next.length === 0 &&
      (s.values.messages as BaseMessage[] | undefined)?.length === 4,
  );

  if (afterTurn2 === undefined) {
    console.log("조건에 맞는 체크포인트를 못 찾았습니다 (모델이 도구를 부르면 개수가 달라집니다).");
    return;
  }

  printKV({
    "고른 checkpoint_id": String(afterTurn2.config.configurable?.checkpoint_id),
    "그 시점 messages": (afterTurn2.values.messages as BaseMessage[]).length,
    "그 시점 step": String(afterTurn2.metadata?.step),
  });

  printSection("[10-6] 리플레이 — 과거 시점에 새 질문을 던진다");

  // 스냅샷의 config 에는 checkpoint_id 가 박혀 있습니다.
  // 그 config 로 invoke 하면 "그 시점의 상태"에서 이어서 실행됩니다.
  const replay = await agent.invoke(
    { messages: [{ role: "user", content: "제가 좋아하는 동물이 뭐죠?" }] },
    afterTurn2.config,
  );
  printMessages(replay.messages.at(-1)!);
  printKV({ "리플레이 결과 messages": replay.messages.length });

  printSection("[10-6] 포크 — 과거를 고쳐서 분기시킨다");

  // updateState 로 과거 체크포인트 위에 새 체크포인트를 만듭니다.
  // 원본은 그대로 남고, 반환된 config 가 "새 가지"를 가리킵니다.
  const forkConfig = await agent.updateState(afterTurn2.config, {
    messages: [{ role: "user", content: "정정합니다. 제가 좋아하는 동물은 강아지입니다." }],
  });

  const forked = await agent.invoke(
    { messages: [{ role: "user", content: "제가 좋아하는 동물이 뭐죠?" }] },
    forkConfig,
  );
  printMessages(forked.messages.at(-1)!);

  printSection("[10-6] 원본 스레드는 무사한가");

  // 포크를 만들어도 thread_id 의 "최신"은 여전히 원래 대화의 끝입니다.
  const mainline = await agent.getState(config);
  printKV({
    "원본 최신 messages": (mainline.values.messages as BaseMessage[]).length,
  });
}

/* ===== [10-7] 영속 체크포인터 — SqliteSaver / PostgresSaver ===== */

async function step10_7(): Promise<void> {
  printSection("[10-7] 영속 체크포인터 (설명용 — 이 프로젝트엔 패키지가 없습니다)");

  // 아래 코드는 별도 패키지를 설치해야 동작합니다.
  //
  //   npm install @langchain/langgraph-checkpoint-sqlite
  //   npm install @langchain/langgraph-checkpoint-postgres
  //
  // 설치 전에 import 하면 "Cannot find module ..." 로 파일 전체가 죽으므로
  // 주석으로 남깁니다. 설치했다면 주석을 풀고 MemorySaver 자리에 끼우면 끝입니다.
  //
  // --- SQLite ---
  // import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
  // const checkpointer = SqliteSaver.fromConnString("./checkpoints.sqlite");
  //
  // --- PostgreSQL ---
  // import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
  // const checkpointer = PostgresSaver.fromConnString(
  //   "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable",
  // );
  // await checkpointer.setup();   // ← 최초 1회. 테이블을 만듭니다. 빼먹으면 런타임 에러.
  //
  // const agent = createAgent({ model: MODEL, tools: [], checkpointer });

  console.log("코드는 주석으로만 두었습니다. 본문 10-7 을 보세요.");

  printSection("[10-7] MemorySaver 는 프로세스와 함께 사라진다 — 재현");

  // 프로세스 재시작을 흉내 냅니다: 새 MemorySaver = 새 (빈) 저장소.
  const saverA = new MemorySaver();
  const agentA = createAgent({ model: MODEL, tools: [], checkpointer: saverA });
  const cfg = { configurable: { thread_id: "restart-demo" } };

  await agentA.invoke(
    { messages: [{ role: "user", content: "제 이름은 김민수입니다." }] },
    cfg,
  );
  const stateA = await agentA.getState(cfg);
  printKV({ "재시작 전 messages": (stateA.values.messages as BaseMessage[]).length });

  // "재시작"
  const saverB = new MemorySaver();
  const agentB = createAgent({ model: MODEL, tools: [], checkpointer: saverB });
  const stateB = await agentB.getState(cfg); // 같은 thread_id 인데도...

  printKV({
    "재시작 후 messages": (stateB.values.messages as BaseMessage[] | undefined)?.length ?? 0,
    비고: "thread_id 는 같지만 저장소가 다른 객체입니다",
  });
}

/* ===== [10-8] 컨텍스트 윈도우 관리 ===== */

async function step10_8(): Promise<void> {
  printSection("[10-8] 대화가 길어지면 비용이 제곱으로 는다");

  const agent = createAgent({
    model: MODEL,
    tools: [],
    systemPrompt: "당신은 한 문장으로만 답합니다.",
    checkpointer: new MemorySaver(),
  });
  const config = { configurable: { thread_id: "cost-demo" } };

  let cumulativeInput = 0;
  for (let i = 1; i <= 5; i++) {
    const result = await agent.invoke(
      { messages: [{ role: "user", content: `${i}번째 질문입니다. 아무 말이나 한 문장 해 주세요.` }] },
      config,
    );
    const last = result.messages.at(-1)!;
    const usage = "usage_metadata" in last ? last.usage_metadata : undefined;
    const input = usage?.input_tokens ?? 0;
    cumulativeInput += input;
    console.log(
      `턴 ${i}: 입력 토큰 ${String(input).padStart(5)} | 누적 입력 ${String(cumulativeInput).padStart(6)}`,
    );
  }
  console.log("\n입력 토큰이 턴마다 늘어납니다 — 매번 전체 히스토리를 다시 보내기 때문입니다.");

  printSection("[10-8] 해법 1: beforeModel 에서 잘라내기");

  // 공식 문서의 트리밍 패턴입니다.
  // RemoveMessage({ id: REMOVE_ALL_MESSAGES }) 로 채널을 비우고, 남길 것만 다시 넣습니다.
  // 이게 "덮어쓰기" 를 하는 유일하게 안전한 방법입니다 (10-5 의 append 함정 회피).
  const trimMiddleware = createMiddleware({
    name: "TrimMessages",
    beforeModel: (state) => {
      const messages = state.messages;
      if (messages.length <= 3) return;

      // noUncheckedIndexedAccess 가 켜져 있으므로 messages[0] 은 undefined 일 수 있습니다.
      // 위에서 length > 3 을 확인했으니 실제로는 항상 존재하지만, 타입상 좁혀 줍니다.
      const firstMsg = messages[0];
      if (firstMsg === undefined) return;

      const recentMessages = messages.length % 2 === 0
        ? messages.slice(-3)
        : messages.slice(-4);

      return {
        messages: [
          new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),
          firstMsg,
          ...recentMessages,
        ],
      };
    },
  });

  const trimmed = createAgent({
    model: MODEL,
    tools: [],
    systemPrompt: "당신은 한 문장으로만 답합니다.",
    middleware: [trimMiddleware],
    checkpointer: new MemorySaver(),
  });
  const trimCfg = { configurable: { thread_id: "trim-demo" } };

  for (let i = 1; i <= 5; i++) {
    const result = await trimmed.invoke(
      { messages: [{ role: "user", content: `${i}번째 질문입니다. 아무 말이나 한 문장 해 주세요.` }] },
      trimCfg,
    );
    const last = result.messages.at(-1)!;
    const usage = "usage_metadata" in last ? last.usage_metadata : undefined;
    console.log(
      `턴 ${i}: 입력 토큰 ${String(usage?.input_tokens ?? 0).padStart(5)} | ` +
        `저장된 messages ${result.messages.length}`,
    );
  }
  console.log("\n입력 토큰이 더 이상 선형으로 늘지 않습니다. 대신 오래된 맥락은 사라졌습니다.");

  // 트리밍 후 스레드에 실제로 남은 것을 확인합니다.
  const trimState = await trimmed.getState(trimCfg);
  printKV({
    "체크포인트에 남은 messages": (trimState.values.messages as BaseMessage[]).length,
    비고: "미들웨어가 상태 자체를 잘랐습니다 — 체크포인트에도 반영됩니다",
  });

  printSection("[10-8] 해법 2: summarizationMiddleware (Step 11 예고)");

  // import { summarizationMiddleware } from "langchain";
  //
  // const agent = createAgent({
  //   model: MODEL,
  //   tools: [],
  //   middleware: [
  //     summarizationMiddleware({
  //       model: "anthropic:claude-haiku-4-5",  // 요약은 싼 모델로
  //       trigger: { tokens: 4000 },            // 4000 토큰 넘으면 발동
  //       keep: { messages: 20 },               // 최근 20개는 원문 유지
  //     }),
  //   ],
  //   checkpointer: new MemorySaver(),
  // });
  //
  // 그 외 옵션: summaryPrompt, trimTokensToSummarize (기본 4000)
  // 도구 결과만 골라 비우는 contextEditingMiddleware 도 있습니다. Step 11 에서 다룹니다.

  console.log("코드는 주석으로만 두었습니다. Step 11 에서 실제로 돌려봅니다.");
}

/* ===== [10-9] 단기 vs 장기 메모리 ===== */

async function step10_9(): Promise<void> {
  printSection("[10-9] 단기 메모리의 한계 — 스레드를 넘으면 없다");

  const agent = createAgent({
    model: MODEL,
    tools: [],
    checkpointer: new MemorySaver(),
  });

  // 월요일의 대화
  await agent.invoke(
    { messages: [{ role: "user", content: "저는 매운 음식을 못 먹습니다. 기억해 주세요." }] },
    { configurable: { thread_id: "chat-monday" } },
  );

  // 화요일의 새 대화 (새 thread_id)
  const tuesday = await agent.invoke(
    { messages: [{ role: "user", content: "저녁 메뉴 하나만 추천해 주세요. 제 식성 알죠?" }] },
    { configurable: { thread_id: "chat-tuesday" } },
  );

  printMessages(tuesday.messages.at(-1)!);
  console.log(
    "\n월요일에 말한 식성을 모릅니다. 이건 버그가 아니라 단기 메모리의 정의입니다.\n" +
      "스레드를 넘어가는 기억은 장기 메모리(Store)의 일입니다 — Step 15.",
  );

  // MemoryStore 도 @langchain/langgraph 에서 옵니다. 미리보기만.
  //
  // import { MemoryStore } from "@langchain/langgraph";
  // const store = new MemoryStore();
  // → createAgent({ ..., checkpointer, store })
  //   checkpointer = 스레드 안, store = 스레드 밖. 둘은 별개입니다.
}

/* ===== 실행 ===== */

async function main(): Promise<void> {
  await step10_1();
  await step10_2();
  await step10_3();
  await step10_4();
  await step10_5();
  await step10_6();
  await step10_7();
  await step10_8();
  await step10_9();
}

main().catch((error: unknown) => {
  console.error(error);
  process.exit(1);
});

/**
 * Step 10 — 단기 메모리와 스레드 · 연습문제
 * 실행: npx tsx docs/reference/langchain/step-10-memory/exercise.ts
 *
 * 각 [문제 N] 블록 아래가 비어 있습니다. 직접 채워 넣고 실행해 보세요.
 * 파일을 그대로 실행하면 아무것도 출력되지 않습니다. 정상입니다.
 *
 * 정답은 solution.ts 에 있습니다. 먼저 스스로 풀어 보세요.
 */
import "dotenv/config";

import { createAgent, createMiddleware, tool } from "langchain";
import { MemorySaver, REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
import { RemoveMessage, type BaseMessage } from "@langchain/core/messages";
import * as z from "zod";

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

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

/* ===== [문제 1] 조용한 실패 재현 ===== */
/*
 * checkpointer 를 주지 않은 에이전트에 thread_id 를 주고 두 번 invoke 하세요.
 *
 * - 1턴: "제 이름은 홍길동입니다."
 * - 2턴: "제 이름이 뭐죠?"
 *
 * 그다음 checkpointer: new MemorySaver() 만 추가한 에이전트로 똑같이 하세요.
 * 두 경우의 (a) 답변과 (b) result.messages.length 를 나란히 출력해서
 * "에러 없이 조용히 다르다" 를 눈으로 확인하세요.
 *
 * 확인할 것: checkpointer 없는 쪽의 2턴 messages 길이는 몇인가요?
 */

async function exercise1(): Promise<void> {
  printSection("[문제 1] checkpointer 유무 비교");

  // 여기에 작성하세요
}

/* ===== [문제 2] 스레드 격리 확인 ===== */
/*
 * MemorySaver 하나를 공유하는 에이전트 1개로, thread_id 를 3개 만들어
 * 각각 다른 이름("가", "나", "다")을 알려준 뒤 각 스레드에서 이름을 되물으세요.
 *
 * 그다음 getState 로 각 스레드의 messages 개수를 출력해서
 * 스레드마다 독립된 히스토리를 갖는다는 것을 보이세요.
 *
 * 마지막으로 한 번도 쓴 적 없는 thread_id 로 getState 를 호출하면
 * 무엇이 나오는지 출력하세요. (에러인가요? 아닌가요?)
 */

async function exercise2(): Promise<void> {
  printSection("[문제 2] 스레드 격리");

  // 여기에 작성하세요
}

/* ===== [문제 3] getStateHistory 로 체크포인트 세기 ===== */
/*
 * 도구 없이 에이전트를 만들고 2턴 대화한 뒤, getStateHistory 를 for await 로 돌려
 * 각 스냅샷의 step / source / next / messages 개수 / checkpoint_id 앞 8자리를
 * 한 줄씩 출력하세요.
 *
 * 질문:
 *  - 히스토리의 index 0 은 가장 오래된 것인가요, 가장 최신인가요?
 *  - metadata.source 에 어떤 값들이 보이나요?
 *  - 2턴 대화인데 체크포인트가 몇 개 생겼나요? 왜 그럴까요?
 */

async function exercise3(): Promise<void> {
  printSection("[문제 3] 체크포인트 히스토리");

  // 여기에 작성하세요
}

/* ===== [문제 4] updateState 의 append 함정 ===== */
/*
 * 1턴 대화한 스레드에 updateState 로
 *   { messages: [{ role: "user", content: "덮어쓰기 시도" }] }
 * 를 넣으세요.
 *
 * (a) updateState 전후의 messages 개수를 출력하세요. 몇 개가 되었나요? 왜죠?
 * (b) 이번엔 "정말로 messages 를 이 하나로만 만들기" 를 하세요.
 *     힌트: RemoveMessage 와 REMOVE_ALL_MESSAGES 를 씁니다.
 * (c) (b) 이후 개수가 1이 되는지 확인하세요.
 */

async function exercise4(): Promise<void> {
  printSection("[문제 4] updateState 와 리듀서");

  // 여기에 작성하세요
}

/* ===== [문제 5] 타임트래블 — 포크 ===== */
/*
 * 3턴 대화를 만드세요.
 *   1턴: "제 목표는 마라톤 완주입니다."
 *   2턴: "목표 달성을 위한 팁 하나만요."
 *   3턴: "제 목표가 뭐라고 했죠?"
 *
 * 그다음:
 *  (a) getStateHistory 에서 "1턴이 끝난 시점"(next 가 []이고 messages 가 2개인 스냅샷)을 찾으세요.
 *  (b) 그 시점 config 로 updateState 를 호출해
 *      "정정합니다. 제 목표는 금연입니다." 를 끼워 넣고 반환된 forkConfig 를 받으세요.
 *  (c) forkConfig 로 "제 목표가 뭐죠?" 를 물어 답이 바뀌는지 확인하세요.
 *  (d) 원본 thread_id 로 getState 를 해서 원본이 안 망가졌는지 확인하세요.
 */

async function exercise5(): Promise<void> {
  printSection("[문제 5] 포크");

  // 여기에 작성하세요
}

/* ===== [문제 6] thread_id 재사용 오염 ===== */
/*
 * 같은 checkpointer 를 쓰는 에이전트에서 thread_id "shared" 로
 *   1) "제 이름은 앨리스입니다." 를 보내고
 *   2) (다른 사용자인 척) "제 이름이 뭐죠?" 를 보내세요.
 *
 * 2번 응답에 "앨리스" 가 나오면 스레드 오염입니다.
 * 이 문제를 고치는 방법을 코드로 보이세요.
 * (힌트: thread_id 를 매번 새로 만듭니다. crypto.randomUUID() 를 쓰세요.)
 */

async function exercise6(): Promise<void> {
  printSection("[문제 6] thread_id 재사용 오염");

  // 여기에 작성하세요
}

/* ===== [문제 7] 비용 측정 ===== */
/*
 * checkpointer 를 붙인 에이전트로 6턴 대화하며, 매 턴 마지막 AIMessage 의
 * usage_metadata.input_tokens 를 출력하고 누적 합계도 함께 출력하세요.
 *
 * 그다음 practice.ts [10-8] 의 TrimMessages 미들웨어를 붙인 에이전트로
 * 똑같이 6턴 돌려서 두 누적 합계를 비교하세요.
 *
 * 질문: 트리밍으로 얻은 것과 잃은 것은 각각 무엇인가요? 주석으로 답하세요.
 */

async function exercise7(): Promise<void> {
  printSection("[문제 7] 토큰 비용 비교");

  // 여기에 작성하세요
}

/* ===== [문제 8] 도구 결과도 저장되는가 ===== */
/*
 * 간단한 도구(get_weather)를 붙인 에이전트를 checkpointer 와 함께 만들고,
 * 도구를 부르게 만드는 질문을 1턴 던지세요.
 *
 * 그다음 getState 로 values.messages 를 꺼내 각 메시지의 getType() 을 출력하세요.
 * ToolMessage 가 체크포인트에 남아 있나요?
 *
 * 이어서 다음 턴에 "방금 조회한 날씨가 뭐였죠?" 를 물어
 * 도구를 다시 부르지 않고도 답하는지 확인하세요.
 */

async function exercise8(): Promise<void> {
  printSection("[문제 8] 도구 결과의 저장");

  // 여기에 작성하세요
}

/* ===== 실행 ===== */

async function main(): Promise<void> {
  await exercise1();
  await exercise2();
  await exercise3();
  await exercise4();
  await exercise5();
  await exercise6();
  await exercise7();
  await exercise8();
}

main().catch((error: unknown) => {
  console.error(error);
  process.exit(1);
});

/**
 * Step 10 — 단기 메모리와 스레드 · 정답과 해설
 * 실행: npx tsx docs/reference/langchain/step-10-memory/solution.ts
 *
 * exercise.ts 를 스스로 풀어본 뒤에 열어 보세요.
 * 각 정답 위 주석에 "무엇을 확인해야 하는가" 와 함정 포인트가 적혀 있습니다.
 */
import "dotenv/config";

import { createAgent, createMiddleware, tool } from "langchain";
import { MemorySaver, REMOVE_ALL_MESSAGES } from "@langchain/langgraph";
import { RemoveMessage, type BaseMessage } from "@langchain/core/messages";
import * as z from "zod";

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

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

/* ===== [정답 1] 조용한 실패 재현 =====
 *
 * 핵심: checkpointer 가 없으면 thread_id 는 **읽히기만 하고 아무 일도 안 합니다.**
 * LangGraph 입장에서 thread_id 는 "저장소에서 이 키로 찾아라" 라는 지시인데,
 * 저장소 자체가 없으니 지시가 갈 곳이 없습니다. 에러도 경고도 없습니다.
 *
 * 기대 결과:
 *  - checkpointer 없음 → 2턴 messages 길이 = 2 (user, ai). 이름을 모른다고 답함.
 *  - checkpointer 있음 → 2턴 messages 길이 = 4 (user, ai, user, ai). "홍길동" 이라고 답함.
 *
 * 이 길이 숫자가 진단 도구입니다. 응답 텍스트는 모델이 눈치껏 둘러댈 수 있어서
 * (예: "성함을 말씀해 주시면...") 믿을 수 없습니다. messages 길이는 거짓말을 안 합니다.
 */

async function solution1(): Promise<void> {
  printSection("[정답 1] checkpointer 유무 비교");

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

  // (A) checkpointer 없음
  const without = createAgent({ model: MODEL, tools: [] });
  await without.invoke(
    { messages: [{ role: "user", content: "제 이름은 홍길동입니다." }] },
    config,
  );
  const withoutSecond = await without.invoke(
    { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
    config,
  );

  console.log("\n[checkpointer 없음]");
  printMessages(withoutSecond.messages.at(-1)!);
  printKV({ "messages 길이": withoutSecond.messages.length }); // 2

  // (B) checkpointer 있음 — 딱 한 줄 차이
  const withSaver = createAgent({
    model: MODEL,
    tools: [],
    checkpointer: new MemorySaver(),
  });
  await withSaver.invoke(
    { messages: [{ role: "user", content: "제 이름은 홍길동입니다." }] },
    config,
  );
  const withSecond = await withSaver.invoke(
    { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
    config,
  );

  console.log("\n[checkpointer 있음]");
  printMessages(withSecond.messages.at(-1)!);
  printKV({ "messages 길이": withSecond.messages.length }); // 4
}

/* ===== [정답 2] 스레드 격리 =====
 *
 * 핵심: checkpointer 는 "스레드들이 사는 아파트" 고 thread_id 는 "호수" 입니다.
 * 같은 건물에 살아도 옆집 대화는 안 들립니다.
 *
 * 두 번째 포인트: 없는 thread_id 로 getState 를 하면 **에러가 아닙니다.**
 * values 는 {} (또는 빈 상태), next 는 [], parentConfig 는 undefined 인 빈 스냅샷이 옵니다.
 * "존재하지 않는 스레드" 와 "아직 아무 말 안 한 스레드" 를 LangGraph 는 구분하지 않습니다.
 * → 그래서 "이 스레드가 처음인가?" 를 판별하려면 getState 성공 여부가 아니라
 *   values.messages 의 길이(또는 undefined 여부)를 봐야 합니다.
 */

async function solution2(): Promise<void> {
  printSection("[정답 2] 스레드 격리");

  const checkpointer = new MemorySaver();
  const agent = createAgent({ model: MODEL, tools: [], checkpointer });

  const names = ["가", "나", "다"];

  for (const name of names) {
    await agent.invoke(
      { messages: [{ role: "user", content: `제 이름은 ${name}입니다.` }] },
      { configurable: { thread_id: `ex2-${name}` } },
    );
  }

  for (const name of names) {
    const config = { configurable: { thread_id: `ex2-${name}` } };
    const result = await agent.invoke(
      { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
      config,
    );
    console.log(`\n[ex2-${name}]`);
    printMessages(result.messages.at(-1)!);

    const state = await agent.getState(config);
    printKV({ "저장된 messages": (state.values.messages as BaseMessage[]).length }); // 각 4
  }

  // 없는 스레드 — 에러가 아니라 빈 스냅샷
  printSection("[정답 2] 없는 thread_id");
  const empty = await agent.getState({ configurable: { thread_id: "ex2-없음" } });
  printKV({
    values: JSON.stringify(empty.values),
    next: JSON.stringify(empty.next),
    "parentConfig 있음": String(empty.parentConfig !== undefined), // false
    비고: "에러가 아닙니다. 빈 스냅샷입니다.",
  });
}

/* ===== [정답 3] 체크포인트 히스토리 =====
 *
 * 답:
 *  - index 0 은 **가장 최신**입니다. 문서 표현 그대로 "most recent checkpoint being
 *    the first in the list". 시간 역순이라 for await 로 돌면 과거로 거슬러 갑니다.
 *  - metadata.source 로는 "input" (invoke 로 입력이 들어온 순간),
 *    "loop" (그래프가 한 스텝 돌 때마다), "update" (updateState 로 사람이 끼어든 것)
 *    이 보입니다.
 *  - 2턴인데 체크포인트가 6개 안팎입니다. **턴당 1개가 아니라 super-step 당 1개**이기
 *    때문입니다. invoke 한 번에 input → 모델 노드 실행 → 종료 로 여러 개가 찍힙니다.
 *    도구를 부르면 더 늘어납니다.
 *
 * 함정: "턴 수 = 체크포인트 수" 라고 가정하고 history[1] 을 "직전 턴" 이라고 집으면 틀립니다.
 *       반드시 metadata.step 이나 next / messages 개수로 판별하세요.
 */

async function solution3(): Promise<void> {
  printSection("[정답 3] 체크포인트 히스토리");

  const agent = createAgent({
    model: MODEL,
    tools: [],
    systemPrompt: "한 문장으로만 답하세요.",
    checkpointer: new MemorySaver(),
  });
  const config = { configurable: { thread_id: "ex3" } };

  await agent.invoke({ messages: [{ role: "user", content: "안녕하세요." }] }, config);
  await agent.invoke({ messages: [{ role: "user", content: "오늘 기분이 좋네요." }] }, config);

  const history = [];
  for await (const state of agent.getStateHistory(config)) {
    history.push(state);
  }

  console.log(`체크포인트 ${history.length}개\n`);
  for (const [i, s] of history.entries()) {
    console.log(
      `[${i}] step=${String(s.metadata?.step).padStart(3)} ` +
        `source=${String(s.metadata?.source).padEnd(6)} ` +
        `next=${JSON.stringify(s.next).padEnd(12)} ` +
        `messages=${(s.values.messages as BaseMessage[] | undefined)?.length ?? 0} ` +
        `id=${String(s.config.configurable?.checkpoint_id).slice(0, 8)}…`,
    );
  }

  console.log(
    "\n→ index 0 이 최신이고 마지막 index 가 가장 오래된 것입니다 (시간 역순).\n" +
      "→ step 이 -1 인 것이 최초 입력, 그 뒤로 0, 1, 2... 로 증가합니다.",
  );
}

/* ===== [정답 4] updateState 와 리듀서 =====
 *
 * 이 스텝에서 가장 많이 틀리는 곳입니다.
 *
 * (a) updateState 는 상태를 **교체하지 않습니다.** 채널에 리듀서가 정의되어 있으면
 *     그 리듀서를 거칩니다. messages 채널의 리듀서는 "append + id 기준 병합" 입니다.
 *     그래서 2 → 3 이 됩니다. 1이 아닙니다.
 *
 *     비유하자면 updateState 는 "값을 대입" 이 아니라 "노드 하나가 그 값을 반환한 것처럼
 *     처리" 입니다. 노드가 { messages: [...] } 를 반환하면 append 되니까 여기서도 append 됩니다.
 *
 * (b) 정말 덮어쓰려면 리듀서에게 "다 지워라" 를 명령해야 합니다.
 *     RemoveMessage({ id: REMOVE_ALL_MESSAGES }) 를 **먼저** 넣고 그 뒤에 남길 것을 둡니다.
 *     순서가 중요합니다 — 뒤에 두면 방금 넣은 것까지 지워집니다.
 *
 * (c) 결과 1.
 *
 * 참고: 개별 메시지 하나만 지우려면 RemoveMessage({ id: 그메시지의id }) 를 씁니다.
 *       id 가 undefined 인 메시지(직접 만든 plain object)는 이 방법으로 못 지웁니다.
 */

async function solution4(): Promise<void> {
  printSection("[정답 4] updateState 와 리듀서");

  const agent = createAgent({
    model: MODEL,
    tools: [],
    checkpointer: new MemorySaver(),
  });
  const config = { configurable: { thread_id: "ex4" } };

  await agent.invoke({ messages: [{ role: "user", content: "안녕하세요." }] }, config);

  const before = await agent.getState(config);
  const beforeCount = (before.values.messages as BaseMessage[]).length;

  // (a) 덮어쓰기를 의도했지만 append 된다
  await agent.updateState(config, {
    messages: [{ role: "user", content: "덮어쓰기 시도" }],
  });
  const after = await agent.getState(config);
  const afterCount = (after.values.messages as BaseMessage[]).length;

  printKV({
    "(a) 전": beforeCount,   // 2
    "(a) 후": afterCount,    // 3 ← 1이 아님
    해석: "messages 리듀서가 append 했습니다",
  });

  // (b) 진짜 덮어쓰기 — REMOVE_ALL_MESSAGES 를 먼저
  await agent.updateState(config, {
    messages: [
      new RemoveMessage({ id: REMOVE_ALL_MESSAGES }),
      { role: "user", content: "이것만 남는다" },
    ],
  });

  // (c) 확인
  const replaced = await agent.getState(config);
  const replacedMessages = replaced.values.messages as BaseMessage[];
  printKV({ "(c) 최종 개수": replacedMessages.length }); // 1
  printMessages(replacedMessages);
}

/* ===== [정답 5] 포크 =====
 *
 * 핵심 3가지:
 *  1. 스냅샷의 config 에는 checkpoint_id 가 들어 있습니다. 그 config 를 invoke 나
 *     updateState 에 넘기면 "그 시점" 을 가리킵니다. 그냥 { thread_id } 만 넘기면
 *     항상 최신입니다 — 이걸 헷갈리면 타임트래블이 아니라 그냥 이어쓰기가 됩니다.
 *  2. updateState 는 원본을 수정하지 않습니다. 과거 체크포인트를 부모로 삼는
 *     **새 체크포인트**를 만들고 그것을 가리키는 config 를 반환합니다.
 *  3. 그래서 원본 thread_id 의 최신 상태는 그대로 남습니다.
 *
 * 함정: (a) 에서 스냅샷을 index 로 집으면(history[2] 같은 식) 모델이 도구를 부르거나
 *       미들웨어가 끼면 index 가 밀려서 엉뚱한 곳을 잡습니다.
 *       반드시 next / messages 개수 같은 **내용 기준**으로 찾으세요.
 *
 * 기대 결과: (c) 는 "금연", (d) 의 원본은 여전히 "마라톤" 대화(messages 6개).
 */

async function solution5(): Promise<void> {
  printSection("[정답 5] 포크");

  const agent = createAgent({
    model: MODEL,
    tools: [],
    systemPrompt: "한 문장으로만 답하세요.",
    checkpointer: new MemorySaver(),
  });
  const config = { configurable: { thread_id: "ex5" } };

  await agent.invoke(
    { messages: [{ role: "user", content: "제 목표는 마라톤 완주입니다." }] },
    config,
  );
  await agent.invoke(
    { messages: [{ role: "user", content: "목표 달성을 위한 팁 하나만요." }] },
    config,
  );
  const third = await agent.invoke(
    { messages: [{ role: "user", content: "제 목표가 뭐라고 했죠?" }] },
    config,
  );
  console.log("\n[원본 3턴]");
  printMessages(third.messages.at(-1)!);

  // (a) 1턴이 끝난 시점 찾기 — 내용 기준
  const history = [];
  for await (const state of agent.getStateHistory(config)) {
    history.push(state);
  }
  const afterTurn1 = history.find(
    (s) => s.next.length === 0 && (s.values.messages as BaseMessage[] | undefined)?.length === 2,
  );

  if (afterTurn1 === undefined) {
    console.log("조건에 맞는 체크포인트가 없습니다.");
    return;
  }

  // (b) 포크 — 반환값이 새 가지를 가리키는 config
  const forkConfig = await agent.updateState(afterTurn1.config, {
    messages: [{ role: "user", content: "정정합니다. 제 목표는 금연입니다." }],
  });

  // (c) 새 가지에서 물어보기
  const forked = await agent.invoke(
    { messages: [{ role: "user", content: "제 목표가 뭐죠?" }] },
    forkConfig,
  );
  console.log("\n[포크된 가지]");
  printMessages(forked.messages.at(-1)!); // "금연"

  // (d) 원본 확인
  const mainline = await agent.getState(config);
  printKV({
    "원본 최신 messages": (mainline.values.messages as BaseMessage[]).length,
    비고: "포크는 원본을 건드리지 않았습니다",
  });
}

/* ===== [정답 6] thread_id 재사용 오염 =====
 *
 * 이건 테스트 코드와 데모 서버에서 실제로 자주 터집니다.
 * "thread_id: 'test'" 를 하드코딩해 두고 테스트를 두 번 돌리면, 두 번째 실행은
 * 첫 번째 실행의 대화를 물려받은 채 시작합니다. 그러면
 *  - 테스트가 처음엔 통과하고 재실행하면 실패하거나 (혹은 그 반대로)
 *  - 로컬에선 되는데 CI(깨끗한 프로세스)에선 다르게 동작합니다.
 *
 * MemorySaver 를 쓰면 프로세스 재시작마다 초기화돼서 이 문제가 가려집니다.
 * SqliteSaver 로 바꾸는 순간 드러납니다. "영속성으로 바꿨더니 테스트가 깨졌다" 의 정체입니다.
 *
 * 해법:
 *  - 사용자 대화: thread_id 를 crypto.randomUUID() 로 새로 발급하고 세션에 저장.
 *  - 테스트: 케이스마다 새 thread_id. 또는 checkpointer 자체를 케이스마다 새로 만들기.
 */

async function solution6(): Promise<void> {
  printSection("[정답 6] 오염 재현");

  const checkpointer = new MemorySaver();
  const agent = createAgent({ model: MODEL, tools: [], checkpointer });

  // 잘못된 방식: 고정 thread_id
  const shared = { configurable: { thread_id: "shared" } };

  await agent.invoke(
    { messages: [{ role: "user", content: "제 이름은 앨리스입니다." }] },
    shared,
  );

  // 다른 사용자인데 같은 thread_id 를 씁니다
  const leaked = await agent.invoke(
    { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
    shared,
  );
  console.log("\n[오염됨 — 앨리스가 나오면 남의 대화가 샌 것입니다]");
  printMessages(leaked.messages.at(-1)!);

  printSection("[정답 6] 고친 방식 — 사용자/세션마다 새 thread_id");

  // 세션 시작 시점에 발급해 두고 그 세션 동안만 재사용합니다.
  const aliceThread = { configurable: { thread_id: crypto.randomUUID() } };
  const bobThread = { configurable: { thread_id: crypto.randomUUID() } };

  await agent.invoke(
    { messages: [{ role: "user", content: "제 이름은 앨리스입니다." }] },
    aliceThread,
  );

  const bobAsks = await agent.invoke(
    { messages: [{ role: "user", content: "제 이름이 뭐죠?" }] },
    bobThread,
  );
  console.log("\n[격리됨 — 밥은 앨리스를 모릅니다]");
  printMessages(bobAsks.messages.at(-1)!);
}

/* ===== [정답 7] 토큰 비용 비교 =====
 *
 * 관찰:
 *  - 트리밍 없음: 입력 토큰이 턴마다 계단식으로 증가합니다. N턴 대화의 총 입력 토큰은
 *    대략 N²/2 에 비례합니다. 매 턴 전체 히스토리를 다시 보내기 때문입니다.
 *    턴당 비용이 아니라 **누적 비용**을 봐야 이게 보입니다.
 *  - 트리밍 있음: 입력 토큰이 어느 선에서 평평해집니다. 총합은 N 에 비례(선형).
 *
 * 얻은 것: 비용 상한, 컨텍스트 윈도우 초과 방지, 지연시간 안정.
 * 잃은 것: 잘려나간 구간의 맥락. 사용자가 3턴 전에 말한 제약을 모델이 모릅니다.
 *          게다가 **조용히** 모릅니다 — 에이전트는 "모른다" 고 하지 않고 그냥 다르게 답합니다.
 *
 * 그래서 실무에서는 통짜 트리밍보다 요약(summarizationMiddleware)을 씁니다.
 * 오래된 구간을 버리는 대신 한 문단으로 압축해 남기면 맥락 손실이 훨씬 적습니다.
 * 단 요약도 공짜가 아닙니다 — 요약 자체가 모델 호출입니다. Step 11 에서 저울질합니다.
 */

async function solution7(): Promise<void> {
  // 마지막 AIMessage 에서 입력 토큰을 꺼냅니다.
  // usage_metadata 는 optional 이므로 in 연산자로 좁힌 뒤 읽습니다.
  const inputTokens = (m: BaseMessage): number => {
    if (!("usage_metadata" in m)) return 0;
    return m.usage_metadata?.input_tokens ?? 0;
  };

  printSection("[정답 7] 트리밍 없음");
  const plain = createAgent({
    model: MODEL,
    tools: [],
    systemPrompt: "한 문장으로만 답하세요.",
    checkpointer: new MemorySaver(),
  });

  let plainTotal = 0;
  for (let i = 1; i <= 6; i++) {
    const result = await plain.invoke(
      { messages: [{ role: "user", content: `${i}번째 질문입니다. 한 문장으로 답해 주세요.` }] },
      { configurable: { thread_id: "ex7-plain" } },
    );
    const input = inputTokens(result.messages.at(-1)!);
    plainTotal += input;
    console.log(
      `[전체] 턴 ${i}: 입력 ${String(input).padStart(5)} | 누적 ${String(plainTotal).padStart(6)} | ` +
        `messages ${result.messages.length}`,
    );
  }

  printSection("[정답 7] 트리밍 있음");
  const trimMiddleware = createMiddleware({
    name: "TrimMessages",
    beforeModel: (state) => {
      const messages = state.messages;
      if (messages.length <= 3) return;
      const firstMsg = messages[0];
      if (firstMsg === undefined) return;
      const recentMessages = messages.length % 2 === 0 ? messages.slice(-3) : messages.slice(-4);
      return {
        messages: [new RemoveMessage({ id: REMOVE_ALL_MESSAGES }), firstMsg, ...recentMessages],
      };
    },
  });

  const trimmed = createAgent({
    model: MODEL,
    tools: [],
    systemPrompt: "한 문장으로만 답하세요.",
    middleware: [trimMiddleware],
    checkpointer: new MemorySaver(),
  });

  let trimTotal = 0;
  for (let i = 1; i <= 6; i++) {
    const result = await trimmed.invoke(
      { messages: [{ role: "user", content: `${i}번째 질문입니다. 한 문장으로 답해 주세요.` }] },
      { configurable: { thread_id: "ex7-trim" } },
    );
    const input = inputTokens(result.messages.at(-1)!);
    trimTotal += input;
    console.log(
      `[트림] 턴 ${i}: 입력 ${String(input).padStart(5)} | 누적 ${String(trimTotal).padStart(6)} | ` +
        `messages ${result.messages.length}`,
    );
  }

  printSection("[정답 7] 비교");
  printKV({
    "트리밍 없음 누적 입력": plainTotal,
    "트리밍 있음 누적 입력": trimTotal,
    절감률: `${Math.round((1 - trimTotal / plainTotal) * 100)}%`,
    비고: "턴 수가 늘어날수록 격차가 벌어집니다 (제곱 vs 선형)",
  });
}

/* ===== [정답 8] 도구 결과의 저장 =====
 *
 * 답: 네, ToolMessage 도 체크포인트에 그대로 남습니다.
 * 체크포인터가 저장하는 건 "대화 텍스트" 가 아니라 **상태 채널 전체**이고,
 * messages 채널에는 AIMessage(tool_calls 포함)와 ToolMessage 가 다 들어 있습니다.
 *
 * 그래서 다음 턴에 "방금 조회한 날씨" 를 물으면 도구를 다시 안 부르고 답합니다 —
 * 히스토리에 답이 이미 있으니까요.
 *
 * 이게 양날의 검입니다:
 *  - 좋은 점: 중복 호출 없음, 비용 절약.
 *  - 나쁜 점: **날씨는 변하는데 모델은 옛 ToolMessage 를 사실로 믿습니다.**
 *    "아까 조회한 값" 이라고 명시하지 않으면 사용자는 실시간 값으로 오해합니다.
 *    시간에 민감한 도구는 도구 결과에 조회 시각을 같이 넣거나,
 *    contextEditingMiddleware 로 오래된 도구 결과를 비우는 걸 고려하세요 (Step 11).
 *
 * 또 하나: 도구 결과는 대개 **길고** 대화의 대부분을 차지합니다.
 * 컨텍스트가 터지면 범인은 보통 사용자 발화가 아니라 ToolMessage 입니다.
 */

async function solution8(): Promise<void> {
  printSection("[정답 8] 도구 결과의 저장");

  const getWeather = tool(
    async ({ city }) => {
      console.log(`  (도구 실제 실행됨: ${city})`);
      return `${city}의 날씨: 흐림, 19도`;
    },
    {
      name: "get_weather",
      description: "도시의 현재 날씨를 조회합니다.",
      schema: z.object({ city: z.string().describe("도시 이름") }),
    },
  );

  const agent = createAgent({
    model: MODEL,
    tools: [getWeather],
    checkpointer: new MemorySaver(),
  });
  const config = { configurable: { thread_id: "ex8" } };

  await agent.invoke(
    { messages: [{ role: "user", content: "제주 날씨 알려주세요." }] },
    config,
  );

  const state = await agent.getState(config);
  const messages = state.values.messages as BaseMessage[];

  console.log("\n체크포인트에 저장된 메시지 타입:");
  for (const [i, m] of messages.entries()) {
    console.log(`  [${i}] ${m.getType()}`);
  }
  console.log("→ tool 이 목록에 있으면 도구 결과도 저장된 것입니다.");

  console.log("\n다음 턴 — 도구가 다시 실행되는지 보세요:");
  const second = await agent.invoke(
    { messages: [{ role: "user", content: "방금 조회한 날씨가 뭐였죠?" }] },
    config,
  );
  printMessages(second.messages.at(-1)!);
  console.log("→ '도구 실제 실행됨' 이 안 찍혔다면 히스토리에서 읽어 답한 것입니다.");
}

/* ===== 실행 ===== */

async function main(): Promise<void> {
  await solution1();
  await solution2();
  await solution3();
  await solution4();
  await solution5();
  await solution6();
  await solution7();
  await solution8();
}

main().catch((error: unknown) => {
  console.error(error);
  process.exit(1);
});