@cartanova/qgrid-cli 2.9.4 → 2.9.6

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

@@ -12,6 +12,7 @@ const STRUCTURED_ENVELOPE_LIMITS = {
   maxDepth: 132,
 } as const;
 import {
+  type ImageGenerationMetadata,
   type QgridContent,
   type QgridThreadCoord,
   type QgridTool,
@@ -66,10 +67,12 @@ export class ToolCallEmulationError extends Error {
   }
 }
 
-// dispatcher 가 넘기는 이미지 결과. qgrid 는 base64 payload 만 전달하고 포맷은 보장하지 않는다.
+// Preserve image bytes and the provider's resolved MIME type.
 interface EmulationImage {
   data: string;
+  mediaType?: Extract<QgridContent, { type: "image" }>["mediaType"];
   revisedPrompt?: string | null;
+  generation?: ImageGenerationMetadata;
 }
 
 // answer 인코딩 종류. envelope 디코더는 한 벌이고 이 값은 answer 브랜치의 타입과
@@ -211,7 +214,9 @@ function appendImages(content: QgridContent[], images?: EmulationImage[]): Qgrid
       (image): QgridContent => ({
         type: "image",
         data: image.data,
+        ...(image.mediaType ? { mediaType: image.mediaType } : {}),
         revisedPrompt: image.revisedPrompt ?? null,
+        ...(image.generation ? { generation: image.generation } : {}),
       }),
     ),
   ];

package/bundle/src/application/setting/setting.model.test.ts

@@ -6,6 +6,26 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { resetNativeRunRegistryForTests } from "../qgrid/qgrid-run-lifecycle";
 import { resetServerRestartForTests } from "../../utils/server-restart";
 import { SettingModel } from "./setting.model";
+import * as reminders from "../qgrid/expired-token-reminder";
+import { SlackNotificationError } from "../../utils/slack-notify";
+
+describe("SettingModel.triggerExpiryReminder", () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it("returns the sent count after successful delivery", async () => {
+    vi.spyOn(reminders, "sendExpiredTokenReminderNow").mockResolvedValue(3);
+    await expect(SettingModel.triggerExpiryReminder()).resolves.toEqual({ sent: 3 });
+  });
+
+  it("returns a readable API error when Slack rejects a manual send", async () => {
+    vi.spyOn(reminders, "sendExpiredTokenReminderNow").mockRejectedValue(
+      new SlackNotificationError("Slack 알림 발송 실패: not_in_channel"),
+    );
+    await expect(SettingModel.triggerExpiryReminder()).rejects.toMatchObject({
+      statusCode: 400, message: "Slack 알림 발송 실패: not_in_channel",
+    });
+  });
+});
 
 function installContext(headers: Record<string, string>) {
   const raw = Object.assign(new EventEmitter(), {

package/bundle/src/application/setting/setting.model.ts

@@ -11,9 +11,10 @@ import {
   exhaustive,
 } from "sonamu";
 
-import { SD } from "../../i18n/sd.generated";
+import { SD, type LocalizedString } from "../../i18n/sd.generated";
 import { detectSupervisor } from "../../utils/process-supervisor";
 import { armServerRestartExit, beginServerRestart } from "../../utils/server-restart";
+import { SlackNotificationError } from "../../utils/slack-notify";
 import { type SettingSubsetKey, type SettingSubsetMapping } from "../sonamu.generated";
 import { settingSubsetQueries, settingLoaderQueries } from "../sonamu.generated.sso";
 import {
@@ -315,7 +316,14 @@ class SettingModelClass extends BaseModelClass<
     // setting.model → expired-token-reminder → token.model 경로가 생겨,
     // token.model 을 mock 하는 테스트가 실제 모듈을 먼저 로드하게 된다.
     const { sendExpiredTokenReminderNow } = await import("../qgrid/expired-token-reminder");
-    return { sent: await sendExpiredTokenReminderNow() };
+    try {
+      return { sent: await sendExpiredTokenReminderNow() };
+    } catch (error) {
+      if (error instanceof SlackNotificationError) {
+        throw new BadRequestException(error.message as LocalizedString);
+      }
+      throw error;
+    }
   }
 
   /**

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

@@ -326,7 +326,8 @@ Content-Type: application/json
     "imageGeneration": false,
     "imageGenerationOptions": {
       "quality": "low",
-      "size": "1024x1024"
+      "size": "1024x1024",
+      "background": "auto"
     }
   }
 }
@@ -388,7 +389,8 @@ Content-Type: application/json
     "imageGeneration": false,
     "imageGenerationOptions": {
       "quality": "low",
-      "size": "1024x1024"
+      "size": "1024x1024",
+      "background": "auto"
     }
   }
 }

package/bundle/src/utils/providers/common/provider-dispatcher.ts

@@ -4,7 +4,11 @@
  * MVP 에서는 stream() 만. getRateLimits(), listModels() 는 future.
  */
 
-import { type ImageGenerationOptions } from "../../../application/qgrid/qgrid.types";
+import {
+  type ImageGenerationMetadata,
+  type ImageGenerationOptions,
+  type QgridContent,
+} from "../../../application/qgrid/qgrid.types";
 import { type JsonValue, type TokenUsageBreakdown, type UserInput } from "./provider-types";
 
 // qgrid provider 내부 표준 usage. provider 전용 cache write 세부 필드는 여기서 확장해 보존한다.
@@ -25,8 +29,10 @@ export interface ReuseThreadCoord {
 // provider-무관 이미지 결과. OpenAI 경로에서만 채워지며, 상위(qgrid.dispatcher)가
 // content 파트로 전파한다. Anthropic 경로는 이 필드를 채우지 않는다.
 export interface GeneratedImage {
-  data: string; // base64 PNG
+  data: string; // base64 image
+  mediaType?: Extract<QgridContent, { type: "image" }>["mediaType"];
   revisedPrompt: string | null;
+  generation?: ImageGenerationMetadata;
 }
 
 // Provider/런타임이 요청 모델 대신 다른 모델로 실제 응답을 생성한 이력.

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

@@ -8,6 +8,29 @@ import {
 } from "./openai-backend-protocol";
 
 describe("OpenAI Codex backend protocol", () => {
+  it("uses returned bytes rather than a mismatched format label", () => {
+    expect(normalizeOpenAIEvent({ type: "response.output_item.done", item: {
+      type: "image_generation_call", result: "UklGRgAAAABXRUJQ", output_format: "png",
+    } })).toMatchObject({ mimeType: "image/webp" });
+  });
+
+  it("detects JPEG when the format label is absent", () => {
+    expect(normalizeOpenAIEvent({ type: "response.output_item.done", item: {
+      type: "image_generation_call", result: "/9j/",
+    } })).toMatchObject({ mimeType: "image/jpeg" });
+  });
+
+  it.each([
+    ["png", "iVBORw0KGgo=", "image/png"],
+    ["jpeg", "/9j/", "image/jpeg"],
+    ["webp", "UklGRgAAAABXRUJQ", "image/webp"],
+  ])("preserves %s output MIME type", (format, result, mimeType) => {
+    expect(normalizeOpenAIEvent({
+      type: "response.output_item.done",
+      item: { type: "image_generation_call", result, output_format: format },
+    })).toMatchObject({ type: "image", mimeType });
+  });
+
   it("preserves raw history and pins Responses controls", () => {
     const history = [{ type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] }];
     const request = buildOpenAIResponsesRequest({

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

@@ -1,5 +1,6 @@
 import os from "node:os";
 
+import { type ImageGenerationMetadata } from "../../../application/qgrid/qgrid.types";
 import { type OpenAIEffort } from "../common/effort";
 
 export const CHATGPT_CODEX_RESPONSES_URL =
@@ -170,7 +171,14 @@ export interface OpenAIUsage {
 export type OpenAINormalizedEvent =
   | { type: "created"; responseId?: string }
   | { type: "text-delta"; text: string }
-  | { type: "image"; id?: string; base64: string; mimeType: "image/png"; revisedPrompt?: string }
+  | {
+      type: "image";
+      id?: string;
+      base64: string;
+      mimeType: "image/png" | "image/jpeg" | "image/webp";
+      revisedPrompt?: string;
+      generation?: ImageGenerationMetadata;
+    }
   | { type: "output-item"; item: OpenAIResponseItem }
   | { type: "completed"; responseId: string; usage?: OpenAIUsage; model?: string }
   | { type: "error"; error: OpenAIProtocolError };
@@ -201,6 +209,23 @@ function usageFrom(value: unknown): OpenAIUsage | undefined {
   };
 }
 
+export function imageMimeType(
+  base64: string,
+  outputFormat?: unknown,
+): "image/png" | "image/jpeg" | "image/webp" {
+  // Inspect only the header, without decoding a potentially large image twice.
+  const header = Buffer.from(base64.slice(0, 24), "base64");
+  if (header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+    return "image/png";
+  if (header[0] === 255 && header[1] === 216 && header[2] === 255) return "image/jpeg";
+  if (header.toString("ascii", 0, 4) === "RIFF" && header.toString("ascii", 8, 12) === "WEBP")
+    return "image/webp";
+  if (outputFormat === "jpeg") return "image/jpeg";
+  if (outputFormat === "webp") return "image/webp";
+  if (outputFormat === undefined || outputFormat === "png") return "image/png";
+  throw new OpenAIProtocolError(`Unsupported image output format: ${String(outputFormat)}`);
+}
+
 export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | undefined {
   if (!raw || typeof raw !== "object") return undefined;
   const event = raw as Record<string, unknown>;
@@ -223,7 +248,7 @@ export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | unde
         type: "image",
         ...(typeof item.id === "string" ? { id: item.id } : {}),
         base64: item.result,
-        mimeType: "image/png",
+        mimeType: imageMimeType(item.result, item.output_format),
         ...(typeof item.revised_prompt === "string"
           ? { revisedPrompt: item.revised_prompt }
           : typeof item.revisedPrompt === "string"

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

@@ -12,6 +12,10 @@ import {
   type OpenAIResponsesOptions,
   type OpenAIResponsesRequest,
 } from "./openai-backend-protocol";
+import {
+  buildStandaloneImageRequest,
+  readStandaloneImageResponse,
+} from "./openai-image-generation";
 import { normalizeOpenAISSE, type OpenAIEventStream } from "./openai-sse";
 
 export interface OpenAIDirectCredentials {
@@ -446,8 +450,10 @@ export interface OpenAIDirectClientOptions extends OpenAIHttpsTransportOptions {
 
 export class OpenAIDirectClient {
   private readonly transport: OpenAIResponsesTransport;
+  private imageCredentials: OpenAIDirectCredentials;
 
-  constructor(options: OpenAIDirectClientOptions) {
+  constructor(private readonly options: OpenAIDirectClientOptions) {
+    this.imageCredentials = options.credentials;
     this.transport =
       options.transport ??
       (options.transportKind === "websocket"
@@ -456,6 +462,12 @@ export class OpenAIDirectClient {
   }
 
   responses(options: OpenAIResponsesOptions, signal?: AbortSignal): OpenAIEventStream {
+    if (
+      typeof options.imageGeneration === "object" &&
+      options.imageGeneration.background === "transparent"
+    ) {
+      return this.standaloneImages(options, signal);
+    }
     const clientRequestId = crypto.randomUUID();
     const affinityId = options.promptCacheKey
       ? cacheAffinityUuid(options.promptCacheKey)
@@ -472,6 +484,41 @@ export class OpenAIDirectClient {
     });
   }
 
+  private async *standaloneImages(
+    options: OpenAIResponsesOptions,
+    signal?: AbortSignal,
+  ): OpenAIEventStream {
+    const request = buildStandaloneImageRequest(options);
+    const requestId = crypto.randomUUID();
+    for (let attempt = 0; attempt < 2; attempt++) {
+      signal?.throwIfAborted();
+      const response = await (this.options.fetch ?? fetch)(request.url, {
+        method: "POST",
+        headers: {
+          ...buildCodexIdentityHeaders(
+            this.imageCredentials.accessToken,
+            this.imageCredentials.accountId,
+          ),
+          Accept: "application/json",
+          "x-codex-image-turn-id": requestId,
+        },
+        body: JSON.stringify(request.body),
+        signal,
+      });
+      if (response.status === 401 && attempt === 0 && this.options.refreshCredentials) {
+        await response.body?.cancel();
+        this.imageCredentials = await this.options.refreshCredentials();
+        continue;
+      }
+      if (!response.ok) throw await responseError(response);
+      const images = await readStandaloneImageResponse(response);
+      signal?.throwIfAborted();
+      yield* images;
+      yield { type: "completed", responseId: requestId, model: "gpt-image-2" };
+      return;
+    }
+  }
+
   close(): void {
     this.transport.close?.();
   }

package/bundle/src/utils/providers/openai/openai-dispatcher.test.ts

@@ -1,8 +1,12 @@
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import { QuotaThresholdExceededError } from "../../../application/qgrid/qgrid.types";
+const { refreshMock } = vi.hoisted(() => ({ refreshMock: vi.fn() }));
+vi.mock("./openai-refresh", () => ({ handleChatgptAuthTokensRefresh: refreshMock }));
+
+import { QueryInput, QuotaThresholdExceededError } from "../../../application/qgrid/qgrid.types";
 import { type GenerateRequest } from "../common/provider-dispatcher";
 import {
+  buildOpenAIResponsesRequest,
   type OpenAINormalizedEvent,
   type OpenAIResponsesOptions,
 } from "./openai-backend-protocol";
@@ -47,6 +51,155 @@ async function tickTimer(): Promise<void> {
 }
 
 describe("OpenAIDispatcher direct runtime", () => {
+  it.each(["png", "jpeg", "webp"] as const)("forwards %s format and preserves returned MIME", async (outputFormat) => {
+    const args = QueryInput.parse({ prompt: "draw", imageGeneration: true, imageGenerationOptions: { outputFormat } });
+    let body: ReturnType<typeof buildOpenAIResponsesRequest> | undefined;
+    const d = dispatcher((options) => {
+      body = buildOpenAIResponsesRequest(options);
+      return events({ type: "image", base64: "data", mimeType: `image/${outputFormat}` }, { type: "completed", responseId: "r" });
+    });
+    await d.onTokenAdded(1, "one", credentials);
+    const result = await d.generate(request({ imageGeneration: args.imageGeneration, imageGenerationOptions: args.imageGenerationOptions }));
+    expect(body?.tools).toEqual([{ type: "image_generation", output_format: outputFormat }]);
+    expect(result.images).toMatchObject([{ mediaType: `image/${outputFormat}` }]);
+  });
+
+  it("rejects unsupported output formats and non-PNG transparent requests", () => {
+    for (const imageGenerationOptions of [{ outputFormat: "gif" }, { outputFormat: "webp", background: "transparent" }, { outputFormat: "jpeg", background: "transparent" }]) {
+      expect(QueryInput.safeParse({ prompt: "draw", imageGeneration: true, imageGenerationOptions }).success).toBe(false);
+    }
+  });
+
+  beforeEach(() => { refreshMock.mockReset(); });
+
+  it("refreshes a quota 401 once, shares the recovery, and uses the new credentials", async () => {
+    const fetchMock = vi.fn()
+      .mockResolvedValueOnce(new Response("", { status: 401 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify({
+        rate_limits: { primary_window: { used_percent: 20 } },
+      })));
+    refreshMock.mockResolvedValue({ accessToken: "new-access", chatgptAccountId: "acct" });
+    const factory = vi.fn(() => ({ responses: () => events({ type: "completed", responseId: "r" }) }));
+    const d = new OpenAIDispatcher(config(), { fetch: fetchMock, clientFactory: factory });
+    await d.onTokenAdded(1, "one", credentials);
+    const [first, second] = await Promise.all([
+      d.getRateLimitsByTokenId(1), d.getRateLimitsByTokenId(1),
+    ]);
+    expect(first).toEqual(second);
+    expect(first.data.rateLimits.primary?.usedPercent).toBe(20);
+    expect(refreshMock).toHaveBeenCalledExactlyOnceWith(1);
+    expect(new Headers(fetchMock.mock.calls[1]?.[1]?.headers).get("Authorization")).toBe("Bearer new-access");
+    await d.generate(request());
+    expect(factory).toHaveBeenCalledWith(expect.objectContaining({
+      credentials: { accessToken: "new-access", accountId: "acct" },
+    }), 1);
+  });
+
+  it("does not loop when quota still returns 401 after refresh", async () => {
+    const fetchMock = vi.fn().mockImplementation(() => Promise.resolve(new Response("", { status: 401 })));
+    refreshMock.mockResolvedValue({ accessToken: "new-access", chatgptAccountId: "acct" });
+    const d = new OpenAIDispatcher(config(), { fetch: fetchMock });
+    await d.onTokenAdded(1, "one", credentials);
+    await expect(d.getRateLimitsByTokenId(1)).rejects.toThrow("HTTP 401");
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(refreshMock).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([403, 429, 500, 503])("does not refresh credentials for quota HTTP %s", async (status) => {
+    const d = new OpenAIDispatcher(config(), {
+      fetch: vi.fn().mockResolvedValue(new Response("", { status })),
+    });
+    await d.onTokenAdded(1, "one", credentials);
+    await expect(d.getRateLimitsByTokenId(1)).rejects.toThrow(`HTTP ${status}`);
+    expect(refreshMock).not.toHaveBeenCalled();
+    expect(d.tokenCount).toBe(1);
+  });
+
+  it("propagates refresh failure instead of retrying rejected credentials", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response("", { status: 401 }));
+    refreshMock.mockRejectedValue(new Error("OpenAI refresh failed: 401 refresh_token_reused"));
+    const d = new OpenAIDispatcher(config(), { fetch: fetchMock });
+    await d.onTokenAdded(1, "one", credentials);
+    await expect(d.getRateLimitsByTokenId(1)).rejects.toThrow("refresh_token_reused");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("uses a newer subscriber credential and never caches an old generation's lookup", async () => {
+    let finishRefresh!: (value: { accessToken: string; chatgptAccountId: string }) => void;
+    refreshMock.mockImplementation(() => new Promise((resolve) => { finishRefresh = resolve; }));
+    const quota = (percent: number) => new Response(JSON.stringify({
+      rate_limits: { primary_window: { used_percent: percent } },
+    }));
+    const fetchMock = vi.fn()
+      .mockResolvedValueOnce(new Response("", { status: 401 }))
+      .mockResolvedValueOnce(quota(20))
+      .mockResolvedValueOnce(quota(30));
+    const d = new OpenAIDispatcher(config(), { fetch: fetchMock });
+    await d.onTokenAdded(1, "one", credentials);
+    const pending = d.getRateLimitsByTokenId(1);
+    await vi.waitFor(() => expect(refreshMock).toHaveBeenCalledTimes(1));
+    await d.onTokenUpdated(1, "one", { ...credentials, accessToken: "subscriber-access" });
+    finishRefresh({ accessToken: "older-refresh-access", chatgptAccountId: "acct" });
+    await pending;
+    expect(new Headers(fetchMock.mock.calls[1]?.[1]?.headers).get("Authorization")).toBe("Bearer subscriber-access");
+    expect((await d.getRateLimitsByTokenId(1)).data.rateLimits.primary?.usedPercent).toBe(30);
+  });
+
+  it("does not share pending quota requests across subscriber generations", async () => {
+    let finishOld!: (value: Response) => void;
+    const quota = (percent: number) => new Response(JSON.stringify({
+      rate_limits: { primary_window: { used_percent: percent } },
+    }));
+    const fetchMock = vi.fn()
+      .mockImplementationOnce(() => new Promise((resolve) => { finishOld = resolve; }))
+      .mockResolvedValueOnce(quota(10));
+    const d = new OpenAIDispatcher(config(), { fetch: fetchMock });
+    await d.onTokenAdded(1, "one", credentials);
+    const old = d.getRateLimitsByTokenId(1);
+    await d.onTokenUpdated(1, "one", { ...credentials, accessToken: "new" });
+    const current = d.getRateLimitsByTokenId(1);
+    finishOld(quota(90));
+    await old;
+    expect((await current).data.rateLimits.primary?.usedPercent).toBe(10);
+    expect((await d.getRateLimitsByTokenId(1)).data.rateLimits.primary?.usedPercent).toBe(10);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it.each(["transparent", "opaque", "auto"] as const)(
+    "preserves %s background through validation and Responses serialization",
+    async (background) => {
+      const args = QueryInput.parse({
+        model: "openai/gpt-test",
+        prompt: "an isolated red circle",
+        imageGeneration: true,
+        imageGenerationOptions: { background, quality: "high", size: "1024x1024" },
+      });
+      let body: ReturnType<typeof buildOpenAIResponsesRequest> | undefined;
+      const d = dispatcher((options) => {
+        body = buildOpenAIResponsesRequest(options);
+        return events(
+          { type: "image", id: "i", base64: "png", mimeType: "image/png" },
+          { type: "completed", responseId: "r" },
+        );
+      });
+      await d.onTokenAdded(1, "one", credentials);
+      await d.generate(request({
+        imageGeneration: args.imageGeneration,
+        imageGenerationOptions: args.imageGenerationOptions,
+      }));
+      expect(body?.tools).toEqual([{
+        type: "image_generation", background, quality: "high", size: "1024x1024",
+      }]);
+    },
+  );
+
+  it("rejects unsupported image backgrounds", () => {
+    expect(QueryInput.safeParse({
+      prompt: "a circle", imageGeneration: true,
+      imageGenerationOptions: { background: "green" },
+    }).success).toBe(false);
+  });
+
   it("passes the resolved transport to the injectable client factory", async () => {
     const factory = vi.fn(
       (_options: import("./openai-direct-client").OpenAIDirectClientOptions) => ({

package/bundle/src/utils/providers/openai/openai-dispatcher.ts

@@ -112,6 +112,7 @@ function asReasoning(req: GenerateRequest): OpenAIResponsesOptions["reasoning"]
 }
 
 function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
+  const { outputFormat, ...imageControls } = req.imageGenerationOptions ?? {};
   return {
     model: req.model ?? "",
     ...(req.systemPrompt ? { instructions: req.systemPrompt } : {}),
@@ -124,7 +125,14 @@ function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
     ...(req.promptCacheKey ? { promptCacheKey: req.promptCacheKey } : {}),
     ...(req.outputSchema ? { outputSchema: { schema: req.outputSchema as JsonValue } } : {}),
     ...(req.imageGeneration
-      ? { imageGeneration: req.imageGenerationOptions ? { ...req.imageGenerationOptions } : true }
+      ? {
+          imageGeneration: req.imageGenerationOptions
+            ? {
+                ...imageControls,
+                ...(outputFormat ? { output_format: outputFormat } : {}),
+              }
+            : true,
+        }
       : {}),
   };
 }
@@ -143,7 +151,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
   readonly rateLimitsCache = new Map<number, OpenAIRateLimitsWithMeta & { generation: number }>();
   private readonly pendingRateLimits = new Map<
     number,
-    Promise<OpenAIRateLimitsWithMeta & { generation: number }>
+    { token: TokenMetadata; generation: number; promise: Promise<OpenAIRateLimitsWithMeta> }
   >();
   private readonly clients = new Map<number, ClientEntry>();
   private readonly retiredClients = new Set<ClientEntry>();
@@ -318,7 +326,12 @@ export class OpenAIDispatcher implements ProviderDispatcher {
           onDelta?.(event.text);
         } else if (event.type === "image") {
           imageAttempted = true;
-          images.push({ data: event.base64, revisedPrompt: event.revisedPrompt ?? null });
+          images.push({
+            data: event.base64,
+            mediaType: event.mimeType,
+            revisedPrompt: event.revisedPrompt ?? null,
+            ...(event.generation ? { generation: event.generation } : {}),
+          });
         } else if (event.type === "output-item" && event.item.type === "image_generation_call") {
           imageAttempted = true;
         } else if (event.type === "completed" && event.usage) {
@@ -356,6 +369,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
       durationMs: Date.now() - startedAt,
       ttftMs: firstDeltaAt === undefined ? null : firstDeltaAt - startedAt,
       model: servingModel,
+      ...(servingModel !== req.model ? { requestedModel: req.model } : {}),
       threadCoord: { workerId: selection.tokenId, threadId: req.promptCacheKey ?? "", epoch: -1 },
       ...(images.length ? { images } : {}),
     };
@@ -378,17 +392,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
           },
           transportKind: this.transportKind,
           fetch: this.fetchImpl,
-          refreshCredentials: async () => {
-            const refreshed = await handleChatgptAuthTokensRefresh(selection.tokenId);
-            const current = this.tokenMetadata.get(selection.tokenId);
-            if (current)
-              current.credentials = {
-                ...current.credentials,
-                accessToken: refreshed.accessToken,
-                accountId: refreshed.chatgptAccountId,
-              };
-            return { accessToken: refreshed.accessToken, accountId: refreshed.chatgptAccountId };
-          },
+          refreshCredentials: () => this.refreshCredentials(selection.tokenId),
         },
         selection.tokenId,
       );
@@ -519,6 +523,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
   ): Promise<OpenAIRateLimitsWithMeta> {
     const token = this.tokenMetadata.get(tokenId);
     if (!token) throw new Error(`openai token ${tokenId} not found`);
+    const generation = token.generation;
     const cached = this.rateLimitsCache.get(tokenId);
     if (
       cached &&
@@ -531,23 +536,53 @@ export class OpenAIDispatcher implements ProviderDispatcher {
     // 조회가 몰릴 수 있다 — 진행 중인 fetch 를 공유한다. 최초 호출자의 abort 로
     // 공유 조회가 실패해도 소비처(isQuotaEligible)가 fail-open 으로 처리한다.
     const pending = this.pendingRateLimits.get(tokenId);
-    if (pending) return pending;
+    if (pending?.token === token && pending.generation === generation) return pending.promise;
     const fetchPromise = (async () => {
       const result = await readOpenAIQuotaUsage({
         credentials: token.credentials,
+        refreshCredentials: () => this.refreshCredentials(tokenId),
         fetch: this.fetchImpl,
         ...(signal ? { signal } : {}),
       });
       if (result.kind === "lookup_failed") throw new Error(result.reason);
       if (!result.raw) throw new Error("OpenAI quota response missing raw rate limits");
-      const entry = { data: result.raw, cachedAt: Date.now(), generation: token.generation };
-      if (this.tokenMetadata.get(tokenId) === token) this.rateLimitsCache.set(tokenId, entry);
+      const entry = { data: result.raw, cachedAt: Date.now(), generation };
+      if (this.tokenMetadata.get(tokenId) === token && token.generation === generation) {
+        this.rateLimitsCache.set(tokenId, entry);
+      }
       return entry;
-    })().finally(() => this.pendingRateLimits.delete(tokenId));
-    this.pendingRateLimits.set(tokenId, fetchPromise);
+    })().finally(() => {
+      if (this.pendingRateLimits.get(tokenId)?.promise === fetchPromise) {
+        this.pendingRateLimits.delete(tokenId);
+      }
+    });
+    this.pendingRateLimits.set(tokenId, { token, generation, promise: fetchPromise });
     return fetchPromise;
   }
 
+  private async refreshCredentials(tokenId: number) {
+    const previous = this.tokenMetadata.get(tokenId);
+    const generation = previous?.generation;
+    const refreshed = await handleChatgptAuthTokensRefresh(tokenId);
+    const credentials = {
+      accessToken: refreshed.accessToken,
+      accountId: refreshed.chatgptAccountId,
+    };
+    const current = this.tokenMetadata.get(tokenId);
+    if (!current?.active) throw new Error(`openai token ${tokenId} is no longer active`);
+    // A subscriber update may already contain newer credentials. Never overwrite it
+    // with the result of a refresh that started against an older generation.
+    if (current === previous && current.generation === generation) {
+      current.credentials = { ...current.credentials, ...credentials };
+      this.retireClient(tokenId);
+      this.invalidateRateLimitsCache(tokenId);
+    }
+    return {
+      accessToken: current.credentials.accessToken,
+      accountId: current.credentials.accountId,
+    };
+  }
+
   private async isQuotaEligible(
     id: number,
     token: TokenMetadata,