@cartanova/qgrid-cli 2.4.6 → 2.4.8

package/bundle/src/utils/providers/anthropic/claude-session.ts

@@ -30,6 +30,7 @@ import {
   assertSupportedOneMillionSuffix,
   canonicalAnthropicModel,
   needsCli1mSuffix,
+  requiresAdaptiveThinking,
   supports1MContext,
 } from "./anthropic-constants";
 import {
@@ -145,6 +146,18 @@ export function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONT
   return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" };
 }
 
+export function thinkingEnv(model: string): {
+  CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING?: "1";
+  MAX_THINKING_TOKENS?: "0";
+} {
+  return requiresAdaptiveThinking(model)
+    ? {}
+    : {
+        CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
+        MAX_THINKING_TOKENS: "0",
+      };
+}
+
 // SON-495: structured output retry 를 1 로 고정한다. CC 가 attempt 를 reject 하고 retry 하면
 // `{rejected}{accepted}` 누적이 AI-SDK 의 JSON.parse 를 깨뜨리므로, retry 자체를 막아 그 경로를
 // 원천 차단한다. `0` 은 CC query loop(`callsThisQuery >= maxRetries`)가 첫 attempt emit 전에
@@ -211,8 +224,8 @@ export function buildClaudeArgs(opts: {
     // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.
     // 크기에 따라 --system-prompt(작음) / --system-prompt-file(큼)로 분기(systemArgs).
     ...systemArgs,
-    "--thinking",
-    "disabled",
+    // Fable 5 는 adaptive thinking 이 항상 켜져 있어 disabled 를 거부한다.
+    ...(requiresAdaptiveThinking(opts.model) ? [] : ["--thinking", "disabled"]),
     "--effort",
     opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,
     "--disable-slash-commands",
@@ -291,14 +304,13 @@ export function runClaudeSession(
           CLAUDE_CODE_OAUTH_TOKEN: req.token,
           CLAUDE_CONFIG_DIR: configDir,
           CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
-          CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
+          ...thinkingEnv(model),
           ...oneMillionEnv(supportsOneMillion),
           CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
           CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1",
           CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: "1",
           CLAUDE_CODE_DISABLE_WORKFLOWS: "1",
           CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
-          MAX_THINKING_TOKENS: "0",
           // structured output 일 때만 retry 를 고정한다(SON-495). text 모드는 영향 없음.
           ...(useStructured ? structuredOutputRetriesEnv() : {}),
         },

package/bundle/src/utils/providers/anthropic/stream-json-adapter.test.ts

@@ -340,6 +340,10 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
           input_tokens: 10,
           cache_creation_input_tokens: 2274,
           cache_read_input_tokens: 14853,
+          cache_creation: {
+            ephemeral_5m_input_tokens: 274,
+            ephemeral_1h_input_tokens: 2000,
+          },
           output_tokens: 111,
         },
       }),
@@ -349,6 +353,8 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
       inputTokens: 10 + 2274 + 14853,
       cachedInputTokens: 14853,
       cacheCreationInputTokens: 2274,
+      cacheCreationInputTokens5m: 274,
+      cacheCreationInputTokens1h: 2000,
       outputTokens: 111,
       reasoningOutputTokens: 0,
     });
@@ -392,6 +398,131 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
     expect(ok2.result!.isError).toBe(false);
   });
 
+  it("Fable refusal fallback: Opus 응답은 성공으로 유지하고 실제 serving model을 보존", () => {
+    const { result } = runLines([
+      JSON.stringify({
+        type: "system",
+        subtype: "model_refusal_fallback",
+        trigger: "refusal",
+        originalModel: "claude-fable-5",
+        fallbackModel: "claude-opus-4-8",
+        apiRefusalCategory: "cyber",
+        apiRefusalExplanation: "classifier declined the request",
+      }),
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          model: "claude-opus-4-8",
+          stop_reason: "end_turn",
+          content: [{ type: "text", text: "safe answer" }],
+          usage: {
+            iterations: [
+              { type: "message", model: "claude-fable-5", input_tokens: 100 },
+              {
+                type: "fallback_message",
+                model: "claude-opus-4-8",
+                input_tokens: 100,
+                output_tokens: 20,
+              },
+            ],
+          },
+        },
+      }),
+      JSON.stringify({
+        type: "result",
+        subtype: "success",
+        result: "safe answer",
+        usage: { input_tokens: 100, output_tokens: 20 },
+        total_cost_usd: 0.003,
+      }),
+    ]);
+
+    expect(result).toMatchObject({
+      isError: false,
+      stopReason: "end_turn",
+      servedModel: "claude-opus-4-8",
+      modelFallbacks: [
+        {
+          trigger: "refusal",
+          fromModel: "claude-fable-5",
+          toModel: "claude-opus-4-8",
+          category: "cyber",
+          explanation: "classifier declined the request",
+        },
+      ],
+    });
+  });
+
+  it("Fable final refusal: success envelope라도 fallback이 없으면 에러", () => {
+    const { result } = runLines([
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          model: "claude-fable-5",
+          stop_reason: "refusal",
+          stop_details: { type: "refusal", category: "bio", explanation: "declined" },
+          content: [],
+        },
+      }),
+      JSON.stringify({
+        type: "system",
+        subtype: "model_refusal_no_fallback",
+        trigger: "refusal",
+        originalModel: "claude-fable-5",
+        apiRefusalCategory: "bio",
+        apiRefusalExplanation: "declined",
+      }),
+      JSON.stringify({
+        type: "result",
+        subtype: "success",
+        result: "",
+        usage: { input_tokens: 412, output_tokens: 0 },
+        total_cost_usd: 0,
+      }),
+    ]);
+
+    expect(result).toMatchObject({
+      isError: true,
+      stopReason: "refusal",
+      servedModel: "claude-fable-5",
+      refusal: { category: "bio", explanation: "declined" },
+    });
+  });
+
+  it("usage.iterations만 있어도 Fable → Opus fallback을 복원", () => {
+    const { result } = runLines([
+      JSON.stringify({
+        type: "assistant",
+        message: {
+          model: "claude-opus-4-8",
+          stop_reason: "end_turn",
+          content: [{ type: "text", text: "answer" }],
+          usage: {
+            iterations: [
+              { type: "message", model: "claude-fable-5" },
+              { type: "fallback_message", model: "claude-opus-4-8" },
+            ],
+          },
+        },
+      }),
+      JSON.stringify({
+        type: "result",
+        subtype: "success",
+        result: "answer",
+        usage: { input_tokens: 10, output_tokens: 2 },
+      }),
+    ]);
+
+    expect(result!.servedModel).toBe("claude-opus-4-8");
+    expect(result!.modelFallbacks).toEqual([
+      {
+        trigger: "refusal",
+        fromModel: "claude-fable-5",
+        toModel: "claude-opus-4-8",
+      },
+    ]);
+  });
+
   it("quota: result text가 'You've hit'로 시작 → quotaExhausted true", () => {
     const { result } = runLines([
       JSON.stringify({ type: "result", result: "You've hit your limit", usage: {} }),

package/bundle/src/utils/providers/anthropic/stream-json-adapter.ts

@@ -10,7 +10,10 @@
 
 import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
 import { type UserInput } from "../../../codex-protocol/v2/UserInput";
-import { type ProviderTokenUsageBreakdown } from "../common/provider-dispatcher";
+import {
+  type ModelFallback,
+  type ProviderTokenUsageBreakdown,
+} from "../common/provider-dispatcher";
 
 // ── 입력 어댑터 ────────────────────────────────────────────────────
 
@@ -122,6 +125,14 @@ interface ClaudeUsage {
   output_tokens?: number;
   cache_creation_input_tokens?: number;
   cache_read_input_tokens?: number;
+  cache_creation?: {
+    ephemeral_5m_input_tokens?: number;
+    ephemeral_1h_input_tokens?: number;
+  };
+  iterations?: Array<{
+    type?: string;
+    model?: string;
+  }>;
 }
 
 export interface ClaudeStreamResult {
@@ -137,10 +148,26 @@ export interface ClaudeStreamResult {
   // isError 판정 사유를 에러 메시지에 드러내기 위해 보존한다(SON-495).
   subtype?: string;
   terminalReason?: string;
+  // 실제 최종 응답을 만든 모델. Fable refusal fallback 때 requested model 과 다르다.
+  servedModel?: string;
+  stopReason?: string;
+  refusal?: {
+    category?: string;
+    explanation?: string;
+  };
+  modelFallbacks?: Array<ModelFallback>;
 }
 
 export interface ClaudeStreamJsonState {
   structuredOutputText?: string;
+  servedModel?: string;
+  stopReason?: string;
+  refusal?: {
+    category?: string;
+    explanation?: string;
+  };
+  modelFallbacks?: Array<ModelFallback>;
+  refusalWithoutFallback?: boolean;
 }
 
 // Anthropic usage 4 카테고리 → TokenUsageBreakdown.
@@ -154,11 +181,15 @@ function toUsageBreakdown(u: ClaudeUsage): ProviderTokenUsageBreakdown {
   const cacheRead = u.cache_read_input_tokens ?? 0;
   const output = u.output_tokens ?? 0;
   const totalInput = input + cacheCreate + cacheRead;
+  const cacheCreate5m = u.cache_creation?.ephemeral_5m_input_tokens;
+  const cacheCreate1h = u.cache_creation?.ephemeral_1h_input_tokens;
   return {
     totalTokens: totalInput + output,
     inputTokens: totalInput,
     cachedInputTokens: cacheRead,
     cacheCreationInputTokens: cacheCreate,
+    ...(typeof cacheCreate5m === "number" ? { cacheCreationInputTokens5m: cacheCreate5m } : {}),
+    ...(typeof cacheCreate1h === "number" ? { cacheCreationInputTokens1h: cacheCreate1h } : {}),
     outputTokens: output,
     reasoningOutputTokens: 0,
   };
@@ -190,6 +221,91 @@ function structuredOutputToolUseText(j: ResponseItem): string | undefined {
   return undefined;
 }
 
+function canonicalEventModel(model: string): string {
+  const withoutProvider = model.startsWith("anthropic/") ? model.slice("anthropic/".length) : model;
+  return withoutProvider.replace(/\[1m\]$/, "");
+}
+
+function optionalString(value: JsonValue | undefined): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function recordFallback(state: ClaudeStreamJsonState | undefined, fallback: ModelFallback): void {
+  if (!state) return;
+  const normalized: ModelFallback = {
+    ...fallback,
+    fromModel: canonicalEventModel(fallback.fromModel),
+    toModel: canonicalEventModel(fallback.toModel),
+  };
+  const existing = state.modelFallbacks?.find(
+    (item) =>
+      item.trigger === normalized.trigger &&
+      item.fromModel === normalized.fromModel &&
+      item.toModel === normalized.toModel,
+  );
+  if (existing) {
+    existing.category ??= normalized.category;
+    existing.explanation ??= normalized.explanation;
+  } else {
+    (state.modelFallbacks ??= []).push(normalized);
+  }
+  state.servedModel = normalized.toModel;
+  state.refusalWithoutFallback = false;
+}
+
+function updateRoutingFromUsage(
+  usage: ResponseItem | null,
+  state: ClaudeStreamJsonState | undefined,
+): void {
+  if (!state || !usage || !Array.isArray(usage.iterations)) return;
+
+  let previousModel: string | undefined;
+  for (const raw of usage.iterations) {
+    const iteration = asObject(raw);
+    if (!iteration) continue;
+    const model = optionalString(iteration.model);
+    const type = optionalString(iteration.type);
+    if (!model) continue;
+    const canonicalModel = canonicalEventModel(model);
+    if (type === "fallback_message" && previousModel) {
+      recordFallback(state, {
+        trigger: "refusal",
+        fromModel: previousModel,
+        toModel: canonicalModel,
+      });
+    }
+    previousModel = canonicalModel;
+    state.servedModel = canonicalModel;
+  }
+}
+
+function updateRoutingFromMessage(
+  message: ResponseItem | null,
+  state: ClaudeStreamJsonState | undefined,
+): void {
+  if (!state || !message) return;
+  const model = optionalString(message.model);
+  const canonicalModel = model ? canonicalEventModel(model) : undefined;
+  if (canonicalModel) state.servedModel = canonicalModel;
+  const stopReason = optionalString(message.stop_reason);
+  if (stopReason) {
+    state.stopReason = stopReason;
+    if (stopReason === "refusal") state.refusalWithoutFallback = true;
+    else if (state.modelFallbacks?.some((fallback) => fallback.toModel === canonicalModel)) {
+      state.refusalWithoutFallback = false;
+    }
+  }
+
+  const stopDetails = asObject(message.stop_details);
+  if (stopDetails?.type === "refusal" || stopReason === "refusal") {
+    state.refusal = {
+      category: optionalString(stopDetails?.category),
+      explanation: optionalString(stopDetails?.explanation),
+    };
+  }
+  updateRoutingFromUsage(asObject(message.usage), state);
+}
+
 // Processes one Claude stdout JSONL line. Returns final result on result event.
 export function handleStreamJsonLine(
   line: string,
@@ -210,6 +326,16 @@ export function handleStreamJsonLine(
 
   if (j.type === "stream_event") {
     const event = asObject(j.event);
+    if (event?.type === "message_start") {
+      updateRoutingFromMessage(asObject(event.message), state);
+    } else if (event?.type === "message_delta") {
+      const delta = asObject(event.delta);
+      const stopReason = optionalString(delta?.stop_reason);
+      if (state && stopReason) {
+        state.stopReason = stopReason;
+        if (stopReason === "refusal") state.refusalWithoutFallback = true;
+      }
+    }
     if (event && event.type === "content_block_delta") {
       const delta = asObject(event.delta);
       if (delta) {
@@ -227,14 +353,55 @@ export function handleStreamJsonLine(
     return null;
   }
 
-  if (
-    j.type === "assistant" &&
-    structuredOutput &&
-    state &&
-    state.structuredOutputText === undefined
-  ) {
-    const text = structuredOutputToolUseText(j);
-    if (text !== undefined) state.structuredOutputText = text;
+  if (j.type === "system") {
+    const subtype = optionalString(j.subtype);
+    if (subtype === "model_refusal_fallback") {
+      const fromModel = optionalString(j.originalModel) ?? optionalString(j.original_model);
+      const toModel = optionalString(j.fallbackModel) ?? optionalString(j.fallback_model);
+      if (fromModel && toModel) {
+        recordFallback(state, {
+          trigger: "refusal",
+          fromModel,
+          toModel,
+          category:
+            optionalString(j.apiRefusalCategory) ??
+            optionalString(j.api_refusal_category) ??
+            optionalString(j.refusalCategory) ??
+            optionalString(j.refusal_category),
+          explanation:
+            optionalString(j.apiRefusalExplanation) ??
+            optionalString(j.api_refusal_explanation) ??
+            optionalString(j.refusalExplanation) ??
+            optionalString(j.refusal_explanation),
+        });
+      }
+    } else if (subtype === "model_refusal_no_fallback" && state) {
+      const originalModel = optionalString(j.originalModel) ?? optionalString(j.original_model);
+      if (originalModel) state.servedModel = canonicalEventModel(originalModel);
+      state.stopReason = "refusal";
+      state.refusalWithoutFallback = true;
+      state.refusal = {
+        category:
+          optionalString(j.apiRefusalCategory) ??
+          optionalString(j.api_refusal_category) ??
+          optionalString(j.refusalCategory) ??
+          optionalString(j.refusal_category),
+        explanation:
+          optionalString(j.apiRefusalExplanation) ??
+          optionalString(j.api_refusal_explanation) ??
+          optionalString(j.refusalExplanation) ??
+          optionalString(j.refusal_explanation),
+      };
+    }
+    return null;
+  }
+
+  if (j.type === "assistant") {
+    updateRoutingFromMessage(asObject(j.message), state);
+    if (structuredOutput && state && state.structuredOutputText === undefined) {
+      const text = structuredOutputToolUseText(j);
+      if (text !== undefined) state.structuredOutputText = text;
+    }
     return null;
   }
 
@@ -249,7 +416,18 @@ export function handleStreamJsonLine(
       text = stripCodeFence(typeof j.result === "string" ? j.result : "");
     }
 
-    const usage = toUsageBreakdown((asObject(j.usage) ?? {}) as ClaudeUsage);
+    const rawUsage = asObject(j.usage) ?? {};
+    updateRoutingFromUsage(rawUsage, state);
+    const resultModel = optionalString(j.model);
+    if (state && resultModel && !state.servedModel) {
+      state.servedModel = canonicalEventModel(resultModel);
+    }
+    const resultStopReason = optionalString(j.stop_reason);
+    if (state && resultStopReason) {
+      state.stopReason = resultStopReason;
+      if (resultStopReason === "refusal") state.refusalWithoutFallback = true;
+    }
+    const usage = toUsageBreakdown(rawUsage as ClaudeUsage);
     const quotaExhausted = text.startsWith("You've hit");
     const subtype = typeof j.subtype === "string" ? j.subtype : undefined;
     const terminalReason = typeof j.terminal_reason === "string" ? j.terminal_reason : undefined;
@@ -264,7 +442,8 @@ export function handleStreamJsonLine(
     const isError =
       j.is_error === true ||
       j.terminal_reason === "model_error" ||
-      (subtype !== undefined && subtype !== "success");
+      (subtype !== undefined && subtype !== "success") ||
+      state?.refusalWithoutFallback === true;
 
     return {
       text,
@@ -275,6 +454,10 @@ export function handleStreamJsonLine(
       isError,
       subtype,
       terminalReason,
+      servedModel: state?.servedModel,
+      stopReason: state?.stopReason,
+      refusal: state?.refusal,
+      modelFallbacks: state?.modelFallbacks,
     };
   }
 

package/bundle/src/utils/providers/common/model-cost.test.ts

@@ -3,6 +3,86 @@ import { describe, expect, it } from "vitest";
 import { calculateCostUsd, getModelCosts } from "./model-cost";
 
 describe("calculateCostUsd", () => {
+  it.each([
+    ["gpt-5.6-sol", 5, 30, 0.5, 6.25],
+    ["gpt-5.6-terra", 2.5, 15, 0.25, 3.125],
+    ["gpt-5.6-luna", 1, 6, 0.1, 1.25],
+    ["gpt-5.5", 5, 30, 0.5, undefined],
+    ["gpt-5.4", 2.5, 15, 0.25, undefined],
+    ["gpt-5.4-mini", 0.75, 4.5, 0.075, undefined],
+    ["gpt-5.3-codex", 1.75, 14, 0.175, undefined],
+    ["gpt-5.2", 1.75, 14, 0.175, undefined],
+  ])(
+    "%s official OpenAI rates",
+    (model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens) => {
+      expect(getModelCosts(model)).toEqual(
+        expect.objectContaining({
+          inputTokens,
+          outputTokens,
+          cachedInputTokens,
+          ...(cacheCreationInputTokens === undefined ? {} : { cacheCreationInputTokens }),
+        }),
+      );
+      if (cacheCreationInputTokens === undefined) {
+        expect(getModelCosts(model).cacheCreationInputTokens).toBeUndefined();
+      }
+    },
+  );
+
+  it.each([
+    ["claude-fable-5", 10, 50, 1, 20],
+    ["claude-haiku-4-5", 1, 5, 0.1, 2],
+    ["claude-sonnet-4", 3, 15, 0.3, 6],
+    ["claude-sonnet-4-5", 3, 15, 0.3, 6],
+    ["claude-sonnet-4-6", 3, 15, 0.3, 6],
+    ["claude-sonnet-4-7", 3, 15, 0.3, 6],
+    ["claude-opus-4", 15, 75, 1.5, 30],
+    ["claude-opus-4-1", 15, 75, 1.5, 30],
+    ["claude-opus-4-5", 5, 25, 0.5, 10],
+    ["claude-opus-4-6", 5, 25, 0.5, 10],
+    ["claude-opus-4-7", 5, 25, 0.5, 10],
+    ["claude-opus-4-8", 5, 25, 0.5, 10],
+  ])(
+    "%s official Anthropic rates for 5m/1h cache writes",
+    (model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens) => {
+      expect(getModelCosts(model)).toMatchObject({
+        inputTokens,
+        outputTokens,
+        cachedInputTokens,
+        cacheCreationInputTokens,
+        cacheCreationInputTokens5m: inputTokens * 1.25,
+        cacheCreationInputTokens1h: inputTokens * 2,
+      });
+    },
+  );
+
+  it("Claude Sonnet 5 introductory pricing switches to standard pricing on 2026-09-01", () => {
+    expect(getModelCosts("claude-sonnet-5", Date.UTC(2026, 7, 31))).toEqual({
+      inputTokens: 2,
+      outputTokens: 10,
+      cachedInputTokens: 0.2,
+      cacheCreationInputTokens: 4,
+      cacheCreationInputTokens5m: 2.5,
+      cacheCreationInputTokens1h: 4,
+    });
+    expect(getModelCosts("claude-sonnet-5", Date.UTC(2026, 8, 1))).toEqual({
+      inputTokens: 3,
+      outputTokens: 15,
+      cachedInputTokens: 0.3,
+      cacheCreationInputTokens: 6,
+      cacheCreationInputTokens5m: 3.75,
+      cacheCreationInputTokens1h: 6,
+    });
+  });
+
+  it("provider prefix 와 [1m] suffix 를 제거한 canonical model 로 가격을 찾는다", () => {
+    expect(getModelCosts("anthropic/claude-fable-5")).toBe(getModelCosts("claude-fable-5"));
+    expect(getModelCosts("anthropic/claude-sonnet-4-6[1m]")).toBe(
+      getModelCosts("claude-sonnet-4-6"),
+    );
+    expect(getModelCosts("openai/gpt-5.6-sol")).toBe(getModelCosts("gpt-5.6-sol"));
+  });
+
   it.each([
     ["gpt-5.6-sol", 5, 30, 0.5, 6.25, 3.30625],
     ["gpt-5.6-terra", 2.5, 15, 0.25, 3.125, 1.653125],
@@ -68,7 +148,7 @@ describe("calculateCostUsd", () => {
     expect(cost).toBeCloseTo(0.0054012, 10);
   });
 
-  it("Anthropic cache creation 은 Claude Code 기본인 5분 write 단가를 적용한다", () => {
+  it("Anthropic cache creation 은 subscription Claude Code 기본인 1시간 write 단가를 적용한다", () => {
     const cost = calculateCostUsd("claude-sonnet-4-6", {
       inputTokens: 1_992,
       outputTokens: 187,
@@ -76,7 +156,61 @@ describe("calculateCostUsd", () => {
       cacheCreationInputTokens: 1_068,
     });
 
-    expect(cost).toBeCloseTo(0.009582, 10);
+    expect(cost).toBeCloseTo(0.011985, 10);
+  });
+
+  it("Anthropic cache creation 의 5분/1시간 token breakdown 을 각각 계산한다", () => {
+    const cost = calculateCostUsd("claude-sonnet-4-6", {
+      inputTokens: 100_000,
+      outputTokens: 0,
+      cachedInputTokens: 0,
+      cacheCreationInputTokens: 80_000,
+      cacheCreationInputTokens5m: 30_000,
+      cacheCreationInputTokens1h: 50_000,
+    });
+
+    expect(cost).toBeCloseTo(0.4725, 10);
+  });
+
+  it("Fable input/output/cache read/1h cache write 단가를 각각 적용한다", () => {
+    expect(
+      calculateCostUsd("claude-fable-5", {
+        inputTokens: 100_000,
+        outputTokens: 100_000,
+        cachedInputTokens: 50_000,
+        cacheCreationInputTokens: 25_000,
+      }),
+    ).toBeCloseTo(5.8, 10);
+  });
+
+  it("Fable 의 5분/1시간 cache write 단가도 구분한다", () => {
+    expect(
+      calculateCostUsd("claude-fable-5", {
+        inputTokens: 100_000,
+        outputTokens: 100_000,
+        cachedInputTokens: 50_000,
+        cacheCreationInputTokens: 25_000,
+        cacheCreationInputTokens5m: 10_000,
+        cacheCreationInputTokens1h: 15_000,
+      }),
+    ).toBeCloseTo(5.725, 10);
+  });
+
+  it("Sonnet 5 introductory/standard 단가 전환을 cost 계산에도 적용한다", () => {
+    const usage = {
+      inputTokens: 100_000,
+      outputTokens: 100_000,
+      cachedInputTokens: 50_000,
+      cacheCreationInputTokens: 25_000,
+    };
+    expect(calculateCostUsd("claude-sonnet-5", usage, Date.UTC(2026, 7, 31))).toBeCloseTo(
+      1.16,
+      10,
+    );
+    expect(calculateCostUsd("claude-sonnet-5", usage, Date.UTC(2026, 8, 1))).toBeCloseTo(
+      1.74,
+      10,
+    );
   });
 
   it("legacy/원시 Anthropic usage 처럼 cache 가 input 보다 커도 음수 비용을 만들지 않는다", () => {