#Step 07 — 시스템 프롬프트 설계

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [getStockPrice],
  systemPrompt: "당신은 주식 리서치 어시스턴트입니다.",
});

// deepagents 내부 (개념적으로)
function normalizeSystemPrompt(systemPrompt) {
  if (systemPrompt === undefined) return {};
  if (typeof systemPrompt === "string" || SystemMessage.isInstance(systemPrompt))
    return { prefix: systemPrompt };   // ← 문자열은 prefix 가 된다
  return systemPrompt;
}

import { createMiddleware } from "langchain";

function makePromptSpy(label: string) {
  return createMiddleware({
    name: "PromptSpyMiddleware",
    wrapModelCall: async (request, handler) => {
      const text = request.systemMessage.text ?? "";
      console.log(`===== [${label}] 최종 시스템 프롬프트 (${text.length}자) =====`);
      console.log(text);
      return handler(request);
    },
  });
}

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  systemPrompt: "### MY-PREFIX-MARKER ###\n당신은 주식 리서치 어시스턴트입니다.",
  middleware: [makePromptSpy("7-2")],
});

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

interface SystemPromptConfig {
  /** base 프롬프트 앞에 놓일 내용 */
  prefix?: string | SystemMessage | null;
  /**
   * 활성 base 프롬프트의 교체물.
   * 이 필드를 생략하면 하네스 프로파일 base 또는 내장 base 프롬프트가 유지된다.
   * null 로 두면 base 프롬프트를 완전히 생략한다.
   */
  base?: string | SystemMessage | null;
  /** base 뒤, 하네스 프로파일 suffix 앞에 놓일 내용 */
  suffix?: string | SystemMessage | null;
}

// createDeepAgent 의 시그니처
systemPrompt?: string | SystemMessage | SystemPromptConfig;

// (A) base 교체 — 내장 인격은 버리고 내 매뉴얼로 대체
const replaced = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  systemPrompt: {
    prefix: "### PREFIX ###",
    base: "### 내가 직접 쓴 BASE 프롬프트. 내장 Deep Agent 프롬프트는 사라졌다. ###",
    suffix: "### SUFFIX ###",
  },
});

// (B) base 제거 — 내장 base 없이 내 prefix 만
const removed = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  systemPrompt: {
    prefix: "당신은 사내 규정만 인용해 답하는 컴플라이언스 봇입니다. 추측 금지.",
    base: null,
  },
});

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [getStockPrice],
  subagents: [
    {
      name: "ticker-checker",
      description: "티커 심볼이 유효한지만 확인하는 서브에이전트",
      systemPrompt: "티커가 유효한지 한 줄로만 답하세요.",
      tools: [getStockPrice],
    },
  ],
  systemPrompt: "당신은 주식 리서치 어시스턴트입니다.",
  middleware: [makePromptSpy("7-4 전체 조립본")],
});

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

const GOOD_PREFIX = `당신은 주식 리서치 어시스턴트입니다. (역할)

## 워크플로
1. 사용자가 요청한 티커를 확인한다.
2. get_stock_price 로 각 티커의 가격을 조회한다. 여러 개면 **반드시 병렬로** 호출한다.
3. 조회 결과를 표로 정리한다.
4. 마지막에 한 줄 코멘트를 단다.

## 도구 사용 규칙
- 가격은 절대 기억이나 추측으로 말하지 않는다. 반드시 get_stock_price 결과만 인용한다.
- get_stock_price 가 "Unknown ticker" 를 반환하면 그 티커는 "조회 불가" 로 표기하고 넘어간다.
- 티커가 3개 이상이면 write_todos 로 계획을 먼저 세운다.

## 출력 형식
| 티커 | 가격(USD) |
|---|---|
| ... | ... |

표 아래에 코멘트 한 줄. 그 외 서론/맺음말 금지.

## 중단 조건
- 모든 티커의 가격을 표에 채웠으면 즉시 종료한다.
- 같은 도구를 같은 인자로 두 번 부르지 않는다.
- 사용자가 티커를 하나도 주지 않았으면 조회하지 말고 티커를 되묻는다.`;

const BAD_PREFIX = "주식 도와줘.";

const question = "AAPL, NVDA, TSLA 가격 비교해줘.";

for (const [label, prompt] of [
  ["BAD ", BAD_PREFIX],
  ["GOOD", GOOD_PREFIX],
] as const) {
  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    tools: [getStockPrice],
    systemPrompt: prompt,
  });

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

  const toolCalls = result.messages.filter((m) => m.getType() === "tool").length;
  const answer = result.messages.at(-1)?.text ?? "";

  console.log(`\n--- ${label} ---`);
  console.log(`도구호출=${toolCalls} 메시지수=${result.messages.length} 응답길이=${answer.length}`);
  console.log(answer);
}

import { registerHarnessProfile, getHarnessProfile } from "deepagents";

registerHarnessProfile("anthropic:claude-sonnet-4-6", {
  systemPromptSuffix: "### PROFILE-SUFFIX ### 모든 답변은 한국어로, 200자 이내로 하세요.",
  generalPurposeSubagent: { enabled: false },
});

// createDeepAgent 호출부는 하나도 안 바꿨는데 프롬프트 끝에 suffix 가 붙는다
const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  systemPrompt: "당신은 주식 리서치 어시스턴트입니다.",
});

import { parseHarnessProfileConfig, registerHarnessProfile, serializeProfile } from "deepagents";
import YAML from "yaml";

const raw = YAML.parse(fileContent);
registerHarnessProfile("openai", parseHarnessProfileConfig(raw));

// 반대로 직렬화 (extraMiddleware 에 인스턴스가 들어있으면 실패합니다)
const json = serializeProfile(getHarnessProfile("openai"));

type Case = { question: string; expect: (answer: string) => boolean; why: string };

const CASES: Case[] = [
  {
    question: "AAPL 가격 알려줘.",
    expect: (a) => a.includes("231.4"),
    why: "도구가 준 실제 가격을 인용해야 함",
  },
  {
    question: "TSLA 가격 알려줘.",
    expect: (a) => /조회 불가|Unknown|알 수 없/.test(a),
    why: "모르는 티커를 지어내면 안 됨",
  },
  {
    question: "주식 좀 알려줘.",
    expect: (a) => /어떤|티커|종목/.test(a),
    why: "티커가 없으면 되물어야 함",
  },
];

async function evalPrompt(label: string, systemPrompt: string) {
  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    tools: [getStockPrice],
    systemPrompt,
  });

  let pass = 0;
  for (const c of CASES) {
    const r = await agent.invoke({ messages: [{ role: "user", content: c.question }] });
    const answer = r.messages.at(-1)?.text ?? "";
    const ok = c.expect(answer);
    if (ok) pass += 1;
    console.log(`  [${ok ? "PASS" : "FAIL"}] ${c.question}  (${c.why})`);
  }
  console.log(`  ${label}: ${pass}/${CASES.length}`);
  return pass;
}

await evalPrompt("v1", BAD_PREFIX);
await evalPrompt("v2", GOOD_PREFIX);

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  systemPrompt: {
    prefix: `당신은 TypeScript 코드 리뷰어입니다.

## 워크플로
1. /src 를 ls 로 훑어 구조를 파악한다.
2. 리뷰 대상 파일을 read_file 로 읽는다.
3. 문제를 심각도(HIGH/MEDIUM/LOW)로 분류한다.
4. /review.md 에 결과를 write_file 로 저장한다.

## 도구 사용 규칙
- 파일을 읽지 않고 리뷰하지 않는다. 추측 금지.
- 파일 경로는 항상 /로 시작한다.

## 출력 형식
심각도별 불릿. 각 항목은 "파일:라인 — 문제 — 제안" 형식.

## 중단 조건
- /review.md 를 쓴 뒤 즉시 종료한다. 같은 파일을 두 번 읽지 않는다.`,
    base: null,   // 내장 Deep Agent 인격을 걷어내고 내 규칙만 남긴다
    suffix: "리뷰는 반드시 한국어로 작성한다.",
  },
});

const result = await agent.invoke({
  messages: [{
    role: "user",
    content:
      "먼저 /src/util.ts 에 다음 코드를 저장하고 리뷰해줘:\n" +
      "export function sum(a: any, b: any) { return a + b }\n" +
      "export async function load(url: string) { const r = await fetch(url); return r.json() }",
  }],
});

console.log(result.messages.at(-1)?.text);
console.log("생성된 파일 목록:", Object.keys(result.files ?? {}));

/**
 * Step 07 — 시스템 프롬프트 설계
 * 실행: npx tsx docs/reference/deepagent/step-07-prompting/practice.ts
 *
 * 검증 버전: deepagents 1.11.0 / langchain 1.5.3 / @langchain/anthropic 1.5.1
 *
 * 이 파일은 본문 7-1 ~ 7-9 의 예제를 순서대로 담고 있습니다.
 * 위에서부터 차례로 실행되며, 각 블록은 독립적으로 잘라내 써도 됩니다.
 *
 * 필요 환경변수: ANTHROPIC_API_KEY
 *   (OpenAI 를 쓰려면 model 을 "openai:gpt-5.5" 로 바꾸고 OPENAI_API_KEY 를 설정하세요)
 */
import "dotenv/config";
import { createDeepAgent, registerHarnessProfile, getHarnessProfile } from "deepagents";
import { createMiddleware, tool } from "langchain";
import * as z from "zod";

/* ===== 공용 준비물 ===== */

/**
 * 조립된 최종 시스템 프롬프트를 가로채서 찍어보는 미들웨어.
 *
 * `wrapModelCall` 훅은 모델 호출 직전에 `request` 를 받습니다.
 * `request.systemMessage` 가 **미들웨어까지 전부 반영된 최종 시스템 메시지**입니다.
 * 이 스텝 내내 "실제로 모델에게 뭐가 갔는가" 를 확인하는 데 씁니다.
 */
function makePromptSpy(label: string) {
  return createMiddleware({
    name: "PromptSpyMiddleware",
    wrapModelCall: async (request, handler) => {
      const text = request.systemMessage.text ?? "";
      console.log(`\n===== [${label}] 최종 시스템 프롬프트 (${text.length}자) =====`);
      console.log(text);
      console.log(`===== [${label}] 끝 =====\n`);
      // 한 번만 찍고 싶으면 여기서 플래그를 세우세요. 매 모델 호출마다 찍힙니다.
      return handler(request);
    },
  });
}

/** 프롬프트 길이/포함 여부만 요약해서 찍는 가벼운 버전 (A/B 비교용) */
function makePromptSummarySpy(label: string) {
  return createMiddleware({
    name: "PromptSpyMiddleware",
    wrapModelCall: async (request, handler) => {
      const text = request.systemMessage.text ?? "";
      console.log(
        `[${label}] 길이=${text.length} | 내장기반="${text.includes("You are a Deep Agent")}" ` +
          `| todo지침=${text.includes("write_todos") || text.includes("todo")} ` +
          `| 파일지침=${text.includes("Filesystem Tools")} ` +
          `| task지침=${text.includes("subagent spawner")}`,
      );
      return handler(request);
    },
  });
}

/** 예제 내내 재사용할 간단한 도구 하나 */
const getStockPrice = tool(
  ({ ticker }: { ticker: string }) => {
    // 실제 API 대신 고정값. 이 스텝의 관심사는 프롬프트지 도구가 아닙니다.
    const table: Record<string, number> = { AAPL: 231.4, MSFT: 512.9, NVDA: 178.2 };
    const price = table[ticker.toUpperCase()];
    return price === undefined
      ? `Unknown ticker: ${ticker}`
      : `${ticker.toUpperCase()} = ${price} USD`;
  },
  {
    name: "get_stock_price",
    description: "티커 심볼로 현재 주가를 조회합니다. 예: AAPL, MSFT, NVDA",
    schema: z.object({ ticker: z.string().describe("주식 티커 심볼") }),
  },
);

/* ===== [7-1] 네 번째 기둥 — 상세한 시스템 프롬프트 ===== */
/**
 * 같은 모델, 같은 도구. 프롬프트만 다릅니다.
 * "한 줄짜리 프롬프트" 와 "상세한 프롬프트" 가 얼마나 다르게 행동하는지 뒤(7-6)에서 A/B 로 봅니다.
 * 여기서는 우선 Deep Agent 의 기본 동작을 확인합니다.
 */
async function step7_1() {
  console.log("\n########## [7-1] 기본 Deep Agent ##########");

  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    tools: [getStockPrice],
    systemPrompt: "당신은 주식 리서치 어시스턴트입니다.",
  });

  const result = await agent.invoke({
    messages: [{ role: "user", content: "AAPL 주가 알려줘." }],
  });

  console.log(result.messages.at(-1)?.text);
}

/* ===== [7-2] 프롬프트 조립 구조 — systemPrompt 는 prefix 다 ===== */
/**
 * 핵심: `systemPrompt: "문자열"` 은 내장 프롬프트를 **교체하지 않습니다.**
 * 내부적으로 `{ prefix: "문자열" }` 로 정규화되어 내장 프롬프트 **앞**에 붙습니다.
 *
 * 아래를 실행하면 내 문장이 맨 앞에 있고, 그 뒤로
 * "You are a Deep Agent, ..." 로 시작하는 내장 프롬프트가 그대로 이어지는 것을 볼 수 있습니다.
 */
async function step7_2() {
  console.log("\n########## [7-2] systemPrompt 는 prefix 다 ##########");

  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    systemPrompt: "### MY-PREFIX-MARKER ###\n당신은 주식 리서치 어시스턴트입니다.",
    middleware: [makePromptSpy("7-2 문자열 systemPrompt")],
  });

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

/* ===== [7-3] { prefix, base, suffix } — 구조체로 완전 제어 ===== */
/**
 * SystemPromptConfig = { prefix?, base?, suffix? }
 * 조립 순서: prefix → base → suffix → (하네스 프로파일의 systemPromptSuffix)
 * 구분자는 빈 줄 두 개("\n\n").
 *
 * - base 를 **생략**하면       → 내장 base 프롬프트 유지 (기본값)
 * - base: "내 문자열" 이면      → 내장 base 를 내 것으로 **교체**
 * - base: null 이면            → base 프롬프트를 **완전히 제거**
 */
async function step7_3() {
  console.log("\n########## [7-3] prefix / base / suffix ##########");

  // (A) base 를 교체
  const replaced = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    systemPrompt: {
      prefix: "### PREFIX ###",
      base: "### 내가 직접 쓴 BASE 프롬프트. 내장 Deep Agent 프롬프트는 사라졌다. ###",
      suffix: "### SUFFIX ###",
    },
    middleware: [makePromptSpy("7-3A base 교체")],
  });
  await replaced.invoke({ messages: [{ role: "user", content: "안녕" }] });

  // (B) base: null — base 제거. 단, 미들웨어가 붙이는 도구 지침은 그대로 남는다!
  const removed = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    systemPrompt: {
      prefix: "당신은 사내 규정만 인용해 답하는 컴플라이언스 봇입니다. 추측 금지.",
      base: null,
    },
    middleware: [makePromptSpy("7-3B base:null")],
  });
  await removed.invoke({ messages: [{ role: "user", content: "안녕" }] });

  // (C) 함정: base: undefined 는 "제거" 가 아니라 "생략" 이다 → 내장 base 가 그대로 남는다.
  const notRemoved = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    systemPrompt: {
      prefix: "제거하려던 시도",
      base: undefined, // ← null 이 아니라 undefined. 내장 프롬프트가 살아있다.
    },
    middleware: [makePromptSummarySpy("7-3C base:undefined")],
  });
  await notRemoved.invoke({ messages: [{ role: "user", content: "안녕" }] });
}

/* ===== [7-4] 내장 프롬프트가 실제로 뭘 시키는가 ===== */
/**
 * 최종 시스템 프롬프트는 네 겹입니다.
 *   1. 내 prefix
 *   2. BASE_AGENT_PROMPT  (createDeepAgent 가 붙임)
 *   3. 미들웨어가 런타임에 덧붙이는 도구 지침
 *      - todoListMiddleware  → write_todos 사용 지침
 *      - FilesystemMiddleware → "## Filesystem Tools ..." 파일 지침
 *      - SubAgentMiddleware   → "## `task` (subagent spawner)" 위임 지침
 *   4. 하네스 프로파일 suffix
 *
 * 아래는 3번 겹이 "붙는 조건" 을 직접 확인합니다.
 * 서브에이전트를 하나 주면 task 지침이, 도구를 주면 파일 지침이 붙습니다.
 */
async function step7_4() {
  console.log("\n########## [7-4] 내장 프롬프트 해부 ##########");

  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    tools: [getStockPrice],
    subagents: [
      {
        name: "ticker-checker",
        description: "티커 심볼이 유효한지만 확인하는 서브에이전트",
        systemPrompt: "티커가 유효한지 한 줄로만 답하세요.",
        tools: [getStockPrice],
      },
    ],
    systemPrompt: "당신은 주식 리서치 어시스턴트입니다.",
    middleware: [makePromptSpy("7-4 전체 조립본")],
  });

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

  // 프롬프트에서 각 섹션이 어디쯤 있는지 눈으로 찾아보세요:
  //   "You are a Deep Agent"        ← BASE_AGENT_PROMPT 시작
  //   "## Filesystem Tools"          ← FilesystemMiddleware
  //   "## `task` (subagent spawner)" ← SubAgentMiddleware
}

/* ===== [7-5] 좋은 Deep Agent 프롬프트의 다섯 요소 ===== */
/**
 * 역할 / 워크플로 / 도구 사용 규칙 / 출력 형식 / 중단 조건.
 * 아래는 다섯 요소를 모두 채운 prefix 예시입니다.
 * 내장 base 는 그대로 두고(생략), 내 도메인 지식만 앞에 얹습니다 — 이게 권장 패턴입니다.
 */
const GOOD_PREFIX = `당신은 주식 리서치 어시스턴트입니다. (역할)

## 워크플로
1. 사용자가 요청한 티커를 확인한다.
2. get_stock_price 로 각 티커의 가격을 조회한다. 여러 개면 **반드시 병렬로** 호출한다.
3. 조회 결과를 표로 정리한다.
4. 마지막에 한 줄 코멘트를 단다.

## 도구 사용 규칙
- 가격은 절대 기억이나 추측으로 말하지 않는다. 반드시 get_stock_price 결과만 인용한다.
- get_stock_price 가 "Unknown ticker" 를 반환하면 그 티커는 "조회 불가" 로 표기하고 넘어간다.
- 티커가 3개 이상이면 write_todos 로 계획을 먼저 세운다.

## 출력 형식
| 티커 | 가격(USD) |
|---|---|
| ... | ... |

표 아래에 코멘트 한 줄. 그 외 서론/맺음말 금지.

## 중단 조건
- 모든 티커의 가격을 표에 채웠으면 즉시 종료한다.
- 같은 도구를 같은 인자로 두 번 부르지 않는다.
- 사용자가 티커를 하나도 주지 않았으면 조회하지 말고 티커를 되묻는다.`;

async function step7_5() {
  console.log("\n########## [7-5] 다섯 요소를 갖춘 프롬프트 ##########");

  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    tools: [getStockPrice],
    systemPrompt: GOOD_PREFIX,
  });

  const result = await agent.invoke({
    messages: [{ role: "user", content: "AAPL, NVDA, TSLA 가격 비교해줘." }],
  });

  console.log(result.messages.at(-1)?.text);
  // TSLA 는 표에 없으므로 "조회 불가" 로 표기되어야 합니다 — 규칙이 지켜지는지 보세요.
}

/* ===== [7-6] 나쁜 프롬프트 vs 좋은 프롬프트 A/B ===== */
/**
 * 완전히 같은 모델·도구·질문. 프롬프트만 교체합니다.
 * 나쁜 쪽은 "환각 가격", "형식 제멋대로", "안 끝나는 서론" 이 나오기 쉽습니다.
 */
const BAD_PREFIX = "주식 도와줘.";

async function step7_6() {
  console.log("\n########## [7-6] A/B 실험 ##########");

  const question = "AAPL, NVDA, TSLA 가격 비교해줘.";

  for (const [label, prompt] of [
    ["BAD ", BAD_PREFIX],
    ["GOOD", GOOD_PREFIX],
  ] as const) {
    const agent = await createDeepAgent({
      model: "anthropic:claude-sonnet-4-6",
      tools: [getStockPrice],
      systemPrompt: prompt,
    });

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

    // 정량 지표: 도구 호출 횟수 / 총 메시지 수 / 응답 길이
    const toolCalls = result.messages.filter((m) => m.getType() === "tool").length;
    const answer = result.messages.at(-1)?.text ?? "";

    console.log(`\n--- ${label} ---`);
    console.log(`도구호출=${toolCalls} 메시지수=${result.messages.length} 응답길이=${answer.length}`);
    console.log(answer);
  }
}

/* ===== [7-7] 하네스 프로파일 (profiles) ===== */
/**
 * registerHarnessProfile(key, options) 로 "모델/프로바이더별 기본값" 을 등록합니다.
 * key 는 "anthropic" (프로바이더) 또는 "anthropic:claude-sonnet-4-6" (모델) 형식.
 *
 * 옵션:
 *   baseSystemPrompt        — 내장 base 프롬프트 자체를 교체
 *   systemPromptSuffix      — 조립된 프롬프트 **맨 뒤**에 덧붙임 (프로파일의 주력 수단)
 *   toolDescriptionOverrides— 도구 설명 문구 교체
 *   excludedTools           — 하네스 도구 제거
 *   excludedMiddleware      — 미들웨어 제거 (단, 필수 2개는 못 뺌)
 *   extraMiddleware         — 사용자 미들웨어 뒤에 추가
 *   generalPurposeSubagent  — general-purpose 서브에이전트 설정/비활성화
 *
 * ⚠️ 전역 레지스트리입니다. 한 번 등록하면 그 프로세스의 모든 createDeepAgent 에 적용됩니다.
 */
async function step7_7() {
  console.log("\n########## [7-7] 하네스 프로파일 ##########");

  registerHarnessProfile("anthropic:claude-sonnet-4-6", {
    systemPromptSuffix: "### PROFILE-SUFFIX ### 모든 답변은 한국어로, 200자 이내로 하세요.",
    generalPurposeSubagent: { enabled: false }, // general-purpose 서브에이전트 끄기
  });

  // 등록된 프로파일 확인
  // ⚠️ getHarnessProfile 은 등록된 게 없으면 undefined 를 반환합니다. ?. 로 접근하세요.
  const profile = getHarnessProfile("anthropic:claude-sonnet-4-6");
  console.log("등록된 suffix:", profile?.systemPromptSuffix);
  console.log("GP 서브에이전트:", profile?.generalPurposeSubagent);

  // createDeepAgent 호출부는 하나도 안 바꿨는데 프롬프트 끝에 suffix 가 붙습니다.
  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    systemPrompt: "당신은 주식 리서치 어시스턴트입니다.",
    middleware: [makePromptSpy("7-7 프로파일 적용")],
  });

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

  // 정리: 이 프로세스에서 이후 예제에 영향을 주지 않도록 되돌립니다.
  // (registerHarnessProfile 은 "머지" 라서 빈 문자열로 덮어써야 합니다)
  registerHarnessProfile("anthropic:claude-sonnet-4-6", {
    systemPromptSuffix: undefined,
    generalPurposeSubagent: { enabled: true },
  });
}

/* ===== [7-8] 프롬프트 반복 개선 루프 ===== */
/**
 * 프롬프트는 "한 번 잘 쓰는" 게 아니라 "실패를 보고 고치는" 것입니다.
 * 아래는 최소 하네스: 같은 케이스 묶음을 여러 프롬프트 버전에 돌리고 점수를 비교합니다.
 */
type Case = { question: string; expect: (answer: string) => boolean; why: string };

const CASES: Case[] = [
  {
    question: "AAPL 가격 알려줘.",
    expect: (a) => a.includes("231.4"),
    why: "도구가 준 실제 가격을 인용해야 함",
  },
  {
    question: "TSLA 가격 알려줘.",
    expect: (a) => /조회 불가|Unknown|알 수 없/.test(a),
    why: "모르는 티커를 지어내면 안 됨",
  },
  {
    question: "주식 좀 알려줘.",
    expect: (a) => /어떤|티커|종목/.test(a),
    why: "티커가 없으면 되물어야 함",
  },
];

async function evalPrompt(label: string, systemPrompt: string) {
  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    tools: [getStockPrice],
    systemPrompt,
  });

  let pass = 0;
  for (const c of CASES) {
    const r = await agent.invoke({ messages: [{ role: "user", content: c.question }] });
    const answer = r.messages.at(-1)?.text ?? "";
    const ok = c.expect(answer);
    if (ok) pass += 1;
    console.log(`  [${ok ? "PASS" : "FAIL"}] ${c.question}  (${c.why})`);
    if (!ok) console.log(`         → 실제 응답: ${answer.slice(0, 120).replace(/\n/g, " ")}`);
  }
  console.log(`  ${label}: ${pass}/${CASES.length}`);
  return pass;
}

async function step7_8() {
  console.log("\n########## [7-8] 프롬프트 개선 루프 ##########");
  console.log("\n[v1: 나쁜 프롬프트]");
  await evalPrompt("v1", BAD_PREFIX);
  console.log("\n[v2: 다섯 요소 프롬프트]");
  await evalPrompt("v2", GOOD_PREFIX);
  // FAIL 이 난 케이스를 보고 GOOD_PREFIX 의 "도구 사용 규칙" 에 문장을 한 줄 추가해보세요.
  // 그것이 개선 루프입니다: 실패 → 규칙 추가 → 재측정.
}

/* ===== [7-9] 종합 — 코드 리뷰 에이전트 ===== */
/**
 * 다섯 요소 + base:null 완전 제어 + 프로파일 suffix 를 한 번에 씁니다.
 * base:null 을 썼지만 파일/task 지침은 미들웨어가 여전히 붙여준다는 점을 기억하세요.
 */
async function step7_9() {
  console.log("\n########## [7-9] 종합 ##########");

  const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-4-6",
    systemPrompt: {
      prefix: `당신은 TypeScript 코드 리뷰어입니다.

## 워크플로
1. /src 를 ls 로 훑어 구조를 파악한다.
2. 리뷰 대상 파일을 read_file 로 읽는다.
3. 문제를 심각도(HIGH/MEDIUM/LOW)로 분류한다.
4. /review.md 에 결과를 write_file 로 저장한다.

## 도구 사용 규칙
- 파일을 읽지 않고 리뷰하지 않는다. 추측 금지.
- 파일 경로는 항상 /로 시작한다.

## 출력 형식
심각도별 불릿. 각 항목은 "파일:라인 — 문제 — 제안" 형식.

## 중단 조건
- /review.md 를 쓴 뒤 즉시 종료한다. 같은 파일을 두 번 읽지 않는다.`,
      base: null, // 내장 Deep Agent 인격을 걷어내고 내 규칙만 남긴다
      suffix: "리뷰는 반드시 한국어로 작성한다.",
    },
    middleware: [makePromptSummarySpy("7-9")],
  });

  const result = await agent.invoke({
    messages: [
      {
        role: "user",
        content:
          "먼저 /src/util.ts 에 다음 코드를 저장하고 리뷰해줘:\n" +
          "export function sum(a: any, b: any) { return a + b }\n" +
          "export async function load(url: string) { const r = await fetch(url); return r.json() }",
      },
    ],
  });

  console.log(result.messages.at(-1)?.text);
  console.log("\n생성된 파일 목록:", Object.keys(result.files ?? {}));
}

/* ===== 실행 ===== */
async function main() {
  await step7_1();
  await step7_2();
  await step7_3();
  await step7_4();
  await step7_5();
  await step7_6();
  await step7_7();
  await step7_8();
  await step7_9();
}

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

/**
 * Step 07 — 시스템 프롬프트 설계 · 연습문제
 * 실행: npx tsx docs/reference/deepagent/step-07-prompting/exercise.ts
 *
 * 각 [문제 N] 블록 아래를 직접 채우세요.
 * 정답은 solution.ts 에 있습니다. 먼저 스스로 풀어보고 여세요.
 *
 * 필요 환경변수: ANTHROPIC_API_KEY
 */
import "dotenv/config";
import { createDeepAgent, registerHarnessProfile, getHarnessProfile } from "deepagents";
import { createMiddleware, tool } from "langchain";
import * as z from "zod";

/* ===== 공용 준비물 (그대로 쓰세요) ===== */

/** 최종 시스템 프롬프트를 가로채는 스파이 미들웨어 */
function makePromptSpy(onPrompt: (text: string) => void) {
  return createMiddleware({
    name: "PromptSpyMiddleware",
    wrapModelCall: async (request, handler) => {
      onPrompt(request.systemMessage.text ?? "");
      return handler(request);
    },
  });
}

const searchDocs = tool(
  ({ query }: { query: string }) => {
    const db: Record<string, string> = {
      환불: "환불은 구매 후 14일 이내, 미개봉 상태에서만 가능합니다. (규정 3.2조)",
      배송: "배송은 결제 후 2~3 영업일이 소요됩니다. (규정 5.1조)",
    };
    const hit = Object.entries(db).find(([k]) => query.includes(k));
    return hit ? hit[1] : "NOT_FOUND";
  },
  {
    name: "search_docs",
    description: "사내 규정 문서를 검색합니다. 규정 원문을 반환합니다.",
    schema: z.object({ query: z.string().describe("검색어") }),
  },
);

/* ===== [문제 1] =====
 * `systemPrompt: "### MARKER ###"` 를 준 Deep Agent 를 만들고,
 * makePromptSpy 로 최종 시스템 프롬프트를 가로채서 다음 두 가지를 콘솔에 출력하세요.
 *
 *   (a) "### MARKER ###" 가 프롬프트의 **맨 앞**(index 0)에 있는가?
 *   (b) 내장 프롬프트 문구인 "You are a Deep Agent" 가 **여전히 포함**되어 있는가?
 *
 * 이 문제의 목적: systemPrompt 문자열이 "교체" 가 아니라 "prefix" 임을 스스로 증명하는 것.
 */
async function ex1() {
  console.log("\n===== [문제 1] =====");
  // 여기에 작성
}

/* ===== [문제 2] =====
 * `systemPrompt: { prefix: "...", base: null }` 로 에이전트를 만들고,
 * 최종 프롬프트에서 다음을 각각 true/false 로 출력하세요.
 *
 *   (a) "You are a Deep Agent" 포함 여부
 *   (b) "## Filesystem Tools" 포함 여부
 *
 * (b) 의 결과를 보고, base: null 이 "무엇까지" 지우는지 주석으로 한 줄 적으세요.
 */
async function ex2() {
  console.log("\n===== [문제 2] =====");
  // 여기에 작성
  // → base: null 이 지우는 것은:
}

/* ===== [문제 3] =====
 * `base: null` 과 `base: undefined` 를 각각 준 에이전트 두 개를 만들고
 * 최종 프롬프트 길이를 나란히 출력해 **다르다**는 것을 보이세요.
 *
 * 왜 다른지 주석으로 설명하세요. (힌트: 내부 판정이 `base !== undefined` 다)
 */
async function ex3() {
  console.log("\n===== [문제 3] =====");
  // 여기에 작성
  // → 왜 다른가:
}

/* ===== [문제 4] =====
 * 아래 두 가지를 동시에 설정하고, 최종 프롬프트에서 둘의 **등장 순서**를 확인하세요.
 *   - systemPrompt: { prefix: "P", suffix: "### MY-SUFFIX ###" }
 *   - registerHarnessProfile("anthropic:claude-sonnet-4-6", { systemPromptSuffix: "### PROFILE-SUFFIX ###" })
 *
 * indexOf 로 두 마커의 위치를 찍어서 어느 쪽이 더 뒤에 오는지 출력하세요.
 * 테스트가 끝나면 프로파일을 되돌려 놓으세요.
 */
async function ex4() {
  console.log("\n===== [문제 4] =====");
  // 여기에 작성
}

/* ===== [문제 5] =====
 * search_docs 도구를 쓰는 "사내 규정 안내 봇" 의 systemPrompt(prefix)를 작성하세요.
 * 반드시 다섯 요소를 모두 포함해야 합니다:
 *   역할 / 워크플로 / 도구 사용 규칙 / 출력 형식 / 중단 조건
 *
 * 요구사항:
 *   - 규정 원문을 인용하지 않고 답하면 안 된다 (환각 금지)
 *   - search_docs 가 "NOT_FOUND" 를 반환하면 "해당 규정을 찾지 못했습니다" 라고만 답한다
 *   - 출력은 "답변 한 줄 + 근거(규정 N조)" 형식
 *
 * 작성 후 "환불 규정 알려줘" 와 "주차장 규정 알려줘" 두 질문으로 실행해 확인하세요.
 */
const RULE_BOT_PREFIX = `TODO: 여기에 다섯 요소를 갖춘 프롬프트를 작성하세요.`;

async function ex5() {
  console.log("\n===== [문제 5] =====");
  // 여기에 작성
}

/* ===== [문제 6] =====
 * 나쁜 프롬프트("규정 알려줘")와 문제 5 의 RULE_BOT_PREFIX 를 A/B 로 비교하세요.
 * 질문은 "주차장 규정 알려줘" (= DB 에 없는 항목) 로 고정합니다.
 *
 * 각 프롬프트에 대해 다음을 출력하세요:
 *   - 도구 호출 횟수 (result.messages 중 getType() === "tool" 개수)
 *   - 최종 응답 길이
 *   - "찾지 못했" 문구 포함 여부 (= 환각을 안 했는가)
 */
async function ex6() {
  console.log("\n===== [문제 6] =====");
  // 여기에 작성
}

/* ===== [문제 7] =====
 * (a) registerHarnessProfile("anthropic", { excludedMiddleware: ["FilesystemMiddleware"] })
 *     를 try/catch 로 감싸 호출하고, 무슨 일이 일어나는지 출력하세요.
 * (b) 이어서 excludedMiddleware: ["SummarizationMiddleware"] 는 등록이 되는지 확인하세요.
 *
 * 두 결과의 차이를 REQUIRED_MIDDLEWARE_NAMES 를 근거로 주석에 설명하세요.
 * (힌트: import { REQUIRED_MIDDLEWARE_NAMES } from "deepagents")
 *
 * 끝나면 프로파일을 되돌려 놓으세요.
 */
async function ex7() {
  console.log("\n===== [문제 7] =====");
  // 여기에 작성
  // → 왜 그런가:
}

/* ===== [문제 8] =====
 * 문제 5 의 RULE_BOT_PREFIX 를 대상으로 최소 평가 하네스를 만드세요.
 *
 *   케이스 A: "환불 규정 알려줘"   → 응답에 "14일" 포함
 *   케이스 B: "주차장 규정 알려줘" → 응답에 "찾지 못했" 포함
 *   케이스 C: "규정 알려줘"        → 응답에 "어떤" 또는 "무엇" 포함 (되묻기)
 *
 * 3케이스를 돌려 pass/3 를 출력하고, FAIL 이 나면 RULE_BOT_PREFIX 에
 * 규칙 한 줄을 추가해 다시 돌려 점수가 오르는지 확인하세요.
 */
async function ex8() {
  console.log("\n===== [문제 8] =====");
  // 여기에 작성
}

async function main() {
  await ex1();
  await ex2();
  await ex3();
  await ex4();
  await ex5();
  await ex6();
  await ex7();
  await ex8();
}

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

/**
 * Step 07 — 시스템 프롬프트 설계 · 정답
 * 실행: npx tsx docs/reference/deepagent/step-07-prompting/solution.ts
 *
 * exercise.ts 를 스스로 풀어본 뒤에 여세요.
 * 각 정답 위 주석에 기대 결과와 해설이 있습니다.
 */
import "dotenv/config";
import {
  createDeepAgent,
  registerHarnessProfile,
  getHarnessProfile,
  REQUIRED_MIDDLEWARE_NAMES,
} from "deepagents";
import { createMiddleware, tool } from "langchain";
import * as z from "zod";

/* ===== 공용 준비물 ===== */

function makePromptSpy(onPrompt: (text: string) => void) {
  return createMiddleware({
    name: "PromptSpyMiddleware",
    wrapModelCall: async (request, handler) => {
      onPrompt(request.systemMessage.text ?? "");
      return handler(request);
    },
  });
}

/** 프롬프트를 한 번만 캡처해서 돌려주는 헬퍼. 모델을 실제로 한 번 호출합니다. */
async function capturePrompt(params: Parameters<typeof createDeepAgent>[0]): Promise<string> {
  let captured = "";
  const agent = await createDeepAgent({
    ...params,
    middleware: [
      ...((params?.middleware as any[]) ?? []),
      makePromptSpy((t) => {
        if (!captured) captured = t;
      }),
    ] as any,
  });
  await agent.invoke({ messages: [{ role: "user", content: "안녕" }] });
  return captured;
}

const searchDocs = tool(
  ({ query }: { query: string }) => {
    const db: Record<string, string> = {
      환불: "환불은 구매 후 14일 이내, 미개봉 상태에서만 가능합니다. (규정 3.2조)",
      배송: "배송은 결제 후 2~3 영업일이 소요됩니다. (규정 5.1조)",
    };
    const hit = Object.entries(db).find(([k]) => query.includes(k));
    return hit ? hit[1] : "NOT_FOUND";
  },
  {
    name: "search_docs",
    description: "사내 규정 문서를 검색합니다. 규정 원문을 반환합니다.",
    schema: z.object({ query: z.string().describe("검색어") }),
  },
);

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

/* ===== [정답 1] =====
 * 기대 결과: (a) true — 마커가 index 0 에 있다.
 *            (b) true — 내장 프롬프트가 **지워지지 않고** 뒤에 그대로 남아 있다.
 *
 * 해설: createDeepAgent 는 문자열 systemPrompt 를 `{ prefix: systemPrompt }` 로
 * 정규화합니다. 조립은 prefix → base → suffix 순이므로 내 문자열은 항상 맨 앞이고,
 * 내장 BASE_AGENT_PROMPT 는 그 뒤에 살아남습니다.
 * "systemPrompt 를 주면 내장 프롬프트가 대체된다" 는 흔한 오해입니다.
 */
async function sol1() {
  console.log("\n===== [정답 1] =====");
  const text = await capturePrompt({ model: MODEL, systemPrompt: "### MARKER ###" });

  console.log("(a) 마커가 맨 앞인가:", text.indexOf("### MARKER ###") === 0);
  console.log("(b) 내장 프롬프트가 남아있나:", text.includes("You are a Deep Agent"));
}

/* ===== [정답 2] =====
 * 기대 결과: (a) false — base 가 사라졌다.
 *            (b) true  — 파일 지침은 **그대로 남아 있다.**
 *
 * → base: null 이 지우는 것은: `createDeepAgent` 가 붙이는 BASE_AGENT_PROMPT **한 겹뿐**이다.
 *   미들웨어(Filesystem/SubAgent/TodoList)가 wrapModelCall 에서 systemMessage 에
 *   덧붙이는 도구 지침은 조립 단계 **밖**에서 일어나므로 전혀 영향을 받지 않는다.
 */
async function sol2() {
  console.log("\n===== [정답 2] =====");
  const text = await capturePrompt({
    model: MODEL,
    systemPrompt: { prefix: "당신은 컴플라이언스 봇입니다.", base: null },
  });

  console.log("(a) 내장 base 포함:", text.includes("You are a Deep Agent")); // false
  console.log("(b) 파일 지침 포함:", text.includes("## Filesystem Tools")); // true
}

/* ===== [정답 3] =====
 * 기대 결과: base:null 쪽이 눈에 띄게 짧다 (BASE_AGENT_PROMPT 약 2천 자만큼).
 *
 * → 왜 다른가: 내부 판정이 `promptConfig.base !== undefined` 이기 때문이다.
 *   - base: undefined → "필드를 생략한 것" 으로 취급 → 내장 base 를 그대로 유지
 *   - base: null      → "명시적으로 비운 것" 으로 취급 → base 를 통째로 제거
 *   TypeScript 는 `base?: string | SystemMessage | null` 이라 둘 다 통과시킵니다.
 *   객체 스프레드로 프롬프트 설정을 조립하다 보면 실수로 undefined 가 들어가기 쉽고,
 *   그러면 "왜 내장 프롬프트가 안 지워지지?" 로 조용히 헤매게 됩니다.
 */
async function sol3() {
  console.log("\n===== [정답 3] =====");
  const withNull = await capturePrompt({
    model: MODEL,
    systemPrompt: { prefix: "P", base: null },
  });
  const withUndefined = await capturePrompt({
    model: MODEL,
    systemPrompt: { prefix: "P", base: undefined },
  });

  console.log("base:null      길이:", withNull.length);
  console.log("base:undefined 길이:", withUndefined.length);
  console.log("차이:", withUndefined.length - withNull.length, "자 (= 내장 base 프롬프트 분량)");
}

/* ===== [정답 4] =====
 * 기대 결과: PROFILE-SUFFIX 의 위치가 MY-SUFFIX 보다 **뒤**다.
 *
 * 해설: 조립 순서는 prefix → base → suffix → harnessProfile.systemPromptSuffix.
 * 즉 프로파일 suffix 가 **항상 최후미**입니다.
 * "모델별 마지막 한마디" 를 프로파일에 두면 호출부와 충돌하지 않는 이유가 이것입니다.
 */
async function sol4() {
  console.log("\n===== [정답 4] =====");
  registerHarnessProfile(MODEL, { systemPromptSuffix: "### PROFILE-SUFFIX ###" });

  const text = await capturePrompt({
    model: MODEL,
    systemPrompt: { prefix: "P", suffix: "### MY-SUFFIX ###" },
  });

  const mine = text.indexOf("### MY-SUFFIX ###");
  const profile = text.indexOf("### PROFILE-SUFFIX ###");
  console.log("MY-SUFFIX      위치:", mine);
  console.log("PROFILE-SUFFIX 위치:", profile);
  console.log("프로파일 suffix 가 더 뒤인가:", profile > mine); // true

  registerHarnessProfile(MODEL, { systemPromptSuffix: undefined });
}

/* ===== [정답 5] =====
 * 다섯 요소를 모두 채운 프롬프트. 정답은 하나가 아니지만, 아래 다섯 헤더가
 * 모두 존재하고 각 규칙이 **검증 가능한 문장**인지가 채점 기준입니다.
 *
 * 특히 "NOT_FOUND 면 X 라고만 답한다" 처럼 **도구의 실제 반환값 문자열**을 프롬프트에
 * 못박는 것이 중요합니다. "모르면 모른다고 해" 같은 추상적 지시는 잘 안 지켜집니다.
 */
const RULE_BOT_PREFIX = `당신은 사내 규정 안내 봇입니다. 규정 원문에만 근거해 답합니다. (역할)

## 워크플로
1. 사용자 질문에서 규정 키워드를 뽑는다.
2. search_docs 로 그 키워드를 검색한다.
3. 반환된 규정 원문에 근거해서만 답한다.

## 도구 사용 규칙
- 절대 기억이나 상식으로 규정을 답하지 않는다. search_docs 를 반드시 먼저 호출한다.
- search_docs 가 정확히 "NOT_FOUND" 를 반환하면, 다른 검색어로 재시도하지 말고
  "해당 규정을 찾지 못했습니다." 라고만 답한다. 내용을 지어내지 않는다.
- 사용자가 규정 키워드를 하나도 주지 않았으면 검색하지 말고 "어떤 규정이 궁금하신가요?" 라고 되묻는다.

## 출력 형식
답변 한 줄.
근거: (규정 N조)

그 외 서론/맺음말/이모지 금지.

## 중단 조건
- 답변 한 줄과 근거를 출력했으면 즉시 종료한다.
- search_docs 는 질문당 최대 1회만 호출한다.`;

async function sol5() {
  console.log("\n===== [정답 5] =====");
  const agent = await createDeepAgent({
    model: MODEL,
    tools: [searchDocs],
    systemPrompt: RULE_BOT_PREFIX,
  });

  for (const q of ["환불 규정 알려줘", "주차장 규정 알려줘"]) {
    const r = await agent.invoke({ messages: [{ role: "user", content: q }] });
    console.log(`\nQ: ${q}\nA: ${r.messages.at(-1)?.text}`);
  }
}

/* ===== [정답 6] =====
 * 기대 경향 (모델 응답이므로 매번 다릅니다):
 *   - BAD  : 도구를 아예 안 부르거나, 부른 뒤 NOT_FOUND 를 무시하고 그럴듯한 주차 규정을 **지어냄**
 *   - GOOD : 도구 1회 호출 → NOT_FOUND → "해당 규정을 찾지 못했습니다." 한 줄
 *
 * 해설: 환각은 모델이 나빠서가 아니라 **프롬프트가 실패 경로를 정의하지 않아서** 납니다.
 * "NOT_FOUND 면 이렇게 답해라" 한 줄이 환각을 막는 실질적 장치입니다.
 */
async function sol6() {
  console.log("\n===== [정답 6] =====");
  const question = "주차장 규정 알려줘";

  for (const [label, prompt] of [
    ["BAD ", "규정 알려줘."],
    ["GOOD", RULE_BOT_PREFIX],
  ] as const) {
    const agent = await createDeepAgent({
      model: MODEL,
      tools: [searchDocs],
      systemPrompt: prompt,
    });
    const r = await agent.invoke({ messages: [{ role: "user", content: question }] });
    const answer = r.messages.at(-1)?.text ?? "";
    const toolCalls = r.messages.filter((m) => m.getType() === "tool").length;

    console.log(`\n--- ${label} ---`);
    console.log(`도구호출=${toolCalls} 응답길이=${answer.length} 환각안함=${answer.includes("찾지 못했")}`);
    console.log(answer);
  }
}

/* ===== [정답 7] =====
 * 기대 결과:
 *   (a) Error 를 던진다:
 *       Cannot exclude required middleware "FilesystemMiddleware" —
 *       it provides essential agent capabilities that the runtime depends on.
 *   (b) SummarizationMiddleware 는 조용히 등록된다.
 *
 * → 왜 그런가: `REQUIRED_MIDDLEWARE_NAMES` 가
 *   Set(["FilesystemMiddleware", "SubAgentMiddleware"]) 이기 때문이다.
 *   이 둘은 Deep Agent 의 필수 골격(파일 도구 / task 도구)을 제공하므로
 *   프로파일로 제거할 수 없다.
 *
 * 중요한 것은 **던지는 시점**이다. createDeepAgent 가 아니라 registerHarnessProfile
 * 이 던진다 — 프로파일 옵션은 등록 시점에 createHarnessProfile 로 검증되기 때문이다.
 * 프로파일 등록을 모듈 최상단(로드 시점)에 두면 앱이 부팅하다 죽는다.
 *
 * 참고로 excludedMiddleware 엔 세 가지 검증이 더 있다:
 *   - 빈 문자열/공백만 있는 문자열 불가
 *   - ":" 포함 불가 (클래스 경로 문법은 지원하지 않음)
 *   - "_" 로 시작 불가 (비공개 미들웨어는 제외 대상이 아님)
 */
async function sol7() {
  console.log("\n===== [정답 7] =====");
  console.log("REQUIRED_MIDDLEWARE_NAMES:", [...REQUIRED_MIDDLEWARE_NAMES]);

  // (a) 필수 미들웨어 제외 시도 → throw
  try {
    registerHarnessProfile("anthropic", { excludedMiddleware: ["FilesystemMiddleware"] });
    console.log("(a) 등록 성공 — 예상과 다름!");
  } catch (err) {
    console.log("(a) 등록 실패:", (err as Error).message);
  }

  // (b) 필수가 아닌 미들웨어는 등록된다
  // ⚠️ getHarnessProfile 은 등록된 프로파일이 없으면 undefined 를 반환합니다.
  registerHarnessProfile("anthropic", { excludedMiddleware: ["SummarizationMiddleware"] });
  console.log("(b) 등록된 excludedMiddleware:", [
    ...(getHarnessProfile("anthropic")?.excludedMiddleware ?? []),
  ]);

  // 파일 지침은 당연히 그대로 남아 있다 — 애초에 뺄 수 없었으므로.
  const text = await capturePrompt({ model: MODEL, systemPrompt: "P" });
  console.log("파일 지침 포함:", text.includes("## Filesystem Tools")); // true

  // 되돌리기: 재등록은 머지이므로 빈 배열로 덮어써도 Set 은 비워지지 않는다는 점에 주의.
  // 확실히 초기화하려면 새 프로세스를 쓰거나, 애초에 테스트용 키를 쓰는 것이 낫다.
  registerHarnessProfile("anthropic", { excludedMiddleware: [] });
  console.log("되돌린 뒤:", [...(getHarnessProfile("anthropic")?.excludedMiddleware ?? [])]);
}

/* ===== [정답 8] =====
 * 기대 결과: RULE_BOT_PREFIX 는 대체로 3/3.
 * 만약 케이스 C(되묻기)가 FAIL 이면, "도구 사용 규칙" 에 아래 한 줄을 더 못박습니다:
 *   "- 질문에 구체적 규정 키워드(환불/배송 등)가 없으면 search_docs 를 호출하지 말고 되묻는다."
 *
 * 해설: 이것이 프롬프트 개선 루프의 전부입니다.
 *   실패 케이스를 고정된 테스트로 박제 → 규칙 한 줄 추가 → 재측정 → 점수가 올랐는지 확인.
 *   "프롬프트를 통째로 다시 쓰는" 것보다 훨씬 빠르고, 회귀(regression)를 잡아줍니다.
 *   LLM 응답은 비결정적이라 1회 실행으로 판정하면 노이즈가 큽니다.
 *   실무에서는 케이스당 3~5회 반복해 다수결/통과율로 봅니다.
 */
type Case = { question: string; expect: (a: string) => boolean; why: string };

const CASES: Case[] = [
  { question: "환불 규정 알려줘", expect: (a) => a.includes("14일"), why: "규정 원문 인용" },
  { question: "주차장 규정 알려줘", expect: (a) => a.includes("찾지 못했"), why: "환각 금지" },
  { question: "규정 알려줘", expect: (a) => /어떤|무엇/.test(a), why: "키워드 없으면 되묻기" },
];

async function sol8() {
  console.log("\n===== [정답 8] =====");
  const agent = await createDeepAgent({
    model: MODEL,
    tools: [searchDocs],
    systemPrompt: RULE_BOT_PREFIX,
  });

  let pass = 0;
  for (const c of CASES) {
    const r = await agent.invoke({ messages: [{ role: "user", content: c.question }] });
    const answer = r.messages.at(-1)?.text ?? "";
    const ok = c.expect(answer);
    if (ok) pass += 1;
    console.log(`[${ok ? "PASS" : "FAIL"}] ${c.question} (${c.why})`);
    if (!ok) console.log(`       실제: ${answer.slice(0, 120).replace(/\n/g, " ")}`);
  }
  console.log(`점수: ${pass}/${CASES.length}`);
}

async function main() {
  await sol1();
  await sol2();
  await sol3();
  await sol4();
  await sol5();
  await sol6();
  await sol7();
  await sol8();
}

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