@cartanova/qgrid-cli 2.7.3 → 2.7.5

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

@@ -1,12 +1,50 @@
 import { describe, expect, it } from "vitest";
 
-import { renderJsonSchemaTypeText } from "./json-schema-type-text";
+import {
+  renderJsonSchemaZodShapeText,
+  renderJsonSchemaTypeText,
+  renderParsedJsonSchemaTypeText,
+} from "./json-schema-type-text";
 
 function schema(value: unknown): string {
   return JSON.stringify(value);
 }
 
 describe("renderJsonSchemaTypeText", () => {
+  it("preserves the existing parsed-schema output across supported node kinds", () => {
+    expect(
+      renderParsedJsonSchemaTypeText({
+        type: "object",
+        properties: {
+          mode: { anyOf: [{ const: "fast" }, { const: "safe" }] },
+          attempts: { type: "integer" },
+          tag: { type: ["string", "null"] },
+          options: {
+            type: "object",
+            properties: {
+              enabled: { type: "boolean" },
+              opaque: { format: "custom" },
+            },
+            required: ["enabled"],
+          },
+        },
+        required: ["mode", "attempts", "tag", "options"],
+      }),
+    ).toBe(
+      [
+        "type Response = {",
+        '  mode: "fast" | "safe"',
+        "  attempts: number",
+        "  tag: string | null",
+        "  options: {",
+        "    enabled: boolean",
+        "    opaque?: unknown",
+        "  }",
+        "}",
+      ].join("\n"),
+    );
+  });
+
   it("renders a flat object with optionality from required", () => {
     const result = renderJsonSchemaTypeText(
       schema({
@@ -94,3 +132,79 @@ describe("renderJsonSchemaTypeText", () => {
     expect(renderJsonSchemaTypeText("{broken")).toBeNull();
   });
 });
+
+describe("renderJsonSchemaZodShapeText", () => {
+  it("renders a compact object shape with required, optional, and default annotations", () => {
+    expect(
+      renderJsonSchemaZodShapeText(
+        {
+          type: "object",
+          properties: {
+            limit: { type: "integer", default: 10, maximum: 100 },
+            query: { type: "string", minLength: 1, pattern: "^[a-z]+$" },
+          },
+          required: ["query"],
+        },
+        6,
+      ),
+    ).toBe(
+      [
+        "z.object({",
+        "  query: z.string(),",
+        "  limit: z.number().optional(), // default=10",
+        "})",
+      ].join("\n"),
+    );
+  });
+
+  it("shortens long string enums with an inline remainder comment", () => {
+    expect(
+      renderJsonSchemaZodShapeText(
+        {
+          type: "object",
+          properties: {
+            mode: { enum: ["one", "two", "three", "four", "five", "six", "seven", "eight"] },
+          },
+          required: ["mode"],
+        },
+        6,
+      ),
+    ).toBe(
+      [
+        "z.object({",
+        '  mode: z.enum(["one", "two", "three", "four", "five", "six" /* +2 */]),',
+        "})",
+      ].join("\n"),
+    );
+  });
+
+  it("renders nested objects, arrays, unions, literals, and unknown nodes", () => {
+    expect(
+      renderJsonSchemaZodShapeText({
+        type: "object",
+        properties: {
+          filters: {
+            type: "object",
+            properties: {
+              tags: { type: "array", items: { type: "string" } },
+              value: { anyOf: [{ const: 1 }, { type: "boolean" }] },
+            },
+            required: ["tags"],
+          },
+          opaque: { format: "custom" },
+        },
+        required: ["filters", "opaque"],
+      }),
+    ).toBe(
+      [
+        "z.object({",
+        "  filters: z.object({",
+        "    tags: z.array(z.string()),",
+        "    value: z.union([z.literal(1), z.boolean()]).optional(),",
+        "  }),",
+        "  opaque: z.unknown(),",
+        "})",
+      ].join("\n"),
+    );
+  });
+});

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

@@ -25,6 +25,92 @@ function renderPrimitive(type: unknown): string {
   return "unknown";
 }
 
+function renderZodPrimitive(type: unknown): string {
+  if (type === "string") return "z.string()";
+  if (type === "number" || type === "integer") return "z.number()";
+  if (type === "boolean") return "z.boolean()";
+  if (type === "null") return "z.null()";
+  return "z.unknown()";
+}
+
+function renderZodEnum(values: unknown[], enumValueLimit?: number): string {
+  if (values.length === 0) return "z.never()";
+
+  const visibleValues =
+    enumValueLimit === undefined ? values : values.slice(0, Math.max(0, enumValueLimit));
+  const omittedCount = values.length - visibleValues.length;
+  const suffix = omittedCount > 0 ? ` /* +${omittedCount} */` : "";
+
+  if (values.every((value) => typeof value === "string")) {
+    return `z.enum([${visibleValues.map((value) => JSON.stringify(value)).join(", ")}${suffix}])`;
+  }
+
+  const literals = visibleValues.map((value) => `z.literal(${JSON.stringify(value)})`);
+  if (literals.length === 1 && omittedCount === 0) return literals[0] ?? "z.never()";
+  return `z.union([${literals.join(", ")}${suffix}])`;
+}
+
+function renderZodNode(node: unknown, depth: number, enumValueLimit?: number): string {
+  if (node === true) return "z.unknown()";
+  if (!node || typeof node !== "object" || Array.isArray(node)) return "z.unknown()";
+  const schema = node as SchemaNode;
+
+  if (Array.isArray(schema.enum)) return renderZodEnum(schema.enum, enumValueLimit);
+  if (schema.const !== undefined) return `z.literal(${JSON.stringify(schema.const)})`;
+
+  const variants = (schema.anyOf ?? schema.oneOf) as unknown;
+  if (Array.isArray(variants) && variants.length > 0) {
+    const rendered = [
+      ...new Set(variants.map((variant) => renderZodNode(variant, depth, enumValueLimit))),
+    ];
+    return rendered.length === 1
+      ? (rendered[0] ?? "z.unknown()")
+      : `z.union([${rendered.join(", ")}])`;
+  }
+
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    const rendered = [...new Set(type.map(renderZodPrimitive))];
+    return rendered.length === 1
+      ? (rendered[0] ?? "z.unknown()")
+      : `z.union([${rendered.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 "z.object({})";
+    const orderedKeys = [
+      ...keys.filter((key) => required.has(key)),
+      ...keys.filter((key) => !required.has(key)),
+    ];
+
+    const inner = "  ".repeat(depth + 1);
+    const lines = orderedKeys.map((key) => {
+      const propertySchema = properties[key];
+      const rendered = renderZodNode(propertySchema, depth + 1, enumValueLimit);
+      const optional = required.has(key) ? rendered : `${rendered}.optional()`;
+      const defaultValue =
+        propertySchema &&
+        typeof propertySchema === "object" &&
+        !Array.isArray(propertySchema) &&
+        Object.hasOwn(propertySchema, "default")
+          ? JSON.stringify((propertySchema as SchemaNode).default)
+          : undefined;
+      const defaultComment = defaultValue === undefined ? "" : ` // default=${defaultValue}`;
+      return `${inner}${renderKey(key)}: ${optional},${defaultComment}`;
+    });
+    return `z.object({\n${lines.join("\n")}\n${"  ".repeat(depth)}})`;
+  }
+
+  if (type === "array") {
+    return `z.array(${renderZodNode(schema.items, depth, enumValueLimit)})`;
+  }
+
+  return renderZodPrimitive(type);
+}
+
 function renderNode(node: unknown, depth: number): string {
   if (node === true) return "unknown";
   if (!node || typeof node !== "object" || Array.isArray(node)) return "unknown";
@@ -73,6 +159,11 @@ export function renderParsedJsonSchemaTypeText(schema: unknown, name = "Response
   return `type ${name} = ${renderNode(schema, 0)}`;
 }
 
+/** Tool input 계약용 표시 전용 Zod shape. 검증 제약은 의도적으로 생략한다. */
+export function renderJsonSchemaZodShapeText(schema: unknown, enumValueLimit?: number): string {
+  return renderZodNode(schema, 0, enumValueLimit);
+}
+
 /** 실패(파싱 불가 등) 시 null — 호출부가 표시 자체를 생략한다. */
 export function renderJsonSchemaTypeText(schemaJson: string, name = "Response"): string | null {
   try {

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

@@ -28,6 +28,16 @@ function mockTransactionalWritePuri(transactionPuri: unknown) {
   return transaction;
 }
 
+function mockToolsViewQuery(row: { tools: unknown } | undefined) {
+  const chain = mockQueryBuilder(row === undefined ? [] : [row]);
+  const from = vi.fn(() => chain);
+  vi.spyOn(
+    RequestLogModel as unknown as { getPuri: () => { from: typeof from } },
+    "getPuri",
+  ).mockReturnValue({ from });
+  return { chain, from };
+}
+
 describe("RequestLogModel TTFT", () => {
   afterEach(() => {
     vi.restoreAllMocks();
@@ -108,6 +118,162 @@ describe("RequestLogModel TTFT", () => {
   });
 });
 
+describe("RequestLogModel toolsView", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns a display-ready required-first contract from the decoded JSONB value", async () => {
+    const tools = [
+      {
+        name: "search",
+        description: "Search indexed records",
+        inputSchema: {
+          type: "object",
+          properties: {
+            optionalEmpty: { type: "string", default: "" },
+            requiredEnum: {
+              enum: ["one", "two", "three", "four", "five", "six", "seven", "eight"],
+              description: "Search mode",
+            },
+            requiredFalse: { type: "boolean", default: false },
+            requiredZero: { type: "integer", default: 0 },
+            optionalNull: { type: ["string", "null"], default: null, description: 42 },
+            optionalAbsent: { type: "string", description: "Optional note" },
+          },
+          required: ["requiredEnum", "requiredFalse", "requiredZero"],
+        },
+      },
+      {
+        name: "ping",
+        inputSchema: {
+          type: "object",
+          properties: { message: { type: "string" } },
+          required: ["message"],
+        },
+      },
+    ];
+    const { chain, from } = mockToolsViewQuery({ tools });
+
+    await expect(RequestLogModel.toolsView(7)).resolves.toEqual([
+      {
+        name: "search",
+        description: "Search indexed records",
+        parameterCount: 6,
+        inputZod: [
+          "z.object({",
+          '  requiredEnum: z.enum(["one", "two", "three", "four", "five", "six" /* +2 */]),',
+          "  requiredFalse: z.boolean(), // default=false",
+          "  requiredZero: z.number(), // default=0",
+          '  optionalEmpty: z.string().optional(), // default=""',
+          "  optionalNull: z.union([z.string(), z.null()]).optional(), // default=null",
+          "  optionalAbsent: z.string().optional(),",
+          "})",
+        ].join("\n"),
+        fullInputZod: [
+          "z.object({",
+          '  requiredEnum: z.enum(["one", "two", "three", "four", "five", "six", "seven", "eight"]),',
+          "  requiredFalse: z.boolean(), // default=false",
+          "  requiredZero: z.number(), // default=0",
+          '  optionalEmpty: z.string().optional(), // default=""',
+          "  optionalNull: z.union([z.string(), z.null()]).optional(), // default=null",
+          "  optionalAbsent: z.string().optional(),",
+          "})",
+        ].join("\n"),
+      },
+      {
+        name: "ping",
+        parameterCount: 1,
+        inputZod: ["z.object({", "  message: z.string(),", "})"].join("\n"),
+      },
+    ]);
+
+    expect(from).toHaveBeenCalledWith("request_logs");
+    expect(chain.select).toHaveBeenCalledWith({ tools: "request_logs.tools" });
+    expect(chain.where).toHaveBeenCalledWith("request_logs.id", 7);
+    expect(chain.first).toHaveBeenCalledTimes(1);
+  });
+
+  it("defensively decodes string storage without changing the view contract", async () => {
+    mockToolsViewQuery({
+      tools: JSON.stringify([
+        {
+          name: "lookup",
+          description: "Look up one record",
+          inputSchema: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+          },
+        },
+      ]),
+    });
+
+    await expect(RequestLogModel.toolsView(11)).resolves.toEqual([
+      {
+        name: "lookup",
+        description: "Look up one record",
+        parameterCount: 1,
+        inputZod: ["z.object({", "  id: z.string(),", "})"].join("\n"),
+      },
+    ]);
+  });
+
+  // inputSchema 는 QgridTool 상 z.unknown() 이라 키 누락·null 도 wire 검증을 통과한다.
+  // 하나가 터지면 map 전체가 죽어 그 요청의 tool 계약이 통째로 사라지므로 개별 정규화한다.
+  it("renders unusable input schemas without failing the entire tool contract", async () => {
+    mockToolsViewQuery({
+      tools: [
+        { name: "unknown_input", inputSchema: {} },
+        { name: "empty_object_input", inputSchema: { type: "object" } },
+        { name: "string_input", inputSchema: { type: "string" } },
+        { name: "null_input", inputSchema: null },
+        { name: "absent_input" },
+      ],
+    });
+
+    await expect(RequestLogModel.toolsView(13)).resolves.toEqual([
+      {
+        name: "unknown_input",
+        parameterCount: 0,
+        inputZod: "z.unknown()",
+      },
+      {
+        name: "empty_object_input",
+        parameterCount: 0,
+        inputZod: "z.object({})",
+      },
+      {
+        name: "string_input",
+        parameterCount: 0,
+        inputZod: "z.string()",
+      },
+      {
+        name: "null_input",
+        parameterCount: 0,
+        inputZod: "z.unknown()",
+      },
+      {
+        name: "absent_input",
+        parameterCount: 0,
+        inputZod: "z.unknown()",
+      },
+    ]);
+  });
+
+  it.each([
+    ["a missing row", undefined],
+    ["null tools", { tools: null }],
+    ["an empty decoded array", { tools: [] }],
+    ["empty stored text", { tools: "" }],
+    ["invalid stored JSON", { tools: "{broken" }],
+  ])("returns an empty view for %s", async (_label, row) => {
+    mockToolsViewQuery(row);
+
+    await expect(RequestLogModel.toolsView(12)).resolves.toEqual([]);
+  });
+});
+
 describe("RequestLogModel run lifecycle", () => {
   afterEach(() => {
     vi.restoreAllMocks();

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

@@ -14,17 +14,32 @@ 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 {
+  renderJsonSchemaZodShapeText,
+  renderParsedJsonSchemaTypeText,
+} from "./json-schema-type-text";
 import {
   type RequestLogListParams,
   type RequestLogSaveParams,
   type ToolDefinitions,
+  type ToolView,
 } 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;
 const REQUEST_LOG_RUN_LOCK_CLASS_ID = 718;
+const TOOL_ENUM_VALUE_LIMIT = 6;
+
+function decodeStoredTools(value: unknown): ToolDefinitions | null {
+  if (!value) return null;
+  if (typeof value !== "string") return value as ToolDefinitions;
+  try {
+    return JSON.parse(value) as ToolDefinitions;
+  } catch {
+    return null;
+  }
+}
 
 type ToolResultContinuation = {
   toolCallId: string;
@@ -263,11 +278,6 @@ 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));
@@ -426,6 +436,42 @@ class RequestLogModelClass extends BaseModelClass<
     return { typescript: renderParsedJsonSchemaTypeText(parsed), zod };
   }
 
+  // ── Tool Contract View
+
+  /**
+   * 요청에 장착된 tool 계약을 detail 화면용으로 축약한다. JSONB 는 이미 decode 된
+   * 배열로 오며 문자열인 경우만 방어적으로 parse 한다. 저장된 QgridTool 계약은
+   * 전수 검사로 확인됐으므로 항목별 보정이나 unreadable sentinel 은 만들지 않는다.
+   * 다만 `QgridTool.inputSchema` 는 `z.unknown()` 이라 키가 없거나 null 인 값도
+   * wire 검증을 통과하므로 빈 스키마로 정규화한다 — SDK 는 `{}` 로 채워 보낸다.
+   */
+  @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
+  async toolsView(id: number): Promise<ToolView[]> {
+    const row = (await this.getPuri("r")
+      .from("request_logs")
+      .select({ tools: "request_logs.tools" })
+      .where("request_logs.id", id)
+      .first()) as { tools: unknown } | undefined;
+    const tools = decodeStoredTools(row?.tools);
+    if (!tools) return [];
+
+    return tools.map((tool) => {
+      const inputSchema = (tool.inputSchema ?? {}) as {
+        properties?: Record<string, unknown>;
+      };
+      const inputZod = renderJsonSchemaZodShapeText(inputSchema, TOOL_ENUM_VALUE_LIMIT);
+      const fullInputZod = renderJsonSchemaZodShapeText(inputSchema);
+
+      return {
+        name: tool.name,
+        ...(tool.description !== undefined ? { description: tool.description } : {}),
+        parameterCount: Object.keys(inputSchema.properties ?? {}).length,
+        inputZod,
+        ...(inputZod !== fullInputZod ? { fullInputZod } : {}),
+      };
+    });
+  }
+
   // ── Run Lifecycle ──────────────────────────────────────────────
 
   async createRun(params: {

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

@@ -20,13 +20,22 @@ export type HistoryItems = z.infer<typeof HistoryItems>;
 export const ToolDefinitions = z.array(QgridTool);
 export type ToolDefinitions = z.infer<typeof ToolDefinitions>;
 
+// request-log detail 화면이 소비하는 tool 계약 projection. API 반환 타입은 Sonamu
+// syncer 가 모듈을 해석할 수 있도록 type-only 선언 대신 Zod schema 로 둔다.
+export const ToolView = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  parameterCount: z.number(),
+  inputZod: z.string(),
+  fullInputZod: z.string().optional(),
+});
+export type ToolView = z.infer<typeof ToolView>;
+
 // RequestLog - ListParams
 // project_name NULL 분기: IS NULL만 조회(unassigned 필터) 또는 IS NOT NULL만(distinct 조회).
 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/sonamu.generated.http

@@ -226,7 +226,6 @@ GET {{baseUrl}}/api/requestLog/findMany
 	&rawParams[model_name]=
 	&rawParams[project_name_is_null]=false
 	&rawParams[project_name_is_not_null]=false
-	&rawParams[response_json_broken]=false
 Content-Type: application/json
 
 ###
@@ -281,6 +280,12 @@ Content-Type: application/json
 
 ###
 
+GET {{baseUrl}}/api/requestLog/toolsView
+	?id=0
+Content-Type: application/json
+
+###
+
 POST {{baseUrl}}/api/requestLog/del
 Content-Type: application/json
 
@@ -520,7 +525,6 @@ GET {{baseUrl}}/api/qgrid/totalCost
 	&params[model_name]=
 	&params[project_name_is_null]=false
 	&params[project_name_is_not_null]=false
-	&params[response_json_broken]=false
 Content-Type: application/json
 
 ###