@cartanova/qgrid-cli 2.10.4 → 2.10.5

package/bundle/dist/utils/providers/openai/openai-backend-protocol.js

@@ -128,13 +128,24 @@ function normalizeOpenAIEvent(raw) {
 	};
 	if ((type === "response.output_item.added" || type === "response.output_item.done") && event.item && typeof event.item === "object") {
 		const item = event.item;
-		if (item.type === "image_generation_call" && typeof item.result === "string") return {
-			type: "image",
-			...typeof item.id === "string" ? { id: item.id } : {},
-			base64: item.result,
-			mimeType: imageMimeType(item.result, item.output_format),
-			...typeof item.revised_prompt === "string" ? { revisedPrompt: item.revised_prompt } : typeof item.revisedPrompt === "string" ? { revisedPrompt: item.revisedPrompt } : {}
-		};
+		if (item.type === "image_generation_call" && typeof item.result === "string") {
+			const header = Buffer.from(item.result.slice(0, 32), "base64");
+			const size = (header.length >= 24 && header.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex")) && header.readUInt32BE(16) > 0 && header.readUInt32BE(20) > 0 ? `${header.readUInt32BE(16)}x${header.readUInt32BE(20)}` : void 0) ?? (typeof item.size === "string" && /^[1-9]\d*x[1-9]\d*$/.test(item.size) ? item.size : void 0);
+			return {
+				type: "image",
+				...typeof item.id === "string" ? { id: item.id } : {},
+				base64: item.result,
+				mimeType: imageMimeType(item.result, item.output_format),
+				generation: {
+					route: "codex-responses",
+					...size ? { size } : {},
+					...typeof item.model === "string" ? { model: item.model } : {},
+					...typeof item.quality === "string" ? { quality: item.quality } : {},
+					...typeof item.background === "string" ? { background: item.background } : {}
+				},
+				...typeof item.revised_prompt === "string" ? { revisedPrompt: item.revised_prompt } : typeof item.revisedPrompt === "string" ? { revisedPrompt: item.revisedPrompt } : {}
+			};
+		}
 		return {
 			type: "output-item",
 			item,
@@ -162,4 +173,4 @@ function normalizeOpenAIEvent(raw) {
 //#endregion
 export { CHATGPT_CODEX_RESPONSES_URL, CODEX_CLI_ORIGINATOR, CODEX_CLI_VERSION, OpenAIProtocolError, buildCodexIdentityHeaders, buildOpenAIResponsesRequest, codexCliUserAgent, imageMimeType, normalizeOpenAIEvent };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-backend-protocol.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-backend-protocol.ts"],"sourcesContent":["import os from \"node:os\";\n\nimport { type ImageGenerationMetadata } from \"../../../application/qgrid/qgrid.types\";\nimport { type OpenAIEffort } from \"../common/effort\";\n\nexport const CHATGPT_CODEX_RESPONSES_URL =\n  \"https://chatgpt.com/backend-api/codex/responses\" as const;\n\nexport const CODEX_CLI_ORIGINATOR = \"codex_cli_rs\" as const;\nexport const CODEX_CLI_VERSION = \"0.147.0\" as const;\n\nexport interface CodexUserAgentPlatform {\n  osType: string;\n  osVersion: string;\n  architecture: string;\n  terminal: string;\n}\n\nfunction codexPlatform(): CodexUserAgentPlatform {\n  const names: Partial<Record<NodeJS.Platform, string>> = {\n    darwin: \"Mac OS\",\n    linux: \"Linux\",\n    win32: \"Windows\",\n  };\n  const terminal = process.env.TERM_PROGRAM;\n  const terminalVersion = process.env.TERM_PROGRAM_VERSION;\n  return {\n    osType: names[process.platform] ?? process.platform,\n    osVersion: os.release(),\n    architecture: process.arch,\n    terminal: terminal ? `${terminal}${terminalVersion ? `/${terminalVersion}` : \"\"}` : \"unknown\",\n  };\n}\n\n/** Matches the platform/terminal suffix emitted by the pinned Rust Codex CLI. */\nexport function codexCliUserAgent(platform: CodexUserAgentPlatform = codexPlatform()): string {\n  return `codex_cli_rs/${CODEX_CLI_VERSION} (${platform.osType} ${platform.osVersion}; ${platform.architecture}) ${platform.terminal}`;\n}\n\nexport type JsonValue =\n  | null\n  | boolean\n  | number\n  | string\n  | JsonValue[]\n  | { [key: string]: JsonValue };\n\n/** Raw Responses API items. Keeping these opaque preserves the complete conversation history. */\nexport type OpenAIResponseItem = Record<string, unknown>;\n\nexport interface OpenAIOutputSchema {\n  name?: string;\n  schema: JsonValue;\n}\n\nexport interface OpenAIResponsesOptions {\n  model: string;\n  instructions?: string;\n  history: readonly OpenAIResponseItem[];\n  tools?: readonly OpenAIResponseItem[];\n  toolChoice?: string | OpenAIResponseItem;\n  parallelToolCalls?: boolean;\n  reasoning?: {\n    effort?: OpenAIEffort | \"none\";\n    summary?: \"auto\" | \"concise\" | \"detailed\";\n  };\n  verbosity?: \"low\" | \"medium\" | \"high\";\n  serviceTier?: string;\n  promptCacheKey?: string;\n  outputSchema?: OpenAIOutputSchema;\n  imageGeneration?: boolean | OpenAIResponseItem;\n}\n\nexport interface OpenAIResponsesRequest {\n  model: string;\n  instructions?: string;\n  input: OpenAIResponseItem[];\n  tools?: OpenAIResponseItem[];\n  tool_choice: string | OpenAIResponseItem;\n  parallel_tool_calls: boolean;\n  reasoning: OpenAIResponsesOptions[\"reasoning\"] | null;\n  store: false;\n  stream: true;\n  include: string[];\n  service_tier?: string;\n  prompt_cache_key?: string;\n  text?: {\n    verbosity?: \"low\" | \"medium\" | \"high\";\n    format?: {\n      type: \"json_schema\";\n      strict: true;\n      schema: JsonValue;\n      name: string;\n    };\n  };\n}\n\nexport function buildOpenAIResponsesRequest(\n  options: OpenAIResponsesOptions,\n): OpenAIResponsesRequest {\n  const tools = options.tools ? [...options.tools] : [];\n  if (options.imageGeneration) {\n    tools.push(\n      options.imageGeneration === true\n        ? { type: \"image_generation\" }\n        : { type: \"image_generation\", ...options.imageGeneration },\n    );\n  }\n\n  const text =\n    options.verbosity || options.outputSchema\n      ? {\n          ...(options.verbosity ? { verbosity: options.verbosity } : {}),\n          ...(options.outputSchema\n            ? {\n                format: {\n                  type: \"json_schema\" as const,\n                  strict: true as const,\n                  schema: options.outputSchema.schema,\n                  name: options.outputSchema.name ?? \"codex_output_schema\",\n                },\n              }\n            : {}),\n        }\n      : undefined;\n\n  return {\n    model: options.model,\n    ...(options.instructions ? { instructions: options.instructions } : {}),\n    // Copy the array, not its items: raw items must arrive byte-for-byte equivalent.\n    input: [...options.history],\n    ...(tools.length ? { tools } : {}),\n    tool_choice: options.toolChoice ?? \"auto\",\n    parallel_tool_calls: options.parallelToolCalls ?? true,\n    reasoning: options.reasoning ?? null,\n    store: false,\n    stream: true,\n    include: [\"reasoning.encrypted_content\"],\n    ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),\n    ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),\n    ...(text ? { text } : {}),\n  };\n}\n\nexport function buildCodexIdentityHeaders(\n  accessToken: string,\n  accountId: string,\n  correlation?: { sessionId?: string; threadId?: string; clientRequestId?: string },\n): Record<string, string> {\n  return {\n    Accept: \"text/event-stream\",\n    Authorization: `Bearer ${accessToken}`,\n    \"ChatGPT-Account-ID\": accountId,\n    \"Content-Type\": \"application/json\",\n    originator: CODEX_CLI_ORIGINATOR,\n    \"User-Agent\": codexCliUserAgent(),\n    ...(correlation?.sessionId ? { \"session-id\": correlation.sessionId } : {}),\n    ...(correlation?.threadId ? { \"thread-id\": correlation.threadId } : {}),\n    ...(correlation?.clientRequestId ? { \"x-client-request-id\": correlation.clientRequestId } : {}),\n  };\n}\n\nexport interface OpenAIUsage {\n  inputTokens: number;\n  cachedInputTokens: number;\n  outputTokens: number;\n  reasoningTokens: number;\n  totalTokens: number;\n}\n\nexport type OpenAINormalizedEvent =\n  | { type: \"created\"; responseId?: string }\n  | { type: \"text-delta\"; text: string; itemId?: string }\n  | {\n      type: \"image\";\n      id?: string;\n      base64: string;\n      mimeType: \"image/png\" | \"image/jpeg\" | \"image/webp\";\n      revisedPrompt?: string;\n      generation?: ImageGenerationMetadata;\n    }\n  | { type: \"output-item\"; item: OpenAIResponseItem; completed?: boolean }\n  | { type: \"completed\"; responseId: string; usage?: OpenAIUsage; model?: string }\n  | { type: \"error\"; error: OpenAIProtocolError };\n\nexport class OpenAIProtocolError extends Error {\n  constructor(\n    message: string,\n    public readonly code?: string,\n    public readonly status?: number,\n    public readonly retryAfterMs?: number,\n  ) {\n    super(message);\n    this.name = \"OpenAIProtocolError\";\n  }\n}\n\nfunction usageFrom(value: unknown): OpenAIUsage | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const usage = value as Record<string, unknown>;\n  const inputDetails = (usage.input_tokens_details ?? {}) as Record<string, unknown>;\n  const outputDetails = (usage.output_tokens_details ?? {}) as Record<string, unknown>;\n  return {\n    inputTokens: Number(usage.input_tokens ?? 0),\n    cachedInputTokens: Number(inputDetails.cached_tokens ?? 0),\n    outputTokens: Number(usage.output_tokens ?? 0),\n    reasoningTokens: Number(outputDetails.reasoning_tokens ?? 0),\n    totalTokens: Number(usage.total_tokens ?? 0),\n  };\n}\n\nexport function imageMimeType(\n  base64: string,\n  outputFormat?: unknown,\n): \"image/png\" | \"image/jpeg\" | \"image/webp\" {\n  // Inspect only the header, without decoding a potentially large image twice.\n  const header = Buffer.from(base64.slice(0, 24), \"base64\");\n  if (header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))\n    return \"image/png\";\n  if (header[0] === 255 && header[1] === 216 && header[2] === 255) return \"image/jpeg\";\n  if (header.toString(\"ascii\", 0, 4) === \"RIFF\" && header.toString(\"ascii\", 8, 12) === \"WEBP\")\n    return \"image/webp\";\n  if (outputFormat === \"jpeg\") return \"image/jpeg\";\n  if (outputFormat === \"webp\") return \"image/webp\";\n  if (outputFormat === undefined || outputFormat === \"png\") return \"image/png\";\n  throw new OpenAIProtocolError(`Unsupported image output format: ${String(outputFormat)}`);\n}\n\nexport function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | undefined {\n  if (!raw || typeof raw !== \"object\") return undefined;\n  const event = raw as Record<string, unknown>;\n  const type = String(event.type ?? \"\");\n  if (type === \"response.created\") {\n    const response = event.response as Record<string, unknown> | undefined;\n    return { type: \"created\", ...(response?.id ? { responseId: String(response.id) } : {}) };\n  }\n  if (type === \"response.output_text.delta\" && typeof event.delta === \"string\") {\n    return {\n      type: \"text-delta\",\n      text: event.delta,\n      ...(typeof event.item_id === \"string\" ? { itemId: event.item_id } : {}),\n    };\n  }\n  if (\n    (type === \"response.output_item.added\" || type === \"response.output_item.done\") &&\n    event.item &&\n    typeof event.item === \"object\"\n  ) {\n    const item = event.item as OpenAIResponseItem;\n    if (item.type === \"image_generation_call\" && typeof item.result === \"string\") {\n      return {\n        type: \"image\",\n        ...(typeof item.id === \"string\" ? { id: item.id } : {}),\n        base64: item.result,\n        mimeType: imageMimeType(item.result, item.output_format),\n        ...(typeof item.revised_prompt === \"string\"\n          ? { revisedPrompt: item.revised_prompt }\n          : typeof item.revisedPrompt === \"string\"\n            ? { revisedPrompt: item.revisedPrompt }\n            : {}),\n      };\n    }\n    return { type: \"output-item\", item, completed: type === \"response.output_item.done\" };\n  }\n  if (type === \"response.completed\") {\n    const response = (event.response ?? {}) as Record<string, unknown>;\n    return {\n      type: \"completed\",\n      responseId: String(response.id ?? \"\"),\n      ...(response.usage ? { usage: usageFrom(response.usage) } : {}),\n      ...(typeof response.model === \"string\" ? { model: response.model } : {}),\n    };\n  }\n  if (type === \"error\" || type === \"response.failed\" || type === \"response.incomplete\") {\n    const source = (event.error ?? event.response ?? event) as Record<string, unknown>;\n    const nested = (source.error ?? source) as Record<string, unknown>;\n    return {\n      type: \"error\",\n      error: new OpenAIProtocolError(\n        String(nested.message ?? `OpenAI stream ended with ${type}`),\n        typeof nested.code === \"string\" ? nested.code : undefined,\n      ),\n    };\n  }\n  return undefined;\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-backend-protocol.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-backend-protocol.ts"],"sourcesContent":["import os from \"node:os\";\n\nimport { type ImageGenerationMetadata } from \"../../../application/qgrid/qgrid.types\";\nimport { type OpenAIEffort } from \"../common/effort\";\n\nexport const CHATGPT_CODEX_RESPONSES_URL =\n  \"https://chatgpt.com/backend-api/codex/responses\" as const;\n\nexport const CODEX_CLI_ORIGINATOR = \"codex_cli_rs\" as const;\nexport const CODEX_CLI_VERSION = \"0.147.0\" as const;\n\nexport interface CodexUserAgentPlatform {\n  osType: string;\n  osVersion: string;\n  architecture: string;\n  terminal: string;\n}\n\nfunction codexPlatform(): CodexUserAgentPlatform {\n  const names: Partial<Record<NodeJS.Platform, string>> = {\n    darwin: \"Mac OS\",\n    linux: \"Linux\",\n    win32: \"Windows\",\n  };\n  const terminal = process.env.TERM_PROGRAM;\n  const terminalVersion = process.env.TERM_PROGRAM_VERSION;\n  return {\n    osType: names[process.platform] ?? process.platform,\n    osVersion: os.release(),\n    architecture: process.arch,\n    terminal: terminal ? `${terminal}${terminalVersion ? `/${terminalVersion}` : \"\"}` : \"unknown\",\n  };\n}\n\n/** Matches the platform/terminal suffix emitted by the pinned Rust Codex CLI. */\nexport function codexCliUserAgent(platform: CodexUserAgentPlatform = codexPlatform()): string {\n  return `codex_cli_rs/${CODEX_CLI_VERSION} (${platform.osType} ${platform.osVersion}; ${platform.architecture}) ${platform.terminal}`;\n}\n\nexport type JsonValue =\n  | null\n  | boolean\n  | number\n  | string\n  | JsonValue[]\n  | { [key: string]: JsonValue };\n\n/** Raw Responses API items. Keeping these opaque preserves the complete conversation history. */\nexport type OpenAIResponseItem = Record<string, unknown>;\n\nexport interface OpenAIOutputSchema {\n  name?: string;\n  schema: JsonValue;\n}\n\nexport interface OpenAIResponsesOptions {\n  model: string;\n  instructions?: string;\n  history: readonly OpenAIResponseItem[];\n  tools?: readonly OpenAIResponseItem[];\n  toolChoice?: string | OpenAIResponseItem;\n  parallelToolCalls?: boolean;\n  reasoning?: {\n    effort?: OpenAIEffort | \"none\";\n    summary?: \"auto\" | \"concise\" | \"detailed\";\n  };\n  verbosity?: \"low\" | \"medium\" | \"high\";\n  serviceTier?: string;\n  promptCacheKey?: string;\n  outputSchema?: OpenAIOutputSchema;\n  imageGeneration?: boolean | OpenAIResponseItem;\n}\n\nexport interface OpenAIResponsesRequest {\n  model: string;\n  instructions?: string;\n  input: OpenAIResponseItem[];\n  tools?: OpenAIResponseItem[];\n  tool_choice: string | OpenAIResponseItem;\n  parallel_tool_calls: boolean;\n  reasoning: OpenAIResponsesOptions[\"reasoning\"] | null;\n  store: false;\n  stream: true;\n  include: string[];\n  service_tier?: string;\n  prompt_cache_key?: string;\n  text?: {\n    verbosity?: \"low\" | \"medium\" | \"high\";\n    format?: {\n      type: \"json_schema\";\n      strict: true;\n      schema: JsonValue;\n      name: string;\n    };\n  };\n}\n\nexport function buildOpenAIResponsesRequest(\n  options: OpenAIResponsesOptions,\n): OpenAIResponsesRequest {\n  const tools = options.tools ? [...options.tools] : [];\n  if (options.imageGeneration) {\n    tools.push(\n      options.imageGeneration === true\n        ? { type: \"image_generation\" }\n        : { type: \"image_generation\", ...options.imageGeneration },\n    );\n  }\n\n  const text =\n    options.verbosity || options.outputSchema\n      ? {\n          ...(options.verbosity ? { verbosity: options.verbosity } : {}),\n          ...(options.outputSchema\n            ? {\n                format: {\n                  type: \"json_schema\" as const,\n                  strict: true as const,\n                  schema: options.outputSchema.schema,\n                  name: options.outputSchema.name ?? \"codex_output_schema\",\n                },\n              }\n            : {}),\n        }\n      : undefined;\n\n  return {\n    model: options.model,\n    ...(options.instructions ? { instructions: options.instructions } : {}),\n    // Copy the array, not its items: raw items must arrive byte-for-byte equivalent.\n    input: [...options.history],\n    ...(tools.length ? { tools } : {}),\n    tool_choice: options.toolChoice ?? \"auto\",\n    parallel_tool_calls: options.parallelToolCalls ?? true,\n    reasoning: options.reasoning ?? null,\n    store: false,\n    stream: true,\n    include: [\"reasoning.encrypted_content\"],\n    ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),\n    ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),\n    ...(text ? { text } : {}),\n  };\n}\n\nexport function buildCodexIdentityHeaders(\n  accessToken: string,\n  accountId: string,\n  correlation?: { sessionId?: string; threadId?: string; clientRequestId?: string },\n): Record<string, string> {\n  return {\n    Accept: \"text/event-stream\",\n    Authorization: `Bearer ${accessToken}`,\n    \"ChatGPT-Account-ID\": accountId,\n    \"Content-Type\": \"application/json\",\n    originator: CODEX_CLI_ORIGINATOR,\n    \"User-Agent\": codexCliUserAgent(),\n    ...(correlation?.sessionId ? { \"session-id\": correlation.sessionId } : {}),\n    ...(correlation?.threadId ? { \"thread-id\": correlation.threadId } : {}),\n    ...(correlation?.clientRequestId ? { \"x-client-request-id\": correlation.clientRequestId } : {}),\n  };\n}\n\nexport interface OpenAIUsage {\n  inputTokens: number;\n  cachedInputTokens: number;\n  outputTokens: number;\n  reasoningTokens: number;\n  totalTokens: number;\n}\n\nexport type OpenAINormalizedEvent =\n  | { type: \"created\"; responseId?: string }\n  | { type: \"text-delta\"; text: string; itemId?: string }\n  | {\n      type: \"image\";\n      id?: string;\n      base64: string;\n      mimeType: \"image/png\" | \"image/jpeg\" | \"image/webp\";\n      revisedPrompt?: string;\n      generation?: ImageGenerationMetadata;\n    }\n  | { type: \"output-item\"; item: OpenAIResponseItem; completed?: boolean }\n  | { type: \"completed\"; responseId: string; usage?: OpenAIUsage; model?: string }\n  | { type: \"error\"; error: OpenAIProtocolError };\n\nexport class OpenAIProtocolError extends Error {\n  constructor(\n    message: string,\n    public readonly code?: string,\n    public readonly status?: number,\n    public readonly retryAfterMs?: number,\n  ) {\n    super(message);\n    this.name = \"OpenAIProtocolError\";\n  }\n}\n\nfunction usageFrom(value: unknown): OpenAIUsage | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const usage = value as Record<string, unknown>;\n  const inputDetails = (usage.input_tokens_details ?? {}) as Record<string, unknown>;\n  const outputDetails = (usage.output_tokens_details ?? {}) as Record<string, unknown>;\n  return {\n    inputTokens: Number(usage.input_tokens ?? 0),\n    cachedInputTokens: Number(inputDetails.cached_tokens ?? 0),\n    outputTokens: Number(usage.output_tokens ?? 0),\n    reasoningTokens: Number(outputDetails.reasoning_tokens ?? 0),\n    totalTokens: Number(usage.total_tokens ?? 0),\n  };\n}\n\nexport function imageMimeType(\n  base64: string,\n  outputFormat?: unknown,\n): \"image/png\" | \"image/jpeg\" | \"image/webp\" {\n  // Inspect only the header, without decoding a potentially large image twice.\n  const header = Buffer.from(base64.slice(0, 24), \"base64\");\n  if (header.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))\n    return \"image/png\";\n  if (header[0] === 255 && header[1] === 216 && header[2] === 255) return \"image/jpeg\";\n  if (header.toString(\"ascii\", 0, 4) === \"RIFF\" && header.toString(\"ascii\", 8, 12) === \"WEBP\")\n    return \"image/webp\";\n  if (outputFormat === \"jpeg\") return \"image/jpeg\";\n  if (outputFormat === \"webp\") return \"image/webp\";\n  if (outputFormat === undefined || outputFormat === \"png\") return \"image/png\";\n  throw new OpenAIProtocolError(`Unsupported image output format: ${String(outputFormat)}`);\n}\n\nexport function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | undefined {\n  if (!raw || typeof raw !== \"object\") return undefined;\n  const event = raw as Record<string, unknown>;\n  const type = String(event.type ?? \"\");\n  if (type === \"response.created\") {\n    const response = event.response as Record<string, unknown> | undefined;\n    return { type: \"created\", ...(response?.id ? { responseId: String(response.id) } : {}) };\n  }\n  if (type === \"response.output_text.delta\" && typeof event.delta === \"string\") {\n    return {\n      type: \"text-delta\",\n      text: event.delta,\n      ...(typeof event.item_id === \"string\" ? { itemId: event.item_id } : {}),\n    };\n  }\n  if (\n    (type === \"response.output_item.added\" || type === \"response.output_item.done\") &&\n    event.item &&\n    typeof event.item === \"object\"\n  ) {\n    const item = event.item as OpenAIResponseItem;\n    if (item.type === \"image_generation_call\" && typeof item.result === \"string\") {\n      // PNG exposes dimensions in its fixed header. Other formats retain the\n      // backend's observed size; never substitute requested image controls.\n      const header = Buffer.from(item.result.slice(0, 32), \"base64\");\n      const pngSize =\n        header.length >= 24 &&\n        header.subarray(0, 8).equals(Buffer.from(\"89504e470d0a1a0a\", \"hex\")) &&\n        header.readUInt32BE(16) > 0 &&\n        header.readUInt32BE(20) > 0\n          ? `${header.readUInt32BE(16)}x${header.readUInt32BE(20)}`\n          : undefined;\n      const size =\n        pngSize ??\n        (typeof item.size === \"string\" && /^[1-9]\\d*x[1-9]\\d*$/.test(item.size)\n          ? item.size\n          : undefined);\n      return {\n        type: \"image\",\n        ...(typeof item.id === \"string\" ? { id: item.id } : {}),\n        base64: item.result,\n        mimeType: imageMimeType(item.result, item.output_format),\n        generation: {\n          route: \"codex-responses\",\n          ...(size ? { size } : {}),\n          ...(typeof item.model === \"string\" ? { model: item.model } : {}),\n          ...(typeof item.quality === \"string\" ? { quality: item.quality } : {}),\n          ...(typeof item.background === \"string\" ? { background: item.background } : {}),\n        },\n        ...(typeof item.revised_prompt === \"string\"\n          ? { revisedPrompt: item.revised_prompt }\n          : typeof item.revisedPrompt === \"string\"\n            ? { revisedPrompt: item.revisedPrompt }\n            : {}),\n      };\n    }\n    return { type: \"output-item\", item, completed: type === \"response.output_item.done\" };\n  }\n  if (type === \"response.completed\") {\n    const response = (event.response ?? {}) as Record<string, unknown>;\n    return {\n      type: \"completed\",\n      responseId: String(response.id ?? \"\"),\n      ...(response.usage ? { usage: usageFrom(response.usage) } : {}),\n      ...(typeof response.model === \"string\" ? { model: response.model } : {}),\n    };\n  }\n  if (type === \"error\" || type === \"response.failed\" || type === \"response.incomplete\") {\n    const source = (event.error ?? event.response ?? event) as Record<string, unknown>;\n    const nested = (source.error ?? source) as Record<string, unknown>;\n    return {\n      type: \"error\",\n      error: new OpenAIProtocolError(\n        String(nested.message ?? `OpenAI stream ended with ${type}`),\n        typeof nested.code === \"string\" ? nested.code : undefined,\n      ),\n    };\n  }\n  return undefined;\n}\n"],"mappings":";;AAKA,MAAa,8BACX;AAEF,MAAa,uBAAuB;AACpC,MAAa,oBAAoB;AASjC,SAAS,gBAAwC;CAC/C,MAAM,QAAkD;EACtD,QAAQ;EACR,OAAO;EACP,OAAO;CACT;CACA,MAAM,WAAW,QAAQ,IAAI;CAC7B,MAAM,kBAAkB,QAAQ,IAAI;CACpC,OAAO;EACL,QAAQ,MAAM,QAAQ,aAAa,QAAQ;EAC3C,WAAW,GAAG,QAAQ;EACtB,cAAc,QAAQ;EACtB,UAAU,WAAW,GAAG,WAAW,kBAAkB,IAAI,oBAAoB,OAAO;CACtF;AACF;;AAGA,SAAgB,kBAAkB,WAAmC,cAAc,GAAW;CAC5F,OAAO,gBAAgB,kBAAkB,IAAI,SAAS,OAAO,GAAG,SAAS,UAAU,IAAI,SAAS,aAAa,IAAI,SAAS;AAC5H;AA4DA,SAAgB,4BACd,SACwB;CACxB,MAAM,QAAQ,QAAQ,QAAQ,CAAC,GAAG,QAAQ,KAAK,IAAI,CAAC;CACpD,IAAI,QAAQ,iBACV,MAAM,KACJ,QAAQ,oBAAoB,OACxB,EAAE,MAAM,mBAAmB,IAC3B;EAAE,MAAM;EAAoB,GAAG,QAAQ;CAAgB,CAC7D;CAGF,MAAM,OACJ,QAAQ,aAAa,QAAQ,eACzB;EACE,GAAI,QAAQ,YAAY,EAAE,WAAW,QAAQ,UAAU,IAAI,CAAC;EAC5D,GAAI,QAAQ,eACR,EACE,QAAQ;GACN,MAAM;GACN,QAAQ;GACR,QAAQ,QAAQ,aAAa;GAC7B,MAAM,QAAQ,aAAa,QAAQ;EACrC,EACF,IACA,CAAC;CACP,IACA;CAEN,OAAO;EACL,OAAO,QAAQ;EACf,GAAI,QAAQ,eAAe,EAAE,cAAc,QAAQ,aAAa,IAAI,CAAC;EAErE,OAAO,CAAC,GAAG,QAAQ,OAAO;EAC1B,GAAI,MAAM,SAAS,EAAE,MAAM,IAAI,CAAC;EAChC,aAAa,QAAQ,cAAc;EACnC,qBAAqB,QAAQ,qBAAqB;EAClD,WAAW,QAAQ,aAAa;EAChC,OAAO;EACP,QAAQ;EACR,SAAS,CAAC,6BAA6B;EACvC,GAAI,QAAQ,cAAc,EAAE,cAAc,QAAQ,YAAY,IAAI,CAAC;EACnE,GAAI,QAAQ,iBAAiB,EAAE,kBAAkB,QAAQ,eAAe,IAAI,CAAC;EAC7E,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;CACzB;AACF;AAEA,SAAgB,0BACd,aACA,WACA,aACwB;CACxB,OAAO;EACL,QAAQ;EACR,eAAe,UAAU;EACzB,sBAAsB;EACtB,gBAAgB;EAChB,YAAY;EACZ,cAAc,kBAAkB;EAChC,GAAI,aAAa,YAAY,EAAE,cAAc,YAAY,UAAU,IAAI,CAAC;EACxE,GAAI,aAAa,WAAW,EAAE,aAAa,YAAY,SAAS,IAAI,CAAC;EACrE,GAAI,aAAa,kBAAkB,EAAE,uBAAuB,YAAY,gBAAgB,IAAI,CAAC;CAC/F;AACF;AAyBA,IAAa,sBAAb,cAAyC,MAAM;CAG3B;CACA;CACA;CAJlB,YACE,SACA,MACA,QACA,cACA;EACA,MAAM,OAAO;EAJG,KAAA,OAAA;EACA,KAAA,SAAA;EACA,KAAA,eAAA;EAGhB,KAAK,OAAO;CACd;AACF;AAEA,SAAS,UAAU,OAAyC;CAC1D,IAAI,CAAC,SAAS,OAAO,UAAU,UAAU,OAAO;CAChD,MAAM,QAAQ;CACd,MAAM,eAAgB,MAAM,wBAAwB,CAAC;CACrD,MAAM,gBAAiB,MAAM,yBAAyB,CAAC;CACvD,OAAO;EACL,aAAa,OAAO,MAAM,gBAAgB,CAAC;EAC3C,mBAAmB,OAAO,aAAa,iBAAiB,CAAC;EACzD,cAAc,OAAO,MAAM,iBAAiB,CAAC;EAC7C,iBAAiB,OAAO,cAAc,oBAAoB,CAAC;EAC3D,aAAa,OAAO,MAAM,gBAAgB,CAAC;CAC7C;AACF;AAEA,SAAgB,cACd,QACA,cAC2C;CAE3C,MAAM,SAAS,OAAO,KAAK,OAAO,MAAM,GAAG,EAAE,GAAG,QAAQ;CACxD,IAAI,OAAO,SAAS,GAAG,CAAC,CAAC,CAAC,OAAO,OAAO,KAAK;EAAC;EAAK;EAAI;EAAI;EAAI;EAAI;EAAI;EAAI;CAAE,CAAC,CAAC,GAC7E,OAAO;CACT,IAAI,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,OAAO,KAAK,OAAO;CACxE,IAAI,OAAO,SAAS,SAAS,GAAG,CAAC,MAAM,UAAU,OAAO,SAAS,SAAS,GAAG,EAAE,MAAM,QACnF,OAAO;CACT,IAAI,iBAAiB,QAAQ,OAAO;CACpC,IAAI,iBAAiB,QAAQ,OAAO;CACpC,IAAI,iBAAiB,UAAa,iBAAiB,OAAO,OAAO;CACjE,MAAM,IAAI,oBAAoB,oCAAoC,OAAO,YAAY,GAAG;AAC1F;AAEA,SAAgB,qBAAqB,KAAiD;CACpF,IAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,OAAO;CAC5C,MAAM,QAAQ;CACd,MAAM,OAAO,OAAO,MAAM,QAAQ,EAAE;CACpC,IAAI,SAAS,oBAAoB;EAC/B,MAAM,WAAW,MAAM;EACvB,OAAO;GAAE,MAAM;GAAW,GAAI,UAAU,KAAK,EAAE,YAAY,OAAO,SAAS,EAAE,EAAE,IAAI,CAAC;EAAG;CACzF;CACA,IAAI,SAAS,gCAAgC,OAAO,MAAM,UAAU,UAClE,OAAO;EACL,MAAM;EACN,MAAM,MAAM;EACZ,GAAI,OAAO,MAAM,YAAY,WAAW,EAAE,QAAQ,MAAM,QAAQ,IAAI,CAAC;CACvE;CAEF,KACG,SAAS,gCAAgC,SAAS,gCACnD,MAAM,QACN,OAAO,MAAM,SAAS,UACtB;EACA,MAAM,OAAO,MAAM;EACnB,IAAI,KAAK,SAAS,2BAA2B,OAAO,KAAK,WAAW,UAAU;GAG5E,MAAM,SAAS,OAAO,KAAK,KAAK,OAAO,MAAM,GAAG,EAAE,GAAG,QAAQ;GAQ7D,MAAM,QANJ,OAAO,UAAU,MACjB,OAAO,SAAS,GAAG,CAAC,CAAC,CAAC,OAAO,OAAO,KAAK,oBAAoB,KAAK,CAAC,KACnE,OAAO,aAAa,EAAE,IAAI,KAC1B,OAAO,aAAa,EAAE,IAAI,IACtB,GAAG,OAAO,aAAa,EAAE,EAAE,GAAG,OAAO,aAAa,EAAE,MACpD,YAGH,OAAO,KAAK,SAAS,YAAY,sBAAsB,KAAK,KAAK,IAAI,IAClE,KAAK,OACL;GACN,OAAO;IACL,MAAM;IACN,GAAI,OAAO,KAAK,OAAO,WAAW,EAAE,IAAI,KAAK,GAAG,IAAI,CAAC;IACrD,QAAQ,KAAK;IACb,UAAU,cAAc,KAAK,QAAQ,KAAK,aAAa;IACvD,YAAY;KACV,OAAO;KACP,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;KACvB,GAAI,OAAO,KAAK,UAAU,WAAW,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;KAC9D,GAAI,OAAO,KAAK,YAAY,WAAW,EAAE,SAAS,KAAK,QAAQ,IAAI,CAAC;KACpE,GAAI,OAAO,KAAK,eAAe,WAAW,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;IAC/E;IACA,GAAI,OAAO,KAAK,mBAAmB,WAC/B,EAAE,eAAe,KAAK,eAAe,IACrC,OAAO,KAAK,kBAAkB,WAC5B,EAAE,eAAe,KAAK,cAAc,IACpC,CAAC;GACT;EACF;EACA,OAAO;GAAE,MAAM;GAAe;GAAM,WAAW,SAAS;EAA4B;CACtF;CACA,IAAI,SAAS,sBAAsB;EACjC,MAAM,WAAY,MAAM,YAAY,CAAC;EACrC,OAAO;GACL,MAAM;GACN,YAAY,OAAO,SAAS,MAAM,EAAE;GACpC,GAAI,SAAS,QAAQ,EAAE,OAAO,UAAU,SAAS,KAAK,EAAE,IAAI,CAAC;GAC7D,GAAI,OAAO,SAAS,UAAU,WAAW,EAAE,OAAO,SAAS,MAAM,IAAI,CAAC;EACxE;CACF;CACA,IAAI,SAAS,WAAW,SAAS,qBAAqB,SAAS,uBAAuB;EACpF,MAAM,SAAU,MAAM,SAAS,MAAM,YAAY;EACjD,MAAM,SAAU,OAAO,SAAS;EAChC,OAAO;GACL,MAAM;GACN,OAAO,IAAI,oBACT,OAAO,OAAO,WAAW,4BAA4B,MAAM,GAC3D,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO,MAClD;EACF;CACF;AAEF"}

package/bundle/src/application/qgrid/qgrid-image-generation.test.ts

@@ -17,6 +17,24 @@ function result(content: QgridContent[]): QueryOutput {
 }
 
 describe("standalone image cost estimates", () => {
+  it("accepts size hints without promising public API resolution limits", () => {
+    for (const size of ["auto", "1152x2560", "841x1870", "2160x3840"]) {
+      expect(QueryInput.parse({ prompt: "draw", imageGenerationOptions: { size } }).imageGenerationOptions?.size).toBe(size);
+    }
+    for (const size of ["9:20", "0x1024", "1.5x1024", "-1x1024", "9007199254740992x1"]) {
+      expect(QueryInput.safeParse({ prompt: "draw", imageGenerationOptions: { size } }).success).toBe(false);
+    }
+  });
+
+  it("leaves custom/auto size and observed hosted image costs unknown", () => {
+    const output = result([{ type: "image", data: "png" }]);
+    for (const size of ["auto", "1152x2560"] as const) {
+      expect(estimateImageGenerationCostMicroUsd(output, { size })).toBeNull();
+    }
+    expect(estimateImageGenerationCostMicroUsd(result([{ type: "image", data: "png", generation: {
+      route: "codex-responses", size: "841x1870", quality: "low",
+    } }]), options)).toBeNull();
+  });
   it("accepts automatic image mode while preserving boolean requests", () => {
     for (const imageGeneration of [true, false, "auto"] as const) {
       expect(QueryInput.parse({ prompt: "chat", imageGeneration }).imageGeneration).toBe(imageGeneration);

package/bundle/src/application/qgrid/qgrid-image-generation.ts

@@ -18,7 +18,7 @@ export type ResolvedImageGenerationOptions = {
 // https://developers.openai.com/api/docs/guides/image-generation#calculating-costs
 const IMAGE_OUTPUT_COST_MICRO_USD: Record<
   ImageGenerationQuality,
-  Record<ImageGenerationSize, number>
+  Partial<Record<ImageGenerationSize, number>>
 > = {
   low: {
     "1024x1024": 6_000,
@@ -49,7 +49,13 @@ export function resolveImageGenerationOptions(
 export function imageGenerationCostMethod(
   options: ImageGenerationOptions | undefined,
   result?: QueryOutput,
-): string {
+): string | null {
+  if (
+    result?.content.some(
+      (item) => item.type === "image" && item.generation?.route === "codex-responses",
+    )
+  )
+    return null;
   if (
     result?.content.some(
       (item) => item.type === "image" && item.generation?.route === "codex-images",
@@ -58,6 +64,7 @@ export function imageGenerationCostMethod(
     return "estimated:gpt-image-2:reported-usage:public-prices:conservative";
   }
   const resolved = resolveImageGenerationOptions(options);
+  if (IMAGE_OUTPUT_COST_MICRO_USD[resolved.quality][resolved.size] === undefined) return null;
   return `assumed:${CODEX_IMAGE_GENERATION_MODEL}:${resolved.quality}:${resolved.size}:png`;
 }
 
@@ -68,6 +75,9 @@ export function estimateImageGenerationCostMicroUsd(
   const images = result.content.filter((item) => item.type === "image");
   const imageCount = images.length;
   if (imageCount === 0) return null;
+  // Hosted Responses reports observed settings but no trustworthy image usage
+  // or guaranteed image model. Requested size/quality cannot price that output.
+  if (images.some((image) => image.generation?.route === "codex-responses")) return null;
   if (images.some((image) => image.generation?.route === "codex-images")) {
     // The standalone response's aggregate usage is carried by its first image only.
     // Do not multiply it by output count or price it as the requested text driver.
@@ -88,5 +98,6 @@ export function estimateImageGenerationCostMicroUsd(
     );
   }
   const resolved = resolveImageGenerationOptions(options);
-  return imageCount * IMAGE_OUTPUT_COST_MICRO_USD[resolved.quality][resolved.size];
+  const unitCost = IMAGE_OUTPUT_COST_MICRO_USD[resolved.quality][resolved.size];
+  return unitCost === undefined ? null : imageCount * unitCost;
 }

package/bundle/src/application/qgrid/qgrid-response-format.test.ts

@@ -19,6 +19,15 @@ it("logs observed standalone settings separately from requested controls without
 });
 
 describe("qgrid response log formatting", () => {
+  it("keeps custom requests and hosted observations separate without inventing a price assumption", () => {
+    const args = { prompt: "draw in 9:20", imageGenerationOptions: { size: "1152x2560" } };
+    const generation = { route: "codex-responses" as const, size: "841x1870", quality: "low" };
+    const observed = JSON.parse(imageGenerationToolArgs(args, { generation }));
+    expect(observed.requestedOptions.size).toBe("1152x2560");
+    expect(observed.observedGeneration).toEqual(generation);
+    expect(observed).not.toHaveProperty("pricingAssumption");
+    expect(JSON.parse(imageGenerationToolArgs(args))).not.toHaveProperty("pricingAssumption");
+  });
   it("logs the returned MIME and requested output format", () => {
     expect(formatImagePartForLog({ type: "image", data: "webp", mediaType: "image/webp" })).toContain("data:image/webp;base64,webp");
     expect(JSON.parse(imageGenerationToolArgs({ prompt: "draw", imageGenerationOptions: { outputFormat: "webp" } })).tool.outputFormat).toBe("webp");

package/bundle/src/application/qgrid/qgrid-response-format.ts

@@ -1,5 +1,6 @@
 import {
   CODEX_IMAGE_GENERATION_MODEL,
+  imageGenerationCostMethod,
   resolveImageGenerationOptions,
 } from "./qgrid-image-generation";
 import {
@@ -62,13 +63,15 @@ export function imageGenerationToolArgs(
     ...(args.imageGenerationOptions ? { requestedOptions: args.imageGenerationOptions } : {}),
     ...(options.generation
       ? { observedGeneration: options.generation }
-      : {
-          pricingAssumption: {
-            model: CODEX_IMAGE_GENERATION_MODEL,
-            quality: resolved.quality,
-            size: resolved.size,
-          },
-        }),
+      : imageGenerationCostMethod(args.imageGenerationOptions)
+        ? {
+            pricingAssumption: {
+              model: CODEX_IMAGE_GENERATION_MODEL,
+              quality: resolved.quality,
+              size: resolved.size,
+            },
+          }
+        : {}),
   });
 }
 

package/bundle/src/application/qgrid/qgrid.frame.ts

@@ -500,8 +500,10 @@ class QgridFrameClass extends BaseFrameClass {
   // 화면의 목록 필터를 그대로 받아 같은 조건의 합계를 돌려준다 — 목록과 비용이
   // 서로 다른 모수를 보면 사용자에게는 숫자가 어긋난 것으로 읽힌다.
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })
-  async totalCost(params?: RequestLogListParams): Promise<{ usd: number }> {
-    return { usd: await RequestLogModel.totalCost(params) };
+  async totalCost(
+    params?: RequestLogListParams,
+  ): Promise<{ usd: number; unknownImageCostCount: number }> {
+    return RequestLogModel.totalCost(params);
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "tanstack-query"] })

package/bundle/src/application/qgrid/qgrid.types.ts

@@ -12,10 +12,10 @@ export const QgridTool = z.object({
 });
 export type QgridTool = z.infer<typeof QgridTool>;
 
-// Observed standalone Images response values, distinct from requested generation hints.
+// Observed image response values, distinct from requested generation hints.
 export const ImageGenerationMetadata = z.object({
-  route: z.literal("codex-images"),
-  model: z.literal("gpt-image-2"),
+  route: z.enum(["codex-images", "codex-responses"]),
+  model: z.string().optional(),
   background: z.string().optional(),
   quality: z.string().optional(),
   size: z.string().optional(),
@@ -79,7 +79,17 @@ export type ServiceTier = z.infer<typeof ServiceTier>;
 export const ImageGenerationQuality = z.enum(["low", "medium", "high"]);
 export type ImageGenerationQuality = z.infer<typeof ImageGenerationQuality>;
 
-export const ImageGenerationSize = z.enum(["1024x1024", "1024x1536", "1536x1024"]);
+// Subscription-backend hints, not public Images API resolution guarantees.
+export const ImageGenerationSize = z.union([
+  z.literal("auto"),
+  z
+    .string()
+    .regex(/^[1-9]\d*x[1-9]\d*$/)
+    .refine(
+      (size) => size.split("x").every((edge) => Number.isSafeInteger(Number(edge))),
+      "Image dimensions must be positive safe integers",
+    ),
+]);
 export type ImageGenerationSize = z.infer<typeof ImageGenerationSize>;
 
 export const ImageGenerationOptions = z

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

@@ -564,7 +564,7 @@ describe("RequestLogModel cost provenance", () => {
    * @param confirmedTotal SUM 쿼리가 돌려줄 micro-USD 합계
    * @param legacyRows 재계산 대상 row 들
    */
-  function mockTotalCostQueries(confirmedTotal: number, legacyRows: unknown[]) {
+  function mockTotalCostQueries(confirmedTotal: number, legacyRows: unknown[], unknownImageCostCount = 0) {
     // subset qb 는 SELECT 를 비우고(clear) 집계/축소된 컬럼만 다시 얹는다 — 구현과 같은 체인.
     const sumChain = {
       where: vi.fn(),
@@ -572,7 +572,7 @@ describe("RequestLogModel cost provenance", () => {
       whereRaw: vi.fn(),
       clear: vi.fn(),
       select: vi.fn(),
-      first: vi.fn(async () => ({ total: confirmedTotal })),
+      first: vi.fn(async () => ({ total: confirmedTotal, unknownImageCostCount })),
     };
     sumChain.where.mockReturnValue(sumChain);
     sumChain.whereIn.mockReturnValue(sumChain);
@@ -606,7 +606,7 @@ describe("RequestLogModel cost provenance", () => {
   it("uses exact stored cost for rows with a cost source", async () => {
     mockTotalCostQueries(3_000, []);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBe(0.003);
+    await expect(RequestLogModel.totalCost()).resolves.toEqual({ usd: 0.003, unknownImageCostCount: 0 });
   });
 
   it("sums every row in SQL without a cost_source predicate", async () => {
@@ -637,7 +637,7 @@ describe("RequestLogModel cost provenance", () => {
       },
     ]);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
+    await expect(RequestLogModel.totalCost().then((result) => result.usd)).resolves.toBeCloseTo(0.4725, 10);
   });
 
   it("adds only the delta for legacy rows already counted in the SQL sum", async () => {
@@ -656,7 +656,7 @@ describe("RequestLogModel cost provenance", () => {
       },
     ]);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4725, 10);
+    await expect(RequestLogModel.totalCost().then((result) => result.usd)).resolves.toBeCloseTo(0.4725, 10);
   });
 
   it("leaves the stored value untouched for legacy rows without a model name", async () => {
@@ -675,7 +675,7 @@ describe("RequestLogModel cost provenance", () => {
       },
     ]);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.005, 10);
+    await expect(RequestLogModel.totalCost().then((result) => result.usd)).resolves.toBeCloseTo(0.005, 10);
   });
 
   it("applies list filters to both cost queries so totals match the filtered list", async () => {
@@ -721,7 +721,7 @@ describe("RequestLogModel cost provenance", () => {
       },
     ]);
 
-    await expect(RequestLogModel.totalCost()).resolves.toBeCloseTo(0.4755, 10);
+    await expect(RequestLogModel.totalCost().then((result) => result.usd)).resolves.toBeCloseTo(0.4755, 10);
   });
 });
 
@@ -738,10 +738,13 @@ describe("RequestLogModel PostgreSQL", () => {
         { cost_usd: 5_000, image_cost_usd: 10_000, cost_source: "provider" },
         { cost_usd: 1_000, image_cost_usd: 20_000, cost_source: null },
         { cost_usd: 900_000, image_cost_usd: 700_000, cost_source: null },
+        { cost_usd: 1_000, image_cost_usd: null, cost_source: "provider", is_image_generation: true },
+        { cost_usd: 2_000, image_cost_usd: null, cost_source: "provider", is_image_generation: false },
+        { cost_usd: 500_000, image_cost_usd: null, cost_source: "provider", is_image_generation: true },
       ].entries()) {
         const id = await RequestLogModel.createRun({
           user_prompt: "cost regression",
-          project_name: index < 2 ? projectName : `${projectName}-other`,
+          project_name: index === 2 || index === 5 ? `${projectName}-other` : projectName,
         });
         ids.push(id);
         await RequestLogModel.getPuri("w").table("request_logs").where("id", id).update({
@@ -754,10 +757,12 @@ describe("RequestLogModel PostgreSQL", () => {
 
       const params = { sonamuFilter: { project_name: projectName }, num: 0, page: 1 };
       const { rows } = await RequestLogModel.findMany("C", params);
-      expect(rows.map((row) => row.id)).toEqual(expect.arrayContaining(ids.slice(0, 2)));
-      expect(rows).toHaveLength(2);
-      // Confirmed: .005 + .010; legacy driver repriced to .003, plus .020 image.
-      await expect(RequestLogModel.totalCost(params)).resolves.toBeCloseTo(0.038, 10);
+      expect(rows.map((row) => row.id)).toEqual(expect.arrayContaining([ids[0], ids[1], ids[3], ids[4]]));
+      expect(rows).toHaveLength(4);
+      // .038 known images + .001 hosted driver + .002 text; other project excluded.
+      const total = await RequestLogModel.totalCost(params);
+      expect(total.usd).toBeCloseTo(0.041, 10);
+      expect(total.unknownImageCostCount).toBe(1);
     } finally {
       await RequestLogModel.del(ids);
     }

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

@@ -820,7 +820,9 @@ class RequestLogModelClass extends BaseModelClass<
    * 필터 조건을 여기서 다시 구현하지 않고 `applyListFilters` 를 공유하는 것이 핵심이다 —
    * 두 쿼리가 각자 필터를 가지면 화면에서 필터를 걸었을 때 행 수와 비용이 조용히 어긋난다.
    */
-  async totalCost(rawParams: RequestLogListParams = { num: 0, page: 1 }): Promise<number> {
+  async totalCost(
+    rawParams: RequestLogListParams = { num: 0, page: 1 },
+  ): Promise<{ usd: number; unknownImageCostCount: number }> {
     const params = {
       num: 0,
       page: 1,
@@ -843,6 +845,9 @@ class RequestLogModelClass extends BaseModelClass<
         total: Puri.rawNumber(
           "COALESCE(SUM(GREATEST(request_logs.cost_usd, 0) + COALESCE(request_logs.image_cost_usd, 0)), 0)",
         ),
+        unknownImageCostCount: Puri.rawNumber(
+          "COUNT(*) FILTER (WHERE request_logs.is_image_generation = true AND request_logs.image_cost_usd IS NULL)",
+        ),
       })
       .first();
 
@@ -867,7 +872,7 @@ class RequestLogModelClass extends BaseModelClass<
     const storedTotal = Number(stored?.total ?? 0) / MICRO_USD;
 
     // legacy row 는 위 SUM 에 저장값으로 이미 포함되어 있다. 재계산값과의 차액만 더한다.
-    return legacyRows.reduce((sum, row) => {
+    const usd = legacyRows.reduce((sum, row) => {
       const alreadySummed = Math.max(row.cost_usd ?? 0, 0) / MICRO_USD;
       const usage = normalizedUsageForCost(row);
       if (!usage.model) return sum;
@@ -884,6 +889,7 @@ class RequestLogModelClass extends BaseModelClass<
         alreadySummed
       );
     }, storedTotal);
+    return { usd, unknownImageCostCount: Number(stored?.unknownImageCostCount ?? 0) };
   }
 
   async distinctProjectNames(): Promise<string[]> {

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

@@ -8,6 +8,24 @@ import {
 } from "./openai-backend-protocol";
 
 describe("OpenAI Codex backend protocol", () => {
+  it.each(["png", "jpeg", "webp"])("preserves reported hosted %s generation settings", (output_format) => {
+    expect(normalizeOpenAIEvent({ type: "response.output_item.done", item: {
+      type: "image_generation_call", result: "aGVsbG8=", output_format,
+      size: "841x1870", quality: "low", background: "opaque",
+    } })).toMatchObject({ generation: {
+      route: "codex-responses", size: "841x1870", quality: "low", background: "opaque",
+    } });
+  });
+
+  it("reports PNG byte dimensions instead of a conflicting backend size", () => {
+    const bytes = Buffer.alloc(24);
+    Buffer.from("89504e470d0a1a0a", "hex").copy(bytes);
+    bytes.writeUInt32BE(841, 16);
+    bytes.writeUInt32BE(1870, 20);
+    expect(normalizeOpenAIEvent({ type: "response.output_item.done", item: {
+      type: "image_generation_call", result: bytes.toString("base64"), size: "1152x2560",
+    } })).toMatchObject({ generation: { route: "codex-responses", size: "841x1870" } });
+  });
   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 });
@@ -129,6 +147,6 @@ describe("OpenAI Codex backend protocol", () => {
         type: "response.output_item.done",
         item: { type: "image_generation_call", id: "img", result: "aGVsbG8=", revised_prompt: "better" },
       }),
-    ).toEqual({ type: "image", id: "img", base64: "aGVsbG8=", mimeType: "image/png", revisedPrompt: "better" });
+    ).toEqual({ type: "image", id: "img", base64: "aGVsbG8=", mimeType: "image/png", revisedPrompt: "better", generation: { route: "codex-responses" } });
   });
 });

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

@@ -248,11 +248,33 @@ export function normalizeOpenAIEvent(raw: unknown): OpenAINormalizedEvent | unde
   ) {
     const item = event.item as OpenAIResponseItem;
     if (item.type === "image_generation_call" && typeof item.result === "string") {
+      // PNG exposes dimensions in its fixed header. Other formats retain the
+      // backend's observed size; never substitute requested image controls.
+      const header = Buffer.from(item.result.slice(0, 32), "base64");
+      const pngSize =
+        header.length >= 24 &&
+        header.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex")) &&
+        header.readUInt32BE(16) > 0 &&
+        header.readUInt32BE(20) > 0
+          ? `${header.readUInt32BE(16)}x${header.readUInt32BE(20)}`
+          : undefined;
+      const size =
+        pngSize ??
+        (typeof item.size === "string" && /^[1-9]\d*x[1-9]\d*$/.test(item.size)
+          ? item.size
+          : undefined);
       return {
         type: "image",
         ...(typeof item.id === "string" ? { id: item.id } : {}),
         base64: item.result,
         mimeType: imageMimeType(item.result, item.output_format),
+        generation: {
+          route: "codex-responses",
+          ...(size ? { size } : {}),
+          ...(typeof item.model === "string" ? { model: item.model } : {}),
+          ...(typeof item.quality === "string" ? { quality: item.quality } : {}),
+          ...(typeof item.background === "string" ? { background: item.background } : {}),
+        },
         ...(typeof item.revised_prompt === "string"
           ? { revisedPrompt: item.revised_prompt }
           : typeof item.revisedPrompt === "string"

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

@@ -144,6 +144,18 @@ describe("OpenAIDispatcher direct runtime", () => {
     }
   });
 
+  it.each(["auto", "1152x2560"])("forwards %s size hints and preserves hosted observations", async (size) => {
+    const args = QueryInput.parse({ prompt: "draw in 9:20", imageGeneration: true, imageGenerationOptions: { size } });
+    const generation = { route: "codex-responses" as const, size: "841x1870", quality: "low" };
+    const d = dispatcher((options) => {
+      expect(buildOpenAIResponsesRequest(options).tools).toContainEqual({ type: "image_generation", size });
+      return events({ type: "image", base64: "data", mimeType: "image/png", generation }, { type: "completed", responseId: "r" });
+    });
+    await d.onTokenAdded(1, "one", credentials);
+    const result = await d.generate(request({ imageGeneration: args.imageGeneration, imageGenerationOptions: args.imageGenerationOptions }));
+    expect(result.images).toMatchObject([{ generation }]);
+  });
+
   beforeEach(() => { refreshMock.mockReset(); });
 
   it("refreshes a quota 401 once, shares the recovery, and uses the new credentials", async () => {

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

@@ -0,0 +1 @@
+var e=1e6,t=4;function n(t){return t/e}function r(e,n=!1){return`${n?`Known `:``}$${e.toFixed(t)}`}function i(e){return r(n(e))}function a(e){let t=e.is_image_generation&&e.image_cost_usd===null;return e.cost_usd===null&&e.image_cost_usd===null?t?`Unknown`:`—`:r(n((e.cost_usd??0)+(e.image_cost_usd??0)),t)}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};