@cartanova/qgrid-cli 2.6.1 → 2.6.2

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

@@ -13,6 +13,7 @@ import {
 } from "../../utils/providers/common/credentials";
 import { CallerSchemaValidationError } from "../../utils/providers/common/schema-validation";
 import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model";
+import { type RequestLogListParams } from "../request-log/request-log.types";
 import { type TokenSubsetA } from "../sonamu.generated";
 import { TokenModel, type TokenUpdateFields } from "../token/token.model";
 import { TokenCredentials } from "../token/token.types";
@@ -24,6 +25,7 @@ import {
   fetchUsage,
   generatePKCE,
   refreshAccessToken,
+  RefreshFailedError,
 } from "./oauth";
 import {
   afterQuery,
@@ -45,6 +47,7 @@ import {
   type TokenStats,
   type UsageResponse,
 } from "./qgrid.types";
+import { deactivateAuthDeadToken, notifyTokenAdded } from "./token-death";
 import { ToolSchemaCompositionError } from "./tool-emulation-schema";
 
 const pendingStreams = new Map<string, QueryInput>();
@@ -197,6 +200,9 @@ function createHttpDisconnectHandle(): {
 const logger = getLogger(["qgrid"]);
 const oauthLogger = getLogger(["qgrid", "oauth"]);
 
+// per-token refresh dedup — 회전 겹침으로 인한 사망 오판을 막는다.
+const inflightAnthropicRefresh = new Map<number, Promise<string>>();
+
 class QgridFrameClass extends BaseFrameClass {
   constructor() {
     super("Qgrid");
@@ -464,9 +470,11 @@ class QgridFrameClass extends BaseFrameClass {
     return QgridDispatcher.getStats();
   }
 
+  // 화면의 목록 필터를 그대로 받아 같은 조건의 합계를 돌려준다 — 목록과 비용이
+  // 서로 다른 모수를 보면 사용자에게는 숫자가 어긋난 것으로 읽힌다.
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
-  async totalCost(tokenName?: string): Promise<{ usd: number }> {
-    return { usd: await RequestLogModel.totalCost({ token_name: tokenName }) };
+  async totalCost(params?: RequestLogListParams): Promise<{ usd: number }> {
+    return { usd: await RequestLogModel.totalCost(params) };
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
@@ -601,29 +609,18 @@ class QgridFrameClass extends BaseFrameClass {
       pending.redirectUri,
     );
 
-    if (tokens.accountUuid) {
-      const oldEntries = await TokenModel.findByAccountIdentifier(
-        "A",
-        "anthropic",
-        tokens.accountUuid,
-      );
-      if (oldEntries.length > 0) {
-        await TokenModel.del(oldEntries.map((o) => o.id));
-      }
-    }
-
-    await TokenModel.save([
-      {
-        provider: "anthropic",
-        credentials: {
-          accessToken: tokens.accessToken,
-          refreshToken: tokens.refreshToken,
-          expiresAt: tokens.expiresAt ?? 0,
-          accountUuid: tokens.accountUuid ?? "",
-        },
-        name: pending.name,
+    const { isNew } = await TokenModel.replaceByAccount("anthropic", tokens.accountUuid, {
+      provider: "anthropic",
+      credentials: {
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt ?? 0,
+        accountUuid: tokens.accountUuid ?? "",
       },
-    ]);
+      name: pending.name,
+    });
+
+    if (isNew) notifyTokenAdded(pending.name, "anthropic");
   }
 
   async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {
@@ -651,30 +648,19 @@ class QgridFrameClass extends BaseFrameClass {
     QgridDispatcher.openaiDispatcher
       .completeBrowserLogin()
       .then(async (creds) => {
-        if (creds.accountId) {
-          const oldEntries = await TokenModel.findByAccountIdentifier(
-            "A",
-            "openai",
-            creds.accountId,
-          );
-          if (oldEntries.length > 0) {
-            await TokenModel.del(oldEntries.map((o) => o.id));
-          }
-        }
-        await TokenModel.save([
-          {
-            provider: "openai",
-            credentials: {
-              accessToken: creds.accessToken,
-              refreshToken: creds.refreshToken,
-              idToken: creds.idToken,
-              accessTokenExpiresAt: Date.now() + 10 * 24 * 3600 * 1000,
-              accountId: creds.accountId,
-            },
-            name,
+        const { isNew } = await TokenModel.replaceByAccount("openai", creds.accountId, {
+          provider: "openai",
+          credentials: {
+            accessToken: creds.accessToken,
+            refreshToken: creds.refreshToken,
+            idToken: creds.idToken,
+            accessTokenExpiresAt: Date.now() + 10 * 24 * 3600 * 1000,
+            accountId: creds.accountId,
           },
-        ]);
+          name,
+        });
         logger.info(`OpenAI token saved for ${name}`);
+        if (isNew) notifyTokenAdded(name, "openai");
       })
       .catch((e) => {
         logger.warn(`OpenAI browser login failed: ${(e as Error).message}`);
@@ -754,11 +740,36 @@ class QgridFrameClass extends BaseFrameClass {
     return convertAnthropicUsage(raw);
   }
 
+  // 동시 refresh 가 회전을 겹치면 뒤늦은 호출이 이미 폐기된 refresh token 을 쓰게 되어
+  // 멀쩡한 토큰이 사망으로 오판된다. openai-refresh.ts 와 같은 per-token dedup 을 둔다.
   async refreshToken(token: TokenSubsetA): Promise<string> {
+    const inflight = inflightAnthropicRefresh.get(token.id);
+    if (inflight) return inflight;
+
+    const promise = this.doRefreshToken(token);
+    inflightAnthropicRefresh.set(token.id, promise);
+    try {
+      return await promise;
+    } finally {
+      inflightAnthropicRefresh.delete(token.id);
+    }
+  }
+
+  private async doRefreshToken(token: TokenSubsetA): Promise<string> {
     const creds = token.credentials;
     const rt = getRefreshToken(creds);
     if (!rt) throw new Error("No refresh token");
-    const refreshed = await refreshAccessToken(rt);
+
+    let refreshed;
+    try {
+      refreshed = await refreshAccessToken(rt);
+    } catch (e) {
+      if (e instanceof RefreshFailedError && e.isAuthDead) {
+        await deactivateAuthDeadToken(token, rt, `anthropic:${e.status}`);
+      }
+      throw e;
+    }
+
     const updated = TokenCredentials.parse({
       ...creds,
       accessToken: refreshed.accessToken,

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", () => {