@cartanova/qgrid-cli 1.9.0 → 2.0.1

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

@@ -5,18 +5,81 @@ import { z } from "zod";
 export const Effort = z.enum(["low", "medium", "high"]);
 export type Effort = z.infer<typeof Effort>;
 
+export const QgridTool = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  inputSchema: z.unknown(),
+});
+export type QgridTool = z.infer<typeof QgridTool>;
+
+export const QgridContent = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("text"),
+    text: z.string(),
+  }),
+  z.object({
+    type: z.literal("tool-call"),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    input: z.string(),
+  }),
+]);
+export type QgridContent = z.infer<typeof QgridContent>;
+
+export const FinishReason = z.enum(["stop", "tool-calls"]);
+export type FinishReason = z.infer<typeof FinishReason>;
+
+export const Verbosity = z.enum(["low", "medium", "high"]);
+export type Verbosity = z.infer<typeof Verbosity>;
+
+export const ReasoningSummary = z.enum(["auto", "concise", "detailed", "none"]);
+export type ReasoningSummary = z.infer<typeof ReasoningSummary>;
+
+export const ServiceTier = z.enum(["fast", "flex"]);
+export type ServiceTier = z.infer<typeof ServiceTier>;
+
+// ─── Run Lifecycle Context (SDK ↔ Server contract) ───
+
+export const QgridLogMode = z.enum(["auto", "run", "none"]);
+export type QgridLogMode = z.infer<typeof QgridLogMode>;
+
+export const QgridRunContext = z.object({
+  requestLogId: z.number(),
+});
+export type QgridRunContext = z.infer<typeof QgridRunContext>;
+
+export const QgridToolResultInput = z.object({
+  toolCallId: z.string(),
+  toolName: z.string().optional(),
+  output: z.string(),
+  isError: z.boolean().optional(),
+});
+export type QgridToolResultInput = z.infer<typeof QgridToolResultInput>;
+
 export const QueryInput = z.object({
   system: z.string().optional(),
   prompt: z.string(),
   model: z.string().optional(),
   timeout: z.number().optional(),
   jsonSchema: z.string().optional(),
-  effort: Effort.optional(),
+  tools: z.array(QgridTool).optional(),
+  effort: z.string().optional(),
+  verbosity: Verbosity.optional(),
+  reasoningSummary: ReasoningSummary.optional(),
+  serviceTier: ServiceTier.optional(),
+  history: z.string().optional(),
+  projectName: z.string().optional(),
+  isStep: z.boolean().optional(),
+  logMode: QgridLogMode.optional(),
+  runContext: QgridRunContext.optional(),
+  toolResults: z.array(QgridToolResultInput).optional(),
 });
 export type QueryInput = z.infer<typeof QueryInput>;
 
-export const CliResult = z.object({
+export const QueryOutput = z.object({
   text: z.string(),
+  content: z.array(QgridContent),
+  finishReason: FinishReason,
   tokenName: z.string().optional(),
   model: z.string().optional(),
   usage: z.object({
@@ -27,8 +90,86 @@ export const CliResult = z.object({
   }),
   durationMs: z.number(),
   costUsd: z.number(),
+  runContext: QgridRunContext.optional(),
+});
+export type QueryOutput = z.infer<typeof QueryOutput>;
+
+// ─── Stream Events ───
+
+export const StreamEvents = z.object({
+  delta: z.object({ text: z.string() }),
+  toolCall: z.object({
+    toolCallId: z.string(),
+    toolName: z.string(),
+    input: z.string(),
+  }),
+  done: z.object({
+    text: z.string(),
+    model: z.string().optional(),
+    tokenName: z.string().optional(),
+    finishReason: FinishReason,
+    usage: z.object({
+      input_tokens: z.number(),
+      output_tokens: z.number(),
+      cache_creation_input_tokens: z.number(),
+      cache_read_input_tokens: z.number(),
+    }),
+    durationMs: z.number(),
+    costUsd: z.number(),
+    content: z.array(QgridContent),
+    runContext: QgridRunContext.optional(),
+  }),
+  error: z.object({ message: z.string() }),
+});
+export type StreamEvents = z.infer<typeof StreamEvents>;
+
+// ─── Run Lifecycle ───
+
+export const CreateRunInput = z.object({
+  userPrompt: z.string(),
+  systemPrompt: z.string().optional(),
+  modelName: z.string().optional(),
+  effort: z.string().optional(),
+  projectName: z.string().optional(),
+});
+export type CreateRunInput = z.infer<typeof CreateRunInput>;
+
+export const AppendStepInput = z.object({
+  requestLogId: z.number(),
+  stepIndex: z.number(),
+  type: z.enum(["generate", "tool_call"]),
+  inputTokens: z.number().optional(),
+  outputTokens: z.number().optional(),
+  cacheReadTokens: z.number().optional(),
+  cacheCreationTokens: z.number().optional(),
+  durationMs: z.number().optional(),
+  finishReason: z.string().optional(),
+  reasoningText: z.string().optional(),
+  reasoningTokens: z.number().optional(),
+  toolCallIndex: z.number().optional(),
+  toolCallId: z.string().optional(),
+  toolName: z.string().optional(),
+  toolArgs: z.string().optional(),
+  toolResult: z.string().optional(),
+  toolDurationMs: z.number().optional(),
+  error: z.string().optional(),
+});
+export type AppendStepInput = z.infer<typeof AppendStepInput>;
+
+export const FinishRunInput = z.object({
+  requestLogId: z.number(),
+  status: z.enum(["succeeded", "error", "aborted"]),
+  response: z.string().optional(),
+  tokenName: z.string().optional(),
+  totalInputTokens: z.number().optional(),
+  totalOutputTokens: z.number().optional(),
+  totalCacheReadTokens: z.number().optional(),
+  totalCacheCreationTokens: z.number().optional(),
+  totalDurationMs: z.number().optional(),
+  history: z.string().optional(),
+  errorMessage: z.string().optional(),
 });
-export type CliResult = z.infer<typeof CliResult>;
+export type FinishRunInput = z.infer<typeof FinishRunInput>;
 
 // ─── Token Management ───
 
@@ -46,6 +187,7 @@ export type RemoveTokenInput = z.infer<typeof RemoveTokenInput>;
 export const TokenStats = z.object({
   token: z.string(),
   name: z.string(),
+  provider: z.string(),
   requests: z.number(),
 });
 export type TokenStats = z.infer<typeof TokenStats>;
@@ -57,30 +199,18 @@ export const OAuthStartResult = z.object({
 });
 export type OAuthStartResult = z.infer<typeof OAuthStartResult>;
 
-const RateLimit = z
+const RateWindow = z
   .object({
     utilization: z.number().nullable(),
-    resets_at: z.string().nullable(),
+    resetsAt: z.string().nullable(),
   })
   .nullable();
 
 export const UsageResponse = z.object({
   error: z.string().optional(),
-  five_hour: RateLimit.optional(),
-  seven_day: RateLimit.optional(),
-  seven_day_opus: RateLimit.optional(),
-  seven_day_sonnet: RateLimit.optional(),
-  seven_day_oauth_apps: RateLimit.optional(),
-  seven_day_cowork: RateLimit.optional(),
-  extra_usage: z
-    .object({
-      is_enabled: z.boolean(),
-      monthly_limit: z.number().nullable(),
-      used_credits: z.number().nullable(),
-      utilization: z.number().nullable(),
-    })
-    .nullable()
-    .optional(),
+  provider: z.string().optional(),
+  fiveHour: RateWindow.optional(),
+  sevenDay: RateWindow.optional(),
 });
 export type UsageResponse = z.infer<typeof UsageResponse>;
 

package/bundle/src/application/qgrid/token-subscriber.ts

@@ -3,6 +3,7 @@ import { getLogger } from "@logtape/logtape";
 import { Client, type ClientConfig } from "pg";
 
 import { TokenModel } from "../token/token.model";
+import { type OpenAICredentials } from "../token/token.types";
 import { type QgridDispatcherClass } from "./qgrid.dispatcher";
 import { type SubscriberStatus } from "./qgrid.types";
 
@@ -153,19 +154,40 @@ export class TokenSubscriber {
     const payload = JSON.parse(payloadJson) as Payload;
     if (payload.op === "DELETE") {
       this.dispatcher.removeCache(payload.id);
+      this.dispatcher.openaiDispatcher
+        ?.onTokenRemoved(payload.id)
+        .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));
       logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);
       return;
     }
     const row = await TokenModel.findOne("A", { id: payload.id });
-    if (!row || !row.active) {
+    if (!row) {
       this.dispatcher.removeCache(payload.id);
-      logger.info(
-        `NOTIFY ${payload.op} id=${payload.id} (${row?.name ?? "?"}) active=${row?.active ?? "missing"} → removed from cache`,
-      );
+      this.dispatcher.openaiDispatcher
+        ?.onTokenRemoved(payload.id)
+        .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));
+      logger.info(`NOTIFY ${payload.op} id=${payload.id} → missing, removed from cache`);
       return;
     }
+
     this.dispatcher.upsertCache(payload.id, row);
-    logger.info(`NOTIFY ${payload.op} id=${payload.id} (${row.name}) active=true → cache upserted`);
+
+    if (row.provider === "openai") {
+      const creds = row.credentials as Record<string, unknown>;
+      if (payload.op === "INSERT") {
+        this.dispatcher.openaiDispatcher
+          ?.onTokenAdded(payload.id, row.name, creds as OpenAICredentials)
+          .catch((e) => logger.warn(`openai worker spawn failed: ${(e as Error).message}`));
+      } else if (row.active) {
+        this.dispatcher.openaiDispatcher?.onTokenActivated(payload.id);
+        this.dispatcher.openaiDispatcher
+          ?.onTokenUpdated(payload.id, row.name, creds as OpenAICredentials)
+          .catch((e) => logger.warn(`openai worker update failed: ${(e as Error).message}`));
+      } else {
+        this.dispatcher.openaiDispatcher?.onTokenDeactivated(payload.id);
+      }
+    }
+    logger.info(`NOTIFY ${payload.op} id=${payload.id} (${row.name}) active=${row.active}`);
   }
 
   async reconcile(): Promise<void> {

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

@@ -37,9 +37,8 @@ const SETUP_SQL = `
   FOR EACH ROW
   WHEN (
     OLD.active IS DISTINCT FROM NEW.active OR
-    OLD.token IS DISTINCT FROM NEW.token OR
-    OLD.refresh_token IS DISTINCT FROM NEW.refresh_token OR
-    OLD.expires_at IS DISTINCT FROM NEW.expires_at OR
+    OLD.credentials IS DISTINCT FROM NEW.credentials OR
+    OLD.provider IS DISTINCT FROM NEW.provider OR
     OLD.name IS DISTINCT FROM NEW.name
   )
   EXECUTE FUNCTION public.tokens_notify();

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

@@ -0,0 +1,95 @@
+import { getLogger } from "@logtape/logtape";
+
+import { type JsonValue } from "../../codex-protocol/serde_json/JsonValue";
+import { type QgridContent, type QgridTool, type QueryOutput } from "./qgrid.types";
+
+const logger = getLogger(["qgrid", "tool-emulation"]);
+
+type ToolCallResponse = {
+  action: "answer" | "tool_call";
+  answer?: string | null;
+  toolCalls?: Array<{ toolName: string; args: string }> | null;
+};
+
+export function buildToolCallSchema(tools: QgridTool[]): JsonValue {
+  const toolDescriptions = tools
+    .map((tool) => {
+      const schema = JSON.stringify(tool.inputSchema);
+      return `- ${tool.name}: ${tool.description ?? ""}\n  inputSchema: ${schema}`;
+    })
+    .join("\n");
+
+  return {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["answer", "tool_call"] },
+      answer: { anyOf: [{ type: "string" }, { type: "null" }] },
+      toolCalls: {
+        anyOf: [
+          {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                toolName: {
+                  type: "string",
+                  enum: tools.map((tool) => tool.name),
+                  description: toolDescriptions,
+                },
+                args: { type: "string", description: "Tool arguments as JSON string" },
+              },
+              required: ["toolName", "args"],
+              additionalProperties: false,
+            },
+          },
+          { type: "null" },
+        ],
+      },
+    },
+    required: ["action", "answer", "toolCalls"],
+    additionalProperties: false,
+  };
+}
+
+export function applyToolCallEmulation(
+  result: Omit<QueryOutput, "content" | "finishReason">,
+  tools?: QgridTool[],
+): QueryOutput {
+  if (!tools?.length) {
+    const content: QgridContent[] = [{ type: "text", text: result.text }];
+    return { ...result, content, finishReason: "stop" };
+  }
+
+  let parsed: ToolCallResponse;
+  try {
+    parsed = JSON.parse(result.text) as ToolCallResponse;
+  } catch (e) {
+    logger.warn(`tool-call emulation parse failed, falling back to text: ${(e as Error).message}`);
+    return { ...result, content: [{ type: "text", text: result.text }], finishReason: "stop" };
+  }
+
+  if (parsed.action === "tool_call") {
+    const toolCalls = parsed.toolCalls ?? [];
+    const content: QgridContent[] = toolCalls.map((toolCall) => {
+      if (!tools.some((tool) => tool.name === toolCall.toolName)) {
+        throw new Error(`unknown emulated tool: ${toolCall.toolName}`);
+      }
+
+      return {
+        type: "tool-call",
+        toolCallId: `call_${Math.random().toString(36).slice(2, 10)}`,
+        toolName: toolCall.toolName,
+        input: toolCall.args,
+      };
+    });
+    return { ...result, content, finishReason: "tool-calls" };
+  }
+
+  const text = parsed.answer ?? result.text;
+  return {
+    ...result,
+    text,
+    content: [{ type: "text", text }],
+    finishReason: "stop",
+  };
+}

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

@@ -17,8 +17,9 @@ function createSSRQuery(
   return { modelName, methodName, params, serviceKey, __brand: "SSRQuery" } as SSRQuery;
 }
 
+import { RequestLogStepListParams } from "./request-log-step/request-log-step.types";
 import { RequestLogListParams } from "./request-log/request-log.types";
-import { TokenSubsetKey, RequestLogSubsetKey } from "./sonamu.generated";
+import { TokenSubsetKey, RequestLogStepSubsetKey, RequestLogSubsetKey } from "./sonamu.generated";
 import { TokenListParams } from "./token/token.types";
 
 export namespace TokenService {
@@ -32,6 +33,33 @@ export namespace TokenService {
     createSSRQuery("TokenModel", "findMany", [subset, rawParams], ["Token", "getTokens"]);
 }
 
+export namespace RequestLogStepService {
+  export const getRequestLogStep = <T extends RequestLogStepSubsetKey>(
+    subset: T,
+    id: number,
+  ): SSRQuery =>
+    createSSRQuery(
+      "RequestLogStepModel",
+      "findById",
+      [subset, id],
+      ["RequestLogStep", "getRequestLogStep"],
+    );
+
+  export const getRequestLogSteps = <
+    T extends RequestLogStepSubsetKey,
+    LP extends RequestLogStepListParams,
+  >(
+    subset: T,
+    rawParams?: LP,
+  ): SSRQuery =>
+    createSSRQuery(
+      "RequestLogStepModel",
+      "findMany",
+      [subset, rawParams],
+      ["RequestLogStep", "getRequestLogSteps"],
+    );
+}
+
 export namespace RequestLogService {
   export const getRequestLog = <T extends RequestLogSubsetKey>(subset: T, id: number): SSRQuery =>
     createSSRQuery("RequestLogModel", "findById", [subset, id], ["RequestLog", "getRequestLog"]);
@@ -58,8 +86,8 @@ export namespace QgridService {
   export const projectNames = (): SSRQuery =>
     createSSRQuery("QgridFrame", "projectNames", [], ["Qgrid", "projectNames"]);
 
-  export const usage = (tokenName?: string): SSRQuery =>
-    createSSRQuery("QgridFrame", "usage", [tokenName], ["Qgrid", "usage"]);
+  export const usage = (tokenId?: number): SSRQuery =>
+    createSSRQuery("QgridFrame", "usage", [tokenId], ["Qgrid", "usage"]);
 
   export const health = (): SSRQuery =>
     createSSRQuery("QgridFrame", "health", [], ["Qgrid", "health"]);

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

@@ -2,26 +2,16 @@
   "id": "RequestLog",
   "table": "request_logs",
   "title": "RequestLog",
-  "cone": {
-    "note": "RequestLog 엔티티. 테스트 데이터 생성 시 각 필드는 실제 데이터와 유사한 형식으로 생성됩니다."
-  },
   "props": [
-    {
-      "name": "id",
-      "type": "integer",
-      "desc": "ID",
-      "cone": {
-        "note": "정수 형식으로 생성됩니다.",
-        "fixtureGenerator": "faker.number.int({ \"min\": 1, \"max\": 1000 })"
-      }
-    },
+    { "name": "id", "type": "integer", "desc": "ID" },
     { "name": "created_at", "desc": "등록일시", "dbDefault": "CURRENT_TIMESTAMP", "type": "date" },
     {
       "name": "token_name",
       "toFilter": true,
       "desc": "토큰 이름",
       "type": "string",
-      "length": 100
+      "length": 100,
+      "nullable": true
     },
     {
       "name": "project_name",
@@ -41,13 +31,35 @@
     },
     { "name": "user_prompt", "type": "string", "nullable": true, "desc": "사용자 프롬프트" },
     { "name": "system_prompt", "type": "string", "nullable": true, "desc": "시스템 프롬프트" },
-    { "name": "response", "desc": "llm 응답 전문", "type": "string" },
-    { "name": "input_tokens", "type": "integer", "desc": "입력 토큰" },
-    { "name": "output_tokens", "type": "integer", "desc": "출력 토큰" },
-    { "name": "cache_read_tokens", "type": "integer", "desc": "캐시 읽기 토큰" },
-    { "name": "cache_creation_tokens", "type": "integer", "desc": "캐시 생성 토큰" },
-    { "name": "duration_ms", "type": "integer", "desc": "응답 소요시간(ms)" },
-    { "name": "cost_usd", "type": "integer", "nullable": true, "desc": "API 비용" }
+    { "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",
+      "desc": "캐시 생성 토큰",
+      "dbDefault": "0"
+    },
+    { "name": "duration_ms", "type": "integer", "desc": "응답 소요시간(ms)", "dbDefault": "0" },
+    { "name": "cost_usd", "type": "integer", "nullable": true, "desc": "API 비용" },
+    { "name": "effort", "type": "string", "length": 10, "nullable": true, "desc": "effort level" },
+    {
+      "name": "history",
+      "type": "json",
+      "id": "HistoryItems",
+      "nullable": true,
+      "desc": "inject_items 히스토리"
+    },
+    {
+      "name": "status",
+      "type": "enum",
+      "id": "RequestLogStatus",
+      "desc": "실행 상태",
+      "dbDefault": "\"succeeded\""
+    },
+    { "name": "error_message", "type": "string", "nullable": true, "desc": "에러 메시지" },
+    { "name": "tool_call_count", "type": "integer", "desc": "tool call 횟수", "dbDefault": "0" }
   ],
   "indexes": [
     {
@@ -79,9 +91,13 @@
         "cache_read_tokens",
         "cache_creation_tokens",
         "duration_ms",
-        "cost_usd"
-      ],
-      "cone": { "note": "전체 필드 서브셋" }
+        "cost_usd",
+        "effort",
+        "history",
+        "status",
+        "error_message",
+        "tool_call_count"
+      ]
     },
     "P": {
       "fields": [
@@ -95,28 +111,20 @@
         "cache_read_tokens",
         "cache_creation_tokens",
         "duration_ms",
-        "cost_usd"
-      ],
-      "cone": {
-        "note": "리스트 조회용 Preview 서브셋. TEXT 컬럼(user_prompt, system_prompt, response) 제외"
-      }
+        "cost_usd",
+        "effort",
+        "status",
+        "tool_call_count"
+      ]
     }
   },
   "enums": {
-    "RequestLogOrderBy": {
-      "values": { "id-desc": "ID최신순" },
-      "cone": { "note": "가능한 값: id-desc", "values": { "id-desc": { "note": "ID최신순" } } }
-    },
+    "RequestLogOrderBy": { "values": { "id-desc": "ID최신순" } },
     "RequestLogSearchField": {
-      "values": { "id": "ID", "token_name": "토큰이름", "user_prompt": "사용자 프롬프트" },
-      "cone": {
-        "note": "가능한 값: id, token_name, user_prompt",
-        "values": {
-          "id": { "note": "ID" },
-          "token_name": { "note": "토큰이름" },
-          "user_prompt": { "note": "사용자 프롬프트" }
-        }
-      }
+      "values": { "id": "ID", "token_name": "토큰이름", "user_prompt": "사용자 프롬프트" }
+    },
+    "RequestLogStatus": {
+      "values": { "running": "실행 중", "succeeded": "성공", "error": "에러", "aborted": "중단" }
     }
   }
 }