@cartanova/qgrid-cli 2.10.5 → 2.10.7

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

@@ -89,6 +89,7 @@ export async function beforeQuery(args: QueryInput): Promise<{
       system_prompt: args.system,
       requested_model_name: args.model,
       effort: args.thinking === false ? undefined : args.effort,
+      service_tier: args.model?.startsWith("openai/") ? args.serviceTier : undefined,
       project_name: args.projectName,
       history: filterHistoryForStorage(args.history),
       tools: args.tools?.length ? args.tools : undefined,
@@ -100,12 +101,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 +133,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(
@@ -182,6 +198,7 @@ export async function afterQuery(
     requested_model_name: requestedModelName,
     model_name: servedModelName,
     fallback_count: agg.fallback_count,
+    service_tier: args.model?.startsWith("openai/") ? (args.serviceTier ?? null) : null,
     cost_usd: agg.cost_usd,
     cost_source: agg.cost_source,
     image_cost_usd: imageCostMicroUsd,
@@ -200,12 +217,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 +235,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 +258,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,162 @@ function deeplyNestedOutputSchema(depth: number): string {
 }
 
 describe("QgridDispatcherClass", () => {
+  it.each([false, true])("applies Fast pricing to OpenAI query (stream=%s)", async (stream) => {
+    const dispatcher = new QgridDispatcherClass();
+    const result = providerResult({
+      model: "gpt-6.1-sol",
+      usage: { totalTokens: 2000, inputTokens: 1000, cachedInputTokens: 500, outputTokens: 1000, reasoningOutputTokens: 0 },
+    });
+    dispatcher.openaiDispatcher = {
+      generate: vi.fn(async () => result),
+      generateStream: vi.fn(async (_req, cb) => cb.onComplete(result)),
+    } as never;
+    const input = { prompt: "hi", model: "openai/gpt-6.1-sol", serviceTier: "fast" as const };
+    let output: QueryOutput | undefined;
+    if (stream) {
+      await dispatcher.queryStream(input, {
+        onDelta: () => {}, onComplete: (value) => { output = value; }, onError: (error) => { throw error; },
+      });
+    } else {
+      output = await dispatcher.query(input);
+    }
+    expect(output?.costUsd).toBeCloseTo(0.0221, 10);
+    expect(output?.costSource).toBe("pricing_table");
+  });
+
+  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(completedDriverFromImageFailure(error, "fast")?.costUsd).toBeCloseTo(0.0000382, 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 {
@@ -124,7 +127,7 @@ export class QgridDispatcherClass {
         ? undefined
         : issueConvContext(result.threadCoord, decision, result.threadCoord.workerId);
 
-      return applyToolCallEmulation(toEmulationResult(result), input.tools, {
+      return applyToolCallEmulation(toEmulationResult(result, input.serviceTier), input.tools, {
         threadCoord: coord,
         images: result.images,
         answerKind,
@@ -203,14 +206,18 @@ export class QgridDispatcherClass {
           onComplete: (turnResult) => {
             this.recordCompleted("openai", turnResult.tokenName);
             cb.onComplete(
-              applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {
-                threadCoord: issueConvContext(
-                  turnResult.threadCoord,
-                  decision,
-                  turnResult.threadCoord.workerId,
-                ),
-                answerKind,
-              }),
+              applyToolCallEmulation(
+                toEmulationResult(turnResult, input.serviceTier),
+                input.tools,
+                {
+                  threadCoord: issueConvContext(
+                    turnResult.threadCoord,
+                    decision,
+                    turnResult.threadCoord.workerId,
+                  ),
+                  answerKind,
+                },
+              ),
             );
           },
           onError: cb.onError,
@@ -325,9 +332,20 @@ function buildRawOutputSchema(
     : callerOutputSchema;
 }
 
+export function completedDriverFromImageFailure(
+  error: unknown,
+  serviceTier?: string,
+): QueryOutput | undefined {
+  if (!(error instanceof ImageGenerationError) || !error.completedDriver) return undefined;
+  return applyToolCallEmulation(toEmulationResult(error.completedDriver, serviceTier), undefined, {
+    answerKind: "text",
+  });
+}
+
 // Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.
 function toEmulationResult(
   result: GenerateResult,
+  serviceTier?: string,
 ): Omit<QueryOutput, "content" | "finishReason" | "runContext"> {
   const hasProviderCost = result.costUsd !== undefined && result.costUsd > 0;
   return {
@@ -349,14 +367,18 @@ function toEmulationResult(
     ttftMs: result.ttftMs ?? 0,
     costUsd: hasProviderCost
       ? result.costUsd!
-      : calculateCostUsd(result.model, {
-          inputTokens: result.usage.inputTokens,
-          outputTokens: result.usage.outputTokens,
-          cachedInputTokens: result.usage.cachedInputTokens,
-          cacheCreationInputTokens: result.usage.cacheCreationInputTokens ?? 0,
-          cacheCreationInputTokens5m: result.usage.cacheCreationInputTokens5m,
-          cacheCreationInputTokens1h: result.usage.cacheCreationInputTokens1h,
-        }),
+      : calculateCostUsd(
+          result.model,
+          {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            cachedInputTokens: result.usage.cachedInputTokens,
+            cacheCreationInputTokens: result.usage.cacheCreationInputTokens ?? 0,
+            cacheCreationInputTokens5m: result.usage.cacheCreationInputTokens5m,
+            cacheCreationInputTokens1h: result.usage.cacheCreationInputTokens1h,
+          },
+          serviceTier,
+        ),
     costSource: hasProviderCost ? "provider" : "pricing_table",
   };
 }

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,46 @@ 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,
+      serviceTier: "fast" 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.00004,
+          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 +817,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 +857,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, resolvedArgs.serviceTier);
+        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,21 @@
       "name": "image_cost_usd",
       "type": "integer",
       "nullable": true,
-      "desc": "이미지 생성 추정 비용"
+      "desc": "이미지 생성 비용"
     },
     {
       "name": "image_cost_method",
       "type": "string",
       "length": 100,
       "nullable": true,
-      "desc": "이미지 비용 추정 방식"
+      "desc": "이미지 비용 계산 방식"
+    },
+    {
+      "name": "service_tier",
+      "type": "string",
+      "length": 20,
+      "nullable": true,
+      "desc": "Requested OpenAI service tier"
     },
     {
       "name": "effort",
@@ -288,6 +295,7 @@
       "image_cost_usd",
       "image_cost_method",
       "effort",
+      "service_tier",
       "history",
       "tools",
       "status",
@@ -318,6 +326,7 @@
       "image_cost_usd",
       "image_cost_method",
       "effort",
+      "service_tier",
       "status",
       "response_json_ok",
       "tool_call_count",

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

@@ -481,6 +481,7 @@ class RequestLogModelClass extends BaseModelClass<
     system_prompt?: string | null;
     requested_model_name?: string | null;
     effort?: string | null;
+    service_tier?: string | null;
     project_name?: string | null;
     history?: unknown;
     tools?: ToolDefinitions;
@@ -496,6 +497,7 @@ class RequestLogModelClass extends BaseModelClass<
       requested_model_name: params.requested_model_name ?? null,
       model_name: null,
       effort: params.effort ?? null,
+      service_tier: params.service_tier ?? null,
       project_name: params.project_name ?? null,
       status: "running",
       response: "",
@@ -546,6 +548,7 @@ class RequestLogModelClass extends BaseModelClass<
       duration_ms?: number;
       requested_model_name?: string | null;
       model_name?: string | null;
+      service_tier?: string | null;
       fallback_count?: number | null;
       cost_usd?: number | null;
       cost_source?: string | null;
@@ -574,6 +577,7 @@ class RequestLogModelClass extends BaseModelClass<
       "duration_ms",
       "requested_model_name",
       "model_name",
+      "service_tier",
       "fallback_count",
       "cost_usd",
       "cost_source",

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"
     }