#Step 01 — 환경 구축과 첫 모델 호출

// Anthropic SDK 직접
const res = await anthropic.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [{ role: "user", content: "안녕" }],
});
const text = res.content[0].type === "text" ? res.content[0].text : "";
const inputTokens = res.usage.input_tokens;

// OpenAI SDK 직접
const res = await openai.chat.completions.create({
  model: "gpt-5.5",
  messages: [{ role: "user", content: "안녕" }],
});
const text = res.choices[0].message.content;
const inputTokens = res.usage.prompt_tokens;

// LangChain — 제공자를 바꿔도 아래 코드는 안 바뀝니다
const model = await initChatModel("anthropic:claude-sonnet-4-6");
//                                 ^^^^^^^^^ "openai:gpt-5.5" 로 바꾸면 끝
const res = await model.invoke("안녕");
const text = res.text;
const inputTokens = res.usage_metadata?.input_tokens;

import { printSection } from "../project/src/lib/print.js";
//                                                   ^^^ .ts 가 아니라 .js

import "dotenv/config";

const apiKey = process.env["ANTHROPIC_API_KEY"];
console.log(`${apiKey.slice(0, 14)}...${apiKey.slice(-4)}`);

import "dotenv/config";
import { initChatModel } from "langchain";

const model = await initChatModel("anthropic:claude-sonnet-4-6");
const response = await model.invoke("LangChain을 한 문장으로 설명해줘.");

console.log(response.text);

import "dotenv/config";
import { ChatAnthropic } from "@langchain/anthropic";

const model = new ChatAnthropic({
  model: "claude-sonnet-4-6",
  temperature: 0,
  maxTokens: 1024,
});
const response = await model.invoke("LangChain을 한 문장으로 설명해줘.");

console.log(response.text);

const response = await model.invoke("안녕");

console.log(typeof response);              // "object"  ← 문자열 아님!
console.log(response.constructor.name);    // "AIMessage"

console.log(response.text);

console.log(Array.isArray(response.content) ? "배열" : "문자열");

console.log(JSON.stringify(response.contentBlocks, null, 2));

const usage = response.usage_metadata;
if (usage !== undefined) {
  console.log(usage.input_tokens, usage.output_tokens, usage.total_tokens);
}

console.log(JSON.stringify(response.response_metadata, null, 2));

console.log(response.id);

import { createAgent } from "langchain";

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [],   // 도구는 Step 06 에서 만듭니다
  systemPrompt: "너는 간결하게 답하는 한국어 조수다. 두 문장을 넘기지 마라.",
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "에이전트와 그냥 모델 호출의 차이가 뭐야?" }],
});

console.log(result.messages.length);

const { createAgent } = require("langchain");
// ReferenceError: require is not defined in ES module scope

import { createAgent } from "langchain";   // 이렇게

// 이게 파일 최상단에서 바로 됩니다
const model = await initChatModel("anthropic:claude-sonnet-4-6");

/**
 * Step 01 — 환경 구축과 첫 모델 호출
 * 실행: npx tsx docs/reference/langchain/step-01-setup/practice.ts
 */
import "dotenv/config";

import { createAgent, initChatModel } from "langchain";
import { ChatAnthropic } from "@langchain/anthropic";
import { AIMessage } from "@langchain/core/messages";

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

/* ===== [1-2] 실행 환경 확인 =====
 *
 * 모델을 부르기 전에, 지금 이 파일이 어떤 환경에서 돌고 있는지부터 봅니다.
 * LangChain v1 은 Node.js 22 이상을 요구합니다.
 */
printSection("[1-2] 실행 환경 확인");

const major = Number(process.versions.node.split(".")[0]);
printKV({
  "Node.js": process.versions.node,
  "모듈 형식": typeof require === "undefined" ? "ESM (정상)" : "CommonJS (tsconfig/package.json 확인 필요)",
  "22 이상?": major >= 22 ? "예" : `아니오 — ${major} 입니다. 업그레이드하세요`,
});

/* ===== [1-3] 패키지 지형도 =====
 *
 * 다섯 개 패키지가 각각 무엇을 주는지 import 로 직접 확인합니다.
 * 여기서 중요한 건 "무엇을 어디서 가져오는가"입니다.
 *
 *   langchain          → createAgent, initChatModel, tool   (조립 도구)
 *   @langchain/core    → AIMessage 등 메시지 타입           (공용 언어)
 *   @langchain/anthropic → ChatAnthropic                    (제공자 어댑터)
 *
 * @langchain/langgraph 는 Step 10(메모리)부터 직접 씁니다.
 * 지금은 createAgent 밑에서 조용히 돌아가고 있습니다.
 */
printSection("[1-3] 패키지 지형도");

printKV({
  "langchain → createAgent": typeof createAgent,
  "langchain → initChatModel": typeof initChatModel,
  "@langchain/anthropic → ChatAnthropic": typeof ChatAnthropic,
  "@langchain/core → AIMessage": typeof AIMessage,
});

/* ===== [1-4] API 키 확인 =====
 *
 * 키를 통째로 출력하면 그게 터미널 스크롤백에, CI 로그에, 스크린샷에 남습니다.
 * 확인할 때는 항상 마스킹하세요. "있는지"와 "형식이 맞는지"만 보면 충분합니다.
 */
printSection("[1-4] API 키 확인");

const apiKey = process.env["ANTHROPIC_API_KEY"];

if (apiKey === undefined || apiKey.trim() === "") {
  console.error("ANTHROPIC_API_KEY 가 없습니다.");
  console.error("  1. project/.env 파일이 있습니까?  (cp .env.example .env)");
  console.error("  2. 이 파일 맨 위에 import \"dotenv/config\"; 가 있습니까?  ← 가장 흔한 원인");
  process.exit(1);
}

printKV({
  "키 존재": "예",
  "마스킹된 값": `${apiKey.slice(0, 14)}...${apiKey.slice(-4)}`,
  "길이": `${apiKey.length}자`,
  // 키 양끝에 공백이나 따옴표가 붙는 사고가 잦습니다. .env 에 KEY="sk-..." 라고
  // 따옴표째 적으면 dotenv 가 따옴표는 벗겨주지만, 뒤에 붙은 공백은 남습니다.
  "앞뒤 공백": apiKey !== apiKey.trim() ? "있음 — .env 를 확인하세요!" : "없음",
});

/* ===== [1-5] 첫 모델 호출 =====
 *
 * 모델을 지정하는 방법은 두 가지입니다. 결과는 같고, 쓰임새가 다릅니다.
 */
printSection("[1-5] 첫 모델 호출 — 방법 A: 문자열");

// (A) "provider:model" 문자열. initChatModel 이 접두사를 보고
//     알맞은 제공자 패키지를 동적으로 불러옵니다. await 가 필요합니다.
const modelFromString = await initChatModel("anthropic:claude-sonnet-4-6");
const answerA = await modelFromString.invoke("LangChain을 한 문장으로 설명해줘.");

printMessages(answerA);

printSection("[1-5] 첫 모델 호출 — 방법 B: 모델 인스턴스");

// (B) 제공자 클래스를 직접 생성. 그 제공자에만 있는 옵션까지 타입 지원을 받습니다.
//     apiKey 를 안 주면 ANTHROPIC_API_KEY 환경변수를 자동으로 읽습니다.
const modelFromClass = new ChatAnthropic({
  model: "claude-sonnet-4-6",
  temperature: 0,
  maxTokens: 1024,
});
const answerB = await modelFromClass.invoke("LangChain을 한 문장으로 설명해줘.");

printMessages(answerB);

// OpenAI 로 바꾸려면 이 두 줄이면 됩니다. 아래 코드는 하나도 안 바뀝니다.
//   import { ChatOpenAI } from "@langchain/openai";
//   const model = new ChatOpenAI({ model: "gpt-5.5" });
// 또는 문자열만 갈아끼우기:
//   const model = await initChatModel("openai:gpt-5.5");

/* ===== [1-6] 응답 객체 해부 =====
 *
 * invoke() 가 돌려주는 건 문자열이 아니라 AIMessage 객체입니다.
 * 문자열인 줄 알고 answer.length 를 세거나 answer.toUpperCase() 를 부르면
 * 엉뚱한 결과가 나옵니다.
 */
printSection("[1-6] 응답 객체 해부");

printKV({
  "typeof": typeof answerA,
  "생성자": answerA.constructor.name,
  ".id": answerA.id ?? "(없음)",
  ".text 타입": typeof answerA.text,
  ".content 타입": Array.isArray(answerA.content) ? "배열 (콘텐츠 블록)" : "문자열",
});

console.log("\n▸ .text — 텍스트만 뽑는 가장 안전한 방법");
console.log(answerA.text);

console.log("\n▸ .contentBlocks — 표준화된 콘텐츠 블록 (Step 03 에서 자세히)");
printJson("", answerA.contentBlocks);

console.log("\n▸ usage_metadata — 토큰 사용량 (= 돈)");
printUsage(answerA);

console.log("\n▸ response_metadata — 제공자 원본 응답. 모양이 제공자마다 다릅니다");
printJson("", answerA.response_metadata);

/* ===== [1-7] 첫 에이전트 맛보기 =====
 *
 * 모델은 "물으면 답한다"가 전부입니다. 에이전트는 여기에 루프와 도구가 붙습니다.
 * 아직 도구를 안 줬으니 이 에이전트는 한 번 답하고 끝납니다 —
 * 그래도 결과의 모양이 model.invoke() 와 어떻게 다른지 봐 두세요.
 *
 * 자세한 건 Step 08 에서 다룹니다.
 */
printSection("[1-7] 첫 에이전트 맛보기");

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [], // 도구는 Step 06 에서 만듭니다
  systemPrompt: "너는 간결하게 답하는 한국어 조수다. 두 문장을 넘기지 마라.",
});

// 모델은 문자열을 받았지만, 에이전트는 { messages: [...] } 를 받고
// { messages: [...] } 를 돌려줍니다. 대화 전체가 오간다는 뜻입니다.
const agentResult = await agent.invoke({
  messages: [{ role: "user", content: "에이전트와 그냥 모델 호출의 차이가 뭐야?" }],
});

console.log(`돌아온 메시지 수: ${agentResult.messages.length}개 (내가 보낸 것 + 모델이 답한 것)\n`);
printMessages(agentResult.messages);

/* ===== [1-8] 문제 해결 — provider 접두사 오타 =====
 *
 * 이 코스에서 가장 자주 보게 될 함정입니다.
 * "anthropi:..." 처럼 접두사를 틀려도 TypeScript 는 아무 말도 안 합니다.
 * model 파라미터의 타입이 그냥 string 이기 때문입니다.
 * 에러는 코드를 짤 때가 아니라, 실행해서 그 줄에 도달했을 때 터집니다.
 */
printSection("[1-8] 문제 해결 — provider 접두사 오타는 런타임에 터진다");

try {
  // 오타: "anthropic" 이 아니라 "anthropi" — 컴파일은 멀쩡히 통과합니다.
  await initChatModel("anthropi:claude-sonnet-4-6");
  console.log("여기는 실행되지 않습니다.");
} catch (error) {
  console.log("잡힌 에러 타입:", (error as Error).constructor.name);
  console.log("메시지:", (error as Error).message.split("\n")[0]);
  console.log("\n→ 오타 하나가 런타임 에러입니다. 모델 문자열은 상수로 빼서 한곳에서 관리하세요.");
}

printSection("Step 01 완료");
console.log("다음 → Step 02 에서 temperature, maxTokens 같은 파라미터를 다룹니다.\n");

/**
 * Step 01 — 환경 구축과 첫 모델 호출 · 연습문제
 * 실행: cd docs/reference/langchain/project && npx tsx ../step-01-setup/exercise.ts
 *
 * 각 [문제 N] 아래를 직접 채우세요. 정답은 solution.ts 에 있습니다.
 * 먼저 스스로 풀어본 뒤에 열어보세요.
 */
import "dotenv/config";

/* ===== [문제 1] dotenv 를 빼면 무슨 일이 일어나는가 =====
 *
 * 이 파일 맨 위의 `import "dotenv/config";` 를 잠시 주석 처리하고 실행해 보세요.
 * 그리고 아래 코드로 키가 읽히는지 확인하세요.
 *
 * 관찰한 뒤, 아래 질문에 주석으로 답하세요.
 *   (a) .env 파일은 그대로 있는데 왜 키를 못 읽습니까?
 *   (b) 그런데도 왜 어떤 사람의 컴퓨터에서는 잘 되기도 합니까?
 *       (힌트: 셸에서 export ANTHROPIC_API_KEY=... 를 해 본 적이 있다면?)
 *
 * 확인이 끝나면 주석을 반드시 되돌리세요.
 */

console.log("[문제 1] 키 존재 여부:", process.env["ANTHROPIC_API_KEY"] !== undefined);

// (a) 답:
// (b) 답:

/* ===== [문제 2] 모델 문자열을 상수로 =====
 *
 * practice.ts 의 [1-8] 에서 봤듯 "anthropi:..." 같은 오타는 런타임에야 터집니다.
 * 모델 이름을 아래에 상수로 정의하고, 이 파일의 나머지 문제에서 그 상수만 쓰세요.
 *
 * 추가로: `as const` 를 붙이는 것과 안 붙이는 것의 타입 차이를 확인하세요.
 * (에디터에서 MODEL 에 마우스를 올려 보세요. string 입니까, 리터럴 타입입니까?)
 */

// TODO: MODEL 상수를 정의하세요

/* ===== [문제 3] 첫 모델 호출 =====
 *
 * initChatModel 을 써서 [문제 2]의 MODEL 상수로 모델을 만들고,
 * "너는 어떤 모델이야?" 라고 물어 답을 출력하세요.
 *
 * 힌트: initChatModel 은 async 입니다. await 를 빠뜨리면 무슨 일이 생길까요?
 *       한 번 일부러 빼 보고 에러 메시지를 읽어 보세요.
 */

// TODO: 여기에 작성

/* ===== [문제 4] .text 와 .content 는 어떻게 다른가 =====
 *
 * [문제 3]의 응답 객체에서 아래 셋을 모두 출력해 비교하세요.
 *   - response.text
 *   - response.content
 *   - response.contentBlocks
 *
 * 그리고 주석으로 답하세요:
 *   (a) 셋 중 "텍스트만 안전하게 꺼내는" 용도로 뭘 써야 합니까? 왜입니까?
 *   (b) content 가 문자열이 아니라 배열로 오는 경우는 언제입니까?
 */

// TODO: 여기에 작성

// (a) 답:
// (b) 답:

/* ===== [문제 5] 토큰으로 비용 계산하기 =====
 *
 * [문제 3]의 응답에서 usage_metadata 를 읽어 이번 호출의 비용을 달러로 계산하세요.
 *
 * 아래 단가를 쓰세요 (100만 토큰당 달러, 예시 값입니다):
 *   입력 $3.00 / 출력 $15.00
 *
 * 주의: usage_metadata 는 optional 입니다. strict 모드에서 그냥 읽으면
 *       타입 에러가 납니다. 없을 때를 반드시 처리하세요.
 */

// TODO: 여기에 작성

/* ===== [문제 6] 제공자 갈아끼우기 =====
 *
 * [문제 3]의 코드를 OpenAI 로 바꾸면 몇 줄을 고쳐야 합니까?
 * 실제로 바꿔서 (키가 있다면) 실행해 보고, 없다면 코드만 작성한 뒤
 * 주석으로 "몇 줄이 바뀌었는지" 적으세요.
 *
 * 힌트: 모델 문자열 방식이라면 "openai:gpt-5.5".
 *       나머지 코드(invoke, .text, usage_metadata)는 몇 줄이나 바뀝니까?
 *       이게 1-1 에서 말한 "표준화"의 실체입니다.
 */

// TODO: 여기에 작성

// 바뀐 줄 수:

/* ===== [문제 7] 코어 중복 확인 =====
 *
 * @langchain/core 가 두 벌 설치되면 instanceof 검사가 조용히 깨집니다.
 * 지금 내 환경이 안전한지 확인하세요.
 *
 *   (a) 터미널에서 아래를 실행하고 결과를 주석으로 적으세요.
 *         npm ls @langchain/core
 *       "deduped" 만 보이면 안전, 서로 다른 버전이 여러 줄이면 위험합니다.
 *
 *   (b) 아래 코드로 실제 instanceof 가 동작하는지 확인하세요.
 *       AIMessage 를 import 해서, [문제 3]의 응답이 instanceof AIMessage 인지 출력하세요.
 *
 *   (c) 만약 false 가 나온다면 무엇을 의심해야 합니까?
 */

// TODO: (b) 여기에 작성

// (a) 답:
// (c) 답:

/* ===== [문제 8] 첫 에이전트 =====
 *
 * createAgent 로 에이전트를 하나 만드세요. 조건:
 *   - 도구는 없음 (빈 배열)
 *   - systemPrompt: "너는 무조건 한 문장으로만 답한다."
 *
 * 아무거나 물어보고, 다음을 확인하세요:
 *   (a) result.messages 는 몇 개입니까? 각각의 역할(getType())은 무엇입니까?
 *   (b) systemPrompt 로 준 메시지도 result.messages 에 들어 있습니까?
 *   (c) model.invoke("문자열") 과 agent.invoke({ messages: [...] }) 는
 *       입력/출력 모양이 어떻게 다릅니까?
 */

// TODO: 여기에 작성

// (a) 답:
// (b) 답:
// (c) 답:

/**
 * Step 01 — 환경 구축과 첫 모델 호출 · 정답과 해설
 * 실행: cd docs/reference/langchain/project && npx tsx ../step-01-setup/solution.ts
 *
 * exercise.ts 를 스스로 풀어본 뒤에 열어보세요.
 */
import "dotenv/config";

import { createAgent, initChatModel } from "langchain";
import { AIMessage } from "@langchain/core/messages";
import { ChatOpenAI } from "@langchain/openai";

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

/* ===== [정답 1] dotenv 를 빼면 무슨 일이 일어나는가 =====
 *
 * (a) .env 는 그냥 텍스트 파일입니다. Node.js 는 이 파일의 존재를 모릅니다.
 *     `import "dotenv/config"` 가 실행되는 순간 dotenv 가 파일을 읽어
 *     process.env 에 채워 넣습니다. 그 import 가 없으면 파일은 그대로 있지만
 *     아무도 읽지 않으므로 process.env.ANTHROPIC_API_KEY 는 undefined 입니다.
 *
 * (b) 셸에 이미 export 되어 있으면 dotenv 없이도 읽힙니다.
 *     ~/.zshrc 에 export ANTHROPIC_API_KEY=... 를 해 둔 사람은 dotenv 를 빼도
 *     잘 돌아갑니다. 그래서 "내 컴퓨터에선 되는데 동료 컴퓨터에선 안 되는"
 *     전형적인 상황이 만들어집니다.
 *
 *     반대 방향도 알아 두세요: dotenv 는 기본적으로 "이미 있는" 환경변수를
 *     덮어쓰지 않습니다. 셸에 낡은 키가 export 되어 있으면 .env 를 아무리
 *     고쳐도 그 낡은 키가 계속 이깁니다. 이때는 `echo $ANTHROPIC_API_KEY` 로
 *     셸 쪽을 먼저 의심하세요.
 *
 *     그리고 dotenv 는 process.cwd() 기준으로 .env 를 찾습니다.
 *     그래서 이 코스는 항상 project/ 에서 실행합니다.
 */
printSection("[정답 1] dotenv");
console.log("키 존재 여부:", process.env["ANTHROPIC_API_KEY"] !== undefined);
console.log("dotenv 는 cwd 기준으로 .env 를 찾습니다. 지금 cwd:", process.cwd());

/* ===== [정답 2] 모델 문자열을 상수로 =====
 *
 * `as const` 를 붙이면 타입이 string 이 아니라 "anthropic:claude-sonnet-4-6"
 * 리터럴 타입이 됩니다. 그 자체로 오타를 막아주진 않지만(어차피 처음 적을 때
 * 틀리면 그 오타가 리터럴 타입이 됩니다), 아래 MODELS 처럼 허용 목록을
 * 만들어 두면 "목록에 없는 값"을 컴파일 타임에 잡을 수 있습니다.
 *
 * 이게 provider 접두사 오타에 대한 유일한 실질적 방어입니다 —
 * LangChain 의 model 파라미터 타입은 그냥 string 이라 프레임워크가
 * 대신 잡아줄 방법이 없습니다.
 */
const MODELS = {
  sonnet: "anthropic:claude-sonnet-4-6",
  gpt: "openai:gpt-5.5",
} as const;

type ModelId = (typeof MODELS)[keyof typeof MODELS];

const MODEL: ModelId = MODELS.sonnet;

// 아래 줄의 주석을 풀면 컴파일 에러가 납니다 — 이게 목적입니다.
// const BAD: ModelId = "anthropi:claude-sonnet-4-6";
//   Type '"anthropi:claude-sonnet-4-6"' is not assignable to type ModelId.

/* ===== [정답 3] 첫 모델 호출 =====
 *
 * initChatModel 은 제공자 패키지를 동적으로 import 하므로 Promise 를 돌려줍니다.
 * await 를 빠뜨리면 model 이 Promise 가 되고, model.invoke 는 존재하지 않으므로
 * "model.invoke is not a function" 이라는, 원인과 동떨어진 에러를 보게 됩니다.
 */
printSection("[정답 3] 첫 모델 호출");

const model = await initChatModel(MODEL);
const response = await model.invoke("너는 어떤 모델이야? 한 문장으로 답해.");

console.log(response.text);

/* ===== [정답 4] .text 와 .content 는 어떻게 다른가 =====
 *
 * (a) .text 를 쓰세요.
 *     .content 는 제공자와 응답 종류에 따라 string 일 수도, 블록 배열일 수도
 *     있습니다. 즉 타입이 `string | ContentBlock[]` 입니다. 그래서
 *     response.content.toUpperCase() 같은 코드는 "오늘은" 동작하다가
 *     추론(reasoning) 블록이나 인용(citation)이 끼는 순간 조용히 깨집니다.
 *     .text 는 어떤 경우든 텍스트 블록만 이어붙여 string 을 돌려줍니다.
 *
 * (b) 모델이 텍스트 말고 다른 걸 같이 보낼 때입니다.
 *     추론 블록, 인용, 도구 호출, 이미지 등. Anthropic 은 대체로 배열로 옵니다.
 *     자세한 건 Step 03 에서 다룹니다.
 */
printSection("[정답 4] .text vs .content vs .contentBlocks");

console.log("▸ .text (항상 string)");
console.log(response.text);

console.log("\n▸ .content 의 실제 타입:", Array.isArray(response.content) ? "배열" : "문자열");
console.log(JSON.stringify(response.content, null, 2));

console.log("\n▸ .contentBlocks (제공자와 무관하게 표준화된 모양)");
console.log(JSON.stringify(response.contentBlocks, null, 2));

/* ===== [정답 5] 토큰으로 비용 계산하기 =====
 *
 * 핵심은 usage_metadata 가 optional 이라는 것입니다.
 * strict 모드에서는 undefined 확인 없이 못 읽습니다 — 이건 tsc 의 잔소리가
 * 아니라 실제로 자주 없는 값입니다(스트리밍 청크, 일부 제공자).
 *
 * 비용 계산에서 흔한 실수: total_tokens 에 출력 단가를 곱하는 것.
 * 입력과 출력은 단가가 5배 차이납니다. 반드시 따로 곱하세요.
 */
printSection("[정답 5] 비용 계산");

const PRICE_PER_MTOK = { input: 3.0, output: 15.0 };

const usage = response.usage_metadata;
if (usage === undefined) {
  console.log("usage_metadata 가 없습니다 — 비용을 계산할 수 없습니다.");
} else {
  const cost =
    (usage.input_tokens / 1_000_000) * PRICE_PER_MTOK.input +
    (usage.output_tokens / 1_000_000) * PRICE_PER_MTOK.output;

  console.log(`입력  ${usage.input_tokens} 토큰`);
  console.log(`출력  ${usage.output_tokens} 토큰`);
  console.log(`합계  ${usage.total_tokens} 토큰`);
  console.log(`비용  $${cost.toFixed(6)}`);
  console.log(`\n이 호출을 100만 번 하면 $${(cost * 1_000_000).toFixed(2)} 입니다.`);
}

/* ===== [정답 6] 제공자 갈아끼우기 =====
 *
 * 바뀌는 줄: 1줄 (모델 문자열).
 * invoke, .text, .content, usage_metadata, contentBlocks — 전부 그대로입니다.
 *
 * 이게 1-1 에서 말한 "표준화"입니다. Anthropic SDK 와 OpenAI SDK 를 직접 쓰면
 * 응답 파싱 코드(content[0].text vs choices[0].message.content)와
 * 토큰 필드명(input_tokens vs prompt_tokens)이 전부 달라서
 * 제공자를 바꾸는 순간 애플리케이션 코드를 다시 씁니다.
 */
printSection("[정답 6] 제공자 갈아끼우기");

if (process.env["OPENAI_API_KEY"] === undefined) {
  console.log("OPENAI_API_KEY 가 없어 건너뜁니다. 바뀌는 코드는 아래 한 줄뿐입니다:");
  console.log('  const model = await initChatModel(MODELS.gpt);   // "openai:gpt-5.5"');
} else {
  const gpt = await initChatModel(MODELS.gpt);
  const gptResponse = await gpt.invoke("너는 어떤 모델이야? 한 문장으로 답해.");

  // 아래 세 줄은 Anthropic 일 때와 글자 하나 다르지 않습니다.
  console.log(gptResponse.text);
  console.log("토큰:", gptResponse.usage_metadata?.total_tokens ?? "(없음)");

  // 클래스를 직접 쓰는 방법도 동일합니다.
  const gptDirect = new ChatOpenAI({ model: "gpt-5.5" });
  console.log("클래스 방식도 같은 인터페이스:", typeof gptDirect.invoke);
}

/* ===== [정답 7] 코어 중복 확인 =====
 *
 * (a) 안전한 출력은 이렇게 생겼습니다 — 실제 버전이 한 번만 나오고
 *     나머지는 전부 deduped 입니다.
 *
 *       ├─┬ @langchain/anthropic@1.5.1
 *       │ └── @langchain/core@1.2.3 deduped
 *       ├─┬ @langchain/core@1.2.3
 *       └─┬ @langchain/langgraph@1.4.8
 *         └── @langchain/core@1.2.3 deduped
 *
 *     위험한 출력은 서로 다른 버전이 중첩되어 나옵니다.
 *     그러면 node_modules/@langchain/core 와
 *     node_modules/@langchain/anthropic/node_modules/@langchain/core 가
 *     동시에 존재하고, 서로 다른 AIMessage 클래스가 두 개 생깁니다.
 *
 * (c) false 가 나오면 코어 중복을 의심하세요.
 *     확인: npm ls @langchain/core
 *     해결: package.json 의 @langchain/* 버전을 서로 맞추고
 *           rm -rf node_modules package-lock.json && npm install
 *     또는 npm 의 overrides 로 코어 버전을 한 개로 고정합니다.
 *
 *     그리고 애초에 instanceof 에 의존하지 않는 코드를 쓰는 게 가장 안전합니다.
 *     project/src/lib/print.ts 가 instanceof 대신 "필드가 있는지"만 보는
 *     구조적 검사를 쓰는 이유입니다.
 */
printSection("[정답 7] 코어 중복 확인");

const isAIMessage = response instanceof AIMessage;
console.log("response instanceof AIMessage:", isAIMessage);

if (!isAIMessage) {
  console.log("⚠️  false 입니다! @langchain/core 가 두 벌 설치됐을 가능성이 큽니다.");
  console.log("   확인: npm ls @langchain/core");
} else {
  console.log("정상 — @langchain/core 가 한 벌입니다.");
}

// instanceof 에 의존하지 않는 대안: getType() 으로 역할을 봅니다.
// 이 방법은 코어가 몇 벌이든 항상 동작합니다.
console.log("instanceof 없이 확인하기 — getType():", response.getType()); // "ai"

/* ===== [정답 8] 첫 에이전트 =====
 *
 * (a) 2개입니다: human(내가 보낸 것), ai(모델이 답한 것).
 *     도구가 없으니 한 번 답하고 루프가 끝납니다.
 *     Step 06~08 에서 도구를 붙이면 여기에 ai(도구 호출) → tool(결과) →
 *     ai(최종 답) 이 끼어들어 4개, 6개로 늘어납니다.
 *
 * (b) 아니오. systemPrompt 는 매 모델 호출 때 앞에 붙지만
 *     result.messages 에는 남지 않습니다. 대화 기록이 아니라
 *     에이전트의 설정이기 때문입니다.
 *
 * (c) 모델: 문자열을 받아 AIMessage 하나를 돌려줍니다. 상태가 없습니다.
 *     에이전트: { messages: [...] } 를 받아 { messages: [...] } 를 돌려줍니다.
 *     대화 전체가 오갑니다. 그래서 여기에 checkpointer 를 붙이면
 *     (Step 10) 그대로 메모리가 됩니다.
 */
printSection("[정답 8] 첫 에이전트");

const agent = createAgent({
  model: MODEL,
  tools: [],
  systemPrompt: "너는 무조건 한 문장으로만 답한다.",
});

const result = await agent.invoke({
  messages: [{ role: "user", content: "TypeScript 를 왜 써?" }],
});

console.log(`메시지 ${result.messages.length}개\n`);
for (const m of result.messages) {
  console.log(`  ${m.getType().padEnd(6)} │ ${m.text}`);
}

console.log("\nsystem 메시지가 목록에 있습니까?");
console.log("  ", result.messages.some((m) => m.getType() === "system") ? "예" : "아니오 — 설정이지 대화 기록이 아닙니다");

printSection("Step 01 연습문제 완료");