@cartanova/qgrid-cli 2.6.0 → 2.6.2

package/bundle/src/application/qgrid/token-death.test.ts

@@ -0,0 +1,120 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { SLACK_COLOR } from "../../utils/slack-notify";
+import { deactivateAuthDeadToken, notifyTokenAdded } from "./token-death";
+
+const { findOneMock, deactivateMock, notifySlackMock } = vi.hoisted(() => ({
+  findOneMock: vi.fn(),
+  deactivateMock: vi.fn(),
+  notifySlackMock: vi.fn(),
+}));
+
+vi.mock("../token/token.model", () => ({
+  TokenModel: { findOne: findOneMock, deactivateIfActive: deactivateMock },
+}));
+
+// SLACK_COLOR 는 상수라 가릴 이유가 없다 — 전송 함수만 스텁한다.
+vi.mock("../../utils/slack-notify", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../../utils/slack-notify")>()),
+  notifySlack: notifySlackMock,
+}));
+
+const token = { id: 7, name: "anthropic/test-token", provider: "anthropic" };
+
+function storedRefreshToken(refreshToken: string) {
+  return {
+    id: 7,
+    provider: "anthropic",
+    credentials: { accessToken: "at", refreshToken, expiresAt: 0, accountUuid: "acc-1" },
+  };
+}
+
+describe("deactivateAuthDeadToken", () => {
+  afterEach(() => {
+    findOneMock.mockReset();
+    deactivateMock.mockReset();
+    notifySlackMock.mockReset();
+  });
+
+  it("deactivates and notifies when the failed attempt used the current refresh token", async () => {
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
+    deactivateMock.mockResolvedValue(true);
+
+    await expect(
+      deactivateAuthDeadToken(token, "rt-current", "anthropic:400"),
+    ).resolves.toBe(true);
+
+    expect(deactivateMock).toHaveBeenCalledWith(7);
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+    const notification = notifySlackMock.mock.calls[0]![0] as {
+      subject: string;
+      context: string;
+      color: string;
+    };
+    expect(notification.subject).toBe("anthropic/test-token");
+    expect(notification.context).toContain("anthropic:400");
+    expect(notification.color).toBe(SLACK_COLOR.bad);
+  });
+
+  it("skips deactivation when the refresh token rotated since the failed attempt", async () => {
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-rotated"));
+
+    await expect(deactivateAuthDeadToken(token, "rt-stale", "anthropic:400")).resolves.toBe(false);
+
+    expect(deactivateMock).not.toHaveBeenCalled();
+    expect(notifySlackMock).not.toHaveBeenCalled();
+  });
+
+  it("does not notify when another process won the deactivation race", async () => {
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
+    deactivateMock.mockResolvedValue(false);
+
+    await expect(deactivateAuthDeadToken(token, "rt-current", "anthropic:400")).resolves.toBe(
+      false,
+    );
+
+    expect(notifySlackMock).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when the token no longer exists", async () => {
+    findOneMock.mockResolvedValue(undefined);
+
+    await expect(deactivateAuthDeadToken(token, "rt-current", "anthropic:400")).resolves.toBe(
+      false,
+    );
+
+    expect(deactivateMock).not.toHaveBeenCalled();
+  });
+
+  it("never puts the raw provider error body in the notification", async () => {
+    findOneMock.mockResolvedValue(storedRefreshToken("rt-current"));
+    deactivateMock.mockResolvedValue(true);
+
+    await deactivateAuthDeadToken(token, "rt-current", "anthropic:400");
+
+    // 필드가 늘어도 새는 곳이 생기지 않도록 페이로드 전체를 훑는다.
+    const payload = JSON.stringify(notifySlackMock.mock.calls[0]![0]);
+    expect(payload).not.toContain("sk-ant");
+    expect(payload).not.toContain("@");
+  });
+});
+
+describe("notifyTokenAdded", () => {
+  afterEach(() => {
+    notifySlackMock.mockReset();
+  });
+
+  it("sends one added notification naming the token and provider", () => {
+    notifyTokenAdded("anthropic/test-token", "anthropic");
+
+    expect(notifySlackMock).toHaveBeenCalledTimes(1);
+    const notification = notifySlackMock.mock.calls[0]![0] as {
+      subject: string;
+      context: string;
+      color: string;
+    };
+    expect(notification.subject).toBe("anthropic/test-token");
+    expect(notification.context).toContain("anthropic");
+    expect(notification.color).toBe(SLACK_COLOR.good);
+  });
+});

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

@@ -0,0 +1,67 @@
+/**
+ * 세션 만료(auth-dead) 토큰의 라우팅 제외 지점.
+ *
+ * refresh 가 재로그인 외 복구 불가한 실패를 반환한 순간에만 호출된다. 비활성화는
+ * `active=true` 조건부 갱신 1회이고, 그 갱신을 이긴 프로세스만 Slack 알림을 보낸다 —
+ * 공유 DB 를 쓰는 인스턴스가 몇이든 사건당 알림은 1건이다.
+ */
+import { getLogger } from "@logtape/logtape";
+
+import { getRefreshToken } from "../../utils/providers/common/credentials";
+import { notifySlack, SLACK_COLOR } from "../../utils/slack-notify";
+import { TokenModel } from "../token/token.model";
+
+const logger = getLogger(["qgrid", "token-death"]);
+
+type DeadTokenRef = {
+  id: number;
+  name: string;
+  provider: string;
+};
+
+/**
+ * @param usedRefreshToken 실패한 요청이 실제로 사용한 refresh token.
+ *   refresh token 은 회전 저장되므로, 이미 회전된 옛 토큰으로 늦게 도착한 재시도가
+ *   400 을 받는 것은 정상 레이스다. DB 의 현재 값과 다르면 사망으로 보지 않는다.
+ * @param reasonCode `provider:code` 형태의 내부 코드. provider 응답 본문에는 계정 이메일이나
+ *   토큰 조각이 섞일 수 있어 raw 메시지를 그대로 알림에 싣지 않는다.
+ */
+export async function deactivateAuthDeadToken(
+  token: DeadTokenRef,
+  usedRefreshToken: string,
+  reasonCode: string,
+): Promise<boolean> {
+  const current = await TokenModel.findOne("A", { id: token.id });
+  if (!current) return false;
+
+  const currentRefreshToken = getRefreshToken(current.credentials);
+  if (currentRefreshToken && currentRefreshToken !== usedRefreshToken) {
+    logger.info(
+      `skipping auth-death for ${token.name}(id=${token.id}): refresh token rotated since this attempt`,
+    );
+    return false;
+  }
+
+  const deactivated = await TokenModel.deactivateIfActive(token.id);
+  if (!deactivated) return false;
+
+  logger.warn(`token deactivated (auth dead): ${token.name}(id=${token.id}) reason=${reasonCode}`);
+  void notifySlack({
+    title: "세션 만료",
+    subject: token.name,
+    context: `${token.provider} · ${reasonCode} · 재로그인이 필요합니다`,
+    color: SLACK_COLOR.bad,
+  });
+  return true;
+}
+
+/** 처음 보는 계정이 등록됐을 때. 재로그인(기존 토큰 교체)은 알리지 않는다. */
+export function notifyTokenAdded(name: string, provider: string): void {
+  logger.info(`token added: ${name} (${provider})`);
+  void notifySlack({
+    title: "토큰 추가",
+    subject: name,
+    context: `${provider} · 요청 처리에 사용됩니다`,
+    color: SLACK_COLOR.good,
+  });
+}

package/bundle/src/application/queries.generated.ts

@@ -80,8 +80,8 @@ export namespace QgridService {
   export const stats = (): SSRQuery =>
     createSSRQuery("QgridFrame", "stats", [], ["Qgrid", "stats"]);
 
-  export const totalCost = (tokenName?: string): SSRQuery =>
-    createSSRQuery("QgridFrame", "totalCost", [tokenName], ["Qgrid", "totalCost"]);
+  export const totalCost = (params?: RequestLogListParams): SSRQuery =>
+    createSSRQuery("QgridFrame", "totalCost", [params], ["Qgrid", "totalCost"]);
 
   export const projectNames = (): SSRQuery =>
     createSSRQuery("QgridFrame", "projectNames", [], ["Qgrid", "projectNames"]);

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

@@ -36,12 +36,7 @@
       "length": 255,
       "nullable": true
     },
-    {
-      "name": "fallback_count",
-      "type": "integer",
-      "nullable": true,
-      "desc": "모델 fallback 횟수"
-    },
+    { "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": "\"\"" },
@@ -132,6 +127,12 @@
       "name": "request_logs_project_name_index",
       "columns": [{ "name": "project_name" }],
       "using": "btree"
+    },
+    {
+      "type": "index",
+      "name": "request_logs_project_name_cost_usd_index",
+      "columns": [{ "name": "project_name" }, { "name": "cost_usd" }],
+      "using": "btree"
     }
   ],
   "subsets": {
@@ -190,6 +191,19 @@
       "status",
       "tool_call_count",
       "is_image_generation"
+    ],
+    "C": [
+      "id",
+      "token_name",
+      "model_name",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "cache_creation_5m_tokens",
+      "cache_creation_1h_tokens",
+      "cost_usd",
+      "cost_source"
     ]
   },
   "enums": {

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

@@ -366,59 +366,170 @@ describe("RequestLogModel cost provenance", () => {
     vi.restoreAllMocks();
   });
 
-  it("uses exact stored cost for rows with a cost source", async () => {
-    const chain = {
+  /**
+   * totalCost 는 확정 비용(SQL SUM)과 legacy 재계산(JS) 두 쿼리로 나뉜다.
+   * @param confirmedTotal SUM 쿼리가 돌려줄 micro-USD 합계
+   * @param legacyRows 재계산 대상 row 들
+   */
+  function mockTotalCostQueries(confirmedTotal: number, legacyRows: unknown[]) {
+    // subset qb 는 SELECT 를 비우고(clear) 집계/축소된 컬럼만 다시 얹는다 — 구현과 같은 체인.
+    const sumChain = {
       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",
-        },
-      ]),
+      whereIn: vi.fn(),
+      whereRaw: vi.fn(),
+      clear: vi.fn(),
+      select: vi.fn(),
+      first: vi.fn(async () => ({ total: confirmedTotal })),
     };
-    chain.where.mockReturnValue(chain);
-    const from = vi.fn(() => chain);
+    sumChain.where.mockReturnValue(sumChain);
+    sumChain.whereIn.mockReturnValue(sumChain);
+    sumChain.whereRaw.mockReturnValue(sumChain);
+    sumChain.clear.mockReturnValue(sumChain);
+    sumChain.select.mockReturnValue(sumChain);
+
+    const legacyChain = {
+      where: vi.fn(),
+      whereIn: vi.fn(),
+      whereRaw: vi.fn(),
+      clear: vi.fn(),
+      select: vi.fn(async () => legacyRows),
+    };
+    legacyChain.where.mockReturnValue(legacyChain);
+    legacyChain.whereIn.mockReturnValue(legacyChain);
+    legacyChain.whereRaw.mockReturnValue(legacyChain);
+    legacyChain.clear.mockReturnValue(legacyChain);
+
+    const getSubsetQueries = vi
+      .fn()
+      .mockReturnValueOnce({ qb: sumChain })
+      .mockReturnValueOnce({ qb: legacyChain });
     vi.spyOn(
-      RequestLogModel as unknown as { getPuri: () => { from: typeof from } },
-      "getPuri",
-    ).mockReturnValue({ from });
+      RequestLogModel as unknown as { getSubsetQueries: typeof getSubsetQueries },
+      "getSubsetQueries",
+    ).mockImplementation(getSubsetQueries);
+    return { sumChain, legacyChain };
+  }
+
+  it("uses exact stored cost for rows with a cost source", async () => {
+    mockTotalCostQueries(3_000, []);
 
     await expect(RequestLogModel.totalCost()).resolves.toBe(0.003);
   });
 
+  it("sums every row in SQL without a cost_source predicate", async () => {
+    const { sumChain, legacyChain } = mockTotalCostQueries(3_000, []);
+
+    await RequestLogModel.totalCost();
+
+    expect(sumChain.select).toHaveBeenCalledTimes(1);
+    // 조건을 걸면 cost_source 가 인덱스에 없어 커버링 인덱스가 무효화된다.
+    expect(sumChain.whereRaw).not.toHaveBeenCalled();
+    expect(legacyChain.whereRaw).toHaveBeenCalledWith(
+      "request_logs.cost_source IS NULL OR request_logs.cost_usd IS NULL",
+    );
+  });
+
   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 from = vi.fn(() => chain);
-    vi.spyOn(
-      RequestLogModel as unknown as { getPuri: () => { from: typeof from } },
-      "getPuri",
-    ).mockReturnValue({ from });
+    mockTotalCostQueries(0, [
+      {
+        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,
+      },
+    ]);
 
     await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
   });
+
+  it("adds only the delta for legacy rows already counted in the SQL sum", async () => {
+    // 전체 SUM 이 저장값 0.2 를 이미 포함하므로, 재계산값 0.4725 와의 차액만 더해야 한다.
+    mockTotalCostQueries(200_000, [
+      {
+        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: 200_000,
+        cost_source: null,
+      },
+    ]);
+
+    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
+  });
+
+  it("leaves the stored value untouched for legacy rows without a model name", async () => {
+    // 모델을 모르면 재계산할 수 없다. 저장값이 SUM 에 이미 들어갔으므로 보정하지 않는다.
+    mockTotalCostQueries(5_000, [
+      {
+        model_name: null,
+        input_tokens: 100,
+        output_tokens: 100,
+        cache_read_tokens: 0,
+        cache_creation_tokens: 0,
+        cache_creation_5m_tokens: null,
+        cache_creation_1h_tokens: null,
+        cost_usd: 5_000,
+        cost_source: null,
+      },
+    ]);
+
+    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.005, 10);
+  });
+
+  it("applies list filters to both cost queries so totals match the filtered list", async () => {
+    const { sumChain, legacyChain } = mockTotalCostQueries(0, []);
+
+    await RequestLogModel.totalCost({
+      num: 0,
+      page: 1,
+      project_name: "deti",
+      token_name: "openai/yds",
+      model_name: "openai/gpt-5.5",
+    });
+
+    for (const chain of [sumChain, legacyChain]) {
+      expect(chain.where).toHaveBeenCalledWith("request_logs.project_name", "deti");
+      expect(chain.where).toHaveBeenCalledWith("request_logs.token_name", "openai/yds");
+      expect(chain.where).toHaveBeenCalledWith("request_logs.model_name", "openai/gpt-5.5");
+    }
+  });
+
+  it("applies the unassigned-project filter to both cost queries", async () => {
+    const { sumChain, legacyChain } = mockTotalCostQueries(0, []);
+
+    await RequestLogModel.totalCost({ num: 0, page: 1, project_name_is_null: true });
+
+    for (const chain of [sumChain, legacyChain]) {
+      expect(chain.where).toHaveBeenCalledWith("request_logs.project_name", null);
+    }
+  });
+
+  it("combines the SQL-summed total with the legacy recomputation delta", async () => {
+    mockTotalCostQueries(3_000, [
+      {
+        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,
+      },
+    ]);
+
+    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4755, 10);
+  });
 });
 
 describe("RequestLogModel PostgreSQL run lock", () => {

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

@@ -195,21 +195,15 @@ class RequestLogModelClass extends BaseModelClass<
     return rows[0] ?? null;
   }
 
-  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogs" })
-  async findMany<T extends RequestLogSubsetKey, LP extends RequestLogListParams>(
-    subset: T,
-    rawParams?: LP,
-  ): Promise<ListResult<LP, RequestLogSubsetMapping[T]>> {
-    const params = {
-      num: 24,
-      page: 1,
-      search: "id" as const,
-      orderBy: "id-desc" as const,
-      ...rawParams,
-    } satisfies RequestLogListParams;
-
-    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
-
+  /**
+   * 목록 필터의 단일 정의. findMany 와 totalCost 가 같은 조건을 보도록 공유한다 —
+   * 화면에서 필터를 걸면 행 수와 비용이 함께 좁혀져야 하는데, 두 쿼리가 각자 필터를
+   * 구현하면 한쪽에 축을 추가할 때 조용히 어긋난다.
+   */
+  private applyListFilters(
+    qb: ReturnType<RequestLogModelClass["getSubsetQueries"]>["qb"],
+    params: RequestLogListParams,
+  ): void {
     if (params.id) {
       qb.whereIn("request_logs.id", asArray(params.id));
     }
@@ -241,6 +235,24 @@ class RequestLogModelClass extends BaseModelClass<
         throw new BadRequestException(SD("error.unknownSearchField")(params.search));
       }
     }
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogs" })
+  async findMany<T extends RequestLogSubsetKey, LP extends RequestLogListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): Promise<ListResult<LP, RequestLogSubsetMapping[T]>> {
+    const params = {
+      num: 24,
+      page: 1,
+      search: "id" as const,
+      orderBy: "id-desc" as const,
+      ...rawParams,
+    } satisfies RequestLogListParams;
+
+    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+
+    this.applyListFilters(qb, params);
 
     // orderBy
     if (params.orderBy) {
@@ -254,6 +266,7 @@ class RequestLogModelClass extends BaseModelClass<
 
     const enhancers = this.createEnhancers({
       A: (row) => normalizeLegacyAnthropicRow(row),
+      C: (row) => normalizeLegacyAnthropicRow(row),
     });
 
     return this.executeSubsetQuery({
@@ -606,33 +619,65 @@ class RequestLogModelClass extends BaseModelClass<
     return (row?.max_step ?? -1) + 1;
   }
 
-  // Sonamu findMany는 subset 전체 컬럼(text 포함)을 페치하므로 비용 계산에 필요한 컬럼만 조회한다.
-  async totalCost(params: { token_name?: string } = {}): Promise<number> {
-    // 기존 cost_usd 에는 과거 Anthropic cache 계산 버그로 음수가 저장된 row 가 있을 수 있다.
-    // 화면 집계는 저장값 sum 이 아니라 현재 계산식으로 usage 를 재계산해 과거 로그도 즉시 보정한다.
-    const rows = await this.getPuri("r")
-      .from("request_logs")
-      .where(params.token_name ? { token_name: params.token_name } : {})
+  /**
+   * 화면 표시용 총 비용. 목록과 같은 필터를 적용한다.
+   *
+   * 전체를 조건 없이 SUM 한 뒤, `cost_source` 가 없는 legacy row 의 차액만 보정한다.
+   * 조건 없는 SUM 이어야 `(project_name, cost_usd)` 커버링 인덱스가 Index Only Scan 을
+   * 탄다 — `cost_source IS NOT NULL` 을 걸면 그 컬럼이 인덱스에 없어 heap 을 다시 봐야
+   * 하므로 플래너가 인덱스를 버리고 seq scan 으로 돌아간다(실측 230ms → 814ms).
+   *
+   * legacy 보정을 남겨둔 이유: 백필로 기존 legacy 는 0 이 되었지만, 외부 로거가
+   * `AppendStepInput`/`FinishRunInput` 으로 costSource 없이 넣으면 다시 생길 수 있다.
+   * 그런 row 는 저장값 대신 현재 가격표 재계산값이 맞으므로 차액을 더한다.
+   *
+   * 필터 조건을 여기서 다시 구현하지 않고 `applyListFilters` 를 공유하는 것이 핵심이다 —
+   * 두 쿼리가 각자 필터를 가지면 화면에서 필터를 걸었을 때 행 수와 비용이 조용히 어긋난다.
+   */
+  async totalCost(rawParams: RequestLogListParams = { num: 0, page: 1 }): Promise<number> {
+    const params = {
+      num: 0,
+      page: 1,
+      search: "id" as const,
+      ...rawParams,
+    } satisfies RequestLogListParams;
+
+    const { qb: totalQb } = this.getSubsetQueries("C");
+    this.applyListFilters(totalQb, params);
+    // subset qb 는 컬럼 목록이 이미 SELECT 에 박혀 있어 집계를 얹으면 GROUP BY 에러가 난다.
+    // executeCountQuery 와 같은 방식으로 select 를 비우고 집계만 남긴다.
+    const stored = await totalQb
+      .clear("select")
+      // 음수 저장값(과거 버그)은 0 으로 눌러서 더한다 — JS 쪽 Math.max 와 같은 규칙.
+      .select({
+        total: Puri.rawNumber("COALESCE(SUM(GREATEST(request_logs.cost_usd, 0)), 0)"),
+      })
+      .first();
+
+    const { qb: legacyQb } = this.getSubsetQueries("C");
+    this.applyListFilters(legacyQb, params);
+    const legacyRows = await legacyQb
+      .whereRaw("request_logs.cost_source IS NULL OR request_logs.cost_usd IS NULL")
+      .clear("select")
       .select({
-        model_name: "model_name",
-        input_tokens: "input_tokens",
-        output_tokens: "output_tokens",
-        cache_read_tokens: "cache_read_tokens",
-        cache_creation_tokens: "cache_creation_tokens",
-        cache_creation_5m_tokens: "cache_creation_5m_tokens",
-        cache_creation_1h_tokens: "cache_creation_1h_tokens",
-        cost_usd: "cost_usd",
-        cost_source: "cost_source",
+        token_name: "request_logs.token_name",
+        model_name: "request_logs.model_name",
+        input_tokens: "request_logs.input_tokens",
+        output_tokens: "request_logs.output_tokens",
+        cache_read_tokens: "request_logs.cache_read_tokens",
+        cache_creation_tokens: "request_logs.cache_creation_tokens",
+        cache_creation_5m_tokens: "request_logs.cache_creation_5m_tokens",
+        cache_creation_1h_tokens: "request_logs.cache_creation_1h_tokens",
+        cost_usd: "request_logs.cost_usd",
       });
 
-    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 storedTotal = Number(stored?.total ?? 0) / MICRO_USD;
+
+    // legacy row 는 위 SUM 에 저장값으로 이미 포함되어 있다. 재계산값과의 차액만 더한다.
+    return legacyRows.reduce((sum, row) => {
+      const alreadySummed = Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
       const usage = normalizedUsageForCost(row);
-      if (!usage.model) return sum + Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
+      if (!usage.model) return sum;
       return (
         sum +
         calculateCostUsd(usage.model, {
@@ -642,9 +687,10 @@ class RequestLogModelClass extends BaseModelClass<
           cacheCreationInputTokens: usage.cacheCreationInputTokens,
           cacheCreationInputTokens5m: usage.cacheCreationInputTokens5m,
           cacheCreationInputTokens1h: usage.cacheCreationInputTokens1h,
-        })
+        }) -
+        alreadySummed
       );
-    }, 0);
+    }, storedTotal);
   }
 
   async distinctProjectNames(): Promise<string[]> {

package/bundle/src/application/sonamu.generated.http

@@ -434,7 +434,19 @@ Content-Type: application/json
 ###
 
 GET {{baseUrl}}/api/qgrid/totalCost
-	?tokenName=TOKENNAME
+	?params[num]=24
+	&params[page]=1
+	&params[search]=id
+	&params[keyword]=KEYWORD
+	&params[orderBy]=id-desc
+	&params[queryMode]=both
+	&params[id]=0
+	&params[sonamuFilter]=unknown-custom
+	&params[token_name]=
+	&params[project_name]=
+	&params[model_name]=
+	&params[project_name_is_null]=false
+	&params[project_name_is_not_null]=false
 Content-Type: application/json
 
 ###
@@ -500,6 +512,15 @@ Content-Type: application/json
 
 ###
 
+POST {{baseUrl}}/api/qgrid/oauthComplete
+Content-Type: application/json
+
+{
+  "pastedCode": "PASTEDCODE"
+}
+
+###
+
 POST {{baseUrl}}/api/qgrid/oauthStartOpenAI
 Content-Type: application/json