@cartanova/qgrid-cli 2.3.7 → 2.3.8

package/bundle/src/application/qgrid/qgrid.dispatcher.test.ts

@@ -153,6 +153,22 @@ describe("QgridDispatcherClass", () => {
     expect(req.coldInput).toEqual([{ type: "text", text: "next", text_elements: [] }]);
   });
 
+  it("Anthropic query 에도 imageGeneration 플래그를 전달해 provider 가 명시적으로 거부하게 한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (_req: GenerateRequest) =>
+      providerResult({ model: "claude-sonnet-4-6" }),
+    );
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    await dispatcher.query({
+      prompt: "draw",
+      model: "anthropic/claude-sonnet-4-6",
+      imageGeneration: true,
+    });
+
+    expect(generate.mock.calls[0]![0].imageGeneration).toBe(true);
+  });
+
   it("Anthropic queryStream 도 reuse/reuseInput 을 provider 로 전달하지 않고 delta/complete 를 보존한다", async () => {
     const dispatcher = new QgridDispatcherClass();
     const generateStream = vi.fn(async (_req, cb) => {
@@ -195,6 +211,23 @@ describe("QgridDispatcherClass", () => {
     );
   });
 
+  it("Anthropic queryStream 에도 imageGeneration 플래그를 전달해 provider 가 명시적으로 거부하게 한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generateStream = vi.fn(async (_req, _cb) => {});
+    dispatcher.anthropicDispatcher = { generateStream } as never;
+
+    await dispatcher.queryStream(
+      {
+        prompt: "draw",
+        model: "anthropic/claude-sonnet-4-6",
+        imageGeneration: true,
+      },
+      { onDelta: vi.fn(), onComplete: vi.fn(), onError: vi.fn() },
+    );
+
+    expect(generateStream.mock.calls[0]![0].imageGeneration).toBe(true);
+  });
+
   it("jsonSchema 를 required + additionalProperties:false 로 strictify 한다", () => {
     const schema = buildStrictOutputSchema({
       jsonSchema: JSON.stringify({

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

@@ -87,13 +87,17 @@ export class QgridDispatcherClass {
         coldHistory: decision.coldHistory,
         reuse: decision.reuse,
         reuseInput: decision.reuseInput,
+        imageGeneration: input.imageGeneration,
+        imageGenerationOptions: input.imageGenerationOptions,
       });
 
-      return applyToolCallEmulation(
-        toEmulationResult(result),
-        input.tools,
-        issueConvContext(result.threadCoord, decision),
-      );
+      // 이미지 요청은 cold-only(R8)라 재사용 좌표를 발급하지 않는다. 좌표를 실으면
+      // sessionKey 소비자의 warm 좌표를 죽은 좌표로 덮어써 다음 텍스트 turn 이 cold 로 떨어진다.
+      const coord = input.imageGeneration
+        ? undefined
+        : issueConvContext(result.threadCoord, decision);
+
+      return applyToolCallEmulation(toEmulationResult(result), input.tools, coord, result.images);
     } else if (route.provider === "anthropic") {
       if (!this.anthropicDispatcher) throw new QuotaError("Anthropic dispatcher not initialized");
 
@@ -106,6 +110,8 @@ export class QgridDispatcherClass {
         effort: input.effort,
         coldInput: decision.coldInput,
         coldHistory: decision.coldHistory,
+        imageGeneration: input.imageGeneration,
+        imageGenerationOptions: input.imageGenerationOptions,
       });
 
       return applyToolCallEmulation(
@@ -144,6 +150,9 @@ export class QgridDispatcherClass {
           reuse: decision.reuse,
           reuseInput: decision.reuseInput,
           abortSignal,
+          // 이미지 플래그를 전달해야 generateStream 의 non-stream 전용 거부(R2)가 발동한다.
+          imageGeneration: input.imageGeneration,
+          imageGenerationOptions: input.imageGenerationOptions,
         },
         {
           onDelta: cb.onDelta,
@@ -175,6 +184,8 @@ export class QgridDispatcherClass {
           coldInput: decision.coldInput,
           coldHistory: decision.coldHistory,
           abortSignal,
+          imageGeneration: input.imageGeneration,
+          imageGenerationOptions: input.imageGenerationOptions,
         },
         {
           onDelta: cb.onDelta,

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

@@ -7,6 +7,7 @@ const {
   findManyMock,
   saveMock,
   requestLogSaveMock,
+  appendStepMock,
   dispatcherQueryMock,
   getRateLimitsByTokenIdMock,
 } = vi.hoisted(() => ({
@@ -14,6 +15,7 @@ const {
   findManyMock: vi.fn(),
   saveMock: vi.fn(),
   requestLogSaveMock: vi.fn(),
+  appendStepMock: vi.fn(),
   dispatcherQueryMock: vi.fn(),
   getRateLimitsByTokenIdMock: vi.fn(),
 }));
@@ -22,6 +24,7 @@ vi.mock("../request-log/request-log.model", () => ({
   MICRO_USD: 1_000_000,
   RequestLogModel: {
     save: requestLogSaveMock,
+    appendStep: appendStepMock,
   },
 }));
 
@@ -65,6 +68,8 @@ describe("QgridFrame.updateToken", () => {
     saveMock.mockResolvedValue([1]);
     requestLogSaveMock.mockReset();
     requestLogSaveMock.mockResolvedValue([1]);
+    appendStepMock.mockReset();
+    appendStepMock.mockResolvedValue(1);
     dispatcherQueryMock.mockReset();
   });
 
@@ -138,6 +143,79 @@ describe("QgridFrame.query auto logging", () => {
       expect.objectContaining({ ttft_ms: 0 }),
     ]);
   });
+
+  it("persists image parts in response as data-url img tags", async () => {
+    dispatcherQueryMock.mockResolvedValueOnce({
+      ...queryOutput(39),
+      text: "image ready",
+      content: [
+        { type: "text", text: "image ready" },
+        { type: "image", data: "iVBORw0KGgoBAgM", revisedPrompt: "green triangle" },
+      ],
+    });
+
+    await QgridFrame.query({
+      prompt: "draw",
+      model: "openai/gpt-5-codex",
+      logMode: "auto",
+      imageGeneration: true,
+    });
+
+    expect(requestLogSaveMock).toHaveBeenCalledWith([
+      expect.objectContaining({
+        response:
+          'image ready\n<img src="data:image/png;base64,iVBORw0KGgoBAgM" alt="green triangle" />',
+        tool_call_count: 0,
+        is_image_generation: true,
+        image_cost_usd: 41000,
+        image_cost_method: "assumed:gpt-image-2:medium:1536x1024:png",
+      }),
+    ]);
+    expect(appendStepMock).toHaveBeenCalledWith(
+      1,
+      expect.objectContaining({
+        step_index: 0,
+        type: "tool_call",
+        tool_call_index: 0,
+        tool_call_id: "image_generation:0:0",
+        tool_name: "image_generation",
+        tool_args: JSON.stringify({
+          prompt: "draw",
+          driverModel: "openai/gpt-5-codex",
+          tool: {
+            type: "image_generation",
+            outputFormat: "png",
+          },
+          pricingAssumption: {
+            model: "gpt-image-2",
+            quality: "medium",
+            size: "1536x1024",
+          },
+        }),
+        tool_result: '<img src="data:image/png;base64,iVBORw0KGgoBAgM" alt="green triangle" />',
+      }),
+    );
+  });
+});
+
+describe("QgridFrame.prepareStream", () => {
+  beforeEach(() => {
+    dispatcherQueryMock.mockReset();
+    requestLogSaveMock.mockReset();
+  });
+
+  it("rejects imageGeneration before creating an SSE stream", async () => {
+    await expect(
+      QgridFrame.prepareStream({
+        prompt: "draw",
+        model: "openai/gpt-5-codex",
+        imageGeneration: true,
+      }),
+    ).rejects.toThrow(/imageGeneration is not supported with streaming/);
+
+    expect(dispatcherQueryMock).not.toHaveBeenCalled();
+    expect(requestLogSaveMock).not.toHaveBeenCalled();
+  });
 });
 
 describe("QgridFrame.usage", () => {

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

@@ -33,6 +33,16 @@ import {
   finishRunAborted,
   finishRunWithError,
 } from "./qgrid-run-lifecycle";
+import {
+  formatImagePartForLog,
+  formatResponseForLog,
+  getImageParts,
+  imageGenerationToolArgs,
+} from "./qgrid-response-format";
+import {
+  estimateImageGenerationCostMicroUsd,
+  imageGenerationCostMethod,
+} from "./qgrid-image-generation";
 import { QgridDispatcher } from "./qgrid.dispatcher";
 import {
   type QueryInput,
@@ -90,6 +100,13 @@ function getOAuthRedirectUri(): string {
   return `http://localhost:${serverPort}/callback`;
 }
 
+function rejectImageGenerationStream(args: QueryInput): void {
+  if (!args.imageGeneration) return;
+  throw new BadRequestException(
+    "qgrid: imageGeneration is not supported with streaming; use query/generateText instead." as LocalizedString,
+  );
+}
+
 const logger = getLogger(["qgrid"]);
 const oauthLogger = getLogger(["qgrid", "oauth"]);
 
@@ -132,11 +149,13 @@ class QgridFrameClass extends BaseFrameClass {
   // 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 = result.content
-      .filter((item) => item.type === "text")
-      .map((item) => item.text)
-      .join("\n");
+    const responseText = formatResponseForLog(result);
 
     RequestLogModel.save([
       {
@@ -153,6 +172,9 @@ class QgridFrameClass extends BaseFrameClass {
         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 => {
@@ -164,12 +186,32 @@ class QgridFrameClass extends BaseFrameClass {
         })(),
         status: "succeeded",
         tool_call_count: toolCallCount,
+        // 이미지 turn 식별(R13): quota 소모를 이미지 워크로드에 귀속.
+        is_image_generation: args.imageGeneration ?? false,
       },
-    ]).catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));
+    ])
+      .then(async (ids) => {
+        const requestLogId = ids[0];
+        if (!requestLogId || imageParts.length === 0) return;
+        for (let i = 0; i < imageParts.length; i++) {
+          const image = imageParts[i]!;
+          await RequestLogModel.appendStep(requestLogId, {
+            step_index: 0,
+            type: "tool_call",
+            tool_call_index: i,
+            tool_call_id: `image_generation:0:${i}`,
+            tool_name: "image_generation",
+            tool_args: imageGenerationToolArgs(args),
+            tool_result: formatImagePartForLog(image),
+          });
+        }
+      })
+      .catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));
   }
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async prepareStream(args: QueryInput): Promise<{ streamId: string }> {
+    rejectImageGenerationStream(args);
     const streamId = crypto.randomUUID();
     pendingStreams.set(streamId, args);
     setTimeout(() => pendingStreams.delete(streamId), 30_000);
@@ -181,6 +223,7 @@ class QgridFrameClass extends BaseFrameClass {
     const args = pendingStreams.get(streamId);
     pendingStreams.delete(streamId);
     if (!args) throw new Error("invalid or expired streamId");
+    rejectImageGenerationStream(args);
 
     const effectiveLogMode = args.logMode ?? (args.isStep ? "run" : "auto");
     const shouldLog = effectiveLogMode === "run";

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

@@ -23,6 +23,12 @@ export const QgridContent = z.discriminatedUnion("type", [
     toolName: z.string(),
     input: z.string(),
   }),
+  z.object({
+    type: z.literal("image"),
+    // Codex image_generation result base64. qgrid 는 포맷/확장자 책임을 지지 않는다.
+    data: z.string(),
+    revisedPrompt: z.string().nullish(),
+  }),
 ]);
 export type QgridContent = z.infer<typeof QgridContent>;
 
@@ -38,6 +44,18 @@ export type ReasoningSummary = z.infer<typeof ReasoningSummary>;
 export const ServiceTier = z.enum(["fast", "flex"]);
 export type ServiceTier = z.infer<typeof ServiceTier>;
 
+export const ImageGenerationQuality = z.enum(["low", "medium", "high"]);
+export type ImageGenerationQuality = z.infer<typeof ImageGenerationQuality>;
+
+export const ImageGenerationSize = z.enum(["1024x1024", "1024x1536", "1536x1024"]);
+export type ImageGenerationSize = z.infer<typeof ImageGenerationSize>;
+
+export const ImageGenerationOptions = z.object({
+  quality: ImageGenerationQuality.optional(),
+  size: ImageGenerationSize.optional(),
+});
+export type ImageGenerationOptions = z.infer<typeof ImageGenerationOptions>;
+
 // ─── Run Lifecycle Context (SDK ↔ Server contract) ───
 
 export const QgridLogMode = z.enum(["auto", "run", "none"]);
@@ -86,6 +104,10 @@ export const QueryInput = z.object({
   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 type QueryInput = z.infer<typeof QueryInput>;
 

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

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 
 import { type QgridTool } from "./qgrid.types";
-import { buildToolCallSchema } from "./tool-emulation";
+import { applyToolCallEmulation, buildToolCallSchema } from "./tool-emulation";
 
 describe("buildToolCallSchema", () => {
   it("documents that emulated tools must be requested through StructuredOutput", () => {
@@ -48,3 +48,46 @@ describe("buildToolCallSchema", () => {
     ).toContain("getWeather");
   });
 });
+
+describe("applyToolCallEmulation image parts", () => {
+  const baseResult = {
+    text: "here is your image",
+    tokenName: "token",
+    model: "gpt-5.5",
+    usage: {
+      input_tokens: 1,
+      output_tokens: 1,
+      cache_creation_input_tokens: 0,
+      cache_read_input_tokens: 0,
+    },
+    durationMs: 10,
+    ttftMs: 0,
+    costUsd: 0,
+  };
+  const img = { data: "iVBORw0KGgoBAgM", revisedPrompt: "a red circle" };
+
+  it("appends an image part after text when images are present (no tools)", () => {
+    const out = applyToolCallEmulation(baseResult, undefined, undefined, [img]);
+    expect(out.content).toEqual([
+      { type: "text", text: "here is your image" },
+      { type: "image", data: "iVBORw0KGgoBAgM", revisedPrompt: "a red circle" },
+    ]);
+    // 이미지는 finishReason 과 직교 — 여전히 stop.
+    expect(out.finishReason).toBe("stop");
+  });
+
+  it("appends multiple images preserving order", () => {
+    const out = applyToolCallEmulation(baseResult, undefined, undefined, [
+      { data: "iVBORw0KGgoAAA", revisedPrompt: "one" },
+      { data: "iVBORw0KGgoBBB", revisedPrompt: "two" },
+    ]);
+    const images = out.content.filter((c) => c.type === "image");
+    expect(images).toHaveLength(2);
+    expect(images.map((c) => (c.type === "image" ? c.revisedPrompt : null))).toEqual(["one", "two"]);
+  });
+
+  it("leaves content unchanged when no images are passed (regression guard)", () => {
+    const out = applyToolCallEmulation(baseResult, undefined, undefined);
+    expect(out.content).toEqual([{ type: "text", text: "here is your image" }]);
+  });
+});

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

@@ -16,6 +16,27 @@ type ToolCallResponse = {
   toolCalls?: Array<{ toolName: string; args: string }> | null;
 };
 
+// dispatcher 가 넘기는 이미지 결과. qgrid 는 base64 payload 만 전달하고 포맷은 보장하지 않는다.
+export interface EmulationImage {
+  data: string;
+  revisedPrompt?: string | null;
+}
+
+// 조립된 content 뒤에 이미지 파트를 append 한다. 모든 반환 분기가 공유.
+function appendImages(content: QgridContent[], images?: EmulationImage[]): QgridContent[] {
+  if (!images?.length) return content;
+  return [
+    ...content,
+    ...images.map(
+      (img): QgridContent => ({
+        type: "image",
+        data: img.data,
+        revisedPrompt: img.revisedPrompt ?? null,
+      }),
+    ),
+  ];
+}
+
 export function buildToolCallSchema(tools: QgridTool[]): JsonValue {
   const toolDescriptions = tools
     .map((tool) => {
@@ -72,13 +93,15 @@ export function applyToolCallEmulation(
   result: Omit<QueryOutput, "content" | "finishReason" | "runContext">,
   tools?: QgridTool[],
   threadCoord?: QgridThreadCoord,
+  images?: EmulationImage[],
 ): QueryOutput {
   // thread 재사용 좌표를 runContext 로 실어 올린다 (auto 모드는 requestLogId 없이 threadCoord 만).
   const runContext = threadCoord ? { threadCoord } : undefined;
+  // 이미지는 finishReason 과 직교하는 content 파트. 조립된 content 뒤에 append 한다.
 
   if (!tools?.length) {
     const content: QgridContent[] = [{ type: "text", text: result.text }];
-    return { ...result, content, finishReason: "stop", runContext };
+    return { ...result, content: appendImages(content, images), finishReason: "stop", runContext };
   }
 
   let parsed: ToolCallResponse;
@@ -88,7 +111,7 @@ export function applyToolCallEmulation(
     logger.warn(`tool-call emulation parse failed, falling back to text: ${(e as Error).message}`);
     return {
       ...result,
-      content: [{ type: "text", text: result.text }],
+      content: appendImages([{ type: "text", text: result.text }], images),
       finishReason: "stop",
       runContext,
     };
@@ -108,14 +131,14 @@ export function applyToolCallEmulation(
         input: toolCall.args,
       };
     });
-    return { ...result, content, finishReason: "tool-calls", runContext };
+    return { ...result, content: appendImages(content, images), finishReason: "tool-calls", runContext };
   }
 
   const text = parsed.answer ?? result.text;
   return {
     ...result,
     text,
-    content: [{ type: "text", text }],
+    content: appendImages([{ type: "text", text }], images),
     finishReason: "stop",
     runContext,
   };

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

@@ -44,6 +44,19 @@
     { "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": "image_cost_usd",
+      "type": "integer",
+      "nullable": true,
+      "desc": "이미지 생성 추정 비용"
+    },
+    {
+      "name": "image_cost_method",
+      "type": "string",
+      "length": 100,
+      "nullable": true,
+      "desc": "이미지 비용 추정 방식"
+    },
     { "name": "effort", "type": "string", "length": 10, "nullable": true, "desc": "effort level" },
     {
       "name": "history",
@@ -60,7 +73,13 @@
       "dbDefault": "\"succeeded\""
     },
     { "name": "error_message", "type": "string", "nullable": true, "desc": "에러 메시지" },
-    { "name": "tool_call_count", "type": "integer", "desc": "tool call 횟수", "dbDefault": "0" }
+    { "name": "tool_call_count", "type": "integer", "desc": "tool call 횟수", "dbDefault": "0" },
+    {
+      "name": "is_image_generation",
+      "type": "boolean",
+      "desc": "이미지 생성 turn 여부 (quota 귀속용)",
+      "dbDefault": "false"
+    }
   ],
   "indexes": [
     {
@@ -77,57 +96,64 @@
     }
   ],
   "subsets": {
-    "A": {
-      "fields": [
-        "id",
-        "created_at",
-        "token_name",
-        "project_name",
-        "model_name",
-        "user_prompt",
-        "system_prompt",
-        "response",
-        "input_tokens",
-        "output_tokens",
-        "cache_read_tokens",
-        "cache_creation_tokens",
-        "duration_ms",
-        "ttft_ms",
-        "cost_usd",
-        "effort",
-        "history",
-        "status",
-        "error_message",
-        "tool_call_count"
-      ]
-    },
-    "P": {
-      "fields": [
-        "id",
-        "created_at",
-        "token_name",
-        "project_name",
-        "model_name",
-        "input_tokens",
-        "output_tokens",
-        "cache_read_tokens",
-        "cache_creation_tokens",
-        "duration_ms",
-        "ttft_ms",
-        "cost_usd",
-        "effort",
-        "status",
-        "tool_call_count"
-      ]
-    }
+    "A": [
+      "id",
+      "created_at",
+      "token_name",
+      "project_name",
+      "model_name",
+      "user_prompt",
+      "system_prompt",
+      "response",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "duration_ms",
+      "ttft_ms",
+      "cost_usd",
+      "image_cost_usd",
+      "image_cost_method",
+      "effort",
+      "history",
+      "status",
+      "error_message",
+      "tool_call_count",
+      "is_image_generation"
+    ],
+    "P": [
+      "id",
+      "created_at",
+      "token_name",
+      "project_name",
+      "model_name",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "duration_ms",
+      "ttft_ms",
+      "cost_usd",
+      "image_cost_usd",
+      "image_cost_method",
+      "effort",
+      "status",
+      "tool_call_count",
+      "is_image_generation"
+    ]
   },
   "enums": {
-    "RequestLogOrderBy": { "values": { "id-desc": "ID최신순" } },
+    "RequestLogOrderBy": { "id-desc": "ID최신순" },
     "RequestLogSearchField": {
-      "values": { "id": "ID", "token_name": "토큰이름", "user_prompt": "사용자 프롬프트" }
+      "id": "ID",
+      "token_name": "토큰이름",
+      "user_prompt": "사용자 프롬프트"
     },
     "RequestLogStatus": {
-      "values": { "running": "실행 중", "succeeded": "성공", "error": "에러", "aborted": "중단" }
+      "running": "실행 중",
+      "succeeded": "성공",
+      "error": "에러",
+      "aborted": "중단"
     }
   }
 }

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

@@ -209,6 +209,7 @@ class RequestLogModelClass extends BaseModelClass<
     effort?: string | null;
     project_name?: string | null;
     history?: unknown;
+    is_image_generation?: boolean;
   }): Promise<number> {
     const wdb = this.getPuri("w");
     wdb.ubRegister("request_logs", {
@@ -225,6 +226,8 @@ class RequestLogModelClass extends BaseModelClass<
       cache_creation_tokens: 0,
       duration_ms: 0,
       tool_call_count: 0,
+      // 이미지 turn 식별(R13). run 경로(tools+image 조합)도 auto 경로와 동일하게 마킹.
+      is_image_generation: params.is_image_generation ?? false,
       ...(params.history !== undefined ? { history: params.history as { type: string }[] } : {}),
     });
     return wdb.transaction(async (trx) => {
@@ -259,6 +262,8 @@ class RequestLogModelClass extends BaseModelClass<
       history?: unknown;
       error_message?: string;
       tool_call_count?: number;
+      image_cost_usd?: number | null;
+      image_cost_method?: string | null;
     },
   ): Promise<void> {
     if (params.status === "succeeded" && !params.token_name) {
@@ -275,6 +280,8 @@ class RequestLogModelClass extends BaseModelClass<
       "duration_ms",
       "error_message",
       "tool_call_count",
+      "image_cost_usd",
+      "image_cost_method",
     ] as const;
     for (const key of fields) {
       if (params[key] !== undefined) update[key] = params[key];