@cartanova/qgrid-cli 2.4.7 → 2.4.9

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,87 @@ 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],
+    ["claude-opus-5", 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 +149,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 +157,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 보다 커도 음수 비용을 만들지 않는다", () => {

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

@@ -14,7 +14,10 @@ export interface ModelCosts {
   inputTokens: number;
   outputTokens: number;
   cachedInputTokens: number;
+  /** TTL breakdown 이 없는 usage 에 적용할 cache write fallback 단가. */
   cacheCreationInputTokens?: number;
+  cacheCreationInputTokens5m?: number;
+  cacheCreationInputTokens1h?: number;
   /**
    * long-context 할증. 전체 입력 토큰(input_tokens, cache_read 포함)이 threshold 초과 시
    * 초과분만이 아니라 요청 전체(full session)에 배율 적용.
@@ -29,7 +32,7 @@ export interface ModelCosts {
 
 // ── OpenAI — codex app-server 에서 사용 가능한 모델 ─────────────────
 //
-// 가격 출처: https://openai.com/api/pricing (2026-06-11 확인)
+// 가격 출처: https://developers.openai.com/api/docs/models (2026-07-18 확인)
 // 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함
 
 // GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)
@@ -97,105 +100,57 @@ const OPENAI_COSTS: Record<string, ModelCosts> = {
 
 // ── Anthropic ───────────────────────────────────────────────────────
 
+function anthropicCosts(inputTokens: number, outputTokens: number): ModelCosts {
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens: inputTokens / 10,
+    // Claude Code subscription OAuth 는 1h TTL 을 자동 선택한다. 구버전처럼 응답에
+    // TTL breakdown 이 없을 때만 이 1h 단가를 fallback 으로 사용한다.
+    cacheCreationInputTokens: inputTokens * 2,
+    cacheCreationInputTokens5m: inputTokens * 1.25,
+    cacheCreationInputTokens1h: inputTokens * 2,
+  };
+}
+
 const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
-  // Claude Code 는 별도 ttl:"1h" 옵션 없이 실행되므로 fallback 가격표는 5분 cache write(1.25x)를 기준으로 둔다.
-  // 1시간 cache write 는 input 2x 이지만 현재 qgrid 실행 경로의 기본값이 아니다.
-  sonnet: {
-    inputTokens: 3,
-    outputTokens: 15,
-    cachedInputTokens: 0.3,
-    cacheCreationInputTokens: 3.75,
-  },
-  "claude-3-5-haiku": {
-    inputTokens: 0.8,
-    outputTokens: 4,
-    cachedInputTokens: 0.08,
-    cacheCreationInputTokens: 1,
-  },
-  "claude-haiku-4-5": {
-    inputTokens: 1,
-    outputTokens: 5,
-    cachedInputTokens: 0.1,
-    cacheCreationInputTokens: 1.25,
-  },
-  "claude-3-5-sonnet": {
-    inputTokens: 3,
-    outputTokens: 15,
-    cachedInputTokens: 0.3,
-    cacheCreationInputTokens: 3.75,
-  },
-  "claude-3-7-sonnet": {
-    inputTokens: 3,
-    outputTokens: 15,
-    cachedInputTokens: 0.3,
-    cacheCreationInputTokens: 3.75,
-  },
-  "claude-sonnet-4": {
-    inputTokens: 3,
-    outputTokens: 15,
-    cachedInputTokens: 0.3,
-    cacheCreationInputTokens: 3.75,
-  },
-  "claude-sonnet-4-5": {
-    inputTokens: 3,
-    outputTokens: 15,
-    cachedInputTokens: 0.3,
-    cacheCreationInputTokens: 3.75,
-  },
-  "claude-sonnet-4-6": {
-    inputTokens: 3,
-    outputTokens: 15,
-    cachedInputTokens: 0.3,
-    cacheCreationInputTokens: 3.75,
-  },
-  "claude-sonnet-4-7": {
-    inputTokens: 3,
-    outputTokens: 15,
-    cachedInputTokens: 0.3,
-    cacheCreationInputTokens: 3.75,
-  },
-  "claude-opus-4": {
-    inputTokens: 15,
-    outputTokens: 75,
-    cachedInputTokens: 1.5,
-    cacheCreationInputTokens: 18.75,
-  },
-  "claude-opus-4-1": {
-    inputTokens: 15,
-    outputTokens: 75,
-    cachedInputTokens: 1.5,
-    cacheCreationInputTokens: 18.75,
-  },
-  "claude-opus-4-5": {
-    inputTokens: 5,
-    outputTokens: 25,
-    cachedInputTokens: 0.5,
-    cacheCreationInputTokens: 6.25,
-  },
-  "claude-opus-4-6": {
-    inputTokens: 5,
-    outputTokens: 25,
-    cachedInputTokens: 0.5,
-    cacheCreationInputTokens: 6.25,
-  },
-  "claude-opus-4-7": {
-    inputTokens: 5,
-    outputTokens: 25,
-    cachedInputTokens: 0.5,
-    cacheCreationInputTokens: 6.25,
-  },
-  "claude-opus-4-8": {
-    inputTokens: 5,
-    outputTokens: 25,
-    cachedInputTokens: 0.5,
-    cacheCreationInputTokens: 6.25,
-  },
+  "claude-fable-5": anthropicCosts(10, 50),
+  sonnet: anthropicCosts(3, 15),
+  "claude-3-5-haiku": anthropicCosts(0.8, 4),
+  "claude-haiku-4-5": anthropicCosts(1, 5),
+  "claude-3-5-sonnet": anthropicCosts(3, 15),
+  "claude-3-7-sonnet": anthropicCosts(3, 15),
+  "claude-sonnet-4": anthropicCosts(3, 15),
+  "claude-sonnet-4-5": anthropicCosts(3, 15),
+  "claude-sonnet-4-6": anthropicCosts(3, 15),
+  "claude-sonnet-4-7": anthropicCosts(3, 15),
+  "claude-opus-4": anthropicCosts(15, 75),
+  "claude-opus-4-1": anthropicCosts(15, 75),
+  "claude-opus-4-5": anthropicCosts(5, 25),
+  "claude-opus-4-6": anthropicCosts(5, 25),
+  "claude-opus-4-7": anthropicCosts(5, 25),
+  "claude-opus-4-8": anthropicCosts(5, 25),
+  "claude-opus-5": anthropicCosts(5, 25),
 };
 
+// Anthropic 공식 introductory pricing: 2026-08-31까지 $2/$10, 이후 $3/$15.
+// qgrid 는 요청 시점에 계산하므로 배포를 다시 하지 않아도 2026-09-01 UTC부터 표준 단가로 전환한다.
+const CLAUDE_SONNET_5_INTRO_PRICING_END_MS = Date.UTC(2026, 8, 1);
+const CLAUDE_SONNET_5_INTRO_COSTS = anthropicCosts(2, 10);
+const CLAUDE_SONNET_5_STANDARD_COSTS = anthropicCosts(3, 15);
+
+// gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.
+// 지원 타입은 유지하되, 공식 단가가 공개될 때까지 아래 generic estimate 로 계산한다.
+// @see https://help.openai.com/en/articles/20001106-codex-rate-card
 const DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };
 
-export function getModelCosts(model: string): ModelCosts {
-  const normalizedModel = model.replace(/\[1m\]$/i, "");
+export function getModelCosts(model: string, atMs = Date.now()): ModelCosts {
+  const normalizedModel = (model.split("/").pop() ?? model).replace(/\[1m\]$/i, "");
+  if (normalizedModel === "claude-sonnet-5") {
+    return atMs < CLAUDE_SONNET_5_INTRO_PRICING_END_MS
+      ? CLAUDE_SONNET_5_INTRO_COSTS
+      : CLAUDE_SONNET_5_STANDARD_COSTS;
+  }
   return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;
 }
 
@@ -206,11 +161,26 @@ export function calculateCostUsd(
     outputTokens: number;
     cachedInputTokens?: number;
     cacheCreationInputTokens?: number;
+    cacheCreationInputTokens5m?: number;
+    cacheCreationInputTokens1h?: number;
   },
+  atMs = Date.now(),
 ): number {
-  const costs = getModelCosts(model);
+  const costs = getModelCosts(model, atMs);
   const cachedInput = usage.cachedInputTokens ?? 0;
-  const cacheCreationInput = usage.cacheCreationInputTokens ?? 0;
+  const cacheCreationInput5m = Math.max(usage.cacheCreationInputTokens5m ?? 0, 0);
+  const cacheCreationInput1h = Math.max(usage.cacheCreationInputTokens1h ?? 0, 0);
+  const cacheCreationInput = Math.max(
+    usage.cacheCreationInputTokens ?? 0,
+    cacheCreationInput5m + cacheCreationInput1h,
+  );
+  const classifiedCacheCreationInput5m = Math.min(cacheCreationInput5m, cacheCreationInput);
+  const classifiedCacheCreationInput1h = Math.min(
+    cacheCreationInput1h,
+    cacheCreationInput - classifiedCacheCreationInput5m,
+  );
+  const unclassifiedCacheCreationInput =
+    cacheCreationInput - classifiedCacheCreationInput5m - classifiedCacheCreationInput1h;
   const nonCachedInput = Math.max(usage.inputTokens - cachedInput - cacheCreationInput, 0);
 
   // long-context 할증: 전체 입력(input_tokens, cache 포함)이 threshold 초과 시 요청 전체에 배율 적용
@@ -218,15 +188,23 @@ export function calculateCostUsd(
   const isLongContext = lc !== undefined && usage.inputTokens > lc.threshold;
   const inputRate = costs.inputTokens * (isLongContext ? lc.inputMultiplier : 1);
   const cachedRate = costs.cachedInputTokens * (isLongContext ? lc.cachedInputMultiplier : 1);
-  const cacheCreationRate =
+  const cacheCreationFallbackRate =
     (costs.cacheCreationInputTokens ?? costs.inputTokens) *
     (isLongContext ? lc.inputMultiplier : 1);
+  const cacheCreation5mRate =
+    (costs.cacheCreationInputTokens5m ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *
+    (isLongContext ? lc.inputMultiplier : 1);
+  const cacheCreation1hRate =
+    (costs.cacheCreationInputTokens1h ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *
+    (isLongContext ? lc.inputMultiplier : 1);
   const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);
 
   return (
     (nonCachedInput / 1_000_000) * inputRate +
     (usage.outputTokens / 1_000_000) * outputRate +
     (cachedInput / 1_000_000) * cachedRate +
-    (cacheCreationInput / 1_000_000) * cacheCreationRate
+    (unclassifiedCacheCreationInput / 1_000_000) * cacheCreationFallbackRate +
+    (classifiedCacheCreationInput5m / 1_000_000) * cacheCreation5mRate +
+    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate
   );
 }