@cartanova/qgrid-cli 2.2.1 → 2.3.2

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

@@ -0,0 +1,110 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  type GenerateRequest,
+  type GenerateResult,
+} from "../../utils/providers/common/provider-dispatcher";
+import { buildStrictOutputSchema, QgridDispatcherClass } from "./qgrid.dispatcher";
+
+describe("QgridDispatcherClass", () => {
+  it("jsonSchema 를 required + additionalProperties:false 로 strictify 한다", () => {
+    const schema = buildStrictOutputSchema({
+      jsonSchema: JSON.stringify({
+        type: "object",
+        properties: {
+          contents: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: { text: { type: "string" } },
+            },
+          },
+        },
+      }),
+    }) as {
+      required?: string[];
+      additionalProperties?: boolean;
+      properties?: {
+        contents?: {
+          items?: { required?: string[]; additionalProperties?: boolean };
+        };
+      };
+    };
+
+    expect(schema.required).toEqual(["contents"]);
+    expect(schema.additionalProperties).toBe(false);
+    const contentsArray = (
+      schema.properties?.contents as {
+        anyOf?: Array<{ items?: { required?: string[]; additionalProperties?: boolean } }>;
+      }
+    ).anyOf?.[0];
+    expect(contentsArray?.items?.required).toEqual(["text"]);
+    expect(contentsArray?.items?.additionalProperties).toBe(false);
+  });
+
+  it("Anthropic provider 경로에 strictified outputSchema 를 전달한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(
+      async (_req: GenerateRequest): Promise<GenerateResult> => ({
+        text: '{"contents":[{"text":"ok"}]}',
+        tokenName: "anthropic/test",
+        usage: {
+          totalTokens: 10,
+          inputTokens: 5,
+          cachedInputTokens: 0,
+          outputTokens: 5,
+          reasoningOutputTokens: 0,
+        },
+        durationMs: 12,
+        costUsd: 0.01,
+        model: "claude-sonnet-4-6",
+        threadCoord: { workerId: 1, threadId: "sess-1", epoch: 0 },
+      }),
+    );
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    await dispatcher.query({
+      prompt: "hi",
+      model: "anthropic/claude-sonnet-4-6",
+      jsonSchema: JSON.stringify({
+        type: "object",
+        properties: { contents: { type: "array", items: { type: "object" } } },
+      }),
+    });
+
+    const outputSchema = generate.mock.calls[0]![0].outputSchema as {
+      required?: string[];
+      additionalProperties?: boolean;
+    };
+    expect(outputSchema.required).toEqual(["contents"]);
+    expect(outputSchema.additionalProperties).toBe(false);
+  });
+
+  it("provider 가 산출한 costUsd 를 가격표 fallback 보다 우선한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(
+      async (_req: GenerateRequest): Promise<GenerateResult> => ({
+        text: "ok",
+        tokenName: "anthropic/test",
+        usage: {
+          totalTokens: 1_110,
+          inputTokens: 1_000,
+          cachedInputTokens: 0,
+          cacheCreationInputTokens: 600,
+          outputTokens: 110,
+          reasoningOutputTokens: 0,
+        },
+        durationMs: 12,
+        costUsd: 0.123456,
+        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: "claude-sonnet-4-6" });
+
+    expect(result.costUsd).toBe(0.123456);
+    expect(result.usage.cache_creation_input_tokens).toBe(600);
+  });
+});

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

@@ -17,12 +17,15 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { getLogger } from "@logtape/logtape";
 
 import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
+import { canonicalAnthropicModel } from "../../utils/providers/anthropic/anthropic-constants";
+import { type AnthropicDispatcher } from "../../utils/providers/anthropic/anthropic-dispatcher";
 import {
   getAccessToken,
   getExpiresAt,
   getRefreshToken,
 } from "../../utils/providers/common/credentials";
 import { calculateCostUsd } from "../../utils/providers/common/model-cost";
+import { type GenerateResult } from "../../utils/providers/common/provider-dispatcher";
 import { strictify } from "../../utils/providers/common/strictifier";
 import { type OpenAIDispatcher } from "../../utils/providers/openai/openai-dispatcher";
 import { type TokenSubsetA } from "../sonamu.generated";
@@ -55,6 +58,20 @@ const QGRID_CLAUDE_SETTINGS = {
 // 토큰 만료 임박 임계값 — token.expiredAt이 1분 안에 만료된다면 query 시 체크하고 refresh.
 const REFRESH_SAFETY_MS = 60_000;
 
+export function buildStrictOutputSchema(
+  input: Pick<QueryInput, "tools" | "jsonSchema">,
+): JsonValue | undefined {
+  const outputSchema = input.tools?.length
+    ? buildToolCallSchema(input.tools)
+    : input.jsonSchema
+      ? (JSON.parse(input.jsonSchema) as JsonValue)
+      : undefined;
+
+  return outputSchema
+    ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)
+    : undefined;
+}
+
 export class QgridDispatcherClass {
   tokens = new Map<number, TokenSubsetA>();
 
@@ -65,6 +82,7 @@ export class QgridDispatcherClass {
   // sonamu.config onStart 에서 처리하는 변수
   subscriber: TokenSubscriber | null = null;
   openaiDispatcher: OpenAIDispatcher | null = null;
+  anthropicDispatcher: AnthropicDispatcher | null = null;
 
   constructor() {
     const settingsJson = JSON.stringify(QGRID_CLAUDE_SETTINGS, null, 2);
@@ -119,11 +137,7 @@ export class QgridDispatcherClass {
       throw new ProcessError("tools and jsonSchema cannot be used together");
     }
 
-    const outputSchema = input.tools?.length
-      ? buildToolCallSchema(input.tools)
-      : input.jsonSchema
-        ? (JSON.parse(input.jsonSchema) as JsonValue)
-        : undefined;
+    const outputSchema = buildStrictOutputSchema(input);
 
     // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher
     if (input.model?.includes("/")) {
@@ -135,9 +149,7 @@ export class QgridDispatcherClass {
         const result = await this.openaiDispatcher.generate({
           model: model,
           systemPrompt: input.system,
-          outputSchema: outputSchema
-            ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)
-            : undefined,
+          outputSchema,
           effort: input.effort,
           verbosity: input.verbosity,
           reasoningSummary: input.reasoningSummary,
@@ -149,36 +161,35 @@ export class QgridDispatcherClass {
         });
 
         const issuedCoord = issueConvContext(result.threadCoord, decision);
-        return applyToolCallEmulation(
-          {
-            text: result.text,
-            tokenName: result.tokenName,
-            model: result.model,
-            usage: {
-              input_tokens: result.usage.inputTokens,
-              output_tokens: result.usage.outputTokens,
-              cache_creation_input_tokens: 0,
-              cache_read_input_tokens: result.usage.cachedInputTokens,
-            },
-            durationMs: result.durationMs,
-            costUsd: calculateCostUsd(result.model, {
-              inputTokens: result.usage.inputTokens,
-              outputTokens: result.usage.outputTokens,
-              cachedInputTokens: result.usage.cachedInputTokens,
-            }),
-          },
-          input.tools,
-          issuedCoord,
-        );
+        return applyToolCallEmulation(toEmulationResult(result), input.tools, issuedCoord);
       }
     }
 
-    const executionInput =
-      outputSchema && input.tools?.length
-        ? { ...input, jsonSchema: JSON.stringify(outputSchema) }
-        : input;
+    // Anthropic — AnthropicDispatcher(멀티턴 session resume) 경로. OpenAI 경로와 동형.
+    if (this.anthropicDispatcher) {
+      const decision = decideConvRouting(input);
+      const result = await this.anthropicDispatcher.generate({
+        // model 미지정이면 AnthropicDispatcher 가 ANTHROPIC_DEFAULT_MODEL 적용 — "sonnet" 별칭을
+        // 강제로 끼워 dispatcher default 를 죽이지 않는다. prefix 정규화도 dispatcher 내부에서.
+        model: input.model,
+        systemPrompt: input.system,
+        outputSchema,
+        effort: input.effort,
+        coldInput: decision.coldInput,
+        coldHistory: decision.coldHistory,
+        reuse: decision.reuse,
+        reuseInput: decision.reuseInput,
+      });
+
+      const issuedCoord = issueConvContext(result.threadCoord, decision);
+      return applyToolCallEmulation(toEmulationResult(result), input.tools, issuedCoord);
+    }
+
+    // 폴백: AnthropicDispatcher 미초기화 시 기존 stateless claude -p 경로(멀티턴 없음).
+    const executionInput = outputSchema
+      ? { ...input, jsonSchema: JSON.stringify(outputSchema) }
+      : input;
 
-    // Anthropic (기존 claude -p 경로)
     const electedToken = this.selectToken();
     if (!electedToken) throw new QuotaError("No tokens available");
 
@@ -205,7 +216,8 @@ export class QgridDispatcherClass {
 
     const result = await executeClaude(executionInput, token, timeoutMs ?? DEFAULT_TIMEOUT_MS);
     return applyToolCallEmulation(
-      { ...result, tokenName: electedToken.name, model: input.model ?? DEFAULT_MODEL },
+      // model 도 canonical 로 — fallback 도 cost/표기가 main 경로와 일치하게.
+      { ...result, tokenName: electedToken.name, model: canonicalAnthropicModel(input.model) },
       input.tools,
     );
   }
@@ -220,7 +232,38 @@ export class QgridDispatcherClass {
       onTurnId?: (turnId: string) => void;
     },
   ): Promise<void> {
+    // Anthropic 스트리밍: openai/ prefix 가 아니면 anthropic 경로.
     if (!input.model?.startsWith("openai/")) {
+      // AnthropicDispatcher 가 있으면 실제 delta 스트리밍. 없으면 기존 query() 폴백(delta 없음).
+      if (this.anthropicDispatcher) {
+        const outputSchema = buildStrictOutputSchema(input);
+        const decision = decideConvRouting(input);
+        await this.anthropicDispatcher.generateStream(
+          {
+            // model 미지정 시 dispatcher 가 ANTHROPIC_DEFAULT_MODEL 적용. prefix 정규화도 내부에서.
+            model: input.model,
+            systemPrompt: input.system,
+            outputSchema,
+            effort: input.effort,
+            coldInput: decision.coldInput,
+            coldHistory: decision.coldHistory,
+            reuse: decision.reuse,
+            reuseInput: decision.reuseInput,
+          },
+          {
+            onDelta: cb.onDelta,
+            onThreadId: cb.onThreadId,
+            onComplete: (turnResult) => {
+              const issuedCoord = issueConvContext(turnResult.threadCoord, decision);
+              cb.onComplete(
+                applyToolCallEmulation(toEmulationResult(turnResult), input.tools, issuedCoord),
+              );
+            },
+            onError: cb.onError,
+          },
+        );
+        return;
+      }
       const result = await this.query(input);
       cb.onComplete(result);
       return;
@@ -230,20 +273,14 @@ export class QgridDispatcherClass {
     if (!model) throw new ProcessError("unknown model");
     if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
 
-    const outputSchema = input.tools?.length
-      ? buildToolCallSchema(input.tools)
-      : input.jsonSchema
-        ? (JSON.parse(input.jsonSchema) as JsonValue)
-        : undefined;
+    const outputSchema = buildStrictOutputSchema(input);
 
     const decision = decideConvRouting(input);
     await this.openaiDispatcher.generateStream(
       {
         model,
         systemPrompt: input.system,
-        outputSchema: outputSchema
-          ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)
-          : undefined,
+        outputSchema,
         effort: input.effort,
         verbosity: input.verbosity,
         reasoningSummary: input.reasoningSummary,
@@ -259,28 +296,9 @@ export class QgridDispatcherClass {
         onTurnId: cb.onTurnId,
         onComplete: (turnResult) => {
           const issuedCoord = issueConvContext(turnResult.threadCoord, decision);
-          const applied = applyToolCallEmulation(
-            {
-              text: turnResult.text,
-              tokenName: turnResult.tokenName,
-              model: turnResult.model,
-              usage: {
-                input_tokens: turnResult.usage.inputTokens,
-                output_tokens: turnResult.usage.outputTokens,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: turnResult.usage.cachedInputTokens,
-              },
-              durationMs: turnResult.durationMs,
-              costUsd: calculateCostUsd(turnResult.model, {
-                inputTokens: turnResult.usage.inputTokens,
-                outputTokens: turnResult.usage.outputTokens,
-                cachedInputTokens: turnResult.usage.cachedInputTokens,
-              }),
-            },
-            input.tools,
-            issuedCoord,
+          cb.onComplete(
+            applyToolCallEmulation(toEmulationResult(turnResult), input.tools, issuedCoord),
           );
-          cb.onComplete(applied);
         },
         onError: cb.onError,
       },
@@ -288,6 +306,36 @@ export class QgridDispatcherClass {
   }
 }
 
+// GenerateResult(provider dispatcher 응답)를 applyToolCallEmulation 입력 shape 로 매핑한다.
+// OpenAI/Anthropic, query/queryStream 4 경로가 동일하게 쓴다.
+// Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.
+// per-request cost 는 Claude Code 가 준 total_cost_usd 를 우선 사용하고 fallback 계산만 공통 cost 함수를 쓴다.
+function toEmulationResult(
+  result: GenerateResult,
+): Omit<QueryOutput, "content" | "finishReason" | "runContext"> {
+  return {
+    text: result.text,
+    tokenName: result.tokenName,
+    model: result.model,
+    usage: {
+      input_tokens: result.usage.inputTokens,
+      output_tokens: result.usage.outputTokens,
+      cache_creation_input_tokens: result.usage.cacheCreationInputTokens ?? 0,
+      cache_read_input_tokens: result.usage.cachedInputTokens,
+    },
+    durationMs: result.durationMs,
+    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,
+          }),
+  };
+}
+
 async function executeClaude(
   input: QueryInput,
   token: string,

package/bundle/src/application/qgrid/token-subscriber.ts

@@ -3,7 +3,7 @@ import { getLogger } from "@logtape/logtape";
 import { Client, type ClientConfig } from "pg";
 
 import { TokenModel } from "../token/token.model";
-import { type OpenAICredentials } from "../token/token.types";
+import { type AnthropicCredentials, type OpenAICredentials } from "../token/token.types";
 import { type QgridDispatcherClass } from "./qgrid.dispatcher";
 import { type SubscriberStatus } from "./qgrid.types";
 
@@ -157,6 +157,8 @@ export class TokenSubscriber {
       this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
         .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));
+      // anthropic 토큰 이벤트는 동기(void) — provider 를 모르므로 무해하게 항상 제거 시도.
+      this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
       logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);
       return;
     }
@@ -166,6 +168,7 @@ export class TokenSubscriber {
       this.dispatcher.openaiDispatcher
         ?.onTokenRemoved(payload.id)
         .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));
+      this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
       logger.info(`NOTIFY ${payload.op} id=${payload.id} → missing, removed from cache`);
       return;
     }
@@ -186,6 +189,19 @@ export class TokenSubscriber {
       } else {
         this.dispatcher.openaiDispatcher?.onTokenDeactivated(payload.id);
       }
+    } else if (row.provider === "anthropic") {
+      // anthropic 토큰 이벤트는 동기(void). worker 가 없고 풀(Map)만 관리하므로 단순:
+      //  INSERT → 추가, active 면 갱신(onTokenUpdated 가 identity 변경도 처리), inactive 면 풀에서 제거.
+      //  (별도 activate/deactivate 콜백이 없어 active 토글을 add/remove 로 매핑.)
+      const creds = row.credentials as AnthropicCredentials;
+      if (payload.op === "INSERT" && row.active) {
+        this.dispatcher.anthropicDispatcher?.onTokenAdded(payload.id, row.name, creds);
+      } else if (row.active) {
+        this.dispatcher.anthropicDispatcher?.onTokenUpdated(payload.id, row.name, creds);
+      } else {
+        // inactive 면 INSERT 든 UPDATE 든 풀에 넣지 않는다.
+        this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
+      }
     }
     logger.info(`NOTIFY ${payload.op} id=${payload.id} (${row.name}) active=${row.active}`);
   }
@@ -193,6 +209,12 @@ export class TokenSubscriber {
   async reconcile(): Promise<void> {
     const rows = await TokenModel.findActive("A");
     this.dispatcher.replaceCache(rows);
+    // NOTIFY 유실 대비: AnthropicDispatcher 풀도 DB active anthropic 토큰 기준으로 재동기화.
+    // (rows 는 active 만 — inactive/삭제된 토큰은 여기 없으므로 replaceTokens 가 풀에서 제거한다.)
+    const anthropicRows = rows
+      .filter((r) => r.provider === "anthropic")
+      .map((r) => ({ id: r.id, name: r.name, credentials: r.credentials as AnthropicCredentials }));
+    this.dispatcher.anthropicDispatcher?.replaceTokens(anthropicRows);
     this.lastReconcileAt = new Date();
   }
 }

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

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+
+import { buildToolCallSchema } from "./tool-emulation";
+import { type QgridTool } from "./qgrid.types";
+
+describe("buildToolCallSchema", () => {
+  it("documents that emulated tools must be requested through StructuredOutput", () => {
+    const tools: QgridTool[] = [
+      {
+        name: "getWeather",
+        description: "Get weather for a city",
+        inputSchema: {
+          type: "object",
+          properties: { city: { type: "string" } },
+          required: ["city"],
+          additionalProperties: false,
+        },
+      },
+    ];
+
+    const schema = buildToolCallSchema(tools) as {
+      description?: string;
+      properties?: {
+        action?: { description?: string };
+        toolCalls?: {
+          description?: string;
+          anyOf?: Array<{
+            items?: {
+              properties?: {
+                toolName?: { description?: string };
+              };
+            };
+          }>;
+        };
+      };
+    };
+
+    expect(schema.description).toContain("StructuredOutput");
+    expect(schema.description).toContain("Do not invoke listed client tools as native Claude Code tools");
+    expect(schema.properties?.action?.description).toContain("tool_call");
+    expect(schema.properties?.toolCalls?.description).toContain("Do not call these tools as native");
+    expect(
+      schema.properties?.toolCalls?.anyOf?.[0]?.items?.properties?.toolName?.description,
+    ).toContain("getWeather");
+  });
+});

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

@@ -26,10 +26,19 @@ export function buildToolCallSchema(tools: QgridTool[]): JsonValue {
 
   return {
     type: "object",
+    description:
+      "Use this schema only through StructuredOutput. Do not invoke listed client tools as native Claude Code tools. To request client-side tool execution, set action to tool_call and include toolCalls. Use action answer only when no further client tool result is needed.",
     properties: {
-      action: { type: "string", enum: ["answer", "tool_call"] },
+      action: {
+        type: "string",
+        enum: ["answer", "tool_call"],
+        description:
+          "Use tool_call to request client-side tool execution through this structured output. Use answer only for a final answer.",
+      },
       answer: { anyOf: [{ type: "string" }, { type: "null" }] },
       toolCalls: {
+        description:
+          "Client-side tool calls requested through structured output. Do not call these tools as native Claude Code tools.",
         anyOf: [
           {
             type: "array",
@@ -39,9 +48,12 @@ export function buildToolCallSchema(tools: QgridTool[]): JsonValue {
                 toolName: {
                   type: "string",
                   enum: tools.map((tool) => tool.name),
-                  description: toolDescriptions,
+                  description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\n${toolDescriptions}`,
+                },
+                args: {
+                  type: "string",
+                  description: "Tool arguments as a JSON string for the client-side tool.",
                 },
-                args: { type: "string", description: "Tool arguments as JSON string" },
               },
               required: ["toolName", "args"],
               additionalProperties: false,

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

@@ -17,6 +17,59 @@ import { type RequestLogListParams, type RequestLogSaveParams } from "./request-
 // cost_usd는 정수 micro-USD로 저장. 실제 USD = cost_usd / MICRO_USD.
 export const MICRO_USD = 1_000_000;
 
+type RequestLogUsageRow = {
+  token_name?: string | null;
+  model_name?: string | null;
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_tokens: number;
+  cache_creation_tokens: number;
+  cost_usd?: number | null;
+};
+
+function isAnthropicUsageRow(row: Pick<RequestLogUsageRow, "token_name" | "model_name">): boolean {
+  return (
+    row.token_name?.startsWith("anthropic/") === true ||
+    row.model_name?.startsWith("claude-") === true ||
+    row.model_name?.startsWith("anthropic/claude-") === true
+  );
+}
+
+function canonicalModelName(modelName: string): string {
+  return modelName.includes("/") ? modelName.split("/").pop()! : modelName;
+}
+
+function normalizedUsageForCost(row: RequestLogUsageRow): {
+  model: string | null;
+  inputTokens: number;
+  outputTokens: number;
+  cachedInputTokens: number;
+  cacheCreationInputTokens: number;
+} {
+  const cacheRead = Number(row.cache_read_tokens ?? 0);
+  const cacheCreation = Number(row.cache_creation_tokens ?? 0);
+  const storedInput = Number(row.input_tokens ?? 0);
+  const legacyAnthropicSplitInput =
+    isAnthropicUsageRow(row) && storedInput < cacheRead + cacheCreation;
+  return {
+    model: row.model_name ? canonicalModelName(row.model_name) : null,
+    inputTokens: legacyAnthropicSplitInput ? storedInput + cacheRead + cacheCreation : storedInput,
+    outputTokens: Number(row.output_tokens ?? 0),
+    cachedInputTokens: cacheRead,
+    cacheCreationInputTokens: cacheCreation,
+  };
+}
+
+function normalizeLegacyAnthropicRow<T extends RequestLogUsageRow>(row: T): T {
+  const usage = normalizedUsageForCost(row);
+  if (usage.inputTokens === Number(row.input_tokens ?? 0)) return row;
+  const normalized = { ...row, input_tokens: usage.inputTokens };
+  if (usage.model) {
+    normalized.cost_usd = Math.round(calculateCostUsd(usage.model, usage) * MICRO_USD);
+  }
+  return normalized;
+}
+
 /*
   RequestLog Model
 */
@@ -118,10 +171,7 @@ class RequestLogModelClass extends BaseModelClass<
     }
 
     const enhancers = this.createEnhancers({
-      A: (row) => ({
-        ...row,
-        // 서브셋별로 virtual 필드 계산로직 추가
-      }),
+      A: (row) => normalizeLegacyAnthropicRow(row),
     });
 
     return this.executeSubsetQuery({
@@ -238,14 +288,21 @@ class RequestLogModelClass extends BaseModelClass<
         .where("id", requestLogId)
         .limit(1);
       if (row?.model_name) {
-        const model = row.model_name.includes("/")
-          ? row.model_name.split("/").pop()!
-          : row.model_name;
+        const model = canonicalModelName(row.model_name);
+        const usage = normalizedUsageForCost({
+          token_name: params.token_name,
+          model_name: row.model_name,
+          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,
+        });
         update.cost_usd = Math.round(
           calculateCostUsd(model, {
-            inputTokens: params.input_tokens,
-            outputTokens: params.output_tokens,
-            cachedInputTokens: params.cache_read_tokens ?? 0,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cachedInputTokens: usage.cachedInputTokens,
+            cacheCreationInputTokens: usage.cacheCreationInputTokens,
           }) * 1_000_000,
         );
       }
@@ -333,9 +390,37 @@ class RequestLogModelClass extends BaseModelClass<
     if (params.token_name) {
       qb.where("token_name", params.token_name);
     }
-    // knex는 pg에서 numeric aggregate를 string으로 반환.
-    const row = (await qb.sum({ sum: "cost_usd" }).first()) as { sum: string | null } | undefined;
-    return Number(row?.sum ?? 0) / MICRO_USD;
+    // 기존 cost_usd 에는 과거 Anthropic cache 계산 버그로 음수가 저장된 row 가 있을 수 있다.
+    // 화면 집계는 저장값 sum 이 아니라 현재 계산식으로 usage 를 재계산해 과거 로그도 즉시 보정한다.
+    const rows = (await qb.select(
+      "model_name",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "cost_usd",
+    )) as Array<{
+      model_name: string | null;
+      input_tokens: number;
+      output_tokens: number;
+      cache_read_tokens: number;
+      cache_creation_tokens: number;
+      cost_usd: number | null;
+    }>;
+
+    return rows.reduce((sum, row) => {
+      const usage = normalizedUsageForCost(row);
+      if (!usage.model) return sum + Math.max(Number(row.cost_usd ?? 0), 0) / MICRO_USD;
+      return (
+        sum +
+        calculateCostUsd(usage.model, {
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          cachedInputTokens: usage.cachedInputTokens,
+          cacheCreationInputTokens: usage.cacheCreationInputTokens,
+        })
+      );
+    }, 0);
   }
 
   async distinctProjectNames(): Promise<string[]> {