@cartanova/qgrid-cli 2.3.5 → 2.3.6

package/bundle/src/application/qgrid/token-trigger-setup.ts

@@ -39,7 +39,8 @@ const SETUP_SQL = `
     OLD.active IS DISTINCT FROM NEW.active OR
     OLD.credentials IS DISTINCT FROM NEW.credentials OR
     OLD.provider IS DISTINCT FROM NEW.provider OR
-    OLD.name IS DISTINCT FROM NEW.name
+    OLD.name IS DISTINCT FROM NEW.name OR
+    OLD.quota_threshold IS DISTINCT FROM NEW.quota_threshold
   )
   EXECUTE FUNCTION public.tokens_notify();
 `;

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

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 
-import { buildToolCallSchema } from "./tool-emulation";
 import { type QgridTool } from "./qgrid.types";
+import { buildToolCallSchema } from "./tool-emulation";
 
 describe("buildToolCallSchema", () => {
   it("documents that emulated tools must be requested through StructuredOutput", () => {
@@ -36,9 +36,13 @@ describe("buildToolCallSchema", () => {
     };
 
     expect(schema.description).toContain("StructuredOutput");
-    expect(schema.description).toContain("Do not invoke listed client tools as native Claude Code tools");
+    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?.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/request-log/request-log.entity.json

@@ -42,6 +42,7 @@
       "dbDefault": "0"
     },
     { "name": "duration_ms", "type": "integer", "desc": "응답 소요시간(ms)", "dbDefault": "0" },
+    { "name": "ttft_ms", "type": "integer", "desc": "first gen TTFT(ms)", "dbDefault": "0" },
     { "name": "cost_usd", "type": "integer", "nullable": true, "desc": "API 비용" },
     { "name": "effort", "type": "string", "length": 10, "nullable": true, "desc": "effort level" },
     {
@@ -91,6 +92,7 @@
         "cache_read_tokens",
         "cache_creation_tokens",
         "duration_ms",
+        "ttft_ms",
         "cost_usd",
         "effort",
         "history",
@@ -111,6 +113,7 @@
         "cache_read_tokens",
         "cache_creation_tokens",
         "duration_ms",
+        "ttft_ms",
         "cost_usd",
         "effort",
         "status",

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

@@ -0,0 +1,92 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { RequestLogModel } from "./request-log.model";
+
+function mockQueryBuilder(rows: unknown[]) {
+  const chain = {
+    select: vi.fn(() => chain),
+    where: vi.fn(() => chain),
+    whereNotNull: vi.fn(() => chain),
+    orderBy: vi.fn(() => chain),
+    limit: vi.fn(async () => rows),
+  };
+  return chain;
+}
+
+describe("RequestLogModel TTFT", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("reads the first non-null generate-step ttft", async () => {
+    const chain = mockQueryBuilder([{ ttft_ms: 42 }]);
+    const db = vi.fn(() => chain);
+    vi.spyOn(RequestLogModel as unknown as { getDB: () => typeof db }, "getDB").mockReturnValue(
+      db,
+    );
+
+    await expect(RequestLogModel.firstGenerateStepTtft(7)).resolves.toBe(42);
+
+    expect(db).toHaveBeenCalledWith("request_log_steps");
+    expect(chain.where).toHaveBeenCalledWith("request_log_id", 7);
+    expect(chain.where).toHaveBeenCalledWith("type", "generate");
+    expect(chain.whereNotNull).toHaveBeenCalledWith("ttft_ms");
+    expect(chain.orderBy).toHaveBeenNthCalledWith(1, "step_index", "asc");
+    expect(chain.orderBy).toHaveBeenNthCalledWith(2, "id", "asc");
+  });
+
+  it("returns null when no generate step has ttft", async () => {
+    const db = vi.fn(() => mockQueryBuilder([]));
+    vi.spyOn(RequestLogModel as unknown as { getDB: () => typeof db }, "getDB").mockReturnValue(
+      db,
+    );
+
+    await expect(RequestLogModel.firstGenerateStepTtft(7)).resolves.toBeNull();
+  });
+
+  it("stores server-derived ttft_ms during finishRun", async () => {
+    const ubRegister = vi.fn();
+    const transaction = vi.fn(async (cb: (trx: { ubUpsert: () => Promise<number[]> }) => void) =>
+      cb({ ubUpsert: vi.fn(async () => [7]) }),
+    );
+    vi.spyOn(RequestLogModel, "firstGenerateStepTtft").mockResolvedValue(55);
+    vi.spyOn(
+      RequestLogModel as unknown as { getPuri: () => { ubRegister: typeof ubRegister; transaction: typeof transaction } },
+      "getPuri",
+    ).mockReturnValue({ ubRegister, transaction });
+
+    await RequestLogModel.finishRun(7, { status: "error", error_message: "boom" });
+
+    expect(ubRegister).toHaveBeenCalledWith(
+      "request_logs",
+      expect.objectContaining({
+        id: 7,
+        status: "error",
+        error_message: "boom",
+        ttft_ms: 55,
+      }),
+    );
+  });
+
+  it("stores zero during finishRun when no generate step has ttft", async () => {
+    const ubRegister = vi.fn();
+    const transaction = vi.fn(async (cb: (trx: { ubUpsert: () => Promise<number[]> }) => void) =>
+      cb({ ubUpsert: vi.fn(async () => [7]) }),
+    );
+    vi.spyOn(RequestLogModel, "firstGenerateStepTtft").mockResolvedValue(null);
+    vi.spyOn(
+      RequestLogModel as unknown as { getPuri: () => { ubRegister: typeof ubRegister; transaction: typeof transaction } },
+      "getPuri",
+    ).mockReturnValue({ ubRegister, transaction });
+
+    await RequestLogModel.finishRun(7, { status: "error", error_message: "boom" });
+
+    expect(ubRegister).toHaveBeenCalledWith(
+      "request_logs",
+      expect.objectContaining({
+        id: 7,
+        ttft_ms: 0,
+      }),
+    );
+  });
+});

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

@@ -46,15 +46,15 @@ function normalizedUsageForCost(row: RequestLogUsageRow): {
   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 cacheRead = row.cache_read_tokens;
+  const cacheCreation = row.cache_creation_tokens;
+  const storedInput = row.input_tokens;
   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),
+    outputTokens: row.output_tokens,
     cachedInputTokens: cacheRead,
     cacheCreationInputTokens: cacheCreation,
   };
@@ -62,7 +62,7 @@ function normalizedUsageForCost(row: RequestLogUsageRow): {
 
 function normalizeLegacyAnthropicRow<T extends RequestLogUsageRow>(row: T): T {
   const usage = normalizedUsageForCost(row);
-  if (usage.inputTokens === Number(row.input_tokens ?? 0)) return row;
+  if (usage.inputTokens === row.input_tokens) return row;
   const normalized = { ...row, input_tokens: usage.inputTokens };
   if (usage.model) {
     normalized.cost_usd = Math.round(calculateCostUsd(usage.model, usage) * MICRO_USD);
@@ -280,6 +280,7 @@ class RequestLogModelClass extends BaseModelClass<
       if (params[key] !== undefined) update[key] = params[key];
     }
     if (params.history !== undefined) update.history = params.history;
+    update.ttft_ms = (await this.firstGenerateStepTtft(requestLogId)) ?? 0;
 
     if (params.input_tokens !== undefined && params.output_tokens !== undefined) {
       const db = this.getDB("r");
@@ -315,6 +316,19 @@ class RequestLogModelClass extends BaseModelClass<
     });
   }
 
+  async firstGenerateStepTtft(requestLogId: number): Promise<number | null> {
+    const db = this.getDB("r");
+    const [row] = await db("request_log_steps")
+      .select("ttft_ms")
+      .where("request_log_id", requestLogId)
+      .where("type", "generate")
+      .whereNotNull("ttft_ms")
+      .orderBy("step_index", "asc")
+      .orderBy("id", "asc")
+      .limit(1);
+    return row?.ttft_ms === null || row?.ttft_ms === undefined ? null : Number(row.ttft_ms);
+  }
+
   async aggregateStepUsage(requestLogId: number): Promise<{
     input_tokens: number;
     output_tokens: number;
@@ -410,7 +424,7 @@ class RequestLogModelClass extends BaseModelClass<
 
     return rows.reduce((sum, row) => {
       const usage = normalizedUsageForCost(row);
-      if (!usage.model) return sum + Math.max(Number(row.cost_usd ?? 0), 0) / MICRO_USD;
+      if (!usage.model) return sum + Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
       return (
         sum +
         calculateCostUsd(usage.model, {

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

@@ -32,6 +32,7 @@
       "desc": "캐시 생성 토큰"
     },
     { "name": "duration_ms", "type": "integer", "nullable": true, "desc": "소요시간(ms)" },
+    { "name": "ttft_ms", "type": "integer", "nullable": true, "desc": "Gen TTFT(ms)" },
     {
       "name": "finish_reason",
       "type": "string",
@@ -99,6 +100,7 @@
       "cache_read_tokens",
       "cache_creation_tokens",
       "duration_ms",
+      "ttft_ms",
       "finish_reason",
       "reasoning_text",
       "reasoning_tokens",
@@ -120,6 +122,7 @@
       "cache_read_tokens",
       "cache_creation_tokens",
       "duration_ms",
+      "ttft_ms",
       "finish_reason",
       "reasoning_tokens",
       "tool_call_index",

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

@@ -39,7 +39,8 @@ Content-Type: application/json
       },
       "name": "NAME",
       "active": false,
-      "ord": 0
+      "ord": 0,
+      "quota_threshold": null
     }
   ]
 }
@@ -106,6 +107,7 @@ Content-Type: application/json
       "cache_read_tokens": null,
       "cache_creation_tokens": null,
       "duration_ms": null,
+      "ttft_ms": null,
       "finish_reason": null,
       "reasoning_text": null,
       "reasoning_tokens": null,
@@ -178,6 +180,7 @@ Content-Type: application/json
       "cache_read_tokens": 0,
       "cache_creation_tokens": 0,
       "duration_ms": 0,
+      "ttft_ms": 0,
       "cost_usd": null,
       "effort": null,
       "history": null,
@@ -330,6 +333,7 @@ Content-Type: application/json
     "cacheReadTokens": 0,
     "cacheCreationTokens": 0,
     "durationMs": 0,
+    "ttftMs": null,
     "finishReason": "FINISHREASON",
     "reasoningText": "REASONINGTEXT",
     "reasoningTokens": 0,
@@ -405,7 +409,8 @@ Content-Type: application/json
 
 {
   "id": 0,
-  "name": "NAME"
+  "name": "NAME",
+  "quotaThreshold": null
 }
 
 ###

package/bundle/src/application/sonamu.generated.sso.ts

@@ -31,6 +31,7 @@ export const requestLogSubsetQueries = {
       cache_read_tokens: "request_logs.cache_read_tokens",
       cache_creation_tokens: "request_logs.cache_creation_tokens",
       duration_ms: "request_logs.duration_ms",
+      ttft_ms: "request_logs.ttft_ms",
       cost_usd: "request_logs.cost_usd",
       effort: "request_logs.effort",
       history: "request_logs.history",
@@ -51,6 +52,7 @@ export const requestLogSubsetQueries = {
       cache_read_tokens: "request_logs.cache_read_tokens",
       cache_creation_tokens: "request_logs.cache_creation_tokens",
       duration_ms: "request_logs.duration_ms",
+      ttft_ms: "request_logs.ttft_ms",
       cost_usd: "request_logs.cost_usd",
       effort: "request_logs.effort",
       status: "request_logs.status",
@@ -78,6 +80,7 @@ export const requestLogStepSubsetQueries = {
       cache_read_tokens: "request_log_steps.cache_read_tokens",
       cache_creation_tokens: "request_log_steps.cache_creation_tokens",
       duration_ms: "request_log_steps.duration_ms",
+      ttft_ms: "request_log_steps.ttft_ms",
       finish_reason: "request_log_steps.finish_reason",
       reasoning_text: "request_log_steps.reasoning_text",
       reasoning_tokens: "request_log_steps.reasoning_tokens",
@@ -101,6 +104,7 @@ export const requestLogStepSubsetQueries = {
       cache_read_tokens: "request_log_steps.cache_read_tokens",
       cache_creation_tokens: "request_log_steps.cache_creation_tokens",
       duration_ms: "request_log_steps.duration_ms",
+      ttft_ms: "request_log_steps.ttft_ms",
       finish_reason: "request_log_steps.finish_reason",
       reasoning_tokens: "request_log_steps.reasoning_tokens",
       tool_call_index: "request_log_steps.tool_call_index",
@@ -129,6 +133,7 @@ export const tokenSubsetQueries = {
       name: "tokens.name",
       active: "tokens.active",
       ord: "tokens.ord",
+      quota_threshold: "tokens.quota_threshold",
     });
   },
 };

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

@@ -100,6 +100,7 @@ export const RequestLogBaseSchema = z.object({
   cache_read_tokens: z.int(),
   cache_creation_tokens: z.int(),
   duration_ms: z.int(),
+  ttft_ms: z.int(),
   cost_usd: z.int().nullable(),
   effort: z.string().max(10).nullable(),
   history: HistoryItems.nullable(),
@@ -121,6 +122,7 @@ export type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {
     "cache_read_tokens",
     "cache_creation_tokens",
     "duration_ms",
+    "ttft_ms",
     "cost_usd",
     "effort",
     "history",
@@ -143,6 +145,7 @@ export const RequestLogStepBaseSchema = z.object({
   cache_read_tokens: z.int().nullable(),
   cache_creation_tokens: z.int().nullable(),
   duration_ms: z.int().nullable(),
+  ttft_ms: z.int().nullable(),
   finish_reason: z.string().max(20).nullable(),
   reasoning_text: z.string().nullable(),
   reasoning_tokens: z.int().nullable(),
@@ -162,6 +165,7 @@ export type RequestLogStepBaseSchema = z.infer<typeof RequestLogStepBaseSchema>
     "cache_read_tokens",
     "cache_creation_tokens",
     "duration_ms",
+    "ttft_ms",
     "finish_reason",
     "reasoning_text",
     "reasoning_tokens",
@@ -185,9 +189,10 @@ export const TokenBaseSchema = z.object({
   name: z.string(),
   active: z.boolean(),
   ord: z.int(),
+  quota_threshold: z.int().nullable(),
 });
 export type TokenBaseSchema = z.infer<typeof TokenBaseSchema> & {
-  readonly __hasDefault__: readonly ["created_at", "active", "ord", "id"];
+  readonly __hasDefault__: readonly ["created_at", "active", "ord", "quota_threshold", "id"];
 };
 
 // BaseListParams: RequestLog
@@ -254,6 +259,7 @@ export const RequestLogSubsetA = z.object({
   cache_read_tokens: z.int(),
   cache_creation_tokens: z.int(),
   duration_ms: z.int(),
+  ttft_ms: z.int(),
   cost_usd: z.int().nullable(),
   effort: z.string().max(10).nullable(),
   history: HistoryItems.nullable(),
@@ -273,6 +279,7 @@ export const RequestLogSubsetP = z.object({
   cache_read_tokens: z.int(),
   cache_creation_tokens: z.int(),
   duration_ms: z.int(),
+  ttft_ms: z.int(),
   cost_usd: z.int().nullable(),
   effort: z.string().max(10).nullable(),
   status: RequestLogStatus,
@@ -297,6 +304,7 @@ export const RequestLogStepSubsetA = z.object({
   cache_read_tokens: z.int().nullable(),
   cache_creation_tokens: z.int().nullable(),
   duration_ms: z.int().nullable(),
+  ttft_ms: z.int().nullable(),
   finish_reason: z.string().max(20).nullable(),
   reasoning_text: z.string().nullable(),
   reasoning_tokens: z.int().nullable(),
@@ -319,6 +327,7 @@ export const RequestLogStepSubsetT = z.object({
   cache_read_tokens: z.int().nullable(),
   cache_creation_tokens: z.int().nullable(),
   duration_ms: z.int().nullable(),
+  ttft_ms: z.int().nullable(),
   finish_reason: z.string().max(20).nullable(),
   reasoning_tokens: z.int().nullable(),
   tool_call_index: z.int().nullable(),
@@ -344,6 +353,7 @@ export const TokenSubsetA = z.object({
   name: z.string(),
   active: z.boolean(),
   ord: z.int(),
+  quota_threshold: z.int().nullable(),
 });
 export type TokenSubsetA = z.infer<typeof TokenSubsetA>;
 export type TokenSubsetMapping = {

package/bundle/src/application/token/token.entity.json

@@ -14,11 +14,17 @@
     },
     { "name": "name", "desc": "토큰 이름", "type": "string" },
     { "name": "active", "type": "boolean", "desc": "활성 여부", "dbDefault": "true" },
-    { "name": "ord", "type": "integer", "desc": "정렬 순서", "dbDefault": "0" }
+    { "name": "ord", "type": "integer", "desc": "정렬 순서", "dbDefault": "0" },
+    {
+      "name": "quota_threshold",
+      "type": "integer",
+      "nullable": true,
+      "desc": "quota 사용률 임계치(%). null이면 미설정"
+    }
   ],
   "indexes": [],
   "subsets": {
-    "A": ["id", "created_at", "provider", "credentials", "name", "active", "ord"]
+    "A": ["id", "created_at", "provider", "credentials", "name", "active", "ord", "quota_threshold"]
   },
   "enums": {
     "TokenOrderBy": { "id-desc": "ID최신순", "ord-asc": "순서순" },

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

@@ -0,0 +1,69 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { TokenModel } from "./token.model";
+
+const baseToken = {
+  provider: "anthropic",
+  credentials: {
+    accessToken: "sk-ant-oat01-test",
+    refreshToken: "sk-ant-ort01-test",
+    expiresAt: Date.now() + 3_600_000,
+    accountUuid: "acc-1",
+  },
+  name: "tok-A",
+};
+
+type MockPuri = {
+  ubRegister: ReturnType<typeof vi.fn>;
+  transaction: ReturnType<typeof vi.fn>;
+};
+
+function mockWritePuri() {
+  const ubRegister = vi.fn();
+  const ubUpsert = vi.fn(async () => [1]);
+  const transaction = vi.fn(
+    async (cb: (trx: { ubUpsert: typeof ubUpsert }) => Promise<number[]>) =>
+      cb({ ubUpsert }),
+  );
+  vi.spyOn(TokenModel as unknown as { getPuri: (mode: "w") => MockPuri }, "getPuri")
+    .mockReturnValue({ ubRegister, transaction });
+
+  return { ubRegister, ubUpsert, transaction };
+}
+
+describe("TokenModel.save", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("applies 80% quota threshold to newly created tokens by default", async () => {
+    const { ubRegister } = mockWritePuri();
+
+    await TokenModel.save([baseToken]);
+
+    expect(ubRegister).toHaveBeenCalledWith(
+      "tokens",
+      expect.objectContaining({ quota_threshold: 80 }),
+    );
+  });
+
+  it("preserves explicit null quota threshold on newly created tokens", async () => {
+    const { ubRegister } = mockWritePuri();
+
+    await TokenModel.save([{ ...baseToken, quota_threshold: null }]);
+
+    expect(ubRegister).toHaveBeenCalledWith(
+      "tokens",
+      expect.objectContaining({ quota_threshold: null }),
+    );
+  });
+
+  it("does not inject a quota threshold into existing token updates", async () => {
+    const { ubRegister } = mockWritePuri();
+
+    await TokenModel.save([{ ...baseToken, id: 1 }]);
+
+    const saved = ubRegister.mock.calls[0]?.[1];
+    expect(saved).not.toHaveProperty("quota_threshold");
+  });
+});

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

@@ -13,6 +13,13 @@ import { type TokenSubsetKey, type TokenSubsetMapping } from "../sonamu.generate
 import { tokenLoaderQueries, tokenSubsetQueries } from "../sonamu.generated.sso";
 import { type TokenListParams, type TokenSaveParams } from "./token.types";
 
+const DEFAULT_QUOTA_THRESHOLD = 80;
+
+function applyCreateDefaults(sp: TokenSaveParams): TokenSaveParams {
+  if (sp.id !== undefined || sp.quota_threshold !== undefined) return sp;
+  return { ...sp, quota_threshold: DEFAULT_QUOTA_THRESHOLD };
+}
+
 class TokenModelClass extends BaseModelClass<
   TokenSubsetKey,
   TokenSubsetMapping,
@@ -143,7 +150,7 @@ class TokenModelClass extends BaseModelClass<
   async save(spa: TokenSaveParams[]): Promise<number[]> {
     const wdb = this.getPuri("w");
     spa.forEach((sp) => {
-      wdb.ubRegister("tokens", sp);
+      wdb.ubRegister("tokens", applyCreateDefaults(sp));
     });
     return wdb.transaction(async (trx) => {
       return trx.ubUpsert("tokens");

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

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+
+import { TokenSaveParams } from "./token.types";
+
+const baseToken = {
+  provider: "anthropic",
+  credentials: {
+    accessToken: "sk-ant-oat01-test",
+    refreshToken: "sk-ant-ort01-test",
+    expiresAt: Date.now() + 3_600_000,
+    accountUuid: "acc-1",
+  },
+  name: "tok-A",
+};
+
+describe("TokenSaveParams", () => {
+  it("keeps quota_threshold optional for existing token saves", () => {
+    const parsed = TokenSaveParams.parse(baseToken);
+
+    expect(parsed).not.toHaveProperty("quota_threshold");
+  });
+
+  it("accepts valid nullable quota_threshold values", () => {
+    expect(TokenSaveParams.parse({ ...baseToken, quota_threshold: 80 }).quota_threshold).toBe(80);
+    expect(
+      TokenSaveParams.parse({ ...baseToken, quota_threshold: null }).quota_threshold,
+    ).toBeNull();
+  });
+
+  it("rejects quota_threshold values outside 1..100", () => {
+    expect(() => TokenSaveParams.parse({ ...baseToken, quota_threshold: 0 })).toThrow();
+    expect(() => TokenSaveParams.parse({ ...baseToken, quota_threshold: 101 })).toThrow();
+  });
+});

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

@@ -30,11 +30,16 @@ export type TokenCredentials = z.infer<typeof TokenCredentials>;
 export const TokenListParams = TokenBaseListParams;
 export type TokenListParams = z.infer<typeof TokenListParams>;
 
+const TokenQuotaThreshold = z.int().min(1).max(100).nullable();
+
 // Token - SaveParams
 export const TokenSaveParams = TokenBaseSchema.partial({
   id: true,
   created_at: true,
   active: true,
   ord: true,
+  quota_threshold: true,
+}).extend({
+  quota_threshold: TokenQuotaThreshold.optional(),
 });
 export type TokenSaveParams = z.infer<typeof TokenSaveParams>;

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

@@ -223,6 +223,7 @@ const entityLabels = {
   "entity.RequestLog.cache_read_tokens": "캐시 읽기 토큰",
   "entity.RequestLog.cache_creation_tokens": "캐시 생성 토큰",
   "entity.RequestLog.duration_ms": "응답 소요시간(ms)",
+  "entity.RequestLog.ttft_ms": "first gen TTFT(ms)",
   "entity.RequestLog.cost_usd": "API 비용",
   "entity.RequestLog.effort": "effort level",
   "entity.RequestLog.history": "inject_items 히스토리",
@@ -248,6 +249,7 @@ const entityLabels = {
   "entity.RequestLogStep.cache_read_tokens": "캐시 읽기 토큰",
   "entity.RequestLogStep.cache_creation_tokens": "캐시 생성 토큰",
   "entity.RequestLogStep.duration_ms": "소요시간(ms)",
+  "entity.RequestLogStep.ttft_ms": "Gen TTFT(ms)",
   "entity.RequestLogStep.finish_reason": "완료 사유",
   "entity.RequestLogStep.reasoning_text": "reasoning 텍스트",
   "entity.RequestLogStep.reasoning_tokens": "reasoning 토큰 수",
@@ -270,6 +272,7 @@ const entityLabels = {
   "entity.Token.name": "토큰 이름",
   "entity.Token.active": "활성 여부",
   "entity.Token.ord": "정렬 순서",
+  "entity.Token.quota_threshold": "quota 사용률 임계치(%). null이면 미설정",
   "enum.TokenOrderBy.id-desc": "ID최신순",
   "enum.TokenOrderBy.ord-asc": "순서순",
   "enum.TokenSearchField.id": "ID",

package/bundle/src/migrations/20260630223950_alter_tokens_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("tokens", (table) => {
+    // add
+    table.integer("quota_threshold").nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("tokens", (table) => {
+    // rollback - add
+    table.dropColumns("quota_threshold");
+  });
+}

package/bundle/src/migrations/20260701105327_alter_request_logs_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // add
+    table.integer("ttft_ms").notNullable().defaultTo(knex.raw("0"));
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("ttft_ms");
+  });
+}

package/bundle/src/migrations/20260701105328_alter_request_log_steps_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    // add
+    table.integer("ttft_ms").nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    // rollback - add
+    table.dropColumns("ttft_ms");
+  });
+}