@cartanova/qgrid-cli 2.7.0 → 2.7.2

package/bundle/src/application/request-log/json-schema-type-text.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+
+import { renderJsonSchemaTypeText } from "./json-schema-type-text";
+
+function schema(value: unknown): string {
+  return JSON.stringify(value);
+}
+
+describe("renderJsonSchemaTypeText", () => {
+  it("renders a flat object with optionality from required", () => {
+    const result = renderJsonSchemaTypeText(
+      schema({
+        type: "object",
+        properties: {
+          dish: { type: "string" },
+          spiceLevel: { type: "number" },
+          note: { type: "string" },
+        },
+        required: ["dish", "spiceLevel"],
+      }),
+    );
+    expect(result).toBe(
+      ["type Response = {", "  dish: string", "  spiceLevel: number", "  note?: string", "}"].join(
+        "\n",
+      ),
+    );
+  });
+
+  it("renders nested arrays of objects without tuple unions", () => {
+    const result = renderJsonSchemaTypeText(
+      schema({
+        type: "object",
+        properties: {
+          sides: {
+            type: "array",
+            // maxItems 는 요약에서 무시한다 — 튜플 유니온 장황함이 이 렌더러를 만든 이유다.
+            maxItems: 3,
+            items: {
+              type: "object",
+              properties: { name: { type: "string" }, required: { type: "boolean" } },
+              required: ["name", "required"],
+            },
+          },
+        },
+        required: ["sides"],
+      }),
+    );
+    expect(result).toContain("sides: {");
+    expect(result).toContain("}[]");
+    expect(result).not.toContain("|");
+  });
+
+  it("renders enum, const, union, and nullable types", () => {
+    expect(
+      renderJsonSchemaTypeText(
+        schema({
+          type: "object",
+          properties: {
+            kind: { enum: ["add", "modify"] },
+            version: { const: 2 },
+            id: { anyOf: [{ type: "string" }, { type: "number" }] },
+            tag: { type: ["string", "null"] },
+            ids: { type: "array", items: { anyOf: [{ type: "string" }, { type: "number" }] } },
+          },
+          required: ["kind", "version", "id", "tag", "ids"],
+        }),
+      ),
+    ).toBe(
+      [
+        "type Response = {",
+        '  kind: "add" | "modify"',
+        "  version: 2",
+        "  id: string | number",
+        "  tag: string | null",
+        "  ids: (string | number)[]",
+        "}",
+      ].join("\n"),
+    );
+  });
+
+  it("quotes non-identifier keys and folds unknown keywords to unknown", () => {
+    const result = renderJsonSchemaTypeText(
+      schema({
+        type: "object",
+        properties: { "not-ident": { format: "weird" }, empty: { type: "object" } },
+        required: ["not-ident"],
+      }),
+    );
+    expect(result).toContain('"not-ident": unknown');
+    expect(result).toContain("empty?: Record<string, unknown>");
+  });
+
+  it("returns null on unparseable schema text", () => {
+    expect(renderJsonSchemaTypeText("{broken")).toBeNull();
+  });
+});

package/bundle/src/application/request-log/json-schema-type-text.ts

@@ -0,0 +1,83 @@
+/**
+ * JSON Schema → 간결한 TypeScript `type` 선언 텍스트.
+ *
+ * 라이브러리(json-schema-to-typescript 계열)는 interface + maxItems 튜플 유니온 등
+ * 장황한 출력을 내서 detail 화면 요약용으로 부적합하다. qgrid 가 받는 스키마는
+ * zod 직렬화 산물(object root, draft-07 부분집합)이라 이 정도 지원이면 충분하고,
+ * 모르는 키워드는 unknown 으로 접어 절대 던지지 않는다.
+ */
+
+type SchemaNode = Record<string, unknown>;
+
+/** TS/zod 표시 코드 공용 식별자 판별 — zod-code-format 의 키 unquote 도 이걸 쓴다. */
+export const IDENT_SOURCE = "[A-Za-z_$][\\w$]*";
+const IDENT_RE = new RegExp(`^${IDENT_SOURCE}$`);
+
+function renderKey(key: string): string {
+  return IDENT_RE.test(key) ? key : JSON.stringify(key);
+}
+
+function renderPrimitive(type: unknown): string {
+  if (type === "string") return "string";
+  if (type === "number" || type === "integer") return "number";
+  if (type === "boolean") return "boolean";
+  if (type === "null") return "null";
+  return "unknown";
+}
+
+function renderNode(node: unknown, depth: number): string {
+  if (node === true) return "unknown";
+  if (!node || typeof node !== "object" || Array.isArray(node)) return "unknown";
+  const schema = node as SchemaNode;
+
+  if (Array.isArray(schema.enum)) {
+    return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+  }
+  if (schema.const !== undefined) return JSON.stringify(schema.const);
+
+  const variants = (schema.anyOf ?? schema.oneOf) as unknown;
+  if (Array.isArray(variants) && variants.length > 0) {
+    return [...new Set(variants.map((variant) => renderNode(variant, depth)))].join(" | ");
+  }
+
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    return [...new Set(type.map(renderPrimitive))].join(" | ");
+  }
+
+  if (type === "object" || (type === undefined && schema.properties)) {
+    const properties = (schema.properties ?? {}) as Record<string, unknown>;
+    const required = new Set(Array.isArray(schema.required) ? (schema.required as string[]) : []);
+    const keys = Object.keys(properties);
+    if (keys.length === 0) return "Record<string, unknown>";
+    const inner = "  ".repeat(depth + 1);
+    const lines = keys.map(
+      (key) =>
+        `${inner}${renderKey(key)}${required.has(key) ? "" : "?"}: ${renderNode(properties[key], depth + 1)}`,
+    );
+    return `{\n${lines.join("\n")}\n${"  ".repeat(depth)}}`;
+  }
+
+  if (type === "array") {
+    const item = renderNode(schema.items, depth);
+    // 유니온 요소는 괄호가 없으면 `A | B[]` 로 잘못 읽힌다.
+    if (item.includes(" | ")) return `(${item})[]`;
+    return `${item}[]`;
+  }
+
+  return renderPrimitive(type);
+}
+
+/** 이미 파싱된 스키마 값용 — 호출부가 같은 JSON 을 두 번 파싱하지 않게 한다. */
+export function renderParsedJsonSchemaTypeText(schema: unknown, name = "Response"): string {
+  return `type ${name} = ${renderNode(schema, 0)}`;
+}
+
+/** 실패(파싱 불가 등) 시 null — 호출부가 표시 자체를 생략한다. */
+export function renderJsonSchemaTypeText(schemaJson: string, name = "Response"): string | null {
+  try {
+    return renderParsedJsonSchemaTypeText(JSON.parse(schemaJson) as unknown, name);
+  } catch {
+    return null;
+  }
+}

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

@@ -3,8 +3,17 @@
   "table": "request_logs",
   "title": "RequestLog",
   "props": [
-    { "name": "id", "type": "integer", "desc": "ID" },
-    { "name": "created_at", "desc": "등록일시", "dbDefault": "CURRENT_TIMESTAMP", "type": "date" },
+    {
+      "name": "id",
+      "type": "integer",
+      "desc": "ID"
+    },
+    {
+      "name": "created_at",
+      "desc": "등록일시",
+      "dbDefault": "CURRENT_TIMESTAMP",
+      "type": "date"
+    },
     {
       "name": "token_name",
       "toFilter": true,
@@ -36,13 +45,48 @@
       "length": 255,
       "nullable": true
     },
-    { "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": "\"\"" },
-    { "name": "input_tokens", "type": "integer", "desc": "입력 토큰", "dbDefault": "0" },
-    { "name": "output_tokens", "type": "integer", "desc": "출력 토큰", "dbDefault": "0" },
-    { "name": "cache_read_tokens", "type": "integer", "desc": "캐시 읽기 토큰", "dbDefault": "0" },
+    {
+      "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": "\"\""
+    },
+    {
+      "name": "input_tokens",
+      "type": "integer",
+      "desc": "입력 토큰",
+      "dbDefault": "0"
+    },
+    {
+      "name": "output_tokens",
+      "type": "integer",
+      "desc": "출력 토큰",
+      "dbDefault": "0"
+    },
+    {
+      "name": "cache_read_tokens",
+      "type": "integer",
+      "desc": "캐시 읽기 토큰",
+      "dbDefault": "0"
+    },
     {
       "name": "cache_creation_tokens",
       "type": "integer",
@@ -61,9 +105,24 @@
       "nullable": true,
       "desc": "1시간 TTL 캐시 생성 토큰"
     },
-    { "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": "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": "cost_source",
       "type": "string",
@@ -84,7 +143,13 @@
       "nullable": true,
       "desc": "이미지 비용 추정 방식"
     },
-    { "name": "effort", "type": "string", "length": 10, "nullable": true, "desc": "effort level" },
+    {
+      "name": "effort",
+      "type": "string",
+      "length": 10,
+      "nullable": true,
+      "desc": "effort level"
+    },
     {
       "name": "history",
       "type": "json",
@@ -99,6 +164,12 @@
       "nullable": true,
       "desc": "요청에 장착된 tool 정의 목록"
     },
+    {
+      "name": "json_schema",
+      "type": "string",
+      "nullable": true,
+      "desc": "structured output 요청의 JSON Schema 원문 (detail 의 response 타입 표시용)"
+    },
     {
       "name": "status",
       "type": "enum",
@@ -106,38 +177,89 @@
       "desc": "실행 상태",
       "dbDefault": "\"succeeded\""
     },
-    { "name": "error_message", "type": "string", "nullable": true, "desc": "에러 메시지" },
-    { "name": "tool_call_count", "type": "integer", "desc": "tool call 횟수", "dbDefault": "0" },
+    {
+      "name": "error_message",
+      "type": "string",
+      "nullable": true,
+      "desc": "에러 메시지"
+    },
+    {
+      "name": "response_json_ok",
+      "type": "boolean",
+      "nullable": true,
+      "desc": "structured(jsonSchema) 요청의 응답 JSON 파싱 성공 여부. 비structured 요청은 null"
+    },
+    {
+      "name": "tool_call_count",
+      "type": "integer",
+      "desc": "tool call 횟수",
+      "dbDefault": "0"
+    },
     {
       "name": "is_image_generation",
       "type": "boolean",
       "desc": "이미지 생성 turn 여부 (quota 귀속용)",
       "dbDefault": "false"
+    },
+    {
+      "name": "is_structured",
+      "type": "boolean",
+      "desc": "structured output(jsonSchema) 요청 여부 (목록 구분 표시용)",
+      "dbDefault": "false"
     }
   ],
   "indexes": [
     {
       "type": "index",
       "name": "request_logs_token_name_index",
-      "columns": [{ "name": "token_name" }],
+      "columns": [
+        {
+          "name": "token_name"
+        }
+      ],
       "using": "btree"
     },
     {
       "type": "index",
       "name": "request_logs_project_name_index",
-      "columns": [{ "name": "project_name" }],
+      "columns": [
+        {
+          "name": "project_name"
+        }
+      ],
       "using": "btree"
     },
     {
       "type": "index",
       "name": "request_logs_project_name_cost_usd_index",
-      "columns": [{ "name": "project_name" }, { "name": "cost_usd" }],
+      "columns": [
+        {
+          "name": "project_name"
+        },
+        {
+          "name": "cost_usd"
+        }
+      ],
       "using": "btree"
     },
     {
       "type": "index",
       "name": "request_logs_model_name_index",
-      "columns": [{ "name": "model_name" }],
+      "columns": [
+        {
+          "name": "model_name"
+        }
+      ],
+      "using": "btree"
+    },
+    {
+      "type": "index",
+      "name": "request_logs_created_at_index",
+      "columns": [
+        {
+          "name": "created_at"
+        }
+      ],
       "using": "btree"
     }
   ],
@@ -169,9 +291,11 @@
       "history",
       "tools",
       "status",
+      "response_json_ok",
       "error_message",
       "tool_call_count",
-      "is_image_generation"
+      "is_image_generation",
+      "is_structured"
     ],
     "P": [
       "id",
@@ -195,8 +319,10 @@
       "image_cost_method",
       "effort",
       "status",
+      "response_json_ok",
       "tool_call_count",
-      "is_image_generation"
+      "is_image_generation",
+      "is_structured"
     ],
     "C": [
       "id",

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

@@ -1,3 +1,4 @@
+import { jsonSchemaToZod } from "json-schema-to-zod";
 import {
   api,
   asArray,
@@ -13,11 +14,13 @@ 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 { renderParsedJsonSchemaTypeText } from "./json-schema-type-text";
 import {
   type RequestLogListParams,
   type RequestLogSaveParams,
   type ToolDefinitions,
 } from "./request-log.types";
+import { formatZodCode } from "./zod-code-format";
 
 // cost_usd는 정수 micro-USD로 저장. 실제 USD = cost_usd / MICRO_USD.
 export const MICRO_USD = 1_000_000;
@@ -260,6 +263,11 @@ class RequestLogModelClass extends BaseModelClass<
       qb.where("request_logs.model_name", params.model_name);
     }
 
+    // structured 응답이 JSON 파싱에 실패한 행만 — broken 배치 조사용 필터.
+    if (params.response_json_broken) {
+      qb.where("request_logs.response_json_ok", false);
+    }
+
     if (params.search && params.keyword && params.keyword.length > 0) {
       if (params.search === "id") {
         qb.where("request_logs.id", Number(params.keyword));
@@ -323,6 +331,101 @@ class RequestLogModelClass extends BaseModelClass<
     });
   }
 
+  /**
+   * 최근 구간의 provider 별 경량 통계(모니터링용). provider 는 requested_model_name 의
+   * "openai/..." | "anthropic/..." prefix 로 판정한다 — serving model_name 은 prefix 가
+   * 없고, running 초기엔 아직 비어 있다. 집계는 JS 에서 한다: 폴링 주기가 느슨하고
+   * 구간이 짧아 row 수가 작으며, prefix CASE 식을 쿼리 빌더에 박지 않아도 된다.
+   */
+  async providerStatsSince(since: Date): Promise<
+    Array<{
+      provider: string;
+      requests: number;
+      errors: number;
+      inputTokens: number;
+      cacheReadTokens: number;
+    }>
+  > {
+    const rdb = this.getPuri("r");
+    const rows = (await rdb
+      .from("request_logs")
+      .select({
+        requested_model_name: "request_logs.requested_model_name",
+        status: "request_logs.status",
+        input_tokens: "request_logs.input_tokens",
+        cache_read_tokens: "request_logs.cache_read_tokens",
+      })
+      .where("request_logs.created_at", ">=", since)) as unknown as Array<{
+      requested_model_name: string | null;
+      status: string;
+      input_tokens: number;
+      cache_read_tokens: number;
+    }>;
+
+    const byProvider = new Map<
+      string,
+      { requests: number; errors: number; inputTokens: number; cacheReadTokens: number }
+    >();
+    for (const row of rows) {
+      const model = row.requested_model_name ?? "";
+      const provider = model.startsWith("openai/")
+        ? "openai"
+        : model.startsWith("anthropic/")
+          ? "anthropic"
+          : "unknown";
+      const agg = byProvider.get(provider) ?? {
+        requests: 0,
+        errors: 0,
+        inputTokens: 0,
+        cacheReadTokens: 0,
+      };
+      agg.requests += 1;
+      if (row.status === "error") agg.errors += 1;
+      agg.inputTokens += row.input_tokens;
+      agg.cacheReadTokens += row.cache_read_tokens;
+      byProvider.set(provider, agg);
+    }
+    return [...byProvider.entries()]
+      .map(([provider, agg]) => ({ provider, ...agg }))
+      .toSorted((a, b) => a.provider.localeCompare(b.provider));
+  }
+
+  /**
+   * structured output 요청의 JSON Schema 를 표시용 타입 텍스트로 변환한다.
+   * typescript 는 간결한 `type` 선언, zod 는 재구성된 zod 표현식이다 — 원본 zod
+   * 소스는 wire 를 건너오며 소실되므로 refine/transform 류는 복원되지 않는다.
+   * 스키마가 없거나 변환 실패면 null — 화면은 해당 블록 표시를 생략한다.
+   */
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
+  async responseTypeTs(id: number): Promise<{
+    typescript: string | null;
+    zod: string | null;
+  }> {
+    const rdb = this.getPuri("r");
+    const rows = (await rdb
+      .from("request_logs")
+      .select({ json_schema: "request_logs.json_schema" })
+      .where("request_logs.id", id)) as unknown as Array<{ json_schema: string | null }>;
+    const schema = rows[0]?.json_schema;
+    if (!schema) return { typescript: null, zod: null };
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(schema);
+    } catch {
+      return { typescript: null, zod: null };
+    }
+    let zod: string | null = null;
+    try {
+      zod = formatZodCode(
+        jsonSchemaToZod(parsed as Parameters<typeof jsonSchemaToZod>[0], { module: "none" }),
+      );
+    } catch {
+      zod = null;
+    }
+    return { typescript: renderParsedJsonSchemaTypeText(parsed), zod };
+  }
+
   // ── Run Lifecycle ──────────────────────────────────────────────
 
   async createRun(params: {
@@ -334,6 +437,7 @@ class RequestLogModelClass extends BaseModelClass<
     history?: unknown;
     tools?: ToolDefinitions;
     is_image_generation?: boolean;
+    json_schema?: string | null;
   }): Promise<number> {
     const wdb = this.getPuri("w");
     wdb.ubRegister("request_logs", {
@@ -354,6 +458,8 @@ class RequestLogModelClass extends BaseModelClass<
       tool_call_count: 0,
       // 이미지 turn 식별(R13). run 경로(tools+image 조합)도 auto 경로와 동일하게 마킹.
       is_image_generation: params.is_image_generation ?? false,
+      json_schema: params.json_schema ?? null,
+      is_structured: params.json_schema !== null && params.json_schema !== undefined,
       ...(params.history !== undefined ? { history: params.history as { type: string }[] } : {}),
       ...(params.tools !== undefined ? { tools: params.tools } : {}),
     });
@@ -398,6 +504,7 @@ class RequestLogModelClass extends BaseModelClass<
       tool_call_count?: number;
       image_cost_usd?: number | null;
       image_cost_method?: string | null;
+      response_json_ok?: boolean | null;
     },
   ): Promise<void> {
     if (params.status === "succeeded" && !params.token_name) {
@@ -423,6 +530,7 @@ class RequestLogModelClass extends BaseModelClass<
       "tool_call_count",
       "image_cost_usd",
       "image_cost_method",
+      "response_json_ok",
     ] as const;
     for (const key of fields) {
       if (params[key] !== undefined) update[key] = params[key];

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

@@ -25,6 +25,8 @@ export type ToolDefinitions = z.infer<typeof ToolDefinitions>;
 export const RequestLogListParams = RequestLogBaseListParams.extend({
   project_name_is_null: z.boolean().optional(),
   project_name_is_not_null: z.boolean().optional(),
+  // structured 응답이 깨진(JSON 파싱 실패) 행만 조회
+  response_json_broken: z.boolean().optional(),
 });
 export type RequestLogListParams = z.infer<typeof RequestLogListParams>;
 

package/bundle/src/application/request-log/zod-code-format.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+
+import { formatZodCode } from "./zod-code-format";
+
+describe("formatZodCode", () => {
+  it("breaks object members onto lines and unquotes identifier keys", () => {
+    const code =
+      'z.object({ "dish": z.string().describe("추천 점심 메뉴"), "sides": z.array(z.object({ "name": z.string() })).max(3) })';
+    expect(formatZodCode(code)).toBe(
+      [
+        "z.object({",
+        '  dish: z.string().describe("추천 점심 메뉴"),',
+        "  sides: z.array(z.object({",
+        "    name: z.string()",
+        "  })).max(3)",
+        "})",
+      ].join("\n"),
+    );
+  });
+
+  it("keeps arrays, arguments, and chains inline", () => {
+    expect(formatZodCode('z.enum(["a", "b"]).describe("x, y")')).toBe(
+      'z.enum(["a", "b"]).describe("x, y")',
+    );
+  });
+
+  it("never touches string literal content", () => {
+    const code = 'z.object({ "note": z.string().describe("중괄호 { 와 , 쉼표 \\" 포함") })';
+    expect(formatZodCode(code)).toContain('describe("중괄호 { 와 , 쉼표 \\" 포함")');
+  });
+});