@cartanova/qgrid-cli 1.9.0 → 2.0.1

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

@@ -9,6 +9,7 @@ import {
 } from "sonamu";
 
 import { SD } from "../../i18n/sd.generated";
+import { calculateCostUsd } from "../../utils/providers/common/model-cost";
 import { type RequestLogSubsetKey, type RequestLogSubsetMapping } from "../sonamu.generated";
 import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso";
 import { type RequestLogListParams, type RequestLogSaveParams } from "./request-log.types";
@@ -149,6 +150,181 @@ class RequestLogModelClass extends BaseModelClass<
     });
   }
 
+  // ── Run Lifecycle ──────────────────────────────────────────────
+
+  async createRun(params: {
+    user_prompt: string;
+    system_prompt?: string | null;
+    model_name?: string | null;
+    effort?: string | null;
+    project_name?: string | null;
+  }): Promise<number> {
+    const wdb = this.getPuri("w");
+    wdb.ubRegister("request_logs", {
+      user_prompt: params.user_prompt,
+      system_prompt: params.system_prompt ?? null,
+      model_name: params.model_name ?? null,
+      effort: params.effort ?? null,
+      project_name: params.project_name ?? null,
+      status: "running",
+      response: "",
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_read_tokens: 0,
+      cache_creation_tokens: 0,
+      duration_ms: 0,
+      tool_call_count: 0,
+    });
+    return wdb.transaction(async (trx) => {
+      const ids = await trx.ubUpsert("request_logs");
+      return ids[0]!;
+    });
+  }
+
+  async appendStep(requestLogId: number, step: Record<string, unknown>): Promise<number> {
+    const wdb = this.getPuri("w");
+    wdb.ubRegister("request_log_steps", { request_log_id: requestLogId, ...step });
+    return wdb.transaction(async (trx) => {
+      const ids = await trx.ubUpsert("request_log_steps");
+      if (step.type === "tool_call") {
+        await trx.from("request_logs").where("id", requestLogId).increment("tool_call_count", 1);
+      }
+      return ids[0]!;
+    });
+  }
+
+  async finishRun(
+    requestLogId: number,
+    params: {
+      status: string;
+      response?: string;
+      token_name?: string;
+      input_tokens?: number;
+      output_tokens?: number;
+      cache_read_tokens?: number;
+      cache_creation_tokens?: number;
+      duration_ms?: number;
+      history?: unknown;
+      error_message?: string;
+      tool_call_count?: number;
+    },
+  ): Promise<void> {
+    if (params.status === "succeeded" && !params.token_name) {
+      throw new Error("tokenName is required for succeeded runs");
+    }
+    const update: Record<string, unknown> = { id: requestLogId, status: params.status };
+    const fields = [
+      "response",
+      "token_name",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "duration_ms",
+      "error_message",
+      "tool_call_count",
+    ] as const;
+    for (const key of fields) {
+      if (params[key] !== undefined) update[key] = params[key];
+    }
+    if (params.history !== undefined) update.history = params.history;
+
+    if (params.input_tokens !== undefined && params.output_tokens !== undefined) {
+      const db = this.getDB("r");
+      const [row] = await db("request_logs")
+        .select("model_name")
+        .where("id", requestLogId)
+        .limit(1);
+      if (row?.model_name) {
+        const model = row.model_name.includes("/")
+          ? row.model_name.split("/").pop()!
+          : row.model_name;
+        update.cost_usd = Math.round(
+          calculateCostUsd(model, {
+            inputTokens: params.input_tokens,
+            outputTokens: params.output_tokens,
+            cachedInputTokens: params.cache_read_tokens ?? 0,
+          }) * 1_000_000,
+        );
+      }
+    }
+
+    const wdb = this.getPuri("w");
+    wdb.ubRegister("request_logs", update);
+    await wdb.transaction(async (trx) => {
+      await trx.ubUpsert("request_logs");
+    });
+  }
+
+  async aggregateStepUsage(requestLogId: number): Promise<{
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_creation_tokens: number;
+    duration_ms: number;
+  }> {
+    const db = this.getDB("r");
+    const [row] = await db("request_log_steps")
+      .where("request_log_id", requestLogId)
+      .where("type", "generate")
+      .sum({
+        input_tokens: "input_tokens",
+        output_tokens: "output_tokens",
+        cache_read_tokens: "cache_read_tokens",
+        cache_creation_tokens: "cache_creation_tokens",
+        duration_ms: "duration_ms",
+      });
+    return {
+      input_tokens: Number(row?.input_tokens ?? 0),
+      output_tokens: Number(row?.output_tokens ?? 0),
+      cache_read_tokens: Number(row?.cache_read_tokens ?? 0),
+      cache_creation_tokens: Number(row?.cache_creation_tokens ?? 0),
+      duration_ms: Number(row?.duration_ms ?? 0),
+    };
+  }
+
+  async findStaleRunningIds(thresholdMs: number, limit: number = 10): Promise<number[]> {
+    const db = this.getDB("r");
+    const threshold = new Date(Date.now() - thresholdMs);
+    const rows = await db("request_logs")
+      .select("id")
+      .where("status", "running")
+      .where("created_at", "<", threshold)
+      .limit(limit);
+    return rows.map((r: { id: number }) => r.id);
+  }
+
+  async getNextStepIndex(requestLogId: number): Promise<number> {
+    const db = this.getDB("r");
+    const [row] = await db("request_log_steps")
+      .where("request_log_id", requestLogId)
+      .max("step_index as maxStep");
+    return ((row as { maxStep: number | null })?.maxStep ?? -1) + 1;
+  }
+
+  async completeToolCall(
+    requestLogId: number,
+    toolCallId: string,
+    params: { tool_result?: string; tool_duration_ms?: number; error?: string },
+  ): Promise<number> {
+    const wdb = this.getPuri("w");
+    return wdb.transaction(async (trx) => {
+      const updated = await trx
+        .from("request_log_steps")
+        .where("request_log_id", requestLogId)
+        .where("tool_call_id", toolCallId)
+        .where("type", "tool_call")
+        .update({
+          ...(params.tool_result !== undefined ? { tool_result: params.tool_result } : {}),
+          ...(params.tool_duration_ms !== undefined
+            ? { tool_duration_ms: params.tool_duration_ms }
+            : {}),
+          ...(params.error !== undefined ? { error: params.error } : {}),
+        });
+      return updated;
+    });
+  }
+
   // Sonamu findMany는 subset 전체 컬럼(text 포함)을 페치해서 aggregate엔 너무 무거움 → raw sum 사용.
   async totalCost(params: { token_name?: string } = {}): Promise<number> {
     const qb = this.getDB("r")("request_logs");
@@ -178,6 +354,10 @@ class RequestLogModelClass extends BaseModelClass<
 
     // transaction
     await wdb.transaction(async (trx) => {
+      await trx
+        .table("request_log_steps")
+        .whereIn("request_log_steps.request_log_id", ids)
+        .delete();
       return trx.table("request_logs").whereIn("request_logs.id", ids).delete();
     });
 

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

@@ -2,6 +2,19 @@ import { z } from "zod";
 
 import { RequestLogBaseListParams, RequestLogBaseSchema } from "../sonamu.generated";
 
+export const HistoryItems = z.array(
+  z.object({
+    type: z.string(),
+    role: z.string().optional(),
+    content: z.unknown().optional(),
+    name: z.string().optional(),
+    arguments: z.string().optional(),
+    call_id: z.string().optional(),
+    output: z.string().optional(),
+  }),
+);
+export type HistoryItems = z.infer<typeof HistoryItems>;
+
 // RequestLog - ListParams
 // project_name NULL 분기: IS NULL만 조회(unassigned 필터) 또는 IS NOT NULL만(distinct 조회).
 export const RequestLogListParams = RequestLogBaseListParams.extend({
@@ -15,5 +28,7 @@ export const RequestLogSaveParams = RequestLogBaseSchema.partial({
   id: true,
   created_at: true,
   token_name: true,
+  status: true,
+  error_message: true,
 });
 export type RequestLogSaveParams = z.infer<typeof RequestLogSaveParams>;

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

@@ -0,0 +1,137 @@
+{
+  "id": "RequestLogStep",
+  "table": "request_log_steps",
+  "title": "RequestLogStep",
+  "props": [
+    { "name": "id", "type": "integer", "desc": "ID" },
+    { "name": "created_at", "desc": "등록일시", "dbDefault": "CURRENT_TIMESTAMP", "type": "date" },
+    {
+      "type": "relation",
+      "name": "request_log",
+      "with": "RequestLog",
+      "toFilter": true,
+      "desc": "부모 request log ID",
+      "relationType": "BelongsToOne",
+      "onUpdate": "CASCADE",
+      "onDelete": "CASCADE"
+    },
+    { "name": "step_index", "type": "integer", "desc": "ai-sdk step number (0-based)" },
+    { "name": "type", "type": "enum", "id": "RequestLogStepType", "desc": "step 타입" },
+    { "name": "input_tokens", "type": "integer", "nullable": true, "desc": "입력 토큰 (generate)" },
+    {
+      "name": "output_tokens",
+      "type": "integer",
+      "nullable": true,
+      "desc": "출력 토큰 (generate)"
+    },
+    { "name": "cache_read_tokens", "type": "integer", "nullable": true, "desc": "캐시 읽기 토큰" },
+    {
+      "name": "cache_creation_tokens",
+      "type": "integer",
+      "nullable": true,
+      "desc": "캐시 생성 토큰"
+    },
+    { "name": "duration_ms", "type": "integer", "nullable": true, "desc": "소요시간(ms)" },
+    {
+      "name": "finish_reason",
+      "type": "string",
+      "length": 20,
+      "nullable": true,
+      "desc": "완료 사유"
+    },
+    {
+      "name": "reasoning_text",
+      "type": "string",
+      "nullable": true,
+      "desc": "reasoning 텍스트"
+    },
+    {
+      "name": "reasoning_tokens",
+      "type": "integer",
+      "nullable": true,
+      "desc": "reasoning 토큰 수"
+    },
+    {
+      "name": "tool_call_index",
+      "type": "integer",
+      "nullable": true,
+      "desc": "같은 step 내 tool call 순서"
+    },
+    {
+      "name": "tool_call_id",
+      "type": "string",
+      "length": 100,
+      "nullable": true,
+      "desc": "tool call ID"
+    },
+    { "name": "tool_name", "type": "string", "length": 100, "nullable": true, "desc": "tool 이름" },
+    { "name": "tool_args", "type": "string", "nullable": true, "desc": "tool 인자 (JSON string)" },
+    {
+      "name": "tool_result",
+      "type": "string",
+      "nullable": true,
+      "desc": "tool 결과 (JSON string)"
+    },
+    {
+      "name": "tool_duration_ms",
+      "type": "integer",
+      "nullable": true,
+      "desc": "tool 실행 소요시간(ms)"
+    },
+    { "name": "error", "type": "string", "nullable": true, "desc": "step 에러 메시지" }
+  ],
+  "indexes": [
+    {
+      "type": "index",
+      "name": "request_log_steps_request_log_id_index",
+      "columns": [{ "name": "request_log_id" }],
+      "using": "btree"
+    }
+  ],
+  "subsets": {
+    "A": [
+      "id",
+      "created_at",
+      "step_index",
+      "type",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "duration_ms",
+      "finish_reason",
+      "reasoning_text",
+      "reasoning_tokens",
+      "tool_call_index",
+      "tool_call_id",
+      "tool_name",
+      "tool_args",
+      "tool_result",
+      "tool_duration_ms",
+      "error"
+    ],
+    "T": [
+      "id",
+      "created_at",
+      "step_index",
+      "type",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "duration_ms",
+      "finish_reason",
+      "reasoning_tokens",
+      "tool_call_index",
+      "tool_call_id",
+      "tool_name",
+      "tool_duration_ms",
+      "error"
+    ]
+  },
+  "enums": {
+    "RequestLogStepType": { "generate": "LLM 생성", "tool_call": "Tool 호출" },
+    "RequestLogStepOrderBy": { "id-asc": "ID순" },
+    "RequestLogStepSearchField": { "id": "ID" }
+  }
+}

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

@@ -0,0 +1,161 @@
+import {
+  BaseModelClass,
+  type ListResult,
+  asArray,
+  NotFoundException,
+  BadRequestException,
+  api,
+  exhaustive,
+} from "sonamu";
+
+import { SD } from "../../i18n/sd.generated";
+import {
+  type RequestLogStepSubsetKey,
+  type RequestLogStepSubsetMapping,
+} from "../sonamu.generated";
+import { requestLogStepSubsetQueries, requestLogStepLoaderQueries } from "../sonamu.generated.sso";
+import {
+  type RequestLogStepListParams,
+  type RequestLogStepSaveParams,
+} from "./request-log-step.types";
+
+/*
+  RequestLogStep Model
+*/
+class RequestLogStepModelClass extends BaseModelClass<
+  RequestLogStepSubsetKey,
+  RequestLogStepSubsetMapping,
+  typeof requestLogStepSubsetQueries,
+  typeof requestLogStepLoaderQueries
+> {
+  constructor() {
+    super("RequestLogStep", requestLogStepSubsetQueries, requestLogStepLoaderQueries);
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogStep" })
+  async findById<T extends RequestLogStepSubsetKey>(
+    subset: T,
+    id: number,
+  ): Promise<RequestLogStepSubsetMapping[T]> {
+    const { rows } = await this.findMany(subset, {
+      id,
+      num: 1,
+      page: 1,
+    });
+    if (!rows[0]) {
+      throw new NotFoundException(SD("error.entityNotFound")("RequestLogStep", id));
+    }
+
+    return rows[0];
+  }
+
+  async findOne<T extends RequestLogStepSubsetKey>(
+    subset: T,
+    listParams: RequestLogStepListParams,
+  ): Promise<RequestLogStepSubsetMapping[T] | null> {
+    const { rows } = await this.findMany(subset, {
+      ...listParams,
+      num: 1,
+      page: 1,
+    });
+
+    return rows[0] ?? null;
+  }
+
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"], resourceName: "RequestLogSteps" })
+  async findMany<T extends RequestLogStepSubsetKey, LP extends RequestLogStepListParams>(
+    subset: T,
+    rawParams?: LP,
+  ): Promise<ListResult<LP, RequestLogStepSubsetMapping[T]>> {
+    // params with defaults
+    const params = {
+      num: 24,
+      page: 1,
+      search: "id" as const,
+      orderBy: "id-asc" as const,
+      ...rawParams,
+    } satisfies RequestLogStepListParams;
+
+    // build queries
+    const { qb, onSubset: _ } = this.getSubsetQueries(subset);
+
+    if (params.id) {
+      qb.whereIn("request_log_steps.id", asArray(params.id));
+    }
+
+    if (params.request_log_id) {
+      qb.where("request_log_steps.request_log_id", params.request_log_id);
+    }
+
+    // search-keyword
+    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));
+      }
+    }
+
+    // orderBy
+    if (params.orderBy) {
+      if (params.orderBy === "id-asc") {
+        qb.orderBy("request_log_steps.step_index", "asc")
+          .orderBy("request_log_steps.tool_call_index", "asc")
+          .orderBy("request_log_steps.id", "asc");
+      } else {
+        exhaustive(params.orderBy);
+      }
+    }
+
+    const enhancers = this.createEnhancers({
+      A: (row) => ({
+        ...row,
+        // 서브셋별로 virtual 필드 계산로직 추가
+      }),
+      T: (row) => ({
+        ...row,
+      }),
+    });
+
+    return this.executeSubsetQuery({
+      subset,
+      qb,
+      params,
+      enhancers,
+      debug: false,
+    });
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
+  async save(spa: RequestLogStepSaveParams[]): Promise<number[]> {
+    const wdb = this.getPuri("w");
+
+    // register
+    spa.forEach((sp) => {
+      wdb.ubRegister("request_log_steps", sp);
+    });
+
+    // transaction
+    return wdb.transaction(async (trx) => {
+      const ids = await trx.ubUpsert("request_log_steps");
+
+      return ids;
+    });
+  }
+
+  @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"], guards: ["admin"] })
+  async del(ids: number[]): Promise<number> {
+    const wdb = this.getPuri("w");
+
+    // transaction
+    await wdb.transaction(async (trx) => {
+      return trx.table("request_log_steps").whereIn("request_log_steps.id", ids).delete();
+    });
+
+    return ids.length;
+  }
+}
+
+export const RequestLogStepModel = new RequestLogStepModelClass();

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

@@ -0,0 +1,30 @@
+import { type z } from "zod";
+
+import { RequestLogStepBaseSchema, RequestLogStepBaseListParams } from "../sonamu.generated";
+
+// RequestLogStep - ListParams
+export const RequestLogStepListParams = RequestLogStepBaseListParams;
+export type RequestLogStepListParams = z.infer<typeof RequestLogStepListParams>;
+
+// RequestLogStep - SaveParams
+export const RequestLogStepSaveParams = RequestLogStepBaseSchema.partial({
+  id: true,
+  created_at: true,
+  request_log_id: true,
+  input_tokens: true,
+  output_tokens: true,
+  cache_read_tokens: true,
+  cache_creation_tokens: true,
+  duration_ms: true,
+  finish_reason: true,
+  reasoning_text: true,
+  reasoning_tokens: true,
+  tool_call_index: true,
+  tool_call_id: true,
+  tool_name: true,
+  tool_args: true,
+  tool_result: true,
+  tool_duration_ms: true,
+  error: true,
+});
+export type RequestLogStepSaveParams = z.infer<typeof RequestLogStepSaveParams>;