@cartanova/qgrid-cli 2.10.5 → 2.10.6

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

@@ -14,6 +14,7 @@ import {
 import { SmoothWeightedRoundRobin } from "../common/smooth-weighted-round-robin";
 import { ThinkingValidationError } from "../common/thinking";
 import {
+  imageMimeType,
   type JsonValue,
   type OpenAIResponseItem,
   type OpenAIResponsesOptions,
@@ -34,16 +35,25 @@ const THINKING_OFF_MODELS = new Set([
   "gpt-5.5",
 ]);
 const DEFAULT_REQUEST_TIMEOUT_MS = 600_000;
-const TRANSPARENT_IMAGE_TOOL = "generate_transparent_image";
+const IMAGE_TOOL = "generate_image";
+
+type ImageToolArguments = {
+  prompt: string;
+  transparent_background: boolean;
+  num_last_images_to_include: number;
+};
 
 export type ImageFailureKind = "gate" | "not_called" | "incomplete";
 
 export class ImageGenerationError extends Error {
+  completedDriver?: GenerateResult;
+
   constructor(
     readonly kind: ImageFailureKind,
     message: string,
+    options?: ErrorOptions,
   ) {
-    super(message);
+    super(message, options);
     this.name = "ImageGenerationError";
   }
 }
@@ -104,6 +114,26 @@ function inputItems(req: GenerateRequest): OpenAIResponseItem[] {
   return [...history, { type: "message", role: "user", content }];
 }
 
+function imageReferences(req: GenerateRequest): OpenAIResponseItem[] {
+  return inputItems(req).flatMap((item) => {
+    if (item.type === "image_generation_call" && typeof item.result === "string") {
+      return [
+        {
+          type: "input_image",
+          image_url: `data:${imageMimeType(item.result, item.output_format)};base64,${item.result}`,
+        },
+      ];
+    }
+    if (!Array.isArray(item.content)) return [];
+    return item.content.filter(
+      (part): part is OpenAIResponseItem =>
+        part !== null &&
+        typeof part === "object" &&
+        (part.type === "input_image" || part.type === "image_url"),
+    );
+  });
+}
+
 function asReasoning(req: GenerateRequest): OpenAIResponsesOptions["reasoning"] | undefined {
   if (req.thinking === false) return { effort: "none" };
   const summary =
@@ -130,6 +160,9 @@ function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
       "Automatic image generation does not support structured output or external tools",
     );
   }
+  if (auto && outputFormat && outputFormat !== "png") {
+    throw new ImageGenerationError("gate", "Automatic image generation only supports PNG output");
+  }
   return {
     model: req.model ?? "",
     ...(req.systemPrompt ? { instructions: req.systemPrompt } : {}),
@@ -137,7 +170,7 @@ function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
       ? {
           instructions: [
             req.systemPrompt,
-            "Use image_generation for ordinary image generation or editing. Use generate_transparent_image only when a transparent background is requested. Text replies are allowed when no image is needed. Use only one kind of image tool per response, and at most one generate_transparent_image call.",
+            "Use generate_image when image generation or editing is needed; otherwise reply with text. Call it at most once per response. Supply a complete, self-contained prompt with all relevant conversation instructions. Set transparent_background to true only when a transparent background is requested. Set num_last_images_to_include to 0 for a new image without references. For editing or reference-based generation, choose the smallest number of recent conversation images that includes all needed references, at most 5. References retain their chronological order. Do not select images for an unrelated new request.",
           ]
             .filter(Boolean)
             .join("\n\n"),
@@ -145,20 +178,24 @@ function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
           tools: [
             {
               type: "function",
-              name: TRANSPARENT_IMAGE_TOOL,
+              name: IMAGE_TOOL,
               description:
-                "Generate or edit an image with a transparent background using the conversation's reference images.",
-              strict: true,
+                "Generate or edit an image, optionally with a transparent background or recent conversation images as references.",
+              // Astra's subscription backend rejects strict tools; validate arguments locally.
+              strict: false,
               parameters: {
                 type: "object",
                 properties: {
                   prompt: {
                     type: "string",
+                    minLength: 1,
                     description:
-                      "Complete instructions for the transparent image generation or edit.",
+                      "Complete, self-contained instructions for the image generation or edit.",
                   },
+                  transparent_background: { type: "boolean" },
+                  num_last_images_to_include: { type: "integer", minimum: 0, maximum: 5 },
                 },
-                required: ["prompt"],
+                required: ["prompt", "transparent_background", "num_last_images_to_include"],
                 additionalProperties: false,
               },
             },
@@ -173,12 +210,11 @@ function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
       : {}),
     ...(req.promptCacheKey ? { promptCacheKey: req.promptCacheKey } : {}),
     ...(req.outputSchema ? { outputSchema: { schema: req.outputSchema as JsonValue } } : {}),
-    ...(req.imageGeneration
+    ...(req.imageGeneration && !auto
       ? {
           imageGeneration: req.imageGenerationOptions
             ? {
                 ...imageControls,
-                ...(auto ? { background: "auto" } : {}),
                 ...(outputFormat ? { output_format: outputFormat } : {}),
               }
             : true,
@@ -368,12 +404,22 @@ export class OpenAIDispatcher implements ProviderDispatcher {
     const images: GeneratedImage[] = [];
     let imageAttempted = false;
     const auto = req.imageGeneration === "auto";
-    const transparentCalls = new Map<string, string>();
-    const transparentCallIds = new Set<unknown>();
-    let transparentAttempted = false;
+    const imageCalls = new Map<string, ImageToolArguments>();
+    const imageCallIds = new Set<unknown>();
+    let imageToolAttempted = false;
     let driverCompleted = false;
     let servingModel = req.model ?? "";
     const metadata = selection.metadata;
+    const driverResult = (): GenerateResult => ({
+      text,
+      tokenName: metadata.name,
+      usage,
+      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 },
+    });
     const clientEntry = this.acquireClient(selection);
     try {
       for await (const event of clientEntry.client.responses(
@@ -428,6 +474,8 @@ export class OpenAIDispatcher implements ProviderDispatcher {
             streamedMessageIds.add(event.item.id);
           }
         } else if (event.type === "image") {
+          if (auto)
+            throw new ImageGenerationError("incomplete", "Unexpected hosted image generation");
           imageAttempted = true;
           images.push({
             data: event.base64,
@@ -436,20 +484,22 @@ export class OpenAIDispatcher implements ProviderDispatcher {
             ...(event.generation ? { generation: event.generation } : {}),
           });
         } else if (event.type === "output-item" && event.item.type === "image_generation_call") {
+          if (auto)
+            throw new ImageGenerationError("incomplete", "Unexpected hosted image generation");
           imageAttempted = true;
         } else if (auto && event.type === "output-item" && event.item.type === "function_call") {
-          if (event.item.name !== TRANSPARENT_IMAGE_TOOL) {
+          if (event.item.name !== IMAGE_TOOL) {
             throw new ImageGenerationError("incomplete", "Unexpected automatic image tool call");
           }
-          transparentAttempted = true;
-          transparentCallIds.add(event.item.call_id);
+          imageToolAttempted = true;
+          imageCallIds.add(event.item.call_id);
           if (!event.completed) continue;
           const id = event.item.call_id;
           let args: unknown;
           try {
             args = JSON.parse(String(event.item.arguments));
           } catch {
-            throw new ImageGenerationError("incomplete", "Invalid transparent image arguments");
+            throw new ImageGenerationError("incomplete", "Invalid image tool arguments");
           }
           if (
             typeof id !== "string" ||
@@ -457,67 +507,111 @@ export class OpenAIDispatcher implements ProviderDispatcher {
             !args ||
             typeof args !== "object" ||
             Array.isArray(args) ||
-            Object.keys(args).length !== 1 ||
+            Object.keys(args).length !== 3 ||
             !("prompt" in args) ||
             typeof args.prompt !== "string" ||
-            !args.prompt.trim()
+            !args.prompt.trim() ||
+            !("transparent_background" in args) ||
+            typeof args.transparent_background !== "boolean" ||
+            !("num_last_images_to_include" in args) ||
+            typeof args.num_last_images_to_include !== "number" ||
+            !Number.isInteger(args.num_last_images_to_include) ||
+            args.num_last_images_to_include < 0 ||
+            args.num_last_images_to_include > 5
           ) {
-            throw new ImageGenerationError("incomplete", "Invalid transparent image arguments");
+            throw new ImageGenerationError("incomplete", "Invalid image tool arguments");
           }
-          if (transparentCalls.has(id) && transparentCalls.get(id) !== args.prompt) {
-            throw new ImageGenerationError(
-              "incomplete",
-              "Conflicting transparent image tool calls",
-            );
+          const previous = imageCalls.get(id);
+          if (
+            previous &&
+            (previous.prompt !== args.prompt ||
+              previous.transparent_background !== args.transparent_background ||
+              previous.num_last_images_to_include !== args.num_last_images_to_include)
+          ) {
+            throw new ImageGenerationError("incomplete", "Conflicting image tool calls");
           }
-          transparentCalls.set(id, args.prompt);
-        } else if (event.type === "completed" && event.usage) {
-          driverCompleted = true;
-          servingModel = event.model ?? servingModel;
-          usage = {
-            totalTokens: event.usage.totalTokens,
-            inputTokens: event.usage.inputTokens,
-            outputTokens: event.usage.outputTokens,
-            cachedInputTokens: event.usage.cachedInputTokens,
-            reasoningOutputTokens: event.usage.reasoningTokens,
-          };
+          imageCalls.set(id, {
+            prompt: args.prompt,
+            transparent_background: args.transparent_background,
+            num_last_images_to_include: args.num_last_images_to_include,
+          });
         } else if (event.type === "completed") {
+          const imageUsage = event.imageGeneration?.usage;
+          // The backend also reports all-zero image usage for text-only responses.
+          if (
+            auto &&
+            imageUsage &&
+            (imageUsage.input_tokens > 0 ||
+              imageUsage.output_tokens > 0 ||
+              imageUsage.total_tokens > 0)
+          )
+            throw new ImageGenerationError("incomplete", "Unexpected hosted image generation");
           driverCompleted = true;
           servingModel = event.model ?? servingModel;
+          if (event.usage) {
+            usage = {
+              totalTokens: event.usage.totalTokens,
+              inputTokens: event.usage.inputTokens,
+              outputTokens: event.usage.outputTokens,
+              cachedInputTokens: event.usage.cachedInputTokens,
+              reasoningOutputTokens: event.usage.reasoningTokens,
+            };
+          }
+          if (event.imageGeneration) {
+            const hostedImages = images.filter(
+              (image) => image.generation?.route === "codex-responses",
+            );
+            for (const [index, image] of hostedImages.entries()) {
+              image.generation = {
+                route: "codex-responses",
+                ...(event.imageGeneration.model ? { model: event.imageGeneration.model } : {}),
+                ...image.generation,
+                // Tool usage covers the whole response, not each returned image.
+                ...(index === 0 && event.imageGeneration.usage
+                  ? { usage: event.imageGeneration.usage }
+                  : {}),
+              };
+            }
+          }
         } else if (event.type === "error") {
           if (req.imageGeneration)
             throw new ImageGenerationError("incomplete", event.error.message);
           throw event.error;
         }
       }
-      if (auto && transparentAttempted) {
-        if (
-          !driverCompleted ||
-          transparentCalls.size !== 1 ||
-          transparentCallIds.size !== 1 ||
-          imageAttempted
-        ) {
+      if (auto && imageToolAttempted) {
+        if (!driverCompleted || imageCalls.size !== 1 || imageCallIds.size !== 1) {
+          throw new ImageGenerationError("incomplete", "Expected one completed image tool call");
+        }
+        if (req.abortSignal?.aborted) throw abortError(req.abortSignal);
+        const args = [...imageCalls.values()][0]!;
+        const referenceCount = args.num_last_images_to_include;
+        const references = referenceCount ? imageReferences(req) : [];
+        if (referenceCount > references.length) {
           throw new ImageGenerationError(
             "incomplete",
-            "Expected one completed transparent image call without another image tool",
+            "Requested image references are unavailable",
           );
         }
-        if (req.abortSignal?.aborted) throw abortError(req.abortSignal);
-        const prompt = [...transparentCalls.values()][0]!;
         let imageCompleted = false;
         for await (const event of clientEntry.client.responses(
           {
-            model: req.model ?? "",
-            ...(req.systemPrompt ? { instructions: req.systemPrompt } : {}),
+            model: "gpt-image-2",
             history: [
-              ...inputItems(req),
-              { type: "message", role: "user", content: [{ type: "input_text", text: prompt }] },
+              {
+                type: "message",
+                role: "user",
+                content: [
+                  { type: "input_text", text: args.prompt },
+                  ...(referenceCount ? references.slice(-referenceCount) : []),
+                ],
+              },
             ],
             imageGeneration: {
               quality: req.imageGenerationOptions?.quality,
               size: req.imageGenerationOptions?.size,
               output_format: "png",
-              background: "transparent",
+              background: args.transparent_background ? "transparent" : "opaque",
             },
           },
           req.abortSignal,
@@ -531,38 +625,46 @@ export class OpenAIDispatcher implements ProviderDispatcher {
             });
           else if (event.type === "completed") imageCompleted = true;
           else if (event.type === "error")
-            throw new ImageGenerationError("incomplete", event.error.message);
+            throw new ImageGenerationError("incomplete", event.error.message, {
+              cause: event.error,
+            });
         }
         imageAttempted = true;
         if (!imageCompleted)
-          throw new ImageGenerationError(
-            "incomplete",
-            "Transparent image generation did not complete",
-          );
+          throw new ImageGenerationError("incomplete", "Image generation did not complete");
       }
       if (auto && imageAttempted && !driverCompleted)
         throw new ImageGenerationError("incomplete", "Image generation response did not complete");
       if (req.abortSignal?.aborted) throw abortError(req.abortSignal);
+      if ((req.imageGeneration === true || (auto && imageAttempted)) && images.length === 0) {
+        throw new ImageGenerationError(
+          imageAttempted ? "incomplete" : "not_called",
+          imageAttempted
+            ? "image generation did not complete"
+            : "model did not call image generation",
+        );
+      }
+    } catch (error) {
+      if (auto && driverCompleted && imageToolAttempted) {
+        const failure =
+          error instanceof ImageGenerationError
+            ? error
+            : new ImageGenerationError(
+                "incomplete",
+                error instanceof Error ? error.message : String(error),
+                { cause: error },
+              );
+        if (error instanceof Error) failure.name = error.name;
+        // Only the completed chat stage is chargeable here; discard partial image output.
+        failure.completedDriver = driverResult();
+        throw failure;
+      }
+      throw error;
     } finally {
       this.releaseClient(clientEntry);
     }
-    if ((req.imageGeneration === true || (auto && imageAttempted)) && images.length === 0) {
-      throw new ImageGenerationError(
-        imageAttempted ? "incomplete" : "not_called",
-        imageAttempted
-          ? "image generation did not complete"
-          : "model did not call image generation",
-      );
-    }
     return {
-      text,
-      tokenName: metadata.name,
-      usage,
-      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 },
+      ...driverResult(),
       ...(images.length ? { images } : {}),
     };
   }

package/bundle/src/utils/providers/openai/openai-image-generation.test.ts

@@ -150,3 +150,92 @@ describe("standalone transparent images", () => {
     expect(fetchMock).not.toHaveBeenCalled();
   });
 });
+
+describe("standalone image model", () => {
+  it.each([true, { background: "opaque" }, { background: "auto" }])(
+    "generates ordinary PNGs directly without the Responses transport (%j)",
+    async (imageGeneration) => {
+      const stream = vi.fn();
+      const fetchMock = vi.fn<typeof fetch>(async () => Response.json({
+        data: [{ b64_json: png([255, 255]) }],
+      }));
+      const client = new OpenAIDirectClient({
+        credentials: { accessToken: "subscription-token", accountId: "account" },
+        fetch: fetchMock,
+        transport: { stream },
+      });
+      const events = await Array.fromAsync(client.responses({
+        ...options, model: "gpt-image-2", imageGeneration,
+      }));
+      expect(stream).not.toHaveBeenCalled();
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const [url, init] = fetchMock.mock.calls[0]!;
+      expect(url).toBe("https://chatgpt.com/backend-api/codex/images/generations");
+      expect(init?.headers).toMatchObject({
+        Authorization: "Bearer subscription-token", "ChatGPT-Account-ID": "account",
+        Accept: "application/json",
+      });
+      const body = JSON.parse(String(init?.body));
+      expect(body.model).toBe("gpt-image-2");
+      expect(body.background).toBe(typeof imageGeneration === "object" ? imageGeneration.background : undefined);
+      expect(events[0]).toMatchObject({
+        type: "image", mimeType: "image/png",
+        generation: { route: "codex-images", model: "gpt-image-2", size: "2x1" },
+      });
+      expect(events[0]).not.toHaveProperty("generation.background");
+      expect(events[0]).not.toHaveProperty("generation.quality");
+      expect(events[1]).toMatchObject({ type: "completed", model: "gpt-image-2" });
+      expect(events[1]).not.toHaveProperty("usage");
+    },
+  );
+
+  it("edits references and preserves observed settings and aggregate usage once", async () => {
+    const usage = {
+      input_tokens: 2260, output_tokens: 1415, total_tokens: 3675,
+      input_tokens_details: { text_tokens: 248, image_tokens: 2012 },
+    };
+    const fetchMock = vi.fn<typeof fetch>(async () => Response.json({
+      model: "gpt-image-2-codex", quality: "medium", background: "opaque", size: "1024x1536",
+      data: [{ b64_json: png([255, 255]), revised_prompt: "A red circle." }, { b64_json: png() }],
+      usage,
+    }));
+    const events = await run(fetchMock, {
+      model: "gpt-image-2",
+      imageGeneration: { background: "auto", quality: "high", size: "1024x1536", output_format: "png" },
+      history: [{ role: "user", content: [
+        { type: "input_text", text: "Use these references." },
+        { type: "input_image", image_url: "data:image/png;base64,reference" },
+        { type: "input_image", image_url: "https://example.com/reference.png" },
+      ] }],
+    });
+    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://chatgpt.com/backend-api/codex/images/edits");
+    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toMatchObject({
+      model: "gpt-image-2", background: "auto", quality: "high", size: "1024x1536",
+      images: [{ image_url: "data:image/png;base64,reference" }, { image_url: "https://example.com/reference.png" }],
+    });
+    expect(events[0]).toMatchObject({
+      type: "image", revisedPrompt: "A red circle.",
+      generation: { model: "gpt-image-2-codex", background: "opaque", quality: "medium", size: "2x1", usage },
+    });
+    expect(events[1]).not.toHaveProperty("generation.usage");
+    expect(events[2]).toMatchObject({ type: "completed", model: "gpt-image-2-codex" });
+    expect(events[2]).not.toHaveProperty("usage");
+  });
+
+  it.each([
+    { imageGeneration: false },
+    { imageGeneration: undefined },
+    { imageGeneration: { output_format: "webp" } },
+    { imageGeneration: { output_format: "jpeg" } },
+  ])("rejects disabled generation and unsupported output formats before I/O (%j)", async (overrides) => {
+    const fetchMock = vi.fn<typeof fetch>();
+    await expect(run(fetchMock, { model: "gpt-image-2", ...overrides })).rejects.toThrow(/enabled|PNG/);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("validates decoded PNG content on the ordinary route", async () => {
+    const fetchMock = vi.fn<typeof fetch>(async () => Response.json(result("bm90IHBuZw==")));
+    await expect(run(fetchMock, { model: "gpt-image-2", imageGeneration: true })).rejects.toThrow(/PNG/);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+});

package/bundle/src/utils/providers/openai/openai-image-generation.ts

@@ -18,17 +18,20 @@ const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
   if (options.outputSchema || options.tools?.length) {
     throw new OpenAIProtocolError(
-      "Transparent image generation does not support tools or structured output",
+      "Standalone image generation does not support tools or structured output",
     );
   }
-  const controls = options.imageGeneration;
-  if (!controls || controls === true || controls.background !== "transparent") {
+  if (!options.imageGeneration) {
+    throw new OpenAIProtocolError("Standalone images require image generation to be enabled");
+  }
+  const controls = typeof options.imageGeneration === "object" ? options.imageGeneration : {};
+  if (options.model !== "gpt-image-2" && controls.background !== "transparent") {
     throw new OpenAIProtocolError(
       "Standalone images require an explicit transparent background request",
     );
   }
   if (controls.output_format && controls.output_format !== "png") {
-    throw new OpenAIProtocolError("Transparent image generation only supports PNG output");
+    throw new OpenAIProtocolError("Standalone image generation only supports PNG output");
   }
   const text: string[] = [];
   const images: Array<{ image_url: string }> = [];
@@ -43,7 +46,7 @@ export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
     }
     if (item.type !== "message" && typeof item.role !== "string") {
       throw new OpenAIProtocolError(
-        "Unsupported conversation item for transparent image generation",
+        "Unsupported conversation item for standalone image generation",
       );
     }
     if (typeof item.content === "string") {
@@ -51,11 +54,11 @@ export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
       continue;
     }
     if (!Array.isArray(item.content)) {
-      throw new OpenAIProtocolError("Unsupported message content for transparent image generation");
+      throw new OpenAIProtocolError("Unsupported message content for standalone image generation");
     }
     for (const part of item.content) {
       if (!part || typeof part !== "object") {
-        throw new OpenAIProtocolError("Unsupported message part for transparent image generation");
+        throw new OpenAIProtocolError("Unsupported message part for standalone image generation");
       }
       if (
         ["input_text", "output_text", "text"].includes(part.type) &&
@@ -69,12 +72,12 @@ export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
         }
         images.push({ image_url: url });
       } else {
-        throw new OpenAIProtocolError("Unsupported message part for transparent image generation");
+        throw new OpenAIProtocolError("Unsupported message part for standalone image generation");
       }
     }
   }
   if (images.length > 5)
-    throw new OpenAIProtocolError("Transparent image editing supports at most 5 reference images");
+    throw new OpenAIProtocolError("Standalone image editing supports at most 5 reference images");
   if (!text.some((part) => part.trim())) throw new OpenAIProtocolError("Image prompt is empty");
   return {
     url: CHATGPT_CODEX_RESPONSES_URL.replace(
@@ -84,7 +87,7 @@ export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
     body: {
       model: "gpt-image-2",
       prompt: text.join("\n\n"),
-      background: "transparent",
+      ...(controls.background ? { background: controls.background } : {}),
       ...(controls.quality ? { quality: controls.quality } : {}),
       ...(controls.size ? { size: controls.size } : {}),
       ...(images.length ? { images } : {}),
@@ -92,8 +95,10 @@ export function buildStandaloneImageRequest(options: OpenAIResponsesOptions) {
   };
 }
 
-// Decode before accepting the result: an alpha channel alone can still be fully opaque.
-export function inspectTransparentPng(base64: string): { width: number; height: number } {
+function inspectGeneratedPng(
+  base64: string,
+  requireTransparency: boolean,
+): { width: number; height: number } {
   if (base64.length > Math.ceil(MAX_PNG_BYTES / 3) * 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(base64)) {
     throw new OpenAIProtocolError("Invalid or oversized generated PNG");
   }
@@ -116,6 +121,8 @@ export function inspectTransparentPng(base64: string): { width: number; height:
   } catch {
     throw new OpenAIProtocolError("Image generation returned an invalid PNG");
   }
+  if (!requireTransparency) return { width: image.width, height: image.height };
+  // An alpha channel alone can still be fully opaque or have no visible content.
   let transparent = false;
   let visible = false;
   for (let i = 3; i < image.data.length; i += 4) {
@@ -130,6 +137,7 @@ export function inspectTransparentPng(base64: string): { width: number; height:
 
 export async function readStandaloneImageResponse(
   response: Response,
+  requireTransparency: boolean,
 ): Promise<OpenAINormalizedEvent[]> {
   if (!response.body) throw new OpenAIProtocolError("Image response had no body");
   const reader = response.body.getReader();
@@ -155,6 +163,8 @@ export async function readStandaloneImageResponse(
       .min(1)
       .max(16),
     quality: z.string().optional(),
+    model: z.string().optional(),
+    background: z.string().optional(),
     usage: ImageGenerationMetadata.shape.usage,
   });
   let parsed: z.infer<typeof schema>;
@@ -163,8 +173,9 @@ export async function readStandaloneImageResponse(
   } catch {
     throw new OpenAIProtocolError("Invalid standalone image response");
   }
+  const background = parsed.background ?? (requireTransparency ? "transparent" : undefined);
   return parsed.data.map((item, index) => {
-    const dimensions = inspectTransparentPng(item.b64_json);
+    const dimensions = inspectGeneratedPng(item.b64_json, requireTransparency);
     return {
       type: "image",
       base64: item.b64_json,
@@ -172,8 +183,8 @@ export async function readStandaloneImageResponse(
       ...(item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {}),
       generation: {
         route: "codex-images",
-        model: "gpt-image-2",
-        background: "transparent",
+        model: parsed.model ?? "gpt-image-2",
+        ...(background ? { background } : {}),
         size: `${dimensions.width}x${dimensions.height}`,
         ...(parsed.quality ? { quality: parsed.quality } : {}),
         ...(index === 0 && parsed.usage ? { usage: parsed.usage } : {}),

package/bundle/web-dist/client/assets/cost-DH2jZbrw.js

@@ -0,0 +1 @@
+var e=1e6,t=4;function n(t){return t/e}function r(e){return`$${e.toFixed(t)}`}function i(e){return r(n(e))}function a(e){return e.cost_usd===null&&e.image_cost_usd===null?`—`:r(n((e.cost_usd??0)+(e.image_cost_usd??0)))}function o(e){return e.input_tokens<=0?`—`:`${Math.round(e.cache_read_tokens/e.input_tokens*100)}%`}export{r as i,i as n,a as r,o as t};