@cartanova/qgrid-cli 2.10.0 → 2.10.2

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

@@ -48,8 +48,9 @@ export type InternalQueryInput = QueryInput & {
 export class QgridDispatcherClass {
   tokens = new Map<number, TokenSubsetA>();
 
-  // TokenStats shape 보존용. 실제 provider 요청 카운팅은 각 dispatcher 로 이동했다.
-  requestCounts = new Map<string, number>();
+  // 프로세스 시작 이후 완료된 provider generation 수. 실패/중간 시도는 제외하며,
+  // 후속 tool turn도 한 generation으로 센다. 동명 토큰은 provider별로 분리한다.
+  private requestCounts = new Map<string, number>();
 
   // sonamu.config onStart 에서 처리하는 변수
   subscriber: TokenSubscriber | null = null;
@@ -61,7 +62,7 @@ export class QgridDispatcherClass {
    * HTTP 리스닝은 dispatcher 준비보다 먼저 열리므로(sonamu.config onStart),
    * 그 사이 들어온 요청은 "잠시 후 되는" 상태와 "재시도해도 안 되는" 상태가 다르다.
    *
-   * - `starting`: 워커 spawn 중. dev0 기준 25 워커 × 500ms 간격이라 1~2분 걸린다 → 재시도 가능
+   * - `starting`: provider 토큰·런타임 초기화 중 → 재시도 가능
    * - `ready`: 정상
    * - `failed`: start() 가 예외로 끝남 → 재시도해도 같은 결과
    */
@@ -84,8 +85,9 @@ export class QgridDispatcherClass {
       : new ServiceUnavailableException(SD("qgrid.dispatcherStarting")(label));
   }
 
-  countOf(name: string): number {
-    return this.requestCounts.get(name) ?? 0;
+  private recordCompleted(provider: string, tokenName: string): void {
+    const key = `${provider}\0${tokenName}`;
+    this.requestCounts.set(key, (this.requestCounts.get(key) ?? 0) + 1);
   }
 
   // TokenSubscriber 콜백 — 캐시 mutation
@@ -106,7 +108,7 @@ export class QgridDispatcherClass {
       token: maskToken(getAccessToken(r.credentials)),
       name: r.name,
       provider: r.provider,
-      requests: this.countOf(r.name),
+      requests: this.requestCounts.get(`${r.provider}\0${r.name}`) ?? 0,
     }));
   }
 
@@ -143,6 +145,7 @@ export class QgridDispatcherClass {
         imageGeneration: input.imageGeneration,
         imageGenerationOptions: input.imageGenerationOptions,
       });
+      this.recordCompleted("openai", result.tokenName);
 
       // 이미지 요청은 cold-only(R8)라 재사용 좌표를 발급하지 않는다. 좌표를 실으면
       // sessionKey 소비자의 warm 좌표를 죽은 좌표로 덮어써 다음 텍스트 turn 이 cold 로 떨어진다.
@@ -175,6 +178,7 @@ export class QgridDispatcherClass {
         imageGeneration: input.imageGeneration,
         imageGenerationOptions: input.imageGenerationOptions,
       });
+      this.recordCompleted("anthropic", result.tokenName);
 
       return applyToolCallEmulation(toEmulationResult(result), input.tools, {
         threadCoord: issueConvContext(result.threadCoord, decision),
@@ -227,6 +231,7 @@ export class QgridDispatcherClass {
           onThreadId: cb.onThreadId,
           onTurnId: cb.onTurnId,
           onComplete: (turnResult) => {
+            this.recordCompleted("openai", turnResult.tokenName);
             cb.onComplete(
               applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {
                 threadCoord: issueConvContext(
@@ -276,6 +281,7 @@ export class QgridDispatcherClass {
           onDelta: emitDelta,
           onThreadId: cb.onThreadId,
           onComplete: (turnResult) => {
+            this.recordCompleted("anthropic", turnResult.tokenName);
             // 홀드백 잔여(닫는 펜스가 아니었던 tail)를 done 전에 마저 방출한다 —
             // 델타를 조립하는 클라이언트(EnvelopeStreamParser 등)의 무손실 보장.
             const rest = fenceStrip?.flush();

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

@@ -896,20 +896,29 @@ describe("QgridFrame.prepareStream", () => {
 });
 
 describe("QgridFrame raw lifecycle API", () => {
-  it("treats createRun.modelName as the requested model", async () => {
+  it("maps the requested model and structured metadata through the external createRun API", async () => {
     requestLogCreateRunMock.mockReset().mockResolvedValue(81);
+    const jsonSchema = JSON.stringify({
+      type: "object",
+      properties: { answer: { type: "string" } },
+      required: ["answer"],
+    });
 
     await expect(
       QgridFrame.createRun({
         userPrompt: "hi",
         modelName: "google/gemini-3-flash",
         projectName: "external",
+        isStructured: true,
+        jsonSchema,
       }),
     ).resolves.toEqual({ requestLogId: 81 });
 
     expect(requestLogCreateRunMock).toHaveBeenCalledWith(
       expect.objectContaining({
         requested_model_name: "google/gemini-3-flash",
+        is_structured: true,
+        json_schema: jsonSchema,
       }),
     );
     expect(requestLogCreateRunMock).toHaveBeenCalledWith(
@@ -917,29 +926,6 @@ describe("QgridFrame raw lifecycle API", () => {
     );
   });
 
-  it("passes optional structured metadata through the external createRun API", async () => {
-    requestLogCreateRunMock.mockReset().mockResolvedValue(82);
-    const jsonSchema = JSON.stringify({
-      type: "object",
-      properties: { answer: { type: "string" } },
-      required: ["answer"],
-    });
-
-    await QgridFrame.createRun({
-      userPrompt: "hi",
-      modelName: "google/gemini-3.5-flash-lite",
-      isStructured: true,
-      jsonSchema,
-    });
-
-    expect(requestLogCreateRunMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        is_structured: true,
-        json_schema: jsonSchema,
-      }),
-    );
-  });
-
   it("passes optional response JSON validity through the external finishRun API", async () => {
     requestLogFinishRunMock.mockReset().mockResolvedValue(undefined);
 

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

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+
 import { Client, type ClientConfig } from "pg";
 import { Sonamu } from "sonamu";
 import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
@@ -613,7 +615,7 @@ describe("RequestLogModel cost provenance", () => {
     await RequestLogModel.totalCost();
 
     expect(sumChain.select).toHaveBeenCalledTimes(1);
-    // 조건을 걸면 cost_source 가 인덱스에 없어 커버링 인덱스가 무효화된다.
+    // source 없는 행도 저장된 이미지 비용을 포함하고 driver 차액만 별도로 보정한다.
     expect(sumChain.whereRaw).not.toHaveBeenCalled();
     expect(legacyChain.whereRaw).toHaveBeenCalledWith(
       "request_logs.cost_source IS NULL OR request_logs.cost_usd IS NULL",
@@ -723,11 +725,44 @@ describe("RequestLogModel cost provenance", () => {
   });
 });
 
-describe("RequestLogModel PostgreSQL run lock", () => {
+describe("RequestLogModel PostgreSQL", () => {
   beforeAll(async () => {
     await Sonamu.initForTesting();
   });
 
+  it("includes image costs once and filters both stored totals and legacy adjustments", async () => {
+    const projectName = `cost-${randomUUID()}`;
+    const ids: number[] = [];
+    try {
+      for (const [index, costs] of [
+        { cost_usd: 5_000, image_cost_usd: 10_000, cost_source: "provider" },
+        { cost_usd: 1_000, image_cost_usd: 20_000, cost_source: null },
+        { cost_usd: 900_000, image_cost_usd: 700_000, cost_source: null },
+      ].entries()) {
+        const id = await RequestLogModel.createRun({
+          user_prompt: "cost regression",
+          project_name: index < 2 ? projectName : `${projectName}-other`,
+        });
+        ids.push(id);
+        await RequestLogModel.getPuri("w").table("request_logs").where("id", id).update({
+          ...costs,
+          model_name: "anthropic/claude-sonnet-4-6",
+          token_name: "anthropic/test",
+          input_tokens: 1_000,
+        });
+      }
+
+      const params = { sonamuFilter: { project_name: projectName }, num: 0, page: 1 };
+      const { rows } = await RequestLogModel.findMany("C", params);
+      expect(rows.map((row) => row.id)).toEqual(expect.arrayContaining(ids.slice(0, 2)));
+      expect(rows).toHaveLength(2);
+      // Confirmed: .005 + .010; legacy driver repriced to .003, plus .020 image.
+      await expect(RequestLogModel.totalCost(params)).resolves.toBeCloseTo(0.038, 10);
+    } finally {
+      await RequestLogModel.del(ids);
+    }
+  });
+
   it("does not expire a run while another connection holds its follow-up lock", async () => {
     const wdb = RequestLogModel.getPuri("w");
     const client = new Client(wdb.knex.client.config.connection as ClientConfig);

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

@@ -5,6 +5,7 @@ import {
   BadRequestException,
   BaseModelClass,
   type ListResult,
+  normalizeFilterQuery,
   NotFoundException,
   Puri,
   transactional,
@@ -228,6 +229,7 @@ class RequestLogModelClass extends BaseModelClass<
       id,
       num: 1,
       page: 1,
+      queryMode: "list",
     });
     if (!rows[0]) {
       throw new NotFoundException(SD("error.entityNotFound")("RequestLog", id));
@@ -244,6 +246,7 @@ class RequestLogModelClass extends BaseModelClass<
       ...listParams,
       num: 1,
       page: 1,
+      queryMode: "list",
     });
 
     return rows[0] ?? null;
@@ -304,7 +307,7 @@ class RequestLogModelClass extends BaseModelClass<
       ...rawParams,
     } satisfies RequestLogListParams;
 
-    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+    const { qb } = this.getSubsetQueries(subset);
 
     this.applyListFilters(qb, params);
 
@@ -320,7 +323,6 @@ class RequestLogModelClass extends BaseModelClass<
       qb,
       params,
       enhancers,
-      debug: false,
     });
   }
 
@@ -808,10 +810,8 @@ class RequestLogModelClass extends BaseModelClass<
   /**
    * 화면 표시용 총 비용. 목록과 같은 필터를 적용한다.
    *
-   * 전체를 조건 없이 SUM 한 뒤, `cost_source` 가 없는 legacy row 의 차액만 보정한다.
-   * 조건 없는 SUM 이어야 `(project_name, cost_usd)` 커버링 인덱스가 Index Only Scan 을
-   * 탄다 — `cost_source IS NOT NULL` 을 걸면 그 컬럼이 인덱스에 없어 heap 을 다시 봐야
-   * 하므로 플래너가 인덱스를 버리고 seq scan 으로 돌아간다(실측 230ms → 814ms).
+   * driver와 image 비용을 함께 SUM한 뒤, legacy driver 비용의 차액만 보정한다.
+   * 이미지 비용은 저장값을 한 번만 포함하고 가격표 재계산 대상에서 제외한다.
    *
    * legacy 보정을 남겨둔 이유: 백필로 기존 legacy 는 0 이 되었지만, 외부 로거가
    * `AppendStepInput`/`FinishRunInput` 으로 costSource 없이 넣으면 다시 생길 수 있다.
@@ -830,18 +830,25 @@ class RequestLogModelClass extends BaseModelClass<
 
     const { qb: totalQb } = this.getSubsetQueries("C");
     this.applyListFilters(totalQb, params);
+    const sonamuFilter = params.sonamuFilter
+      ? normalizeFilterQuery(params.sonamuFilter)
+      : undefined;
+    this.applySonamuFilters(totalQb, sonamuFilter);
     // 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)"),
+        total: Puri.rawNumber(
+          "COALESCE(SUM(GREATEST(request_logs.cost_usd, 0) + COALESCE(request_logs.image_cost_usd, 0)), 0)",
+        ),
       })
       .first();
 
     const { qb: legacyQb } = this.getSubsetQueries("C");
     this.applyListFilters(legacyQb, params);
+    this.applySonamuFilters(legacyQb, sonamuFilter);
     const legacyRows = await legacyQb
       .whereRaw("request_logs.cost_source IS NULL OR request_logs.cost_usd IS NULL")
       .clear("select")

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

@@ -41,6 +41,7 @@ class RequestLogStepModelClass extends BaseModelClass<
       id,
       num: 1,
       page: 1,
+      queryMode: "list",
     });
     if (!rows[0]) {
       throw new NotFoundException(SD("error.entityNotFound")("RequestLogStep", id));
@@ -57,6 +58,7 @@ class RequestLogStepModelClass extends BaseModelClass<
       ...listParams,
       num: 1,
       page: 1,
+      queryMode: "list",
     });
 
     return rows[0] ?? null;
@@ -77,7 +79,7 @@ class RequestLogStepModelClass extends BaseModelClass<
     } satisfies RequestLogStepListParams;
 
     // build queries
-    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+    const { qb } = this.getSubsetQueries(subset);
 
     if (params.id) {
       qb.whereIn("request_log_steps.id", asArray(params.id));
@@ -91,8 +93,6 @@ class RequestLogStepModelClass extends BaseModelClass<
     if (params.search && params.keyword && params.keyword.length > 0) {
       if (params.search === "id") {
         qb.where("request_log_steps.id", Number(params.keyword));
-        // } else if (params.search === "field") {
-        //   qb.where("request_log_steps.field", "like", `%${params.keyword}%`);
       } else {
         throw new BadRequestException(SD("error.unknownSearchField")(params.search));
       }
@@ -109,22 +109,10 @@ class RequestLogStepModelClass extends BaseModelClass<
       }
     }
 
-    const enhancers = this.createEnhancers({
-      A: (row) => ({
-        ...row,
-        // 서브셋별로 virtual 필드 계산로직 추가
-      }),
-      T: (row) => ({
-        ...row,
-      }),
-    });
-
     return this.executeSubsetQuery({
       subset,
       qb,
       params,
-      enhancers,
-      debug: false,
     });
   }
 

package/bundle/src/application/setting/setting.constant.test.ts

@@ -10,6 +10,7 @@ describe("validateSettingValue", () => {
     // 저장을 막지 않으면 런타임에서 조용히 기본값으로 떨어져 원인을 찾기 어렵다.
     expect(validateSettingValue(intDef, "24")).toMatchObject({ ok: false });
     expect(validateSettingValue(intDef, "-1")).toMatchObject({ ok: false });
+    expect(validateSettingValue(intDef, "0")).toMatchObject({ ok: true, value: "0" });
     expect(validateSettingValue(intDef, "23")).toMatchObject({ ok: true, value: "23" });
   });
 
@@ -48,19 +49,6 @@ describe("preset 검증", () => {
   });
 });
 
-describe("조용 시간 설정", () => {
-  // fallback("20"/"8")은 quiet-hours.ts 의 DEFAULT_QUIET_* 와 같아야 하지만 테스트로 묶지
-  // 않는다 — 두 모듈을 한 파일에서 import 하면 setting.store → token.model 이 딸려와,
-  // token.model 을 mock 하는 테스트가 같은 워커에 배치될 때 실제 모듈을 먼저 로드해 버린다.
-  it("0..23 을 벗어나면 거부한다", () => {
-    const fromDef = findSettingDef("slack.quietFromHour")!;
-    expect(validateSettingValue(fromDef, "24")).toMatchObject({ ok: false });
-    expect(validateSettingValue(fromDef, "-1")).toMatchObject({ ok: false });
-    expect(validateSettingValue(fromDef, "0")).toMatchObject({ ok: true });
-    expect(validateSettingValue(fromDef, "23")).toMatchObject({ ok: true });
-  });
-});
-
 describe("maskSecret", () => {
   it("긴 값은 앞뒤만 남긴다", () => {
     expect(maskSecret("xoxb-1234567890-abcdefghij")).toBe("xoxb-123...ghij");

package/bundle/src/application/setting/setting.model.ts

@@ -90,6 +90,7 @@ class SettingModelClass extends BaseModelClass<
       id,
       num: 1,
       page: 1,
+      queryMode: "list",
     });
     if (!rows[0]) {
       throw new NotFoundException(SD("error.entityNotFound")("Setting", id));
@@ -106,6 +107,7 @@ class SettingModelClass extends BaseModelClass<
       ...listParams,
       num: 1,
       page: 1,
+      queryMode: "list",
     });
 
     return rows[0] ?? null;
@@ -126,7 +128,7 @@ class SettingModelClass extends BaseModelClass<
     } satisfies SettingListParams;
 
     // build queries
-    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+    const { qb } = this.getSubsetQueries(subset);
 
     // id
     if (params.id) {
@@ -157,19 +159,10 @@ class SettingModelClass extends BaseModelClass<
       }
     }
 
-    const enhancers = this.createEnhancers({
-      A: (row) => ({
-        ...row,
-        // 서브셋별로 virtual 필드 계산로직 추가
-      }),
-    });
-
     return this.executeSubsetQuery({
       subset,
       qb,
       params,
-      enhancers,
-      debug: false,
     });
   }
 
@@ -202,30 +195,21 @@ class SettingModelClass extends BaseModelClass<
 
   /** 저장된 설정 전체를 key→value 로. 부팅 시 한 번 읽어 메모리에 올린다. */
   async findAllAsMap(): Promise<Map<string, string>> {
-    const { rows } = await this.findMany("A", { num: 0, page: 1 });
+    const { rows } = await this.findMany("A", { num: 0, page: 1, queryMode: "list" });
     return new Map(rows.map((r) => [r.key, r.value]));
   }
 
-  /**
-   * key 로 upsert 한다. `save` 는 id 기준이라 key 중복을 걸러내지 못해, 기존 행을 먼저 찾아
-   * id 를 실어 보낸다.
-   */
+  /** 최초 동시 저장도 key unique constraint로 원자적으로 처리한다. */
   async setByKey(key: string, value: string): Promise<void> {
-    const existing = await this.findOne("A", { key, num: 1, page: 1 });
-    await this.save([
-      {
-        ...(existing ? { id: existing.id } : {}),
-        key,
-        value,
-        updated_at: new Date(),
-      },
-    ]);
+    await this.getPuri("w")
+      .table("settings")
+      .insert({ key, value, updated_at: new Date() })
+      .onConflict("key", { update: ["value", "updated_at"] });
   }
 
   /** 저장값을 지워 env 기본값으로 되돌린다. */
   async clearByKey(key: string): Promise<void> {
-    const existing = await this.findOne("A", { key, num: 1, page: 1 });
-    if (existing) await this.del([existing.id]);
+    await this.getPuri("w").table("settings").where("key", key).delete();
   }
 
   /**

package/bundle/src/application/setting/setting.persistence.test.ts

@@ -0,0 +1,27 @@
+import { randomUUID } from "node:crypto";
+
+import { Sonamu } from "sonamu";
+import { beforeAll, expect, it } from "vitest";
+
+import { SettingModel } from "./setting.model";
+
+beforeAll(async () => {
+  await Sonamu.initForTesting();
+});
+
+it("atomically saves concurrent first writes to the same setting key", async () => {
+  const key = `test.concurrent.${randomUUID()}`;
+  try {
+    await Promise.all([SettingModel.setByKey(key, "first"), SettingModel.setByKey(key, "second")]);
+    const { rows } = await SettingModel.findMany("A", { key, num: 0, page: 1 });
+    expect(rows).toHaveLength(1);
+    expect(["first", "second"]).toContain(rows[0]!.value);
+    await SettingModel.setByKey(key, "final");
+    await expect(SettingModel.findOne("A", { key })).resolves.toMatchObject({
+      id: rows[0]!.id,
+      value: "final",
+    });
+  } finally {
+    await SettingModel.clearByKey(key);
+  }
+});

package/bundle/src/application/token/token.model.test.ts

@@ -115,32 +115,99 @@ describe("TokenModel.updateFields", () => {
 });
 
 describe("TokenModel.replaceByAccount", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
+  beforeAll(async () => {
+    await Sonamu.initForTesting();
   });
 
-  it("re-login으로 row가 교체돼도 기존 keepalive 선택을 보존한다", async () => {
-    vi.spyOn(TokenModel, "findByAccountIdentifier").mockResolvedValue([
+  it("replaces duplicate account rows while preserving routing settings and renewing login state", async () => {
+    const accountUuid = randomUUID();
+    const credentials = { ...baseToken.credentials, accountUuid };
+    const ids = await TokenModel.save([
       {
-        id: 1,
-        created_at: new Date(),
-        active: true,
-        reauth_required: false,
-        ord: 0,
-        quota_threshold: 80,
-        weight: 1,
-        keepalive_enabled: true,
         ...baseToken,
+        name: `replace-first-${accountUuid}`,
+        credentials,
+        active: false,
+        reauth_required: true,
+        ord: 9,
+        quota_threshold: null,
+        weight: 7,
+        keepalive_enabled: false,
       },
+      { ...baseToken, name: `replace-second-${accountUuid}`, credentials, keepalive_enabled: true },
     ]);
-    vi.spyOn(TokenModel, "del").mockResolvedValue(1);
-    const save = vi.spyOn(TokenModel, "save").mockResolvedValue([2]);
+    const refreshed = { ...credentials, accessToken: "refreshed-access-token" };
+    try {
+      await TokenModel.replaceByAccount("anthropic", accountUuid, {
+        ...baseToken,
+        name: `replace-first-${accountUuid}`,
+        credentials: refreshed,
+      });
+      const rows = await TokenModel.findByAccountIdentifier("A", "anthropic", accountUuid);
+      expect(rows).toHaveLength(1);
+      expect(ids).not.toContain(rows[0]!.id);
+      expect(rows[0]).toMatchObject({
+        credentials: refreshed,
+        active: true,
+        reauth_required: false,
+        ord: 9,
+        quota_threshold: null,
+        weight: 7,
+        keepalive_enabled: true,
+      });
+    } finally {
+      const rows = await TokenModel.findByAccountIdentifier("A", "anthropic", accountUuid);
+      await TokenModel.del(rows.map((row) => row.id));
+    }
+  });
 
-    await TokenModel.replaceByAccount("anthropic", "acc-1", baseToken);
+  it("rolls back the deletion when the replacement violates a database constraint", async () => {
+    const accountUuid = randomUUID();
+    const original = {
+      ...baseToken,
+      name: `rollback-${accountUuid}`,
+      credentials: { ...baseToken.credentials, accountUuid },
+      quota_threshold: 42,
+      weight: 3,
+      ord: 8,
+      keepalive_enabled: true,
+    };
+    const [id] = await TokenModel.save([original]);
+    try {
+      await expect(
+        TokenModel.replaceByAccount("anthropic", accountUuid, {
+          ...original,
+          provider: "x".repeat(21),
+        }),
+      ).rejects.toThrow();
+      await expect(TokenModel.findById("A", id!)).resolves.toMatchObject(original);
+    } finally {
+      await TokenModel.del([id!]);
+    }
+  });
 
-    expect(save).toHaveBeenCalledWith([
-      expect.objectContaining({ keepalive_enabled: true }),
-    ]);
+  it("loads every active or expired token when a pool exceeds 100 accounts", async () => {
+    const suffix = randomUUID();
+    const ids = await TokenModel.save(
+      Array.from({ length: 101 }, (_, index) => ({
+        ...baseToken,
+        name: `pool-${suffix}-${index}`,
+        credentials: { ...baseToken.credentials, accountUuid: suffix },
+        reauth_required: true,
+      })),
+    );
+    try {
+      for (const rows of [
+        await TokenModel.findActive("A"),
+        await TokenModel.findActiveByProvider("A", "anthropic"),
+        await TokenModel.findReauthRequired("A"),
+        await TokenModel.findByAccountIdentifier("A", "anthropic", suffix),
+      ]) {
+        expect(rows.map((row) => row.id)).toEqual(expect.arrayContaining(ids));
+      }
+    } finally {
+      await TokenModel.del(ids);
+    }
   });
 });
 
@@ -176,7 +243,7 @@ describe("TokenModel.findActiveByProviderAndName", () => {
       ["tokens.name", "anthropic/tok-A"],
     ]);
     expect(executeSubsetQuery).toHaveBeenCalledWith(
-      expect.objectContaining({ subset: "A", qb, params: { num: 1, page: 1 } }),
+      expect.objectContaining({ subset: "A", qb, params: { num: 1, page: 1, queryMode: "list" } }),
     );
   });
 });