@cartanova/qgrid-cli 2.3.7 → 2.3.9

package/bundle/src/utils/providers/openai/codex-worker.ts

@@ -3,12 +3,20 @@ import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 
 import { getLogger } from "@logtape/logtape";
 
+import { type Model } from "../../../codex-protocol/v2/Model";
+import { type ModelListResponse } from "../../../codex-protocol/v2/ModelListResponse";
+import { type ModelProviderCapabilitiesReadResponse } from "../../../codex-protocol/v2/ModelProviderCapabilitiesReadResponse";
 import { type ThreadInjectItemsParams } from "../../../codex-protocol/v2/ThreadInjectItemsParams";
 import { type ThreadStartParams } from "../../../codex-protocol/v2/ThreadStartParams";
 import { type ThreadStartResponse } from "../../../codex-protocol/v2/ThreadStartResponse";
 import { type TokenUsageBreakdown } from "../../../codex-protocol/v2/TokenUsageBreakdown";
 import { type TurnStartParams } from "../../../codex-protocol/v2/TurnStartParams";
 import { type TurnStartResponse } from "../../../codex-protocol/v2/TurnStartResponse";
+import {
+  CODEX_IMAGE_GENERATION_MODEL,
+  resolveImageGenerationOptions,
+} from "../../../application/qgrid/qgrid-image-generation";
+import { type ImageGenerationOptions } from "../../../application/qgrid/qgrid.types";
 import { type StreamCallbacks as CommonStreamCallbacks } from "../common/provider-dispatcher";
 import { createTtftTracker } from "../common/ttft";
 import { CodexRpcClient } from "./codex-rpc";
@@ -39,6 +47,17 @@ export interface TurnRequest {
   verbosity?: string;
   reasoningSummary?: string;
   serviceTier?: string;
+  // 이 turn 에서 codex 내장 image_generation tool 을 켠다.
+  // thread 단위로만 활성화되며(전역 config 는 image_generation=false 유지),
+  // 플래그 없는 요청은 tool 구성이 현행과 동일하다.
+  imageGeneration?: boolean;
+  imageGenerationOptions?: ImageGenerationOptions;
+}
+
+// 한 turn 에서 생성된 이미지 하나. codex imageGeneration item 에서 파생.
+export interface TurnImage {
+  data: string; // base64 image payload (item.result)
+  revisedPrompt: string | null;
 }
 
 export interface TurnResult {
@@ -47,6 +66,11 @@ export interface TurnResult {
   durationMs: number;
   ttftMs: number | null;
   model: string;
+  // 이미지 turn 에서만 채워짐. 완성 이미지가 없으면 빈 배열/undefined.
+  images?: TurnImage[];
+  // 이미지 tool 호출이 관측됐는지(item/started 또는 hasResult 있는 completed).
+  // 이미지 0개일 때 재시도 가능 실패("시도 후 미완성")와 재시도 무익("tool 미호출")을 구분.
+  imageAttempted?: boolean;
 }
 
 export type StreamCallbacks = CommonStreamCallbacks<TurnResult>;
@@ -66,6 +90,27 @@ const THREAD_DEFAULTS = {
 const BASE_INSTRUCTIONS =
   "You are a helpful assistant. Do not use any tools such as shell, file operations, or web search. Respond with text only.";
 
+// 이미지 생성 thread 전용 instruction. 기본 BASE_INSTRUCTIONS 의 "text only" 지시가
+// 실질 억제기이므로(codex image_generation feature 는 default-on), 이미지 모드에서는
+// image_generation tool 사용을 명시적으로 허용한다. shell/web 등 나머지 tool 은 여전히 금지.
+const IMAGE_BASE_INSTRUCTIONS =
+  "You are a helpful assistant. When asked to create an image, use the image_generation tool to produce it. Do not use any other tools such as shell, file operations, or web search.";
+
+function imageBaseInstructions(options: ImageGenerationOptions | undefined): string {
+  const resolved = resolveImageGenerationOptions(options);
+  return `${IMAGE_BASE_INSTRUCTIONS} Requested image output: model ${CODEX_IMAGE_GENERATION_MODEL}, quality ${resolved.quality}, size ${resolved.size}, format png.`;
+}
+
+// 실측상 완료 item 의 status 는 "generating" 으로 와도 result 에 완성 base64 가 실린다.
+// 따라서 완성 판정은 status 문자열이 아니라 result 의 유효성(비어있지 않고 표준 base64 인지)으로 한다.
+function isCompletedImageResult(result: unknown): result is string {
+  if (typeof result !== "string") return false;
+  const trimmed = result.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("data:")) return false;
+  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(trimmed) || trimmed.length % 4 !== 0) return false;
+  return true;
+}
+
 // codex가 매 요청에 자동 주입하는 내장 tool(shell/web_search/spawn_agent 등 14개)과
 // instruction 블록(permissions/environment_context/skills, ~10KB)을 비활성화
 // $CODEX_HOME/config.toml 로 써넣으면 codex 부팅 시 scan
@@ -114,6 +159,10 @@ export class CodexAppServerWorker {
   private epochCounter = 0;
   private static readonly THREAD_IDLE_TTL_MS = 10 * 60_000;
   private static readonly MAX_THREADS_PER_WORKER = 16;
+  // 이미지 게이트 검증용 캐시. spawn 단위로 무효화(restart 시 clear).
+  // capability 는 provider 단위 boolean, 모델 멀티모달 여부는 model/list 로 확인.
+  private cachedCapabilities?: ModelProviderCapabilitiesReadResponse;
+  private cachedModels?: Map<string, Model>;
 
   constructor(private config: WorkerConfig) {
     const suffix = config.workerIndex !== undefined ? `-${config.workerIndex}` : "";
@@ -126,6 +175,9 @@ export class CodexAppServerWorker {
     // 새 codex 프로세스 → 기존 ephemeral thread 전부 무효. epoch 증가로 stale 감지.
     this.epochCounter++;
     this.threadMeta.clear();
+    // 새 프로세스 → capability/model 캐시 무효(로그인 계정/버전이 바뀌었을 수 있음).
+    this.cachedCapabilities = undefined;
+    this.cachedModels = undefined;
     const cwd = `${this.codexHome}/cwd`;
     mkdirSync(cwd, { recursive: true });
     // codex 내장 tool/web_search/instruction 블록 비활성화
@@ -291,6 +343,49 @@ export class CodexAppServerWorker {
     return this.rpc.request("account/rateLimits/read", {});
   }
 
+  // ── Image generation gate ───────────────────────────────────────
+  // 이미지 tool 은 codex 에서 (AuthMode::Chatgpt) AND (image_generation feature)
+  // AND (모델 멀티모달) 3중 게이트다. qgrid 는 OAuth 전용이고 feature 는 thread 에서
+  // 켜므로, dispatcher 가 사전 검증할 남은 조건은 capability(provider) + 모델 멀티모달이다.
+
+  private async loadCapabilities(): Promise<ModelProviderCapabilitiesReadResponse> {
+    if (!this.rpc || !this.ready) throw new Error("worker not ready");
+    if (!this.cachedCapabilities) {
+      this.cachedCapabilities = await this.rpc.request<ModelProviderCapabilitiesReadResponse>(
+        "modelProvider/capabilities/read",
+        {},
+      );
+    }
+    return this.cachedCapabilities;
+  }
+
+  private async loadModels(): Promise<Map<string, Model>> {
+    if (!this.rpc || !this.ready) throw new Error("worker not ready");
+    if (!this.cachedModels) {
+      const res = await this.rpc.request<ModelListResponse>("model/list", {});
+      this.cachedModels = new Map(res.data.map((m) => [m.model, m]));
+    }
+    return this.cachedModels;
+  }
+
+  // 주어진 모델(미지정이면 thread 기본 모델)로 이미지 생성이 가능한지 검증.
+  // 불가 사유를 문자열로 반환하고, 가능하면 null 을 반환한다.
+  async checkImageGenerationSupport(model?: string): Promise<string | null> {
+    if (!this.rpc || !this.ready) return "worker not ready";
+    const caps = await this.loadCapabilities();
+    if (!caps.imageGeneration) return "provider does not support image generation";
+    // 모델 멀티모달 검증. model 미지정이면 provider capability 만으로 통과시키고,
+    // 실제 적용 모델의 멀티모달 여부는 turn 실행 결과(이미지 0개 → U3 실패 분류)가 잡는다.
+    if (model) {
+      const models = await this.loadModels();
+      const info = models.get(model);
+      if (info && !info.inputModalities.includes("image")) {
+        return `model ${model} is not multimodal (no image input modality)`;
+      }
+    }
+    return null;
+  }
+
   // ── Server-request delegation ───────────────────────────────────
 
   setServerRequestHandler(handler: (method: string, params: unknown) => Promise<unknown>): void {
@@ -331,13 +426,19 @@ export class CodexAppServerWorker {
     const threadConfig: ThreadStartParams["config"] = {
       ...THREAD_DEFAULTS.config,
       ...(req.verbosity ? { model_verbosity: req.verbosity } : {}),
+      // 이미지 모드: thread 단위로만 image_generation feature 를 켠다.
+      // 전역 config.toml 은 image_generation=false 유지(텍스트 thread 이중 차단),
+      // dotted CLI-스타일 override 키로 이 thread 에서만 활성화(실측 확인).
+      ...(req.imageGeneration ? { "features.image_generation": true } : {}),
     };
     const { thread, model: threadModel } = await this.rpc.request<ThreadStartResponse>(
       "thread/start",
       {
         ephemeral: true,
         cwd: `${this.codexHome}/cwd`,
-        baseInstructions: BASE_INSTRUCTIONS,
+        baseInstructions: req.imageGeneration
+          ? imageBaseInstructions(req.imageGenerationOptions)
+          : BASE_INSTRUCTIONS,
         developerInstructions: req.developerInstructions ?? "",
         sandbox: THREAD_DEFAULTS.sandbox,
         approvalPolicy: THREAD_DEFAULTS.approvalPolicy,
@@ -352,7 +453,12 @@ export class CodexAppServerWorker {
         items: req.history,
       } satisfies ThreadInjectItemsParams);
     }
-    this.threadMeta.set(threadId, { lastUsedAt: Date.now() });
+    // 이미지 turn 은 재사용에서 제외(R8): base64 가 thread 메모리·캐시 prefix 에
+    // 상주하는 것을 막고, 이미지 thread 를 1 회용으로 둔다. threadMeta 미등록 →
+    // 후속 reuse 조회에서 이 thread 는 후보가 되지 않는다.
+    if (!req.imageGeneration) {
+      this.threadMeta.set(threadId, { lastUsedAt: Date.now() });
+    }
 
     return { threadId, model: req.model ?? threadModel };
   }
@@ -498,11 +604,14 @@ export class CodexAppServerWorker {
         reasoningOutputTokens: 0,
       };
       let durationMs = 0;
+      const images = new Map<string, TurnImage>(); // item.id → 이미지 (dedup)
+      let imageAttempted = false;
 
       const cleanup = () => {
         clearTimeout(timeout);
         if (this.activeTurnAbort === abort) this.activeTurnAbort = undefined;
         for (const n of [
+          "item/started",
           "item/completed",
           "item/agentMessage/delta",
           "turn/completed",
@@ -530,9 +639,23 @@ export class CodexAppServerWorker {
       abort = finishWithError;
       this.activeTurnAbort = abort;
 
+      // 이미지 tool 호출 관측(재시도 판정용). started 는 result 없이 오므로
+      // attempted 신호로만 쓰고, 완성 이미지는 completed 에서 result 유효성으로 판정한다.
+      this.rpc!.onNotification("item/started", (p) => {
+        if (p.threadId !== threadId) return;
+        if (p.item.type === "imageGeneration") imageAttempted = true;
+      });
+
       this.rpc!.onNotification("item/completed", (p) => {
         if (p.threadId !== threadId) return;
-        if (p.item.type === "agentMessage") text = p.item.text;
+        if (p.item.type === "agentMessage") {
+          text = p.item.text;
+        } else if (p.item.type === "imageGeneration") {
+          imageAttempted = true;
+          if (isCompletedImageResult(p.item.result)) {
+            images.set(p.item.id, { data: p.item.result, revisedPrompt: p.item.revisedPrompt });
+          }
+        }
       });
 
       this.rpc!.onNotification("item/agentMessage/delta", (p) => {
@@ -553,8 +676,17 @@ export class CodexAppServerWorker {
         if (p.threadId !== threadId) return;
         durationMs = p.turn.durationMs ?? 0;
         if (p.turn.status === "completed") {
-          finishWithResult({ text, usage, durationMs, ttftMs: ttftTracker.value(), model });
+          finishWithResult({
+            text,
+            usage,
+            durationMs,
+            ttftMs: ttftTracker.value(),
+            model,
+            images: images.size > 0 ? [...images.values()] : undefined,
+            imageAttempted,
+          });
         } else {
+          // turn 실패/중단 시 부분 이미지는 폐기(성공으로 승격하지 않음).
           finishWithError(new Error(`turn failed: ${JSON.stringify(p.turn.error)}`));
         }
       });
@@ -589,11 +721,14 @@ export class CodexAppServerWorker {
         cachedInputTokens: 0,
         reasoningOutputTokens: 0,
       };
+      const images = new Map<string, TurnImage>(); // item.id → 이미지 (dedup)
+      let imageAttempted = false;
 
       const cleanup = () => {
         clearTimeout(timeout);
         if (this.activeTurnAbort === abort) this.activeTurnAbort = undefined;
         for (const n of [
+          "item/started",
           "item/completed",
           "item/agentMessage/delta",
           "turn/completed",
@@ -630,9 +765,21 @@ export class CodexAppServerWorker {
         cb.onDelta(p.delta);
       });
 
+      this.rpc!.onNotification("item/started", (p) => {
+        if (p.threadId !== threadId) return;
+        if (p.item.type === "imageGeneration") imageAttempted = true;
+      });
+
       this.rpc!.onNotification("item/completed", (p) => {
         if (p.threadId !== threadId) return;
-        if (p.item.type === "agentMessage") text = p.item.text;
+        if (p.item.type === "agentMessage") {
+          text = p.item.text;
+        } else if (p.item.type === "imageGeneration") {
+          imageAttempted = true;
+          if (isCompletedImageResult(p.item.result)) {
+            images.set(p.item.id, { data: p.item.result, revisedPrompt: p.item.revisedPrompt });
+          }
+        }
       });
 
       this.rpc!.onNotification("thread/tokenUsage/updated", (p) => {
@@ -652,6 +799,8 @@ export class CodexAppServerWorker {
             durationMs: p.turn.durationMs ?? 0,
             ttftMs: ttftTracker.value(),
             model,
+            images: images.size > 0 ? [...images.values()] : undefined,
+            imageAttempted,
           });
         } else {
           finishWithError(new Error(`turn ${p.turn.status}: ${JSON.stringify(p.turn.error)}`));

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

@@ -4,7 +4,7 @@ import { QuotaThresholdExceededError } from "../../../application/qgrid/qgrid.ty
 import { type OpenAICredentials } from "../../../application/token/token.types";
 import { type GenerateRequest, type GenerateResult } from "../common/provider-dispatcher";
 import { type CodexAppServerWorker } from "./codex-worker";
-import { OpenAIDispatcher } from "./openai-dispatcher";
+import { ImageGenerationError, OpenAIDispatcher } from "./openai-dispatcher";
 import { type OpenAIQuotaUsageResult } from "./openai-quota";
 
 const { readOpenAIQuotaUsageMock, loggerInfoMock, loggerWarnMock } = vi.hoisted(() => ({
@@ -91,6 +91,10 @@ function fakeWorker(
         threads?: string[];
         epoch?: number;
         rateLimits?: unknown;
+        // 이미지 게이트/생성 mock. imageGateReason 이 있으면 checkImageGenerationSupport 가
+        // 그 사유를 반환(불가), null 이면 통과. imageTurnResult 로 worker.executeTurn 반환값 지정.
+        imageGateReason?: string | null;
+        imageTurnResult?: { images?: Array<{ data: string; revisedPrompt: string | null }>; imageAttempted?: boolean };
       },
 ): CodexAppServerWorker {
   const options =
@@ -120,6 +124,17 @@ function fakeWorker(
     getRateLimits: vi.fn(
       async () => options.rateLimits ?? { rateLimits: {}, rateLimitsByLimitId: null },
     ),
+    checkImageGenerationSupport: vi.fn(async () => options.imageGateReason ?? null),
+    executeTurn: vi.fn(async () => ({
+      text: "ok",
+      usage: { totalTokens: 1, inputTokens: 1, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0 },
+      durationMs: 10,
+      ttftMs: null,
+      model: "gpt-5-codex",
+      threadId: "thread-new",
+      images: options.imageTurnResult?.images,
+      imageAttempted: options.imageTurnResult?.imageAttempted,
+    })),
   } as unknown as CodexAppServerWorker;
   return worker;
 }
@@ -429,3 +444,82 @@ describe("OpenAIDispatcher quota threshold gate", () => {
     ).rejects.toBeInstanceOf(QuotaThresholdExceededError);
   });
 });
+
+describe("OpenAIDispatcher image generation gate and failure classification", () => {
+  it("throws a gate error without running the turn when capability is unsupported", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = fakeWorker({ imageGateReason: "provider does not support image generation" });
+
+    await expect(
+      dispatcher.executeTurn(worker, baseReq({ imageGeneration: true })),
+    ).rejects.toMatchObject({ kind: "gate" });
+    // 게이트 실패 시 turn 은 실행되지 않는다.
+    expect((worker as unknown as { executeTurn: ReturnType<typeof vi.fn> }).executeTurn).not.toHaveBeenCalled();
+  });
+
+  it("throws a gate error for a non-multimodal model", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = fakeWorker({ imageGateReason: "model gpt-x is not multimodal (no image input modality)" });
+
+    await expect(
+      dispatcher.executeTurn(worker, baseReq({ imageGeneration: true, model: "gpt-x" })),
+    ).rejects.toBeInstanceOf(ImageGenerationError);
+  });
+
+  it("classifies zero images with no tool call as not_called (retry futile)", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = fakeWorker({ imageGateReason: null, imageTurnResult: { imageAttempted: false } });
+
+    await expect(
+      dispatcher.executeTurn(worker, baseReq({ imageGeneration: true })),
+    ).rejects.toMatchObject({ kind: "not_called" });
+  });
+
+  it("classifies zero images after an attempt as incomplete (retry candidate)", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = fakeWorker({ imageGateReason: null, imageTurnResult: { imageAttempted: true } });
+
+    await expect(
+      dispatcher.executeTurn(worker, baseReq({ imageGeneration: true })),
+    ).rejects.toMatchObject({ kind: "incomplete" });
+  });
+
+  it("passes an image result through without gating a valid request", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = fakeWorker({
+      imageGateReason: null,
+      imageTurnResult: { images: [{ data: "iVBORw0KGgoBAgM", revisedPrompt: "a cat" }], imageAttempted: true },
+    });
+
+    const result = await dispatcher.executeTurn(worker, baseReq({ imageGeneration: true }));
+    expect(result.images).toHaveLength(1);
+    expect(result.images?.[0]?.revisedPrompt).toBe("a cat");
+  });
+
+  it("does not gate or classify a normal text request", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = fakeWorker({ imageTurnResult: {} });
+
+    const result = await dispatcher.executeTurn(worker, baseReq());
+    expect(result.text).toBe("ok");
+    expect((worker as unknown as { checkImageGenerationSupport: ReturnType<typeof vi.fn> }).checkImageGenerationSupport).not.toHaveBeenCalled();
+  });
+});
+
+describe("OpenAIDispatcher image generation routing", () => {
+  it("rejects image requests on the streaming path", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const cb = { onDelta: vi.fn(), onComplete: vi.fn(), onError: vi.fn() };
+    await expect(
+      dispatcher.generateStream(baseReq({ imageGeneration: true }), cb),
+    ).rejects.toBeInstanceOf(ImageGenerationError);
+  });
+
+  it("forces cold thread for image requests even when a reuse coordinate is present", async () => {
+    const dispatcher = new OpenAIDispatcher();
+    const worker = await dispatcher.acquireReuseWorker(
+      baseReq({ imageGeneration: true, reuse: { workerId: 10, threadId: "t1", epoch: 1 } }),
+    );
+    expect(worker).toBeNull();
+  });
+});

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

@@ -28,6 +28,22 @@ import { handleChatgptAuthTokensRefresh } from "./openai-refresh";
 
 const logger = getLogger(["qgrid", "openai-dispatcher"]);
 
+// 이미지 생성 요청이 게이트/생성에 실패했을 때의 구분자.
+// - "gate": 사전 검증 실패(capability/모델 멀티모달 불충족) — turn 미실행.
+// - "not_called": turn 은 성공했으나 모델이 image tool 을 호출 안 함 — 재시도 무익(프롬프트 문제).
+// - "incomplete": tool 시도됐으나 완성 이미지 미도착 — 재시도 후보(서버측 실패/거부).
+export type ImageFailureKind = "gate" | "not_called" | "incomplete";
+
+export class ImageGenerationError extends Error {
+  constructor(
+    readonly kind: ImageFailureKind,
+    message: string,
+  ) {
+    super(message);
+    this.name = "ImageGenerationError";
+  }
+}
+
 const DEFAULT_EFFORT = "low";
 const MAX_WORKERS_PER_TOKEN = 5;
 const WORKERS_PER_TOKEN = Math.min(
@@ -254,6 +270,11 @@ export class OpenAIDispatcher implements ProviderDispatcher {
   }
 
   async generateStream(req: GenerateRequest, cb: GenerateStreamCallbacks): Promise<void> {
+    // 이미지 생성은 non-stream 전용(R2): codex 가 이미지 델타를 주지 않고 완성 base64 를
+    // 한 번에 준다. 스트리밍 경로로 이미지 요청이 오면 명시적 에러.
+    if (req.imageGeneration) {
+      throw new ImageGenerationError("gate", "image generation is not supported on the streaming path");
+    }
     const excludedTokenIds = new Set<number>();
     const reuseWorker = await this.acquireReuseWorker(req, excludedTokenIds);
     if (reuseWorker) {
@@ -281,6 +302,9 @@ export class OpenAIDispatcher implements ProviderDispatcher {
     req: GenerateRequest,
     excludedTokenIds = new Set<number>(),
   ): Promise<CodexAppServerWorker | null> {
+    // 이미지 요청은 항상 cold thread(R8): 재사용 좌표가 있어도 건너뛴다.
+    // base64 가 thread 메모리·캐시 prefix 에 상주하는 것을 막는다.
+    if (req.imageGeneration) return null;
     if (!THREAD_REUSE_ENABLED || !req.reuse) return null;
     const { workerId, threadId, epoch } = req.reuse;
 
@@ -481,6 +505,8 @@ export class OpenAIDispatcher implements ProviderDispatcher {
       verbosity: req.verbosity,
       reasoningSummary: req.reasoningSummary,
       serviceTier: req.serviceTier,
+      imageGeneration: req.imageGeneration,
+      imageGenerationOptions: req.imageGenerationOptions,
     };
   }
 
@@ -489,8 +515,23 @@ export class OpenAIDispatcher implements ProviderDispatcher {
     req: GenerateRequest,
     reuseThreadId?: string,
   ): Promise<GenerateResult> {
+    // 이미지 요청 사전 게이트(R5): 배정된 worker 의 capability + 적용 모델 멀티모달.
+    // 불충족이면 turn 을 실행하지 않고 명시적 에러.
+    if (req.imageGeneration) {
+      const reason = await worker.checkImageGenerationSupport(req.model);
+      if (reason) throw new ImageGenerationError("gate", reason);
+    }
+
     const turnReq = this.buildTurnRequest(req, reuseThreadId);
     const result = await worker.executeTurn(turnReq, reuseThreadId);
+
+    // 이미지 0개 실패 분류(R6): tool 미호출(재시도 무익) vs 시도 후 미완성(재시도 후보).
+    if (req.imageGeneration && (!result.images || result.images.length === 0)) {
+      throw result.imageAttempted
+        ? new ImageGenerationError("incomplete", "image tool ran but produced no completed image")
+        : new ImageGenerationError("not_called", "model did not call the image_generation tool");
+    }
+
     return {
       text: result.text,
       tokenName: worker.tokenName,
@@ -503,6 +544,7 @@ export class OpenAIDispatcher implements ProviderDispatcher {
         threadId: result.threadId,
         epoch: worker.epoch,
       },
+      images: result.images,
     };
   }