@cartanova/qgrid-cli 2.9.7 → 2.9.10

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

@@ -327,7 +327,8 @@ Content-Type: application/json
     "imageGenerationOptions": {
       "quality": "low",
       "size": "1024x1024",
-      "background": "auto"
+      "background": "auto",
+      "outputFormat": "png"
     }
   }
 }
@@ -390,7 +391,8 @@ Content-Type: application/json
     "imageGenerationOptions": {
       "quality": "low",
       "size": "1024x1024",
-      "background": "auto"
+      "background": "auto",
+      "outputFormat": "png"
     }
   }
 }

package/bundle/src/utils/providers/anthropic/anthropic-constants.test.ts

@@ -35,6 +35,7 @@ describe("Anthropic 1M context policy", () => {
     expect(supports1MContext("claude-opus-5")).toBe(true);
     expect(supports1MContext("claude-opus-5-5")).toBe(true);
     expect(supports1MContext("claude-sonnet-5")).toBe(true);
+    expect(supports1MContext("claude-sonnet-5-5")).toBe(true);
     expect(supports1MContext("claude-sonnet-4-6")).toBe(true);
     expect(supports1MContext("claude-opus-4-6")).toBe(true);
     expect(supports1MContext("claude-opus-4-8")).toBe(true);
@@ -51,6 +52,7 @@ describe("Anthropic 1M context policy", () => {
     expect(needsCli1mSuffix("claude-opus-5")).toBe(false);
     expect(needsCli1mSuffix("claude-opus-5-5")).toBe(false);
     expect(needsCli1mSuffix("claude-sonnet-5")).toBe(false);
+    expect(needsCli1mSuffix("claude-sonnet-5-5")).toBe(false);
     expect(needsCli1mSuffix("claude-sonnet-4-6")).toBe(true);
     expect(needsCli1mSuffix("claude-opus-4-6")).toBe(true);
     expect(needsCli1mSuffix("claude-opus-4-8")).toBe(false);
@@ -80,7 +82,7 @@ describe("Anthropic 1M context policy", () => {
 });
 
 describe("Anthropic thinking policy", () => {
-  it("Fable 5/5.1, Opus 5, Opus 5.5 는 adaptive thinking 을 보존한다", () => {
+  it("Fable 5/5.1, Opus 5, Opus 5.5, Sonnet 5.5 는 adaptive thinking 을 보존한다", () => {
     expect(usesAdaptiveThinking("claude-fable-5-1")).toBe(true);
     expect(usesAdaptiveThinking("anthropic/claude-fable-5-1")).toBe(true);
     expect(usesAdaptiveThinking("claude-fable-5")).toBe(true);
@@ -89,6 +91,8 @@ describe("Anthropic thinking policy", () => {
     expect(usesAdaptiveThinking("anthropic/claude-opus-5")).toBe(true);
     expect(usesAdaptiveThinking("claude-opus-5-5")).toBe(true);
     expect(usesAdaptiveThinking("anthropic/claude-opus-5-5[1m]")).toBe(true);
+    expect(usesAdaptiveThinking("claude-sonnet-5-5")).toBe(true);
+    expect(usesAdaptiveThinking("anthropic/claude-sonnet-5-5[1m]")).toBe(true);
     expect(usesAdaptiveThinking("claude-sonnet-5")).toBe(false);
     expect(usesAdaptiveThinking("claude-opus-4-8")).toBe(false);
   });

package/bundle/src/utils/providers/anthropic/anthropic-constants.ts

@@ -49,6 +49,7 @@ const ONE_MILLION_CONTEXT_MODELS = new Set([
   "claude-fable-5",
   "claude-opus-5",
   "claude-opus-5-5",
+  "claude-sonnet-5-5",
   "claude-sonnet-5",
   "claude-sonnet-4-6",
   "claude-opus-4-6",
@@ -56,8 +57,8 @@ const ONE_MILLION_CONTEXT_MODELS = new Set([
 ]);
 
 const CLI_ONE_MILLION_SUFFIX_MODELS = new Set(["claude-sonnet-4-6", "claude-opus-4-6"]);
-// Fable 5/5.1 과 Opus 5.5 는 adaptive thinking 이 유일한 모드다(Fable: CLI 카탈로그 `rejects_disabled_thinking`,
-// Opus 5.5: 공식 사양 "can't be turned off", 2026-09-22 출시). Opus 5 는
+// Fable 5/5.1, Opus 5.5, Sonnet 5.5 는 thinking disabled 를 거부한다(Fable: CLI 카탈로그 `rejects_disabled_thinking`,
+// Opus 5.5: 공식 사양 "can't be turned off", 2026-09-22 출시. Sonnet 5.5: API `{type: "disabled"}` 400, CLI 카탈로그 `rejects_disabled_thinking`, 2026-09-29 출시). Opus 5 는
 // disabled 를 high 이하에서 지원하지만, 공식 기본값·권장 동작인 adaptive thinking 을 유지한다. qgrid
 // 기본 effort=low 가 비용/지연 제어를 맡으며, 이 정책은 disabled+xhigh/max 400 오류와 disabled 시
 // tool/XML 출력 오염도 피한다.
@@ -66,6 +67,7 @@ const ADAPTIVE_THINKING_MODELS = new Set([
   "claude-fable-5",
   "claude-opus-5",
   "claude-opus-5-5",
+  "claude-sonnet-5-5",
 ]);
 
 // Fable 계열: 구독 플랜에서 usage credits 가 필요한 최상위 티어. 구독 usage API 의

package/bundle/src/utils/providers/common/effort.test.ts

@@ -23,6 +23,7 @@ describe("resolveOpenAIEffort", () => {
     expect(resolveOpenAIEffort("gpt-5.6-terra", "max")).toBe("max");
     expect(resolveOpenAIEffort("gpt-5.6-terra", "ultra")).toBe("ultra");
     expect(resolveOpenAIEffort("gpt-5.6-luna", "max")).toBe("max");
+    expect(resolveOpenAIEffort("gpt-6.1-sol", "ultra")).toBe("ultra");
     expect(resolveOpenAIEffort("gpt-6-sol", "ultra")).toBe("ultra");
     expect(resolveOpenAIEffort("gpt-6-luna", "max")).toBe("max");
   });

package/bundle/src/utils/providers/common/model-cost.test.ts

@@ -13,6 +13,7 @@ describe("calculateCostUsd", () => {
   });
   it.each([
     ["gpt-6-astra", 10, 50, 1, 12.5],
+    ["gpt-6.1-sol", 2, 10, 0.1, 2.5],
     ["gpt-6-sol", 2, 10, 0.2, 2.5],
     ["gpt-6-luna", 0.1, 0.5, 0.01, 0.125],
     ["gpt-5.6-sol", 4, 20, 0.4, 5],
@@ -59,6 +60,7 @@ describe("calculateCostUsd", () => {
     // Opus 5.5 는 cache read 만 0.05x 특례($0.20), cache write 배율은 표준(5m $5 / 1h $8).
     ["claude-opus-5-5", 4, 20, 0.2, 8],
     ["claude-sonnet-5", 2, 10, 0.2, 4],
+    ["claude-sonnet-5-5", 2, 10, 0.2, 4],
   ])(
     "%s official Anthropic rates for 5m/1h cache writes",
     (model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens) => {
@@ -96,6 +98,7 @@ describe("calculateCostUsd", () => {
 
   it.each([
     ["gpt-6-astra", 10, 50, 1, 12.5, 5.6125],
+    ["gpt-6.1-sol", 2, 10, 0.1, 2.5, 1.1175],
     ["gpt-6-sol", 2, 10, 0.2, 2.5, 1.1225],
     ["gpt-6-luna", 0.1, 0.5, 0.01, 0.125, 0.056125],
     ["gpt-5.6-sol", 4, 20, 0.4, 5, 2.245],
@@ -124,6 +127,7 @@ describe("calculateCostUsd", () => {
 
   it.each([
     ["gpt-6-astra", 2.475],
+    ["gpt-6.1-sol", 0.455],
     ["gpt-6-sol", 0.495],
     ["gpt-6-luna", 0.02475],
     ["gpt-5.6-sol", 0.99],
@@ -141,6 +145,7 @@ describe("calculateCostUsd", () => {
 
   it.each([
     ["gpt-6-astra", 2.725],
+    ["gpt-6.1-sol", 0.505],
     ["gpt-6-sol", 0.545],
     ["gpt-6-luna", 0.02725],
     ["gpt-5.6-sol", 1.09],

package/bundle/src/utils/providers/common/model-cost.ts

@@ -65,6 +65,18 @@ const OPENAI_COSTS: Record<string, OpenAIModelSpec> = {
     cacheCreationInputTokens: 12.5,
     longContext: LONG_CONTEXT_272K,
   },
+  // GPT-6.1 Sol (2026-09-29 DevDay 출시): Standard API pricing verified 2026-09-30. GPT-6 Sol 과 같고 cached input 만 절반.
+  // Codex 카탈로그(2026-09-30)는 ultra 까지 허용하고 기본 effort 는 low 다(GPT-6 Sol 은 medium).
+  // qgrid 의 요청 형태 + codex_cli_rs/0.147.0 헤더로 2026-09-30 구독 경로 라이브 생성 성공.
+  // @see https://developers.openai.com/api/docs/models/gpt-6.1-sol
+  "gpt-6.1-sol": {
+    maxEffort: "ultra",
+    inputTokens: 2,
+    outputTokens: 10,
+    cachedInputTokens: 0.1,
+    cacheCreationInputTokens: 2.5,
+    longContext: LONG_CONTEXT_272K,
+  },
   // GPT-6 Sol, Luna (2026-09-22 출시): Standard API pricing verified 2026-09-23. GPT-5.6 Sol/Luna 의 절반 단가.
   // Codex 카탈로그(2026-09-23)는 Sol 에 ultra, Luna 에 max 까지 허용하고 기본 effort 는 둘 다 medium 이다.
   // @see https://developers.openai.com/api/docs/models/gpt-6-sol
@@ -188,6 +200,9 @@ const ANTHROPIC_COSTS: Record<string, ModelCosts> = {
   // Sonnet 5 의 introductory $2/$10 이 정식 단가로 확정됐다. 2026-09-01 에 예정됐던 $3/$15 인상은
   // 취소됐으므로 날짜 분기 없이 고정 단가로 계산한다.
   "claude-sonnet-5": anthropicCosts(2, 10),
+  // Sonnet 5.5 (2026-09-29 출시): Sonnet 5 와 같은 $2/$10, cache read 는 표준 0.1x($0.20).
+  // @see https://platform.claude.com/docs/en/about-claude/pricing
+  "claude-sonnet-5-5": anthropicCosts(2, 10),
 };
 
 // gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.

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

@@ -79,7 +79,7 @@ export interface GenerateRequest {
   reuseInput?: Array<UserInput>;
   // OpenAI image_generation tool 을 켠다(OpenAI 경로 전용, opt-in).
   // 이 플래그가 있으면 dispatcher 는 항상 cold thread 로 실행하고 재사용 라우팅을 건너뛴다.
-  imageGeneration?: boolean;
+  imageGeneration?: boolean | "auto";
   imageGenerationOptions?: ImageGenerationOptions;
 }
 

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

@@ -8,6 +8,11 @@ import {
 } from "./openai-backend-protocol";
 
 describe("OpenAI Codex backend protocol", () => {
+  it("distinguishes partial function items from completed arguments", () => {
+    const item = { type: "function_call", call_id: "call", name: "generate_transparent_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 });
+  });
   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",

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

@@ -179,7 +179,7 @@ export type OpenAINormalizedEvent =
       revisedPrompt?: string;
       generation?: ImageGenerationMetadata;
     }
-  | { type: "output-item"; item: OpenAIResponseItem }
+  | { type: "output-item"; item: OpenAIResponseItem; completed?: boolean }
   | { type: "completed"; responseId: string; usage?: OpenAIUsage; model?: string }
   | { type: "error"; error: OpenAIProtocolError };
 
@@ -256,7 +256,7 @@ export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | unde
             : {}),
       };
     }
-    return { type: "output-item", item };
+    return { type: "output-item", item, completed: type === "response.output_item.done" };
   }
   if (type === "response.completed") {
     const response = (event.response ?? {}) as Record<string, unknown>;

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

@@ -295,6 +295,120 @@ describe("OpenAIDispatcher direct runtime", () => {
     expect(complete).toHaveBeenCalledWith(expect.objectContaining({ text: "ab" }));
   });
 
+  it("returns multiple hosted images with one driver request", async () => {
+    const run = vi.fn(() => events(
+      { type: "image", id: "first", base64: "first", mimeType: "image/png" },
+      { type: "image", id: "second", base64: "second", mimeType: "image/webp" },
+      { type: "completed", responseId: "driver" },
+    ));
+    const d = dispatcher(run);
+    await d.onTokenAdded(1, "one", credentials);
+    const result = await d.generate(request({ imageGeneration: "auto" }));
+    expect(result.images).toMatchObject([{ data: "first", mediaType: "image/png" }, { data: "second", mediaType: "image/webp" }]);
+    expect(run).toHaveBeenCalledTimes(1);
+  });
+
+  it("lets automatic mode return text or a hosted image with one driver request", async () => {
+    for (const image of [false, true]) {
+      const run = vi.fn((options: OpenAIResponsesOptions) => {
+        const body = buildOpenAIResponsesRequest(options);
+        expect(body.parallel_tool_calls).toBe(false);
+        expect(body.tools).toEqual(expect.arrayContaining([{ type: "image_generation" }, expect.objectContaining({ name: "generate_transparent_image" })]));
+        return events(...(image ? [{ type: "image" as const, base64: "png", mimeType: "image/png" as const }] : [{ type: "text-delta" as const, text: "hello" }]), { type: "completed", responseId: "r" });
+      });
+      const d = dispatcher(run);
+      await d.onTokenAdded(1, "one", credentials);
+      const result = await d.generate(request({ imageGeneration: "auto" }));
+      expect(run).toHaveBeenCalledTimes(1);
+      expect(image ? result.images?.length : result.text).toBe(image ? 1 : "hello");
+    }
+  });
+
+  it("runs one standalone transparent call after completed arguments and preserves driver accounting", async () => {
+    const calls: OpenAIResponsesOptions[] = [];
+    const signals: Array<AbortSignal | undefined> = [];
+    const item = { type: "function_call", call_id: "call", name: "generate_transparent_image", arguments: JSON.stringify({ prompt: "remove background" }) };
+    const d = dispatcher((options, signal) => {
+      calls.push(options); signals.push(signal);
+      if (calls.length === 1) return events(
+        { type: "output-item", item: { ...item, arguments: "" }, completed: false },
+        { type: "output-item", item, completed: true },
+        { type: "output-item", item, completed: true },
+        { type: "completed", responseId: "driver", model: "actual-driver", usage: { inputTokens: 10, cachedInputTokens: 2, outputTokens: 3, reasoningTokens: 1, totalTokens: 13 } },
+      );
+      return events({ type: "image", base64: "png", mimeType: "image/png", generation: { route: "codex-images", model: "gpt-image-2" } }, { type: "completed", responseId: "image", model: "gpt-image-2", usage: { inputTokens: 999, outputTokens: 999, cachedInputTokens: 0, reasoningTokens: 0, totalTokens: 1998 } });
+    });
+    await d.onTokenAdded(1, "one", credentials);
+    const history = [{ type: "message", role: "user", content: [{ type: "input_image", image_url: "https://example.com/ref.png" }] }];
+    const result = await d.generate(request({ imageGeneration: "auto", systemPrompt: "system", coldHistory: history, imageGenerationOptions: { outputFormat: "webp" } }));
+    expect(calls).toHaveLength(2);
+    expect(calls[1]).toMatchObject({ instructions: "system", imageGeneration: { background: "transparent", output_format: "png" } });
+    expect(calls[1]!.history[0]).toEqual(history[0]);
+    expect(calls[1]!.tools).toBeUndefined();
+    expect(calls[1]!.outputSchema).toBeUndefined();
+    expect(signals[0]).toBe(signals[1]);
+    expect(result).toMatchObject({ model: "actual-driver", usage: { inputTokens: 10, outputTokens: 3, totalTokens: 13 }, images: [{ generation: { model: "gpt-image-2" } }] });
+  });
+
+  it("rejects incomplete, invalid, multiple and mixed automatic image calls before standalone execution", async () => {
+    const item = { type: "function_call", call_id: "call", name: "generate_transparent_image", arguments: JSON.stringify({ prompt: "remove background" }) };
+    const done = { type: "output-item" as const, item, completed: true };
+    const badEvents: OpenAINormalizedEvent[][] = [
+      [{ ...done, completed: false }],
+      [{ ...done, item: { ...item, arguments: '{"prompt":"x","extra":true}' } }],
+      [done, { ...done, item: { ...item, call_id: "second" } }],
+      [done, { type: "image", base64: "png", mimeType: "image/png" }],
+      [{ type: "output-item", item: { type: "image_generation_call" }, completed: false }],
+    ];
+    for (const stream of badEvents) {
+      const run = vi.fn(() => events(...stream, { type: "completed", responseId: "driver" }));
+      const d = dispatcher(run);
+      await d.onTokenAdded(1, "one", credentials);
+      await expect(d.generate(request({ imageGeneration: "auto" }))).rejects.toMatchObject({ kind: "incomplete" });
+      expect(run).toHaveBeenCalledTimes(1);
+    }
+  });
+
+  it("rejects structured output in auto mode before transport", async () => {
+    const run = vi.fn(() => events());
+    const d = dispatcher(run);
+    await d.onTokenAdded(1, "one", credentials);
+    await expect(d.generate(request({ imageGeneration: "auto", outputSchema: { type: "object" } }))).rejects.toMatchObject({ kind: "gate" });
+    expect(run).not.toHaveBeenCalled();
+  });
+
+  it.each(["missing-image", "missing-completion", "cancel"])("rejects standalone %s", async (failure) => {
+    const controller = new AbortController();
+    let count = 0;
+    const d = dispatcher(async function* (_options, signal) {
+      count++;
+      if (count === 1) {
+        yield { type: "output-item", completed: true, item: { type: "function_call", call_id: "call", name: "generate_transparent_image", arguments: '{"prompt":"transparent"}' } };
+        yield { type: "completed", responseId: "driver" };
+      } else {
+        if (failure === "cancel") { controller.abort(); expect(signal?.aborted).toBe(true); throw signal!.reason; }
+        if (failure === "missing-image") yield { type: "completed", responseId: "image" };
+        else yield { type: "image", base64: "png", mimeType: "image/png" };
+      }
+    });
+    await d.onTokenAdded(1, "one", credentials);
+    await expect(d.generate(request({ imageGeneration: "auto", abortSignal: controller.signal }))).rejects.toMatchObject(failure === "cancel" ? { name: "AbortError" } : { kind: "incomplete" });
+    expect(count).toBe(2);
+  });
+
+  it("does not start standalone generation after cancellation", async () => {
+    const controller = new AbortController();
+    const run = vi.fn(async function* () {
+      yield { type: "output-item" as const, completed: true, item: { type: "function_call", call_id: "call", name: "generate_transparent_image", arguments: '{"prompt":"transparent"}' } };
+      yield { type: "completed" as const, responseId: "driver" };
+      controller.abort();
+    });
+    const d = dispatcher(run);
+    await d.onTokenAdded(1, "one", credentials);
+    await expect(d.generate(request({ imageGeneration: "auto", abortSignal: controller.signal }))).rejects.toMatchObject({ name: "AbortError" });
+    expect(run).toHaveBeenCalledTimes(1);
+  });
+
   it("maps images and preserves image failure classifications", async () => {
     const success = dispatcher(() =>
       events(
@@ -584,6 +698,7 @@ describe("effort 어휘 해석 (Codex 카탈로그 기준)", () => {
 
   it("모델이 지원하는 값은 그대로 보내고, 상한 초과·공개 API 어휘는 reasoning 에서 빼 백엔드 기본값을 쓴다", async () => {
     await expect(mappedEffortFor("gpt-6-astra", "ultra")).resolves.toBe("ultra");
+    await expect(mappedEffortFor("gpt-6.1-sol", "ultra")).resolves.toBe("ultra");
     await expect(mappedEffortFor("gpt-6-sol", "ultra")).resolves.toBe("ultra");
     await expect(mappedEffortFor("gpt-6-luna", "max")).resolves.toBe("max");
     await expect(mappedEffortFor("gpt-6-luna", "ultra")).resolves.toBeUndefined();

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

@@ -26,6 +26,7 @@ const logger = getLogger(["qgrid", "openai-dispatcher"]);
 // 교체된 codex worker 가 강제하던 watchdog. 호출자가 timeoutMs 를 생략해도 요청이
 // 영원히 매달리지 않도록 direct transport 도 유한한 기본 상한을 유지한다.
 const DEFAULT_REQUEST_TIMEOUT_MS = 600_000;
+const TRANSPARENT_IMAGE_TOOL = "generate_transparent_image";
 
 export type ImageFailureKind = "gate" | "not_called" | "incomplete";
 
@@ -113,9 +114,48 @@ function asReasoning(req: GenerateRequest): OpenAIResponsesOptions["reasoning"]
 
 function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
   const { outputFormat, ...imageControls } = req.imageGenerationOptions ?? {};
+  const auto = req.imageGeneration === "auto";
+  if (auto && req.outputSchema) {
+    throw new ImageGenerationError(
+      "gate",
+      "Automatic image generation does not support structured output or external tools",
+    );
+  }
   return {
     model: req.model ?? "",
     ...(req.systemPrompt ? { instructions: req.systemPrompt } : {}),
+    ...(auto
+      ? {
+          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.",
+          ]
+            .filter(Boolean)
+            .join("\n\n"),
+          parallelToolCalls: false,
+          tools: [
+            {
+              type: "function",
+              name: TRANSPARENT_IMAGE_TOOL,
+              description:
+                "Generate or edit an image with a transparent background using the conversation's reference images.",
+              strict: true,
+              parameters: {
+                type: "object",
+                properties: {
+                  prompt: {
+                    type: "string",
+                    description:
+                      "Complete instructions for the transparent image generation or edit.",
+                  },
+                },
+                required: ["prompt"],
+                additionalProperties: false,
+              },
+            },
+          ],
+        }
+      : {}),
     history: inputItems(req),
     ...(asReasoning(req) ? { reasoning: asReasoning(req) } : {}),
     ...(req.verbosity ? { verbosity: req.verbosity as OpenAIResponsesOptions["verbosity"] } : {}),
@@ -129,6 +169,7 @@ function requestOptions(req: GenerateRequest): OpenAIResponsesOptions {
           imageGeneration: req.imageGenerationOptions
             ? {
                 ...imageControls,
+                ...(auto ? { background: "auto" } : {}),
                 ...(outputFormat ? { output_format: outputFormat } : {}),
               }
             : true,
@@ -312,6 +353,11 @@ 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;
+    let driverCompleted = false;
     let servingModel = req.model ?? "";
     const metadata = selection.metadata;
     const clientEntry = this.acquireClient(selection);
@@ -334,7 +380,42 @@ export class OpenAIDispatcher implements ProviderDispatcher {
           });
         } else if (event.type === "output-item" && event.item.type === "image_generation_call") {
           imageAttempted = true;
+        } else if (auto && event.type === "output-item" && event.item.type === "function_call") {
+          if (event.item.name !== TRANSPARENT_IMAGE_TOOL) {
+            throw new ImageGenerationError("incomplete", "Unexpected automatic image tool call");
+          }
+          transparentAttempted = true;
+          transparentCallIds.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");
+          }
+          if (
+            typeof id !== "string" ||
+            !id ||
+            !args ||
+            typeof args !== "object" ||
+            Array.isArray(args) ||
+            Object.keys(args).length !== 1 ||
+            !("prompt" in args) ||
+            typeof args.prompt !== "string" ||
+            !args.prompt.trim()
+          ) {
+            throw new ImageGenerationError("incomplete", "Invalid transparent image arguments");
+          }
+          if (transparentCalls.has(id) && transparentCalls.get(id) !== args.prompt) {
+            throw new ImageGenerationError(
+              "incomplete",
+              "Conflicting transparent 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,
@@ -344,6 +425,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
             reasoningOutputTokens: event.usage.reasoningTokens,
           };
         } else if (event.type === "completed") {
+          driverCompleted = true;
           servingModel = event.model ?? servingModel;
         } else if (event.type === "error") {
           if (req.imageGeneration)
@@ -351,10 +433,63 @@ export class OpenAIDispatcher implements ProviderDispatcher {
           throw event.error;
         }
       }
+      if (auto && transparentAttempted) {
+        if (
+          !driverCompleted ||
+          transparentCalls.size !== 1 ||
+          transparentCallIds.size !== 1 ||
+          imageAttempted
+        ) {
+          throw new ImageGenerationError(
+            "incomplete",
+            "Expected one completed transparent image call without another image tool",
+          );
+        }
+        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 } : {}),
+            history: [
+              ...inputItems(req),
+              { type: "message", role: "user", content: [{ type: "input_text", text: prompt }] },
+            ],
+            imageGeneration: {
+              quality: req.imageGenerationOptions?.quality,
+              size: req.imageGenerationOptions?.size,
+              output_format: "png",
+              background: "transparent",
+            },
+          },
+          req.abortSignal,
+        )) {
+          if (event.type === "image")
+            images.push({
+              data: event.base64,
+              mediaType: event.mimeType,
+              revisedPrompt: event.revisedPrompt ?? null,
+              ...(event.generation ? { generation: event.generation } : {}),
+            });
+          else if (event.type === "completed") imageCompleted = true;
+          else if (event.type === "error")
+            throw new ImageGenerationError("incomplete", event.error.message);
+        }
+        imageAttempted = true;
+        if (!imageCompleted)
+          throw new ImageGenerationError(
+            "incomplete",
+            "Transparent 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);
     } finally {
       this.releaseClient(clientEntry);
     }
-    if (req.imageGeneration && images.length === 0) {
+    if ((req.imageGeneration === true || (auto && imageAttempted)) && images.length === 0) {
       throw new ImageGenerationError(
         imageAttempted ? "incomplete" : "not_called",
         imageAttempted