@cartanova/qgrid-cli 2.10.5 → 2.10.6

package/bundle/src/application/qgrid/qgrid-run-lifecycle.ts

@@ -100,12 +100,12 @@ export async function beforeQuery(args: QueryInput): Promise<{
   return { requestLogId, stepIndex };
 }
 
-export async function afterQuery(
+async function appendGenerateStep(
   requestLogId: number,
   stepIndex: number,
   args: QueryInput,
   result: QueryOutput,
-): Promise<RunLifecycleResult> {
+) {
   // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.
   const requestedModelName = withProviderPrefix(
     args.model,
@@ -132,6 +132,21 @@ export async function afterQuery(
     ttft_ms: result.ttftMs,
     finish_reason: result.finishReason,
   });
+  return { requestedModelName, servedModelName };
+}
+
+export async function afterQuery(
+  requestLogId: number,
+  stepIndex: number,
+  args: QueryInput,
+  result: QueryOutput,
+): Promise<RunLifecycleResult> {
+  const { requestedModelName, servedModelName } = await appendGenerateStep(
+    requestLogId,
+    stepIndex,
+    args,
+    result,
+  );
 
   const imageParts = getImageParts(result);
   const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(
@@ -200,12 +215,17 @@ export async function finishRunWithError(
   requestLogId: number,
   errorMessage: string,
   args?: QueryInput,
+  completedStep?: { stepIndex: number; result: QueryOutput },
 ): Promise<void> {
-  await finishTerminalRun(requestLogId, "error", errorMessage, args);
+  await finishTerminalRun(requestLogId, "error", errorMessage, args, completedStep);
 }
 
-export async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {
-  await finishTerminalRun(requestLogId, "aborted", "client disconnected", args);
+export async function finishRunAborted(
+  requestLogId: number,
+  args?: QueryInput,
+  completedStep?: { stepIndex: number; result: QueryOutput },
+): Promise<void> {
+  await finishTerminalRun(requestLogId, "aborted", "client disconnected", args, completedStep);
 }
 
 async function finishTerminalRun(
@@ -213,8 +233,18 @@ async function finishTerminalRun(
   status: "error" | "aborted",
   errorMessage: string,
   args?: QueryInput,
+  completedStep?: { stepIndex: number; result: QueryOutput },
 ): Promise<void> {
   try {
+    if (completedStep && args) {
+      try {
+        await appendGenerateStep(requestLogId, completedStep.stepIndex, args, completedStep.result);
+      } catch (e) {
+        logger.error(
+          `appendGenerateStep failed while finishing ${status}: ${(e as Error).message}`,
+        );
+      }
+    }
     let aggregate: Awaited<ReturnType<typeof RequestLogModel.aggregateStepUsage>> | undefined;
     try {
       aggregate = await RequestLogModel.aggregateStepUsage(requestLogId);
@@ -226,6 +256,16 @@ async function finishTerminalRun(
       status,
       error_message: errorMessage,
       history: args ? filterHistoryForStorage(args.history) : undefined,
+      ...(completedStep
+        ? {
+            token_name: completedStep.result.tokenName,
+            requested_model_name: withProviderPrefix(
+              args?.model,
+              args?.model ?? completedStep.result.requestedModel ?? completedStep.result.model,
+            ),
+            model_name: withProviderPrefix(args?.model, completedStep.result.model),
+          }
+        : {}),
       ...(aggregate
         ? {
             input_tokens: aggregate.input_tokens,

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

@@ -6,10 +6,12 @@ import {
   type GenerateStreamCallbacks,
 } from "../../utils/providers/common/provider-dispatcher";
 import { systemHash } from "./conv-routing";
-import { OpenAIDispatcher } from "../../utils/providers/openai/openai-dispatcher";
+import { ImageGenerationError, OpenAIDispatcher } from "../../utils/providers/openai/openai-dispatcher";
 import { normalizeOpenAIEvent } from "../../utils/providers/openai/openai-backend-protocol";
-import { buildStrictOutputSchema, QgridDispatcherClass } from "./qgrid.dispatcher";
+import { buildStrictOutputSchema, completedDriverFromImageFailure, QgridDispatcherClass } from "./qgrid.dispatcher";
 import { QueryInput, type QueryOutput } from "./qgrid.types";
+import { PNG } from "pngjs";
+import { estimateImageGenerationCostMicroUsd } from "./qgrid-image-generation";
 import { type TokenSubsetA } from "../sonamu.generated";
 
 function providerResult(overrides: Partial<GenerateResult> = {}): GenerateResult {
@@ -36,6 +38,138 @@ function deeplyNestedOutputSchema(depth: number): string {
 }
 
 describe("QgridDispatcherClass", () => {
+  it("prices only the completed chat driver from an image failure", () => {
+    const error = new ImageGenerationError("incomplete", "images unavailable");
+    error.completedDriver = providerResult({
+      model: "gpt-6-luna", requestedModel: "gpt-6-astra", ttftMs: 4,
+      usage: { totalTokens: 120, inputTokens: 100, outputTokens: 20, cachedInputTokens: 10, reasoningOutputTokens: 5 },
+    });
+    const result = completedDriverFromImageFailure(error)!;
+    expect(result).toMatchObject({
+      model: "gpt-6-luna", requestedModel: "gpt-6-astra", tokenName: "provider/test",
+      usage: { input_tokens: 100, output_tokens: 20, cache_read_input_tokens: 10, reasoning_tokens: 5 },
+      costSource: "pricing_table", finishReason: "stop", durationMs: 12, ttftMs: 4,
+      content: [{ type: "text", text: "ok" }],
+    });
+    expect(result.costUsd).toBeCloseTo(0.0000191, 10);
+    expect(estimateImageGenerationCostMicroUsd(result, undefined)).toBeNull();
+    expect(result.runContext).toBeUndefined();
+    expect(completedDriverFromImageFailure(new Error("failed"))).toBeUndefined();
+    expect(completedDriverFromImageFailure(new ImageGenerationError("gate", "invalid"))).toBeUndefined();
+  });
+  it.each([
+    [false, 0, "generations"],
+    [false, 2, "edits"],
+    [true, 1, "edits"],
+  ] as const)("auto chat uses Images %s/%s/%s and keeps both usages", async (transparent, referenceCount, endpoint) => {
+    const png = new PNG({ width: 2, height: 1 });
+    png.data.set([0, 0, 0, transparent ? 0 : 255, 255, 0, 0, 255]);
+    const imageUsage = {
+      input_tokens: 10, output_tokens: 100, total_tokens: 110,
+      input_tokens_details: { text_tokens: 4, image_tokens: 6 },
+    };
+    const fetchMock = vi.fn(async (url: string | URL | Request, _init?: RequestInit) => {
+      if (String(url).endsWith("/responses")) {
+        const events = [
+          { type: "response.output_item.done", item: {
+            type: "function_call", call_id: "image-call", name: "generate_image",
+            arguments: JSON.stringify({ prompt: "A red square", transparent_background: transparent, num_last_images_to_include: referenceCount }),
+          } },
+          { type: "response.completed", response: {
+            id: "driver", model: "gpt-6-luna",
+            usage: { input_tokens: 100, output_tokens: 20, total_tokens: 120 },
+          } },
+        ];
+        return new Response(events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join(""), { headers: { "content-type": "text/event-stream" } });
+      }
+      return Response.json({
+        data: [{ b64_json: PNG.sync.write(png).toString("base64") }],
+        background: transparent ? "transparent" : "opaque", quality: "medium", usage: imageUsage,
+      });
+    });
+    const provider = new OpenAIDispatcher("https", { fetch: fetchMock });
+    await provider.onTokenAdded(1, "chat-token", {
+      accessToken: "test-access", refreshToken: "", accountId: "test-account", accessTokenExpiresAt: Date.now() + 60000,
+    });
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.openaiDispatcher = provider;
+    try {
+      const result = await dispatcher.query({
+        model: "openai/gpt-6-luna", prompt: "Draw or edit a square", imageGeneration: "auto",
+        history: JSON.stringify([{ type: "message", role: "user", content: [{ type: "input_image", image_url: "https://example.com/old.png" }] }]),
+        input: [{ type: "image", url: "https://example.com/new.png" }],
+      });
+      expect(fetchMock.mock.calls.map(([url]) => url)).toEqual([
+        "https://chatgpt.com/backend-api/codex/responses",
+        `https://chatgpt.com/backend-api/codex/images/${endpoint}`,
+      ]);
+      const driverInit = fetchMock.mock.calls[0]![1]!;
+      const imageInit = fetchMock.mock.calls[1]![1]!;
+      expect(JSON.parse(String(driverInit.body)).tools).toEqual([
+        expect.objectContaining({ type: "function", name: "generate_image" }),
+      ]);
+      const imageBody = JSON.parse(String(imageInit.body));
+      expect(imageBody).toMatchObject({ model: "gpt-image-2", background: transparent ? "transparent" : "opaque" });
+      expect(imageBody.prompt).toContain("A red square");
+      expect(imageBody.prompt).not.toContain("Draw or edit a square");
+      const refs = ["https://example.com/old.png", "https://example.com/new.png"].slice(-referenceCount);
+      expect(imageBody.images).toEqual(referenceCount ? refs.map((image_url) => ({ image_url })) : undefined);
+      expect(imageInit.signal).toBe(driverInit.signal);
+      expect(new Headers(imageInit.headers).get("authorization")).toBe(new Headers(driverInit.headers).get("authorization"));
+      expect(result).toMatchObject({ model: "gpt-6-luna", usage: { input_tokens: 100, output_tokens: 20 } });
+      expect(result.costUsd).toBeCloseTo(0.00002, 8);
+      expect(result.content.find((item) => item.type === "image")).toMatchObject({ generation: { route: "codex-images", usage: imageUsage } });
+      expect(estimateImageGenerationCostMicroUsd(result, undefined)).toBe(3068);
+    } finally {
+      await provider.stop();
+    }
+  });
+
+  it("routes the image model straight to subscription edits and keeps image usage separate", async () => {
+    const png = new PNG({ width: 1, height: 1 });
+    png.data.set([255, 0, 0, 255]);
+    const base64 = PNG.sync.write(png).toString("base64");
+    const usage = {
+      input_tokens: 10, output_tokens: 100, total_tokens: 110,
+      input_tokens_details: { text_tokens: 4, image_tokens: 6 },
+    };
+    const fetchMock = vi.fn(async () => new Response(JSON.stringify({
+      data: [{ b64_json: base64 }], usage, background: "opaque", quality: "medium",
+    })));
+    const provider = new OpenAIDispatcher("https", { fetch: fetchMock });
+    await provider.onTokenAdded(1, "test", {
+      accessToken: "unused", refreshToken: "", accountId: "unused",
+      accessTokenExpiresAt: Date.now() + 60000,
+    });
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.openaiDispatcher = provider;
+    try {
+      const result = await dispatcher.query({
+        model: "openai/gpt-image-2", prompt: "recolor", imageGeneration: true,
+        input: [
+          { type: "text", text: "recolor", text_elements: [] },
+          { type: "image", url: `data:image/png;base64,${base64}` },
+        ],
+      });
+      expect(fetchMock).toHaveBeenCalledOnce();
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://chatgpt.com/backend-api/codex/images/edits",
+        expect.objectContaining({ method: "POST", signal: expect.any(AbortSignal) }),
+      );
+      expect(result).toMatchObject({
+        model: "gpt-image-2", costUsd: 0,
+        usage: { input_tokens: 0, output_tokens: 0 },
+        content: expect.arrayContaining([expect.objectContaining({
+          type: "image", mediaType: "image/png",
+          generation: { route: "codex-images", model: "gpt-image-2", background: "opaque", size: "1x1", quality: "medium", usage },
+        })]),
+      });
+      expect(result.runContext?.threadCoord).toBeUndefined();
+    } finally {
+      await provider.stop();
+    }
+  });
+
   it.each(["generate", "stream"])("%s yields a completed tool-call message before a speculative later answer", async (mode) => {
     const tool = JSON.stringify({result: {action: "tool_call", answer: null, toolCalls: [{toolName: "lookupMarker", args: "{}"}]}});
     const answer = JSON.stringify({result: {action: "answer", answer: {marker: ""}, toolCalls: null}});

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

@@ -17,7 +17,10 @@ import {
   serializeAndValidateDispatchSchema,
 } from "../../utils/providers/common/schema-validation";
 import { strictify } from "../../utils/providers/common/strictifier";
-import { type OpenAIDispatcher } from "../../utils/providers/openai/openai-dispatcher";
+import {
+  ImageGenerationError,
+  type OpenAIDispatcher,
+} from "../../utils/providers/openai/openai-dispatcher";
 import { type TokenSubsetA } from "../sonamu.generated";
 import { decideConvRouting, issueConvContext } from "./conv-routing";
 import {
@@ -325,6 +328,13 @@ function buildRawOutputSchema(
     : callerOutputSchema;
 }
 
+export function completedDriverFromImageFailure(error: unknown): QueryOutput | undefined {
+  if (!(error instanceof ImageGenerationError) || !error.completedDriver) return undefined;
+  return applyToolCallEmulation(toEmulationResult(error.completedDriver), undefined, {
+    answerKind: "text",
+  });
+}
+
 // Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.
 function toEmulationResult(
   result: GenerateResult,

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

@@ -5,6 +5,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { QgridFrame } from "./qgrid.frame";
 import { QueryInput } from "./qgrid.types";
+import { ImageGenerationError } from "../../utils/providers/openai/openai-dispatcher";
 
 const {
   findOneMock,
@@ -213,6 +214,7 @@ describe("QgridFrame.query request logging", () => {
     beforeQueryMock.mockReset().mockResolvedValue({ requestLogId: 41, stepIndex: 0 });
     afterQueryMock.mockReset().mockResolvedValue({});
     finishRunWithErrorMock.mockReset();
+    finishRunAbortedMock.mockReset();
     dispatcherQueryMock.mockReset();
     findActiveByProviderAndNameMock.mockReset();
   });
@@ -385,6 +387,45 @@ describe("QgridFrame.query request logging", () => {
     expect(finishRunWithErrorMock).toHaveBeenCalledWith(41, "provider failed", args);
   });
 
+  it.each(["error", "abort", "logger-disabled"])("handles completed driver accounting on image %s", async (mode) => {
+    const requestRaw = Object.assign(new EventEmitter(), { aborted: false });
+    const responseRaw = Object.assign(new EventEmitter(), { destroyed: false, writableEnded: false });
+    vi.spyOn(Sonamu, "getContext").mockReturnValue({
+      transport: "http", request: { raw: requestRaw }, reply: { raw: responseRaw },
+    } as never);
+    const error = new ImageGenerationError("incomplete", "image failed");
+    error.completedDriver = {
+      text: "drawing", tokenName: "one", model: "gpt-6-luna", durationMs: 20, ttftMs: 2,
+      threadCoord: { workerId: 1, threadId: "", epoch: -1 },
+      usage: { inputTokens: 100, outputTokens: 20, cachedInputTokens: 0, reasoningOutputTokens: 0, totalTokens: 120 },
+    };
+    dispatcherQueryMock.mockImplementationOnce(async () => {
+      if (mode === "abort") { responseRaw.destroyed = true; responseRaw.emit("close"); }
+      throw error;
+    });
+    const args = {
+      prompt: "draw", model: "openai/gpt-6-luna", imageGeneration: "auto" as const,
+      ...(mode === "logger-disabled" ? { logger: false } : {}),
+    };
+    await expect(QgridFrame.query(args)).rejects.toBe(error);
+    expect(afterQueryMock).not.toHaveBeenCalled();
+    if (mode === "logger-disabled") {
+      expect(beforeQueryMock).not.toHaveBeenCalled();
+      expect(finishRunWithErrorMock).not.toHaveBeenCalled();
+      expect(finishRunAbortedMock).not.toHaveBeenCalled();
+    } else {
+      const completedStep = expect.objectContaining({
+        stepIndex: 0,
+        result: expect.objectContaining({
+          model: "gpt-6-luna", tokenName: "one", costUsd: 0.00002,
+          usage: expect.objectContaining({ input_tokens: 100, output_tokens: 20 }),
+        }),
+      });
+      if (mode === "abort") expect(finishRunAbortedMock).toHaveBeenCalledWith(41, args, completedStep);
+      else expect(finishRunWithErrorMock).toHaveBeenCalledWith(41, "image failed", args, completedStep);
+    }
+  });
+
   it("marks an incoherent structured envelope failure as a request-log error", async () => {
     const error = new Error(
       "tool-call emulation: structured response envelope is missing required keys: toolCalls",
@@ -775,6 +816,32 @@ describe("QgridFrame.query request logging", () => {
     expect(QueryInput.safeParse({ prompt: "hi", logger: false }).success).toBe(true);
   });
 
+  it.each([
+    { imageGeneration: undefined },
+    { imageGeneration: "auto" as const },
+    { imageGeneration: true, tools: [{ name: "lookup", inputSchema: { type: "object" } }] },
+    { imageGeneration: true, jsonSchema: '{"type":"object"}' },
+    { imageGeneration: true, imageGenerationOptions: { outputFormat: "webp" as const } },
+  ])("rejects unsupported standalone image requests before logging: %j", async (options) => {
+    await expect(QgridFrame.query({
+      prompt: "draw", model: "openai/gpt-image-2", ...options,
+    })).rejects.toMatchObject({ statusCode: 400 });
+    expect(beforeQueryMock).not.toHaveBeenCalled();
+    expect(dispatcherQueryMock).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    { imageGenerationOptions: { outputFormat: "webp" as const } },
+    { tools: [{ name: "lookup", inputSchema: { type: "object" } }] },
+    { jsonSchema: '{"type":"object"}' },
+  ])("rejects unsupported auto image controls before logging: %j", async (options) => {
+    await expect(QgridFrame.query({
+      prompt: "draw", model: "openai/gpt-6-luna", imageGeneration: "auto", ...options,
+    })).rejects.toMatchObject({ statusCode: 400 });
+    expect(beforeQueryMock).not.toHaveBeenCalled();
+    expect(dispatcherQueryMock).not.toHaveBeenCalled();
+  });
+
   it("accepts bounded positive integer timeout values only", () => {
     expect(QueryInput.safeParse({ prompt: "hi", timeout: 360_000 }).success).toBe(true);
     expect(QueryInput.safeParse({ prompt: "hi", timeout: 0 }).success).toBe(false);
@@ -789,6 +856,12 @@ describe("QgridFrame.prepareStream", () => {
     requestLogSaveMock.mockReset();
   });
 
+  it("rejects an image model without a streaming image flag", async () => {
+    await expect(QgridFrame.prepareStream({
+      prompt: "draw", model: "openai/gpt-image-2",
+    })).rejects.toMatchObject({ statusCode: 400 });
+  });
+
   it.each([true, "auto"] as const)("rejects imageGeneration=%s before creating an SSE stream", async (imageGeneration) => {
     await expect(
       QgridFrame.prepareStream({

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

@@ -37,6 +37,7 @@ import {
   refreshAccessToken,
   RefreshFailedError,
 } from "./oauth";
+import { CODEX_IMAGE_GENERATION_MODEL } from "./qgrid-image-generation";
 import {
   afterQuery,
   beforeQuery,
@@ -45,6 +46,7 @@ import {
 } from "./qgrid-run-lifecycle";
 import {
   buildAndValidateStrictOutputSchema,
+  completedDriverFromImageFailure,
   type InternalQueryInput,
   QgridDispatcher,
 } from "./qgrid.dispatcher";
@@ -145,12 +147,35 @@ function parsePastedOAuthResult(input: string): { code: string; state: string }
 }
 
 function rejectImageGenerationStream(args: QueryInput): void {
-  if (!args.imageGeneration) return;
+  if (!args.imageGeneration && args.model !== `openai/${CODEX_IMAGE_GENERATION_MODEL}`) return;
   throw new BadRequestException(
-    "qgrid: imageGeneration is not supported with streaming; use query/generateText instead." as LocalizedString,
+    "qgrid: imageGeneration is not supported with streaming; use query or generateImage with qgrid.image() instead." as LocalizedString,
   );
 }
 
+function rejectInvalidImageQuery(args: QueryInput): void {
+  const standalone = args.model === `openai/${CODEX_IMAGE_GENERATION_MODEL}`;
+  if (!standalone && args.imageGeneration !== "auto") return;
+  if (standalone && args.imageGeneration !== true) {
+    throw new BadRequestException(
+      "qgrid: the image model requires imageGeneration: true; use qgrid.image() with generateImage." as LocalizedString,
+    );
+  }
+  if (args.tools?.length || args.jsonSchema !== undefined) {
+    throw new BadRequestException(
+      "qgrid: automatic and standalone image generation do not support caller tools or structured output." as LocalizedString,
+    );
+  }
+  if (
+    args.imageGenerationOptions?.outputFormat &&
+    args.imageGenerationOptions.outputFormat !== "png"
+  ) {
+    throw new BadRequestException(
+      "qgrid: automatic and standalone image generation only support PNG output." as LocalizedString,
+    );
+  }
+}
+
 // anthropic 은 --json-schema 를 쓰지 않으므로(SON-532) strict 변환·argv 제한 없이 원형의
 // 구문·복잡도만 검증된다 — provider 분기는 buildAndValidateStrictOutputSchema 가 소유한다.
 function rejectInvalidCallerSchemas(args: QueryInput): void {
@@ -247,6 +272,7 @@ class QgridFrameClass extends BaseFrameClass {
 
   @api({ httpMethod: "POST", clients: ["axios", "tanstack-mutation"] })
   async query(args: QueryInput): Promise<QueryOutput> {
+    rejectInvalidImageQuery(args);
     rejectInvalidCallerSchemas(args);
     const resolvedArgs = await resolveTokenName(args);
     const disconnect = createHttpDisconnectHandle();
@@ -260,10 +286,19 @@ class QgridFrameClass extends BaseFrameClass {
       try {
         result = await QgridDispatcher.query(resolvedArgs, disconnect.signal);
       } catch (e) {
+        const completedDriver = completedDriverFromImageFailure(e);
+        const completedStep = completedDriver
+          ? ([{ stepIndex, result: completedDriver }] as const)
+          : ([] as const);
         if (disconnect.signal.aborted) {
-          await finishRunAborted(requestLogId, resolvedArgs);
+          await finishRunAborted(requestLogId, resolvedArgs, ...completedStep);
         } else {
-          await finishRunWithError(requestLogId, (e as Error).message, resolvedArgs);
+          await finishRunWithError(
+            requestLogId,
+            (e as Error).message,
+            resolvedArgs,
+            ...completedStep,
+          );
         }
         throw e;
       }

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

@@ -134,14 +134,14 @@
       "name": "image_cost_usd",
       "type": "integer",
       "nullable": true,
-      "desc": "이미지 생성 추정 비용"
+      "desc": "이미지 생성 비용"
     },
     {
       "name": "image_cost_method",
       "type": "string",
       "length": 100,
       "nullable": true,
-      "desc": "이미지 비용 추정 방식"
+      "desc": "이미지 비용 계산 방식"
     },
     {
       "name": "effort",

package/bundle/src/application/sonamu.generated.http

@@ -320,7 +320,7 @@ Content-Type: application/json
     "imageGeneration": false,
     "imageGenerationOptions": {
       "quality": "low",
-      "size": "1024x1024",
+      "size": "auto",
       "background": "auto",
       "outputFormat": "png"
     }
@@ -385,7 +385,7 @@ Content-Type: application/json
     "imageGeneration": false,
     "imageGenerationOptions": {
       "quality": "low",
-      "size": "1024x1024",
+      "size": "auto",
       "background": "auto",
       "outputFormat": "png"
     }

package/bundle/src/i18n/sd.generated.ts

@@ -230,8 +230,8 @@ const entityLabels = {
   "entity.RequestLog.ttft_ms": "first gen TTFT(ms)",
   "entity.RequestLog.cost_usd": "API 비용",
   "entity.RequestLog.cost_source": "비용 출처(provider/pricing_table/mixed)",
-  "entity.RequestLog.image_cost_usd": "이미지 생성 추정 비용",
-  "entity.RequestLog.image_cost_method": "이미지 비용 추정 방식",
+  "entity.RequestLog.image_cost_usd": "이미지 생성 비용",
+  "entity.RequestLog.image_cost_method": "이미지 비용 계산 방식",
   "entity.RequestLog.effort": "effort level",
   "entity.RequestLog.history": "inject_items 히스토리",
   "entity.RequestLog.tools": "요청에 장착된 tool 정의 목록",

package/bundle/src/utils/providers/openai/openai-backend-protocol.test.ts

@@ -27,7 +27,7 @@ describe("OpenAI Codex backend protocol", () => {
     } })).toMatchObject({ generation: { route: "codex-responses", size: "841x1870" } });
   });
   it("distinguishes partial function items from completed arguments", () => {
-    const item = { type: "function_call", call_id: "call", name: "generate_transparent_image", arguments: "{}" };
+    const item = { type: "function_call", call_id: "call", name: "generate_image", arguments: "{}" };
     expect(normalizeOpenAIEvent({ type: "response.output_item.added", item })).toEqual({ type: "output-item", item, completed: false });
     expect(normalizeOpenAIEvent({ type: "response.output_item.done", item })).toEqual({ type: "output-item", item, completed: true });
   });
@@ -149,4 +149,26 @@ describe("OpenAI Codex backend protocol", () => {
       }),
     ).toEqual({ type: "image", id: "img", base64: "aGVsbG8=", mimeType: "image/png", revisedPrompt: "better", generation: { route: "codex-responses" } });
   });
+
+  it("preserves zero image-tool usage without treating it as missing", () => {
+    const usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+    expect(normalizeOpenAIEvent({ type: "response.completed", response: {
+      id: "r", tool_usage: { image_gen: usage },
+    } })).toEqual({
+      type: "completed", responseId: "r",
+      imageGeneration: { route: "codex-responses", usage },
+    });
+  });
+
+  it.each([undefined, null, {}, { input_tokens: "4", output_tokens: 1, total_tokens: 5 }, { input_tokens: -1, output_tokens: 1, total_tokens: 0 }])(
+    "ignores missing or malformed image-tool usage: %j", (usage) => {
+      expect(normalizeOpenAIEvent({ type: "response.completed", response: {
+        id: "r", tool_usage: { image_gen: usage },
+        tools: [{ type: "image_generation", model: "gpt-image-2-codex", size: "auto", quality: "auto" }],
+      } })).toEqual({
+        type: "completed", responseId: "r",
+        imageGeneration: { route: "codex-responses", model: "gpt-image-2-codex" },
+      });
+    },
+  );
 });

package/bundle/src/utils/providers/openai/openai-backend-protocol.ts

@@ -1,6 +1,6 @@
 import os from "node:os";
 
-import { type ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
+import { ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
 import { type OpenAIEffort } from "../common/effort";
 
 export const CHATGPT_CODEX_RESPONSES_URL =
@@ -180,7 +180,13 @@ export type OpenAINormalizedEvent =
       generation?: ImageGenerationMetadata;
     }
   | { type: "output-item"; item: OpenAIResponseItem; completed?: boolean }
-  | { type: "completed"; responseId: string; usage?: OpenAIUsage; model?: string }
+  | {
+      type: "completed";
+      responseId: string;
+      usage?: OpenAIUsage;
+      model?: string;
+      imageGeneration?: ImageGenerationMetadata;
+    }
   | { type: "error"; error: OpenAIProtocolError };
 
 export class OpenAIProtocolError extends Error {
@@ -286,11 +292,27 @@ export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | unde
   }
   if (type === "response.completed") {
     const response = (event.response ?? {}) as Record<string, unknown>;
+    const toolUsage = response.tool_usage as Record<string, unknown> | undefined;
+    const parsedImageUsage = ImageGenerationMetadata.shape.usage.safeParse(toolUsage?.image_gen);
+    const imageUsage = parsedImageUsage.success ? parsedImageUsage.data : undefined;
+    const imageTool = Array.isArray(response.tools)
+      ? response.tools.find((tool) => tool?.type === "image_generation")
+      : undefined;
+    const imageModel = typeof imageTool?.model === "string" ? imageTool.model : undefined;
     return {
       type: "completed",
       responseId: String(response.id ?? ""),
       ...(response.usage ? { usage: usageFrom(response.usage) } : {}),
       ...(typeof response.model === "string" ? { model: response.model } : {}),
+      ...(imageUsage || imageModel
+        ? {
+            imageGeneration: {
+              route: "codex-responses" as const,
+              ...(imageModel ? { model: imageModel } : {}),
+              ...(imageUsage ? { usage: imageUsage } : {}),
+            },
+          }
+        : {}),
     };
   }
   if (type === "error" || type === "response.failed" || type === "response.incomplete") {

package/bundle/src/utils/providers/openai/openai-direct-client.test.ts

@@ -29,6 +29,21 @@ async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
 }
 
 describe("OpenAI direct HTTPS client", () => {
+  it.each([true, { background: "opaque" }])("keeps chat-model images on Responses (%j)", async (imageGeneration) => {
+    const fetchMock = vi.fn<typeof fetch>(async () =>
+      sse({ type: "response.completed", response: { id: "hosted-image" } }),
+    );
+    const client = new OpenAIDirectClient({
+      credentials: { accessToken: "access", accountId: "acct" }, fetch: fetchMock,
+    });
+    await collect(client.responses({ model: "gpt-6-luna", history: [], imageGeneration }));
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0]?.[0]).toBe(CHATGPT_CODEX_RESPONSES_URL);
+    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toMatchObject({
+      model: "gpt-6-luna", tools: [expect.objectContaining({ type: "image_generation" })],
+    });
+  });
+
   it("posts the pinned body and Codex identity without live calls", async () => {
     const fetchMock = vi.fn<typeof fetch>(async () =>
       sse(

package/bundle/src/utils/providers/openai/openai-direct-client.ts

@@ -450,8 +450,9 @@ export class OpenAIDirectClient {
 
   responses(options: OpenAIResponsesOptions, signal?: AbortSignal): OpenAIEventStream {
     if (
-      typeof options.imageGeneration === "object" &&
-      options.imageGeneration.background === "transparent"
+      options.model === "gpt-image-2" ||
+      (typeof options.imageGeneration === "object" &&
+        options.imageGeneration.background === "transparent")
     ) {
       return this.standaloneImages(options, signal);
     }
@@ -498,10 +499,19 @@ export class OpenAIDirectClient {
         continue;
       }
       if (!response.ok) throw await responseError(response);
-      const images = await readStandaloneImageResponse(response);
+      const images = await readStandaloneImageResponse(
+        response,
+        typeof options.imageGeneration === "object" &&
+          options.imageGeneration.background === "transparent",
+      );
       signal?.throwIfAborted();
       yield* images;
-      yield { type: "completed", responseId: requestId, model: "gpt-image-2" };
+      const firstImage = images[0];
+      yield {
+        type: "completed",
+        responseId: requestId,
+        model: firstImage?.type === "image" ? firstImage.generation?.model : "gpt-image-2",
+      };
       return;
     }
   }