@cartanova/qgrid-cli 2.10.4 → 2.10.6

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;
       }
@@ -500,8 +535,10 @@ class QgridFrameClass extends BaseFrameClass {
   // 화면의 목록 필터를 그대로 받아 같은 조건의 합계를 돌려준다 — 목록과 비용이
   // 서로 다른 모수를 보면 사용자에게는 숫자가 어긋난 것으로 읽힌다.
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
-  async totalCost(params?: RequestLogListParams): Promise<{ usd: number }> {
-    return { usd: await RequestLogModel.totalCost(params) };
+  async totalCost(
+    params?: RequestLogListParams,
+  ): Promise<{ usd: number; unknownImageCostCount: number }> {
+    return RequestLogModel.totalCost(params);
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })

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

@@ -12,10 +12,10 @@ export const QgridTool = z.object({
 });
 export type QgridTool = z.infer<typeof QgridTool>;
 
-// Observed standalone Images response values, distinct from requested generation hints.
+// Observed image response values, distinct from requested generation hints.
 export const ImageGenerationMetadata = z.object({
-  route: z.literal("codex-images"),
-  model: z.literal("gpt-image-2"),
+  route: z.enum(["codex-images", "codex-responses"]),
+  model: z.string().optional(),
   background: z.string().optional(),
   quality: z.string().optional(),
   size: z.string().optional(),
@@ -79,7 +79,17 @@ 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"]);
+// Subscription-backend hints, not public Images API resolution guarantees.
+export const ImageGenerationSize = z.union([
+  z.literal("auto"),
+  z
+    .string()
+    .regex(/^[1-9]\d*x[1-9]\d*$/)
+    .refine(
+      (size) => size.split("x").every((edge) => Number.isSafeInteger(Number(edge))),
+      "Image dimensions must be positive safe integers",
+    ),
+]);
 export type ImageGenerationSize = z.infer<typeof ImageGenerationSize>;
 
 export const ImageGenerationOptions = z

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/request-log/request-log.model.test.ts

@@ -564,7 +564,7 @@ describe("RequestLogModel cost provenance", () => {
    * @param confirmedTotal SUM 쿼리가 돌려줄 micro-USD 합계
    * @param legacyRows 재계산 대상 row 들
    */
-  function mockTotalCostQueries(confirmedTotal: number, legacyRows: unknown[]) {
+  function mockTotalCostQueries(confirmedTotal: number, legacyRows: unknown[], unknownImageCostCount = 0) {
     // subset qb 는 SELECT 를 비우고(clear) 집계/축소된 컬럼만 다시 얹는다 — 구현과 같은 체인.
     const sumChain = {
       where: vi.fn(),
@@ -572,7 +572,7 @@ describe("RequestLogModel cost provenance", () => {
       whereRaw: vi.fn(),
       clear: vi.fn(),
       select: vi.fn(),
-      first: vi.fn(async () => ({ total: confirmedTotal })),
+      first: vi.fn(async () => ({ total: confirmedTotal, unknownImageCostCount })),
     };
     sumChain.where.mockReturnValue(sumChain);
     sumChain.whereIn.mockReturnValue(sumChain);
@@ -606,7 +606,7 @@ describe("RequestLogModel cost provenance", () => {
   it("uses exact stored cost for rows with a cost source", async () => {
     mockTotalCostQueries(3_000, []);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBe(0.003);
+    await expect(RequestLogModel.totalCost()).resolves.toEqual({ usd: 0.003, unknownImageCostCount: 0 });
   });
 
   it("sums every row in SQL without a cost_source predicate", async () => {
@@ -637,7 +637,7 @@ describe("RequestLogModel cost provenance", () => {
       },
     ]);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
+    await expect(RequestLogModel.totalCost().then((result) => result.usd)).resolves.toBeCloseTo(0.4725, 10);
   });
 
   it("adds only the delta for legacy rows already counted in the SQL sum", async () => {
@@ -656,7 +656,7 @@ describe("RequestLogModel cost provenance", () => {
       },
     ]);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
+    await expect(RequestLogModel.totalCost().then((result) => result.usd)).resolves.toBeCloseTo(0.4725, 10);
   });
 
   it("leaves the stored value untouched for legacy rows without a model name", async () => {
@@ -675,7 +675,7 @@ describe("RequestLogModel cost provenance", () => {
       },
     ]);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.005, 10);
+    await expect(RequestLogModel.totalCost().then((result) => result.usd)).resolves.toBeCloseTo(0.005, 10);
   });
 
   it("applies list filters to both cost queries so totals match the filtered list", async () => {
@@ -721,7 +721,7 @@ describe("RequestLogModel cost provenance", () => {
       },
     ]);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4755, 10);
+    await expect(RequestLogModel.totalCost().then((result) => result.usd)).resolves.toBeCloseTo(0.4755, 10);
   });
 });
 
@@ -738,10 +738,13 @@ describe("RequestLogModel PostgreSQL", () => {
         { cost_usd: 5_000, image_cost_usd: 10_000, cost_source: "provider" },
         { cost_usd: 1_000, image_cost_usd: 20_000, cost_source: null },
         { cost_usd: 900_000, image_cost_usd: 700_000, cost_source: null },
+        { cost_usd: 1_000, image_cost_usd: null, cost_source: "provider", is_image_generation: true },
+        { cost_usd: 2_000, image_cost_usd: null, cost_source: "provider", is_image_generation: false },
+        { cost_usd: 500_000, image_cost_usd: null, cost_source: "provider", is_image_generation: true },
       ].entries()) {
         const id = await RequestLogModel.createRun({
           user_prompt: "cost regression",
-          project_name: index < 2 ? projectName : `${projectName}-other`,
+          project_name: index === 2 || index === 5 ? `${projectName}-other` : projectName,
         });
         ids.push(id);
         await RequestLogModel.getPuri("w").table("request_logs").where("id", id).update({
@@ -754,10 +757,12 @@ describe("RequestLogModel PostgreSQL", () => {
 
       const params = { sonamuFilter: { project_name: projectName }, num: 0, page: 1 };
       const { rows } = await RequestLogModel.findMany("C", params);
-      expect(rows.map((row) => row.id)).toEqual(expect.arrayContaining(ids.slice(0, 2)));
-      expect(rows).toHaveLength(2);
-      // Confirmed: .005 + .010; legacy driver repriced to .003, plus .020 image.
-      await expect(RequestLogModel.totalCost(params)).resolves.toBeCloseTo(0.038, 10);
+      expect(rows.map((row) => row.id)).toEqual(expect.arrayContaining([ids[0], ids[1], ids[3], ids[4]]));
+      expect(rows).toHaveLength(4);
+      // .038 known images + .001 hosted driver + .002 text; other project excluded.
+      const total = await RequestLogModel.totalCost(params);
+      expect(total.usd).toBeCloseTo(0.041, 10);
+      expect(total.unknownImageCostCount).toBe(1);
     } finally {
       await RequestLogModel.del(ids);
     }

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

@@ -820,7 +820,9 @@ class RequestLogModelClass extends BaseModelClass<
    * 필터 조건을 여기서 다시 구현하지 않고 `applyListFilters` 를 공유하는 것이 핵심이다 —
    * 두 쿼리가 각자 필터를 가지면 화면에서 필터를 걸었을 때 행 수와 비용이 조용히 어긋난다.
    */
-  async totalCost(rawParams: RequestLogListParams = { num: 0, page: 1 }): Promise<number> {
+  async totalCost(
+    rawParams: RequestLogListParams = { num: 0, page: 1 },
+  ): Promise<{ usd: number; unknownImageCostCount: number }> {
     const params = {
       num: 0,
       page: 1,
@@ -843,6 +845,9 @@ class RequestLogModelClass extends BaseModelClass<
         total: Puri.rawNumber(
           "COALESCE(SUM(GREATEST(request_logs.cost_usd, 0) + COALESCE(request_logs.image_cost_usd, 0)), 0)",
         ),
+        unknownImageCostCount: Puri.rawNumber(
+          "COUNT(*) FILTER (WHERE request_logs.is_image_generation = true AND request_logs.image_cost_usd IS NULL)",
+        ),
       })
       .first();
 
@@ -867,7 +872,7 @@ class RequestLogModelClass extends BaseModelClass<
     const storedTotal = Number(stored?.total ?? 0) / MICRO_USD;
 
     // legacy row 는 위 SUM 에 저장값으로 이미 포함되어 있다. 재계산값과의 차액만 더한다.
-    return legacyRows.reduce((sum, row) => {
+    const usd = legacyRows.reduce((sum, row) => {
       const alreadySummed = Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
       const usage = normalizedUsageForCost(row);
       if (!usage.model) return sum;
@@ -884,6 +889,7 @@ class RequestLogModelClass extends BaseModelClass<
         alreadySummed
       );
     }, storedTotal);
+    return { usd, unknownImageCostCount: Number(stored?.unknownImageCostCount ?? 0) };
   }
 
   async distinctProjectNames(): Promise<string[]> {

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

@@ -8,8 +8,26 @@ import {
 } from "./openai-backend-protocol";
 
 describe("OpenAI Codex backend protocol", () => {
+  it.each(["png", "jpeg", "webp"])("preserves reported hosted %s generation settings", (output_format) => {
+    expect(normalizeOpenAIEvent({ type: "response.output_item.done", item: {
+      type: "image_generation_call", result: "aGVsbG8=", output_format,
+      size: "841x1870", quality: "low", background: "opaque",
+    } })).toMatchObject({ generation: {
+      route: "codex-responses", size: "841x1870", quality: "low", background: "opaque",
+    } });
+  });
+
+  it("reports PNG byte dimensions instead of a conflicting backend size", () => {
+    const bytes = Buffer.alloc(24);
+    Buffer.from("89504e470d0a1a0a", "hex").copy(bytes);
+    bytes.writeUInt32BE(841, 16);
+    bytes.writeUInt32BE(1870, 20);
+    expect(normalizeOpenAIEvent({ type: "response.output_item.done", item: {
+      type: "image_generation_call", result: bytes.toString("base64"), size: "1152x2560",
+    } })).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 });
   });
@@ -129,6 +147,28 @@ describe("OpenAI Codex backend protocol", () => {
         type: "response.output_item.done",
         item: { type: "image_generation_call", id: "img", result: "aGVsbG8=", revised_prompt: "better" },
       }),
-    ).toEqual({ type: "image", id: "img", base64: "aGVsbG8=", mimeType: "image/png", revisedPrompt: "better" });
+    ).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" },
+      });
+    },
+  );
 });