@cartanova/qgrid-cli 2.10.10 → 2.11.1

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

@@ -12,6 +12,7 @@ import {
 } from "sonamu";
 
 import { SD } from "../../i18n/sd.generated";
+import { isProviderId, type ProviderId } from "../../utils/providers/common/provider-types";
 import { type TokenSubsetKey, type TokenSubsetMapping } from "../sonamu.generated";
 import { tokenLoaderQueries, tokenSubsetQueries } from "../sonamu.generated.sso";
 import { type TokenCredentials, type TokenListParams, type TokenSaveParams } from "./token.types";
@@ -29,13 +30,40 @@ export type TokenUpdateFields = {
   keepalive_enabled?: boolean;
 };
 
+// provider 별로 같은 계정을 식별하는 credentials JSONB 키. 재로그인 dedup 과 계정 조회가 함께 쓴다.
+export const TOKEN_IDENTITY_KEYS = {
+  anthropic: "accountUuid",
+  openai: "accountId",
+  grok: "userId",
+} as const satisfies Record<ProviderId, string>;
+
+export type TokenIdentityKey = (typeof TOKEN_IDENTITY_KEYS)[ProviderId];
+
+export class UnknownTokenProviderError extends Error {
+  readonly provider: string;
+
+  constructor(provider: string) {
+    super(`Unknown token provider: ${provider}`);
+    this.name = "UnknownTokenProviderError";
+    this.provider = provider;
+  }
+}
+
+export function tokenIdentityKey(provider: string): TokenIdentityKey {
+  if (!isProviderId(provider)) throw new UnknownTokenProviderError(provider);
+
+  return TOKEN_IDENTITY_KEYS[provider];
+}
+
 function applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {
   if (sp.id !== undefined) return sp;
-  return {
-    ...sp,
-    ...(sp.quota_threshold === undefined ? { quota_threshold: DEFAULT_QUOTA_THRESHOLD } : {}),
-    ...(sp.weight === undefined ? { weight: DEFAULT_WEIGHT } : {}),
-  };
+  const withDefaults: TokenSaveParams = { ...sp };
+
+  if (sp.quota_threshold === undefined) withDefaults.quota_threshold = DEFAULT_QUOTA_THRESHOLD;
+
+  if (sp.weight === undefined) withDefaults.weight = DEFAULT_WEIGHT;
+
+  return withDefaults;
 }
 
 class TokenModelClass extends BaseModelClass<
@@ -51,9 +79,11 @@ class TokenModelClass extends BaseModelClass<
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "Token" })
   async findById<T extends TokenSubsetKey>(subset: T, id: number): Promise<TokenSubsetMapping[T]> {
     const { rows } = await this.findMany(subset, { id, num: 1, page: 1, queryMode: "list" });
+
     if (!rows[0]) {
       throw new NotFoundException(SD("error.entityNotFound")("Token", id));
     }
+
     return rows[0];
   }
 
@@ -67,6 +97,7 @@ class TokenModelClass extends BaseModelClass<
       page: 1,
       queryMode: "list",
     });
+
     return rows[0] ?? null;
   }
 
@@ -119,14 +150,16 @@ class TokenModelClass extends BaseModelClass<
     accountId: string,
   ): Promise<TokenSubsetMapping[T][]> {
     const { qb } = this.getSubsetQueries(subset);
+    const jsonKey = tokenIdentityKey(provider);
     qb.where("tokens.provider", provider);
-    const jsonKey = provider === "anthropic" ? "accountUuid" : "accountId";
     qb.whereRaw(`tokens.credentials->>'${jsonKey}' = ?`, [accountId]);
+
     const result = await this.executeSubsetQuery({
       subset,
       qb,
       params: { num: 0, page: 1, queryMode: "list" },
     });
+
     return result.rows;
   }
 
@@ -137,11 +170,13 @@ class TokenModelClass extends BaseModelClass<
     const { qb } = this.getSubsetQueries(subset);
     qb.where("tokens.active", true);
     qb.where("tokens.provider", provider);
+
     const result = await this.executeSubsetQuery({
       subset,
       qb,
       params: { num: 0, page: 1, queryMode: "list" },
     });
+
     return result.rows;
   }
 
@@ -154,11 +189,13 @@ class TokenModelClass extends BaseModelClass<
     qb.where("tokens.active", true);
     qb.where("tokens.provider", provider);
     qb.where("tokens.name", name);
+
     const result = await this.executeSubsetQuery({
       subset,
       qb,
       params: { num: 1, page: 1, queryMode: "list" },
     });
+
     return result.rows[0];
   }
 
@@ -167,22 +204,26 @@ class TokenModelClass extends BaseModelClass<
     const { qb } = this.getSubsetQueries(subset);
     qb.where("tokens.reauth_required", true);
     qb.orderBy("tokens.name", "asc");
+
     const result = await this.executeSubsetQuery({
       subset,
       qb,
       params: { num: 0, page: 1, queryMode: "list" },
     });
+
     return result.rows;
   }
 
   async findActive<T extends TokenSubsetKey>(subset: T): Promise<TokenSubsetMapping[T][]> {
     const { qb } = this.getSubsetQueries(subset);
     qb.where("tokens.active", true);
+
     const result = await this.executeSubsetQuery({
       subset,
       qb,
       params: { num: 0, page: 1, queryMode: "list" },
     });
+
     return result.rows;
   }
 
@@ -191,6 +232,7 @@ class TokenModelClass extends BaseModelClass<
     spa.forEach((sp) => {
       wdb.ubRegister("tokens", applyCreateDefaults(sp));
     });
+
     return wdb.transaction(async (trx) => {
       return trx.ubUpsert("tokens");
     });
@@ -198,11 +240,13 @@ class TokenModelClass extends BaseModelClass<
 
   async updateFields(id: number, fields: TokenUpdateFields): Promise<number> {
     const wdb = this.getPuri("w");
+
     return wdb.transaction((trx) => trx.table("tokens").where("id", id).update(fields));
   }
 
   async toggleActive(id: number): Promise<{ active: boolean; reauthRequired: boolean } | null> {
     const wdb = this.getPuri("w");
+
     return wdb.transaction(async (trx) => {
       const token = await trx
         .from("tokens")
@@ -210,13 +254,16 @@ class TokenModelClass extends BaseModelClass<
         .where("id", id)
         .forUpdate()
         .first();
+
       if (!token) return null;
+
       if (!token.active && token.reauth_required) {
         return { active: false, reauthRequired: true };
       }
 
       const active = !token.active;
       await trx.from("tokens").where("id", id).update({ active });
+
       return { active, reauthRequired: false };
     });
   }
@@ -232,10 +279,11 @@ class TokenModelClass extends BaseModelClass<
     accountId: string | undefined,
     saveParams: TokenSaveParams,
   ): Promise<void> {
+    const jsonKey = tokenIdentityKey(provider);
     await this.getPuri("w").transaction(async (trx) => {
       let replacement = saveParams;
+
       if (accountId) {
-        const jsonKey = provider === "anthropic" ? "accountUuid" : "accountId";
         const oldEntries = await trx
           .from("tokens")
           .select({
@@ -249,7 +297,9 @@ class TokenModelClass extends BaseModelClass<
           .whereRaw(`credentials->>'${jsonKey}' = ?`, [accountId])
           .orderBy("id", "asc")
           .forUpdate();
+
         const first = oldEntries[0];
+
         if (first) {
           replacement = {
             ...saveParams,
@@ -290,6 +340,7 @@ class TokenModelClass extends BaseModelClass<
     expectedCredentials: TokenCredentials,
   ): Promise<{ marked: boolean; wasLastActive: boolean; staleCredentials: boolean }> {
     const wdb = this.getPuri("w");
+
     return wdb.transaction(async (trx) => {
       const token = await trx
         .from("tokens")
@@ -301,9 +352,11 @@ class TokenModelClass extends BaseModelClass<
         .where("id", id)
         .forUpdate()
         .first();
+
       if (!token || token.reauth_required) {
         return { marked: false, wasLastActive: false, staleCredentials: false };
       }
+
       if (!isDeepStrictEqual(token.credentials, expectedCredentials)) {
         return { marked: false, wasLastActive: false, staleCredentials: true };
       }
@@ -312,6 +365,7 @@ class TokenModelClass extends BaseModelClass<
         TOKEN_AUTH_DEATH_LOCK_CLASS_ID,
         token.provider,
       ]);
+
       const updated = await trx.knex.raw<{ rows: { was_last_active: boolean }[] }>(
         `WITH previous AS (
            SELECT active AND NOT EXISTS (
@@ -327,12 +381,15 @@ class TokenModelClass extends BaseModelClass<
          RETURNING (SELECT was_last_active FROM previous) AS was_last_active`,
         [id, id],
       );
+
       const marked = updated.rows[0];
+
       if (!marked) return { marked: false, wasLastActive: false, staleCredentials: false };
 
       if (marked.was_last_active) {
         logger.error(`deactivated expired token ${id}: no usable provider tokens remain`);
       }
+
       return { marked: true, wasLastActive: marked.was_last_active, staleCredentials: false };
     });
   }
@@ -354,6 +411,7 @@ class TokenModelClass extends BaseModelClass<
         await trx.table("tokens").where("id", ids[i]!).update({ ord: i });
       }
     });
+
     return { done: true };
   }
 
@@ -363,6 +421,7 @@ class TokenModelClass extends BaseModelClass<
     await wdb.transaction(async (trx) => {
       return trx.table("tokens").whereIn("tokens.id", ids).delete();
     });
+
     return ids.length;
   }
 }

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

@@ -10,6 +10,7 @@ export const AnthropicCredentials = z.object({
   expiresAt: z.number(),
   accountUuid: z.string(),
 });
+
 export type AnthropicCredentials = z.infer<typeof AnthropicCredentials>;
 
 export const OpenAICredentials = z.object({
@@ -21,13 +22,34 @@ export const OpenAICredentials = z.object({
   accountId: z.string(),
   planType: z.string().optional(),
 });
+
 export type OpenAICredentials = z.infer<typeof OpenAICredentials>;
 
-export const TokenCredentials = z.union([AnthropicCredentials, OpenAICredentials]);
+// Web-safe storage shape only. Registration and refresh validate with the strict schema in
+// utils/providers/grok/grok-types.ts (at+jwt from auth.x.ai, GUID ids).
+export const GrokCredentials = z.object({
+  authMode: z.literal("oauth"),
+  accessToken: z.string(),
+  refreshToken: z.string(),
+  expiresAt: z.string(),
+  issuer: z.literal("https://auth.x.ai"),
+  clientId: z.string(),
+  scopes: z.array(z.string()),
+  userId: z.string(),
+  sessionId: z.string(),
+  agentId: z.string(),
+  subscriptionTier: z.string().optional(),
+});
+
+export type GrokCredentials = z.infer<typeof GrokCredentials>;
+
+export const TokenCredentials = z.union([AnthropicCredentials, OpenAICredentials, GrokCredentials]);
+
 export type TokenCredentials = z.infer<typeof TokenCredentials>;
 
 // Token - ListParams
 export const TokenListParams = TokenBaseListParams;
+
 export type TokenListParams = z.infer<typeof TokenListParams>;
 
 const TokenQuotaThreshold = z.int().min(1).max(100).nullable();
@@ -47,4 +69,5 @@ export const TokenSaveParams = TokenBaseSchema.partial({
   quota_threshold: TokenQuotaThreshold.optional(),
   weight: TokenWeight.optional(),
 });
+
 export type TokenSaveParams = z.infer<typeof TokenSaveParams>;

package/bundle/src/i18n/en.ts

@@ -42,6 +42,7 @@ export default {
   "entity.listManage": (name: string) => `Manage ${name} List`,
   "error.alreadyProcessed": "Already processed",
   "error.badRequest": "Bad request",
+  "error.detail": (detail: string) => detail,
   "error.duplicateRow": "Duplicate data",
   "error.forbidden": "Forbidden",
   "error.internalServerError": "Internal server error",
@@ -52,6 +53,24 @@ export default {
   "qgrid.dispatcherFailed": (provider: string) => `${provider} dispatcher failed to initialize`,
   "qgrid.dispatcherStarting": (provider: string) =>
     `${provider} dispatcher is starting up. Please retry shortly`,
+  "qgrid.grokCapabilityUnavailable": (detail: string) => `Grok capability unavailable: ${detail}`,
+  "qgrid.grokCapacity": "All Grok tokens are at their in-flight request cap. Please retry shortly",
+  "qgrid.grokContentPolicy": (detail: string) =>
+    `Grok generation blocked by content policy: ${detail}`,
+  "qgrid.grokInvalidRequest": (detail: string) => `Invalid Grok request: ${detail}`,
+  "qgrid.grokLoginFailed": (detail: string) => `Grok login failed: ${detail}`,
+  "qgrid.grokNotOAuthToken": "Grok login returned credentials that are not an xAI OAuth token",
+  "qgrid.grokNoWorkers": (detail: string) => `No Grok token is available: ${detail}`,
+  "qgrid.grokRateLimited": (retryAfterSec: number) =>
+    `All Grok tokens are rate limited. Retry after ${retryAfterSec} seconds`,
+  "qgrid.grokOnDemandExcluded": (tokens: string) =>
+    `All Grok tokens are excluded because on-demand billing is enabled at xAI: ${tokens}. Turn off on-demand billing, or add another account`,
+  "qgrid.grokZdrVideoUnavailable": (tokens: string) =>
+    `Grok video is unavailable because Zero Data Retention is on for: ${tokens}. Turn off the data-retention opt-out at xAI, or use a non-ZDR account`,
+  "qgrid.invalidInput": (detail: string) => `qgrid: invalid input: ${detail}`,
+  "qgrid.requestBodyTooLarge": (limitMiB: number) =>
+    `Request body exceeds the ${limitMiB} MiB limit`,
+  "qgrid.videoJobNotFound": "video job not found",
   "error.unauthorized": "Unauthorized",
   notFound: (name: string, id: number) => `${name} ID ${id} not found`,
   "validation.email": "Invalid email format",

package/bundle/src/i18n/ko.ts

@@ -40,6 +40,8 @@ export default {
   "entity.listManage": (name: string) => `${name} 목록 관리`,
   "error.alreadyProcessed": "이미 처리되었습니다",
   "error.badRequest": "잘못된 요청입니다",
+  // Upstream and validation messages that are shown to the caller verbatim in every locale.
+  "error.detail": (detail: string) => detail,
   "error.duplicateRow": "중복된 데이터입니다",
   "error.entityNotFound": (name: string, id: number | string) => `존재하지 않는 ${name} ID ${id}`,
   "error.forbidden": "권한이 없습니다",
@@ -51,6 +53,25 @@ export default {
   "qgrid.dispatcherFailed": (provider: string) => `${provider} dispatcher 초기화에 실패했습니다`,
   "qgrid.dispatcherStarting": (provider: string) =>
     `${provider} dispatcher 기동 중입니다. 잠시 후 다시 시도해주세요`,
+  "qgrid.grokCapabilityUnavailable": (detail: string) =>
+    `Grok 기능을 사용할 수 없습니다: ${detail}`,
+  "qgrid.grokCapacity": "모든 Grok 토큰이 동시 요청 한도에 도달했습니다. 잠시 후 다시 시도해주세요",
+  "qgrid.grokContentPolicy": (detail: string) =>
+    `콘텐츠 정책 위반으로 Grok 생성이 차단되었습니다: ${detail}`,
+  "qgrid.grokInvalidRequest": (detail: string) => `잘못된 Grok 요청입니다: ${detail}`,
+  "qgrid.grokLoginFailed": (detail: string) => `Grok 로그인에 실패했습니다: ${detail}`,
+  "qgrid.grokNotOAuthToken": "Grok 로그인 결과가 xAI OAuth 토큰이 아닙니다",
+  "qgrid.grokNoWorkers": (detail: string) => `사용 가능한 Grok 토큰이 없습니다: ${detail}`,
+  "qgrid.grokRateLimited": (retryAfterSec: number) =>
+    `모든 Grok 토큰이 요청 한도에 걸렸습니다. ${retryAfterSec}초 후 다시 시도해주세요`,
+  "qgrid.grokOnDemandExcluded": (tokens: string) =>
+    `xAI에서 on-demand 과금이 켜져 있어 모든 Grok 토큰이 제외되었습니다: ${tokens}. on-demand 과금을 끄거나 다른 계정을 추가해주세요`,
+  "qgrid.grokZdrVideoUnavailable": (tokens: string) =>
+    `Zero Data Retention이 켜져 있어 Grok 비디오를 사용할 수 없습니다: ${tokens}. xAI에서 data-retention opt-out을 끄거나 ZDR이 아닌 계정을 사용해주세요`,
+  "qgrid.invalidInput": (detail: string) => `qgrid: 잘못된 입력입니다: ${detail}`,
+  "qgrid.requestBodyTooLarge": (limitMiB: number) =>
+    `요청 본문이 ${limitMiB} MiB 제한을 초과했습니다`,
+  "qgrid.videoJobNotFound": "비디오 작업을 찾을 수 없습니다",
   "error.unauthorized": "인증이 필요합니다",
   "error.unknownSearchField": (field: string) => `구현되지 않은 검색 필드 ${field}`,
   notFound: (name: string, id: number) => `존재하지 않는 ${name} ID ${id}`,

package/bundle/src/i18n/sd.generated.ts

@@ -2,14 +2,18 @@
  * @generated
  * 직접 수정하지 마세요.
  */
+// Sonamu 생성 코드의 타입 계약을 유지하기 위해 anti-slop 검사만 제외합니다.
+/* oxlint-disable anti-slop/no-chained-type-assertions, anti-slop/no-conditional-empty-object-spread, anti-slop/no-known-value-widening, anti-slop/no-module-mocking, anti-slop/no-object-parameters, anti-slop/no-reflect-apply, anti-slop/no-reflect-get, anti-slop/no-runtime-typeof, anti-slop/no-shape-in-symbol-names, anti-slop/no-unknown-parameters, anti-slop/no-unknown-returns, anti-slop/no-unknown-type-aliases, anti-slop/no-unsafe-dictionary-type, anti-slop/no-widen-then-assert, anti-slop/require-safety-comment-for-type-assertion */
 
 import { Sonamu } from "sonamu";
 
 const DEFAULT_LOCALE = "ko" as const;
 const SUPPORTED_LOCALES = ["ko", "en"] as const;
+
 function getCurrentLocale(): (typeof SUPPORTED_LOCALES)[number] {
   try {
     const ctx = Sonamu.getContext();
+
     return (ctx.locale as (typeof SUPPORTED_LOCALES)[number]) ?? DEFAULT_LOCALE;
   } catch {
     return DEFAULT_LOCALE;
@@ -332,8 +336,11 @@ const entityLabels = {
 
 // defaultLocale의 dictionary를 기준으로 키 추출
 type RCKeys = typeof rcKeysKo;
+
 type ProjectDictionary = typeof ko;
+
 type EntityLabels = typeof entityLabels;
+
 type RawMergedDictionary = RCKeys &
   Omit<EntityLabels, keyof (RCKeys & ProjectDictionary)> &
   ProjectDictionary;
@@ -344,7 +351,9 @@ export type MergedDictionary = {
     ? (...args: P) => string
     : string;
 };
+
 export type DictKey = keyof MergedDictionary;
+
 export type LocalizedString = string & { __brand: "LocalizedString" };
 
 export function defineLocale(dict: Partial<MergedDictionary>) {
@@ -364,6 +373,7 @@ type SDReturnType<K extends DictKey> = MergedDictionary[K] extends (...args: inf
 function getDictValue<K extends DictKey>(key: K, locale: string): SDReturnType<K> {
   // 1. 지정된 locale에서 조회
   const dict = dictionaries[locale];
+
   if (dict?.[key] !== undefined) {
     return dict[key] as unknown as SDReturnType<K>;
   }
@@ -396,6 +406,7 @@ function getDictValue<K extends DictKey>(key: K, locale: string): SDReturnType<K
  */
 export function SD<K extends DictKey>(key: K): SDReturnType<K> {
   const locale = getCurrentLocale();
+
   return getDictValue(key, locale);
 }
 
@@ -430,12 +441,15 @@ type LocalizedBaseColumn<T> = {
  * localizedColumn(tag, "name")
  */
 type LocalizedColumnScalarValue = string | number | boolean | bigint;
+
 type LocalizedColumnValue = string | string[];
+
 type NestedLocalizedColumnValueFrom<V> = V extends string
   ? string
   : V extends readonly string[]
     ? string[]
     : never;
+
 type LocalizedColumnValueFrom<V> = V extends string
   ? string
   : V extends readonly string[]
@@ -445,6 +459,7 @@ type LocalizedColumnValueFrom<V> = V extends string
       : V extends Partial<Record<(typeof SUPPORTED_LOCALES)[number], infer LV>>
         ? NestedLocalizedColumnValueFrom<LV>
         : never;
+
 type LocalizedColumnCandidate<T, K extends string> =
   | (K extends keyof T ? T[K] : never)
   | {
@@ -452,9 +467,11 @@ type LocalizedColumnCandidate<T, K extends string> =
         ? T[`${K}_${L}`]
         : never;
     }[(typeof SUPPORTED_LOCALES)[number]];
+
 type LocalizedColumnReturn<T, K extends string> =
   | LocalizedColumnValueFrom<LocalizedColumnCandidate<T, K>>
   | undefined;
+
 type LocaleValueMap = Partial<Record<(typeof SUPPORTED_LOCALES)[number], unknown>>;
 
 function isLocalizedColumnValue(value: unknown): value is LocalizedColumnValue {
@@ -472,12 +489,13 @@ function isEmptyLocalizedColumnValue(value: unknown): value is null | undefined
   return value === null || value === undefined || value === "";
 }
 
-function getNestedLocaleValue<T extends Record<string, unknown>, K extends LocalizedBaseColumn<T>>(
+function getNestedLocaleValue<T extends Record<string, unknown>>(
   row: T,
-  column: K,
+  column: LocalizedBaseColumn<T>,
   locale: (typeof SUPPORTED_LOCALES)[number],
 ): unknown {
   const columnValue = row[column];
+
   if (columnValue === null || typeof columnValue !== "object" || Array.isArray(columnValue)) {
     return undefined;
   }
@@ -496,6 +514,7 @@ export function localizedColumn<
   );
   const localizedKey = (column: K, locale: (typeof SUPPORTED_LOCALES)[number]) =>
     `${column}_${locale}`;
+
   const values = [
     { value: row[localizedKey(column, locale)], source: "direct" },
     { value: getNestedLocaleValue(row, column, locale), source: "nested" },
@@ -512,6 +531,7 @@ export function localizedColumn<
     if (!isEmptyLocalizedColumnValue(value) && isLocalizedColumnValue(value)) {
       return value as LocalizedColumnReturn<T, K>;
     }
+
     if (
       source === "direct" &&
       !isEmptyLocalizedColumnValue(value) &&
@@ -539,6 +559,7 @@ SD.enumLabels = (enumName: string): Record<string, LocalizedString> => {
       }
 
       const dictKey = `enum.${enumName}.${key}` as DictKey;
+
       return getDictValue(dictKey, getCurrentLocale());
     },
   });

package/bundle/src/migrations/20260807133553_manual__backfill_request_log_cost.ts

@@ -52,23 +52,30 @@ function backfilledCostMicroUsd(row: LegacyRow): number {
   // 이를 합치지 않아 input_tokens 가 작게 남은 row 를 복원한다.
   const splitInput =
     isAnthropicRow(row) && row.input_tokens < row.cache_read_tokens + row.cache_creation_tokens;
+
   const inputTokens = splitInput
     ? row.input_tokens + row.cache_read_tokens + row.cache_creation_tokens
     : row.input_tokens;
 
   const model = row.model_name.includes("/") ? row.model_name.split("/").pop()! : row.model_name;
-  const usd = calculateCostUsd(model, {
+
+  const usage: Parameters<typeof calculateCostUsd>[1] = {
     inputTokens,
     outputTokens: row.output_tokens,
     cachedInputTokens: row.cache_read_tokens,
     cacheCreationInputTokens: row.cache_creation_tokens,
-    ...(row.cache_creation_5m_tokens !== null
-      ? { cacheCreationInputTokens5m: row.cache_creation_5m_tokens }
-      : {}),
-    ...(row.cache_creation_1h_tokens !== null
-      ? { cacheCreationInputTokens1h: row.cache_creation_1h_tokens }
-      : {}),
-  });
+  };
+
+  if (row.cache_creation_5m_tokens !== null) {
+    usage.cacheCreationInputTokens5m = row.cache_creation_5m_tokens;
+  }
+
+  if (row.cache_creation_1h_tokens !== null) {
+    usage.cacheCreationInputTokens1h = row.cache_creation_1h_tokens;
+  }
+
+  const usd = calculateCostUsd(model, usage);
+
   return Math.max(Math.round(usd * MICRO_USD), 0);
 }
 
@@ -87,6 +94,7 @@ export async function up(knex: Knex): Promise<void> {
         LIMIT ?`,
       [lastId, CHUNK_SIZE],
     );
+
     if (rows.length === 0) break;
 
     // chunk 당 한 번의 UPDATE ... FROM (VALUES ...) 로 왕복을 줄인다.

package/bundle/src/server-bootstrap.ts

@@ -5,14 +5,16 @@ import { runRequiredMigrations } from "./startup-migrations";
 type BootstrapSteps = {
   init: () => Promise<void>;
   migrate: () => Promise<void>;
-  listen: () => Promise<unknown>;
+  listen: () => Promise<void>;
 };
 
 export async function bootstrapServer(
   steps: BootstrapSteps = {
     init: () => Sonamu.init(),
     migrate: runRequiredMigrations,
-    listen: () => Sonamu.createServer(),
+    listen: async () => {
+      await Sonamu.createServer();
+    },
   },
 ): Promise<void> {
   await steps.init();

package/bundle/src/server-error-handler.ts

@@ -13,6 +13,7 @@ const RETRY_AFTER_SECONDS = "30";
 // upstream 예외를 통과시킨다. 여기서는 instanceof 로 실제 계약을 확인한다.
 export function handleServerError(error: Error, reply: FastifyReply): void {
   getLogger(["qgrid"]).error(`${error}`);
+
   const statusCode =
     error instanceof SoException &&
     Number.isInteger(error.statusCode) &&