@cartanova/qgrid-cli 2.10.3 → 2.10.5

package/bundle/dist/application/setting/setting.types.js

@@ -20,14 +20,6 @@ const SettingSource = z.enum([
 	"env",
 	"default"
 ]);
-/**
-* 프로세스를 다시 띄워주는 도구. 재시작은 스스로 종료하고 이 도구에 맡기므로,
-* 없으면(null) 화면에서 재시작을 시도조차 하지 않는다.
-*
-* API 반환 타입에 쓰이므로 zod 로 둔다 — sonamu syncer 가 클라이언트 코드를 만들 때
-* 타입만 있는 선언은 모듈을 찾지 못한다.
-*/
-const SupervisorKind = z.enum(["pm2"]);
 const SettingItem = z.object({
 	key: z.string(),
 	group: z.string(),
@@ -52,12 +44,10 @@ const RuntimeInfoItem = z.object({
 const SettingsResponse = z.object({
 	settings: SettingItem.array(),
 	runtime: RuntimeInfoItem.array(),
-	/** null 이면 재시작 버튼을 쓸 수 없다 — 종료해도 되살릴 주체가 없다. */
-	supervisor: SupervisorKind.nullable(),
 	/** 이 인스턴스가 keepalive 스케줄러를 소유하도록 명시적으로 허용됐는지. */
 	keepaliveRunnerEnabled: z.boolean()
 });
 //#endregion
-export { RuntimeInfoItem, SettingApplies, SettingItem, SettingKind, SettingListParams, SettingSaveParams, SettingSource, SettingsResponse, SupervisorKind };
+export { RuntimeInfoItem, SettingApplies, SettingItem, SettingKind, SettingListParams, SettingSaveParams, SettingSource, SettingsResponse };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/i18n/en.js

@@ -50,10 +50,8 @@ var en_default = {
 	"error.serviceUnavailable": "Service unavailable",
 	"setting.invalidValue": (reason) => `Invalid setting value: ${reason}`,
 	"setting.unknownKey": (key) => `Unknown setting key ${key}`,
-	"setting.noSupervisor": () => "Restart is unavailable when running locally — nothing would bring the server back up",
 	"qgrid.dispatcherFailed": (provider) => `${provider} dispatcher failed to initialize`,
 	"qgrid.dispatcherStarting": (provider) => `${provider} dispatcher is starting up. Please retry shortly`,
-	"qgrid.restartPending": () => "Server restart is in progress. Please retry shortly",
 	"error.unauthorized": "Unauthorized",
 	notFound: (name, id) => `${name} ID ${id} not found`,
 	"validation.email": "Invalid email format",
@@ -65,4 +63,4 @@ var en_default = {
 //#endregion
 export { en_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/i18n/ko.js

@@ -48,10 +48,8 @@ var ko_default = {
 	"error.serviceUnavailable": "서비스를 사용할 수 없습니다",
 	"setting.invalidValue": (reason) => `설정 값이 올바르지 않습니다: ${reason}`,
 	"setting.unknownKey": (key) => `알 수 없는 설정 키 ${key}`,
-	"setting.noSupervisor": () => "로컬 실행 환경에서는 재시작할 수 없습니다 — 종료하면 다시 켜줄 모니터링 도구가 없습니다",
 	"qgrid.dispatcherFailed": (provider) => `${provider} dispatcher 초기화에 실패했습니다`,
 	"qgrid.dispatcherStarting": (provider) => `${provider} dispatcher 기동 중입니다. 잠시 후 다시 시도해주세요`,
-	"qgrid.restartPending": () => "서버 재시작 중입니다. 잠시 후 다시 시도해주세요",
 	"error.unauthorized": "인증이 필요합니다",
 	"error.unknownSearchField": (field) => `구현되지 않은 검색 필드 ${field}`,
 	notFound: (name, id) => `존재하지 않는 ${name} ID ${id}`,
@@ -64,4 +62,4 @@ var ko_default = {
 //#endregion
 export { ko_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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":"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"}

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-run-lifecycle.test.ts

@@ -1,16 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import {
-  beginServerRestart,
-  resetServerRestartForTests,
-} from "../../utils/server-restart";
 import {
   afterQuery,
   beforeQuery,
-  finishActiveNativeRunsForRestart,
   finishRunAborted,
   finishRunWithError,
-  resetNativeRunRegistryForTests,
 } from "./qgrid-run-lifecycle";
 import { type QueryOutput } from "./qgrid.types";
 
@@ -65,11 +59,6 @@ function queryOutput(overrides: Partial<QueryOutput> = {}): QueryOutput {
 
 let lifecycleNow = Date.now();
 
-afterEach(() => {
-  resetServerRestartForTests();
-  resetNativeRunRegistryForTests();
-});
-
 describe("qgrid run lifecycle start", () => {
   beforeEach(() => {
     lifecycleNow += 60_001;
@@ -221,107 +210,7 @@ describe("qgrid run lifecycle start", () => {
     expect(createRunMock).toHaveBeenCalledTimes(2);
   });
 
-  it("rejects new native runs while a restart is pending", async () => {
-    beginServerRestart();
-
-    await expect(beforeQuery({ prompt: "hi" })).rejects.toMatchObject({ statusCode: 503 });
-    expect(createRunMock).not.toHaveBeenCalled();
-  });
-
-  it("finishes a run prepared during the restart race before rejecting provider execution", async () => {
-    let resolveCreate!: (requestLogId: number) => void;
-    createRunMock.mockReturnValueOnce(
-      new Promise<number>((resolve) => {
-        resolveCreate = resolve;
-      }),
-    );
-
-    const starting = beforeQuery({ prompt: "hi" });
-    await vi.waitFor(() => expect(createRunMock).toHaveBeenCalledOnce());
-    beginServerRestart();
-    resolveCreate(22);
-
-    await expect(starting).rejects.toMatchObject({ statusCode: 503 });
-    expect(finishRunMock).toHaveBeenCalledWith(
-      22,
-      expect.objectContaining({ status: "error", error_message: "server restarted" }),
-    );
-  });
-
-  it("marks only active native runs as restarted and prevents a late success overwrite", async () => {
-    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "hi" });
-
-    await finishActiveNativeRunsForRestart();
-    expect(finishRunMock).toHaveBeenCalledWith(
-      requestLogId,
-      expect.objectContaining({ status: "error", error_message: "server restarted" }),
-    );
-
-    appendStepMock.mockClear();
-    finishRunMock.mockClear();
-    await expect(afterQuery(requestLogId, stepIndex, { prompt: "hi" }, queryOutput())).resolves.toEqual(
-      {},
-    );
-    expect(appendStepMock).not.toHaveBeenCalled();
-    expect(finishRunMock).not.toHaveBeenCalled();
-  });
-
-  it("waits for an in-flight finalizer and writes the restart error last", async () => {
-    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "hi" });
-    let releaseAppend!: () => void;
-    appendStepMock.mockReturnValueOnce(
-      new Promise<void>((resolve) => {
-        releaseAppend = resolve;
-      }),
-    );
-
-    const finishing = afterQuery(requestLogId, stepIndex, { prompt: "hi" }, queryOutput());
-    await vi.waitFor(() => expect(appendStepMock).toHaveBeenCalledOnce());
-    const restarting = finishActiveNativeRunsForRestart();
-
-    await Promise.resolve();
-    expect(finishRunMock).not.toHaveBeenCalledWith(
-      requestLogId,
-      expect.objectContaining({ error_message: "server restarted" }),
-    );
-
-    releaseAppend();
-    await Promise.all([finishing, restarting]);
-
-    const terminalStatuses = finishRunMock.mock.calls
-      .filter(([id]) => id === requestLogId)
-      .map(([, payload]) => payload.status);
-    expect(terminalStatuses.at(-1)).toBe("error");
-    expect(finishRunMock).toHaveBeenLastCalledWith(
-      requestLogId,
-      expect.objectContaining({ status: "error", error_message: "server restarted" }),
-    );
-  });
-
-  it("leaves tool-wait runs alone after their provider turn has completed", async () => {
-    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "use a tool" });
-    await afterQuery(
-      requestLogId,
-      stepIndex,
-      { prompt: "use a tool" },
-      queryOutput({
-        finishReason: "tool-calls",
-        content: [
-          {
-            type: "tool-call",
-            toolCallId: "call-1",
-            toolName: "lookup",
-            input: "{}",
-          },
-        ],
-      }),
-    );
-    finishRunMock.mockClear();
-
-    await finishActiveNativeRunsForRestart();
 
-    expect(finishRunMock).not.toHaveBeenCalled();
-  });
 });
 
 describe("qgrid run lifecycle TTFT", () => {