@cartanova/qgrid-cli 2.4.7 → 2.4.9

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

@@ -23,15 +23,6 @@ import {
   generatePKCE,
   refreshAccessToken,
 } from "./oauth";
-import {
-  estimateImageGenerationCostMicroUsd,
-  imageGenerationCostMethod,
-} from "./qgrid-image-generation";
-import {
-  buildImageGenerationToolSteps,
-  formatResponseForLog,
-  getImageParts,
-} from "./qgrid-response-format";
 import {
   afterQuery,
   beforeQuery,
@@ -102,6 +93,13 @@ function rejectImageGenerationStream(args: QueryInput): void {
   );
 }
 
+function rejectLegacyLogMode(args: QueryInput): void {
+  if (!Object.hasOwn(args, "logMode")) return;
+  throw new BadRequestException(
+    "qgrid: logMode is no longer supported; use logger: false to disable request logging." as LocalizedString,
+  );
+}
+
 const logger = getLogger(["qgrid"]);
 const oauthLogger = getLogger(["qgrid", "oauth"]);
 
@@ -112,97 +110,45 @@ class QgridFrameClass extends BaseFrameClass {
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async query(args: QueryInput): Promise<QueryOutput> {
-    const effectiveLogMode = args.logMode ?? (args.isStep ? "run" : "auto");
-
-    // logMode: "run" → 서버가 lifecycle 관리
-    if (effectiveLogMode === "run") {
-      const { requestLogId, stepIndex } = await beforeQuery(args);
-      try {
-        const result = await QgridDispatcher.query(args, args.timeout);
-        const lifecycle = await afterQuery(requestLogId, stepIndex, args, result);
-        // lifecycle.runContext(requestLogId) 와 dispatcher 가 실은 threadCoord 를 병합.
-        return {
-          ...result,
-          runContext: { ...lifecycle.runContext, threadCoord: result.runContext?.threadCoord },
-        };
-      } catch (e) {
-        await finishRunWithError(requestLogId, (e as Error).message, args);
-        throw e;
-      }
+    rejectLegacyLogMode(args);
+    if (args.logger === false) {
+      return QgridDispatcher.query(args, args.timeout);
     }
 
-    // logMode: "auto" (기존 non-step 경로) 또는 "none"
-    const result = await QgridDispatcher.query(args, args.timeout);
-
-    if (effectiveLogMode === "auto") {
-      this.saveAutoRequestLog(args, result);
+    const { requestLogId, stepIndex } = await beforeQuery(args);
+    let result: QueryOutput;
+    try {
+      result = await QgridDispatcher.query(args, args.timeout);
+    } catch (e) {
+      await finishRunWithError(requestLogId, (e as Error).message, args);
+      throw e;
     }
 
-    return result;
-  }
-
-  // logMode "auto" 단일 요청 로깅: run lifecycle(step 분해) 없이 request_log 1건만 남긴다.
-  // query와 queryStream 양쪽에서 사용.
-  private saveAutoRequestLog(args: QueryInput, result: QueryOutput): void {
-    const imageParts = getImageParts(result);
-    const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(
-      result,
-      args.imageGenerationOptions,
-    );
-    const toolCallCount = result.content.filter((item) => item.type === "tool-call").length;
-    const responseText = formatResponseForLog(result);
-
-    RequestLogModel.save([
-      {
-        token_name: result.tokenName,
-        project_name: args.projectName?.length ? args.projectName : null,
-        model_name: result.model ?? null,
-        user_prompt: args.prompt,
-        system_prompt: args.system ?? null,
-        response: responseText,
-        input_tokens: result.usage.input_tokens,
-        output_tokens: result.usage.output_tokens,
-        cache_read_tokens: result.usage.cache_read_input_tokens,
-        cache_creation_tokens: result.usage.cache_creation_input_tokens,
-        duration_ms: result.durationMs,
-        ttft_ms: result.ttftMs,
-        cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,
-        image_cost_usd: imageCostMicroUsd,
-        image_cost_method:
-          imageCostMicroUsd !== null
-            ? imageGenerationCostMethod(args.imageGenerationOptions)
-            : null,
-        effort: args.effort ?? null,
-        // malformed history가 와도 성공한 턴(특히 stream sse.end())을 깨지 않도록 방어.
-        history: ((): { type: string }[] | null => {
-          try {
-            return args.history ? JSON.parse(args.history) : null;
-          } catch {
-            return null;
-          }
-        })(),
-        status: "succeeded",
-        tool_call_count: toolCallCount,
-        // 이미지 turn 식별(R13): quota 소모를 이미지 워크로드에 귀속.
-        is_image_generation: args.imageGeneration ?? false,
-      },
-    ])
-      .then(async (ids) => {
-        const requestLogId = ids[0];
-        if (!requestLogId || imageParts.length === 0) return;
-        for (const step of buildImageGenerationToolSteps(args, imageParts, 0)) {
-          await RequestLogModel.appendStep(requestLogId, step);
-        }
-      })
-      .catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));
+    try {
+      const lifecycle = await afterQuery(requestLogId, stepIndex, args, result);
+      // tool-call requestLogId와 provider threadCoord는 서로 독립적으로 유지한다.
+      const threadCoord = result.runContext?.threadCoord;
+      const runContext =
+        lifecycle.runContext || threadCoord
+          ? { ...lifecycle.runContext, ...(threadCoord ? { threadCoord } : {}) }
+          : undefined;
+      return { ...result, runContext };
+    } catch (e) {
+      logger.error(`query afterQuery failed: ${(e as Error).message}`);
+      await finishRunWithError(requestLogId, (e as Error).message, args);
+      // provider 응답은 성공했으므로 로깅 장애가 생성 결과를 덮어쓰지 않는다.
+      return result;
+    }
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async prepareStream(args: QueryInput): Promise<{ streamId: string }> {
+    rejectLegacyLogMode(args);
     rejectImageGenerationStream(args);
     const streamId = crypto.randomUUID();
     pendingStreams.set(streamId, args);
-    setTimeout(() => pendingStreams.delete(streamId), 30_000);
+    const expiry = setTimeout(() => pendingStreams.delete(streamId), 30_000);
+    expiry.unref?.();
     return { streamId };
   }
 
@@ -211,26 +157,16 @@ class QgridFrameClass extends BaseFrameClass {
     const args = pendingStreams.get(streamId);
     pendingStreams.delete(streamId);
     if (!args) throw new Error("invalid or expired streamId");
+    rejectLegacyLogMode(args);
     rejectImageGenerationStream(args);
 
-    const effectiveLogMode = args.logMode ?? (args.isStep ? "run" : "auto");
-    const shouldLog = effectiveLogMode === "run";
-
-    let runInfo: { requestLogId: number; stepIndex: number } | undefined;
-    if (shouldLog) {
-      try {
-        runInfo = await beforeQuery(args);
-      } catch (e) {
-        logger.error(`stream beforeQuery failed: ${(e as Error).message}`);
-      }
-    }
-
     const ctx = Sonamu.getContext();
     const sse = ctx.createSSE(StreamEvents);
     let threadId: string | undefined;
     let turnId: string | undefined;
     let streamResult: QueryOutput | undefined;
     let streamError: Error | undefined;
+    let clientClosed = false;
     const abortController = new AbortController();
 
     const interruptOpenAI = () => {
@@ -240,26 +176,40 @@ class QgridFrameClass extends BaseFrameClass {
     };
 
     sse.onClose(() => {
+      clientClosed = true;
       abortController.abort();
       interruptOpenAI();
     });
 
+    let runInfo: { requestLogId: number; stepIndex: number } | undefined;
+    if (args.logger !== false) {
+      // provider 실행 전 running row 생성에 실패하면 logged 요청으로 진행하지 않는다.
+      runInfo = await beforeQuery(args);
+    }
+
+    // beforeQuery DB 작업 중 close를 놓치지 않고 provider 실행 전에 마감한다.
+    if (clientClosed || sse.closed) {
+      if (runInfo) await finishRunAborted(runInfo.requestLogId, args);
+      await sse.end();
+      return;
+    }
+
     try {
       await QgridDispatcher.queryStream(
         args,
         {
           onDelta: (text) => {
-            if (!sse.closed) sse.publish("delta", { text });
+            if (!clientClosed && !sse.closed) sse.publish("delta", { text });
           },
           onThreadId: (id) => {
             threadId = id;
-            if (sse.closed && turnId) {
+            if ((clientClosed || sse.closed) && turnId) {
               interruptOpenAI();
             }
           },
           onTurnId: (id) => {
             turnId = id;
-            if (sse.closed && threadId) {
+            if ((clientClosed || sse.closed) && threadId) {
               interruptOpenAI();
             }
           },
@@ -276,38 +226,55 @@ class QgridFrameClass extends BaseFrameClass {
       streamError = e as Error;
     }
 
+    // provider 결과가 없는 close는 즉시 aborted로 마감한다.
+    if (clientClosed && !streamResult) {
+      if (runInfo) await finishRunAborted(runInfo.requestLogId, args);
+      await sse.end();
+      return;
+    }
+
     // dispatcher 완료 후 lifecycle 처리 (await 안전)
     if (streamResult) {
-      // dispatcher 가 실은 thread 재사용 좌표 (auto/run 공통으로 클라에 회송해야 함).
+      // dispatcher 가 실은 thread 재사용 좌표는 logger 설정과 무관하게 회송한다.
       const threadCoord = streamResult.runContext?.threadCoord;
       let runContext: QgridRunContext | undefined =
         threadCoord !== undefined ? { threadCoord } : undefined;
       if (runInfo) {
         try {
+          // close 후 도착한 결과도 step/usage는 남기되, 아래에서 최종 status를 aborted로 덮어쓴다.
           const lifecycle = await afterQuery(
             runInfo.requestLogId,
             runInfo.stepIndex,
             args,
             streamResult,
           );
-          runContext = { ...lifecycle.runContext, threadCoord };
+          runContext =
+            lifecycle.runContext || threadCoord
+              ? { ...lifecycle.runContext, ...(threadCoord ? { threadCoord } : {}) }
+              : undefined;
+
+          // afterQuery가 진행되는 사이 client가 닫힌 경우 완료 상태를 aborted로 되돌린다.
+          if (clientClosed) {
+            await finishRunAborted(runInfo.requestLogId, args);
+            await sse.end();
+            return;
+          }
         } catch (e) {
           logger.error(`stream afterQuery failed: ${(e as Error).message}`);
+          await finishRunWithError(runInfo.requestLogId, (e as Error).message, args);
+
+          if (clientClosed) {
+            await finishRunAborted(runInfo.requestLogId, args);
+            await sse.end();
+            return;
+          }
         }
-      } else if (effectiveLogMode === "auto") {
-        // run lifecycle을 안 타는 단일 stream 요청도 request_log 1건은 남긴다 (query와 대칭).
-        this.saveAutoRequestLog(args, streamResult);
       }
-      if (!sse.closed) sse.publish("done", { ...streamResult, runContext });
+      if (!clientClosed && !sse.closed) sse.publish("done", { ...streamResult, runContext });
     } else if (streamError) {
-      if (sse.closed && streamError.message === "aborted") {
-        if (runInfo) await finishRunAborted(runInfo.requestLogId, args);
-        await sse.end();
-        return;
-      }
       if (runInfo) await finishRunWithError(runInfo.requestLogId, streamError.message, args);
-      if (!sse.closed) sse.publish("error", { message: streamError.message });
-    } else if (sse.closed && runInfo) {
+      if (!clientClosed && !sse.closed) sse.publish("error", { message: streamError.message });
+    } else if ((clientClosed || sse.closed) && runInfo) {
       await finishRunAborted(runInfo.requestLogId, args);
     }
 
@@ -318,7 +285,7 @@ class QgridFrameClass extends BaseFrameClass {
   async createRun(input: CreateRunInput): Promise<{ requestLogId: number }> {
     const requestLogId = await RequestLogModel.createRun({
       user_prompt: input.userPrompt,
-      model_name: input.modelName,
+      requested_model_name: input.modelName,
       effort: input.effort,
       project_name: input.projectName,
       system_prompt: input.systemPrompt,
@@ -332,10 +299,17 @@ class QgridFrameClass extends BaseFrameClass {
     const stepId = await RequestLogModel.appendStep(input.requestLogId, {
       step_index: input.stepIndex,
       type: input.type,
+      model_name: input.modelName,
+      requested_model_name: input.requestedModelName,
+      fallback_count: input.fallbackCount,
       input_tokens: input.inputTokens,
       output_tokens: input.outputTokens,
       cache_read_tokens: input.cacheReadTokens,
       cache_creation_tokens: input.cacheCreationTokens,
+      cache_creation_5m_tokens: input.cacheCreation5mTokens,
+      cache_creation_1h_tokens: input.cacheCreation1hTokens,
+      cost_usd: input.costUsd === undefined ? undefined : Math.round(input.costUsd * MICRO_USD),
+      cost_source: input.costSource,
       duration_ms: input.durationMs,
       ttft_ms: input.ttftMs ?? null,
       finish_reason: input.finishReason,
@@ -358,10 +332,17 @@ class QgridFrameClass extends BaseFrameClass {
       status: input.status,
       response: input.response,
       token_name: input.tokenName,
+      model_name: input.modelName,
+      requested_model_name: input.requestedModelName,
+      fallback_count: input.fallbackCount,
       input_tokens: input.totalInputTokens,
       output_tokens: input.totalOutputTokens,
       cache_read_tokens: input.totalCacheReadTokens,
       cache_creation_tokens: input.totalCacheCreationTokens,
+      cache_creation_5m_tokens: input.totalCacheCreation5mTokens,
+      cache_creation_1h_tokens: input.totalCacheCreation1hTokens,
+      cost_usd: input.costUsd === undefined ? undefined : Math.round(input.costUsd * MICRO_USD),
+      cost_source: input.costSource,
       duration_ms: input.totalDurationMs,
       history: input.history ? JSON.parse(input.history) : undefined,
       error_message: input.errorMessage,

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

@@ -71,9 +71,6 @@ export type QgridInputPart = z.infer<typeof QgridInputPart>;
 
 // ─── Run Lifecycle Context (SDK ↔ Server contract) ───
 
-export const QgridLogMode = z.enum(["auto", "run", "none"]);
-export type QgridLogMode = z.infer<typeof QgridLogMode>;
-
 // codex thread 좌표. thread 재사용으로 conversation_id(=prompt_cache_key)를 고정해
 // OpenAI prompt caching 을 살리기 위한 핸들. 서버가 발급하고 클라가 다음 요청에 그대로 회송한다.
 // 핸들 미전송 시 기존 "매 turn 새 thread + history inject" 동작으로 폴백(QgridRunContext 참조).
@@ -86,7 +83,7 @@ export const QgridThreadCoord = z.object({
 export type QgridThreadCoord = z.infer<typeof QgridThreadCoord>;
 
 export const QgridRunContext = z.object({
-  // run lifecycle(logMode="run") 에서만 발급. auto 모드(예: IF)는 threadCoord 만 왕복.
+  // tool-call run을 계속할 때만 발급. 일반 대화는 threadCoord 만 왕복.
   requestLogId: z.number().optional(),
   threadCoord: QgridThreadCoord.optional(),
 });
@@ -100,46 +97,74 @@ export const QgridToolResultInput = z.object({
 });
 export type QgridToolResultInput = z.infer<typeof QgridToolResultInput>;
 
-export const QueryInput = z.object({
-  system: z.string().optional(),
-  prompt: z.string(),
-  input: z.array(QgridInputPart).optional(),
-  model: z.string().optional(),
-  timeout: z.number().optional(),
-  jsonSchema: z.string().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(),
-  // codex 내장 image_generation tool 을 켠다(OpenAI 경로 전용, opt-in, non-stream).
-  imageGeneration: z.boolean().optional(),
-  // qgrid 가격 추정 및 Codex 이미지 요청 힌트. 이미지 모델은 gpt-image-2 로 고정 가정한다.
-  imageGenerationOptions: ImageGenerationOptions.optional(),
-});
+export const QueryInput = z
+  .looseObject({
+    system: z.string().optional(),
+    prompt: z.string(),
+    input: z.array(QgridInputPart).optional(),
+    model: z.string().optional(),
+    timeout: z.number().optional(),
+    jsonSchema: z.string().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(),
+    // 호환용 필드. 서버 lifecycle 판단에는 사용하지 않는다.
+    isStep: z.boolean().optional(),
+    // 생략하면 로깅한다. false는 request log 쓰기만 끄고 dispatch/thread는 유지한다.
+    logger: z.boolean().optional(),
+    runContext: QgridRunContext.optional(),
+    toolResults: z.array(QgridToolResultInput).optional(),
+    // codex 내장 image_generation tool 을 켠다(OpenAI 경로 전용, opt-in, non-stream).
+    imageGeneration: z.boolean().optional(),
+    // qgrid 가격 추정 및 Codex 이미지 요청 힌트. 이미지 모델은 gpt-image-2 로 고정 가정한다.
+    imageGenerationOptions: ImageGenerationOptions.optional(),
+  })
+  .superRefine((value, ctx) => {
+    if (!Object.hasOwn(value, "logMode")) return;
+    ctx.addIssue({
+      code: "custom",
+      path: ["logMode"],
+      message: "logMode is no longer supported; use logger: false to disable request logging",
+    });
+  });
 export type QueryInput = z.infer<typeof QueryInput>;
 
+export const ModelFallback = z.object({
+  trigger: z.literal("refusal"),
+  fromModel: z.string(),
+  toModel: z.string(),
+  category: z.string().optional(),
+  explanation: z.string().optional(),
+});
+export type ModelFallback = z.infer<typeof ModelFallback>;
+
+export const CostSource = z.enum(["provider", "pricing_table", "mixed"]);
+export type CostSource = z.infer<typeof CostSource>;
+
 export const QueryOutput = z.object({
   text: z.string(),
   content: z.array(QgridContent),
   finishReason: FinishReason,
   tokenName: z.string().optional(),
   model: z.string().optional(),
+  requestedModel: z.string().optional(),
+  modelFallbacks: z.array(ModelFallback).optional(),
   usage: z.object({
     input_tokens: z.number(),
     output_tokens: z.number(),
     cache_creation_input_tokens: z.number(),
+    cache_creation_5m_input_tokens: z.number().optional(),
+    cache_creation_1h_input_tokens: z.number().optional(),
     cache_read_input_tokens: z.number(),
   }),
   durationMs: z.number(),
   ttftMs: z.number(),
   costUsd: z.number(),
+  costSource: CostSource,
   runContext: QgridRunContext.optional(),
 });
 export type QueryOutput = z.infer<typeof QueryOutput>;
@@ -156,17 +181,22 @@ export const StreamEvents = z.object({
   done: z.object({
     text: z.string(),
     model: z.string().optional(),
+    requestedModel: z.string().optional(),
+    modelFallbacks: z.array(ModelFallback).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_creation_5m_input_tokens: z.number().optional(),
+      cache_creation_1h_input_tokens: z.number().optional(),
       cache_read_input_tokens: z.number(),
     }),
     durationMs: z.number(),
     ttftMs: z.number(),
     costUsd: z.number(),
+    costSource: CostSource,
     content: z.array(QgridContent),
     runContext: QgridRunContext.optional(),
   }),
@@ -190,10 +220,17 @@ export const AppendStepInput = z.object({
   requestLogId: z.number(),
   stepIndex: z.number(),
   type: z.enum(["generate", "tool_call"]),
+  modelName: z.string().optional(),
+  requestedModelName: z.string().optional(),
+  fallbackCount: z.number().optional(),
   inputTokens: z.number().optional(),
   outputTokens: z.number().optional(),
   cacheReadTokens: z.number().optional(),
   cacheCreationTokens: z.number().optional(),
+  cacheCreation5mTokens: z.number().optional(),
+  cacheCreation1hTokens: z.number().optional(),
+  costUsd: z.number().optional(),
+  costSource: CostSource.optional(),
   durationMs: z.number().optional(),
   ttftMs: z.number().nullable().optional(),
   finishReason: z.string().optional(),
@@ -214,10 +251,17 @@ export const FinishRunInput = z.object({
   status: z.enum(["succeeded", "error", "aborted"]),
   response: z.string().optional(),
   tokenName: z.string().optional(),
+  modelName: z.string().optional(),
+  requestedModelName: z.string().optional(),
+  fallbackCount: z.number().optional(),
   totalInputTokens: z.number().optional(),
   totalOutputTokens: z.number().optional(),
   totalCacheReadTokens: z.number().optional(),
   totalCacheCreationTokens: z.number().optional(),
+  totalCacheCreation5mTokens: z.number().optional(),
+  totalCacheCreation1hTokens: z.number().optional(),
+  costUsd: z.number().optional(),
+  costSource: CostSource.optional(),
   totalDurationMs: z.number().optional(),
   history: z.string().optional(),
   errorMessage: z.string().optional(),

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

@@ -63,6 +63,7 @@ describe("applyToolCallEmulation image parts", () => {
     durationMs: 10,
     ttftMs: 0,
     costUsd: 0,
+    costSource: "pricing_table" as const,
   };
   const img = { data: "iVBORw0KGgoBAgM", revisedPrompt: "a red circle" };
 

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

@@ -26,9 +26,22 @@
       "toFilter": true,
       "desc": "모델 이름",
       "type": "string",
-      "length": 50,
+      "length": 255,
+      "nullable": true
+    },
+    {
+      "name": "requested_model_name",
+      "desc": "요청 모델 이름 (fallback 전)",
+      "type": "string",
+      "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": "\"\"" },
@@ -41,9 +54,28 @@
       "desc": "캐시 생성 토큰",
       "dbDefault": "0"
     },
+    {
+      "name": "cache_creation_5m_tokens",
+      "type": "integer",
+      "nullable": true,
+      "desc": "5분 TTL 캐시 생성 토큰"
+    },
+    {
+      "name": "cache_creation_1h_tokens",
+      "type": "integer",
+      "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": "cost_source",
+      "type": "string",
+      "length": 20,
+      "nullable": true,
+      "desc": "비용 출처(provider/pricing_table/mixed)"
+    },
     {
       "name": "image_cost_usd",
       "type": "integer",
@@ -102,6 +134,8 @@
       "token_name",
       "project_name",
       "model_name",
+      "requested_model_name",
+      "fallback_count",
       "user_prompt",
       "system_prompt",
       "response",
@@ -109,9 +143,12 @@
       "output_tokens",
       "cache_read_tokens",
       "cache_creation_tokens",
+      "cache_creation_5m_tokens",
+      "cache_creation_1h_tokens",
       "duration_ms",
       "ttft_ms",
       "cost_usd",
+      "cost_source",
       "image_cost_usd",
       "image_cost_method",
       "effort",
@@ -127,13 +164,18 @@
       "token_name",
       "project_name",
       "model_name",
+      "requested_model_name",
+      "fallback_count",
       "input_tokens",
       "output_tokens",
       "cache_read_tokens",
       "cache_creation_tokens",
+      "cache_creation_5m_tokens",
+      "cache_creation_1h_tokens",
       "duration_ms",
       "ttft_ms",
       "cost_usd",
+      "cost_source",
       "image_cost_usd",
       "image_cost_method",
       "effort",