@cartanova/qgrid-cli 2.4.6 → 2.4.8

package/bundle/src/application/qgrid/qgrid.dispatcher.test.ts

@@ -369,6 +369,87 @@ describe("QgridDispatcherClass", () => {
     expect(result.usage.cache_creation_input_tokens).toBe(600);
   });
 
+  it("provider cost 가 0이면 Anthropic 5m/1h cache breakdown 으로 fallback cost 를 계산한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(
+      async (_req: GenerateRequest): Promise<GenerateResult> => ({
+        text: "ok",
+        tokenName: "anthropic/test",
+        usage: {
+          totalTokens: 100_000,
+          inputTokens: 100_000,
+          cachedInputTokens: 0,
+          cacheCreationInputTokens: 80_000,
+          cacheCreationInputTokens5m: 30_000,
+          cacheCreationInputTokens1h: 50_000,
+          outputTokens: 0,
+          reasoningOutputTokens: 0,
+        },
+        durationMs: 12,
+        costUsd: 0,
+        model: "claude-sonnet-4-6",
+        threadCoord: { workerId: 1, threadId: "sess-1", epoch: 0 },
+      }),
+    );
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    const result = await dispatcher.query({ prompt: "hi", model: "anthropic/claude-sonnet-4-6" });
+
+    expect(result.costUsd).toBeCloseTo(0.4725, 10);
+    expect(result.usage.cache_creation_input_tokens).toBe(80_000);
+    expect(result.usage.cache_creation_5m_input_tokens).toBe(30_000);
+    expect(result.usage.cache_creation_1h_input_tokens).toBe(50_000);
+    expect(result.costSource).toBe("pricing_table");
+  });
+
+  it("Fable refusal fallback은 실제 serving model과 requested model을 구분한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(
+      async (_req: GenerateRequest): Promise<GenerateResult> => ({
+        text: "served by opus",
+        tokenName: "anthropic/test",
+        usage: {
+          totalTokens: 120,
+          inputTokens: 100,
+          cachedInputTokens: 0,
+          outputTokens: 20,
+          reasoningOutputTokens: 0,
+        },
+        durationMs: 12,
+        costUsd: 0.003,
+        requestedModel: "claude-fable-5",
+        model: "claude-opus-4-8",
+        modelFallbacks: [
+          {
+            trigger: "refusal",
+            fromModel: "claude-fable-5",
+            toModel: "claude-opus-4-8",
+            category: "cyber",
+          },
+        ],
+        threadCoord: { workerId: 1, threadId: "sess-1", epoch: 0 },
+      }),
+    );
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    const result = await dispatcher.query({ prompt: "hi", model: "anthropic/claude-fable-5" });
+
+    expect(result).toMatchObject({
+      model: "claude-opus-4-8",
+      requestedModel: "claude-fable-5",
+      costUsd: 0.003,
+      costSource: "provider",
+      modelFallbacks: [
+        {
+          trigger: "refusal",
+          fromModel: "claude-fable-5",
+          toModel: "claude-opus-4-8",
+          category: "cyber",
+        },
+      ],
+    });
+  });
+
   it("provider ttftMs 를 QueryOutput.ttftMs 로 매핑하고 누락 값은 0 으로 둔다", async () => {
     const dispatcher = new QgridDispatcherClass();
     const generate = vi

package/bundle/src/application/qgrid/qgrid.dispatcher.ts

@@ -256,27 +256,34 @@ function buildRawOutputSchema(
 function toEmulationResult(
   result: GenerateResult,
 ): Omit<QueryOutput, "content" | "finishReason" | "runContext"> {
+  const hasProviderCost = result.costUsd !== undefined && result.costUsd > 0;
   return {
     text: result.text,
     tokenName: result.tokenName,
     model: result.model,
+    requestedModel: result.requestedModel,
+    modelFallbacks: result.modelFallbacks,
     usage: {
       input_tokens: result.usage.inputTokens,
       output_tokens: result.usage.outputTokens,
       cache_creation_input_tokens: result.usage.cacheCreationInputTokens ?? 0,
+      cache_creation_5m_input_tokens: result.usage.cacheCreationInputTokens5m,
+      cache_creation_1h_input_tokens: result.usage.cacheCreationInputTokens1h,
       cache_read_input_tokens: result.usage.cachedInputTokens,
     },
     durationMs: result.durationMs,
     ttftMs: result.ttftMs ?? 0,
-    costUsd:
-      result.costUsd !== undefined && result.costUsd > 0
-        ? result.costUsd
-        : calculateCostUsd(result.model, {
-            inputTokens: result.usage.inputTokens,
-            outputTokens: result.usage.outputTokens,
-            cachedInputTokens: result.usage.cachedInputTokens,
-            cacheCreationInputTokens: result.usage.cacheCreationInputTokens ?? 0,
-          }),
+    costUsd: hasProviderCost
+      ? result.costUsd!
+      : calculateCostUsd(result.model, {
+          inputTokens: result.usage.inputTokens,
+          outputTokens: result.usage.outputTokens,
+          cachedInputTokens: result.usage.cachedInputTokens,
+          cacheCreationInputTokens: result.usage.cacheCreationInputTokens ?? 0,
+          cacheCreationInputTokens5m: result.usage.cacheCreationInputTokens5m,
+          cacheCreationInputTokens1h: result.usage.cacheCreationInputTokens1h,
+        }),
+    costSource: hasProviderCost ? "provider" : "pricing_table",
   };
 }
 

package/bundle/src/application/qgrid/qgrid.frame.ts

@@ -157,6 +157,8 @@ class QgridFrameClass extends BaseFrameClass {
         token_name: result.tokenName,
         project_name: args.projectName?.length ? args.projectName : null,
         model_name: result.model ?? null,
+        requested_model_name: result.requestedModel ?? result.model ?? args.model ?? null,
+        fallback_count: result.modelFallbacks?.length ?? 0,
         user_prompt: args.prompt,
         system_prompt: args.system ?? null,
         response: responseText,
@@ -164,9 +166,12 @@ class QgridFrameClass extends BaseFrameClass {
         output_tokens: result.usage.output_tokens,
         cache_read_tokens: result.usage.cache_read_input_tokens,
         cache_creation_tokens: result.usage.cache_creation_input_tokens,
+        cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens ?? null,
+        cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens ?? null,
         duration_ms: result.durationMs,
         ttft_ms: result.ttftMs,
         cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,
+        cost_source: result.costSource,
         image_cost_usd: imageCostMicroUsd,
         image_cost_method:
           imageCostMicroUsd !== null
@@ -332,10 +337,17 @@ class QgridFrameClass extends BaseFrameClass {
     const stepId = await RequestLogModel.appendStep(input.requestLogId, {
       step_index: input.stepIndex,
       type: input.type,
+      model_name: input.modelName,
+      requested_model_name: input.requestedModelName,
+      fallback_count: input.fallbackCount,
       input_tokens: input.inputTokens,
       output_tokens: input.outputTokens,
       cache_read_tokens: input.cacheReadTokens,
       cache_creation_tokens: input.cacheCreationTokens,
+      cache_creation_5m_tokens: input.cacheCreation5mTokens,
+      cache_creation_1h_tokens: input.cacheCreation1hTokens,
+      cost_usd: input.costUsd === undefined ? undefined : Math.round(input.costUsd * MICRO_USD),
+      cost_source: input.costSource,
       duration_ms: input.durationMs,
       ttft_ms: input.ttftMs ?? null,
       finish_reason: input.finishReason,
@@ -358,10 +370,17 @@ class QgridFrameClass extends BaseFrameClass {
       status: input.status,
       response: input.response,
       token_name: input.tokenName,
+      model_name: input.modelName,
+      requested_model_name: input.requestedModelName,
+      fallback_count: input.fallbackCount,
       input_tokens: input.totalInputTokens,
       output_tokens: input.totalOutputTokens,
       cache_read_tokens: input.totalCacheReadTokens,
       cache_creation_tokens: input.totalCacheCreationTokens,
+      cache_creation_5m_tokens: input.totalCacheCreation5mTokens,
+      cache_creation_1h_tokens: input.totalCacheCreation1hTokens,
+      cost_usd: input.costUsd === undefined ? undefined : Math.round(input.costUsd * MICRO_USD),
+      cost_source: input.costSource,
       duration_ms: input.totalDurationMs,
       history: input.history ? JSON.parse(input.history) : undefined,
       error_message: input.errorMessage,

package/bundle/src/application/qgrid/qgrid.types.ts

@@ -125,21 +125,38 @@ export const QueryInput = z.object({
 });
 export type QueryInput = z.infer<typeof QueryInput>;
 
+export const ModelFallback = z.object({
+  trigger: z.literal("refusal"),
+  fromModel: z.string(),
+  toModel: z.string(),
+  category: z.string().optional(),
+  explanation: z.string().optional(),
+});
+export type ModelFallback = z.infer<typeof ModelFallback>;
+
+export const CostSource = z.enum(["provider", "pricing_table", "mixed"]);
+export type CostSource = z.infer<typeof CostSource>;
+
 export const QueryOutput = z.object({
   text: z.string(),
   content: z.array(QgridContent),
   finishReason: FinishReason,
   tokenName: z.string().optional(),
   model: z.string().optional(),
+  requestedModel: z.string().optional(),
+  modelFallbacks: z.array(ModelFallback).optional(),
   usage: z.object({
     input_tokens: z.number(),
     output_tokens: z.number(),
     cache_creation_input_tokens: z.number(),
+    cache_creation_5m_input_tokens: z.number().optional(),
+    cache_creation_1h_input_tokens: z.number().optional(),
     cache_read_input_tokens: z.number(),
   }),
   durationMs: z.number(),
   ttftMs: z.number(),
   costUsd: z.number(),
+  costSource: CostSource,
   runContext: QgridRunContext.optional(),
 });
 export type QueryOutput = z.infer<typeof QueryOutput>;
@@ -156,17 +173,22 @@ export const StreamEvents = z.object({
   done: z.object({
     text: z.string(),
     model: z.string().optional(),
+    requestedModel: z.string().optional(),
+    modelFallbacks: z.array(ModelFallback).optional(),
     tokenName: z.string().optional(),
     finishReason: FinishReason,
     usage: z.object({
       input_tokens: z.number(),
       output_tokens: z.number(),
       cache_creation_input_tokens: z.number(),
+      cache_creation_5m_input_tokens: z.number().optional(),
+      cache_creation_1h_input_tokens: z.number().optional(),
       cache_read_input_tokens: z.number(),
     }),
     durationMs: z.number(),
     ttftMs: z.number(),
     costUsd: z.number(),
+    costSource: CostSource,
     content: z.array(QgridContent),
     runContext: QgridRunContext.optional(),
   }),
@@ -190,10 +212,17 @@ export const AppendStepInput = z.object({
   requestLogId: z.number(),
   stepIndex: z.number(),
   type: z.enum(["generate", "tool_call"]),
+  modelName: z.string().optional(),
+  requestedModelName: z.string().optional(),
+  fallbackCount: z.number().optional(),
   inputTokens: z.number().optional(),
   outputTokens: z.number().optional(),
   cacheReadTokens: z.number().optional(),
   cacheCreationTokens: z.number().optional(),
+  cacheCreation5mTokens: z.number().optional(),
+  cacheCreation1hTokens: z.number().optional(),
+  costUsd: z.number().optional(),
+  costSource: CostSource.optional(),
   durationMs: z.number().optional(),
   ttftMs: z.number().nullable().optional(),
   finishReason: z.string().optional(),
@@ -214,10 +243,17 @@ export const FinishRunInput = z.object({
   status: z.enum(["succeeded", "error", "aborted"]),
   response: z.string().optional(),
   tokenName: z.string().optional(),
+  modelName: z.string().optional(),
+  requestedModelName: z.string().optional(),
+  fallbackCount: z.number().optional(),
   totalInputTokens: z.number().optional(),
   totalOutputTokens: z.number().optional(),
   totalCacheReadTokens: z.number().optional(),
   totalCacheCreationTokens: z.number().optional(),
+  totalCacheCreation5mTokens: z.number().optional(),
+  totalCacheCreation1hTokens: z.number().optional(),
+  costUsd: z.number().optional(),
+  costSource: CostSource.optional(),
   totalDurationMs: z.number().optional(),
   history: z.string().optional(),
   errorMessage: z.string().optional(),

package/bundle/src/application/qgrid/tool-emulation.test.ts

@@ -63,6 +63,7 @@ describe("applyToolCallEmulation image parts", () => {
     durationMs: 10,
     ttftMs: 0,
     costUsd: 0,
+    costSource: "pricing_table" as const,
   };
   const img = { data: "iVBORw0KGgoBAgM", revisedPrompt: "a red circle" };
 

package/bundle/src/application/request-log/request-log.entity.json

@@ -29,6 +29,19 @@
       "length": 50,
       "nullable": true
     },
+    {
+      "name": "requested_model_name",
+      "desc": "요청 모델 이름 (fallback 전)",
+      "type": "string",
+      "length": 50,
+      "nullable": true
+    },
+    {
+      "name": "fallback_count",
+      "type": "integer",
+      "nullable": true,
+      "desc": "모델 fallback 횟수"
+    },
     { "name": "user_prompt", "type": "string", "nullable": true, "desc": "사용자 프롬프트" },
     { "name": "system_prompt", "type": "string", "nullable": true, "desc": "시스템 프롬프트" },
     { "name": "response", "desc": "llm 응답 전문", "type": "string", "dbDefault": "\"\"" },
@@ -41,9 +54,28 @@
       "desc": "캐시 생성 토큰",
       "dbDefault": "0"
     },
+    {
+      "name": "cache_creation_5m_tokens",
+      "type": "integer",
+      "nullable": true,
+      "desc": "5분 TTL 캐시 생성 토큰"
+    },
+    {
+      "name": "cache_creation_1h_tokens",
+      "type": "integer",
+      "nullable": true,
+      "desc": "1시간 TTL 캐시 생성 토큰"
+    },
     { "name": "duration_ms", "type": "integer", "desc": "응답 소요시간(ms)", "dbDefault": "0" },
     { "name": "ttft_ms", "type": "integer", "desc": "first gen TTFT(ms)", "dbDefault": "0" },
     { "name": "cost_usd", "type": "integer", "nullable": true, "desc": "API 비용" },
+    {
+      "name": "cost_source",
+      "type": "string",
+      "length": 20,
+      "nullable": true,
+      "desc": "비용 출처(provider/pricing_table/mixed)"
+    },
     {
       "name": "image_cost_usd",
       "type": "integer",
@@ -102,6 +134,8 @@
       "token_name",
       "project_name",
       "model_name",
+      "requested_model_name",
+      "fallback_count",
       "user_prompt",
       "system_prompt",
       "response",
@@ -109,9 +143,12 @@
       "output_tokens",
       "cache_read_tokens",
       "cache_creation_tokens",
+      "cache_creation_5m_tokens",
+      "cache_creation_1h_tokens",
       "duration_ms",
       "ttft_ms",
       "cost_usd",
+      "cost_source",
       "image_cost_usd",
       "image_cost_method",
       "effort",
@@ -127,13 +164,18 @@
       "token_name",
       "project_name",
       "model_name",
+      "requested_model_name",
+      "fallback_count",
       "input_tokens",
       "output_tokens",
       "cache_read_tokens",
       "cache_creation_tokens",
+      "cache_creation_5m_tokens",
+      "cache_creation_1h_tokens",
       "duration_ms",
       "ttft_ms",
       "cost_usd",
+      "cost_source",
       "image_cost_usd",
       "image_cost_method",
       "effort",

package/bundle/src/application/request-log/request-log.model.test.ts

@@ -90,3 +90,61 @@ describe("RequestLogModel TTFT", () => {
     );
   });
 });
+
+describe("RequestLogModel cost provenance", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("uses exact stored cost for rows with a cost source", async () => {
+    const chain = {
+      where: vi.fn(),
+      select: vi.fn(async () => [
+        {
+          model_name: "claude-opus-4-8",
+          input_tokens: 1_000_000,
+          output_tokens: 1_000_000,
+          cache_read_tokens: 0,
+          cache_creation_tokens: 0,
+          cache_creation_5m_tokens: null,
+          cache_creation_1h_tokens: null,
+          cost_usd: 3_000,
+          cost_source: "provider",
+        },
+      ]),
+    };
+    chain.where.mockReturnValue(chain);
+    const db = vi.fn(() => chain);
+    vi.spyOn(RequestLogModel as unknown as { getDB: () => typeof db }, "getDB").mockReturnValue(
+      db,
+    );
+
+    await expect(RequestLogModel.totalCost()).resolves.toBe(0.003);
+  });
+
+  it("keeps TTL-aware price-table recomputation for legacy rows", async () => {
+    const chain = {
+      where: vi.fn(),
+      select: vi.fn(async () => [
+        {
+          model_name: "claude-sonnet-4-6",
+          input_tokens: 100_000,
+          output_tokens: 0,
+          cache_read_tokens: 0,
+          cache_creation_tokens: 80_000,
+          cache_creation_5m_tokens: 30_000,
+          cache_creation_1h_tokens: 50_000,
+          cost_usd: null,
+          cost_source: null,
+        },
+      ]),
+    };
+    chain.where.mockReturnValue(chain);
+    const db = vi.fn(() => chain);
+    vi.spyOn(RequestLogModel as unknown as { getDB: () => typeof db }, "getDB").mockReturnValue(
+      db,
+    );
+
+    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
+  });
+});

package/bundle/src/application/request-log/request-log.model.ts

@@ -24,7 +24,10 @@ type RequestLogUsageRow = {
   output_tokens: number;
   cache_read_tokens: number;
   cache_creation_tokens: number;
+  cache_creation_5m_tokens?: number | null;
+  cache_creation_1h_tokens?: number | null;
   cost_usd?: number | null;
+  cost_source?: string | null;
 };
 
 function isAnthropicUsageRow(row: Pick<RequestLogUsageRow, "token_name" | "model_name">): boolean {
@@ -45,6 +48,8 @@ function normalizedUsageForCost(row: RequestLogUsageRow): {
   outputTokens: number;
   cachedInputTokens: number;
   cacheCreationInputTokens: number;
+  cacheCreationInputTokens5m?: number;
+  cacheCreationInputTokens1h?: number;
 } {
   const cacheRead = row.cache_read_tokens;
   const cacheCreation = row.cache_creation_tokens;
@@ -57,10 +62,18 @@ function normalizedUsageForCost(row: RequestLogUsageRow): {
     outputTokens: row.output_tokens,
     cachedInputTokens: cacheRead,
     cacheCreationInputTokens: cacheCreation,
+    ...(row.cache_creation_5m_tokens !== null && row.cache_creation_5m_tokens !== undefined
+      ? { cacheCreationInputTokens5m: row.cache_creation_5m_tokens }
+      : {}),
+    ...(row.cache_creation_1h_tokens !== null && row.cache_creation_1h_tokens !== undefined
+      ? { cacheCreationInputTokens1h: row.cache_creation_1h_tokens }
+      : {}),
   };
 }
 
 function normalizeLegacyAnthropicRow<T extends RequestLogUsageRow>(row: T): T {
+  // 새 row 는 당시의 provider/가격표 비용을 확정 저장한다. 현재 가격표로 덮어쓰지 않는다.
+  if (row.cost_source) return row;
   const usage = normalizedUsageForCost(row);
   if (usage.inputTokens === row.input_tokens) return row;
   const normalized = { ...row, input_tokens: usage.inputTokens };
@@ -258,7 +271,14 @@ class RequestLogModelClass extends BaseModelClass<
       output_tokens?: number;
       cache_read_tokens?: number;
       cache_creation_tokens?: number;
+      cache_creation_5m_tokens?: number | null;
+      cache_creation_1h_tokens?: number | null;
       duration_ms?: number;
+      requested_model_name?: string | null;
+      model_name?: string | null;
+      fallback_count?: number | null;
+      cost_usd?: number | null;
+      cost_source?: string | null;
       history?: unknown;
       error_message?: string;
       tool_call_count?: number;
@@ -277,7 +297,14 @@ class RequestLogModelClass extends BaseModelClass<
       "output_tokens",
       "cache_read_tokens",
       "cache_creation_tokens",
+      "cache_creation_5m_tokens",
+      "cache_creation_1h_tokens",
       "duration_ms",
+      "requested_model_name",
+      "model_name",
+      "fallback_count",
+      "cost_usd",
+      "cost_source",
       "error_message",
       "tool_call_count",
       "image_cost_usd",
@@ -289,21 +316,30 @@ class RequestLogModelClass extends BaseModelClass<
     if (params.history !== undefined) update.history = params.history;
     update.ttft_ms = (await this.firstGenerateStepTtft(requestLogId)) ?? 0;
 
-    if (params.input_tokens !== undefined && params.output_tokens !== undefined) {
+    // 서버 run 경로는 step 에서 확정한 exact cost 를 넘긴다. 외부/legacy caller 가 비용을
+    // 생략한 경우에만 저장된 모델+usage 로 계산한다.
+    if (
+      params.cost_usd === undefined &&
+      params.input_tokens !== undefined &&
+      params.output_tokens !== undefined
+    ) {
       const db = this.getDB("r");
       const [row] = await db("request_logs")
         .select("model_name")
         .where("id", requestLogId)
         .limit(1);
-      if (row?.model_name) {
-        const model = canonicalModelName(row.model_name);
+      const effectiveModelName = params.model_name ?? row?.model_name;
+      if (effectiveModelName) {
+        const model = canonicalModelName(effectiveModelName);
         const usage = normalizedUsageForCost({
           token_name: params.token_name,
-          model_name: row.model_name,
+          model_name: effectiveModelName,
           input_tokens: params.input_tokens,
           output_tokens: params.output_tokens,
           cache_read_tokens: params.cache_read_tokens ?? 0,
           cache_creation_tokens: params.cache_creation_tokens ?? 0,
+          cache_creation_5m_tokens: params.cache_creation_5m_tokens,
+          cache_creation_1h_tokens: params.cache_creation_1h_tokens,
         });
         update.cost_usd = Math.round(
           calculateCostUsd(model, {
@@ -311,8 +347,11 @@ class RequestLogModelClass extends BaseModelClass<
             outputTokens: usage.outputTokens,
             cachedInputTokens: usage.cachedInputTokens,
             cacheCreationInputTokens: usage.cacheCreationInputTokens,
+            cacheCreationInputTokens5m: usage.cacheCreationInputTokens5m,
+            cacheCreationInputTokens1h: usage.cacheCreationInputTokens1h,
           }) * 1_000_000,
         );
+        update.cost_source = "pricing_table";
       }
     }
 
@@ -341,25 +380,62 @@ class RequestLogModelClass extends BaseModelClass<
     output_tokens: number;
     cache_read_tokens: number;
     cache_creation_tokens: number;
+    cache_creation_5m_tokens?: number;
+    cache_creation_1h_tokens?: number;
     duration_ms: number;
+    requested_model_name?: string;
+    model_name?: string;
+    fallback_count: number;
+    cost_usd: number;
+    cost_source?: string;
   }> {
     const db = this.getDB("r");
-    const [row] = await db("request_log_steps")
+    const rows = (await db("request_log_steps")
+      .select(
+        "input_tokens",
+        "output_tokens",
+        "cache_read_tokens",
+        "cache_creation_tokens",
+        "cache_creation_5m_tokens",
+        "cache_creation_1h_tokens",
+        "duration_ms",
+        "requested_model_name",
+        "model_name",
+        "fallback_count",
+        "cost_usd",
+        "cost_source",
+      )
       .where("request_log_id", requestLogId)
-      .where("type", "generate")
-      .sum({
-        input_tokens: "input_tokens",
-        output_tokens: "output_tokens",
-        cache_read_tokens: "cache_read_tokens",
-        cache_creation_tokens: "cache_creation_tokens",
-        duration_ms: "duration_ms",
-      });
+      .where("type", "generate")) as Array<Record<string, unknown>>;
+
+    const sum = (field: string): number =>
+      rows.reduce((total, row) => total + Number(row[field] ?? 0), 0);
+    const optionalSum = (field: string): number | undefined =>
+      rows.some((row) => row[field] !== null && row[field] !== undefined) ? sum(field) : undefined;
+    const collapse = (field: string): string | undefined => {
+      const values = [
+        ...new Set(
+          rows
+            .map((row) => row[field])
+            .filter((value): value is string => typeof value === "string" && value.length > 0),
+        ),
+      ];
+      if (values.length === 0) return undefined;
+      return values.length === 1 ? values[0] : "mixed";
+    };
     return {
-      input_tokens: Number(row?.input_tokens ?? 0),
-      output_tokens: Number(row?.output_tokens ?? 0),
-      cache_read_tokens: Number(row?.cache_read_tokens ?? 0),
-      cache_creation_tokens: Number(row?.cache_creation_tokens ?? 0),
-      duration_ms: Number(row?.duration_ms ?? 0),
+      input_tokens: sum("input_tokens"),
+      output_tokens: sum("output_tokens"),
+      cache_read_tokens: sum("cache_read_tokens"),
+      cache_creation_tokens: sum("cache_creation_tokens"),
+      cache_creation_5m_tokens: optionalSum("cache_creation_5m_tokens"),
+      cache_creation_1h_tokens: optionalSum("cache_creation_1h_tokens"),
+      duration_ms: sum("duration_ms"),
+      requested_model_name: collapse("requested_model_name"),
+      model_name: collapse("model_name"),
+      fallback_count: sum("fallback_count"),
+      cost_usd: sum("cost_usd"),
+      cost_source: collapse("cost_source"),
     };
   }
 
@@ -419,17 +495,28 @@ class RequestLogModelClass extends BaseModelClass<
       "output_tokens",
       "cache_read_tokens",
       "cache_creation_tokens",
+      "cache_creation_5m_tokens",
+      "cache_creation_1h_tokens",
       "cost_usd",
+      "cost_source",
     )) as Array<{
       model_name: string | null;
       input_tokens: number;
       output_tokens: number;
       cache_read_tokens: number;
       cache_creation_tokens: number;
+      cache_creation_5m_tokens: number | null;
+      cache_creation_1h_tokens: number | null;
       cost_usd: number | null;
+      cost_source: string | null;
     }>;
 
     return rows.reduce((sum, row) => {
+      // cost_source 가 있으면 새 계약으로 확정 저장된 값이다. 프로모션/가격 변경 이후에도
+      // 당시 비용을 유지한다. NULL인 legacy row 만 현재 가격표로 보정한다.
+      if (row.cost_source && row.cost_usd !== null) {
+        return sum + Math.max(row.cost_usd, 0) / MICRO_USD;
+      }
       const usage = normalizedUsageForCost(row);
       if (!usage.model) return sum + Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
       return (
@@ -439,6 +526,8 @@ class RequestLogModelClass extends BaseModelClass<
           outputTokens: usage.outputTokens,
           cachedInputTokens: usage.cachedInputTokens,
           cacheCreationInputTokens: usage.cacheCreationInputTokens,
+          cacheCreationInputTokens5m: usage.cacheCreationInputTokens5m,
+          cacheCreationInputTokens1h: usage.cacheCreationInputTokens1h,
         })
       );
     }, 0);