@cartanova/qgrid-cli 2.3.6 → 2.3.8

package/bundle/src/application/request-log/request-log.entity.json

@@ -44,6 +44,19 @@
     { "name": "duration_ms", "type": "integer", "desc": "응답 소요시간(ms)", "dbDefault": "0" },
     { "name": "ttft_ms", "type": "integer", "desc": "first gen TTFT(ms)", "dbDefault": "0" },
     { "name": "cost_usd", "type": "integer", "nullable": true, "desc": "API 비용" },
+    {
+      "name": "image_cost_usd",
+      "type": "integer",
+      "nullable": true,
+      "desc": "이미지 생성 추정 비용"
+    },
+    {
+      "name": "image_cost_method",
+      "type": "string",
+      "length": 100,
+      "nullable": true,
+      "desc": "이미지 비용 추정 방식"
+    },
     { "name": "effort", "type": "string", "length": 10, "nullable": true, "desc": "effort level" },
     {
       "name": "history",
@@ -60,7 +73,13 @@
       "dbDefault": "\"succeeded\""
     },
     { "name": "error_message", "type": "string", "nullable": true, "desc": "에러 메시지" },
-    { "name": "tool_call_count", "type": "integer", "desc": "tool call 횟수", "dbDefault": "0" }
+    { "name": "tool_call_count", "type": "integer", "desc": "tool call 횟수", "dbDefault": "0" },
+    {
+      "name": "is_image_generation",
+      "type": "boolean",
+      "desc": "이미지 생성 turn 여부 (quota 귀속용)",
+      "dbDefault": "false"
+    }
   ],
   "indexes": [
     {
@@ -77,57 +96,64 @@
     }
   ],
   "subsets": {
-    "A": {
-      "fields": [
-        "id",
-        "created_at",
-        "token_name",
-        "project_name",
-        "model_name",
-        "user_prompt",
-        "system_prompt",
-        "response",
-        "input_tokens",
-        "output_tokens",
-        "cache_read_tokens",
-        "cache_creation_tokens",
-        "duration_ms",
-        "ttft_ms",
-        "cost_usd",
-        "effort",
-        "history",
-        "status",
-        "error_message",
-        "tool_call_count"
-      ]
-    },
-    "P": {
-      "fields": [
-        "id",
-        "created_at",
-        "token_name",
-        "project_name",
-        "model_name",
-        "input_tokens",
-        "output_tokens",
-        "cache_read_tokens",
-        "cache_creation_tokens",
-        "duration_ms",
-        "ttft_ms",
-        "cost_usd",
-        "effort",
-        "status",
-        "tool_call_count"
-      ]
-    }
+    "A": [
+      "id",
+      "created_at",
+      "token_name",
+      "project_name",
+      "model_name",
+      "user_prompt",
+      "system_prompt",
+      "response",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "duration_ms",
+      "ttft_ms",
+      "cost_usd",
+      "image_cost_usd",
+      "image_cost_method",
+      "effort",
+      "history",
+      "status",
+      "error_message",
+      "tool_call_count",
+      "is_image_generation"
+    ],
+    "P": [
+      "id",
+      "created_at",
+      "token_name",
+      "project_name",
+      "model_name",
+      "input_tokens",
+      "output_tokens",
+      "cache_read_tokens",
+      "cache_creation_tokens",
+      "duration_ms",
+      "ttft_ms",
+      "cost_usd",
+      "image_cost_usd",
+      "image_cost_method",
+      "effort",
+      "status",
+      "tool_call_count",
+      "is_image_generation"
+    ]
   },
   "enums": {
-    "RequestLogOrderBy": { "values": { "id-desc": "ID최신순" } },
+    "RequestLogOrderBy": { "id-desc": "ID최신순" },
     "RequestLogSearchField": {
-      "values": { "id": "ID", "token_name": "토큰이름", "user_prompt": "사용자 프롬프트" }
+      "id": "ID",
+      "token_name": "토큰이름",
+      "user_prompt": "사용자 프롬프트"
     },
     "RequestLogStatus": {
-      "values": { "running": "실행 중", "succeeded": "성공", "error": "에러", "aborted": "중단" }
+      "running": "실행 중",
+      "succeeded": "성공",
+      "error": "에러",
+      "aborted": "중단"
     }
   }
 }

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

@@ -209,6 +209,7 @@ class RequestLogModelClass extends BaseModelClass<
     effort?: string | null;
     project_name?: string | null;
     history?: unknown;
+    is_image_generation?: boolean;
   }): Promise<number> {
     const wdb = this.getPuri("w");
     wdb.ubRegister("request_logs", {
@@ -225,6 +226,8 @@ class RequestLogModelClass extends BaseModelClass<
       cache_creation_tokens: 0,
       duration_ms: 0,
       tool_call_count: 0,
+      // 이미지 turn 식별(R13). run 경로(tools+image 조합)도 auto 경로와 동일하게 마킹.
+      is_image_generation: params.is_image_generation ?? false,
       ...(params.history !== undefined ? { history: params.history as { type: string }[] } : {}),
     });
     return wdb.transaction(async (trx) => {
@@ -259,6 +262,8 @@ class RequestLogModelClass extends BaseModelClass<
       history?: unknown;
       error_message?: string;
       tool_call_count?: number;
+      image_cost_usd?: number | null;
+      image_cost_method?: string | null;
     },
   ): Promise<void> {
     if (params.status === "succeeded" && !params.token_name) {
@@ -275,6 +280,8 @@ class RequestLogModelClass extends BaseModelClass<
       "duration_ms",
       "error_message",
       "tool_call_count",
+      "image_cost_usd",
+      "image_cost_method",
     ] as const;
     for (const key of fields) {
       if (params[key] !== undefined) update[key] = params[key];

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

@@ -182,11 +182,14 @@ Content-Type: application/json
       "duration_ms": 0,
       "ttft_ms": 0,
       "cost_usd": null,
+      "image_cost_usd": null,
+      "image_cost_method": null,
       "effort": null,
       "history": null,
       "status": "running",
       "error_message": null,
-      "tool_call_count": 0
+      "tool_call_count": 0,
+      "is_image_generation": false
     }
   ]
 }
@@ -245,7 +248,12 @@ Content-Type: application/json
         "output": "OUTPUT",
         "isError": false
       }
-    ]
+    ],
+    "imageGeneration": false,
+    "imageGenerationOptions": {
+      "quality": "low",
+      "size": "1024x1024"
+    }
   }
 }
 
@@ -292,7 +300,12 @@ Content-Type: application/json
         "output": "OUTPUT",
         "isError": false
       }
-    ]
+    ],
+    "imageGeneration": false,
+    "imageGenerationOptions": {
+      "quality": "low",
+      "size": "1024x1024"
+    }
   }
 }
 

package/bundle/src/application/sonamu.generated.sso.ts

@@ -33,11 +33,14 @@ export const requestLogSubsetQueries = {
       duration_ms: "request_logs.duration_ms",
       ttft_ms: "request_logs.ttft_ms",
       cost_usd: "request_logs.cost_usd",
+      image_cost_usd: "request_logs.image_cost_usd",
+      image_cost_method: "request_logs.image_cost_method",
       effort: "request_logs.effort",
       history: "request_logs.history",
       status: "request_logs.status",
       error_message: "request_logs.error_message",
       tool_call_count: "request_logs.tool_call_count",
+      is_image_generation: "request_logs.is_image_generation",
     });
   },
   P: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => {
@@ -54,9 +57,12 @@ export const requestLogSubsetQueries = {
       duration_ms: "request_logs.duration_ms",
       ttft_ms: "request_logs.ttft_ms",
       cost_usd: "request_logs.cost_usd",
+      image_cost_usd: "request_logs.image_cost_usd",
+      image_cost_method: "request_logs.image_cost_method",
       effort: "request_logs.effort",
       status: "request_logs.status",
       tool_call_count: "request_logs.tool_call_count",
+      is_image_generation: "request_logs.is_image_generation",
     });
   },
 };

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

@@ -102,11 +102,14 @@ export const RequestLogBaseSchema = z.object({
   duration_ms: z.int(),
   ttft_ms: z.int(),
   cost_usd: z.int().nullable(),
+  image_cost_usd: z.int().nullable(),
+  image_cost_method: z.string().max(100).nullable(),
   effort: z.string().max(10).nullable(),
   history: HistoryItems.nullable(),
   status: RequestLogStatus,
   error_message: z.string().nullable(),
   tool_call_count: z.int(),
+  is_image_generation: z.boolean(),
 });
 export type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {
   readonly __hasDefault__: readonly [
@@ -124,11 +127,14 @@ export type RequestLogBaseSchema = z.infer<typeof RequestLogBaseSchema> & {
     "duration_ms",
     "ttft_ms",
     "cost_usd",
+    "image_cost_usd",
+    "image_cost_method",
     "effort",
     "history",
     "status",
     "error_message",
     "tool_call_count",
+    "is_image_generation",
     "id",
   ];
 };
@@ -261,11 +267,14 @@ export const RequestLogSubsetA = z.object({
   duration_ms: z.int(),
   ttft_ms: z.int(),
   cost_usd: z.int().nullable(),
+  image_cost_usd: z.int().nullable(),
+  image_cost_method: z.string().max(100).nullable(),
   effort: z.string().max(10).nullable(),
   history: HistoryItems.nullable(),
   status: RequestLogStatus,
   error_message: z.string().nullable(),
   tool_call_count: z.int(),
+  is_image_generation: z.boolean(),
 });
 export type RequestLogSubsetA = z.infer<typeof RequestLogSubsetA>;
 export const RequestLogSubsetP = z.object({
@@ -281,9 +290,12 @@ export const RequestLogSubsetP = z.object({
   duration_ms: z.int(),
   ttft_ms: z.int(),
   cost_usd: z.int().nullable(),
+  image_cost_usd: z.int().nullable(),
+  image_cost_method: z.string().max(100).nullable(),
   effort: z.string().max(10).nullable(),
   status: RequestLogStatus,
   tool_call_count: z.int(),
+  is_image_generation: z.boolean(),
 });
 export type RequestLogSubsetP = z.infer<typeof RequestLogSubsetP>;
 export type RequestLogSubsetMapping = {

package/bundle/src/i18n/sd.generated.ts

@@ -225,11 +225,14 @@ const entityLabels = {
   "entity.RequestLog.duration_ms": "응답 소요시간(ms)",
   "entity.RequestLog.ttft_ms": "first gen TTFT(ms)",
   "entity.RequestLog.cost_usd": "API 비용",
+  "entity.RequestLog.image_cost_usd": "이미지 생성 추정 비용",
+  "entity.RequestLog.image_cost_method": "이미지 비용 추정 방식",
   "entity.RequestLog.effort": "effort level",
   "entity.RequestLog.history": "inject_items 히스토리",
   "entity.RequestLog.status": "실행 상태",
   "entity.RequestLog.error_message": "에러 메시지",
   "entity.RequestLog.tool_call_count": "tool call 횟수",
+  "entity.RequestLog.is_image_generation": "이미지 생성 turn 여부 (quota 귀속용)",
   "enum.RequestLogOrderBy.id-desc": "ID최신순",
   "enum.RequestLogSearchField.id": "ID",
   "enum.RequestLogSearchField.token_name": "토큰이름",

package/bundle/src/migrations/20260705140614_alter_request_logs_add1_alter1.ts

@@ -0,0 +1,15 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // add
+    table.boolean("is_image_generation").notNullable().defaultTo(knex.raw("false"));
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    // rollback - add
+    table.dropColumns("is_image_generation");
+  });
+}

package/bundle/src/migrations/20260705140615_alter_request_log_steps_alter1.ts

@@ -0,0 +1,13 @@
+import { type Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(
+    `CREATE INDEX request_log_steps_request_log_id_index ON request_log_steps USING btree(request_log_id ASC NULLS LAST);`,
+  );
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_log_steps", (table) => {
+    table.dropIndex(["request_log_id"], "request_log_steps_request_log_id_index");
+  });
+}

package/bundle/src/migrations/20260706120000_alter_request_logs_add_image_cost.ts

@@ -0,0 +1,14 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    table.integer("image_cost_usd").nullable();
+    table.string("image_cost_method", 100).nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("request_logs", (table) => {
+    table.dropColumns("image_cost_usd", "image_cost_method");
+  });
+}

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

@@ -278,6 +278,11 @@ export class AnthropicDispatcher implements ProviderDispatcher {
     onDelta: (t: string) => void,
     opts?: { includePartialMessages?: boolean },
   ): Promise<GenerateResult> {
+    // 이미지 생성은 OpenAI(codex) 경로 전용. Anthropic 라우팅에 이미지 플래그가
+    // 도달하면 조용히 텍스트로 폴백하지 않고 명시적으로 거부한다.
+    if (req.imageGeneration) {
+      throw new Error("image generation is not supported on the Anthropic route");
+    }
     // model 정규화를 dispatcher 진입점에서 한 번 한다: result.model / runClaudeSession 전부
     // canonical(prefix 없는 cost 키) 을 쓰게 통일. 미지정이면 ANTHROPIC_DEFAULT_MODEL — qgrid.dispatcher
     // 의 "sonnet" 별칭 우회 차단. 정규화 규칙은 fallback 경로와 공유(canonicalAnthropicModel).

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

@@ -7,6 +7,7 @@
 import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
 import { type TokenUsageBreakdown } from "../../../codex-protocol/v2/TokenUsageBreakdown";
 import { type UserInput } from "../../../codex-protocol/v2/UserInput";
+import { type ImageGenerationOptions } from "../../../application/qgrid/qgrid.types";
 
 // qgrid provider 내부 표준 usage. codex-protocol 의 TokenUsageBreakdown 은 생성 파일이므로
 // provider 전용 cache write 세부 필드는 여기서 확장해 보존한다.
@@ -22,6 +23,13 @@ export interface ReuseThreadCoord {
   epoch: number;
 }
 
+// provider-무관 이미지 결과. OpenAI(codex) 경로에서만 채워지며, 상위(qgrid.dispatcher)가
+// content 파트로 전파한다. Anthropic 경로는 이 필드를 채우지 않는다.
+export interface GeneratedImage {
+  data: string; // base64 PNG
+  revisedPrompt: string | null;
+}
+
 export interface GenerateRequest {
   // 미지정이면 dispatcher 가 provider 별 default 를 적용한다(Anthropic: ANTHROPIC_DEFAULT_MODEL).
   // OpenAI 경로는 항상 prefix split 후 canonical model 을 넘기므로 영향 없음.
@@ -42,6 +50,10 @@ export interface GenerateRequest {
   // coldInput + coldHistory 로 폴백한다(전체 history 로 문맥 복구).
   reuse?: ReuseThreadCoord;
   reuseInput?: Array<UserInput>;
+  // codex 내장 image_generation tool 을 켠다(OpenAI 경로 전용, opt-in).
+  // 이 플래그가 있으면 dispatcher 는 항상 cold thread 로 실행하고 재사용 라우팅을 건너뛴다.
+  imageGeneration?: boolean;
+  imageGenerationOptions?: ImageGenerationOptions;
 }
 
 export interface GenerateResult {
@@ -56,6 +68,8 @@ export interface GenerateResult {
   model: string;
   // 이번 turn 이 사용한 thread 좌표. 상위가 conv 핸들을 발급/갱신하는 데 쓴다.
   threadCoord: ReuseThreadCoord;
+  // 이미지 turn 에서만 채워짐(OpenAI 경로). 완성 이미지가 없으면 undefined.
+  images?: GeneratedImage[];
 }
 
 // 스트림 콜백 컨테이너. 계층별로 onComplete payload 만 다르고, 스트림 이벤트 shape 는 동일하다.

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

@@ -15,6 +15,7 @@ import { type AccountLoginCompletedNotification } from "../../../codex-protocol/
 import { type AgentMessageDeltaNotification } from "../../../codex-protocol/v2/AgentMessageDeltaNotification";
 import { type ErrorNotification } from "../../../codex-protocol/v2/ErrorNotification";
 import { type ItemCompletedNotification } from "../../../codex-protocol/v2/ItemCompletedNotification";
+import { type ItemStartedNotification } from "../../../codex-protocol/v2/ItemStartedNotification";
 import { type ThreadTokenUsageUpdatedNotification } from "../../../codex-protocol/v2/ThreadTokenUsageUpdatedNotification";
 import { type TurnCompletedNotification } from "../../../codex-protocol/v2/TurnCompletedNotification";
 
@@ -26,6 +27,7 @@ const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 
 export type NotificationMap = {
   "turn/completed": TurnCompletedNotification;
+  "item/started": ItemStartedNotification;
   "item/completed": ItemCompletedNotification;
   "item/agentMessage/delta": AgentMessageDeltaNotification;
   "thread/tokenUsage/updated": ThreadTokenUsageUpdatedNotification;

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

@@ -309,3 +309,222 @@ describe("CodexAppServerWorker prompt prefix", () => {
     expect(schemaTurnStart).toEqual(expect.objectContaining({ outputSchema }));
   });
 });
+
+describe("CodexAppServerWorker image generation capture", () => {
+  const IMAGE_B64 = "iVBORw0KGgoBAgMEBQYHCA==";
+
+  function imageItem(id: string, result: string, revisedPrompt: string | null = null) {
+    return { type: "imageGeneration", id, status: "generating", result, revisedPrompt };
+  }
+
+  it("captures multiple completed image items into the images array in order", async () => {
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") return { thread: { id: "t1" }, model: "gpt-test" };
+      if (method === "turn/start") {
+        handlers.get("item/completed")?.({
+          threadId: "t1",
+          item: imageItem("img-a", IMAGE_B64, "a red circle"),
+        } as never);
+        handlers.get("item/completed")?.({
+          threadId: "t1",
+          item: imageItem("img-b", IMAGE_B64, "a blue square"),
+        } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "t1",
+          turn: { status: "completed", durationMs: 100 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+
+    const result = await worker.executeTurn({
+      input: [{ type: "text", text: "two images", text_elements: [] }],
+      imageGeneration: true,
+    });
+
+    expect(result.images).toHaveLength(2);
+    expect(result.images?.map((i) => i.revisedPrompt)).toEqual(["a red circle", "a blue square"]);
+    expect(result.images?.[0]?.data).toBe(IMAGE_B64);
+    expect(result.imageAttempted).toBe(true);
+  });
+
+  it("treats status='generating' completed item with valid base64 as a finished image", async () => {
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") return { thread: { id: "t1" }, model: "gpt-test" };
+      if (method === "turn/start") {
+        // 실측: 완료 item 의 status 가 "generating" 으로 와도 result 는 완성 base64.
+        handlers.get("item/completed")?.({
+          threadId: "t1",
+          item: imageItem("img-a", IMAGE_B64),
+        } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "t1",
+          turn: { status: "completed", durationMs: 50 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+
+    const result = await worker.executeTurn({
+      input: [{ type: "text", text: "img", text_elements: [] }],
+      imageGeneration: true,
+    });
+    expect(result.images).toHaveLength(1);
+  });
+
+  it("dedups repeated completed events for the same item id", async () => {
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") return { thread: { id: "t1" }, model: "gpt-test" };
+      if (method === "turn/start") {
+        handlers.get("item/completed")?.({ threadId: "t1", item: imageItem("dup", IMAGE_B64) } as never);
+        handlers.get("item/completed")?.({ threadId: "t1", item: imageItem("dup", IMAGE_B64) } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "t1",
+          turn: { status: "completed", durationMs: 50 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+
+    const result = await worker.executeTurn({
+      input: [{ type: "text", text: "img", text_elements: [] }],
+      imageGeneration: true,
+    });
+    expect(result.images).toHaveLength(1);
+  });
+
+  it("marks imageAttempted but returns no images when only item/started fires (tool called, not finished)", async () => {
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") return { thread: { id: "t1" }, model: "gpt-test" };
+      if (method === "turn/start") {
+        handlers.get("item/started")?.({
+          threadId: "t1",
+          item: { type: "imageGeneration", id: "img-a", status: "in_progress", result: "", revisedPrompt: null },
+        } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "t1",
+          turn: { status: "completed", durationMs: 50 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+
+    const result = await worker.executeTurn({
+      input: [{ type: "text", text: "img", text_elements: [] }],
+      imageGeneration: true,
+    });
+    expect(result.images).toBeUndefined();
+    expect(result.imageAttempted).toBe(true);
+  });
+
+  it("does not count an empty or invalid base64 result as a finished image", async () => {
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") return { thread: { id: "t1" }, model: "gpt-test" };
+      if (method === "turn/start") {
+        handlers.get("item/completed")?.({ threadId: "t1", item: imageItem("empty", "") } as never);
+        handlers.get("item/completed")?.({ threadId: "t1", item: imageItem("junk", "not-base64") } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "t1",
+          turn: { status: "completed", durationMs: 50 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+
+    const result = await worker.executeTurn({
+      input: [{ type: "text", text: "img", text_elements: [] }],
+      imageGeneration: true,
+    });
+    expect(result.images).toBeUndefined();
+    expect(result.imageAttempted).toBe(true);
+  });
+
+  it("discards partial images when the turn fails (no promotion to success)", async () => {
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") return { thread: { id: "t1" }, model: "gpt-test" };
+      if (method === "turn/start") {
+        handlers.get("item/completed")?.({ threadId: "t1", item: imageItem("img-a", IMAGE_B64) } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "t1",
+          turn: { status: "failed", error: { message: "boom" } },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+
+    await expect(
+      worker.executeTurn({
+        input: [{ type: "text", text: "img", text_elements: [] }],
+        imageGeneration: true,
+      }),
+    ).rejects.toThrow(/turn failed/);
+  });
+
+  it("does not register an image turn thread for reuse (threadMeta excluded)", async () => {
+    const spy = createWorkerWithRequestSpy();
+    type WorkerInternals = { createThread(req: unknown): Promise<{ threadId: string; model: string }> };
+    const { threadId } = await (spy.worker as unknown as WorkerInternals).createThread({
+      input: [{ type: "text", text: "img", text_elements: [] }],
+      imageGeneration: true,
+    });
+    const threadMeta = (spy.worker as unknown as { threadMeta: Map<string, unknown> }).threadMeta;
+    expect(threadMeta.has(threadId)).toBe(false);
+  });
+
+  it("still registers a normal text thread for reuse (regression guard)", async () => {
+    const spy = createWorkerWithRequestSpy();
+    type WorkerInternals = { createThread(req: unknown): Promise<{ threadId: string; model: string }> };
+    const { threadId } = await (spy.worker as unknown as WorkerInternals).createThread({
+      input: [{ type: "text", text: "hi", text_elements: [] }],
+    });
+    const threadMeta = (spy.worker as unknown as { threadMeta: Map<string, unknown> }).threadMeta;
+    expect(threadMeta.has(threadId)).toBe(true);
+  });
+});
+
+describe("CodexAppServerWorker image generation thread", () => {
+  type WorkerInternals = {
+    createThread(req: unknown): Promise<{ threadId: string; model: string }>;
+  };
+
+  function threadStartParams(spy: ReturnType<typeof createWorkerWithRequestSpy>) {
+    return spy.request.mock.calls.find(([method]) => method === "thread/start")?.[1] as
+      | { baseInstructions?: string; config?: Record<string, unknown> }
+      | undefined;
+  }
+
+  it("enables image_generation feature and swaps base instructions for image requests", async () => {
+    const spy = createWorkerWithRequestSpy();
+    await (spy.worker as unknown as WorkerInternals).createThread({
+      input: [{ type: "text", text: "draw a red circle", text_elements: [] }],
+      imageGeneration: true,
+    });
+
+    const params = threadStartParams(spy);
+    expect(params?.config).toEqual(
+      expect.objectContaining({ "features.image_generation": true }),
+    );
+    // "text only" 억제기가 이미지 허용 instruction 으로 교체돼야 tool 이 실제로 호출된다.
+    expect(params?.baseInstructions).toContain("image_generation tool");
+    expect(params?.baseInstructions).not.toContain("Respond with text only");
+  });
+
+  it("leaves tool config and instructions untouched when the flag is absent", async () => {
+    const spy = createWorkerWithRequestSpy();
+    await (spy.worker as unknown as WorkerInternals).createThread({
+      input: [{ type: "text", text: "hello", text_elements: [] }],
+    });
+
+    const params = threadStartParams(spy);
+    // 회귀 가드: 이미지 플래그 없는 요청은 image_generation override 를 싣지 않고,
+    // 텍스트 전용 instruction 을 유지한다(플래그 없는 경로 무변화).
+    expect(params?.config).not.toHaveProperty("features.image_generation");
+    expect(params?.baseInstructions).toContain("Respond with text only");
+  });
+});