#Step 02 — 챗 모델과 파라미터

// LangChain 없이 — Anthropic SDK 직접 호출 (참고용, 실습 아님)
const res = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,                                  // snake_case
  messages: [{ role: "user", content: "안녕" }],
});
console.log(res.content[0].text);                    // content 는 블록 배열
console.log(res.usage.input_tokens);                 // usage 위치
console.log(res.stop_reason);                        // 종료 이유 필드명

// LangChain 없이 — OpenAI SDK 직접 호출 (참고용, 실습 아님)
const res = await client.chat.completions.create({
  model: "gpt-5.5",
  max_completion_tokens: 1024,                       // 이름이 다르다
  messages: [{ role: "user", content: "안녕" }],
});
console.log(res.choices[0].message.content);         // choices 배열
console.log(res.usage.prompt_tokens);                // input 이 아니라 prompt
console.log(res.choices[0].finish_reason);           // stop_reason 이 아니라 finish_reason

const res = await model.invoke("안녕");
res.text;                       // 어느 provider 든 여기에 텍스트
res.usage_metadata;             // 어느 provider 든 input_tokens/output_tokens/total_tokens
res.contentBlocks;              // 어느 provider 든 표준화된 블록 배열
res.tool_calls;                 // 어느 provider 든 같은 shape

import { initChatModel } from "langchain";

const model = await initChatModel("anthropic:claude-sonnet-4-6", {
  temperature: 0,
  maxTokens: 1024,
});

import { createAgent } from "langchain";

const agent = createAgent({
  model: "anthropic:claude-sonnet-4-6",   // 문자열을 그대로 넘긴다
  tools: [],
});

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

const model = new ChatAnthropic({
  model: "claude-sonnet-4-6",
  temperature: 0,
  maxTokens: 1024,
  topK: 40,                                  // ← Anthropic 에만 있는 파라미터
  thinking: { type: "disabled" },            // ← Anthropic 에만 있는 파라미터
});

const model = new ChatAnthropic({
  model: "claude-sonnet-4-6",
  stopSequences: ["\n\n관련 항목:"],   // 이 헤더가 시작되면 거기서 끝
});

const res = await model.invoke("광합성을 두 문장으로 설명해줘.");
console.log(res.text);

const stream = await model.stream("광합성을 두 문장으로 설명해줘.");
for await (const chunk of stream) {
  process.stdout.write(chunk.text);
}

const inputs = ["고양이를 한 문장으로", "강아지를 한 문장으로", "앵무새를 한 문장으로"];
const results = await model.batch(inputs);
results.forEach((r, i) => console.log(`[${i}] ${r.text}`));

const res = await model.invoke("광합성을 한 문장으로 설명해줘.");
console.log(res.usage_metadata);

type UsageMetadata = {
  input_tokens: number;          // 입력 토큰. 모든 입력 종류의 합
  output_tokens: number;         // 출력 토큰. 모든 출력 종류의 합
  total_tokens: number;          // input_tokens + output_tokens
  input_token_details?: InputTokenDetails;
  output_token_details?: OutputTokenDetails;
};

type ModalitiesTokenDetails = {
  text?: number; image?: number; audio?: number; video?: number; document?: number;
};

type InputTokenDetails = ModalitiesTokenDetails & {
  cache_read?: number;       // 캐시 히트로 캐시에서 읽어온 토큰
  cache_creation?: number;   // 캐시 미스로 캐시를 새로 만든 토큰
};

type OutputTokenDetails = ModalitiesTokenDetails & {
  reasoning?: number;        // 추론(thinking) 토큰. 출력에는 안 보이지만 요금은 낸다
};

type Pricing = {
  inputPerMTok: number;          // 100만 토큰당 USD
  outputPerMTok: number;
  cacheReadPerMTok: number;
  cacheWritePerMTok: number;
};

function estimateCost(usage: UsageMetadata, p: Pricing): number {
  const cacheRead = usage.input_token_details?.cache_read ?? 0;
  const cacheWrite = usage.input_token_details?.cache_creation ?? 0;

  // 중요: input_tokens 는 캐시 토큰을 "포함한" 총합이다.
  // 캐시분을 빼야 일반 입력 토큰이 남는다. 안 빼면 이중 계산이 된다.
  const plainInput = Math.max(0, usage.input_tokens - cacheRead - cacheWrite);

  return (
    (plainInput   / 1_000_000) * p.inputPerMTok +
    (cacheRead    / 1_000_000) * p.cacheReadPerMTok +
    (cacheWrite   / 1_000_000) * p.cacheWritePerMTok +
    (usage.output_tokens / 1_000_000) * p.outputPerMTok
  );
}

// Anthropic — thinking
import { ChatAnthropic } from "@langchain/anthropic";

const model = new ChatAnthropic({
  model: "claude-sonnet-4-6",
  maxTokens: 4000,
  thinking: { type: "enabled", budget_tokens: 2000 },
});

// OpenAI — reasoning
import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "gpt-5.5",
  reasoning: { effort: "low" },     // "low" | "medium" | "high"
});

const res = await model.invoke("17 * 24 를 암산하듯 계산해줘.");

const reasoning = res.contentBlocks.filter((b) => b.type === "reasoning");
console.log("--- 추론 과정 ---");
console.log(reasoning.map((b) => b.reasoning).join("\n"));

console.log("--- 최종 답변 ---");
console.log(res.text);         // text 에는 추론이 섞이지 않는다

console.log(res.usage_metadata?.output_token_details?.reasoning);

import { initChatModel } from "langchain";

// 이 함수는 provider 를 전혀 모른다. 모델 인터페이스만 안다.
async function askAll(model: Awaited<ReturnType<typeof initChatModel>>, questions: string[]) {
  const results = await model.batch(
    questions,
    { maxConcurrency: 2 },
    { returnExceptions: true },
  );

  let totalIn = 0, totalOut = 0;
  for (const [i, r] of results.entries()) {
    if (r instanceof Error) {
      console.log(`[${i}] 실패: ${r.message}`);
      continue;
    }
    totalIn += r.usage_metadata?.input_tokens ?? 0;
    totalOut += r.usage_metadata?.output_tokens ?? 0;
    console.log(`[${i}] ${r.text.slice(0, 50)}...`);
  }
  console.log(`합계: 입력 ${totalIn} / 출력 ${totalOut} 토큰`);
}

const questions = ["광합성을 한 문장으로", "중력을 한 문장으로"];

// provider 를 문자열로만 바꾼다
await askAll(await initChatModel("anthropic:claude-sonnet-4-6", { temperature: 0, maxTokens: 200 }), questions);
await askAll(await initChatModel("openai:gpt-5.5",              { temperature: 0, maxTokens: 200 }), questions);

const model = await initChatModel(process.env.MODEL ?? "anthropic:claude-sonnet-4-6", {
  temperature: 0,
  maxTokens: 200,
});

import { InMemoryCache } from "@langchain/core/caches";

const cache = new InMemoryCache();
const model = new ChatAnthropic({ model: "claude-sonnet-4-6", cache });
// 또는 그냥: new ChatAnthropic({ model: "claude-sonnet-4-6", cache: true });

console.time("1회차");
await model.invoke("광합성을 한 문장으로 설명해줘.");
console.timeEnd("1회차");     // 1회차: 1823ms  ← 실제 호출

console.time("2회차");
await model.invoke("광합성을 한 문장으로 설명해줘.");
console.timeEnd("2회차");     // 2회차: 0.3ms   ← 캐시 히트. 네트워크 안 탐

const messages = [
  {
    role: "system",
    content: [
      {
        type: "text",
        text: LONG_TEXT,                        // 길고, 매 요청 동일한 내용
        cache_control: { type: "ephemeral" },   // ← 여기까지 캐시
      },
    ],
  },
  { role: "user", content: "이 문서에서 X 를 찾아줘." },
];
const res = await model.invoke(messages);
console.log(res.usage_metadata?.input_token_details);
// 1회차: { cache_creation: 2431, cache_read: 0 }     ← 캐시 만듦 (비쌈)
// 2회차: { cache_creation: 0,    cache_read: 2431 }  ← 캐시 읽음 (쌈)

function inspect(res: AIMessage, label = "") {
  const meta = res.response_metadata as Record<string, unknown>;
  const u = res.usage_metadata;
  const truncated = meta.stop_reason === "max_tokens" || meta.finish_reason === "length";

  console.log(`--- ${label} ---`);
  console.log(`텍스트   : ${res.text.slice(0, 60)}${res.text.length > 60 ? "..." : ""}`);
  console.log(`종료 이유: ${meta.stop_reason ?? meta.finish_reason ?? "(알 수 없음)"}${truncated ? "  ⚠️ 잘림!" : ""}`);
  console.log(`토큰     : 입력 ${u?.input_tokens ?? 0} / 출력 ${u?.output_tokens ?? 0} / 합계 ${u?.total_tokens ?? 0}`);
  console.log(`캐시     : 읽기 ${u?.input_token_details?.cache_read ?? 0} / 생성 ${u?.input_token_details?.cache_creation ?? 0}`);
  console.log(`추론     : ${u?.output_token_details?.reasoning ?? 0} 토큰`);
}

/**
 * Step 02 — 챗 모델과 파라미터
 * 실행: npx tsx docs/reference/langchain/step-02-chat-models/practice.ts
 *
 * 주의: 이 파일은 실제 API 를 호출하므로 요금이 발생합니다.
 *      모든 블록은 maxTokens 를 작게 잡아 두었지만, 반복 실행할 때는
 *      main() 하단에서 필요한 블록만 남기고 주석 처리하세요.
 *
 * 검증 버전: langchain 1.5.3 / @langchain/core 1.2.3
 *           @langchain/anthropic 1.5.1 / @langchain/openai 1.5.5
 */
import "dotenv/config";

import { initChatModel } from "langchain";
import { ChatAnthropic } from "@langchain/anthropic";
import { InMemoryCache } from "@langchain/core/caches";
import type { AIMessage, AIMessageChunk, UsageMetadata } from "@langchain/core/messages";

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

/* ===== [2-9] 계측 헬퍼 — 아래 모든 블록에서 재사용한다 ===== */

/**
 * 응답 하나를 이 스텝에서 배운 관점 전부로 해부해 출력한다.
 * - 종료 이유(잘렸는지)
 * - 입력/출력/합계 토큰
 * - 캐시 읽기/생성 토큰
 * - 추론 토큰
 */
function inspect(res: AIMessage, label = "") {
  const meta = res.response_metadata as Record<string, unknown>;
  const u = res.usage_metadata;

  // 종료 이유 필드명이 provider 마다 다르다. 둘 다 봐야 한다.
  //   Anthropic: stop_reason === "max_tokens"
  //   OpenAI   : finish_reason === "length"
  const truncated = meta.stop_reason === "max_tokens" || meta.finish_reason === "length";

  console.log(`--- ${label} ---`);
  console.log(`텍스트   : ${res.text.slice(0, 60)}${res.text.length > 60 ? "..." : ""}`);
  console.log(
    `종료 이유: ${meta.stop_reason ?? meta.finish_reason ?? "(알 수 없음)"}` +
      `${truncated ? "  ⚠️ 잘림!" : ""}`,
  );
  console.log(
    `토큰     : 입력 ${u?.input_tokens ?? 0} / 출력 ${u?.output_tokens ?? 0} / 합계 ${u?.total_tokens ?? 0}`,
  );
  console.log(
    `캐시     : 읽기 ${u?.input_token_details?.cache_read ?? 0} / 생성 ${u?.input_token_details?.cache_creation ?? 0}`,
  );
  console.log(`추론     : ${u?.output_token_details?.reasoning ?? 0} 토큰`);
  console.log("");
}

/* ===== [2-1] 챗 모델 추상화 — 어느 provider 든 같은 인터페이스 ===== */

async function section_2_1() {
  console.log("========== [2-1] 챗 모델 추상화 ==========\n");

  const model = await initChatModel(MODEL_ID, { temperature: 0, maxTokens: 200 });
  const res = await model.invoke("광합성을 한 문장으로 설명해줘.");

  // provider 가 무엇이든 아래 네 가지는 항상 같은 이름, 같은 shape 다.
  // 이것이 앞으로 배울 createAgent / 미들웨어 / 스트리밍이 서 있는 계약이다.
  console.log("res.text          :", res.text);
  console.log("res.usage_metadata:", res.usage_metadata);
  console.log("res.contentBlocks :", res.contentBlocks.map((b) => b.type));
  console.log("res.tool_calls    :", res.tool_calls);
  console.log("");
}

/* ===== [2-2] 모델을 만드는 세 가지 방법 ===== */

async function section_2_2() {
  console.log("========== [2-2] 모델 생성 세 방식 ==========\n");

  // --- (A) initChatModel + "provider:model" 문자열 ---
  // await 가 필요하다! 접두사를 보고 통합 패키지를 "동적으로" import 하기 때문이다.
  // await 를 빼면 model 이 Promise 가 되고 "model.invoke is not a function" 이 난다.
  const a = await initChatModel("anthropic:claude-sonnet-4-6", {
    temperature: 0,
    maxTokens: 100,
  });
  console.log("(A) initChatModel :", (await a.invoke("1+1은? 숫자만.")).text);

  // --- (B) 문자열만 (createAgent 등 상위 API 에 그대로 넘긴다) ---
  // createAgent({ model: "anthropic:claude-sonnet-4-6", tools: [] })
  // → 내부에서 알아서 initChatModel 을 부른다. Step 08 에서 본격적으로 쓴다.

  // --- (C) new ChatAnthropic() 직접 생성 ---
  // await 가 없다(동적 import 가 아니니까).
  // 그리고 provider 고유 파라미터가 타입으로 잡힌다.
  const c = new ChatAnthropic({
    model: "claude-sonnet-4-6",
    temperature: 0,
    maxTokens: 100,
    topK: 40, //                       ← Anthropic 에만 있는 파라미터
    thinking: { type: "disabled" }, //  ← Anthropic 에만 있는 파라미터
  });
  console.log("(C) new ChatAnthropic:", (await c.invoke("2+2는? 숫자만.")).text);
  console.log("");

  /* --- ⚠️ 함정: initChatModel 의 옵션은 타입 체크를 받지 않는다 --- */
  // initChatModel 의 2번째 인자 타입은 Partial<Record<string, any>> 다.
  // 즉 아무 키나 넣어도 컴파일이 통과한다. 아래 줄은 tsc --strict 를 그냥 통과한다.
  // 지우지 말 것 — 오타가 컴파일에도 실행에도 안 걸린다는 걸 눈으로 확인하는 자리다.
  const typo = await initChatModel("anthropic:claude-sonnet-4-6", {
    temperatur: 0.9, //            ← 오타. 에러 안 남. temperature 는 설정되지 않는다.
    completelyMadeUpParam: 123, // ← 존재하지 않는 파라미터. 에러 안 남.
    maxTokens: 50,
  });
  console.log("⚠️ 오타를 넣어도 그냥 실행된다:", (await typo.invoke("3+3은? 숫자만.")).text);

  // 반면 (C) 방식은 같은 오타를 컴파일 타임에 잡아준다.
  // 아래 주석을 풀면 컴파일 에러가 난다:
  //   error TS2769: Object literal may only specify known properties,
  //                 and 'temperatur' does not exist in type 'ChatAnthropicInput'.
  // → 이것이 (C) 방식의 값어치다. 주석을 지우지 말고 그대로 둘 것.
  //
  // new ChatAnthropic({ model: "claude-sonnet-4-6", temperatur: 0.9 });

  console.log("");
}

/* ===== [2-3] 파라미터 완전 해부 ===== */

async function section_2_3() {
  console.log("========== [2-3] 파라미터 완전 해부 ==========\n");

  /* --- ⚠️ 함정: maxTokens 를 넘기면 응답이 "조용히" 잘린다 --- */
  // 에러가 나지 않는다. 20 토큰까지 만들고 문장 중간에서 뚝 끊긴
  // AIMessage 가 정상 응답인 척 돌아온다.
  const truncating = new ChatAnthropic({
    model: "claude-sonnet-4-6",
    maxTokens: 20, // ← 일부러 아주 작게
  });
  const cut = await truncating.invoke("광합성을 아주 자세히, 단계별로 설명해줘.");
  inspect(cut, "maxTokens: 20 (잘림 예상)");
  // → stop_reason 이 "max_tokens" 로 찍히는 것을 확인하라.
  //   res.text 만 봐서는 완성된 답인지 잘린 답인지 구분할 방법이 없다.
  //   JSON 을 요구했다면 더 나쁘다 — 잘린 JSON 은 파싱에 실패하고,
  //   "모델이 JSON 을 못 만든다"고 오해하며 프롬프트를 고치기 시작한다.

  /* --- stopSequences: 정지 문자열 자체는 출력에 포함되지 않는다 --- */
  const stopping = new ChatAnthropic({
    model: "claude-sonnet-4-6",
    maxTokens: 300,
    stopSequences: ["3."], // "3." 이 나오면 즉시 멈춘다
  });
  const stopped = await stopping.invoke("과일 이름을 1. 2. 3. 4. 형식으로 4개 나열해줘.");
  inspect(stopped, 'stopSequences: ["3."]');
  // → stop_reason 이 "stop_sequence" 다. "max_tokens" 와 달리 이건 정상 종료다.
  //   그리고 "3." 자체는 출력에 포함되지 않는다.

  /* --- ⚠️ 함정: 모델마다 지원 파라미터가 다르다 (timeout 이 대표 사례) --- */
  // ChatOpenAI 에는 timeout 이 있지만 ChatAnthropic 생성자에는 없다.
  // 아래 주석을 풀면 컴파일 에러가 난다:
  //   error TS2769: Object literal may only specify known properties,
  //                 and 'timeout' does not exist in type 'ChatAnthropicInput'.
  // → 주석을 지우지 말 것. 본문 2-3 의 지원 매트릭스를 컴파일러로 검증하는 자리다.
  //
  // new ChatAnthropic({ model: "claude-sonnet-4-6", timeout: 30000 });

  // ChatAnthropic 에서 타임아웃을 주는 올바른 두 가지 방법:
  // 방법 1: clientOptions.timeout (밀리초)
  const withClientTimeout = new ChatAnthropic({
    model: "claude-sonnet-4-6",
    maxTokens: 50,
    clientOptions: { timeout: 30_000 },
  });
  console.log("clientOptions.timeout:", (await withClientTimeout.invoke("4+4는? 숫자만.")).text);

  // 방법 2: 호출 시점에 넘긴다 (밀리초). provider 무관하게 동작하므로 이쪽을 권장.
  const m = await initChatModel(MODEL_ID, { maxTokens: 50 });
  console.log("호출 옵션 timeout   :", (await m.invoke("5+5는? 숫자만.", { timeout: 30_000 })).text);

  // ⚠️ 단위 함정: RunnableConfig.timeout 의 JSDoc 은
  //   "Timeout for this call in milliseconds" 라고 명시한다.
  //   timeout: 30 은 30초가 아니라 30밀리초다.
  //   그리고 이걸 initChatModel 에 넘기면 (위 함정대로) 타입 체크도 없이 조용히 무시된다.

  console.log("");
}

/* ===== [2-4] invoke / batch / stream ===== */

async function section_2_4() {
  console.log("========== [2-4] invoke / batch / stream ==========\n");

  const model = await initChatModel(MODEL_ID, { temperature: 0, maxTokens: 100 });

  /* --- invoke: 하나 보내고 하나 받는다 --- */
  const one = await model.invoke("고양이를 한 문장으로 설명해줘.");
  console.log("[invoke]", one.text);
  console.log("");

  /* --- stream: 만들어지는 대로 받는다 --- */
  // 총 소요 시간은 invoke 와 비슷하지만 첫 글자가 나오는 시간(TTFT)이 극적으로 짧다.
  // 사용자에게 보여주는 모든 곳에서는 stream 이 기본값이어야 한다.
  process.stdout.write("[stream] ");
  let final: AIMessageChunk | undefined;
  for await (const chunk of await model.stream("강아지를 한 문장으로 설명해줘.")) {
    process.stdout.write(chunk.text);
    // ⚠️ 각 청크의 usage_metadata 는 대부분 undefined 다. 토큰 수는 마지막 청크에 실려 온다.
    //    청크를 concat 으로 합치면 usage_metadata 가 병합되어 온전한 값이 나온다.
    final = final === undefined ? chunk : final.concat(chunk);
  }
  console.log("");
  console.log("[stream] 합친 뒤 usage_metadata:", final?.usage_metadata);
  console.log("");

  /* --- batch: 여러 개를 동시에. 입력 순서 = 출력 순서가 보장된다 --- */
  // 주의: 이 batch 는 OpenAI Batch API 같은 "묶어서 싸게 처리하는 오프라인 배치"가 아니다.
  //      그냥 N 개의 요청을 병렬로 날리는 것이다. 할인은 없다.
  const questions = ["고양이를 한 문장으로", "강아지를 한 문장으로", "앵무새를 한 문장으로"];
  const results = await model.batch(questions);
  results.forEach((r, i) => console.log(`[batch ${i}] ${r.text}`));
  console.log("→ results[i] 는 반드시 questions[i] 의 답이다. 순서는 보장된다.");
  console.log("");

  /* --- ⚠️ 함정: batch 는 실패 하나가 전체를 죽인다 (fail-fast) --- */
  const broken = new ChatAnthropic({
    model: "this-model-does-not-exist", // ← 반드시 실패한다
    maxTokens: 50,
    maxRetries: 0, // 실습이니 재시도로 시간 끌지 않는다
  });
  try {
    await broken.batch(["a", "b", "c"]);
    console.log("여기에 도달하면 안 된다");
  } catch (e) {
    // 3개 중 하나만 실패해도 전체가 throw 한다.
    // 성공한 것들의 결과도 함께 사라진다. 돈은 다 냈는데 손에 남는 게 없다.
    console.log("[fail-fast] 전체가 죽었다:", (e as Error).message.slice(0, 80));
  }
  console.log("");

  /* --- ✅ returnExceptions: true 로 부분 실패를 살려낸다 --- */

  // ❌ deprecated 자리 — maxConcurrency 를 3번째 인자(batchOptions)에 넣은 버전.
  //    @langchain/core 1.2.3 의 타입 정의가 직접 이렇게 말한다:
  //      /** @deprecated Pass in via the standard runnable config object instead */
  //      maxConcurrency?: number;
  //    컴파일도 되고 실행도 된다. 하지만 deprecated 경로다. "돌아간다 ≠ 맞다".
  //
  // await model.batch(questions, {}, { maxConcurrency: 2, returnExceptions: true });

  // ✅ 올바른 자리 — 2번째 인자(config)에 maxConcurrency, 3번째(batchOptions)에 returnExceptions.
  //    두 인자의 역할이 다르다:
  //      2번째 = config       (모델 호출 하나하나에 적용될 설정)
  //      3번째 = batchOptions (배치 자체의 동작)
  const safe = await model.batch(
    questions,
    { maxConcurrency: 2 }, //      ← config
    { returnExceptions: true }, // ← batchOptions
  );
  //    ^? (AIMessage | Error)[]
  // 반환 타입이 AIMessage[] 에서 (AIMessage | Error)[] 로 바뀐다는 점에 주목.
  // 타입 시스템이 "이제 에러를 처리해야 한다"고 강제한다.
  // instanceof Error 체크를 빼먹으면 .text 접근에서 컴파일이 안 된다.
  for (const [i, r] of safe.entries()) {
    if (r instanceof Error) {
      console.log(`[safe ${i}] 실패: ${r.message}`); // 이 항목만 재시도하면 된다
    } else {
      console.log(`[safe ${i}] ${r.text.slice(0, 40)}...`);
    }
  }

  // ⚠️ maxConcurrency 의 기본값은 Infinity 다. 즉 아무 제한이 없다.
  //    model.batch(inputs) 에 1000개를 넣으면 1000개가 동시에 출발한다.
  //    결과는 즉각적인 429 폭격이고, maxRetries 기본값 6이 그 1000개를
  //    각각 최대 6번씩 재시도하면서 상황을 더 악화시킨다.

  console.log("");
}

/* ===== [2-5] 토큰과 비용 — usage_metadata 읽기 ===== */

type Pricing = {
  inputPerMTok: number; // 100만 토큰당 USD
  outputPerMTok: number;
  cacheReadPerMTok: number;
  cacheWritePerMTok: number;
};

/**
 * ⚠️ 단가가 전부 0인 것은 의도된 것이다.
 * 모델 단가는 바뀌고, 새 모델이 나오고, 교재에 박아 두면 반드시 낡는다.
 * 반드시 각 provider 의 공식 가격 페이지에서 확인해 채워 넣어라.
 * 실무에서는 이 표를 설정 파일이나 DB 에 둔다.
 */
const PRICING: Record<string, Pricing> = {
  "anthropic:claude-sonnet-4-6": {
    inputPerMTok: 0,
    outputPerMTok: 0,
    cacheReadPerMTok: 0,
    cacheWritePerMTok: 0,
  },
  "openai:gpt-5.5": {
    inputPerMTok: 0,
    outputPerMTok: 0,
    cacheReadPerMTok: 0,
    cacheWritePerMTok: 0,
  },
};

function estimateCost(usage: UsageMetadata, p: Pricing): number {
  // input_token_details 는 optional 이고, 키가 아예 없을 수도 있다.
  // 타입 정의 주석: "Does *not* need to have all keys."
  // 그래서 ?. 와 ?? 0 이 필수다.
  const cacheRead = usage.input_token_details?.cache_read ?? 0;
  const cacheWrite = usage.input_token_details?.cache_creation ?? 0;

  // ⚠️ 이중 계산 방어 — 이 스텝에서 가장 중요한 한 줄.
  // input_tokens 는 캐시 토큰을 "포함한" 총합이다("Sum of all input token types").
  // 캐시분을 빼야 일반 입력 토큰이 남는다. 안 빼면 캐시 토큰 요금을 두 번 낸다.
  // Math.max(0, ...) 로 감싼 이유: provider 가 details 를 부정확하게 채우면 음수가
  // 나올 수 있고, 음수 토큰이 비용을 깎아 버리면 집계가 조용히 틀린다.
  const plainInput = Math.max(0, usage.input_tokens - cacheRead - cacheWrite);

  return (
    (plainInput / 1_000_000) * p.inputPerMTok +
    (cacheRead / 1_000_000) * p.cacheReadPerMTok +
    (cacheWrite / 1_000_000) * p.cacheWritePerMTok +
    (usage.output_tokens / 1_000_000) * p.outputPerMTok
  );
}

async function section_2_5() {
  console.log("========== [2-5] 토큰과 비용 ==========\n");

  const model = await initChatModel(MODEL_ID, { temperature: 0, maxTokens: 200 });
  const res = await model.invoke("광합성을 한 문장으로 설명해줘.");

  // 필드 이름과 구조는 결정적이다. 토큰 "숫자"만 매번 다르다.
  console.log("usage_metadata:", JSON.stringify(res.usage_metadata, null, 2));

  const usage = res.usage_metadata;
  if (usage) {
    const cost = estimateCost(usage, PRICING[MODEL_ID]);
    console.log(`추정 비용: $${cost.toFixed(6)}  (단가가 0이라 0이 나온다 — 위 PRICING 참고)`);
  }
  console.log("");
}

/* ===== [2-6] reasoning 모델 다루기 ===== */

async function section_2_6() {
  console.log("========== [2-6] reasoning 모델 ==========\n");

  // thinking 은 표준 파라미터가 아니라 Anthropic 고유 파라미터다.
  // 그래서 new ChatAnthropic() 으로 만들어 타입 체크를 받는 편이 안전하다.
  //
  // thinking 의 세 가지 형태:
  //   { type: "enabled", budget_tokens: N }  추론 켬. 최대 N 토큰까지 생각
  //   { type: "disabled" }                   추론 끔. ChatAnthropic 의 기본값
  //   { type: "adaptive" }                   모델이 난이도를 보고 알아서 조절
  //
  // OpenAI 는 이렇게 한다:
  //   new ChatOpenAI({ model: "gpt-5.5", reasoning: { effort: "low" } })
  //   ("low" | "medium" | "high". reasoningEffort 는 deprecated 이니 reasoning.effort 를 쓸 것)
  const model = new ChatAnthropic({
    model: "claude-sonnet-4-6",
    maxTokens: 4000, //                                   ← budget_tokens 보다 넉넉히 크게!
    thinking: { type: "enabled", budget_tokens: 2000 },
  });

  const res = await model.invoke("17 * 24 를 암산하듯 단계별로 계산해줘.");

  // provider 가 달라도 contentBlocks 로 표준화되어 나온다.
  // Anthropic 은 thinking 블록으로, OpenAI 는 reasoning 블록으로 주지만
  // contentBlocks 를 거치면 둘 다 type: "reasoning" 이다.
  const reasoning = res.contentBlocks.filter((b) => b.type === "reasoning");
  console.log("--- 추론 과정 (res.text 에는 안 들어 있다) ---");
  console.log(
    reasoning
      .map((b) => (b as { reasoning?: string }).reasoning ?? "")
      .join("\n")
      .slice(0, 300) + "...",
  );
  console.log("");
  console.log("--- 최종 답변 ---");
  console.log(res.text);
  console.log("");

  // 추론 토큰: 출력으로 돌려주지 않는데 output_tokens 에는 포함되고, 요금은 낸다.
  // 타입 주석: "Tokens generated by the model in a chain of thought process
  //            ... that are not returned as part of model output."
  const u = res.usage_metadata;
  console.log(`출력 토큰 합계: ${u?.output_tokens ?? 0}`);
  console.log(`  그중 추론   : ${u?.output_token_details?.reasoning ?? 0}  ← 화면에 못 쓰는데 요금은 냄`);
  console.log(
    `  실제 답변   : ${(u?.output_tokens ?? 0) - (u?.output_token_details?.reasoning ?? 0)}`,
  );
  console.log("");

  /* --- ⚠️ 함정: maxTokens 가 추론 토큰을 포함한다 --- */
  // maxTokens: 2100 + budget_tokens: 2000 → 답변에 쓸 공간이 100 토큰뿐이다.
  // 생각만 하다 답을 못 내고 stop_reason: "max_tokens" 로 잘린다.
  // 생각 값은 다 치르고 답은 못 받는 최악의 조합.
  const tight = new ChatAnthropic({
    model: "claude-sonnet-4-6",
    maxTokens: 2100, //                                   ← budget_tokens 보다 겨우 100 큼
    thinking: { type: "enabled", budget_tokens: 2000 },
  });
  const squeezed = await tight.invoke("17 * 24 를 암산하듯 단계별로 계산해줘.");
  inspect(squeezed, "maxTokens: 2100 / budget_tokens: 2000 (잘림 예상)");

  // 그 밖의 reasoning 함정 (본문 2-6 참고):
  //  - reasoning 모델은 temperature 를 무시한다. @langchain/openai 의 reasoning JSDoc:
  //    "These options will be ignored when not using a reasoning model."
  //  - Anthropic 은 thinking 이 켜져 있으면 temperature 를 함께 쓸 수 없다.
  //  - thinking 이 켜진 채 withStructuredOutput() 을 쓰면 콘솔 경고가 뜨고,
  //    (에러가 아니라 경고다!) 어느 날 갑자기 OutputParserException 이 터진다. Step 05 참고.
}

/* ===== [2-7] 모델 선택 가이드 — 라우터 패턴 ===== */

async function section_2_7() {
  console.log("========== [2-7] 모델 선택 — 라우터 패턴 ==========\n");

  // 실무의 정석은 "모델 하나 고르기"가 아니라 "역할별로 나누기"다.
  // 2-1 에서 말한 추상화의 값어치가 여기서 현금화된다.
  const router = await initChatModel("anthropic:claude-haiku-4-5", {
    temperature: 0,
    maxTokens: 20,
  });
  const worker = await initChatModel("anthropic:claude-sonnet-4-6", {
    temperature: 0,
    maxTokens: 200,
  });

  for (const q of ["오늘 날씨 어때?", "분산 시스템에서 합의 알고리즘의 트레이드오프를 분석해줘"]) {
    const intent = (
      await router.invoke(`다음을 [단순질문|복잡분석] 중 하나로만 분류. 다른 말 금지: ${q}`)
    ).text;

    // 라우팅 결과에 따라 모델을 고른다. 호출 코드는 어느 쪽이든 똑같다.
    const model = intent.includes("복잡분석") ? worker : router;
    const label = intent.includes("복잡분석") ? "sonnet(큰 모델)" : "haiku(작은 모델)";

    const answer = await model.invoke(q);
    console.log(`질문: ${q}`);
    console.log(`  분류: ${intent.trim()} → ${label}`);
    console.log(`  답변: ${answer.text.slice(0, 60)}...`);
    console.log("");
  }

  // 트래픽의 80% 가 단순 질문이면 비용이 극적으로 줄어든다.
  // 라우팅 자체의 비용은 무시할 만하다.
  //
  // 순서도 중요하다: 큰 모델로 먼저 "되는 것"을 확인한 뒤, 구간별로 작은 모델로
  // 내려보며 품질이 유지되는 지점을 찾아라. 처음부터 작은 모델로 시작하면
  // "모델이 약해서 안 되는 건지 내 프롬프트가 틀린 건지" 구분이 안 된다.
  // 일단 되게 만들고, 그 다음에 싸게 만들어라.
}

/* ===== [2-8] provider 교체 실습 — 같은 코드로 anthropic ↔ openai ===== */

/**
 * 이 함수는 provider 를 전혀 모른다. 모델 인터페이스만 안다.
 * batch, usage_metadata.input_tokens, text — 전부 표준 인터페이스다.
 */
async function askAll(
  model: Awaited<ReturnType<typeof initChatModel>>,
  questions: string[],
  label: string,
) {
  const results = await model.batch(questions, { maxConcurrency: 2 }, { returnExceptions: true });

  let totalIn = 0;
  let totalOut = 0;
  console.log(`--- ${label} ---`);
  for (const [i, r] of results.entries()) {
    if (r instanceof Error) {
      console.log(`[${i}] 실패: ${r.message.slice(0, 60)}`);
      continue;
    }
    totalIn += r.usage_metadata?.input_tokens ?? 0;
    totalOut += r.usage_metadata?.output_tokens ?? 0;
    console.log(`[${i}] ${r.text.slice(0, 50)}...`);
  }
  console.log(`합계: 입력 ${totalIn} / 출력 ${totalOut} 토큰`);
  console.log("");
}

async function section_2_8() {
  console.log("========== [2-8] provider 교체 ==========\n");

  const questions = ["광합성을 한 문장으로", "중력을 한 문장으로"];

  // provider 를 문자열로만 바꾼다. askAll 은 한 글자도 안 바뀐다.
  await askAll(
    await initChatModel("anthropic:claude-sonnet-4-6", { temperature: 0, maxTokens: 200 }),
    questions,
    "anthropic:claude-sonnet-4-6",
  );

  // OPENAI_API_KEY 와 @langchain/openai 가 있어야 동작한다.
  // provider 를 바꾼다고 API 키가 자동으로 생기지는 않는다.
  if (process.env.OPENAI_API_KEY) {
    await askAll(
      await initChatModel("openai:gpt-5.5", { temperature: 0, maxTokens: 200 }),
      questions,
      "openai:gpt-5.5",
    );
  } else {
    console.log("(OPENAI_API_KEY 가 없어 OpenAI 비교는 건너뜁니다)\n");
  }

  // 환경변수로 빼면 배포 설정만으로 모델을 바꿀 수 있다:
  //   MODEL="anthropic:claude-sonnet-4-6" npx tsx practice.ts
  //   MODEL="openai:gpt-5.5"              npx tsx practice.ts
  //
  // ⚠️ 다만 교체되는 건 인터페이스지 동작이 아니다. 코드가 그대로 돈다고
  //    결과가 같지는 않다. 프롬프트 민감도, temperature 범위(0~1 vs 0~2),
  //    무시되는 파라미터(topK), response_metadata 필드명(stop_reason vs finish_reason)이
  //    전부 함께 바뀐다. 바꿨으면 반드시 평가를 다시 돌려라(Step 19).
}

/* ===== [2-9] 종합 — 캐싱 ===== */

async function section_2_9() {
  console.log("========== [2-9] 캐싱 ==========\n");

  // LangChain 캐시: 정확히 같은 프롬프트면 모델 호출 자체를 건너뛴다.
  // 2-3 에서 "temperature: 0 은 결정성을 보장하지 않는다"고 했다. 캐시는 보장한다.
  const cache = new InMemoryCache();
  const model = new ChatAnthropic({
    model: "claude-sonnet-4-6",
    maxTokens: 200,
    cache, // 또는 그냥 cache: true
  });

  const prompt = "광합성을 한 문장으로 설명해줘.";

  console.time("1회차");
  const first = await model.invoke(prompt);
  console.timeEnd("1회차"); // ← 실제 호출. 보통 1~3초.

  console.time("2회차");
  const second = await model.invoke(prompt);
  console.timeEnd("2회차"); // ← 캐시 히트. 네트워크를 아예 안 탄다. 보통 1ms 미만.

  console.log("");
  console.log("두 응답이 완전히 같은가?:", first.text === second.text); // true — 캐시니까

  /* --- ⚠️ 함정: 캐시 히트 시 usage_metadata 가 "재생"된다 --- */
  console.log("1회차 usage:", first.usage_metadata);
  console.log("2회차 usage:", second.usage_metadata);
  // → 두 값이 똑같다! 하지만 2회차는 실제로 API 를 안 불렀으니 비용이 0원이다.
  //   비용 집계 코드는 요금이 발생한 것처럼 센다.
  //   캐시 적중률이 높은 개발 환경에서 비용 대시보드가 실제보다 부풀려 보이는 원인이 이것이다.
  //
  // ⚠️ InMemoryCache 는 이름 그대로 메모리에만 있다.
  //    프로세스가 죽으면 다 날아가고, 서버 여러 대에 걸쳐 공유되지도 않는다.
  //    (Step 10 의 MemorySaver 와 정확히 같은 성질이다.)
  console.log("");

  /* --- provider 프롬프트 캐시 (cache_control) — 위 LangChain 캐시와 전혀 다른 물건 --- */
  // LangChain 캐시     : 내 프로세스 안. 프롬프트가 완전히 동일할 때. API 호출 안 함. 비용 0원.
  // provider 프롬프트 캐시: provider 서버. 프롬프트 "접두사"가 동일할 때. API 호출 함. 할인된 입력 단가.
  const LONG_TEXT = "LangChain 은 LLM 애플리케이션을 만드는 프레임워크입니다. ".repeat(120);

  const cachingModel = new ChatAnthropic({ model: "claude-sonnet-4-6", maxTokens: 100 });
  const messages = [
    {
      role: "system",
      content: [
        {
          type: "text",
          text: LONG_TEXT, //                     길고, 매 요청 동일한 내용
          cache_control: { type: "ephemeral" }, // ← 여기까지 캐시
        },
      ],
    },
    { role: "user", content: "이 문서를 한 문장으로 요약해줘." },
  ];

  const p1 = await cachingModel.invoke(messages);
  console.log("프롬프트 캐시 1회차:", p1.usage_metadata?.input_token_details);
  // 예: { cache_creation: 2431, cache_read: 0 }     ← 캐시 만듦 (일반 입력보다 비쌈!)

  const p2 = await cachingModel.invoke(messages);
  console.log("프롬프트 캐시 2회차:", p2.usage_metadata?.input_token_details);
  // 예: { cache_creation: 0,    cache_read: 2431 }  ← 캐시 읽음 (쌈)

  // ⚠️ 프롬프트 캐시는 접두사(prefix) 매칭이다. 앞에서부터 한 글자라도 다르면
  //    그 지점 이후는 전부 캐시 미스다. 그래서 프롬프트를 이렇게 배치해야 한다:
  //      [불변] 시스템 프롬프트, 도구 정의, 참고 문서   ← cache_control 을 여기 끝에
  //      [가변] 대화 이력
  //      [가변] 이번 사용자 입력
  //
  //    흔한 실수는 맨 앞에 타임스탬프나 요청 ID 를 넣는 것이다.
  //    "현재 시각: 2026-07-17 14:23:11" 한 줄이 맨 앞에 있으면 캐시가 영원히 100% 미스한다.
  //    게다가 캐시 생성 단가는 일반 입력보다 비싸므로 캐시를 켜기 전보다 오히려 비싸진다.
  //    이 함정은 에러도 안 내고 로그도 안 남긴다 — cache_read 가 계속 0 인 것으로만 알 수 있다.
  //    캐시를 켰다면 cache_read 를 반드시 모니터링하라.

  console.log("");
  inspect(p2, "종합 — 계측 헬퍼로 전부 해부");
}

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

async function main() {
  // ⚠️ 실제 API 를 호출하므로 요금이 발생합니다.
  //    반복 실행할 때는 필요한 블록만 남기고 주석 처리하세요.
  await section_2_1();
  await section_2_2();
  await section_2_3();
  await section_2_4();
  await section_2_5();
  await section_2_6();
  await section_2_7();
  await section_2_8();
  await section_2_9();
}

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

/**
 * Step 02 — 챗 모델과 파라미터 · 연습문제
 * 실행: npx tsx docs/reference/langchain/step-02-chat-models/exercise.ts
 *
 * 사용법:
 *   1. 아래 [문제 N] 블록의 TODO 를 채운다.
 *   2. main() 하단에서 해당 문제의 주석을 풀고 실행한다.
 *      → 8개를 한꺼번에 돌리면 API 호출이 20번 넘게 나가고
 *        어느 출력이 어느 문제 것인지 알 수 없게 된다. 한 문제씩 풀 것.
 *   3. 다 풀었으면 solution.ts 로 채점한다.
 *
 * 주의: 실제 API 를 호출하므로 요금이 발생합니다.
 */
import "dotenv/config";

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

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

/* ===== [문제 1] await 를 빼면 무슨 일이 일어나나 ===== */
/**
 * initChatModel 로 anthropic:claude-sonnet-4-6 모델을 만들되 await 를 빼고
 * 호출해 보세요. 어떤 에러가 나나요? 주석으로 적고, 고치세요.
 *
 * 힌트: initChatModel 이 왜 Promise 를 돌려주는지 생각해 보세요.
 *      new ChatAnthropic() 은 왜 await 가 필요 없을까요?
 */
async function q1() {
  console.log("===== [문제 1] await 누락 =====");

  // TODO: await 없이 initChatModel 을 부르고 invoke 를 시도하세요.
  //       try/catch 로 감싸서 에러 메시지를 출력하세요.

  // → 에러 메시지를 여기에 적으세요:
  //   (답:                                                          )

  // TODO: 위 코드를 올바르게 고치세요.
}

/* ===== [문제 2] 잘림 판정 함수 ===== */
/**
 * maxTokens: 20 을 주고 "광합성을 자세히 설명해줘"라고 물어보세요.
 * res.text 와 res.response_metadata.stop_reason 을 함께 출력해,
 * 응답이 잘렸는지 판정하는 함수 isTruncated(res): boolean 을 완성하세요.
 *
 * 조건: Anthropic 과 OpenAI 양쪽에서 동작해야 합니다.
 *      stop_reason 하나만 보면 절반짜리 답입니다.
 */
function isTruncated(res: AIMessage): boolean {
  const meta = res.response_metadata as Record<string, unknown>;

  // 힌트: 먼저 이 줄로 response_metadata 에 실제로 어떤 키가 들어 있는지 보세요.
  console.log("  response_metadata:", JSON.stringify(meta, null, 2));

  // TODO: Anthropic 과 OpenAI 양쪽에서 동작하는 잘림 판정을 구현하세요.
  return false;
}

async function q2() {
  console.log("===== [문제 2] 잘림 판정 =====");

  // TODO: maxTokens: 20 인 모델을 만들어 긴 답을 요구하고,
  //       text 와 isTruncated() 결과를 출력하세요.
}

/* ===== [문제 3] temperature: 0 이 결정적인가? ===== */
/**
 * 같은 프롬프트를 temperature: 0 으로 5번 호출해 응답을 모으세요.
 * 서로 다른 응답이 몇 종류 나왔나요? new Set(texts).size 로 세어 보세요.
 *
 * 주의: 이 문제는 정답이 하나로 정해져 있지 않습니다.
 *      1 이 나와도 정상이고 3 이 나와도 정상입니다.
 *      중요한 건 숫자가 아니라 "1 이 보장되지 않는다"는 사실입니다.
 */
async function q3() {
  console.log("===== [문제 3] temperature: 0 의 비결정성 =====");

  // TODO: temperature: 0 인 모델로 같은 프롬프트를 5번 호출하고,
  //       new Set(texts).size 로 서로 다른 응답의 종류 수를 세세요.
  //       (힌트: batch 를 쓰면 5번을 한 번에 보낼 수 있습니다)

  // → 여러분의 결과를 여기에 적어 두고 나중에 다시 돌려 비교해 보세요:
  //   (1회차 결과:      종류 / 2회차 결과:      종류)
}

/* ===== [문제 4] batch 부분 실패 살려내기 ===== */
/**
 * 질문 4개를 batch 로 처리하되, 하나는 반드시 실패하도록 만드세요.
 * (힌트: 존재하지 않는 모델 이름을 쓴 모델 인스턴스를 섞으세요)
 *
 * (a) returnExceptions 없이 먼저 돌려 전체가 죽는 걸 확인하세요.
 * (b) returnExceptions: true 와 maxConcurrency: 2 를 올바른 인자 자리에 넣어
 *     성공한 것만 살려내세요.
 *
 * ⚠️ maxConcurrency 와 returnExceptions 는 서로 다른 인자에 들어갑니다.
 *    본문 2-4 의 함정 블록을 다시 보세요.
 */
async function q4() {
  console.log("===== [문제 4] batch 부분 실패 =====");

  // (a) fail-fast 확인
  // 아래는 일부러 프로그램을 죽이는 코드입니다.
  // catch 에 들어왔다는 것 자체가 "성공한 것들도 함께 사라졌다"는 증거입니다.
  const broken = new ChatAnthropic({
    model: "this-model-does-not-exist",
    maxTokens: 50,
    maxRetries: 0,
  });
  try {
    // TODO: broken.batch(...) 로 4개를 보내 전체가 죽는 것을 확인하세요.
  } catch (e) {
    console.log("(a) 전체가 죽었다:", (e as Error).message.slice(0, 80));
  }

  // (b) returnExceptions 로 살려내기
  // TODO: 정상 모델로 batch 를 호출하되
  //       - maxConcurrency: 2 를 올바른 인자 자리에
  //       - returnExceptions: true 를 올바른 인자 자리에
  //       넣고, instanceof Error 로 성공/실패를 갈라 출력하세요.
}

/* ===== [문제 5] 비용 계산 ===== */
/**
 * usage_metadata 를 받아 비용을 계산하는 estimateCost(usage, pricing) 를 구현하세요.
 *
 * 조건:
 *   - 캐시 토큰 이중 계산을 피해야 합니다.
 *     (input_tokens 는 캐시분을 "포함한" 총합입니다!)
 *   - input_token_details 가 아예 없는 경우에도 터지지 않아야 합니다.
 *
 * 힌트: input_token_details 는 optional 입니다. ?. 와 ?? 0 없이는
 *      컴파일이 안 될 겁니다 — 그 컴파일 에러가 곧 힌트입니다.
 */
type Pricing = {
  inputPerMTok: number; // 100만 토큰당 USD
  outputPerMTok: number;
  cacheReadPerMTok: number;
  cacheWritePerMTok: number;
};

// 실제 단가는 공식 가격 페이지에서 확인해 채우세요.
// 여기서는 계산이 맞는지 보기 위해 임의의 값을 씁니다.
const DEMO_PRICING: Pricing = {
  inputPerMTok: 3,
  outputPerMTok: 15,
  cacheReadPerMTok: 0.3,
  cacheWritePerMTok: 3.75,
};

function estimateCost(usage: UsageMetadata, p: Pricing): number {
  // TODO: 구현하세요.
  //   1. cache_read, cache_creation 을 안전하게 꺼낸다 (없을 수 있다)
  //   2. input_tokens 에서 캐시분을 빼서 "일반 입력 토큰"을 구한다  ← 핵심!
  //   3. 각 종류별로 단가를 곱해 더한다
  return 0;
}

async function q5() {
  console.log("===== [문제 5] 비용 계산 =====");

  // 검산용 가짜 usage — 이 값으로 먼저 손계산과 맞춰 보세요.
  const fake: UsageMetadata = {
    input_tokens: 10_000, // 이 안에 캐시 3000 + 캐시생성 2000 이 포함되어 있다
    output_tokens: 1_000,
    total_tokens: 11_000,
    input_token_details: { cache_read: 3_000, cache_creation: 2_000 },
  };
  // 기대값: 일반입력 5000 → 5000/1e6*3     = 0.015
  //        캐시읽기 3000 → 3000/1e6*0.3   = 0.0009
  //        캐시생성 2000 → 2000/1e6*3.75  = 0.0075
  //        출력    1000 → 1000/1e6*15     = 0.015
  //        합계                            = 0.0384
  console.log("가짜 usage 비용:", estimateCost(fake, DEMO_PRICING).toFixed(6), "(기대: 0.038400)");

  // details 가 아예 없는 경우에도 터지면 안 된다
  const noDetails: UsageMetadata = { input_tokens: 100, output_tokens: 50, total_tokens: 150 };
  console.log("details 없는 usage:", estimateCost(noDetails, DEMO_PRICING).toFixed(6));

  // TODO: 실제 모델을 호출해 진짜 usage_metadata 로도 계산해 보세요.
}

/* ===== [문제 6] 스트리밍에서 토큰 수 얻기 ===== */
/**
 * stream 으로 응답을 받으면서, 각 청크의 usage_metadata 를 출력해 보세요.
 * 대부분 undefined 인 것을 확인한 뒤, 청크를 concat 으로 합쳐
 * 최종 토큰 수를 얻으세요.
 */
async function q6() {
  console.log("===== [문제 6] 스트리밍 토큰 =====");

  // TODO:
  //   1. model.stream(...) 으로 청크를 순회하며 chunk.text 를 출력한다
  //   2. 각 청크의 chunk.usage_metadata 도 함께 출력해 대부분 undefined 임을 확인한다
  //   3. concat 으로 청크를 누적해 최종 usage_metadata 를 얻어 출력한다
}

/* ===== [문제 7] reasoning 모델 ===== */
/**
 * ChatAnthropic 에 thinking: { type: "enabled", budget_tokens: 2000 } 과
 * maxTokens: 4000 을 주고 "17 × 24 를 계산해줘"라고 물어보세요.
 *
 * (a) contentBlocks 에서 type: "reasoning" 블록을 뽑아 출력하세요.
 * (b) output_token_details.reasoning 토큰 수를 출력하세요.
 * (c) res.text 에 추론 내용이 포함되지 않는다는 걸 확인하세요.
 * (d) maxTokens 를 2100 으로 낮춰 다시 돌려 stop_reason 이 어떻게 되는지 보세요.
 *
 * ⚠️ (d) 를 빼먹지 마세요. budget_tokens 와 maxTokens 의 관계를
 *    몸으로 아는 유일한 방법입니다.
 */
async function q7() {
  console.log("===== [문제 7] reasoning 모델 =====");

  // TODO (a)(b)(c): maxTokens: 4000, budget_tokens: 2000 으로 호출하고
  //                 추론 블록 / 추론 토큰 수 / 최종 텍스트를 각각 출력하세요.

  // TODO (d): maxTokens 를 2100 으로 낮춰 다시 호출하고 stop_reason 을 출력하세요.
  //           무슨 일이 일어났나요?
  //   (답:                                                          )
}

/* ===== [문제 8] provider 를 모르는 함수 ===== */
/**
 * askAll(model, questions) 함수를 만들되 provider 를 전혀 모르게 작성하고,
 * anthropic:claude-sonnet-4-6 과 openai:gpt-5.5 양쪽으로 각각 호출해
 * 토큰 합계를 비교하세요.
 *
 * (OpenAI 키가 없다면 Anthropic 의 큰 모델과 작은 모델로 대체해도 됩니다.)
 *
 * 조건: askAll 안에 "anthropic" 이나 "openai" 라는 문자열이 등장하면 안 됩니다.
 */
async function askAll(
  model: Awaited<ReturnType<typeof initChatModel>>,
  questions: string[],
  label: string,
) {
  // TODO: batch 로 questions 를 처리하고, 각 응답의 text 와
  //       usage_metadata 의 input_tokens / output_tokens 를 누적해 합계를 출력하세요.
  //       returnExceptions 와 maxConcurrency 도 올바르게 넣으세요.
}

async function q8() {
  console.log("===== [문제 8] provider 교체 =====");

  const questions = ["광합성을 한 문장으로", "중력을 한 문장으로"];

  // TODO: initChatModel 로 두 provider(또는 두 크기의 모델)를 만들어
  //       각각 askAll 에 넘기고 토큰 합계를 비교하세요.
}

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

async function main() {
  // 한 문제씩 주석을 풀어 가며 푸세요.
  // await q1();
  // await q2();
  // await q3();
  // await q4();
  // await q5();
  // await q6();
  // await q7();
  // await q8();
}

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