feat(protocol): 添加图像生成服务的账户邮箱追踪功能

- 在 ImageGenerationError 和 ImageOutput 类中添加 account_email 字段
- 实现 codex 图像响应的错误解析和事件统计功能
- 集成账户邮箱到图像生成流处理和日志记录流程
- 添加内部

README.md

@@ -13,12 +13,7 @@
 > - 严禁将本项目用于生成、传播或协助生成违法、暴力、色情、未成年人相关内容，或用于诈骗、欺诈、骚扰等非法或不当用途。
 > - 使用者应自行承担全部风险，包括但不限于账号被限制、临时封禁或永久封禁以及因违规使用等所导致的法律责任。
 > - 使用本项目即视为你已充分理解并同意本免责声明全部内容；如因滥用、违规或违法使用造成任何后果，均由使用者自行承担。
-
-> [!IMPORTANT]
-> 本项目基于对 ChatGPT 官网相关能力的逆向研究实现，存在账号受限、临时封禁或永久封禁的风险。请勿使用你自己的重要账号、常用账号或高价值账号进行测试。
-
-> [!CAUTION]
-> 旧版本存在已知漏洞，请尽快升级到最新版本。公网部署时请尽量不要放置敏感信息，并自行做好访问控制与隔离。
+> - 本项目基于对 ChatGPT 官网相关能力的逆向研究实现，存在账号受限、临时封禁或永久封禁的风险。请勿使用你自己的重要账号、常用账号或高价值账号进行测试。
 
 ## 快速开始
 
@@ -124,7 +119,6 @@ environment:
 
 ## 效果展示
 
-
 <table width="100%">
   <tr>
     <td width="50%"><img src="https://i.ibb.co/Jj8nfwwP/image.png" alt="image" border="0"></td>
@@ -139,7 +133,6 @@ environment:
   </tr>
 </table>
 
-
 ## API
 
 所有 AI 接口都需要请求头：

services/image_task_service.py

@@ -237,13 +237,17 @@ class ImageTaskService:
             if not isinstance(result, dict):
                 raise RuntimeError("image task returned streaming result unexpectedly")
             data = result.get("data")
+            account_email = _clean(result.get("_account_email") or result.get("account_email"))
             if not isinstance(data, list) or not data:
                 upstream = _clean(result.get("message"))
                 if upstream:
                     message = upstream
                 else:
                     message = "号池中没有可用账号或所有账号均被限流，请检查号池状态（账号额度、是否被封禁、是否到达生图上限）"
-                raise RuntimeError(message)
+                error = RuntimeError(message)
+                if account_email:
+                    setattr(error, "account_email", account_email)
+                raise error
             usage = result.get("usage")
             self._update_task(key, status=TASK_STATUS_SUCCESS, data=data, usage=usage, error="")
             self._log_call(
@@ -254,9 +258,11 @@ class ImageTaskService:
                 "调用完成",
                 request_preview=request_text(payload.get("prompt")),
                 urls=_collect_image_urls(data),
+                account_email=account_email,
             )
         except Exception as exc:
             error_message = str(exc) or "image task failed"
+            account_email = _clean(getattr(exc, "account_email", ""))
             self._update_task(key, status=TASK_STATUS_ERROR, error=error_message, data=[])
             self._log_call(
                 identity,
@@ -267,6 +273,7 @@ class ImageTaskService:
                 request_preview=request_text(payload.get("prompt")),
                 status="failed",
                 error=error_message,
+                account_email=account_email,
             )
 
     def _log_call(
@@ -281,6 +288,7 @@ class ImageTaskService:
         status: str = "success",
         error: str = "",
         urls: list[str] | None = None,
+        account_email: str = "",
     ) -> None:
         endpoint = "/v1/images/edits" if mode == "edit" else "/v1/images/generations"
         summary_prefix = "图生图" if mode == "edit" else "文生图"
@@ -299,6 +307,8 @@ class ImageTaskService:
             detail["request_text"] = request_preview
         if error:
             detail["error"] = error
+        if account_email:
+            detail["account_email"] = account_email
         if urls:
             detail["urls"] = list(dict.fromkeys(urls))
         try:

services/log_service.py

@@ -20,6 +20,7 @@ from utils.helper import anthropic_sse_stream, sse_json_stream
 
 LOG_TYPE_CALL = "call"
 LOG_TYPE_ACCOUNT = "account"
+INTERNAL_RESPONSE_KEYS = {"_account_email"}
 
 
 class LogService:
@@ -128,6 +129,32 @@ def _collect_urls(value: object) -> list[str]:
     return urls
 
 
+def _collect_account_emails(value: object) -> list[str]:
+    emails: list[str] = []
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key in {"_account_email", "account_email"} and isinstance(item, str) and item.strip():
+                emails.append(item.strip())
+            else:
+                emails.extend(_collect_account_emails(item))
+    elif isinstance(value, list):
+        for item in value:
+            emails.extend(_collect_account_emails(item))
+    return emails
+
+
+def _strip_internal_response_fields(value: object) -> object:
+    if isinstance(value, dict):
+        return {
+            key: _strip_internal_response_fields(item)
+            for key, item in value.items()
+            if key not in INTERNAL_RESPONSE_KEYS
+        }
+    if isinstance(value, list):
+        return [_strip_internal_response_fields(item) for item in value]
+    return value
+
+
 def _request_excerpt(text: object, limit: int = 1000) -> str:
     value = str(text or "").strip()
     if not value:
@@ -186,30 +213,32 @@ class LoggedCall:
         try:
             result = await run_in_threadpool(handler, *args)
         except ImageGenerationError as exc:
-            self.log("调用失败", status="failed", error=str(exc))
+            self.log("调用失败", status="failed", error=str(exc), account_email=getattr(exc, "account_email", ""))
             return _image_error_response(exc)
         except HTTPException as exc:
             self.log("调用失败", status="failed", error=str(exc.detail))
             raise
         except Exception as exc:
-            self.log("调用失败", status="failed", error=str(exc))
+            self.log("调用失败", status="failed", error=str(exc), account_email=getattr(exc, "account_email", ""))
             return _protocol_error_response(exc, 502, sse)
 
         if isinstance(result, dict):
             self.log("调用完成", result)
-            return result
+            response = dict(result)
+            response.pop("_account_email", None)
+            return response
 
         sender = anthropic_sse_stream if sse == "anthropic" else sse_json_stream
         try:
             has_first, first = await run_in_threadpool(_next_item, result)
         except ImageGenerationError as exc:
-            self.log("调用失败", status="failed", error=str(exc))
+            self.log("调用失败", status="failed", error=str(exc), account_email=getattr(exc, "account_email", ""))
             return _image_error_response(exc)
         except HTTPException as exc:
             self.log("调用失败", status="failed", error=str(exc.detail))
             raise
         except Exception as exc:
-            self.log("调用失败", status="failed", error=str(exc))
+            self.log("调用失败", status="failed", error=str(exc), account_email=getattr(exc, "account_email", ""))
             return _protocol_error_response(exc, 502, sse)
         if not has_first:
             self.log("流式调用结束")
@@ -218,21 +247,29 @@ class LoggedCall:
 
     def stream(self, items):
         urls: list[str] = []
+        account_emails: list[str] = []
         failed = False
         try:
             for item in items:
                 urls.extend(_collect_urls(item))
-                yield item
+                account_emails.extend(_collect_account_emails(item))
+                yield _strip_internal_response_fields(item)
         except Exception as exc:
             failed = True
-            self.log("流式调用失败", status="failed", error=str(exc), urls=urls)
+            self.log(
+                "流式调用失败",
+                status="failed",
+                error=str(exc),
+                urls=urls,
+                account_email=(account_emails[0] if account_emails else getattr(exc, "account_email", "")),
+            )
             raise
         finally:
             if not failed:
-                self.log("流式调用结束", urls=urls)
+                self.log("流式调用结束", urls=urls, account_email=account_emails[0] if account_emails else "")
 
     def log(self, suffix: str, result: object = None, status: str = "success", error: str = "",
-            urls: list[str] | None = None) -> None:
+            urls: list[str] | None = None, account_email: str = "") -> None:
         detail = {
             "key_id": self.identity.get("id"),
             "key_name": self.identity.get("name"),
@@ -249,6 +286,12 @@ class LoggedCall:
             detail["request_text"] = request_excerpt
         if error:
             detail["error"] = error
+        email = str(account_email or "").strip()
+        if not email:
+            emails = _collect_account_emails(result)
+            email = emails[0] if emails else ""
+        if email:
+            detail["account_email"] = email
         collected_urls = [*(urls or []), *_collect_urls(result)]
         if collected_urls:
             detail["urls"] = list(dict.fromkeys(collected_urls))

services/openai_backend_api.py

@@ -4,6 +4,8 @@ import os
 import random
 import re
 import time
+import urllib.error
+import urllib.request
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from io import BytesIO
@@ -45,11 +47,6 @@ DEFAULT_CLIENT_BUILD_NUMBER = "5955942"
 DEFAULT_POW_SCRIPT = "https://chatgpt.com/backend-api/sentinel/sdk.js"
 CODEX_IMAGE_MODEL = "codex-gpt-image-2"
 CODEX_RESPONSES_MODEL = "gpt-5.5"
-CODEX_RESPONSES_VERSION = "0.122.0"
-CODEX_RESPONSES_USER_AGENT = (
-    "codex-tui/0.122.0 (Manjaro 26.1.0-pre; x86_64) "
-    "vscode/3.0.12 (codex-tui; 0.122.0)"
-)
 CODEX_RESPONSES_INSTRUCTIONS = (
     "Use the image_generation tool to create exactly one image for the user's request. "
     "Return the generated image result."
@@ -156,26 +153,6 @@ class OpenAIBackendAPI:
             headers.update(extra)
         return headers
 
-    @staticmethod
-    def _decode_token_payload(token: str) -> Dict[str, Any]:
-        try:
-            payload = str(token or "").split(".")[1]
-            payload += "=" * ((4 - len(payload) % 4) % 4)
-            data = json.loads(base64.urlsafe_b64decode(payload.encode("ascii")))
-            return data if isinstance(data, dict) else {}
-        except Exception:
-            return {}
-
-    def _chatgpt_account_id(self) -> str:
-        account = account_service.get_account(self.access_token) if self.access_token else {}
-        account = account if isinstance(account, dict) else {}
-        if str(account.get("account_id") or "").strip():
-            return str(account.get("account_id") or "").strip()
-        payload = self._decode_token_payload(self.access_token)
-        auth_claim = payload.get("https://api.openai.com/auth")
-        auth_claim = auth_claim if isinstance(auth_claim, dict) else {}
-        return str(auth_claim.get("chatgpt_account_id") or account.get("user_id") or "").strip()
-
     @staticmethod
     def _extract_quota_and_restore_at(limits_progress: list[Any]) -> tuple[int, str | None, bool]:
         for item in limits_progress:
@@ -456,19 +433,10 @@ class OpenAIBackendAPI:
         return self._headers(path, headers)
 
     def _codex_responses_headers(self) -> Dict[str, str]:
-        headers = {
+        return {
             "Authorization": f"Bearer {self.access_token}",
-            "User-Agent": CODEX_RESPONSES_USER_AGENT,
-            "version": CODEX_RESPONSES_VERSION,
-            "originator": "codex_cli_rs",
-            "session_id": self.session_id,
-            "Accept": "text/event-stream",
             "Content-Type": "application/json",
         }
-        account_id = self._chatgpt_account_id()
-        if account_id:
-            headers["chatgpt-account-id"] = account_id
-        return headers
 
     def _ensure_codex_source_account(self) -> None:
         account = account_service.get_account(self.access_token)
@@ -495,10 +463,64 @@ class OpenAIBackendAPI:
             text = str(body or "")
         return text if len(text) <= limit else text[:limit] + "...[truncated]"
 
+    @staticmethod
+    def _codex_event_image_result_lengths(value: Any) -> list[int]:
+        if isinstance(value, dict):
+            lengths: list[int] = []
+            if value.get("type") == "image_generation_call" and isinstance(value.get("result"), str):
+                lengths.append(len(value["result"]))
+            for item in value.values():
+                lengths.extend(OpenAIBackendAPI._codex_event_image_result_lengths(item))
+            return lengths
+        if isinstance(value, list):
+            lengths: list[int] = []
+            for item in value:
+                lengths.extend(OpenAIBackendAPI._codex_event_image_result_lengths(item))
+            return lengths
+        return []
+
+    @staticmethod
+    def _codex_event_summary(event: Dict[str, Any]) -> Dict[str, Any]:
+        summary: Dict[str, Any] = {
+            "type": str(event.get("type") or ""),
+            "keys": list(event.keys())[:30],
+        }
+        for key in ("id", "status", "sequence_number", "response_id", "item_id", "output_index", "content_index"):
+            value = event.get(key)
+            if isinstance(value, (str, int, float, bool)) or value is None:
+                summary[key] = value
+        for key in ("response", "item", "output"):
+            value = event.get(key)
+            if isinstance(value, dict):
+                summary[f"{key}_type"] = value.get("type")
+                summary[f"{key}_status"] = value.get("status")
+                summary[f"{key}_keys"] = list(value.keys())[:30]
+            elif isinstance(value, list):
+                summary[f"{key}_len"] = len(value)
+                summary[f"{key}_types"] = [
+                    item.get("type") for item in value[:10] if isinstance(item, dict)
+                ]
+        error = event.get("error")
+        if isinstance(error, dict):
+            summary["error"] = {
+                key: error.get(key)
+                for key in ("type", "code", "message")
+                if error.get(key) is not None
+            }
+        delta = event.get("delta")
+        if isinstance(delta, str):
+            summary["delta_len"] = len(delta)
+            summary["delta_preview"] = delta[:200]
+        result_lengths = OpenAIBackendAPI._codex_event_image_result_lengths(event)
+        if result_lengths:
+            summary["image_result_lengths"] = result_lengths[:10]
+        return summary
+
     def _log_codex_response_failure(
             self,
             path: str,
-            response: requests.Response,
+            status_code: int,
+            headers: Any,
             payload: Dict[str, Any],
             body: Any,
     ) -> None:
@@ -506,11 +528,12 @@ class OpenAIBackendAPI:
         safe_request_headers = {
             key: value for key, value in request_headers.items() if key.lower() != "authorization"
         }
+        response_headers = dict(headers.items()) if hasattr(headers, "items") else dict(headers or {})
         tool = ((payload.get("tools") or [{}])[0]) if isinstance(payload.get("tools"), list) else {}
         logger.warning({
             "event": "codex_responses_http_error",
             "path": path,
-            "status_code": response.status_code,
+            "status_code": status_code,
             "request": {
                 "model": payload.get("model"),
                 "tool_model": tool.get("model"),
@@ -525,11 +548,69 @@ class OpenAIBackendAPI:
                 "headers": safe_request_headers,
             },
             "response": {
-                "headers": dict(response.headers or {}),
+                "headers": response_headers,
                 "body_preview": self._codex_body_preview(body),
             },
         })
 
+    @staticmethod
+    def _iter_codex_response_events(raw: Any) -> Iterator[Dict[str, Any]]:
+        content_type = str(raw.headers.get("content-type") or "").lower()
+        text = raw.read().decode("utf-8", "replace")
+        status_code = getattr(raw, "status", None)
+        parse_errors: list[str] = []
+        events: list[Dict[str, Any]] = []
+        if "application/json" in content_type:
+            try:
+                data = json.loads(text)
+                if isinstance(data, dict):
+                    events.append(data)
+            except Exception as exc:
+                parse_errors.append(str(exc))
+        else:
+            lines: list[str] = []
+            for line in text.splitlines() + [""]:
+                if not line:
+                    if lines:
+                        payload_text = "\n".join(lines).strip()
+                        if payload_text and payload_text != "[DONE]":
+                            try:
+                                data = json.loads(payload_text)
+                            except Exception as exc:
+                                parse_errors.append(str(exc))
+                                data = None
+                            if isinstance(data, dict):
+                                events.append(data)
+                        lines = []
+                elif line.startswith("data:"):
+                    lines.append(line[5:].lstrip())
+
+        event_types: Dict[str, int] = {}
+        image_result_lengths: list[int] = []
+        for event in events:
+            event_type = str(event.get("type") or "<missing>")
+            event_types[event_type] = event_types.get(event_type, 0) + 1
+            image_result_lengths.extend(OpenAIBackendAPI._codex_event_image_result_lengths(event))
+        logger.info({
+            "event": "codex_responses_response_debug",
+            "status_code": status_code,
+            "content_type": content_type,
+            "response_text_len": len(text),
+            "event_count": len(events),
+            "event_types": event_types,
+            "image_result_lengths": image_result_lengths[:10],
+            "parse_error_count": len(parse_errors),
+            "parse_errors": parse_errors[:5],
+            "event_summaries": [OpenAIBackendAPI._codex_event_summary(event) for event in events[:30]],
+            "event_previews": [
+                OpenAIBackendAPI._codex_body_preview(event, 1500)
+                for event in events[:10]
+            ] if not image_result_lengths else [],
+            "body_preview": text[:1000] if not events else "",
+        })
+        for event in events:
+            yield event
+
     def iter_codex_image_response_events(
             self,
             prompt: str,
@@ -557,41 +638,67 @@ class OpenAIBackendAPI:
             "tool_choice": {"type": "image_generation"},
             "stream": True,
         }
-        response = self.session.post(
+        request = urllib.request.Request(
             self.base_url + path,
-            headers=self._codex_responses_headers(),
-            json=payload,
-            timeout=1200,
-            stream=True,
+            json.dumps(payload).encode(),
+            self._codex_responses_headers(),
+            method="POST",
         )
+        account = account_service.get_account(self.access_token) or {}
+        token_payload = account_service._decode_jwt_payload(self.access_token)
+        auth_claim = token_payload.get("https://api.openai.com/auth")
+        auth_claim = auth_claim if isinstance(auth_claim, dict) else {}
+        tool = payload["tools"][0]
+        logger.info({
+            "event": "codex_responses_request_debug",
+            "url": self.base_url + path,
+            "transport": "urllib.request",
+            "timeout_secs": 1200,
+            "account_email": str(account.get("email") or "").strip(),
+            "source_type": str(account.get("source_type") or "").strip(),
+            "account_type": str(account.get("type") or "").strip(),
+            "token_claims": {
+                "jti": token_payload.get("jti"),
+                "iat": token_payload.get("iat"),
+                "exp": token_payload.get("exp"),
+                "client_id": token_payload.get("client_id"),
+                "chatgpt_account_id": auth_claim.get("chatgpt_account_id"),
+                "chatgpt_plan_type": auth_claim.get("chatgpt_plan_type"),
+                "localhost": auth_claim.get("localhost"),
+            },
+            "request": {
+                "model": payload.get("model"),
+                "tool_model": tool.get("model"),
+                "tool_action": tool.get("action"),
+                "size": tool.get("size"),
+                "quality": tool.get("quality"),
+                "output_format": tool.get("output_format"),
+                "stream": payload.get("stream"),
+                "image_input_count": max(len((payload.get("input") or [{}])[0].get("content") or []) - 1, 0),
+                "prompt_preview": self._codex_body_preview(
+                    (((payload.get("input") or [{}])[0].get("content") or [{}])[0].get("text") or ""),
+                    500,
+                ),
+            },
+            "headers": {
+                key: value for key, value in self._codex_responses_headers().items()
+                if key.lower() != "authorization"
+            },
+        })
         try:
-            if not 200 <= response.status_code < 300:
-                body: Any = response.text
-                try:
-                    body = response.json()
-                except Exception:
-                    pass
-                self._log_codex_response_failure(path, response, payload, body)
-                retry_after_header = response.headers.get("Retry-After") if hasattr(response, "headers") else None
-                retry_after = int(retry_after_header) if str(retry_after_header or "").isdigit() else None
-                raise UpstreamHTTPError(path, response.status_code, body, retry_after=retry_after)
-            content_type = str(response.headers.get("content-type") or "").lower()
-            if "application/json" in content_type:
-                data = response.json()
-                if isinstance(data, dict):
-                    yield data
-                return
-            for payload_text in iter_sse_payloads(response):
-                if payload_text == "[DONE]":
-                    break
-                try:
-                    data = json.loads(payload_text)
-                except Exception:
-                    continue
-                if isinstance(data, dict):
-                    yield data
-        finally:
-            response.close()
+            with urllib.request.urlopen(request, timeout=1200) as raw:
+                yield from self._iter_codex_response_events(raw)
+        except urllib.error.HTTPError as error:
+            body_text = error.read().decode("utf-8", "replace")
+            body: Any = body_text
+            try:
+                body = json.loads(body_text)
+            except Exception:
+                pass
+            self._log_codex_response_failure(path, error.code, error.headers, payload, body)
+            retry_after_header = error.headers.get("Retry-After") if error.headers else None
+            retry_after = int(retry_after_header) if str(retry_after_header or "").isdigit() else None
+            raise UpstreamHTTPError(path, error.code, body, retry_after=retry_after) from error
 
     def _prepare_image_conversation(self, prompt: str, requirements: ChatRequirements, model: str) -> str:
         """为图片生成准备 conduit token。"""

services/protocol/conversation.py

@@ -32,12 +32,14 @@ class ImageGenerationError(Exception):
         error_type: str = "server_error",
         code: str | None = "upstream_error",
         param: str | None = None,
+        account_email: str = "",
     ) -> None:
         super().__init__(message)
         self.status_code = status_code
         self.error_type = error_type
         self.code = code
         self.param = param
+        self.account_email = account_email
 
     def to_openai_error(self) -> dict[str, Any]:
         return {
@@ -254,6 +256,7 @@ class ImageOutput:
     text: str = ""
     upstream_event_type: str = ""
     data: list[dict[str, Any]] = field(default_factory=list)
+    account_email: str = ""
 
     def to_chunk(self) -> dict[str, Any]:
         chunk: dict[str, Any] = {
@@ -266,6 +269,8 @@ class ImageOutput:
             "upstream_event_type": self.upstream_event_type,
             "data": [],
         }
+        if self.account_email:
+            chunk["_account_email"] = self.account_email
         if self.kind == "message":
             chunk.update({
                 "object": "image.generation.message",
@@ -646,21 +651,56 @@ def _codex_response_images(value: Any) -> list[str]:
     return []
 
 
+def _codex_response_error(value: Any) -> tuple[str, str]:
+    if not isinstance(value, dict):
+        return "", ""
+    error = value.get("error")
+    if not isinstance(error, dict):
+        response = value.get("response")
+        error = response.get("error") if isinstance(response, dict) and response.get("status") == "failed" else None
+    if not isinstance(error, dict):
+        return "", ""
+    message = str(error.get("message") or "").strip()
+    code = str(error.get("code") or error.get("type") or "server_error").strip()
+    return message or "Codex responses failed upstream.", code
+
+
 def stream_codex_image_outputs(
         backend: OpenAIBackendAPI,
         request: ConversationRequest,
         index: int = 1,
         total: int = 1,
 ) -> Iterator[ImageOutput]:
-    prompt = prompt_with_global_system(build_image_prompt(request.prompt, request.size, request.quality))
     text_parts: list[str] = []
+    event_count = 0
+    event_types: dict[str, int] = {}
     for event in backend.iter_codex_image_response_events(
-            prompt=prompt,
+            prompt=request.prompt,
             images=request.images or [],
             size=request.size,
             quality=request.quality,
     ):
         event_type = str(event.get("type") or "")
+        event_count += 1
+        event_types[event_type or "<missing>"] = event_types.get(event_type or "<missing>", 0) + 1
+        upstream_error, upstream_code = _codex_response_error(event)
+        if upstream_error:
+            logger.warning({
+                "event": "codex_response_upstream_error",
+                "model": request.model,
+                "size": request.size,
+                "quality": request.quality,
+                "event_count": event_count,
+                "event_types": event_types,
+                "upstream_code": upstream_code,
+                "upstream_error": upstream_error,
+            })
+            raise ImageGenerationError(
+                upstream_error,
+                status_code=502,
+                error_type="server_error",
+                code=upstream_code or "server_error",
+            )
         if event_type == "response.output_text.delta":
             delta = str(event.get("delta") or "")
             if delta:
@@ -676,6 +716,16 @@ def stream_codex_image_outputs(
             continue
         images = _codex_response_images(event)
         if images:
+            logger.info({
+                "event": "codex_response_image_result_found",
+                "model": request.model,
+                "size": request.size,
+                "quality": request.quality,
+                "event_count": event_count,
+                "event_types": event_types,
+                "image_count": len(images),
+                "image_result_lengths": [len(item) for item in images[:10]],
+            })
             data = format_image_result(
                 [{"b64_json": item, "revised_prompt": request.prompt} for item in images],
                 request.prompt,
@@ -697,6 +747,18 @@ def stream_codex_image_outputs(
     message = "".join(text_parts).strip()
     if message:
         yield ImageOutput(kind="message", model=request.model, index=index, total=total, text=message)
+        return
+    logger.warning({
+        "event": "codex_response_no_image_result",
+        "model": request.model,
+        "size": request.size,
+        "quality": request.quality,
+        "image_input_count": len(request.images or []),
+        "event_count": event_count,
+        "event_types": event_types,
+        "output_text_len": len("".join(text_parts)),
+    })
+    raise ImageGenerationError("No image result found in response")
 
 
 def stream_image_outputs_with_pool(request: ConversationRequest) -> Iterator[ImageOutput]:
@@ -723,16 +785,21 @@ def stream_image_outputs_with_pool(request: ConversationRequest) -> Iterator[Ima
             emitted_for_token = False
             returned_message = False
             returned_result = False
+            account = account_service.get_account(token) or {}
+            account_email = str(account.get("email") or "").strip()
             try:
                 backend = OpenAIBackendAPI(access_token=token)
                 stream_fn = stream_codex_image_outputs if is_codex_image_model(request.model) else stream_image_outputs
                 for output in stream_fn(backend, request, index, request.n):
+                    if account_email and not output.account_email:
+                        output.account_email = account_email
                     if output.kind == "message" and request.message_as_error:
                         raise ImageGenerationError(
                             output.text or "Image generation was rejected by upstream policy.",
                             status_code=400,
                             error_type="invalid_request_error",
                             code="content_policy_violation",
+                            account_email=account_email,
                         )
                     emitted = True
                     emitted_for_token = True
@@ -744,15 +811,30 @@ def stream_image_outputs_with_pool(request: ConversationRequest) -> Iterator[Ima
                     return
                 account_service.mark_image_result(token, True)
                 break
-            except ImagePollTimeoutError:
+            except ImagePollTimeoutError as exc:
+                if account_email and not getattr(exc, "account_email", ""):
+                    exc.account_email = account_email
                 raise
-            except ImageGenerationError:
+            except ImageGenerationError as exc:
                 account_service.mark_image_result(token, False)
+                if account_email and not getattr(exc, "account_email", ""):
+                    exc.account_email = account_email
+                logger.warning({
+                    "event": "image_stream_generation_error",
+                    "request_token": token,
+                    "account_email": account_email,
+                    "error": str(exc),
+                })
                 raise
             except Exception as exc:
                 account_service.mark_image_result(token, False)
                 last_error = str(exc)
-                logger.warning({"event": "image_stream_fail", "request_token": token, "error": last_error})
+                logger.warning({
+                    "event": "image_stream_fail",
+                    "request_token": token,
+                    "account_email": account_email,
+                    "error": last_error,
+                })
                 if not emitted_for_token and is_token_invalid_error(last_error):
                     refreshed_token = account_service.refresh_access_token(token, force=True, event="image_stream")
                     if refreshed_token and refreshed_token != token:
@@ -760,7 +842,7 @@ def stream_image_outputs_with_pool(request: ConversationRequest) -> Iterator[Ima
                         continue
                     account_service.remove_invalid_token(token, "image_stream")
                     continue
-                raise ImageGenerationError(image_stream_error_message(last_error)) from exc
+                raise ImageGenerationError(image_stream_error_message(last_error), account_email=account_email) from exc
 
     if not emitted:
         if not last_error:
@@ -778,8 +860,11 @@ def collect_image_outputs(outputs: Iterable[ImageOutput]) -> dict[str, Any]:
     data: list[dict[str, Any]] = []
     message = ""
     progress_parts: list[str] = []
+    account_email = ""
     for output in outputs:
         created = created or output.created
+        if output.account_email and not account_email:
+            account_email = output.account_email
         if output.kind == "progress" and output.text:
             progress_parts.append(output.text)
         elif output.kind == "message":
@@ -792,4 +877,6 @@ def collect_image_outputs(outputs: Iterable[ImageOutput]) -> dict[str, Any]:
         text = message or "".join(progress_parts).strip()
         if text:
             result["message"] = text
+    if account_email:
+        result["_account_email"] = account_email
     return result

test/test_codex_4k.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# Test script: directly call https://chatgpt.com/backend-api/codex/responses to generate one 2K image.
+# Only edit ACCESS_TOKEN, then run: python codex_responses_image_test.py
+# Fixed request parameters:
+#   prompt: A highly detailed square 2K image of a quiet futuristic library at sunrise
+#   responses model: gpt-5.5
+#   image model: gpt-image-2
+#   size: 2048x2048
+#   quality: auto
+#   output_format: png
+#   output file: codex_4k.png
+
+import base64
+import json
+import time
+import urllib.request
+
+ACCESS_TOKEN = ""
+
+
+def parse_events(raw):
+    ctype, text = raw.headers.get("content-type", ""), raw.read().decode("utf-8", "replace")
+    if "application/json" in ctype:
+        return [json.loads(text)]
+    events, lines = [], []
+    for line in text.splitlines() + [""]:
+        if not line:
+            if lines:
+                data = "\n".join(lines).strip()
+                if data and data != "[DONE]":
+                    events.append(json.loads(data))
+                lines = []
+        elif line.startswith("data:"):
+            lines.append(line[5:].lstrip())
+    return events
+
+
+def find_images(value):
+    if isinstance(value, dict):
+        if value.get("type") == "image_generation_call" and isinstance(value.get("result"), str):
+            result = value["result"].strip()
+            return [result.split(",", 1)[1] if result.startswith("data:image/") else result]
+        return [image for item in value.values() for image in find_images(item)]
+    if isinstance(value, list):
+        return [image for item in value for image in find_images(item)]
+    return []
+
+
+def main():
+    start_time = time.time()
+    body = {
+        "model": "gpt-5.5",
+        "instructions": "Use the image_generation tool to create exactly one image for the user's request. Return the generated image result.",
+        "store": False,
+        "input": [{"role": "user", "content": [{"type": "input_text", "text": "A highly detailed square 2K image of a quiet futuristic library at sunrise"}]}],
+        "tools": [{
+            "type": "image_generation",
+            "model": "gpt-image-2",
+            "action": "generate",
+            "size": "3840x2160",
+            "quality": "auto",
+            "output_format": "png"
+        }],
+        "tool_choice": {"type": "image_generation"},
+        "stream": True
+    }
+    headers = {"Authorization": f"Bearer {ACCESS_TOKEN}", "Content-Type": "application/json"}
+
+    req = urllib.request.Request("https://chatgpt.com/backend-api/codex/responses", json.dumps(body).encode(), headers, method="POST")
+    try:
+        images = find_images(parse_events(urllib.request.urlopen(req, timeout=1200)))
+    except urllib.error.HTTPError as error:
+        raise SystemExit(f"HTTP {error.code}: {error.read().decode('utf-8', 'replace')[:1000]}")
+
+    if not images:
+        raise SystemExit("No image result found in response")
+
+    with open("codex_4k.png", "wb") as file:
+        file.write(base64.b64decode(images[0]))
+    print("saved codex_4k.png")
+    end_time = time.time()
+    print(f"total time: {end_time - start_time:.2f} seconds")
+
+
+if __name__ == "__main__":
+    main()

web/src/hooks/use-version-check.ts

@@ -1,6 +1,6 @@
 "use client";
 
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
 import { toast } from "sonner";
 
 import webConfig from "@/constants/common-env";
@@ -40,11 +40,6 @@ export function useVersionCheck() {
   const [open, setOpen] = useState(false);
   const hasNewVersion = isNewerVersion(latestVersion, currentVersion);
 
-  const checkLatestVersion = useCallback(async () => {
-    const response = await fetch(latestVersionUrl);
-    if (response.ok) setLatestVersion((await response.text()).trim() || currentVersion);
-  }, [currentVersion]);
-
   const checkLatestRelease = useCallback(
     async (showMessage = false) => {
       setChecking(true);
@@ -72,10 +67,6 @@ export function useVersionCheck() {
     [currentVersion, localReleases],
   );
 
-  useEffect(() => {
-    void checkLatestVersion();
-  }, [checkLatestVersion]);
-
   const openReleaseModal = () => {
     setOpen(true);
     void checkLatestRelease();