增加图片管理、日志管理，优化敏感词等场景

Co-Authored-By: Codex <noreply@openai.com>

VERSION

@@ -1 +1 @@
-0.1.0
+1.0.0

api/ai.py

@@ -1,21 +1,19 @@
 from __future__ import annotations
 
-from datetime import datetime
-import time
-
 from fastapi import APIRouter, File, Form, Header, HTTPException, Request, UploadFile
 from fastapi.concurrency import run_in_threadpool
-from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, ConfigDict, Field
 
-from api.support import raise_image_quota_error, require_identity, resolve_image_base_url
-from services.account_service import account_service
-from services.chatgpt_service import ChatGPTService, ImageGenerationError
-from services.log_service import (
-    LOG_TYPE_CALL,
-    log_service,
+from api.support import require_identity, resolve_image_base_url
+from services.log_service import LoggedCall
+from services.protocol import (
+    anthropic_v1_messages,
+    openai_v1_chat_complete,
+    openai_v1_image_edit,
+    openai_v1_image_generations,
+    openai_v1_models,
+    openai_v1_response,
 )
-from utils.helper import anthropic_sse_stream, is_image_chat_request, sse_json_stream
 
 
 class ImageGenerationRequest(BaseModel):
@@ -55,66 +53,14 @@ class AnthropicMessageRequest(BaseModel):
     stream: bool | None = None
 
 
-def _identity_detail(identity: dict[str, object]) -> dict[str, object]:
-    return {"key_id": identity.get("id"), "key_name": identity.get("name"), "role": identity.get("role")}
-
-
-def _collect_urls(value: object) -> list[str]:
-    urls: list[str] = []
-    if isinstance(value, dict):
-        for key, item in value.items():
-            if key == "url" and isinstance(item, str):
-                urls.append(item)
-            elif key == "urls" and isinstance(item, list):
-                urls.extend(str(url) for url in item if isinstance(url, str))
-            else:
-                urls.extend(_collect_urls(item))
-    elif isinstance(value, list):
-        for item in value:
-            urls.extend(_collect_urls(item))
-    return urls
-
-
-def _log_call(summary: str, identity: dict[str, object], endpoint: str, model: str, started: float, result: object = None, status: str = "success") -> None:
-    detail = {
-        **_identity_detail(identity),
-        "endpoint": endpoint,
-        "model": model,
-        "started_at": datetime.fromtimestamp(started).strftime("%Y-%m-%d %H:%M:%S"),
-        "ended_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "duration_ms": int((time.time() - started) * 1000),
-        "status": status,
-    }
-    urls = _collect_urls(result)
-    if urls:
-        detail["urls"] = urls
-    log_service.add(LOG_TYPE_CALL, summary, detail)
-
-
-def _stream_with_log(items, summary: str, identity: dict[str, object], endpoint: str, model: str, started: float):
-    urls: list[str] = []
-    failed = False
-    try:
-        for item in items:
-            urls.extend(_collect_urls(item))
-            yield item
-    except Exception:
-        failed = True
-        _log_call(summary.replace("结束", "失败"), identity, endpoint, model, started, {"urls": list(dict.fromkeys(urls))}, "failed")
-        raise
-    finally:
-        if not failed:
-            _log_call(summary, identity, endpoint, model, started, {"urls": list(dict.fromkeys(urls))})
-
-
-def create_router(chatgpt_service: ChatGPTService) -> APIRouter:
+def create_router() -> APIRouter:
     router = APIRouter()
 
     @router.get("/v1/models")
     async def list_models(authorization: str | None = Header(default=None)):
         require_identity(authorization)
         try:
-            return await run_in_threadpool(chatgpt_service.list_models)
+            return await run_in_threadpool(openai_v1_models.list_models)
         except Exception as exc:
             raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
 
@@ -125,37 +71,10 @@ def create_router(chatgpt_service: ChatGPTService) -> APIRouter:
             authorization: str | None = Header(default=None),
     ):
         identity = require_identity(authorization)
-        started = time.time()
-        base_url = resolve_image_base_url(request)
-        if body.stream:
-            try:
-                await run_in_threadpool(account_service.get_available_access_token)
-            except RuntimeError as exc:
-                raise_image_quota_error(exc)
-            return StreamingResponse(
-                sse_json_stream(
-                    _stream_with_log(
-                        chatgpt_service.stream_image_generation(
-                            body.prompt, body.model, body.n, body.size, body.response_format, base_url
-                        ),
-                        "文生图流式调用结束",
-                        identity,
-                        "/v1/images/generations",
-                        body.model,
-                        started,
-                    )
-                ),
-                media_type="text/event-stream",
-            )
-        try:
-            result = await run_in_threadpool(
-                chatgpt_service.generate_with_pool, body.prompt, body.model, body.n, body.size, body.response_format, base_url
-            )
-            _log_call("文生图调用完成", identity, "/v1/images/generations", body.model, started, result)
-            return result
-        except ImageGenerationError as exc:
-            _log_call("文生图调用失败", identity, "/v1/images/generations", body.model, started, {"error": str(exc)}, "failed")
-            raise_image_quota_error(exc)
+        payload = body.model_dump(mode="python")
+        payload["base_url"] = resolve_image_base_url(request)
+        call = LoggedCall(identity, "/v1/images/generations", body.model, "文生图")
+        return await call.run(openai_v1_image_generations.handle, payload)
 
     @router.post("/v1/images/edits")
     async def edit_images(
@@ -171,85 +90,45 @@ def create_router(chatgpt_service: ChatGPTService) -> APIRouter:
             stream: bool | None = Form(default=None),
     ):
         identity = require_identity(authorization)
-        started = time.time()
         if n < 1 or n > 4:
             raise HTTPException(status_code=400, detail={"error": "n must be between 1 and 4"})
         uploads = [*(image or []), *(image_list or [])]
         if not uploads:
             raise HTTPException(status_code=400, detail={"error": "image file is required"})
-        base_url = resolve_image_base_url(request)
         images: list[tuple[bytes, str, str]] = []
         for upload in uploads:
             image_data = await upload.read()
             if not image_data:
                 raise HTTPException(status_code=400, detail={"error": "image file is empty"})
             images.append((image_data, upload.filename or "image.png", upload.content_type or "image/png"))
-        if stream:
-            if not account_service.has_available_account():
-                raise_image_quota_error(RuntimeError("no available image quota"))
-            return StreamingResponse(
-                sse_json_stream(_stream_with_log(
-                    chatgpt_service.stream_image_edit(prompt, images, model, n, size, response_format, base_url),
-                    "图生图流式调用结束",
-                    identity,
-                    "/v1/images/edits",
-                    model,
-                    started,
-                )),
-                media_type="text/event-stream",
-            )
-        try:
-            result = await run_in_threadpool(
-                chatgpt_service.edit_with_pool, prompt, images, model, n, size, response_format, base_url
-            )
-            _log_call("图生图调用完成", identity, "/v1/images/edits", model, started, result)
-            return result
-        except ImageGenerationError as exc:
-            _log_call("图生图调用失败", identity, "/v1/images/edits", model, started, {"error": str(exc)}, "failed")
-            raise_image_quota_error(exc)
+        payload = {
+            "prompt": prompt,
+            "images": images,
+            "model": model,
+            "n": n,
+            "size": size,
+            "response_format": response_format,
+            "stream": stream,
+            "base_url": resolve_image_base_url(request),
+        }
+        call = LoggedCall(identity, "/v1/images/edits", model, "图生图")
+        return await call.run(openai_v1_image_edit.handle, payload)
 
     @router.post("/v1/chat/completions")
     async def create_chat_completion(body: ChatCompletionRequest, authorization: str | None = Header(default=None)):
         identity = require_identity(authorization)
-        started = time.time()
         payload = body.model_dump(mode="python")
         model = str(payload.get("model") or "auto")
-        if bool(payload.get("stream")):
-            if is_image_chat_request(payload):
-                try:
-                    await run_in_threadpool(account_service.get_available_access_token)
-                except RuntimeError as exc:
-                    raise_image_quota_error(exc)
-            return StreamingResponse(
-                sse_json_stream(_stream_with_log(chatgpt_service.stream_chat_completion(payload), "文本生成流式调用结束", identity, "/v1/chat/completions", model, started)),
-                media_type="text/event-stream",
-            )
-        try:
-            result = await run_in_threadpool(chatgpt_service.create_chat_completion, payload)
-            _log_call("文本生成调用完成", identity, "/v1/chat/completions", model, started, result)
-            return result
-        except Exception as exc:
-            _log_call("文本生成调用失败", identity, "/v1/chat/completions", model, started, {"error": str(exc)}, "failed")
-            raise
+        call = LoggedCall(identity, "/v1/chat/completions", model, "文本生成")
+        return await call.run(openai_v1_chat_complete.handle, payload)
 
     @router.post("/v1/responses")
     async def create_response(body: ResponseCreateRequest, authorization: str | None = Header(default=None)):
         identity = require_identity(authorization)
-        started = time.time()
         payload = body.model_dump(mode="python")
         model = str(payload.get("model") or "auto")
-        if bool(payload.get("stream")):
-            return StreamingResponse(
-                sse_json_stream(_stream_with_log(chatgpt_service.stream_response(payload), "Responses 流式调用结束", identity, "/v1/responses", model, started)),
-                media_type="text/event-stream",
-            )
-        try:
-            result = await run_in_threadpool(chatgpt_service.create_response, payload)
-            _log_call("Responses 调用完成", identity, "/v1/responses", model, started, result)
-            return result
-        except Exception as exc:
-            _log_call("Responses 调用失败", identity, "/v1/responses", model, started, {"error": str(exc)}, "failed")
-            raise
+        call = LoggedCall(identity, "/v1/responses", model, "Responses")
+        return await call.run(openai_v1_response.handle, payload)
 
     @router.post("/v1/messages")
     async def create_message(
@@ -259,20 +138,9 @@ def create_router(chatgpt_service: ChatGPTService) -> APIRouter:
             anthropic_version: str | None = Header(default=None, alias="anthropic-version"),
     ):
         identity = require_identity(authorization or (f"Bearer {x_api_key}" if x_api_key else None))
-        started = time.time()
         payload = body.model_dump(mode="python")
         model = str(payload.get("model") or "auto")
-        if bool(payload.get("stream")):
-            return StreamingResponse(
-                anthropic_sse_stream(_stream_with_log(chatgpt_service.stream_message(payload), "Messages 流式调用结束", identity, "/v1/messages", model, started)),
-                media_type="text/event-stream",
-            )
-        try:
-            result = await run_in_threadpool(chatgpt_service.create_message, payload)
-            _log_call("Messages 调用完成", identity, "/v1/messages", model, started, result)
-            return result
-        except Exception as exc:
-            _log_call("Messages 调用失败", identity, "/v1/messages", model, started, {"error": str(exc)}, "failed")
-            raise
+        call = LoggedCall(identity, "/v1/messages", model, "Messages")
+        return await call.run(anthropic_v1_messages.handle, payload, sse="anthropic")
 
     return router

api/app.py

@@ -10,13 +10,10 @@ from fastapi.staticfiles import StaticFiles
 
 from api import accounts, ai, system
 from api.support import resolve_web_asset, start_limited_account_watcher
-from services.account_service import account_service
-from services.chatgpt_service import ChatGPTService
 from services.config import config
 
 
 def create_app() -> FastAPI:
-    chatgpt_service = ChatGPTService(account_service)
     app_version = config.app_version
 
     @asynccontextmanager
@@ -38,7 +35,7 @@ def create_app() -> FastAPI:
         allow_methods=["*"],
         allow_headers=["*"],
     )
-    app.include_router(ai.create_router(chatgpt_service))
+    app.include_router(ai.create_router())
     app.include_router(accounts.create_router())
     app.include_router(system.create_router(app_version))
     if config.images_dir.exists():

config.json

@@ -3,6 +3,12 @@
   "refresh_account_interval_minute": 60,
   "image_retention_days": 15,
   "auto_remove_invalid_accounts": false,
+  "log_levels": [
+    "debug",
+    "error",
+    "info",
+    "warning"
+  ],
   "proxy": "",
   "base_url": ""
 }

docs/upstream-sse-conversation.md

@@ -0,0 +1,271 @@
+# 上游 Conversation SSE 协议说明
+
+Conversation SSE 是上游对话链路的流式返回协议。每条 SSE `data:` 通常是一段 JSON payload，也可能是协议标记或结束标记。客户端需要按顺序消费这些 payload，维护当前会话状态、文本内容、工具调用状态和图片结果指针。
+
+## 基本形态
+
+常见 payload 示例：
+
+```text
+"v1"
+{"type":"resume_conversation_token",...}
+{"p":"","o":"add","v":{...}}
+{"v":{...}}
+{"p":"/message/content/parts/0","o":"append","v":"..."}
+{"type":"server_ste_metadata","metadata":{...}}
+[DONE]
+```
+
+处理建议：
+
+| payload | 含义 | 处理方式 |
+|:--|:--|:--|
+| `"v1"` | 协议版本标记 | 可记录，通常不影响业务 |
+| `[DONE]` | 当前 SSE 流结束 | 停止继续读取 |
+| JSON object | 事件、消息或 patch | 按字段更新会话状态 |
+| JSON string | 短文本 patch 或协议标记 | 结合上下文处理 |
+| 非 JSON 内容 | 原始内容 | 保留为 raw 事件，避免中断流 |
+
+## 常用字段
+
+| 字段 | 说明 |
+|:--|:--|
+| `type` | 上游事件类型，如 `resume_conversation_token`、`input_message`、`message_marker`、`title_generation`、`server_ste_metadata` |
+| `conversation_id` | 当前会话 ID，可从多个事件中获得 |
+| `p` | patch 路径，例如 `/message/content/parts/0` |
+| `o` | patch 操作，例如 `add`、`append`、`replace`、`patch` |
+| `v` | patch 值，可能是字符串、数组，也可能包含完整 message |
+| `c` | 消息序号或游标，常见于 add 类事件 |
+| `message.id` | 消息 ID |
+| `message.author.role` | 消息角色，常见 `system`、`user`、`assistant`、`tool` |
+| `message.content.content_type` | 内容类型，如 `text`、`multimodal_text`、`model_editable_context` |
+| `message.content.parts` | 内容片段，可能包含文本、图片指针或多模态对象 |
+| `message.status` | 消息状态，如 `in_progress`、`finished_successfully` |
+| `message.end_turn` | 是否结束当前轮次 |
+| `metadata.tool_invoked` | 本轮是否调用工具 |
+| `metadata.turn_use_case` | 本轮用途，如 `text`、`multimodal` |
+| `metadata.async_task_type` | 异步工具任务类型，图片生成通常为 `image_gen` |
+
+## 会话启动事件
+
+上游通常会先返回恢复令牌或会话令牌：
+
+```json
+{
+  "type": "resume_conversation_token",
+  "kind": "topic",
+  "token": "...",
+  "conversation_id": "..."
+}
+```
+
+这个事件主要用于标识会话和恢复上下文。业务层通常只需要保存 `conversation_id`，`token` 不应该暴露给下游用户。
+
+## 消息 add 场景
+
+完整消息可能通过 `add` 或带 `v.message` 的事件出现：
+
+```json
+{
+  "p": "",
+  "o": "add",
+  "v": {
+    "message": {
+      "author": {"role": "assistant"},
+      "content": {"content_type": "text", "parts": [""]},
+      "status": "in_progress"
+    },
+    "conversation_id": "..."
+  },
+  "c": 3
+}
+```
+
+此类事件常用于创建一条新消息。若消息角色为 `assistant`，后续文本通常会通过 patch 继续追加。
+
+## 文本增量场景
+
+文本输出通常由多条 patch 组成：
+
+```json
+{"p":"/message/content/parts/0","o":"append","v":"Hello"}
+{"v":" world"}
+{"p":"","o":"patch","v":[
+  {"p":"/message/content/parts/0","o":"append","v":"!"},
+  {"p":"/message/status","o":"replace","v":"finished_successfully"},
+  {"p":"/message/end_turn","o":"replace","v":true}
+]}
+```
+
+处理要点：
+
+| 形态 | 含义 |
+|:--|:--|
+| `p == "/message/content/parts/0"` 且 `o == "append"` | 向当前文本追加内容 |
+| `o == "replace"` | 用新值替换目标字段 |
+| `o == "patch"` 且 `v` 是数组 | 批量 patch，需要按数组顺序处理 |
+| 只有 `v` 且 `v` 是字符串 | 可能是省略路径的文本增量，应结合当前文本流处理 |
+
+## 输入消息场景
+
+用户输入会以 `input_message` 或普通 `user` message 出现。图片编辑请求会包含用户上传的参考图：
+
+```json
+{
+  "type": "input_message",
+  "input_message": {
+    "author": {"role": "user"},
+    "content": {
+      "content_type": "multimodal_text",
+      "parts": [
+        {"asset_pointer": "sediment://file_input"},
+        "编辑提示词"
+      ]
+    }
+  },
+  "conversation_id": "..."
+}
+```
+
+这类 `sediment://...` 表示输入附件，不是生成结果。即使它可以被下载，也不能当作输出图片返回。
+
+## 图片工具成功场景
+
+图片生成或图片编辑成功时，上游一般会出现工具消息：
+
+```json
+{
+  "v": {
+    "message": {
+      "author": {"role": "tool"},
+      "content": {
+        "content_type": "multimodal_text",
+        "parts": [
+          {"asset_pointer": "file-service://file_result"},
+          {"asset_pointer": "sediment://file_result"}
+        ]
+      },
+      "metadata": {"async_task_type": "image_gen"}
+    }
+  },
+  "conversation_id": "..."
+}
+```
+
+只有同时满足以下条件的图片指针，才应该视为输出结果：
+
+| 条件 | 说明 |
+|:--|:--|
+| `message.author.role == "tool"` | 来源是工具消息 |
+| `metadata.async_task_type == "image_gen"` | 工具任务是图片生成 |
+| `asset_pointer` 为 `file-service://...` 或 `sediment://...` | 指向可解析图片资源 |
+
+## 图片指针类型
+
+| 指针 | 常见来源 | 说明 |
+|:--|:--|:--|
+| `file-service://file_xxx` | 图片工具输出 | 可通过文件下载接口解析 |
+| `sediment://file_xxx` | 输入附件或图片工具输出 | 需要结合消息角色判断来源 |
+| `file_upload` | 上传过程占位 | 通常不应作为输出 |
+
+不要只凭字符串里出现 `file_` 或 `sediment://` 就判定为输出图。必须结合消息角色和任务类型。
+
+## 策略拒绝场景
+
+当上游拒绝请求时，通常不会产生图片工具消息，而是返回普通 assistant 文本：
+
+```text
+I can't assist with that request. If you have another type of modification...
+```
+
+常见伴随事件：
+
+```json
+{"type":"title_generation","title":"Request Denied","conversation_id":"..."}
+```
+
+```json
+{
+  "type": "server_ste_metadata",
+  "metadata": {
+    "tool_invoked": false,
+    "turn_use_case": "multimodal",
+    "did_prompt_contain_image": true
+  },
+  "conversation_id": "..."
+}
+```
+
+处理要点：
+
+| 条件 | 行为 |
+|:--|:--|
+| 有 assistant 拒绝文本 | 应返回文本消息 |
+| `tool_invoked == false` | 说明没有实际工具结果 |
+| 没有 `role=tool` 且 `async_task_type=image_gen` 的消息 | 不应收集输出图片 |
+| 用户输入消息里有图片指针 | 仍然只视为输入附件 |
+
+## moderation 场景
+
+部分请求可能返回 moderation 事件：
+
+```json
+{
+  "type": "moderation",
+  "moderation_response": {
+    "blocked": true
+  },
+  "conversation_id": "..."
+}
+```
+
+若 `blocked == true`，应认为本轮被策略拦截。后续如有 assistant 文本，应优先返回该文本；若没有文本，可返回合适的错误信息。
+
+## marker 和 title 事件
+
+上游会返回一些辅助事件：
+
+```json
+{"type":"message_marker","marker":"user_visible_token","event":"first"}
+{"type":"message_marker","marker":"last_token","event":"last"}
+{"type":"title_generation","title":"...","conversation_id":"..."}
+```
+
+这些事件通常用于前端展示、标题生成或流式状态标记，不代表实际文本内容或图片结果。
+
+## metadata 事件
+
+`server_ste_metadata` 用于描述本轮调度和工具状态：
+
+```json
+{
+  "type": "server_ste_metadata",
+  "metadata": {
+    "tool_invoked": true,
+    "turn_use_case": "multimodal",
+    "model_slug": "i-mini-m",
+    "did_prompt_contain_image": true
+  }
+}
+```
+
+常用判断：
+
+| 字段 | 说明 |
+|:--|:--|
+| `tool_invoked == true` | 上游认为本轮调用过工具 |
+| `tool_invoked == false` | 上游未调用工具，常见于拒绝或纯文本响应 |
+| `turn_use_case == "text"` | 按文本响应处理 |
+| `turn_use_case == "multimodal"` | 多模态请求，不代表一定有图片输出 |
+| `did_prompt_contain_image == true` | 输入包含图片，不代表输出包含图片 |
+
+## 结束后的结果判断
+
+SSE 结束后可按以下顺序判断结果：
+
+1. 如果已经收集到图片工具输出指针，解析并下载输出图片。
+2. 如果没有输出图片指针，但有 assistant 文本，并且本轮被拦截或未调用工具，返回文本消息。
+3. 如果没有输出图片指针，但有 `conversation_id`，可查询完整会话明细，继续寻找图片工具输出。
+4. 查询完整会话时，仍然只读取 `role=tool` 且 `async_task_type=image_gen` 的消息。
+5. 如果没有图片结果也没有文本，返回上游异常或空结果错误。
+

services/account_service.py

@@ -4,7 +4,6 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import base64
 import hashlib
 import json
-from pathlib import Path
 from threading import Lock
 from typing import Any
 from datetime import datetime
@@ -252,8 +251,7 @@ class AccountService:
             message = str(exc)
             print(f"[account-available] refresh token={token_ref} fail {message}")
             if "/backend-api/me failed: HTTP 401" in message:
-                if config.auto_remove_invalid_accounts and self.remove_token(access_token):
-                    log_service.add(LOG_TYPE_ACCOUNT, "自动移除异常账号", {"source": "refresh_account_state", "token": token_ref})
+                if self.remove_invalid_token(access_token, "refresh_account_state"):
                     return None
                 return self.update_account(
                     access_token,
@@ -280,6 +278,22 @@ class AccountService:
                 f"status={account.get('status') if account else 'unknown'}"
             )
 
+    def get_text_access_token(self) -> str:
+        with self._lock:
+            for account in self._accounts:
+                status = self._clean_token(account.get("status"))
+                if status not in {"禁用", "异常"}:
+                    return self._clean_token(account.get("access_token"))
+        return ""
+
+    def remove_invalid_token(self, access_token: str, event: str) -> bool:
+        if not config.auto_remove_invalid_accounts:
+            return False
+        removed = self.remove_token(access_token)
+        if removed:
+            log_service.add(LOG_TYPE_ACCOUNT, "自动移除异常账号", {"source": event, "token": anonymize_token(access_token)})
+        return removed
+
     def next_token(self) -> str:
         return self.get_available_access_token()
 
@@ -505,9 +519,7 @@ class AccountService:
                     message = str(exc)
                     print(f"[account-refresh] fail {anonymize_token(access_token)} {message}")
                     if "/backend-api/me failed: HTTP 401" in message:
-                        if config.auto_remove_invalid_accounts and self.remove_token(access_token):
-                            log_service.add(LOG_TYPE_ACCOUNT, "自动移除异常账号", {"source": "refresh_accounts", "token": anonymize_token(access_token)})
-                        else:
+                        if not self.remove_invalid_token(access_token, "refresh_accounts"):
                             self.update_account(access_token, {"status": "异常", "quota": 0})
                         message = "检测到封号"
                     errors.append({"access_token": access_token, "error": message})

services/chatgpt_service.py

@@ -1,1178 +0,0 @@
-from __future__ import annotations
-
-import base64
-import hashlib
-import re
-import time
-import uuid
-from pathlib import Path
-from typing import Any, Iterable, Iterator
-
-from fastapi import HTTPException
-
-from services.account_service import AccountService
-from services.anthropic_protocol import preprocess_payload
-from services.config import config
-from services.log_service import LOG_TYPE_ACCOUNT, log_service
-from services.openai_backend_api import CODEX_IMAGE_MODEL, OpenAIBackendAPI
-from utils.helper import (
-    IMAGE_MODELS,
-    anonymize_token,
-    extract_chat_image,
-    extract_chat_prompt,
-    extract_image_from_message_content,
-    extract_response_prompt,
-    has_response_image_generation_tool,
-    parse_image_count,
-    build_chat_image_completion,
-)
-from utils.helper import is_image_chat_request
-from utils.log import logger
-
-
-class ImageGenerationError(Exception):
-    pass
-
-
-def is_token_invalid_error(message: str) -> bool:
-    text = str(message or "").lower()
-    return (
-            "token_invalidated" in text
-            or "token_revoked" in text
-            or "authentication token has been invalidated" in text
-            or "invalidated oauth token" in text
-    )
-
-
-def _save_image_bytes(image_data: bytes, base_url: str | None = None) -> str:
-    config.cleanup_old_images()
-    file_hash = hashlib.md5(image_data).hexdigest()
-    timestamp = int(time.time())
-    filename = f"{timestamp}_{file_hash}.png"
-    relative_dir = Path(time.strftime("%Y"), time.strftime("%m"), time.strftime("%d"))
-    file_path = config.images_dir / relative_dir / filename
-    file_path.parent.mkdir(parents=True, exist_ok=True)
-    file_path.write_bytes(image_data)
-    return f"{(base_url or config.base_url)}/images/{relative_dir.as_posix()}/{filename}"
-
-
-def _extract_response_image(input_value: object) -> tuple[bytes, str] | None:
-    if isinstance(input_value, dict):
-        return extract_image_from_message_content(input_value.get("content"))
-    if not isinstance(input_value, list):
-        return None
-    for item in reversed(input_value):
-        if isinstance(item, dict):
-            if str(item.get("type") or "").strip() == "input_image":
-                import base64 as b64
-                image_url = str(item.get("image_url") or "")
-                if image_url.startswith("data:"):
-                    header, _, data = image_url.partition(",")
-                    mime = header.split(";")[0].removeprefix("data:")
-                    return b64.b64decode(data), mime or "image/png"
-            content = item.get("content")
-            if content:
-                result = extract_image_from_message_content(content)
-                if result:
-                    return result
-    return None
-
-
-class ChatGPTService:
-    def __init__(self, account_service: AccountService):
-        self.account_service = account_service
-
-    @staticmethod
-    def _new_backend(access_token: str = "") -> OpenAIBackendAPI:
-        return OpenAIBackendAPI(access_token=access_token)
-
-    def _get_text_access_token(self) -> str:
-        try:
-            for access_token in self.account_service.list_tokens():
-                status = str((self.account_service.get_account(access_token) or {}).get("status") or "").strip()
-                if status not in {"禁用", "异常"}:
-                    return access_token
-        except Exception:
-            pass
-        return ""
-
-    @staticmethod
-    def _encode_images(images: Iterable[tuple[bytes, str, str]]) -> list[str]:
-        encoded_images: list[str] = []
-        for image_data, _, _ in images:
-            if image_data:
-                encoded_images.append(base64.b64encode(image_data).decode("ascii"))
-        return encoded_images
-
-    def list_models(self) -> dict[str, object]:
-        result = self._new_backend().list_models()
-        data = result.get("data")
-        if not isinstance(data, list):
-            return result
-        seen = {str(item.get("id") or "").strip() for item in data if isinstance(item, dict)}
-        for model in sorted(IMAGE_MODELS):
-            if model in seen:
-                continue
-            data.append({
-                "id": model,
-                "object": "model",
-                "created": 0,
-                "owned_by": "chatgpt2api",
-                "permission": [],
-                "root": model,
-                "parent": None,
-            })
-        return result
-
-    @staticmethod
-    def _chat_messages_from_body(body: dict[str, object]) -> list[dict[str, object]]:
-        messages = body.get("messages")
-        if isinstance(messages, list) and messages:
-            return [message for message in messages if isinstance(message, dict)]
-        prompt = str(body.get("prompt") or "").strip()
-        if prompt:
-            return [{"role": "user", "content": prompt}]
-        raise HTTPException(status_code=400, detail={"error": "messages or prompt is required"})
-
-    @staticmethod
-    def _response_messages_from_input(input_value: object, instructions: object = None) -> list[dict[str, object]]:
-        messages: list[dict[str, object]] = []
-        system_text = str(instructions or "").strip()
-        if system_text:
-            messages.append({"role": "system", "content": system_text})
-
-        if isinstance(input_value, str):
-            user_text = input_value.strip()
-            if user_text:
-                messages.append({"role": "user", "content": user_text})
-            return messages
-
-        if isinstance(input_value, dict):
-            messages.append({
-                "role": str(input_value.get("role") or "user"),
-                "content": extract_response_prompt([input_value]) or input_value.get("content") or "",
-            })
-            return messages
-
-        if isinstance(input_value, list):
-            if all(isinstance(item, dict) and item.get("type") for item in input_value):
-                text = extract_response_prompt(input_value)
-                if text:
-                    messages.append({"role": "user", "content": text})
-                return messages
-            for item in input_value:
-                if not isinstance(item, dict):
-                    continue
-                messages.append({
-                    "role": str(item.get("role") or "user"),
-                    "content": extract_response_prompt([item]) or item.get("content") or "",
-                })
-            return messages
-
-        return messages
-
-    @staticmethod
-    def _response_text_output_item(text: str, item_id: str | None = None, status: str = "completed") -> dict[str, object]:
-        return {
-            "id": item_id or f"msg_{uuid.uuid4().hex}",
-            "type": "message",
-            "status": status,
-            "role": "assistant",
-            "content": [{
-                "type": "output_text",
-                "text": text,
-                "annotations": [],
-            }],
-        }
-
-    def _create_text_response(self, body: dict[str, object]) -> dict[str, object]:
-        model = str(body.get("model") or "auto").strip() or "auto"
-        messages = self._response_messages_from_input(body.get("input"), body.get("instructions"))
-        if len(messages) == 1 and messages[0].get("role") == "system":
-            raise HTTPException(status_code=400, detail={"error": "input text is required"})
-        try:
-            result = self._new_backend(self._get_text_access_token()).chat_completions(messages=messages, model=model, stream=False)
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-        created = int(result.get("created") or time.time())
-        output_text = str((((result.get("choices") or [{}])[0].get("message") or {}).get("content")) or "")
-        response_id = f"resp_{uuid.uuid4().hex}"
-        output_item = self._response_text_output_item(output_text)
-        return {
-            "id": response_id,
-            "object": "response",
-            "created_at": created,
-            "status": "completed",
-            "error": None,
-            "incomplete_details": None,
-            "model": model,
-            "output": [output_item],
-            "parallel_tool_calls": False,
-            "usage": result.get("usage"),
-        }
-
-    def _stream_text_response(self, body: dict[str, object]) -> Iterator[dict[str, object]]:
-        model = str(body.get("model") or "auto").strip() or "auto"
-        messages = self._response_messages_from_input(body.get("input"), body.get("instructions"))
-        if len(messages) == 1 and messages[0].get("role") == "system":
-            raise HTTPException(status_code=400, detail={"error": "input text is required"})
-
-        response_id = f"resp_{uuid.uuid4().hex}"
-        item_id = f"msg_{uuid.uuid4().hex}"
-        created = int(time.time())
-        full_text = ""
-
-        yield {
-            "type": "response.created",
-            "response": {
-                "id": response_id,
-                "object": "response",
-                "created_at": created,
-                "status": "in_progress",
-                "error": None,
-                "incomplete_details": None,
-                "model": model,
-                "output": [],
-                "parallel_tool_calls": False,
-            },
-        }
-        yield {
-            "type": "response.output_item.added",
-            "output_index": 0,
-            "item": self._response_text_output_item("", item_id=item_id, status="in_progress"),
-        }
-
-        try:
-            stream = self._new_backend(self._get_text_access_token()).chat_completions(messages=messages, model=model, stream=True)
-            for chunk in stream:
-                choices = chunk.get("choices")
-                first_choice = choices[0] if isinstance(choices, list) and choices and isinstance(choices[0], dict) else {}
-                delta = first_choice.get("delta") if isinstance(first_choice.get("delta"), dict) else {}
-                delta_text = str(delta.get("content") or "")
-                if delta_text:
-                    full_text += delta_text
-                    yield {
-                        "type": "response.output_text.delta",
-                        "item_id": item_id,
-                        "output_index": 0,
-                        "content_index": 0,
-                        "delta": delta_text,
-                    }
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-        yield {
-            "type": "response.output_text.done",
-            "item_id": item_id,
-            "output_index": 0,
-            "content_index": 0,
-            "text": full_text,
-        }
-        output_item = self._response_text_output_item(full_text, item_id=item_id, status="completed")
-        yield {
-            "type": "response.output_item.done",
-            "output_index": 0,
-            "item": output_item,
-        }
-        yield {
-            "type": "response.completed",
-            "response": {
-                "id": response_id,
-                "object": "response",
-                "created_at": created,
-                "status": "completed",
-                "error": None,
-                "incomplete_details": None,
-                "model": model,
-                "output": [output_item],
-                "parallel_tool_calls": False,
-            },
-        }
-
-    @staticmethod
-    def _is_text_response_request(body: dict[str, object]) -> bool:
-        tools = body.get("tools")
-        if isinstance(tools, list):
-            for tool in tools:
-                if isinstance(tool, dict) and str(tool.get("type") or "").strip() == "image_generation":
-                    return False
-        tool_choice = body.get("tool_choice")
-        if isinstance(tool_choice, dict) and str(tool_choice.get("type") or "").strip() == "image_generation":
-            return False
-        return True
-
-    @staticmethod
-    def _is_codex_image_response_request(body: dict[str, object]) -> bool:
-        return has_response_image_generation_tool(body) and str(body.get("model") or "").strip() == CODEX_IMAGE_MODEL
-
-    @staticmethod
-    def _build_image_response_output(
-            prompt: str,
-            image_result: dict[str, object],
-    ) -> list[dict[str, object]]:
-        image_items = image_result.get("data") if isinstance(image_result.get("data"), list) else []
-        output: list[dict[str, object]] = []
-        for item in image_items:
-            if not isinstance(item, dict):
-                continue
-            b64_json = str(item.get("b64_json") or "").strip()
-            if not b64_json:
-                continue
-            output.append(
-                {
-                    "id": f"ig_{len(output) + 1}",
-                    "type": "image_generation_call",
-                    "status": "completed",
-                    "result": b64_json,
-                    "revised_prompt": str(item.get("revised_prompt") or prompt).strip(),
-                }
-            )
-        return output
-
-    def _create_token_image_response(self, body: dict[str, object]) -> dict[str, object]:
-        prompt = extract_response_prompt(body.get("input"))
-        if not prompt:
-            raise HTTPException(status_code=400, detail={"error": "input text is required"})
-
-        model = str(body.get("model") or "gpt-image-2").strip() or "gpt-image-2"
-        image_info = _extract_response_image(body.get("input"))
-        try:
-            if image_info:
-                image_data, mime_type = image_info
-                image_result = self.edit_with_pool(prompt, [(image_data, "image.png", mime_type)], model, 1)
-            else:
-                image_result = self.generate_with_pool(prompt, model, 1, size="1:1")
-        except ImageGenerationError as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-        output = self._build_image_response_output(prompt, image_result)
-        if not output:
-            raise HTTPException(status_code=502, detail={"error": "image generation failed"})
-
-        created = int(image_result.get("created") or time.time())
-        response = {
-            "id": f"resp_{created}",
-            "object": "response",
-            "created_at": created,
-            "status": "completed",
-            "error": None,
-            "incomplete_details": None,
-            "model": model,
-            "output": output,
-            "parallel_tool_calls": False,
-        }
-        return response
-
-    def _stream_token_image_response(self, body: dict[str, object]) -> Iterator[dict[str, object]]:
-        prompt = extract_response_prompt(body.get("input"))
-        if not prompt:
-            raise HTTPException(status_code=400, detail={"error": "input text is required"})
-
-        model = str(body.get("model") or "gpt-image-2").strip() or "gpt-image-2"
-        image_info = _extract_response_image(body.get("input"))
-        response_id = f"resp_{uuid.uuid4().hex}"
-        item_id = f"ig_{uuid.uuid4().hex}"
-        created = int(time.time())
-        final_output: list[dict[str, object]] = []
-
-        yield {
-            "type": "response.created",
-            "response": {
-                "id": response_id,
-                "object": "response",
-                "created_at": created,
-                "status": "in_progress",
-                "error": None,
-                "incomplete_details": None,
-                "model": model,
-                "output": [],
-                "parallel_tool_calls": False,
-            },
-        }
-
-        try:
-            if image_info:
-                image_data, mime_type = image_info
-                stream = self.stream_image_edit(prompt, [(image_data, "image.png", mime_type)], model, 1)
-            else:
-                stream = self.stream_image_generation(prompt, model, 1, size="1:1")
-
-            for chunk in stream:
-                data = chunk.get("data")
-                if not isinstance(data, list) or not data:
-                    continue
-                output = self._build_image_response_output(
-                    prompt,
-                    {
-                        "created": chunk.get("created"),
-                        "data": data,
-                    },
-                )
-                if output:
-                    final_output = output
-        except ImageGenerationError as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-        if not final_output:
-            raise HTTPException(status_code=502, detail={"error": "image generation failed"})
-
-        final_item = dict(final_output[0])
-        final_item["id"] = item_id
-        yield {
-            "type": "response.output_item.done",
-            "output_index": 0,
-            "item": final_item,
-        }
-        yield {
-            "type": "response.completed",
-            "response": {
-                "id": response_id,
-                "object": "response",
-                "created_at": created,
-                "status": "completed",
-                "error": None,
-                "incomplete_details": None,
-                "model": model,
-                "output": [final_item],
-                "parallel_tool_calls": False,
-            },
-        }
-
-    @staticmethod
-    def _format_image_result(
-            result: dict[str, object],
-            prompt: str,
-            response_format: str,
-            base_url: str | None = None,
-    ) -> dict[str, object]:
-        created = result.get("created")
-        data = result.get("data")
-        formatted_items: list[dict[str, object]] = []
-        if isinstance(data, list):
-            for item in data:
-                if not isinstance(item, dict):
-                    continue
-                revised_prompt = str(item.get("revised_prompt") or prompt).strip() or prompt
-                b64_json = str(item.get("b64_json") or "").strip()
-                if response_format == "b64_json":
-                    if b64_json:
-                        image_url = _save_image_bytes(base64.b64decode(b64_json), base_url)
-                        formatted_items.append({"b64_json": b64_json, "url": image_url, "revised_prompt": revised_prompt})
-                    continue
-                if not b64_json:
-                    continue
-                image_data = base64.b64decode(b64_json)
-                formatted_items.append(
-                    {"url": _save_image_bytes(image_data, base_url), "revised_prompt": revised_prompt})
-        return {"created": created, "data": formatted_items}
-
-    def _remove_invalid_token(self, access_token: str, event: str) -> bool:
-        if not config.auto_remove_invalid_accounts:
-            return False
-        removed = self.account_service.remove_token(access_token)
-        if removed:
-            log_service.add(LOG_TYPE_ACCOUNT, "自动移除异常账号", {"source": event, "token": anonymize_token(access_token)})
-        return removed
-
-    @staticmethod
-    def _extract_image_data_urls(markdown_content: str) -> list[str]:
-        return re.findall(r"!\[[^\]]*\]\((data:image/[^;]+;base64,[^)]+)\)", markdown_content or "")
-
-    def _stream_result_from_markdown(
-            self,
-            markdown_content: str,
-            prompt: str,
-            response_format: str,
-            base_url: str | None = None,
-            created: int | None = None,
-    ) -> dict[str, object] | None:
-        data_urls = self._extract_image_data_urls(markdown_content)
-        if not data_urls:
-            return None
-        raw_items: list[dict[str, object]] = []
-        for data_url in data_urls:
-            header, _, data = data_url.partition(",")
-            mime_type = header.split(";")[0].removeprefix("data:") or "image/png"
-            raw_items.append({
-                "b64_json": data,
-                "revised_prompt": prompt,
-                "mime_type": mime_type,
-            })
-        return self._format_image_result(
-            {"created": created or int(time.time()), "data": raw_items},
-            prompt,
-            response_format,
-            base_url,
-        )
-
-    @staticmethod
-    def _progress_chunk(
-            model: str,
-            index: int,
-            total: int,
-            created: int | None = None,
-            progress_text: str = "",
-            upstream_event_type: str = "",
-    ) -> dict[str, object]:
-        return {
-            "object": "image.generation.chunk",
-            "created": created or int(time.time()),
-            "model": model,
-            "index": index,
-            "total": total,
-            "progress_text": progress_text,
-            "upstream_event_type": upstream_event_type,
-            "data": [],
-        }
-
-    def _stream_single_image_result(
-            self,
-            prompt: str,
-            model: str,
-            index: int,
-            total: int,
-            request_token: str,
-            size: str | None = None,
-            response_format: str = "b64_json",
-            base_url: str | None = None,
-            images: list[str] | None = None,
-    ) -> Iterator[dict[str, object]]:
-        stream = self._new_backend(request_token).stream_image_chat_completions(
-            prompt=prompt,
-            model=model,
-            size=size,
-            images=images or None,
-        )
-        for chunk in stream:
-            created = int(chunk.get("created") or time.time()) if isinstance(chunk, dict) else int(time.time())
-            choices = chunk.get("choices") if isinstance(chunk, dict) else None
-            first_choice = choices[0] if isinstance(choices, list) and choices and isinstance(choices[0], dict) else {}
-            delta = first_choice.get("delta") if isinstance(first_choice.get("delta"), dict) else {}
-            content = str(delta.get("content") or "")
-            finish_reason = str(first_choice.get("finish_reason") or "")
-
-            if "upstream_event" in chunk:
-                upstream_event = chunk.get("upstream_event")
-                upstream_event_type = ""
-                if isinstance(upstream_event, dict):
-                    upstream_event_type = str(upstream_event.get("type") or "")
-                yield self._progress_chunk(model, index, total, created, content, upstream_event_type)
-                continue
-
-            formatted_result = self._stream_result_from_markdown(content, prompt, response_format, base_url, created)
-            if formatted_result:
-                yield {
-                    "object": "image.generation.result",
-                    "created": formatted_result.get("created"),
-                    "model": model,
-                    "index": index,
-                    "total": total,
-                    "data": formatted_result.get("data") if isinstance(formatted_result.get("data"), list) else [],
-                }
-                continue
-
-            if finish_reason:
-                yield {
-                    "object": "image.generation.done",
-                    "created": created,
-                    "model": model,
-                    "index": index,
-                    "total": total,
-                    "data": [],
-                    "finish_reason": finish_reason,
-                }
-
-    def _iter_generated_images_with_pool(
-            self,
-            prompt: str,
-            model: str,
-            n: int,
-            size: str | None = None,
-            response_format: str = "b64_json",
-            base_url: str | None = None,
-    ) -> Iterator[dict[str, object]]:
-        emitted = False
-        last_error = ""
-        for index in range(1, n + 1):
-            while True:
-                try:
-                    request_token = self.account_service.get_available_access_token()
-                except RuntimeError as exc:
-                    last_error = str(exc)
-                    logger.warning({
-                        "event": "image_generate_stop",
-                        "index": index,
-                        "total": n,
-                        "error": last_error,
-                    })
-                    if emitted:
-                        return
-                    raise ImageGenerationError(last_error or "image generation failed") from exc
-
-                logger.info({
-                    "event": "image_generate_start",
-                    "request_token": request_token,
-                    "model": model,
-                    "index": index,
-                    "total": n,
-                })
-                try:
-                    result = self._format_image_result(self._new_backend(request_token).images_generations(
-                        prompt=prompt,
-                        model=model,
-                        size=size,
-                        response_format="b64_json",
-                    ), prompt, response_format, base_url)
-                    account = self.account_service.mark_image_result(request_token, success=True)
-                    data = result.get("data")
-                    image_items = [item for item in data if isinstance(item, dict)] if isinstance(data, list) else []
-                    logger.info({
-                        "event": "image_generate_success",
-                        "request_token": request_token,
-                        "quota": account.get("quota") if account else "unknown",
-                        "status": account.get("status") if account else "unknown",
-                    })
-                    if image_items:
-                        emitted = True
-                        yield {
-                            "created": result.get("created"),
-                            "data": image_items,
-                        }
-                    break
-                except Exception as exc:
-                    account = self.account_service.mark_image_result(request_token, success=False)
-                    message = str(exc)
-                    last_error = message
-                    logger.warning({
-                        "event": "image_generate_fail",
-                        "request_token": request_token,
-                        "error": message,
-                        "quota": account.get("quota") if account else "unknown",
-                        "status": account.get("status") if account else "unknown",
-                    })
-                    if is_token_invalid_error(message):
-                        self._remove_invalid_token(request_token, "image_generate")
-                        logger.warning({
-                            "event": "image_generate_remove_invalid_token",
-                            "request_token": request_token,
-                        })
-                        continue
-                    break
-
-        if not emitted:
-            raise ImageGenerationError(last_error or "image generation failed")
-
-    def generate_with_pool(self, prompt: str, model: str, n: int, size: str | None = None, response_format: str = "b64_json",
-                           base_url: str = None):
-        created = None
-        image_items: list[dict[str, object]] = []
-        for result in self._iter_generated_images_with_pool(prompt, model, n, size, response_format, base_url):
-            if created is None:
-                created = result.get("created")
-            data = result.get("data")
-            if isinstance(data, list):
-                image_items.extend(item for item in data if isinstance(item, dict))
-        result = {
-            "created": created,
-            "data": image_items,
-        }
-        return result
-
-    def stream_image_generation(
-            self,
-            prompt: str,
-            model: str,
-            n: int,
-            size: str | None = None,
-            response_format: str = "b64_json",
-            base_url: str | None = None,
-    ) -> Iterator[dict[str, object]]:
-        last_error = ""
-        emitted = False
-        for index in range(1, n + 1):
-            while True:
-                try:
-                    request_token = self.account_service.get_available_access_token()
-                except RuntimeError as exc:
-                    last_error = str(exc)
-                    logger.warning({
-                        "event": "image_generate_stream_stop",
-                        "index": index,
-                        "total": n,
-                        "error": last_error,
-                    })
-                    if emitted:
-                        return
-                    raise ImageGenerationError(last_error or "image generation failed") from exc
-
-                logger.info({
-                    "event": "image_generate_stream_start",
-                    "request_token": request_token,
-                    "model": model,
-                    "index": index,
-                    "total": n,
-                })
-                emitted_for_request = False
-                has_result = False
-                try:
-                    for chunk in self._stream_single_image_result(
-                            prompt,
-                            model,
-                            index,
-                            n,
-                            request_token,
-                            size,
-                            response_format,
-                            base_url,
-                    ):
-                        emitted = True
-                        emitted_for_request = True
-                        data = chunk.get("data")
-                        if isinstance(data, list) and data:
-                            has_result = True
-                        yield chunk
-                    if not has_result:
-                        last_error = "image generation failed"
-                        raise ImageGenerationError(last_error)
-                    account = self.account_service.mark_image_result(request_token, success=True)
-                    logger.info({
-                        "event": "image_generate_stream_success",
-                        "request_token": request_token,
-                        "quota": account.get("quota") if account else "unknown",
-                        "status": account.get("status") if account else "unknown",
-                        "has_result": has_result,
-                    })
-                    break
-                except Exception as exc:
-                    account = self.account_service.mark_image_result(request_token, success=False)
-                    message = str(exc)
-                    last_error = message
-                    logger.warning({
-                        "event": "image_generate_stream_fail",
-                        "request_token": request_token,
-                        "error": message,
-                        "quota": account.get("quota") if account else "unknown",
-                        "status": account.get("status") if account else "unknown",
-                    })
-                    if not emitted_for_request and is_token_invalid_error(message):
-                        self._remove_invalid_token(request_token, "image_generate_stream")
-                        logger.warning({
-                            "event": "image_generate_stream_remove_invalid_token",
-                            "request_token": request_token,
-                        })
-                        continue
-                    raise ImageGenerationError(last_error or "image generation failed") from exc
-
-    def edit_with_pool(
-            self,
-            prompt: str,
-            images: Iterable[tuple[bytes, str, str]],
-            model: str,
-            n: int,
-            size: str | None = None,
-            response_format: str = "b64_json",
-            base_url: str = None,
-    ):
-        created = None
-        image_items: list[dict[str, object]] = []
-        last_error = ""
-        normalized_images = list(images)
-        if not normalized_images:
-            raise ImageGenerationError("image is required")
-
-        for index in range(1, n + 1):
-            while True:
-                try:
-                    request_token = self.account_service.get_available_access_token()
-                except RuntimeError as exc:
-                    last_error = str(exc)
-                    logger.warning({
-                        "event": "image_edit_stop",
-                        "index": index,
-                        "total": n,
-                        "error": last_error,
-                    })
-                    break
-
-                logger.info({
-                    "event": "image_edit_start",
-                    "request_token": request_token,
-                    "model": model,
-                    "index": index,
-                    "total": n,
-                    "image_count": len(normalized_images),
-                })
-                try:
-                    result = self._format_image_result(self._new_backend(request_token).images_edits(
-                        image=self._encode_images(normalized_images),
-                        prompt=prompt,
-                        model=model,
-                        size=size,
-                        response_format="b64_json",
-                    ), prompt, response_format, base_url)
-                    account = self.account_service.mark_image_result(request_token, success=True)
-                    if created is None:
-                        created = result.get("created")
-                    data = result.get("data")
-                    if isinstance(data, list):
-                        image_items.extend(item for item in data if isinstance(item, dict))
-                    logger.info({
-                        "event": "image_edit_success",
-                        "request_token": request_token,
-                        "quota": account.get("quota") if account else "unknown",
-                        "status": account.get("status") if account else "unknown",
-                    })
-                    break
-                except Exception as exc:
-                    account = self.account_service.mark_image_result(request_token, success=False)
-                    message = str(exc)
-                    last_error = message
-                    logger.warning({
-                        "event": "image_edit_fail",
-                        "request_token": request_token,
-                        "error": message,
-                        "quota": account.get("quota") if account else "unknown",
-                        "status": account.get("status") if account else "unknown",
-                    })
-                    if is_token_invalid_error(message):
-                        self._remove_invalid_token(request_token, "image_edit")
-                        logger.warning({
-                            "event": "image_edit_remove_invalid_token",
-                            "request_token": request_token,
-                        })
-                        continue
-                    break
-
-        if not image_items:
-            raise ImageGenerationError(last_error or "image edit failed")
-
-        result = {
-            "created": created,
-            "data": image_items,
-        }
-        return result
-
-    def stream_image_edit(
-            self,
-            prompt: str,
-            images: Iterable[tuple[bytes, str, str]],
-            model: str,
-            n: int,
-            size: str | None = None,
-            response_format: str = "b64_json",
-            base_url: str | None = None,
-    ) -> Iterator[dict[str, object]]:
-        last_error = ""
-        emitted = False
-        normalized_images = list(images)
-        if not normalized_images:
-            raise ImageGenerationError("image is required")
-        encoded_images = self._encode_images(normalized_images)
-
-        for index in range(1, n + 1):
-            while True:
-                try:
-                    request_token = self.account_service.get_available_access_token()
-                except RuntimeError as exc:
-                    last_error = str(exc)
-                    logger.warning({
-                        "event": "image_edit_stream_stop",
-                        "index": index,
-                        "total": n,
-                        "error": last_error,
-                    })
-                    if emitted:
-                        return
-                    raise ImageGenerationError(last_error or "image edit failed") from exc
-
-                logger.info({
-                    "event": "image_edit_stream_start",
-                    "request_token": request_token,
-                    "model": model,
-                    "index": index,
-                    "total": n,
-                    "image_count": len(normalized_images),
-                })
-                emitted_for_request = False
-                has_result = False
-                try:
-                    for chunk in self._stream_single_image_result(
-                            prompt=prompt,
-                            model=model,
-                            index=index,
-                            total=n,
-                            request_token=request_token,
-                            size=size,
-                            response_format=response_format,
-                            base_url=base_url,
-                            images=encoded_images,
-                    ):
-                        emitted = True
-                        emitted_for_request = True
-                        data = chunk.get("data")
-                        if isinstance(data, list) and data:
-                            has_result = True
-                        yield chunk
-                    if not has_result:
-                        last_error = "image edit failed"
-                        raise ImageGenerationError(last_error)
-                    account = self.account_service.mark_image_result(request_token, success=True)
-                    logger.info({
-                        "event": "image_edit_stream_success",
-                        "request_token": request_token,
-                        "quota": account.get("quota") if account else "unknown",
-                        "status": account.get("status") if account else "unknown",
-                        "has_result": has_result,
-                    })
-                    break
-                except Exception as exc:
-                    account = self.account_service.mark_image_result(request_token, success=False)
-                    message = str(exc)
-                    last_error = message
-                    logger.warning({
-                        "event": "image_edit_stream_fail",
-                        "request_token": request_token,
-                        "error": message,
-                        "quota": account.get("quota") if account else "unknown",
-                        "status": account.get("status") if account else "unknown",
-                    })
-                    if not emitted_for_request and is_token_invalid_error(message):
-                        self._remove_invalid_token(request_token, "image_edit_stream")
-                        logger.warning({
-                            "event": "image_edit_stream_remove_invalid_token",
-                            "request_token": request_token,
-                        })
-                        continue
-                    raise ImageGenerationError(last_error or "image edit failed") from exc
-
-    @staticmethod
-    def _stream_completion_response(result: dict[str, object]) -> Iterator[dict[str, object]]:
-        completion_id = str(result.get("id") or f"chatcmpl-{uuid.uuid4().hex}")
-        created = int(result.get("created") or time.time())
-        model = str(result.get("model") or "auto")
-        choices = result.get("choices")
-        first_choice = choices[0] if isinstance(choices, list) and choices and isinstance(choices[0], dict) else {}
-        message = first_choice.get("message") if isinstance(first_choice.get("message"), dict) else {}
-        content = str(message.get("content") or "")
-        finish_reason = str(first_choice.get("finish_reason") or "stop")
-
-        yield {
-            "id": completion_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [{
-                "index": 0,
-                "delta": {"role": "assistant", "content": content},
-                "finish_reason": None,
-            }],
-        }
-        yield {
-            "id": completion_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [{
-                "index": 0,
-                "delta": {},
-                "finish_reason": finish_reason,
-            }],
-        }
-
-    def _create_image_chat_completion(self, body: dict[str, object]) -> dict[str, object]:
-        model = str(body.get("model") or "gpt-image-2").strip() or "gpt-image-2"
-        n = parse_image_count(body.get("n"))
-        prompt = extract_chat_prompt(body)
-        if not prompt:
-            raise HTTPException(status_code=400, detail={"error": "prompt is required"})
-
-        image_infos = extract_chat_image(body)
-        try:
-            if image_infos:
-                images = [(data, f"image_{idx}.png", mime) for idx, (data, mime) in enumerate(image_infos, start=1)]
-                image_result = self.edit_with_pool(prompt, images, model, n)
-            else:
-                image_result = self.generate_with_pool(prompt, model, n)
-        except ImageGenerationError as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-        return build_chat_image_completion(model, image_result)
-
-    def _stream_image_chat_completion(self, body: dict[str, object]) -> Iterator[dict[str, object]]:
-        model = str(body.get("model") or "gpt-image-2").strip() or "gpt-image-2"
-        n = parse_image_count(body.get("n"))
-        if n != 1:
-            result = self._create_image_chat_completion(body)
-            yield from self._stream_completion_response(result)
-            return
-
-        prompt = extract_chat_prompt(body)
-        if not prompt:
-            raise HTTPException(status_code=400, detail={"error": "prompt is required"})
-
-        image_infos = extract_chat_image(body)
-        encoded_images = []
-        if image_infos:
-            images = [(data, f"image_{idx}.png", mime) for idx, (data, mime) in enumerate(image_infos, start=1)]
-            encoded_images = self._encode_images(images)
-
-        last_error = ""
-        while True:
-            try:
-                request_token = self.account_service.get_available_access_token()
-            except RuntimeError as exc:
-                raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-            logger.info({
-                "event": "image_stream_start",
-                "request_token": request_token,
-                "model": model,
-            })
-            emitted = False
-            try:
-                stream = self._new_backend(request_token).stream_image_chat_completions(
-                    prompt=prompt,
-                    model=model,
-                    images=encoded_images or None,
-                )
-                for chunk in stream:
-                    emitted = True
-                    yield chunk
-                account = self.account_service.mark_image_result(request_token, success=True)
-                logger.info({
-                    "event": "image_stream_success",
-                    "request_token": request_token,
-                    "quota": account.get("quota") if account else "unknown",
-                    "status": account.get("status") if account else "unknown",
-                })
-                return
-            except Exception as exc:
-                account = self.account_service.mark_image_result(request_token, success=False)
-                message = str(exc)
-                last_error = message
-                logger.warning({
-                    "event": "image_stream_fail",
-                    "request_token": request_token,
-                    "error": message,
-                    "quota": account.get("quota") if account else "unknown",
-                    "status": account.get("status") if account else "unknown",
-                })
-                if not emitted and is_token_invalid_error(message):
-                    self._remove_invalid_token(request_token, "image_stream")
-                    logger.warning({
-                        "event": "image_stream_remove_invalid_token",
-                        "request_token": request_token,
-                    })
-                    continue
-                raise HTTPException(status_code=502, detail={"error": last_error or "image generation failed"}) from exc
-
-    def _create_text_chat_completion(self, body: dict[str, object]) -> dict[str, object]:
-        model = str(body.get("model") or "auto").strip() or "auto"
-        messages = self._chat_messages_from_body(body)
-        try:
-            result = self._new_backend(self._get_text_access_token()).chat_completions(messages=messages, model=model, stream=False)
-            return result
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-    def create_chat_completion(self, body: dict[str, object]) -> dict[str, object]:
-        if is_image_chat_request(body):
-            return self._create_image_chat_completion(body)
-        return self._create_text_chat_completion(body)
-
-    def stream_chat_completion(self, body: dict[str, object]) -> Iterator[dict[str, object]]:
-        if is_image_chat_request(body):
-            yield from self._stream_image_chat_completion(body)
-            return
-
-        model = str(body.get("model") or "auto").strip() or "auto"
-        messages = self._chat_messages_from_body(body)
-        try:
-            yield from self._new_backend(self._get_text_access_token()).chat_completions(messages=messages, model=model, stream=True)
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-    def create_message(self, body: dict[str, object]) -> dict[str, object]:
-        body = preprocess_payload(dict(body))
-        model = str(body.get("model") or "auto").strip() or "auto"
-        messages = self._chat_messages_from_body(body)
-        try:
-            result = self._new_backend(self._get_text_access_token()).messages(
-                messages=messages,
-                model=model,
-                stream=False,
-                system=body.get("system"),
-                tools=body.get("tools"),
-            )
-            return result
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-    def stream_message(self, body: dict[str, object]) -> Iterator[dict[str, object]]:
-        body = preprocess_payload(dict(body))
-        model = str(body.get("model") or "auto").strip() or "auto"
-        messages = self._chat_messages_from_body(body)
-        try:
-            yield from self._new_backend(self._get_text_access_token()).messages(
-                messages=messages,
-                model=model,
-                stream=True,
-                system=body.get("system"),
-                tools=body.get("tools"),
-            )
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-    def create_image_completion(self, body: dict[str, object]) -> dict[str, object]:
-        if not is_image_chat_request(body):
-            raise HTTPException(
-                status_code=400,
-                detail={"error": "only image generation requests are supported on this endpoint"},
-            )
-        return self._create_image_chat_completion(body)
-
-    def _get_response_access_token(self, body: dict[str, object]) -> str:
-        return self.account_service.get_available_access_token()
-
-    def stream_response(self, body: dict[str, object]) -> Iterator[dict[str, object]]:
-        if self._is_text_response_request(body):
-            yield from self._stream_text_response(body)
-            return
-        if not self._is_codex_image_response_request(body):
-            yield from self._stream_token_image_response(body)
-            return
-        try:
-            access_token = self._get_response_access_token(body)
-            yield from self._new_backend(access_token).responses(
-                input=body.get("input") or "",
-                model=str(body.get("model") or "gpt-5.4").strip() or "gpt-5.4",
-                tools=body.get("tools") if isinstance(body.get("tools"), list) else None,
-                instructions=str(body.get("instructions") or "you are a helpful assistant"),
-                tool_choice=body.get("tool_choice") or "auto",
-                stream=True,
-                store=bool(body.get("store")),
-            )
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc
-
-    def create_response(self, body: dict[str, object]) -> dict[str, object]:
-        if self._is_text_response_request(body):
-            result = self._create_text_response(body)
-            return result
-        if not self._is_codex_image_response_request(body):
-            return self._create_token_image_response(body)
-        try:
-            access_token = self._get_response_access_token(body)
-            result = self._new_backend(access_token).responses(
-                input=body.get("input") or "",
-                model=str(body.get("model") or "gpt-5.4").strip() or "gpt-5.4",
-                tools=body.get("tools") if isinstance(body.get("tools"), list) else None,
-                instructions=str(body.get("instructions") or "you are a helpful assistant"),
-                tool_choice=body.get("tool_choice") or "auto",
-                stream=False,
-                store=bool(body.get("store")),
-            )
-            return result
-        except Exception as exc:
-            raise HTTPException(status_code=502, detail={"error": str(exc)}) from exc

services/config.py

@@ -117,6 +117,14 @@ class ConfigStore:
             return value.strip().lower() in {"1", "true", "yes", "on"}
         return bool(value)
 
+    @property
+    def log_levels(self) -> list[str]:
+        levels = self.data.get("log_levels")
+        if not isinstance(levels, list):
+            return []
+        allowed = {"debug", "info", "warning", "error"}
+        return [level for item in levels if (level := str(item or "").strip().lower()) in allowed]
+
     @property
     def images_dir(self) -> Path:
         path = DATA_DIR / "images"
@@ -158,6 +166,7 @@ class ConfigStore:
         data["refresh_account_interval_minute"] = self.refresh_account_interval_minute
         data["image_retention_days"] = self.image_retention_days
         data["auto_remove_invalid_accounts"] = self.auto_remove_invalid_accounts
+        data["log_levels"] = self.log_levels
         data.pop("auth-key", None)
         return data
 

services/log_service.py

@@ -1,15 +1,23 @@
 from __future__ import annotations
 
 import json
+import itertools
+import time
+from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
 from typing import Any
 
+from fastapi.concurrency import run_in_threadpool
+from fastapi.responses import JSONResponse, StreamingResponse
+
 from services.config import DATA_DIR
+from utils.helper import anthropic_sse_stream, sse_json_stream
 
 LOG_TYPE_CALL = "call"
 LOG_TYPE_ACCOUNT = "account"
 
+
 class LogService:
     def __init__(self, path: Path):
         self.path = path
@@ -49,3 +57,119 @@ class LogService:
 
 
 log_service = LogService(DATA_DIR / "logs.jsonl")
+
+
+def _collect_urls(value: object) -> list[str]:
+    urls: list[str] = []
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key == "url" and isinstance(item, str):
+                urls.append(item)
+            elif key == "urls" and isinstance(item, list):
+                urls.extend(str(url) for url in item if isinstance(url, str))
+            else:
+                urls.extend(_collect_urls(item))
+    elif isinstance(value, list):
+        for item in value:
+            urls.extend(_collect_urls(item))
+    return urls
+
+
+def _image_error_response(exc: Exception) -> JSONResponse:
+    message = str(exc)
+    if "no available image quota" in message.lower():
+        return JSONResponse(
+            status_code=429,
+            content={
+                "error": {
+                    "message": "no available image quota",
+                    "type": "insufficient_quota",
+                    "param": None,
+                    "code": "insufficient_quota",
+                }
+            },
+        )
+    if hasattr(exc, "to_openai_error") and hasattr(exc, "status_code"):
+        return JSONResponse(status_code=int(exc.status_code), content=exc.to_openai_error())
+    return JSONResponse(
+        status_code=502,
+        content={
+            "error": {
+                "message": message,
+                "type": "server_error",
+                "param": None,
+                "code": "upstream_error",
+            }
+        },
+    )
+
+
+@dataclass
+class LoggedCall:
+    identity: dict[str, object]
+    endpoint: str
+    model: str
+    summary: str
+    started: float = field(default_factory=time.time)
+
+    async def run(self, handler, *args, sse: str = "openai"):
+        from services.protocol.conversation import ImageGenerationError
+
+        try:
+            result = await run_in_threadpool(handler, *args)
+        except ImageGenerationError as exc:
+            self.log("调用失败", status="failed", error=str(exc))
+            return _image_error_response(exc)
+        except Exception as exc:
+            self.log("调用失败", status="failed", error=str(exc))
+            raise
+
+        if isinstance(result, dict):
+            self.log("调用完成", result)
+            return result
+
+        sender = anthropic_sse_stream if sse == "anthropic" else sse_json_stream
+        try:
+            first = next(result)
+        except StopIteration:
+            self.log("流式调用结束")
+            return StreamingResponse(sender(()), media_type="text/event-stream")
+        except ImageGenerationError as exc:
+            self.log("调用失败", status="failed", error=str(exc))
+            return _image_error_response(exc)
+        return StreamingResponse(sender(self.stream(itertools.chain([first], result))), media_type="text/event-stream")
+
+    def stream(self, items):
+        urls: list[str] = []
+        failed = False
+        try:
+            for item in items:
+                urls.extend(_collect_urls(item))
+                yield item
+        except Exception as exc:
+            failed = True
+            self.log("流式调用失败", status="failed", error=str(exc), urls=urls)
+            raise
+        finally:
+            if not failed:
+                self.log("流式调用结束", urls=urls)
+
+    def log(self, suffix: str, result: object = None, status: str = "success", error: str = "",
+            urls: list[str] | None = None) -> None:
+        detail = {
+            "key_id": self.identity.get("id"),
+            "key_name": self.identity.get("name"),
+            "role": self.identity.get("role"),
+            "endpoint": self.endpoint,
+            "model": self.model,
+            "started_at": datetime.fromtimestamp(self.started).strftime("%Y-%m-%d %H:%M:%S"),
+            "ended_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "duration_ms": int((time.time() - self.started) * 1000),
+            "status": status,
+        }
+        if error:
+            detail["error"] = error
+        collected_urls = [*(urls or []), *_collect_urls(result)]
+        if collected_urls:
+            detail["urls"] = list(dict.fromkeys(collected_urls))
+        log_service.add(LOG_TYPE_CALL, f"{self.summary}{suffix}", detail)

services/openai_backend_api.py

@@ -1,5 +1,4 @@
 import base64
-import json
 import os
 import re
 import time
@@ -8,15 +7,12 @@ from io import BytesIO
 from pathlib import Path
 from typing import Any, Dict, Iterator, Optional
 
-import tiktoken
 from curl_cffi import requests
 from PIL import Image
 
 from services.account_service import account_service
-from services.anthropic_protocol import message_response, stream_events
-from services.config import config
 from services.proxy_service import proxy_settings
-from utils.helper import build_chat_image_markdown_content, ensure_ok, new_uuid, parse_sse_lines
+from utils.helper import ensure_ok, iter_sse_payloads, new_uuid
 from utils.log import logger
 from utils.pow import build_legacy_requirements_token, build_proof_token, parse_pow_resources
 from utils.turnstile import solve_turnstile_token
@@ -36,7 +32,6 @@ DEFAULT_CLIENT_VERSION = "prod-be885abbfcfe7b1f511e88b3003d9ee44757fbad"
 DEFAULT_CLIENT_BUILD_NUMBER = "5955942"
 DEFAULT_POW_SCRIPT = "https://chatgpt.com/backend-api/sentinel/sdk.js"
 CODEX_IMAGE_MODEL = "codex-gpt-image-2"
-CODEX_RESPONSE_MODEL = "gpt-5.4"
 
 
 class OpenAIBackendAPI:
@@ -47,8 +42,8 @@ class OpenAIBackendAPI:
       例如 `/backend-api/sentinel/chat-requirements`、`/backend-api/conversation`
     - 不传 `access_token` 时，会走未登录链路
       例如 `/backend-anon/sentinel/chat-requirements`、`/backend-anon/conversation`
-    - 对外统一调用 `list_models()`、`chat_completions(...)`
-    - 图片相关接口 `images_generations(...)`、`images_edits(...)` 目前只支持登录态
+    - `stream_conversation()` 是底层统一流式入口
+    - 协议兼容转换放在 `services.protocol`
     """
 
     def __init__(self, access_token: str = "") -> None:
@@ -155,31 +150,6 @@ class OpenAIBackendAPI:
             "Upgrade-Insecure-Requests": "1",
         }
 
-    def _build_requirements_token(self) -> str:
-        """生成 sentinel 接口需要的旧版 requirements token。"""
-        return build_legacy_requirements_token(
-            self.user_agent,
-            script_sources=self.pow_script_sources,
-            data_build=self.pow_data_build,
-        )
-
-    def _get_token_info(self) -> Dict[str, Any]:
-        """从 access token 的 JWT payload 中提取后续请求可能会用到的信息。"""
-        if not self.access_token:
-            return {}
-        parts = self.access_token.split(".")
-        if len(parts) < 2:
-            return {}
-        payload = parts[1]
-        padding = "=" * (-len(payload) % 4)
-        try:
-            decoded = base64.urlsafe_b64decode(payload + padding).decode("utf-8")
-            data = json.loads(decoded)
-        except Exception:
-            return {}
-        auth_data = data.get("https://api.openai.com/auth") or {}
-        return auth_data
-
     def _build_requirements(self, data: Dict[str, Any], source_p: str = "") -> ChatRequirements:
         """把 sentinel 响应整理成后续对话需要的 token 集合。"""
         if (data.get("arkose") or {}).get("required"):
@@ -271,58 +241,17 @@ class OpenAIBackendAPI:
             },
         }
 
-    def _normalize_models(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """把 web models 响应整理成 OpenAI `/v1/models` 风格结构。"""
-        data = []
-        seen = set()
-        for item in payload.get("models", []):
-            if not isinstance(item, dict):
-                continue
-            slug = str(item.get("slug", "")).strip()
-            if not slug or slug in seen:
-                continue
-            seen.add(slug)
-            data.append({
-                "id": slug,
-                "object": "model",
-                "created": int(item.get("created") or 0),
-                "owned_by": str(item.get("owned_by") or "chatgpt"),
-                "permission": [],
-                "root": slug,
-                "parent": None,
-            })
-        data.sort(key=lambda item: item["id"])
-        return {"object": "list", "data": data}
-
-    def _build_image_prompt(self, prompt: str, size: str | None) -> str:
-        """把标准图片 prompt 和宽高比转成底层图片生成 prompt。"""
-        if not size:
-            return prompt
-        if size not in {"1:1", "16:9", "9:16", "4:3", "3:4"}:
-            return f"{prompt.strip()}\n\n输出图片，宽高比为 {size}。"
-        hint = {
-            "1:1": "输出为 1:1 正方形构图，主体居中，适合正方形画幅。",
-            "16:9": "输出为 16:9 横屏构图，适合宽画幅展示。",
-            "9:16": "输出为 9:16 竖屏构图，适合竖版画幅展示。",
-            "4:3": "输出为 4:3 比例，兼顾宽度与高度，适合展示画面细节。",
-            "3:4": "输出为 3:4 比例，纵向构图，适合人物肖像或竖向场景。",
-        }[size]
-        return f"{prompt.strip()}\n\n{hint}"
-
     def _image_model_slug(self, model: str) -> str:
         """把标准图片模型名映射到底层 model slug。"""
         model = str(model or "").strip()
         if not model:
             return "auto"
-        if model in {"gpt-image-1", "gpt-image-2", "gpt-image"}:
+        if model == "gpt-image-2":
             return "gpt-5-3"
         if model == CODEX_IMAGE_MODEL:
             return model
         return "auto"
 
-    def _is_codex_image_model(self, model: str) -> bool:
-        return model == CODEX_IMAGE_MODEL
-
     def _image_headers(self, path: str, requirements: ChatRequirements, conduit_token: str = "", accept: str = "*/*") -> \
             Dict[str, str]:
         """构造图片链路请求头。"""
@@ -385,16 +314,6 @@ class OpenAIBackendAPI:
         payload = image.split(",", 1)[1] if image.startswith("data:") and "," in image else image
         return base64.b64decode(payload)
 
-    def _image_to_data_url(self, image: str) -> str:
-        """把本地图片路径或 base64 图片统一转成 data URL。"""
-        data = self._decode_image_base64(image)
-        try:
-            opened = Image.open(BytesIO(data))
-            mime_type = Image.MIME.get(opened.format, "image/png")
-        except Exception:
-            mime_type = "image/png"
-        return f"data:{mime_type};base64,{base64.b64encode(data).decode()}"
-
     def _upload_image(self, image: str, file_name: str = "image.png") -> Dict[str, Any]:
         """上传一张 base64 图片，返回底层文件元数据。"""
         data = self._decode_image_base64(image)
@@ -528,32 +447,6 @@ class OpenAIBackendAPI:
         ensure_ok(response, path)
         return response
 
-    def _parse_image_sse(self, response: requests.Response) -> Dict[str, Any]:
-        """从图片 SSE 里提取 conversation_id、file_ids、sediment_ids。"""
-        conversation_id = ""
-        file_ids: list[str] = []
-        sediment_ids: list[str] = []
-        for raw_line in response.iter_lines():
-            if not raw_line:
-                continue
-            line = raw_line.decode("utf-8", errors="ignore")
-            if not line.startswith("data:"):
-                continue
-            payload = line[5:].strip()
-            if payload == "[DONE]":
-                break
-            if not conversation_id:
-                match = re.search(r'"conversation_id"\s*:\s*"([^"]+)"', payload)
-                if match:
-                    conversation_id = match.group(1)
-            for file_id in re.findall(r"(file[-_][A-Za-z0-9]+)", payload):
-                if file_id not in file_ids:
-                    file_ids.append(file_id)
-            for sediment_id in re.findall(r"sediment://([A-Za-z0-9_-]+)", payload):
-                if sediment_id not in sediment_ids:
-                    sediment_ids.append(sediment_id)
-        return {"conversation_id": conversation_id, "file_ids": file_ids, "sediment_ids": sediment_ids}
-
     def _get_conversation(self, conversation_id: str) -> Dict[str, Any]:
         """获取完整 conversation 详情。"""
         path = f"/backend-api/conversation/{conversation_id}"
@@ -597,8 +490,10 @@ class OpenAIBackendAPI:
     def _poll_image_results(self, conversation_id: str, timeout_secs: float = 120.0) -> tuple[list[str], list[str]]:
         """轮询 conversation，直到拿到图片文件 id 或超时。"""
         start = time.time()
-        last_sediment_ids: list[str] = []
+        attempt = 0
+        logger.info({"event": "image_poll_start", "conversation_id": conversation_id, "timeout_secs": timeout_secs})
         while time.time() - start < timeout_secs:
+            attempt += 1
             conversation = self._get_conversation(conversation_id)
             file_ids, sediment_ids = [], []
             for record in self._extract_image_tool_records(conversation):
@@ -608,12 +503,17 @@ class OpenAIBackendAPI:
                 for sediment_id in record["sediment_ids"]:
                     if sediment_id not in sediment_ids:
                         sediment_ids.append(sediment_id)
+            logger.debug({"event": "image_poll_check", "conversation_id": conversation_id, "attempt": attempt, "file_ids": file_ids, "sediment_ids": sediment_ids})
             if file_ids:
+                logger.info({"event": "image_poll_hit", "conversation_id": conversation_id, "file_ids": file_ids, "sediment_ids": sediment_ids})
                 return file_ids, sediment_ids
             if sediment_ids:
+                logger.info({"event": "image_poll_hit", "conversation_id": conversation_id, "file_ids": [], "sediment_ids": sediment_ids})
                 return [], sediment_ids
+            logger.debug({"event": "image_poll_wait", "conversation_id": conversation_id, "elapsed_secs": round(time.time() - start, 1)})
             time.sleep(4)
-        return [], last_sediment_ids
+        logger.info({"event": "image_poll_timeout", "conversation_id": conversation_id, "timeout_secs": timeout_secs})
+        return [], []
 
     def _get_file_download_url(self, file_id: str) -> str:
         """获取文件下载地址。"""
@@ -633,15 +533,6 @@ class OpenAIBackendAPI:
         data = response.json()
         return data.get("download_url") or data.get("url") or ""
 
-    def _save_image_bytes(self, image_data: bytes) -> str:
-        config.cleanup_old_images()
-        file_name = f"{int(time.time())}_{new_uuid().replace('-', '')}.png"
-        relative_dir = Path(time.strftime("%Y"), time.strftime("%m"), time.strftime("%d"))
-        file_path = config.images_dir / relative_dir / file_name
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-        file_path.write_bytes(image_data)
-        return f"{config.base_url}/images/{relative_dir.as_posix()}/{file_name}"
-
     def _resolve_image_urls(self, conversation_id: str, file_ids: list[str], sediment_ids: list[str]) -> list[str]:
         """把图片结果 id 解析成可下载 URL。"""
         urls = []
@@ -714,541 +605,48 @@ class OpenAIBackendAPI:
         })
         return urls
 
-    def _image_response(self, urls: list[str], response_format: str) -> Dict[str, Any]:
-        """把图片结果整理成 OpenAI `/v1/images/*` 风格结构。"""
-        if response_format not in {"url", "b64_json"}:
-            raise ValueError("response_format must be 'url' or 'b64_json'")
-        data = []
+    def resolve_conversation_image_urls(
+            self,
+            conversation_id: str,
+            file_ids: list[str],
+            sediment_ids: list[str],
+            poll: bool = True,
+    ) -> list[str]:
+        file_ids = [item for item in file_ids if item != "file_upload"]
+        sediment_ids = list(sediment_ids)
+        if poll and conversation_id and not file_ids and not sediment_ids:
+            logger.info({"event": "image_resolve_poll_needed", "conversation_id": conversation_id})
+            polled_file_ids, polled_sediment_ids = self._poll_image_results(conversation_id)
+            file_ids.extend(item for item in polled_file_ids if item and item not in file_ids)
+            sediment_ids.extend(item for item in polled_sediment_ids if item and item not in sediment_ids)
+        return self._resolve_image_urls(conversation_id, file_ids, sediment_ids)
+
+    def download_image_bytes(self, urls: list[str]) -> list[bytes]:
+        images = []
         for url in urls:
             response = self.session.get(url, timeout=120)
             ensure_ok(response, "image_download")
-            if response_format == "b64_json":
-                data.append({"b64_json": base64.b64encode(response.content).decode()})
-            else:
-                data.append({"url": self._save_image_bytes(response.content)})
-        return {"created": int(time.time()), "data": data}
+            images.append(response.content)
+        return images
 
-    def _run_image_task(self, prompt: str, model: str, size: str | None, images: Optional[list[str]] = None,
-                        response_format: str = "url") -> Dict[str, Any]:
-        """执行图片生成或图片编辑主流程。"""
-        if not self.access_token:
-            raise RuntimeError("access_token is required for image endpoints")
-        logger.debug({
-            "event": "image_task_start",
-            "prompt": prompt,
-            "model": model,
-            "size": size,
-            "image_count": len(images or []),
-        })
-        references = [self._upload_image(image, f"image_{idx}.png") for idx, image in enumerate(images or [], start=1)]
-        logger.debug({"event": "image_references_uploaded", "references": references})
-        self._bootstrap()
-        requirements = self._get_auth_chat_requirements()
-        logger.debug({
-            "event": "image_requirements_ready",
-            "token_present": bool(requirements.token),
-            "proof_token_present": bool(requirements.proof_token),
-            "turnstile_token_present": bool(requirements.turnstile_token),
-            "so_token_present": bool(requirements.so_token),
-            "raw_finalize": requirements.raw_finalize,
-        })
-        final_prompt = self._build_image_prompt(prompt, size)
-        logger.debug({"event": "image_final_prompt", "final_prompt": final_prompt})
-        conduit_token = self._prepare_image_conversation(final_prompt, requirements, model)
-        logger.debug({"event": "image_conduit_ready", "conduit_token_present": bool(conduit_token)})
-        sse = self._start_image_generation(final_prompt, requirements, conduit_token, model, references)
-        sse_result = self._parse_image_sse(sse)
-        logger.debug({"event": "image_sse_result", "sse_result": sse_result})
-        conversation_id = sse_result["conversation_id"]
-        file_ids = list(sse_result["file_ids"])
-        sediment_ids = list(sse_result["sediment_ids"])
-        invalid_file_id_patterns = {"file_upload"}
-        file_ids = [fid for fid in file_ids if fid not in invalid_file_id_patterns]
-        if conversation_id and not file_ids and not sediment_ids:
-            polled_file_ids, polled_sediment_ids = self._poll_image_results(conversation_id)
-            file_ids.extend([item for item in polled_file_ids if item not in file_ids])
-            sediment_ids.extend([item for item in polled_sediment_ids if item not in sediment_ids])
-            logger.debug({
-                "event": "image_polled_result",
-                "conversation_id": conversation_id,
-                "file_ids": polled_file_ids,
-                "sediment_ids": polled_sediment_ids,
-            })
-            try:
-                conversation = self._get_conversation(conversation_id)
-                logger.debug({
-                    "event": "image_conversation_snapshot",
-                    "conversation_id": conversation_id,
-                    "conversation": conversation,
-                })
-            except Exception as exc:
-                logger.debug({
-                    "event": "image_conversation_snapshot_failed",
-                    "conversation_id": conversation_id,
-                    "error": repr(exc),
-                })
-        logger.debug({
-            "event": "image_resolved_ids",
-            "conversation_id": conversation_id,
-            "file_ids": file_ids,
-            "sediment_ids": sediment_ids,
-        })
-        urls = self._resolve_image_urls(conversation_id, file_ids, sediment_ids)
-        logger.debug({"event": "image_final_urls", "conversation_id": conversation_id, "urls": urls})
-        if not urls:
-            raise RuntimeError(
-                "no downloadable image result found; "
-                f"conversation_id={conversation_id}, file_ids={file_ids}, sediment_ids={sediment_ids}"
-            )
-        return self._image_response(urls, response_format)
-
-    def _build_codex_response_input(self, prompt: str, images: Optional[list[str]] = None) -> list[Dict[str, Any]]:
-        if not images:
-            return [{"role": "user", "content": prompt}]
-        content = [{"type": "input_text", "text": prompt}]
-        for image in images:
-            content.append({"type": "input_image", "image_url": self._image_to_data_url(image)})
-        return [{"role": "user", "content": content}]
-
-    def _collect_codex_events(self, prompt: str, model: str = CODEX_IMAGE_MODEL,
-                              images: Optional[list[str]] = None) -> list[Dict[str, Any]]:
-        events = list(self.responses(
-            input=self._build_codex_response_input(prompt, images),
-            model=model,
-            stream=True,
-        ))
-        logger.debug({"event": "codex_responses_events_collected", "event_count": len(events)})
-        return events
-
-    def _codex_image_response(self, events: list[Dict[str, Any]], response_format: str) -> Dict[str, Any]:
-        if response_format not in {"url", "b64_json"}:
-            raise ValueError("response_format must be 'url' or 'b64_json'")
-        image_item = {}
-        response_payload = {}
-        for event in events:
-            if not isinstance(event, dict):
-                continue
-            if event.get("type") == "response.output_item.done":
-                item = event.get("item") or {}
-                if item.get("type") == "image_generation_call" and item.get("result"):
-                    image_item = item
-            elif event.get("type") == "response.completed":
-                response_payload = event.get("response") or {}
-        image_b64 = image_item.get("result", "")
-        if not image_b64:
-            raise RuntimeError("codex responses did not return image base64 result")
-        data = []
-        if response_format == "b64_json":
-            data.append({"b64_json": image_b64})
-        else:
-            data.append({"url": self._save_image_bytes(base64.b64decode(image_b64))})
-        return {
-            "created": response_payload.get("created_at") or int(time.time()),
-            "data": data,
-            "model": response_payload.get("model") or CODEX_RESPONSE_MODEL,
-            "usage": response_payload.get("usage"),
-            "tool_usage": response_payload.get("tool_usage"),
-            "response_id": response_payload.get("id"),
-            "status": response_payload.get("status"),
-            "revised_prompt": image_item.get("revised_prompt"),
-            "size": image_item.get("size"),
-            "output_format": image_item.get("output_format"),
-            "response": response_payload,
-        }
-
-    def _run_codex_image_task(self, prompt: str, response_format: str = "url",
-                              images: Optional[list[str]] = None) -> Dict[str, Any]:
-        logger.debug({"event": "codex_image_task_start", "prompt": prompt, "image_count": len(images or [])})
-        events = self._collect_codex_events(prompt=prompt, model=CODEX_IMAGE_MODEL, images=images)
-        result = self._codex_image_response(events, response_format)
-        logger.debug({
-            "event": "codex_image_task_done",
-            "response_id": result.get("response_id"),
-            "status": result.get("status"),
-            "usage": result.get("usage"),
-            "tool_usage": result.get("tool_usage"),
-        })
-        return result
-
-    def _extract_text_from_events(self, events: list[Dict[str, Any]]) -> str:
-        """从 SSE 事件中提取最终 assistant 文本。"""
-        for event in reversed(events):
-            message = event.get("message") or {}
-            if (message.get("author") or {}).get("role") != "assistant":
-                continue
-            text = self._text_from_message(message)
-            if text.strip():
-                return text
-        return ""
-
-    @staticmethod
-    def _strip_history_prefix(text: str, history_text: str) -> str:
-        history_text = str(history_text or "")
-        text = str(text or "")
-        if history_text and text.startswith(history_text):
-            return text[len(history_text):]
-        return text
-
-    def _normalize_assistant_text(self, text: str, history_text: str) -> str:
-        return self._strip_history_prefix(text, history_text)
-
-    def _text_from_message(self, message: Dict[str, Any]) -> str:
-        """从单条 message 结构中提取文本。"""
-        content = message.get("content") or {}
-        parts = content.get("parts") or []
-        if not isinstance(parts, list):
-            return ""
-        texts = [part for part in parts if isinstance(part, str)]
-        if texts:
-            return "".join(texts)
-        return ""
-
-    @staticmethod
-    def _append_unique(values: list[str], candidates: list[str]) -> None:
-        for candidate in candidates:
-            if candidate and candidate not in values:
-                values.append(candidate)
-
-    @staticmethod
-    def _extract_image_stream_ids(payload: str) -> tuple[list[str], list[str]]:
-        file_ids = re.findall(r"(file[-_][A-Za-z0-9]+)", payload)
-        sediment_ids = re.findall(r"sediment://([A-Za-z0-9_-]+)", payload)
-        return file_ids, sediment_ids
-
-    @staticmethod
-    def _extract_image_stream_conversation_id(payload: str) -> str:
-        match = re.search(r'"conversation_id"\s*:\s*"([^"]+)"', payload)
-        return match.group(1) if match else ""
-
-    def _next_image_stream_text(self, event: Dict[str, Any], current_text: str) -> str:
-        for candidate in (event, event.get("v")):
-            if not isinstance(candidate, dict):
-                continue
-            message = candidate.get("message")
-            if not isinstance(message, dict):
-                continue
-            role = str((message.get("author") or {}).get("role") or "").strip().lower()
-            if role == "user":
-                continue
-            text = self._text_from_message(message)
-            if text:
-                return text
-        return self._apply_text_patch(event, current_text)
-
-    def stream_image_chat_completions(
-        self,
-        prompt: str,
-        model: str = "gpt-image-2",
-        size: str | None = None,
-        images: Optional[list[str]] = None,
-    ) -> Iterator[Dict[str, Any]]:
-        if not self.access_token:
-            raise RuntimeError("access_token is required for image endpoints")
-
-        completion_id = f"chatcmpl-{new_uuid()}"
-        created = int(time.time())
-        current_text = ""
-        sent_role = False
-        conversation_id = ""
-        file_ids: list[str] = []
-        sediment_ids: list[str] = []
-
-        references = [self._upload_image(image, f"image_{idx}.png") for idx, image in enumerate(images or [], start=1)]
+    def stream_conversation(
+            self,
+            messages: Optional[list[Dict[str, Any]]] = None,
+            model: str = "auto",
+            prompt: str = "",
+            images: Optional[list[str]] = None,
+            system_hints: Optional[list[str]] = None,
+    ) -> Iterator[str]:
+        system_hints = system_hints or []
+        if "picture_v2" in system_hints:
+            yield from self._stream_picture_conversation(prompt, model, images or [])
+            return
+
+        normalized = messages or [{"role": "user", "content": prompt}]
         self._bootstrap()
-        requirements = self._get_auth_chat_requirements()
-        final_prompt = self._build_image_prompt(prompt, size)
-        conduit_token = self._prepare_image_conversation(final_prompt, requirements, model)
-        sse = self._start_image_generation(final_prompt, requirements, conduit_token, model, references)
-        try:
-            for raw_line in sse.iter_lines():
-                if not raw_line:
-                    continue
-                line = raw_line.decode("utf-8", errors="ignore") if isinstance(raw_line, bytes) else str(raw_line)
-                if not line.startswith("data:"):
-                    continue
-                payload = line[5:].strip()
-                if not payload:
-                    continue
-                if payload == "[DONE]":
-                    break
-
-                if not conversation_id:
-                    conversation_id = self._extract_image_stream_conversation_id(payload)
-                new_file_ids, new_sediment_ids = self._extract_image_stream_ids(payload)
-                self._append_unique(file_ids, new_file_ids)
-                self._append_unique(sediment_ids, new_sediment_ids)
-
-                try:
-                    event = json.loads(payload)
-                except json.JSONDecodeError:
-                    continue
-                if not isinstance(event, dict):
-                    continue
-
-                conversation_id = str(event.get("conversation_id") or conversation_id)
-                value = event.get("v")
-                if isinstance(value, dict):
-                    conversation_id = str(value.get("conversation_id") or conversation_id)
-
-                next_text = self._next_image_stream_text(event, current_text)
-                if next_text == current_text:
-                    yield {
-                        "id": completion_id,
-                        "object": "chat.completion.chunk",
-                        "created": created,
-                        "model": model,
-                        "choices": [{
-                            "index": 0,
-                            "delta": {},
-                            "finish_reason": None,
-                        }],
-                        "upstream_event": event,
-                    }
-                    continue
-
-                delta = next_text[len(current_text):] if next_text.startswith(current_text) else next_text
-                current_text = next_text
-                if not sent_role:
-                    sent_role = True
-                    yield {
-                        "id": completion_id,
-                        "object": "chat.completion.chunk",
-                        "created": created,
-                        "model": model,
-                        "choices": [{
-                            "index": 0,
-                            "delta": {"role": "assistant", "content": delta},
-                            "finish_reason": None,
-                        }],
-                        "upstream_event": event,
-                    }
-                    continue
-
-                yield {
-                    "id": completion_id,
-                    "object": "chat.completion.chunk",
-                    "created": created,
-                    "model": model,
-                    "choices": [{
-                        "index": 0,
-                        "delta": {"content": delta},
-                        "finish_reason": None,
-                    }],
-                    "upstream_event": event,
-                }
-        finally:
-            sse.close()
-
-        invalid_file_id_patterns = {"file_upload"}
-        file_ids = [fid for fid in file_ids if fid not in invalid_file_id_patterns]
-        if conversation_id and not file_ids and not sediment_ids:
-            polled_file_ids, polled_sediment_ids = self._poll_image_results(conversation_id)
-            self._append_unique(file_ids, polled_file_ids)
-            self._append_unique(sediment_ids, polled_sediment_ids)
-
-        urls = self._resolve_image_urls(conversation_id, file_ids, sediment_ids)
-        if not urls:
-            raise RuntimeError(
-                "no downloadable image result found; "
-                f"conversation_id={conversation_id}, file_ids={file_ids}, sediment_ids={sediment_ids}"
-            )
-
-        image_content = build_chat_image_markdown_content(self._image_response(urls, "b64_json"))
-        if not sent_role:
-            sent_role = True
-            yield {
-                "id": completion_id,
-                "object": "chat.completion.chunk",
-                "created": created,
-                "model": model,
-                "choices": [{
-                    "index": 0,
-                    "delta": {"role": "assistant", "content": image_content},
-                    "finish_reason": None,
-                }],
-            }
-        else:
-            yield {
-                "id": completion_id,
-                "object": "chat.completion.chunk",
-                "created": created,
-                "model": model,
-                "choices": [{
-                    "index": 0,
-                    "delta": {"content": image_content},
-                    "finish_reason": None,
-                }],
-            }
-        yield {
-            "id": completion_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [{
-                "index": 0,
-                "delta": {},
-                "finish_reason": "stop",
-            }],
-        }
-
-    def _apply_text_patch(self, event: Dict[str, Any], current_text: str, history_text: str = "") -> str:
-        """从 patch 事件里恢复最新文本。"""
-        operations = event.get("v")
-        if not isinstance(operations, list):
-            return current_text
-        text = current_text
-        for item in operations:
-            if not isinstance(item, dict):
-                continue
-            if item.get("p") != "/message/content/parts/0":
-                continue
-            if item.get("o") == "append":
-                text += str(item.get("v", ""))
-            if item.get("o") == "replace":
-                text = self._normalize_assistant_text(str(item.get("v", "")), history_text)
-        return text
-
-    def _next_assistant_text(self, event: Dict[str, Any], current_text: str, history_text: str = "") -> str:
-        """从 SSE 事件中推导当前 assistant 全量文本。"""
-        message = event.get("message")
-        if isinstance(message, dict) and (message.get("author") or {}).get("role") == "assistant":
-            text = self._text_from_message(message)
-            if text:
-                return self._normalize_assistant_text(text, history_text)
-
-        value = event.get("v")
-        if isinstance(value, dict):
-            message = value.get("message")
-            if isinstance(message, dict) and (message.get("author") or {}).get("role") == "assistant":
-                text = self._text_from_message(message)
-                if text:
-                    return self._normalize_assistant_text(text, history_text)
-
-        return self._apply_text_patch(event, current_text, history_text)
-
-    def _encoding_for_model(self, model: str):
-        """按模型选择 tokenizer，失败时回退到通用编码。"""
-        try:
-            return tiktoken.encoding_for_model(model)
-        except KeyError:
-            try:
-                return tiktoken.get_encoding("o200k_base")
-            except KeyError:
-                return tiktoken.get_encoding("cl100k_base")
-
-    def _count_message_tokens(self, messages: list[Dict[str, Any]], model: str) -> int:
-        """估算标准 chat messages 的 token 数。"""
-        encoding = self._encoding_for_model(model)
-        tokens_per_message = 3
-        total = 0
-        for message in messages:
-            total += tokens_per_message
-            for key, value in message.items():
-                if not isinstance(value, str):
-                    continue
-                total += len(encoding.encode(value))
-                if key == "name":
-                    total += 1
-        return total + 3
-
-    def _count_text_tokens(self, text: str, model: str) -> int:
-        """估算单段文本的 token 数。"""
-        return len(self._encoding_for_model(model).encode(text))
-
-    def _extract_message_text(self, content: Any) -> str:
-        """从 OpenAI/Anthropic 风格的 content 字段里提取纯文本。"""
-        if isinstance(content, str):
-            return content
-        if isinstance(content, list):
-            parts = []
-            for item in content:
-                if isinstance(item, str):
-                    parts.append(item)
-                    continue
-                if not isinstance(item, dict):
-                    raise RuntimeError("only string or text content blocks are supported")
-                block_type = item.get("type")
-                if block_type in {"text", "input_text", "output_text"}:
-                    parts.append(str(item.get("text", "")))
-                    continue
-                raise RuntimeError(f"unsupported content block type: {block_type}")
-            return "".join(parts)
-        if content is None:
-            return ""
-        raise RuntimeError("only string or text content blocks are supported")
-
-    def _normalize_messages(self, messages: list[Dict[str, Any]], system: Any = None) -> list[Dict[str, Any]]:
-        """把 OpenAI/Anthropic 风格的消息统一整理成标准 chat messages。"""
-        normalized = []
-        if system is not None:
-            system_text = self._extract_message_text(system)
-            if system_text:
-                normalized.append({"role": "system", "content": system_text})
-
-        for item in messages:
-            normalized.append({
-                "role": item.get("role", "user"),
-                "content": self._extract_message_text(item.get("content", "")),
-            })
-        return normalized
-
-    def _assistant_history_text(self, messages: list[Dict[str, Any]]) -> str:
-        """获取输入历史里所有 assistant 文本拼接结果。"""
-        parts = []
-        for message in messages:
-            if message.get("role") != "assistant":
-                continue
-            content = message.get("content", "")
-            if isinstance(content, str) and content:
-                parts.append(content)
-        return "".join(parts)
-
-    def _assistant_history_messages(self, messages: list[Dict[str, Any]]) -> list[str]:
-        parts = []
-        for message in messages:
-            if message.get("role") != "assistant":
-                continue
-            content = message.get("content", "")
-            if isinstance(content, str) and content:
-                parts.append(content)
-        return parts
-
-    def _event_assistant_text(self, event: Dict[str, Any], history_text: str = "") -> str:
-        message = event.get("message")
-        if isinstance(message, dict) and (message.get("author") or {}).get("role") == "assistant":
-            return self._normalize_assistant_text(self._text_from_message(message), history_text)
-
-        value = event.get("v")
-        if isinstance(value, dict):
-            message = value.get("message")
-            if isinstance(message, dict) and (message.get("author") or {}).get("role") == "assistant":
-                return self._normalize_assistant_text(self._text_from_message(message), history_text)
-
-        return ""
-
-    def _last_event(self, events: list[Dict[str, Any]]) -> Dict[str, Any]:
-        """返回最后一个非终止事件，方便排查问题。"""
-        for event in reversed(events):
-            if not event.get("done"):
-                return event
-        return {}
-
-    def _conversation_payload_debug(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        raw = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
-        messages = payload.get("messages") if isinstance(payload.get("messages"), list) else []
-        details = []
-        for item in messages:
-            content = item.get("content") if isinstance(item, dict) else {}
-            parts = content.get("parts") if isinstance(content, dict) else []
-            text = "\n".join(str(part) for part in parts) if isinstance(parts, list) else ""
-            details.append({"role": (item.get("author") or {}).get("role") if isinstance(item, dict) and isinstance(item.get("author"), dict) else "", "chars": len(text), "preview": text[:120]})
-        return {"bytes": len(raw.encode("utf-8")), "chars": len(raw), "message_count": len(messages), "messages": details}
-
-    def _stream_events(self, path: str, requirements: ChatRequirements, payload: Dict[str, Any]) -> Iterator[
-        Dict[str, Any]]:
-        """向 conversation 接口发起请求，并逐条产出 SSE 事件。"""
-        payload_debug = self._conversation_payload_debug(payload)
-        logger.info({"event": "conversation_payload_debug", "path": path, **payload_debug})
+        requirements = self._get_chat_requirements()
+        path, timezone = self._chat_target()
+        payload = self._conversation_payload(normalized, model, timezone)
         response = self.session.post(
             self.base_url + path,
             headers=self._conversation_headers(path, requirements),
@@ -1256,10 +654,29 @@ class OpenAIBackendAPI:
             timeout=300,
             stream=True,
         )
-        if response.status_code >= 400:
-            logger.warning({"event": "conversation_request_failed", "path": path, "status_code": response.status_code, "payload": payload_debug, "response_text": response.text[:500]})
         ensure_ok(response, path)
-        yield from parse_sse_lines(response)
+        try:
+            yield from iter_sse_payloads(response)
+        finally:
+            response.close()
+
+    def _stream_picture_conversation(
+            self,
+            prompt: str,
+            model: str,
+            images: list[str],
+    ) -> Iterator[str]:
+        if not self.access_token:
+            raise RuntimeError("access_token is required for image endpoints")
+        references = [self._upload_image(image, f"image_{idx}.png") for idx, image in enumerate(images, start=1)]
+        self._bootstrap()
+        requirements = self._get_chat_requirements()
+        conduit_token = self._prepare_image_conversation(prompt, requirements, model)
+        response = self._start_image_generation(prompt, requirements, conduit_token, model, references)
+        try:
+            yield from iter_sse_payloads(response)
+        finally:
+            response.close()
 
     def _bootstrap(self) -> None:
         """预热首页，并提取 PoW 相关脚本引用。"""
@@ -1273,13 +690,11 @@ class OpenAIBackendAPI:
         if not self.pow_script_sources:
             self.pow_script_sources = [DEFAULT_POW_SCRIPT]
 
-    def _get_chat_requirements(self, authenticated: bool) -> ChatRequirements:
+    def _get_chat_requirements(self) -> ChatRequirements:
         """获取当前模式对话所需的 sentinel token。"""
-        if authenticated and not self.access_token:
-            raise RuntimeError("access_token is required for auth chat")
-        path = "/backend-api/sentinel/chat-requirements" if authenticated else "/backend-anon/sentinel/chat-requirements"
-        context = "auth_chat_requirements" if authenticated else "noauth_chat_requirements"
-        body = {"p": self._build_requirements_token()}
+        path = "/backend-api/sentinel/chat-requirements" if self.access_token else "/backend-anon/sentinel/chat-requirements"
+        context = "auth_chat_requirements" if self.access_token else "noauth_chat_requirements"
+        body = {"p": build_legacy_requirements_token(self.user_agent, self.pow_script_sources, self.pow_data_build)}
         response = self.session.post(
             self.base_url + path,
             headers=self._headers(path, {"Content-Type": "application/json"}),
@@ -1287,292 +702,48 @@ class OpenAIBackendAPI:
             timeout=30,
         )
         ensure_ok(response, context)
-        requirements = self._build_requirements(response.json(), "" if authenticated else body["p"])
+        requirements = self._build_requirements(response.json(), "" if self.access_token else body["p"])
         if not requirements.token:
-            message = "missing auth chat requirements token" if authenticated else "missing chat requirements token"
+            message = "missing auth chat requirements token" if self.access_token else "missing chat requirements token"
             raise RuntimeError(f"{message}: {requirements.raw_finalize}")
         return requirements
 
-    def _get_auth_chat_requirements(self) -> ChatRequirements:
-        return self._get_chat_requirements(authenticated=True)
-
-    def _get_anon_chat_requirements(self) -> ChatRequirements:
-        return self._get_chat_requirements(authenticated=False)
+    def _chat_target(self) -> tuple[str, str]:
+        if self.access_token:
+            return "/backend-api/conversation", "Asia/Shanghai"
+        return "/backend-anon/conversation", "America/Los_Angeles"
 
-    def _get_models_raw(self, authenticated: bool) -> Dict[str, Any]:
-        """获取当前模式模型列表原始响应。"""
-        if authenticated and not self.access_token:
-            raise RuntimeError("access_token is required for auth models")
+    def list_models(self) -> Dict[str, Any]:
+        """返回当前模式下可用模型，格式对齐 OpenAI `/v1/models`。"""
         self._bootstrap()
-        path = "/backend-api/models?history_and_training_disabled=false" if authenticated else (
+        path = "/backend-api/models?history_and_training_disabled=false" if self.access_token else (
             "/backend-anon/models?iim=false&is_gizmo=false"
         )
-        route = "/backend-api/models" if authenticated else "/backend-anon/models"
-        context = "auth_models" if authenticated else "anon_models"
+        route = "/backend-api/models" if self.access_token else "/backend-anon/models"
+        context = "auth_models" if self.access_token else "anon_models"
         response = self.session.get(
             self.base_url + path,
             headers=self._headers(route),
             timeout=30,
         )
         ensure_ok(response, context)
-        return response.json()
-
-    def _chat_target(self) -> tuple[str, str]:
-        if self.access_token:
-            return "/backend-api/conversation", "Asia/Shanghai"
-        return "/backend-anon/conversation", "America/Los_Angeles"
-
-    def _complete_chat(self, messages: list[Dict[str, Any]], model: str) -> Dict[str, Any]:
-        self._bootstrap()
-        requirements = self._get_chat_requirements(authenticated=bool(self.access_token))
-        path, timezone = self._chat_target()
-        events = list(self._stream_events(path, requirements, self._conversation_payload(messages, model, timezone)))
-        history_assistant_text = self._assistant_history_text(messages)
-        return {
-            "requirements": requirements,
-            "prepare": {},
-            "events": events,
-            "last_event": self._last_event(events),
-            "text": self._strip_history_prefix(self._extract_text_from_events(events), history_assistant_text),
-        }
-
-    def list_models(self) -> Dict[str, Any]:
-        """返回当前模式下可用模型，格式对齐 OpenAI `/v1/models`。"""
-        return self._normalize_models(self._get_models_raw(authenticated=bool(self.access_token)))
-
-    def images_generations(self, prompt: str, model: str = "gpt-image-2", size: str | None = None,
-                           response_format: str = "url") -> Dict[str, Any]:
-        """返回 OpenAI `/v1/images/generations` 风格结果。"""
-        if self._is_codex_image_model(model):
-            return self._run_codex_image_task(prompt, response_format=response_format)
-        return self._run_image_task(prompt, model, size, response_format=response_format)
-
-    def images_edits(self, image: str | list[str], prompt: str, model: str = "gpt-image-2", size: str | None = None,
-                     response_format: str = "url") -> Dict[str, Any]:
-        """返回 OpenAI `/v1/images/edits` 风格结果。"""
-        images = [image] if isinstance(image, str) else image
-        if not images:
-            raise ValueError("image is required for image edits")
-        if self._is_codex_image_model(model):
-            return self._run_codex_image_task(prompt, response_format=response_format, images=images)
-        return self._run_image_task(prompt, model, size, images=images, response_format=response_format)
-
-    def _chat_completion_response(self, model: str, messages: list[Dict[str, Any]], text: str) -> Dict[str, Any]:
-        """把对话结果整理成 OpenAI `/v1/chat/completions` 风格结构。"""
-        prompt_tokens = self._count_message_tokens(messages, model)
-        completion_tokens = self._count_text_tokens(text, model)
-        return {
-            "id": f"chatcmpl-{new_uuid()}",
-            "object": "chat.completion",
-            "created": int(time.time()),
-            "model": model,
-            "choices": [{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": text,
-                },
-                "finish_reason": "stop",
-            }],
-            "usage": {
-                "prompt_tokens": prompt_tokens,
-                "completion_tokens": completion_tokens,
-                "total_tokens": prompt_tokens + completion_tokens,
-            },
-        }
-
-    def _stream_chat_completions(self, messages: list[Dict[str, Any]], model: str = "auto") -> Iterator[Dict[str, Any]]:
-        """返回 OpenAI `/v1/chat/completions` 风格的流式 chunk。"""
-        completion_id = f"chatcmpl-{new_uuid()}"
-        created = int(time.time())
-        history_assistant_text = self._assistant_history_text(messages)
-        history_assistant_messages = self._assistant_history_messages(messages)
-        history_assistant_index = 0
-        current_text = ""
-        sent_role = False
-        self._bootstrap()
-        requirements = self._get_chat_requirements(authenticated=bool(self.access_token))
-        path, timezone = self._chat_target()
-        payload = self._conversation_payload(messages, model, timezone)
-
-        for event in self._stream_events(path, requirements, payload):
-            if event.get("done"):
-                break
-            event_assistant_text = self._event_assistant_text(event, history_assistant_text)
-            if (
-                history_assistant_index < len(history_assistant_messages)
-                and event_assistant_text
-                and event_assistant_text == history_assistant_messages[history_assistant_index]
-            ):
-                history_assistant_index += 1
-                current_text = ""
-                continue
-            next_text = self._next_assistant_text(event, current_text, history_assistant_text)
-            if next_text == current_text:
-                continue
-            delta = next_text[len(current_text):] if next_text.startswith(current_text) else next_text
-            current_text = next_text
-            if not sent_role:
-                sent_role = True
-                yield {
-                    "id": completion_id,
-                    "object": "chat.completion.chunk",
-                    "created": created,
-                    "model": model,
-                    "choices": [{
-                        "index": 0,
-                        "delta": {"role": "assistant", "content": delta},
-                        "finish_reason": None,
-                    }],
-                }
-                continue
-            yield {
-                "id": completion_id,
-                "object": "chat.completion.chunk",
-                "created": created,
-                "model": model,
-                "choices": [{
-                    "index": 0,
-                    "delta": {"content": delta},
-                    "finish_reason": None,
-                }],
-            }
-
-        if not sent_role:
-            yield {
-                "id": completion_id,
-                "object": "chat.completion.chunk",
-                "created": created,
-                "model": model,
-                "choices": [{
-                    "index": 0,
-                    "delta": {"role": "assistant", "content": ""},
-                    "finish_reason": None,
-                }],
-            }
-        yield {
-            "id": completion_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [{
-                "index": 0,
-                "delta": {},
-                "finish_reason": "stop",
-            }],
-        }
-
-    def _anthropic_message_response(self, model: str, messages: list[Dict[str, Any]], text: str, tools: Any = None) -> Dict[str, Any]:
-        """把对话结果整理成 Anthropic `/v1/messages` 风格结构。"""
-        return message_response(model, text, self._count_message_tokens(messages, model), self._count_text_tokens(text, model), tools)
-
-    def _stream_anthropic_messages(self, messages: list[Dict[str, Any]], model: str = "auto", tools: Any = None) -> Iterator[
-        Dict[str, Any]]:
-        """返回 Anthropic `/v1/messages` 风格的流式事件。"""
-        yield from stream_events(self._stream_chat_completions(messages, model), model, self._count_message_tokens(messages, model), lambda text: self._count_text_tokens(text, model), tools)
-
-    def _iter_response_events(self, response: requests.Response) -> Iterator[Dict[str, Any]]:
-        """按 Responses 接口事件格式直通输出，不额外包装标准事件。"""
-        for raw_line in response.iter_lines():
-            if not raw_line:
-                continue
-            line = raw_line.decode("utf-8", errors="ignore")
-            if not line.startswith("data:"):
+        data = []
+        seen = set()
+        for item in response.json().get("models", []):
+            if not isinstance(item, dict):
                 continue
-            payload = line[5:].strip()
-            if not payload or payload == "[DONE]":
+            slug = str(item.get("slug", "")).strip()
+            if not slug or slug in seen:
                 continue
-            yield json.loads(payload)
-
-    def responses(
-            self,
-            input: str | list[Dict[str, Any]],
-            model: str = CODEX_RESPONSE_MODEL,
-            tools: Optional[list[Dict[str, Any]]] = None,
-            instructions: str = "you are a helpful assistant",
-            tool_choice: str = "auto",
-            stream: bool = False,
-            store: bool = False,
-    ) -> Dict[str, Any] | Iterator[Dict[str, Any]]:
-        """返回 `/v1/responses` 风格结果，底层走 `/backend-api/codex/responses`。"""
-        if not self.access_token:
-            raise RuntimeError("access_token is required for responses")
-        path = "/backend-api/codex/responses"
-        token_info = self._get_token_info()
-        input_items = [{"role": "user", "content": input}] if isinstance(input, str) else input
-        effective_model = CODEX_RESPONSE_MODEL if self._is_codex_image_model(model) else model
-        effective_tools = tools
-        if self._is_codex_image_model(model) and not effective_tools:
-            effective_tools = [{"type": "image_generation", "output_format": "png"}]
-        payload = {
-            "model": effective_model,
-            "input": input_items,
-            "tools": effective_tools or [],
-            "instructions": instructions,
-            "tool_choice": tool_choice,
-            "stream": stream,
-            "store": store,
-        }
-        logger.debug({
-            "event": "responses_start",
-            "model": model,
-            "effective_model": effective_model,
-            "stream": stream,
-            "input_count": len(input_items),
-            "tool_count": len(payload["tools"]),
-            "token_info": token_info,
-        })
-        headers = {
-            "Authorization": f"Bearer {self.access_token}",
-            "user-agent": (
-                "codex-tui/0.122.0 (Manjaro 26.1.0-pre; x86_64) "
-                "vscode/3.0.12 (codex-tui; 0.122.0)"
-            ),
-            "version": "0.122.0",
-            "originator": "codex_cli_rs",
-            "session_id": "test-session",
-            "accept": "text/event-stream" if stream else "application/json",
-            "Content-Type": "application/json",
-        }
-        if token_info.get("chatgpt_account_id"):
-            headers["chatgpt-account-id"] = token_info["chatgpt_account_id"]
-        response = self.session.post(
-            self.base_url + path,
-            headers=headers,
-            json=payload,
-            timeout=300,
-            stream=stream,
-        )
-        if response.status_code >= 400:
-            logger.debug({
-                "event": "responses_failed",
-                "status_code": response.status_code,
-                "headers": dict(response.headers),
-                "body": response.text,
+            seen.add(slug)
+            data.append({
+                "id": slug,
+                "object": "model",
+                "created": int(item.get("created") or 0),
+                "owned_by": str(item.get("owned_by") or "chatgpt"),
+                "permission": [],
+                "root": slug,
+                "parent": None,
             })
-        ensure_ok(response, path)
-        if stream:
-            return self._iter_response_events(response)
-        return response.json()
-
-    def chat_completions(
-            self,
-            messages: list[Dict[str, Any]],
-            model: str = "auto",
-            stream: bool = False,
-    ) -> Dict[str, Any] | Iterator[Dict[str, Any]]:
-        """返回 OpenAI `/v1/chat/completions` 风格结果，支持 stream 模式。"""
-        normalized_messages = self._normalize_messages(messages)
-        if stream:
-            return self._stream_chat_completions(normalized_messages, model)
-        result = self._complete_chat(normalized_messages, model)
-        return self._chat_completion_response(model, normalized_messages, result["text"])
-
-    def messages(self, messages: list[Dict[str, Any]], model: str = "auto", stream: bool = False,
-                 system: Any = None, tools: Any = None) -> Dict[str, Any] | Iterator[Dict[str, Any]]:
-        """返回 Anthropic `/v1/messages` 风格结果，支持 stream 模式。"""
-        normalized_messages = self._normalize_messages(messages, system)
-        if stream:
-            return self._stream_anthropic_messages(normalized_messages, model, tools)
-        result = self._complete_chat(normalized_messages, model)
-        return self._anthropic_message_response(model, normalized_messages, result["text"], tools)
+        data.sort(key=lambda item: item["id"])
+        return {"object": "list", "data": data}

services/protocol/__init__.py

@@ -0,0 +1,2 @@
+"""Protocol converters for OpenAI-compatible endpoints."""
+

services/{anthropic_protocol.py → protocol/anthropic_v1_messages.py}

@@ -6,12 +6,26 @@ import re
 import time
 import uuid
 from collections.abc import Callable, Iterable, Iterator
+from dataclasses import dataclass
 from typing import Any
 
+from services.account_service import account_service
+from services.openai_backend_api import OpenAIBackendAPI
+from services.protocol.conversation import count_message_tokens, count_text_tokens, normalize_messages
+from services.protocol.openai_v1_chat_complete import collect_chat_content, stream_text_chat_completion
+
 XML_TOOL_RULE = """Tool output adapter: when calling tools, output ONLY this XML and no prose/markdown:
 <tool_calls><tool_call><tool_name>TOOL_NAME</tool_name><parameters><PARAM><![CDATA[value]]></PARAM></parameters></tool_call></tool_calls>"""
 
 
+@dataclass
+class MessageRequest:
+    backend: OpenAIBackendAPI
+    messages: list[dict[str, Any]]
+    model: str
+    tools: Any = None
+
+
 def _tool_meta(tool: dict[str, object]) -> tuple[str, str, object]:
     fn = tool.get("function") if isinstance(tool.get("function"), dict) else {}
     name = str(tool.get("name") or fn.get("name") or "").strip()
@@ -93,6 +107,16 @@ def preprocess_payload(payload: dict[str, object], text_mapper: Callable[[str],
     return payload
 
 
+def message_request(body: dict[str, Any]) -> MessageRequest:
+    payload = preprocess_payload(dict(body))
+    return MessageRequest(
+        backend=OpenAIBackendAPI(access_token=account_service.get_text_access_token()),
+        messages=normalize_messages(payload.get("messages"), payload.get("system")),
+        model=str(payload.get("model") or "auto").strip() or "auto",
+        tools=payload.get("tools"),
+    )
+
+
 def preprocess_messages(messages: object, text_mapper: Callable[[str], str] | None = None) -> object:
     if not isinstance(messages, list):
         return messages
@@ -260,3 +284,23 @@ def _stream_buffered_blocks(content: list[dict[str, object]], start_index: int =
         yield {"type": "content_block_start", "index": index, "content_block": start}
         yield {"type": "content_block_delta", "index": index, "delta": delta}
         yield {"type": "content_block_stop", "index": index}
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    request = message_request(body)
+    if body.get("stream"):
+        return stream_events(
+            stream_text_chat_completion(request.backend, request.messages, request.model),
+            request.model,
+            count_message_tokens(request.messages, request.model),
+            lambda text: count_text_tokens(text, request.model),
+            request.tools,
+        )
+    text = collect_chat_content(stream_text_chat_completion(request.backend, request.messages, request.model))
+    return message_response(
+        request.model,
+        text,
+        count_message_tokens(request.messages, request.model),
+        count_text_tokens(text, request.model),
+        request.tools,
+    )

services/protocol/conversation.py

@@ -0,0 +1,586 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import re
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Iterable, Iterator
+
+import tiktoken
+
+from services.account_service import account_service
+from services.config import config
+from services.openai_backend_api import OpenAIBackendAPI
+from utils.helper import IMAGE_MODELS
+from utils.log import logger
+
+
+class ImageGenerationError(Exception):
+    def __init__(
+        self,
+        message: str,
+        status_code: int = 502,
+        error_type: str = "server_error",
+        code: str | None = "upstream_error",
+        param: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.error_type = error_type
+        self.code = code
+        self.param = param
+
+    def to_openai_error(self) -> dict[str, Any]:
+        return {
+            "error": {
+                "message": str(self),
+                "type": self.error_type,
+                "param": self.param,
+                "code": self.code,
+            }
+        }
+
+
+def is_token_invalid_error(message: str) -> bool:
+    text = str(message or "").lower()
+    return (
+        "token_invalidated" in text
+        or "token_revoked" in text
+        or "authentication token has been invalidated" in text
+        or "invalidated oauth token" in text
+    )
+
+
+def encode_images(images: Iterable[tuple[bytes, str, str]]) -> list[str]:
+    return [base64.b64encode(data).decode("ascii") for data, _, _ in images if data]
+
+
+def save_image_bytes(image_data: bytes, base_url: str | None = None) -> str:
+    config.cleanup_old_images()
+    file_hash = hashlib.md5(image_data).hexdigest()
+    filename = f"{int(time.time())}_{file_hash}.png"
+    relative_dir = Path(time.strftime("%Y"), time.strftime("%m"), time.strftime("%d"))
+    file_path = config.images_dir / relative_dir / filename
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    file_path.write_bytes(image_data)
+    return f"{(base_url or config.base_url)}/images/{relative_dir.as_posix()}/{filename}"
+
+
+def message_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, str):
+                parts.append(item)
+            elif isinstance(item, dict) and str(item.get("type") or "") in {"text", "input_text", "output_text"}:
+                parts.append(str(item.get("text") or ""))
+        return "".join(parts)
+    return ""
+
+
+def normalize_messages(messages: object, system: Any = None) -> list[dict[str, Any]]:
+    normalized = []
+    system_text = message_text(system)
+    if system_text:
+        normalized.append({"role": "system", "content": system_text})
+    if isinstance(messages, list):
+        for message in messages:
+            if isinstance(message, dict):
+                normalized.append({"role": message.get("role", "user"), "content": message_text(message.get("content", ""))})
+    return normalized
+
+
+def assistant_history_text(messages: list[dict[str, Any]]) -> str:
+    return "".join(str(item.get("content") or "") for item in messages if item.get("role") == "assistant")
+
+
+def build_image_prompt(prompt: str, size: str | None) -> str:
+    if not size:
+        return prompt
+    if size not in {"1:1", "16:9", "9:16", "4:3", "3:4"}:
+        return f"{prompt.strip()}\n\n输出图片，宽高比为 {size}。"
+    hint = {
+        "1:1": "输出为 1:1 正方形构图，主体居中，适合正方形画幅。",
+        "16:9": "输出为 16:9 横屏构图，适合宽画幅展示。",
+        "9:16": "输出为 9:16 竖屏构图，适合竖版画幅展示。",
+        "4:3": "输出为 4:3 比例，兼顾宽度与高度，适合展示画面细节。",
+        "3:4": "输出为 3:4 比例，纵向构图，适合人物肖像或竖向场景。",
+    }[size]
+    return f"{prompt.strip()}\n\n{hint}"
+
+
+def encoding_for_model(model: str):
+    try:
+        return tiktoken.encoding_for_model(model)
+    except KeyError:
+        try:
+            return tiktoken.get_encoding("o200k_base")
+        except KeyError:
+            return tiktoken.get_encoding("cl100k_base")
+
+
+def count_message_tokens(messages: list[dict[str, Any]], model: str) -> int:
+    encoding = encoding_for_model(model)
+    total = 0
+    for message in messages:
+        total += 3
+        for key, value in message.items():
+            if not isinstance(value, str):
+                continue
+            total += len(encoding.encode(value))
+            if key == "name":
+                total += 1
+    return total + 3
+
+
+def count_text_tokens(text: str, model: str) -> int:
+    return len(encoding_for_model(model).encode(text))
+
+
+def format_image_result(
+    items: list[dict[str, Any]],
+    prompt: str,
+    response_format: str,
+    base_url: str | None = None,
+    created: int | None = None,
+    message: str = "",
+) -> dict[str, Any]:
+    data: list[dict[str, Any]] = []
+    for item in items:
+        b64_json = str(item.get("b64_json") or "").strip()
+        if not b64_json:
+            continue
+        revised_prompt = str(item.get("revised_prompt") or prompt).strip() or prompt
+        if response_format == "b64_json":
+            data.append({
+                "b64_json": b64_json,
+                "url": save_image_bytes(base64.b64decode(b64_json), base_url),
+                "revised_prompt": revised_prompt,
+            })
+        else:
+            data.append({
+                "url": save_image_bytes(base64.b64decode(b64_json), base_url),
+                "revised_prompt": revised_prompt,
+            })
+    result: dict[str, Any] = {"created": created or int(time.time()), "data": data}
+    if message and not data:
+        result["message"] = message
+    return result
+
+
+@dataclass
+class ConversationRequest:
+    model: str = "auto"
+    prompt: str = ""
+    messages: list[dict[str, Any]] | None = None
+    images: list[str] | None = None
+    n: int = 1
+    size: str | None = None
+    response_format: str = "b64_json"
+    base_url: str | None = None
+    message_as_error: bool = False
+
+
+@dataclass
+class ConversationState:
+    text: str = ""
+    conversation_id: str = ""
+    file_ids: list[str] = field(default_factory=list)
+    sediment_ids: list[str] = field(default_factory=list)
+    blocked: bool = False
+    tool_invoked: bool | None = None
+    turn_use_case: str = ""
+
+
+@dataclass
+class ImageOutput:
+    kind: str
+    model: str
+    index: int
+    total: int
+    created: int = field(default_factory=lambda: int(time.time()))
+    text: str = ""
+    upstream_event_type: str = ""
+    data: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_chunk(self) -> dict[str, Any]:
+        chunk: dict[str, Any] = {
+            "object": "image.generation.chunk",
+            "created": self.created,
+            "model": self.model,
+            "index": self.index,
+            "total": self.total,
+            "progress_text": self.text,
+            "upstream_event_type": self.upstream_event_type,
+            "data": [],
+        }
+        if self.kind == "message":
+            chunk.update({
+                "object": "image.generation.message",
+                "message": self.text,
+            })
+            chunk.pop("progress_text", None)
+            chunk.pop("upstream_event_type", None)
+        elif self.kind == "result":
+            chunk.update({
+                "object": "image.generation.result",
+                "data": self.data,
+            })
+            chunk.pop("progress_text", None)
+            chunk.pop("upstream_event_type", None)
+        return chunk
+
+
+def assistant_message_text(message: dict[str, Any]) -> str:
+    content = message.get("content") or {}
+    parts = content.get("parts") or []
+    if not isinstance(parts, list):
+        return ""
+    return "".join(part for part in parts if isinstance(part, str))
+
+
+def strip_history(text: str, history_text: str = "") -> str:
+    text = str(text or "")
+    history_text = str(history_text or "")
+    return text[len(history_text):] if history_text and text.startswith(history_text) else text
+
+
+def assistant_text(event: dict[str, Any], current_text: str = "", history_text: str = "") -> str:
+    for candidate in (event, event.get("v")):
+        if not isinstance(candidate, dict):
+            continue
+        message = candidate.get("message")
+        if not isinstance(message, dict):
+            continue
+        role = str((message.get("author") or {}).get("role") or "").strip().lower()
+        if role != "assistant":
+            continue
+        text = assistant_message_text(message)
+        if text:
+            return strip_history(text, history_text)
+    return apply_text_patch(event, current_text, history_text)
+
+
+def apply_text_patch(event: dict[str, Any], current_text: str = "", history_text: str = "") -> str:
+    if event.get("p") == "/message/content/parts/0":
+        return apply_patch_op(event, current_text, history_text)
+
+    operations = event.get("v")
+    if isinstance(operations, str) and current_text and not event.get("p") and not event.get("o"):
+        return current_text + operations
+
+    if event.get("o") == "patch" and isinstance(operations, list):
+        text = current_text
+        for item in operations:
+            if isinstance(item, dict):
+                text = apply_text_patch(item, text, history_text)
+        return text
+
+    if not isinstance(operations, list):
+        return current_text
+
+    text = current_text
+    for item in operations:
+        if isinstance(item, dict):
+            text = apply_text_patch(item, text, history_text)
+    return text
+
+
+def apply_patch_op(operation: dict[str, Any], current_text: str, history_text: str = "") -> str:
+    op = operation.get("o")
+    value = str(operation.get("v") or "")
+    if op == "append":
+        return current_text + value
+    if op == "replace":
+        return strip_history(value, history_text)
+    return current_text
+
+
+def add_unique(values: list[str], candidates: list[str]) -> None:
+    for candidate in candidates:
+        if candidate and candidate not in values:
+            values.append(candidate)
+
+
+def extract_conversation_ids(payload: str) -> tuple[str, list[str], list[str]]:
+    conversation_match = re.search(r'"conversation_id"\s*:\s*"([^"]+)"', payload)
+    conversation_id = conversation_match.group(1) if conversation_match else ""
+    file_ids = re.findall(r"(file[-_][A-Za-z0-9]+)", payload)
+    sediment_ids = re.findall(r"sediment://([A-Za-z0-9_-]+)", payload)
+    return conversation_id, file_ids, sediment_ids
+
+
+def is_image_tool_event(event: dict[str, Any]) -> bool:
+    value = event.get("v")
+    message = event.get("message") or (value.get("message") if isinstance(value, dict) else None)
+    if not isinstance(message, dict):
+        return False
+    metadata = message.get("metadata") or {}
+    author = message.get("author") or {}
+    return author.get("role") == "tool" and metadata.get("async_task_type") == "image_gen"
+
+
+def update_conversation_state(state: ConversationState, payload: str, event: dict[str, Any] | None = None) -> None:
+    conversation_id, file_ids, sediment_ids = extract_conversation_ids(payload)
+    if conversation_id and not state.conversation_id:
+        state.conversation_id = conversation_id
+    if isinstance(event, dict) and is_image_tool_event(event):
+        add_unique(state.file_ids, file_ids)
+        add_unique(state.sediment_ids, sediment_ids)
+    if not isinstance(event, dict):
+        return
+    state.conversation_id = str(event.get("conversation_id") or state.conversation_id)
+    value = event.get("v")
+    if isinstance(value, dict):
+        state.conversation_id = str(value.get("conversation_id") or state.conversation_id)
+    if event.get("type") == "moderation":
+        moderation = event.get("moderation_response")
+        if isinstance(moderation, dict) and moderation.get("blocked") is True:
+            state.blocked = True
+    if event.get("type") == "server_ste_metadata":
+        metadata = event.get("metadata")
+        if isinstance(metadata, dict):
+            if isinstance(metadata.get("tool_invoked"), bool):
+                state.tool_invoked = metadata["tool_invoked"]
+            state.turn_use_case = str(metadata.get("turn_use_case") or state.turn_use_case)
+
+
+def conversation_base_event(event_type: str, state: ConversationState, **extra: Any) -> dict[str, Any]:
+    return {
+        "type": event_type,
+        "text": state.text,
+        "conversation_id": state.conversation_id,
+        "file_ids": list(state.file_ids),
+        "sediment_ids": list(state.sediment_ids),
+        "blocked": state.blocked,
+        "tool_invoked": state.tool_invoked,
+        "turn_use_case": state.turn_use_case,
+        **extra,
+    }
+
+
+def iter_conversation_payloads(payloads: Iterator[str], history_text: str = "") -> Iterator[dict[str, Any]]:
+    state = ConversationState()
+    for payload in payloads:
+        # print(f"[upstream_sse] {payload}", flush=True)
+        if not payload:
+            continue
+        if payload == "[DONE]":
+            yield conversation_base_event("conversation.done", state, done=True)
+            break
+        try:
+            event = json.loads(payload)
+        except json.JSONDecodeError:
+            update_conversation_state(state, payload)
+            yield conversation_base_event("conversation.raw", state, payload=payload)
+            continue
+        if not isinstance(event, dict):
+            yield conversation_base_event("conversation.event", state, raw=event)
+            continue
+        update_conversation_state(state, payload, event)
+        next_text = assistant_text(event, state.text, history_text)
+        if next_text != state.text:
+            delta = next_text[len(state.text):] if next_text.startswith(state.text) else next_text
+            state.text = next_text
+            yield conversation_base_event("conversation.delta", state, raw=event, delta=delta)
+            continue
+        yield conversation_base_event("conversation.event", state, raw=event)
+
+
+def conversation_events(
+    backend: OpenAIBackendAPI,
+    messages: list[dict[str, Any]] | None = None,
+    model: str = "auto",
+    prompt: str = "",
+    images: list[str] | None = None,
+    size: str | None = None,
+) -> Iterator[dict[str, Any]]:
+    normalized = normalize_messages(messages or ([{"role": "user", "content": prompt}] if prompt else []))
+    image_model = str(model or "").strip() in IMAGE_MODELS
+    history_text = "" if image_model else assistant_history_text(normalized)
+    final_prompt = build_image_prompt(prompt, size) if image_model else prompt
+    payloads = backend.stream_conversation(
+        messages=normalized,
+        model=model,
+        prompt=final_prompt,
+        images=images if image_model else None,
+        system_hints=["picture_v2"] if image_model else None,
+    )
+    yield from iter_conversation_payloads(payloads, history_text)
+
+
+def text_backend() -> OpenAIBackendAPI:
+    return OpenAIBackendAPI(access_token=account_service.get_text_access_token())
+
+
+def stream_text_deltas(backend: OpenAIBackendAPI, request: ConversationRequest) -> Iterator[str]:
+    for event in conversation_events(backend, messages=request.messages, model=request.model, prompt=request.prompt):
+        if event.get("type") != "conversation.delta":
+            continue
+        delta = str(event.get("delta") or "")
+        if delta:
+            yield delta
+
+
+def collect_text(backend: OpenAIBackendAPI, request: ConversationRequest) -> str:
+    return "".join(stream_text_deltas(backend, request))
+
+
+def stream_image_outputs(
+        backend: OpenAIBackendAPI,
+        request: ConversationRequest,
+        index: int = 1,
+        total: int = 1,
+) -> Iterator[ImageOutput]:
+    last: dict[str, Any] = {}
+    for event in conversation_events(
+            backend,
+            prompt=request.prompt,
+            model=request.model,
+            images=request.images or [],
+            size=request.size,
+    ):
+        last = event
+        if event.get("type") == "conversation.delta":
+            yield ImageOutput(
+                kind="progress",
+                model=request.model,
+                index=index,
+                total=total,
+                text=str(event.get("delta") or ""),
+                upstream_event_type="conversation.delta",
+            )
+            continue
+        if event.get("type") == "conversation.event":
+            raw = event.get("raw")
+            raw_type = str(raw.get("type") or "") if isinstance(raw, dict) else ""
+            yield ImageOutput(
+                kind="progress",
+                model=request.model,
+                index=index,
+                total=total,
+                upstream_event_type=raw_type,
+            )
+
+    conversation_id = str(last.get("conversation_id") or "")
+    file_ids = [str(item) for item in last.get("file_ids") or []]
+    sediment_ids = [str(item) for item in last.get("sediment_ids") or []]
+    message = str(last.get("text") or "").strip()
+    is_text_response = last.get("tool_invoked") is False or last.get("turn_use_case") == "text"
+    logger.info({
+        "event": "image_stream_resolve_start",
+        "conversation_id": conversation_id,
+        "file_ids": file_ids,
+        "sediment_ids": sediment_ids,
+        "tool_invoked": last.get("tool_invoked"),
+        "turn_use_case": last.get("turn_use_case"),
+    })
+    if message and not file_ids and not sediment_ids and (last.get("blocked") or is_text_response):
+        yield ImageOutput(kind="message", model=request.model, index=index, total=total, text=message)
+        return
+
+    image_urls = backend.resolve_conversation_image_urls(conversation_id, file_ids, sediment_ids)
+    if image_urls:
+        image_items = [
+            {"b64_json": base64.b64encode(image_data).decode("ascii")}
+            for image_data in backend.download_image_bytes(image_urls)
+        ]
+        data = format_image_result(
+            image_items,
+            request.prompt,
+            request.response_format,
+            request.base_url,
+            int(time.time()),
+        )["data"]
+        if data:
+            yield ImageOutput(kind="result", model=request.model, index=index, total=total, data=data)
+        return
+
+    if message:
+        yield ImageOutput(kind="message", model=request.model, index=index, total=total, text=message)
+
+
+def stream_image_outputs_with_pool(request: ConversationRequest) -> Iterator[ImageOutput]:
+    if str(request.model or "").strip() not in IMAGE_MODELS:
+        raise ImageGenerationError("unsupported image model,supported models: " + ", ".join(IMAGE_MODELS))
+
+    emitted = False
+    last_error = ""
+    for index in range(1, request.n + 1):
+        while True:
+            try:
+                token = account_service.get_available_access_token()
+            except RuntimeError as exc:
+                if emitted:
+                    return
+                raise ImageGenerationError(str(exc) or "image generation failed") from exc
+
+            emitted_for_token = False
+            returned_message = False
+            returned_result = False
+            try:
+                backend = OpenAIBackendAPI(access_token=token)
+                for output in stream_image_outputs(backend, request, index, request.n):
+                    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",
+                        )
+                    emitted = True
+                    emitted_for_token = True
+                    returned_message = output.kind == "message"
+                    returned_result = returned_result or output.kind == "result"
+                    yield output
+                if returned_message or not returned_result:
+                    account_service.mark_image_result(token, False)
+                    return
+                account_service.mark_image_result(token, True)
+                break
+            except ImageGenerationError:
+                account_service.mark_image_result(token, False)
+                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})
+                if not emitted_for_token and is_token_invalid_error(last_error):
+                    account_service.remove_invalid_token(token, "image_stream")
+                    continue
+                raise ImageGenerationError(last_error or "image generation failed") from exc
+
+    if not emitted:
+        raise ImageGenerationError(last_error or "image generation failed")
+
+
+def stream_image_chunks(outputs: Iterable[ImageOutput]) -> Iterator[dict[str, Any]]:
+    for output in outputs:
+        yield output.to_chunk()
+
+
+def collect_image_outputs(outputs: Iterable[ImageOutput]) -> dict[str, Any]:
+    created = None
+    data: list[dict[str, Any]] = []
+    message = ""
+    progress_parts: list[str] = []
+    for output in outputs:
+        created = created or output.created
+        if output.kind == "progress" and output.text:
+            progress_parts.append(output.text)
+        elif output.kind == "message":
+            message = output.text
+        elif output.kind == "result":
+            data.extend(output.data)
+
+    result: dict[str, Any] = {"created": created or int(time.time()), "data": data}
+    if not data:
+        text = message or "".join(progress_parts).strip()
+        if text:
+            result["message"] = text
+    return result

services/protocol/openai_v1_chat_complete.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any, Iterable, Iterator
+
+from fastapi import HTTPException
+
+from services.protocol.conversation import (
+    ConversationRequest,
+    ImageOutput,
+    collect_image_outputs,
+    collect_text,
+    count_message_tokens,
+    count_text_tokens,
+    encode_images,
+    normalize_messages,
+    stream_image_outputs_with_pool,
+    stream_text_deltas,
+    text_backend,
+)
+from utils.helper import build_chat_image_markdown_content, extract_chat_image, extract_chat_prompt, is_image_chat_request, parse_image_count
+
+
+def completion_chunk(model: str, delta: dict[str, Any], finish_reason: str | None = None, completion_id: str = "", created: int | None = None) -> dict[str, Any]:
+    return {
+        "id": completion_id or f"chatcmpl-{uuid.uuid4().hex}",
+        "object": "chat.completion.chunk",
+        "created": created or int(time.time()),
+        "model": model,
+        "choices": [{"index": 0, "delta": delta, "finish_reason": finish_reason}],
+    }
+
+
+def completion_response(
+    model: str,
+    content: str,
+    created: int | None = None,
+    messages: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    prompt_tokens = count_message_tokens(messages, model) if messages else 0
+    completion_tokens = count_text_tokens(content, model) if messages else 0
+    return {
+        "id": f"chatcmpl-{uuid.uuid4().hex}",
+        "object": "chat.completion",
+        "created": created or int(time.time()),
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "message": {"role": "assistant", "content": content},
+            "finish_reason": "stop",
+        }],
+        "usage": {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": prompt_tokens + completion_tokens,
+        },
+    }
+
+
+def stream_text_chat_completion(backend, messages: list[dict[str, Any]], model: str) -> Iterator[dict[str, Any]]:
+    completion_id = f"chatcmpl-{uuid.uuid4().hex}"
+    created = int(time.time())
+    sent_role = False
+    request = ConversationRequest(model=model, messages=messages)
+    for delta_text in stream_text_deltas(backend, request):
+        if not sent_role:
+            sent_role = True
+            yield completion_chunk(model, {"role": "assistant", "content": delta_text}, None, completion_id, created)
+        else:
+            yield completion_chunk(model, {"content": delta_text}, None, completion_id, created)
+    if not sent_role:
+        yield completion_chunk(model, {"role": "assistant", "content": ""}, None, completion_id, created)
+    yield completion_chunk(model, {}, "stop", completion_id, created)
+
+
+def collect_chat_content(chunks: Iterable[dict[str, Any]]) -> str:
+    parts: list[str] = []
+    for chunk in chunks:
+        choices = chunk.get("choices")
+        first = choices[0] if isinstance(choices, list) and choices and isinstance(choices[0], dict) else {}
+        delta = first.get("delta") if isinstance(first.get("delta"), dict) else {}
+        content = str(delta.get("content") or "")
+        if content:
+            parts.append(content)
+    return "".join(parts)
+
+
+def chat_messages_from_body(body: dict[str, Any]) -> list[dict[str, Any]]:
+    messages = body.get("messages")
+    if isinstance(messages, list) and messages:
+        return [message for message in messages if isinstance(message, dict)]
+    prompt = str(body.get("prompt") or "").strip()
+    if prompt:
+        return [{"role": "user", "content": prompt}]
+    raise HTTPException(status_code=400, detail={"error": "messages or prompt is required"})
+
+
+def chat_image_args(body: dict[str, Any]) -> tuple[str, str, int, list[tuple[bytes, str, str]]]:
+    model = str(body.get("model") or "gpt-image-2").strip() or "gpt-image-2"
+    prompt = extract_chat_prompt(body)
+    if not prompt:
+        raise HTTPException(status_code=400, detail={"error": "prompt is required"})
+    images = [
+        (data, f"image_{idx}.png", mime)
+        for idx, (data, mime) in enumerate(extract_chat_image(body), start=1)
+    ]
+    return model, prompt, parse_image_count(body.get("n")), images
+
+
+def text_chat_parts(body: dict[str, Any]) -> tuple[str, list[dict[str, Any]]]:
+    model = str(body.get("model") or "auto").strip() or "auto"
+    messages = normalize_messages(chat_messages_from_body(body))
+    return model, messages
+
+
+def image_result_content(result: dict[str, Any]) -> str:
+    data = result.get("data")
+    if isinstance(data, list) and data:
+        return build_chat_image_markdown_content(result)
+    return str(result.get("message") or "Image generation completed.")
+
+
+def image_chat_response(body: dict[str, Any]) -> dict[str, Any]:
+    model, prompt, n, images = chat_image_args(body)
+    result = collect_image_outputs(stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        n=n,
+        response_format="b64_json",
+        images=encode_images(images) or None,
+    )))
+    return completion_response(model, image_result_content(result), int(result.get("created") or 0) or None)
+
+
+def image_chat_events(body: dict[str, Any]) -> Iterator[dict[str, Any]]:
+    model, prompt, n, images = chat_image_args(body)
+    image_outputs = stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        n=n,
+        response_format="b64_json",
+        images=encode_images(images) or None,
+    ))
+    yield from stream_image_chat_completion(image_outputs, model)
+
+
+def stream_image_chat_completion(image_outputs: Iterable[ImageOutput], model: str) -> Iterator[dict[str, Any]]:
+    completion_id = f"chatcmpl-{uuid.uuid4().hex}"
+    created = int(time.time())
+    sent_role = False
+    sent_text = ""
+    for output in image_outputs:
+        content = ""
+        if output.kind == "progress":
+            content = output.text
+            sent_text += content
+        elif output.kind == "result":
+            content = build_chat_image_markdown_content({"data": output.data})
+        elif output.kind == "message":
+            content = output.text[len(sent_text):] if output.text.startswith(sent_text) else output.text
+        if not content:
+            continue
+        if not sent_role:
+            sent_role = True
+            yield completion_chunk(model, {"role": "assistant", "content": content}, None, completion_id, created)
+        else:
+            yield completion_chunk(model, {"content": content}, None, completion_id, created)
+    if not sent_role:
+        yield completion_chunk(model, {"role": "assistant", "content": ""}, None, completion_id, created)
+    yield completion_chunk(model, {}, "stop", completion_id, created)
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    if body.get("stream"):
+        if is_image_chat_request(body):
+            return image_chat_events(body)
+        model, messages = text_chat_parts(body)
+        return stream_text_chat_completion(text_backend(), messages, model)
+    if is_image_chat_request(body):
+        return image_chat_response(body)
+    model, messages = text_chat_parts(body)
+    request = ConversationRequest(model=model, messages=messages)
+    return completion_response(model, collect_text(text_backend(), request), messages=messages)

services/protocol/openai_v1_image_edit.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any, Iterator
+
+from services.protocol.conversation import (
+    ConversationRequest,
+    ImageGenerationError,
+    collect_image_outputs,
+    encode_images,
+    stream_image_chunks,
+    stream_image_outputs_with_pool,
+)
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    prompt = str(body.get("prompt") or "")
+    images = body.get("images") or []
+    model = str(body.get("model") or "gpt-image-2")
+    n = int(body.get("n") or 1)
+    size = body.get("size")
+    response_format = str(body.get("response_format") or "b64_json")
+    base_url = str(body.get("base_url") or "") or None
+    encoded_images = encode_images(images)
+    if not encoded_images:
+        raise ImageGenerationError("image is required")
+    outputs = stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        n=n,
+        size=size,
+        response_format=response_format,
+        base_url=base_url,
+        images=encoded_images,
+        message_as_error=True,
+    ))
+    if body.get("stream"):
+        return stream_image_chunks(outputs)
+    return collect_image_outputs(outputs)

services/protocol/openai_v1_image_generations.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Any, Iterator
+
+from services.protocol.conversation import (
+    ConversationRequest,
+    collect_image_outputs,
+    stream_image_chunks,
+    stream_image_outputs_with_pool,
+)
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    prompt = str(body.get("prompt") or "")
+    model = str(body.get("model") or "gpt-image-2")
+    n = int(body.get("n") or 1)
+    size = body.get("size")
+    response_format = str(body.get("response_format") or "b64_json")
+    base_url = str(body.get("base_url") or "") or None
+    outputs = stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        n=n,
+        size=size,
+        response_format=response_format,
+        base_url=base_url,
+        message_as_error=True,
+    ))
+    if body.get("stream"):
+        return stream_image_chunks(outputs)
+    return collect_image_outputs(outputs)

services/protocol/openai_v1_models.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import Any
+
+from services.openai_backend_api import OpenAIBackendAPI
+from utils.helper import IMAGE_MODELS
+
+
+def list_models() -> dict[str, Any]:
+    result = OpenAIBackendAPI().list_models()
+    data = result.get("data")
+    if not isinstance(data, list):
+        return result
+    seen = {str(item.get("id") or "").strip() for item in data if isinstance(item, dict)}
+    for model in sorted(IMAGE_MODELS):
+        if model not in seen:
+            data.append({
+                "id": model,
+                "object": "model",
+                "created": 0,
+                "owned_by": "chatgpt2api",
+                "permission": [],
+                "root": model,
+                "parent": None,
+            })
+    return result

services/protocol/openai_v1_response.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import base64
+import time
+import uuid
+from typing import Any, Iterable, Iterator
+
+from fastapi import HTTPException
+
+from services.protocol.conversation import (
+    ConversationRequest,
+    ImageOutput,
+    encode_images,
+    stream_image_outputs_with_pool,
+    stream_text_deltas,
+    text_backend,
+)
+from utils.helper import extract_image_from_message_content, extract_response_prompt, has_response_image_generation_tool
+
+
+def is_text_response_request(body: dict[str, Any]) -> bool:
+    return not has_response_image_generation_tool(body)
+
+
+def extract_response_image(input_value: object) -> tuple[bytes, str] | None:
+    if isinstance(input_value, dict):
+        images = extract_image_from_message_content(input_value.get("content"))
+        return images[0] if images else None
+    if not isinstance(input_value, list):
+        return None
+    for item in reversed(input_value):
+        if isinstance(item, dict) and str(item.get("type") or "").strip() == "input_image":
+            image_url = str(item.get("image_url") or "")
+            if image_url.startswith("data:"):
+                header, _, data = image_url.partition(",")
+                mime = header.split(";")[0].removeprefix("data:")
+                return base64.b64decode(data), mime or "image/png"
+        if isinstance(item, dict):
+            images = extract_image_from_message_content(item.get("content"))
+            if images:
+                return images[0]
+    return None
+
+
+def messages_from_input(input_value: object, instructions: object = None) -> list[dict[str, Any]]:
+    messages: list[dict[str, Any]] = []
+    system_text = str(instructions or "").strip()
+    if system_text:
+        messages.append({"role": "system", "content": system_text})
+    if isinstance(input_value, str):
+        if input_value.strip():
+            messages.append({"role": "user", "content": input_value.strip()})
+        return messages
+    if isinstance(input_value, dict):
+        messages.append({
+            "role": str(input_value.get("role") or "user"),
+            "content": extract_response_prompt([input_value]) or input_value.get("content") or "",
+        })
+        return messages
+    if isinstance(input_value, list):
+        if all(isinstance(item, dict) and item.get("type") for item in input_value):
+            text = extract_response_prompt(input_value)
+            if text:
+                messages.append({"role": "user", "content": text})
+            return messages
+        for item in input_value:
+            if isinstance(item, dict):
+                messages.append({
+                    "role": str(item.get("role") or "user"),
+                    "content": extract_response_prompt([item]) or item.get("content") or "",
+                })
+    return messages
+
+
+def text_output_item(text: str, item_id: str | None = None, status: str = "completed") -> dict[str, Any]:
+    return {
+        "id": item_id or f"msg_{uuid.uuid4().hex}",
+        "type": "message",
+        "status": status,
+        "role": "assistant",
+        "content": [{"type": "output_text", "text": text, "annotations": []}],
+    }
+
+
+def image_output_items(prompt: str, data: list[dict[str, Any]], item_id: str | None = None) -> list[dict[str, Any]]:
+    output = []
+    for item in data:
+        b64_json = str(item.get("b64_json") or "").strip()
+        if b64_json:
+            output.append({
+                "id": item_id or f"ig_{len(output) + 1}",
+                "type": "image_generation_call",
+                "status": "completed",
+                "result": b64_json,
+                "revised_prompt": str(item.get("revised_prompt") or prompt).strip() or prompt,
+            })
+    return output
+
+
+def response_created(response_id: str, model: str, created: int) -> dict[str, Any]:
+    return {
+        "type": "response.created",
+        "response": {
+            "id": response_id,
+            "object": "response",
+            "created_at": created,
+            "status": "in_progress",
+            "error": None,
+            "incomplete_details": None,
+            "model": model,
+            "output": [],
+            "parallel_tool_calls": False,
+        },
+    }
+
+
+def response_completed(response_id: str, model: str, created: int, output: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "type": "response.completed",
+        "response": {
+            "id": response_id,
+            "object": "response",
+            "created_at": created,
+            "status": "completed",
+            "error": None,
+            "incomplete_details": None,
+            "model": model,
+            "output": output,
+            "parallel_tool_calls": False,
+        },
+    }
+
+
+def stream_text_response(backend, body: dict[str, Any]) -> Iterator[dict[str, Any]]:
+    model = str(body.get("model") or "auto").strip() or "auto"
+    messages = messages_from_input(body.get("input"), body.get("instructions"))
+    response_id = f"resp_{uuid.uuid4().hex}"
+    item_id = f"msg_{uuid.uuid4().hex}"
+    created = int(time.time())
+    full_text = ""
+    yield response_created(response_id, model, created)
+    yield {"type": "response.output_item.added", "output_index": 0, "item": text_output_item("", item_id, "in_progress")}
+    request = ConversationRequest(model=model, messages=messages)
+    for delta in stream_text_deltas(backend, request):
+        full_text += delta
+        yield {"type": "response.output_text.delta", "item_id": item_id, "output_index": 0, "content_index": 0, "delta": delta}
+    yield {"type": "response.output_text.done", "item_id": item_id, "output_index": 0, "content_index": 0, "text": full_text}
+    item = text_output_item(full_text, item_id, "completed")
+    yield {"type": "response.output_item.done", "output_index": 0, "item": item}
+    yield response_completed(response_id, model, created, [item])
+
+
+def stream_image_response(image_outputs: Iterable[ImageOutput], prompt: str, model: str) -> Iterator[dict[str, Any]]:
+    response_id = f"resp_{uuid.uuid4().hex}"
+    created = int(time.time())
+    yield response_created(response_id, model, created)
+    for output in image_outputs:
+        if output.kind == "message":
+            text = output.text
+            item = text_output_item(text)
+            yield {"type": "response.output_text.delta", "item_id": item["id"], "output_index": 0, "content_index": 0, "delta": text}
+            yield {"type": "response.output_text.done", "item_id": item["id"], "output_index": 0, "content_index": 0, "text": text}
+            yield {"type": "response.output_item.done", "output_index": 0, "item": item}
+            yield response_completed(response_id, model, created, [item])
+            return
+        if output.kind != "result":
+            continue
+        items = image_output_items(prompt, output.data)
+        if items:
+            item = items[0]
+            yield {"type": "response.output_item.done", "output_index": 0, "item": item}
+            yield response_completed(response_id, model, created, [item])
+            return
+    raise RuntimeError("image generation failed")
+
+
+def collect_response(events: Iterable[dict[str, Any]]) -> dict[str, Any]:
+    completed = {}
+    for event in events:
+        if event.get("type") == "response.completed":
+            completed = event.get("response") if isinstance(event.get("response"), dict) else {}
+    if not completed:
+        raise RuntimeError("response generation failed")
+    return completed
+
+
+def response_events(body: dict[str, Any]) -> Iterator[dict[str, Any]]:
+    if is_text_response_request(body):
+        yield from stream_text_response(text_backend(), body)
+        return
+
+    prompt = extract_response_prompt(body.get("input"))
+    if not prompt:
+        raise HTTPException(status_code=400, detail={"error": "input text is required"})
+    model = str(body.get("model") or "gpt-image-2").strip() or "gpt-image-2"
+    image_info = extract_response_image(body.get("input"))
+    if image_info:
+        image_data, mime_type = image_info
+        images = encode_images([(image_data, "image.png", mime_type)])
+    else:
+        images = None
+    image_outputs = stream_image_outputs_with_pool(ConversationRequest(
+        prompt=prompt,
+        model=model,
+        size=None if images else "1:1",
+        response_format="b64_json",
+        images=images,
+    ))
+    yield from stream_image_response(image_outputs, prompt, model)
+
+
+def handle(body: dict[str, Any]) -> dict[str, Any] | Iterator[dict[str, Any]]:
+    events = response_events(body)
+    if body.get("stream"):
+        return events
+    return collect_response(events)

test/test_generations.py

@@ -3,7 +3,7 @@ from test.utils import post_json, save_image
 
 def main() -> None:
     prompt = "A cute orange cat sitting on a chair"
-    result = post_json("/v1/images/generations", {"prompt": prompt, "model": "gpt-image-1", "n": 1})
+    result = post_json("/v1/images/generations", {"prompt": prompt, "model": "gpt-image-2", "n": 1})
     for index, item in enumerate(result["data"], start=1):
         print(save_image(item["b64_json"], f"generations_{index}"))
 

test/test_generations_url.py

@@ -6,7 +6,7 @@ def main() -> None:
         "/v1/images/generations",
         {
             "prompt": "一只橘猫坐在窗边，午后阳光，写实摄影",
-            "model": "gpt-image-1",
+            "model": "gpt-image-2",
             "n": 1,
             "response_format": "url",
         },

test/test_image.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
-from services.account_service import account_service
-from services.chatgpt_service import ChatGPTService
+from services.protocol import openai_v1_image_generations
 from test.utils import save_image
 
 
 def main() -> None:
     prompt = "一只橘猫坐在窗台上，午后阳光，写实摄影"
-    data = ChatGPTService(account_service).generate_with_pool(prompt, "gpt-5-3", 1)
+    data = openai_v1_image_generations.handle({"prompt": prompt, "model": "gpt-5-3", "n": 1})
     for index, item in enumerate(data["data"], start=1):
         print(save_image(item["b64_json"], f"image_{index}"))
 

test/test_v1_chat_completions.py

@@ -63,7 +63,7 @@ class ChatCompletionsTests(unittest.TestCase):
             f"{BASE_URL}/v1/chat/completions",
             headers={"Authorization": f"Bearer {AUTH_KEY}"},
             json={
-                "model": "gpt-image-1",
+                "model": "gpt-image-2",
                 "messages": [
                     {"role": "user", "content": "我想做一张南京城市宣传海报图。"},
                 ],
@@ -86,7 +86,7 @@ class ChatCompletionsTests(unittest.TestCase):
             f"{BASE_URL}/v1/chat/completions",
             headers={"Authorization": f"Bearer {AUTH_KEY}"},
             json={
-                "model": "gpt-image-1",
+                "model": "gpt-image-2",
                 "stream": True,
                 "messages": [
                     {"role": "user", "content": "我想做一张南京城市宣传海报图。"},

test/test_v1_images_edits.py

@@ -42,7 +42,7 @@ class ImageEditsTests(unittest.TestCase):
             f"{BASE_URL}/v1/images/edits",
             headers={"Authorization": f"Bearer {AUTH_KEY}"},
             data={
-                "model": "gpt-image-1",
+                "model": "gpt-image-2",
                 "prompt": "参考输入图片，保持人物主体和二次元插画风格不变，让女孩怀里抱着一只可爱的小猫，画面自然协调。",
                 "n": "1",
                 "response_format": "b64_json",
@@ -72,7 +72,7 @@ class ImageEditsTests(unittest.TestCase):
             f"{BASE_URL}/v1/images/edits",
             headers={"Authorization": f"Bearer {AUTH_KEY}"},
             data={
-                "model": "gpt-image-1",
+                "model": "gpt-image-2",
                 "prompt": "请提取两张输入界面截图中的 6 个任务，并把这 6 个任务整合排版到同一张图里，做成一张清晰的中文任务总览海报，标题明确，六个任务分区展示，版面整洁。",
                 "n": "1",
                 "response_format": "b64_json",

test/test_v1_images_generations.py

@@ -19,7 +19,7 @@ class ImageGenerationsTests(unittest.TestCase):
             f"{BASE_URL}/v1/images/generations",
             headers={"Authorization": f"Bearer {AUTH_KEY}"},
             json={
-                "model": "gpt-image-1",
+                "model": "gpt-image-2",
                 "prompt": "我想做一张南京城市宣传海报图。",
                 "n": 1,
                 "response_format": "b64_json",
@@ -46,7 +46,7 @@ class ImageGenerationsTests(unittest.TestCase):
             f"{BASE_URL}/v1/images/generations",
             headers={"Authorization": f"Bearer {AUTH_KEY}"},
             json={
-                "model": "gpt-image-1",
+                "model": "gpt-image-2",
                 "prompt": "我想做一张南京城市宣传海报图。",
                 "n": 1,
                 "response_format": "b64_json",

test/test_v1_messages.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+import time
+import unittest
+
+import requests
+
+AUTH_KEY = "chatgpt2api"
+BASE_URL = "http://localhost:8000"
+MODEL = "auto"
+
+
+class AnthropicMessagesTests(unittest.TestCase):
+    @staticmethod
+    def _headers() -> dict[str, str]:
+        return {
+            "x-api-key": AUTH_KEY,
+            "anthropic-version": "2023-06-01",
+        }
+
+    def test_message_http(self):
+        """测试 Anthropic Messages 的非流式 HTTP 调用。"""
+        response = requests.post(
+            f"{BASE_URL}/v1/messages",
+            headers=self._headers(),
+            json={
+                "model": MODEL,
+                "messages": [
+                    {"role": "user", "content": "你好，请简单介绍一下你自己。"},
+                ],
+            },
+            timeout=300,
+        )
+        print("messages non-stream status:")
+        print(response.status_code)
+        print("messages non-stream result:")
+        try:
+            print(json.dumps(response.json(), ensure_ascii=False, indent=2))
+        except Exception:
+            print(response.text)
+
+    def test_message_stream_http(self):
+        """测试 Anthropic Messages 的流式 HTTP 调用。"""
+        started_at = time.time()
+        response = requests.post(
+            f"{BASE_URL}/v1/messages",
+            headers=self._headers(),
+            json={
+                "model": MODEL,
+                "stream": True,
+                "messages": [
+                    {"role": "user", "content": "你好，请简单介绍一下你自己。"},
+                ],
+            },
+            stream=True,
+            timeout=300,
+        )
+        headers_at = time.time()
+        print("messages stream status:")
+        print(response.status_code)
+        print("messages stream content-type:")
+        print(response.headers.get("content-type", ""))
+        print("messages stream response headers:")
+        print(f"{headers_at - started_at:6.2f}s")
+        if response.status_code != 200:
+            print(response.text)
+            return
+        print("messages stream chunks:")
+        for line in response.iter_lines(chunk_size=1):
+            if not line:
+                continue
+            text = line.decode("utf-8", errors="replace")
+            print(f"{time.time() - started_at:6.2f}s {text}")
+            if not text.startswith("data:"):
+                continue
+            try:
+                payload = json.loads(text[5:].strip())
+            except Exception:
+                continue
+            if payload.get("type") == "message_stop":
+                break
+
+
+if __name__ == "__main__":
+    unittest.main()

test/test_v1_models.py

@@ -5,7 +5,7 @@ import unittest
 
 import requests
 
-from services.chatgpt_service import ChatGPTService
+from services.protocol import openai_v1_models
 
 
 AUTH_KEY = "chatgpt2api"
@@ -15,7 +15,7 @@ BASE_URL = "http://localhost:8000"
 class ModelListTests(unittest.TestCase):
     def test_list_models_function(self):
         """测试直接调用服务层获取模型列表。"""
-        result = ChatGPTService(None).list_models()
+        result = openai_v1_models.list_models()
         print("function result:")
         print(json.dumps(result, ensure_ascii=False, indent=2))
 

test/test_v1_responses.py

@@ -11,7 +11,7 @@ from test.utils import save_image
 AUTH_KEY = "chatgpt2api"
 BASE_URL = "http://localhost:8000"
 TEXT_MODEL = "auto"
-IMAGE_MODEL = "gpt-image-1"
+IMAGE_MODEL = "gpt-image-2"
 CODEX_IMAGE_MODEL = "codex-gpt-image-2"
 
 

utils/helper.py

@@ -1,13 +1,13 @@
 import base64
-import json
 import hashlib
-import uuid
+import json
+import re
 import time
+import uuid
 from pathlib import Path
-from typing import Any, Dict, Iterator
+from typing import Any, Iterator
 
 from curl_cffi import requests
-import re
 from fastapi import HTTPException
 from utils.log import logger
 
@@ -24,10 +24,7 @@ def is_image_chat_request(body: dict[str, object]) -> bool:
     modalities = body.get("modalities")
     if model in IMAGE_MODELS:
         return True
-    if isinstance(modalities, list):
-        normalized = {str(item or "").strip().lower() for item in modalities}
-        return "image" in normalized
-    return False
+    return isinstance(modalities, list) and "image" in {str(item or "").strip().lower() for item in modalities}
 
 
 def ensure_ok(response: requests.Response, context: str) -> None:
@@ -41,23 +38,6 @@ def ensure_ok(response: requests.Response, context: str) -> None:
     raise RuntimeError(f"{context} failed: status={response.status_code}, body={body}")
 
 
-def parse_sse_lines(response: requests.Response) -> Iterator[Dict[str, Any]]:
-    for raw_line in response.iter_lines():
-        if not raw_line:
-            continue
-        line = raw_line.decode("utf-8", errors="ignore")
-        if not line.startswith("data:"):
-            continue
-        payload = line[5:].strip()
-        if payload == "[DONE]":
-            yield {"done": True}
-            break
-        try:
-            yield json.loads(payload)
-        except json.JSONDecodeError:
-            yield {"raw": payload}
-
-
 def sse_json_stream(items) -> Iterator[str]:
     yield ": stream-open\n\n"
     try:
@@ -69,7 +49,10 @@ def sse_json_stream(items) -> Iterator[str]:
             "error_type": exc.__class__.__name__,
             "error": str(exc),
         })
-        yield f"data: {json.dumps({'error': {'message': str(exc), 'type': exc.__class__.__name__}}, ensure_ascii=False)}\n\n"
+        error = exc.to_openai_error() if hasattr(exc, "to_openai_error") else {
+            "error": {"message": str(exc), "type": exc.__class__.__name__}
+        }
+        yield f"data: {json.dumps(error, ensure_ascii=False)}\n\n"
     yield "data: [DONE]\n\n"
 
 
@@ -90,6 +73,18 @@ def anthropic_sse_stream(items) -> Iterator[str]:
         yield f"data: {json.dumps(error, ensure_ascii=False)}\n\n"
 
 
+def iter_sse_payloads(response: requests.Response) -> Iterator[str]:
+    for raw_line in response.iter_lines():
+        if not raw_line:
+            continue
+        line = raw_line.decode("utf-8", errors="ignore") if isinstance(raw_line, bytes) else str(raw_line)
+        if not line.startswith("data:"):
+            continue
+        payload = line[5:].strip()
+        if payload:
+            yield payload
+
+
 def save_images_from_text(text: str, prefix: str) -> list[Path]:
     OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
     matches = re.findall(r"data:image/[^;]+;base64,[A-Za-z0-9+/=]+", text or "")
@@ -240,22 +235,6 @@ def parse_image_count(raw_value: object) -> int:
     return value
 
 
-def build_chat_image_completion(model: str, image_result: dict[str, object]) -> dict[str, object]:
-    created = int(image_result.get("created") or time.time())
-    return {
-        "id": f"chatcmpl-{uuid.uuid4().hex}",
-        "object": "chat.completion",
-        "created": created,
-        "model": model,
-        "choices": [{
-            "index": 0,
-            "message": {"role": "assistant", "content": build_chat_image_markdown_content(image_result)},
-            "finish_reason": "stop",
-        }],
-        "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
-    }
-
-
 def build_chat_image_markdown_content(image_result: dict[str, object]) -> str:
     image_items = image_result.get("data") if isinstance(image_result.get("data"), list) else []
     markdown_images: list[str] = []

utils/log.py

@@ -13,11 +13,19 @@ class Logger:
         self._logger = logging.getLogger(name)
         if not self._logger.handlers:
             handler = logging.StreamHandler()
-            handler.setFormatter(logging.Formatter("%(message)s"))
+            handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
             self._logger.addHandler(handler)
-        self._logger.setLevel(logging.INFO)
+        self._logger.setLevel(logging.DEBUG)
         self._logger.propagate = False
 
+    def _enabled(self, level: str) -> bool:
+        try:
+            from services.config import config
+            levels = set(config.log_levels)
+        except Exception:
+            levels = set()
+        return level in (levels or {"info", "warning", "error"})
+
     def _mask_string(self, value: str, keep: int = 10) -> str:
         if len(value) <= keep:
             return value
@@ -76,16 +84,20 @@ class Logger:
         return value
 
     def debug(self, message: Any) -> None:
-        self._logger.debug(self._sanitize(message))
+        if self._enabled("debug"):
+            self._logger.debug(self._sanitize(message))
 
     def info(self, message: Any) -> None:
-        self._logger.info(self._sanitize(message))
+        if self._enabled("info"):
+            self._logger.info(self._sanitize(message))
 
     def warning(self, message: Any) -> None:
-        self._logger.warning(self._sanitize(message))
+        if self._enabled("warning"):
+            self._logger.warning(self._sanitize(message))
 
     def error(self, message: Any) -> None:
-        self._logger.error(self._sanitize(message))
+        if self._enabled("error"):
+            self._logger.error(self._sanitize(message))
 
 
 logger = Logger()

uv.lock

@@ -325,29 +325,29 @@ wheels = [
 [[package]]
 name = "httpcore"
 version = "1.0.9"
-source = { registry = "https://pypi.org/simple" }
+source = { registry = "https://mirrors.aliyun.com/pypi/simple" }
 dependencies = [
     { name = "certifi" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+sdist = { url = "https://mirrors.aliyun.com/pypi/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+    { url = "https://mirrors.aliyun.com/pypi/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" },
 ]
 
 [[package]]
 name = "httpx"
 version = "0.28.1"
-source = { registry = "https://pypi.org/simple" }
+source = { registry = "https://mirrors.aliyun.com/pypi/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "certifi" },
     { name = "httpcore" },
     { name = "idna" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+sdist = { url = "https://mirrors.aliyun.com/pypi/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+    { url = "https://mirrors.aliyun.com/pypi/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" },
 ]
 
 [[package]]

web/src/app/image/components/image-results.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { useState } from "react";
 import { Clock3, LoaderCircle, Sparkles } from "lucide-react";
 
 import { Button } from "@/components/ui/button";
@@ -9,6 +10,8 @@ import type { ImageConversation, ImageTurnStatus, StoredImage, StoredReferenceIm
 export type ImageLightboxItem = {
   id: string;
   src: string;
+  sizeLabel?: string;
+  dimensions?: string;
 };
 
 type ImageResultsProps = {
@@ -24,6 +27,18 @@ export function ImageResults({
   onContinueEdit,
   formatConversationTime,
 }: ImageResultsProps) {
+  const [imageDimensions, setImageDimensions] = useState<Record<string, string>>({});
+
+  const updateImageDimensions = (id: string, width: number, height: number) => {
+    const dimensions = formatImageDimensions(width, height);
+    setImageDimensions((current) => {
+      if (current[id] === dimensions) {
+        return current;
+      }
+      return { ...current, [id]: dimensions };
+    });
+  };
+
   if (!selectedConversation) {
     return (
       <div className="flex h-full min-h-[420px] items-center justify-center text-center">
@@ -58,7 +73,14 @@ export function ImageResults({
         }));
         const successfulTurnImages = turn.images.flatMap((image) =>
           image.status === "success" && image.b64_json
-            ? [{ id: image.id, src: `data:image/png;base64,${image.b64_json}` }]
+            ? [
+                {
+                  id: image.id,
+                  src: `data:image/png;base64,${image.b64_json}`,
+                  sizeLabel: formatBase64ImageSize(image.b64_json),
+                  dimensions: imageDimensions[image.id],
+                },
+              ]
             : [],
         );
 
@@ -125,6 +147,9 @@ export function ImageResults({
                   {turn.images.map((image, index) => {
                     if (image.status === "success" && image.b64_json) {
                       const currentIndex = successfulTurnImages.findIndex((item) => item.id === image.id);
+                      const sizeLabel = formatBase64ImageSize(image.b64_json);
+                      const dimensions = imageDimensions[image.id];
+                      const imageMeta = [sizeLabel, dimensions].filter(Boolean).join(" · ");
 
                       return (
                         <div
@@ -140,10 +165,20 @@ export function ImageResults({
                               src={`data:image/png;base64,${image.b64_json}`}
                               alt={`Generated result ${index + 1}`}
                               className="block h-auto w-full transition duration-200 group-hover:brightness-90"
+                              onLoad={(event) => {
+                                updateImageDimensions(
+                                  image.id,
+                                  event.currentTarget.naturalWidth,
+                                  event.currentTarget.naturalHeight,
+                                );
+                              }}
                             />
                           </button>
                           <div className="flex items-center justify-between gap-2 px-3 py-3">
-                            <div className="text-xs text-stone-500">结果 {index + 1}</div>
+                            <div className="min-w-0 text-xs text-stone-500">
+                              <span>结果 {index + 1}</span>
+                              {imageMeta ? <span className="ml-2 text-stone-400">{imageMeta}</span> : null}
+                            </div>
                             <Button
                               variant="outline"
                               size="sm"
@@ -233,3 +268,21 @@ function getTurnStatusLabel(status: ImageTurnStatus) {
   }
   return "失败";
 }
+
+function formatBase64ImageSize(base64: string) {
+  const normalized = base64.replace(/\s/g, "");
+  const padding = normalized.endsWith("==") ? 2 : normalized.endsWith("=") ? 1 : 0;
+  const bytes = Math.max(0, Math.floor((normalized.length * 3) / 4) - padding);
+
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} B`;
+}
+
+function formatImageDimensions(width: number, height: number) {
+  return `${width} x ${height}`;
+}

web/src/app/image/components/image-sidebar.tsx

@@ -30,7 +30,7 @@ export function ImageSidebar({
   hideActionButtons = false,
 }: ImageSidebarProps) {
   return (
-    <aside className="min-h-0">
+    <aside className="h-full min-h-0 overflow-hidden">
       <div className="flex h-full min-h-0 flex-col gap-2 py-1 sm:gap-3 sm:py-2">
         {!hideActionButtons && (
           <div className="flex items-center gap-2">
@@ -49,7 +49,7 @@ export function ImageSidebar({
           </div>
         )}
 
-        <div className="min-h-0 flex-1 space-y-2 overflow-y-auto pr-1">
+        <div className="min-h-0 flex-1 space-y-2 overflow-y-auto pr-1 [scrollbar-color:rgba(120,113,108,.45)_transparent] [scrollbar-width:thin] [&::-webkit-scrollbar]:w-1.5 [&::-webkit-scrollbar-thumb]:rounded-full [&::-webkit-scrollbar-thumb]:bg-stone-400/45 [&::-webkit-scrollbar-track]:bg-transparent">
           {isLoadingHistory ? (
             <div className="flex items-center gap-2 px-2 py-3 text-sm text-stone-500">
               <LoaderCircle className="size-4 animate-spin" />

web/src/app/image/page.tsx

@@ -11,6 +11,8 @@ import { ImageLightbox } from "@/components/image-lightbox";
 import {
   Dialog,
   DialogContent,
+  DialogDescription,
+  DialogFooter,
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
@@ -22,6 +24,7 @@ import {
   deleteImageConversation,
   getImageConversationStats,
   listImageConversations,
+  saveImageConversation,
   saveImageConversations,
   type ImageConversation,
   type ImageConversationMode,
@@ -192,6 +195,7 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
   const [lightboxImages, setLightboxImages] = useState<ImageLightboxItem[]>([]);
   const [lightboxOpen, setLightboxOpen] = useState(false);
   const [lightboxIndex, setLightboxIndex] = useState(0);
+  const [deleteConfirm, setDeleteConfirm] = useState<{ type: "one"; id: string } | { type: "all" } | null>(null);
 
   const parsedCount = useMemo(() => Math.max(1, Math.min(10, Number(imageCount) || 1)), [imageCount]);
   const selectedConversation = useMemo(
@@ -206,6 +210,13 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
       }, 0),
     [conversations],
   );
+  const deleteConfirmTitle = deleteConfirm?.type === "all" ? "清空历史记录" : deleteConfirm?.type === "one" ? "删除对话" : "";
+  const deleteConfirmDescription =
+    deleteConfirm?.type === "all"
+      ? "确认删除全部图片历史记录吗？删除后无法恢复。"
+      : deleteConfirm?.type === "one"
+        ? "确认删除这条图片对话吗？删除后无法恢复。"
+        : "";
 
   useEffect(() => {
     conversationsRef.current = conversations;
@@ -328,7 +339,7 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
     ]);
     conversationsRef.current = nextConversations;
     setConversations(nextConversations);
-    await saveImageConversations(nextConversations);
+    await saveImageConversation(conversation);
   };
 
   const updateConversation = useCallback(
@@ -346,7 +357,7 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
       conversationsRef.current = nextConversations;
       setConversations(nextConversations);
       if (options.persist !== false) {
-        await saveImageConversations(nextConversations);
+        await saveImageConversation(nextConversation);
       }
     },
     [],
@@ -407,6 +418,29 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
     }
   };
 
+  const openDeleteConversationConfirm = (id: string) => {
+    setIsHistoryOpen(false);
+    setDeleteConfirm({ type: "one", id });
+  };
+
+  const openClearHistoryConfirm = () => {
+    setIsHistoryOpen(false);
+    setDeleteConfirm({ type: "all" });
+  };
+
+  const handleConfirmDelete = async () => {
+    const target = deleteConfirm;
+    setDeleteConfirm(null);
+    if (!target) {
+      return;
+    }
+    if (target.type === "all") {
+      await handleClearHistory();
+      return;
+    }
+    await handleDeleteConversation(target.id);
+  };
+
   const appendReferenceImages = useCallback(async (files: File[]) => {
     if (files.length === 0) {
       return;
@@ -720,7 +754,7 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
     const draftTurn: ImageTurn = {
       id: turnId,
       prompt,
-      model: "auto",
+      model: "gpt-image-2",
       mode: imageMode,
       referenceImages: imageMode === "edit" ? referenceImages : [],
       count: parsedCount,
@@ -772,9 +806,9 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
             isLoadingHistory={isLoadingHistory}
             selectedConversationId={selectedConversationId}
             onCreateDraft={handleCreateDraft}
-            onClearHistory={handleClearHistory}
+            onClearHistory={openClearHistoryConfirm}
             onSelectConversation={setSelectedConversationId}
-            onDeleteConversation={handleDeleteConversation}
+            onDeleteConversation={openDeleteConversationConfirm}
             formatConversationTime={formatConversationTime}
           />
         </div>
@@ -796,12 +830,12 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
                   handleCreateDraft();
                   setIsHistoryOpen(false);
                 }}
-                onClearHistory={handleClearHistory}
+                onClearHistory={openClearHistoryConfirm}
                 onSelectConversation={(id) => {
                   setSelectedConversationId(id);
                   setIsHistoryOpen(false);
                 }}
-                onDeleteConversation={handleDeleteConversation}
+                onDeleteConversation={openDeleteConversationConfirm}
                 formatConversationTime={formatConversationTime}
                 hideActionButtons
               />
@@ -829,7 +863,7 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
             <Button
               variant="outline"
               className="h-10 rounded-2xl border-stone-200 bg-white/85 px-3 text-stone-600 shadow-sm"
-              onClick={() => void handleClearHistory()}
+              onClick={openClearHistoryConfirm}
               disabled={conversations.length === 0}
             >
               <Trash2 className="size-4" />
@@ -877,6 +911,27 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
         onOpenChange={setLightboxOpen}
         onIndexChange={setLightboxIndex}
       />
+
+      {deleteConfirm ? (
+        <Dialog open onOpenChange={(open) => (!open ? setDeleteConfirm(null) : null)}>
+          <DialogContent showCloseButton={false} className="rounded-2xl p-6">
+            <DialogHeader className="gap-2">
+              <DialogTitle>{deleteConfirmTitle}</DialogTitle>
+              <DialogDescription className="text-sm leading-6">
+                {deleteConfirmDescription}
+              </DialogDescription>
+            </DialogHeader>
+            <DialogFooter>
+              <Button variant="outline" onClick={() => setDeleteConfirm(null)}>
+                取消
+              </Button>
+              <Button className="bg-rose-600 text-white hover:bg-rose-700" onClick={() => void handleConfirmDelete()}>
+                确认删除
+              </Button>
+            </DialogFooter>
+          </DialogContent>
+        </Dialog>
+      ) : null}
     </>
   );
 }

web/src/app/layout.tsx

@@ -22,7 +22,7 @@ export default function RootLayout({
             '"SF Pro Display","SF Pro Text","PingFang SC","Microsoft YaHei","Helvetica Neue",sans-serif',
         }}
       >
-        <Toaster position="top-center" richColors />
+        <Toaster position="top-center" richColors offset={48} />
         <main className="min-h-screen bg-[radial-gradient(circle_at_top_left,_rgba(255,255,255,0.92),_rgba(245,239,231,0.96)_42%,_rgba(240,235,227,0.99)_100%)] px-4 py-2 text-stone-900 sm:px-6 lg:px-8">
           <div className="mx-auto flex max-w-[1440px] flex-col gap-5">
             <TopNav />

web/src/app/logs/page.tsx

@@ -53,6 +53,7 @@ function LogsContent() {
   const [startDate, setStartDate] = useState("");
   const [endDate, setEndDate] = useState("");
   const [detailLog, setDetailLog] = useState<SystemLog | null>(null);
+  const [detailOpen, setDetailOpen] = useState(false);
   const [lightboxIndex, setLightboxIndex] = useState(0);
   const [lightboxOpen, setLightboxOpen] = useState(false);
   const [page, setPage] = useState(1);
@@ -83,6 +84,11 @@ function LogsContent() {
     setEndDate("");
   };
 
+  const openDetail = (item: SystemLog) => {
+    setDetailLog(item);
+    setDetailOpen(true);
+  };
+
   useEffect(() => {
     void loadLogs();
   }, [type, startDate, endDate]);
@@ -151,7 +157,7 @@ function LogsContent() {
                     ) : null}
                     <TableCell className="max-w-[420px] truncate text-stone-500">{item.summary || "-"}</TableCell>
                     <TableCell>
-                      <Button variant="ghost" className="h-8 rounded-lg px-3 text-stone-600" onClick={() => setDetailLog(item)}>
+                      <Button variant="ghost" className="h-8 rounded-lg px-3 text-stone-600" onClick={() => openDetail(item)}>
                         查看详情
                       </Button>
                     </TableCell>
@@ -172,7 +178,7 @@ function LogsContent() {
           {!isLoading && items.length === 0 ? <div className="px-6 py-14 text-center text-sm text-stone-500">没有找到日志</div> : null}
         </CardContent>
       </Card>
-      <Dialog open={Boolean(detailLog)} onOpenChange={(open) => (!open ? setDetailLog(null) : null)}>
+      <Dialog open={detailOpen} onOpenChange={setDetailOpen}>
         <DialogContent className="w-[min(92vw,920px)] rounded-2xl p-6">
           <DialogHeader>
             <DialogTitle>日志详情</DialogTitle>

web/src/app/settings/components/config-card.tsx

@@ -15,12 +15,14 @@ import { useSettingsStore } from "../store";
 export function ConfigCard() {
   const [isTestingProxy, setIsTestingProxy] = useState(false);
   const [proxyTestResult, setProxyTestResult] = useState<ProxyTestResult | null>(null);
+  const logLevelOptions = ["debug", "info", "warning", "error"];
   const config = useSettingsStore((state) => state.config);
   const isLoadingConfig = useSettingsStore((state) => state.isLoadingConfig);
   const isSavingConfig = useSettingsStore((state) => state.isSavingConfig);
   const setRefreshAccountIntervalMinute = useSettingsStore((state) => state.setRefreshAccountIntervalMinute);
   const setImageRetentionDays = useSettingsStore((state) => state.setImageRetentionDays);
   const setAutoRemoveInvalidAccounts = useSettingsStore((state) => state.setAutoRemoveInvalidAccounts);
+  const setLogLevel = useSettingsStore((state) => state.setLogLevel);
   const setProxy = useSettingsStore((state) => state.setProxy);
   const setBaseUrl = useSettingsStore((state) => state.setBaseUrl);
   const saveConfig = useSettingsStore((state) => state.saveConfig);
@@ -140,6 +142,23 @@ export function ConfigCard() {
             />
             自动移除异常账号
           </label>
+          <div className="space-y-3 rounded-xl border border-stone-200 bg-white px-4 py-3">
+            <div>
+              <label className="text-sm text-stone-700">控制台日志级别</label>
+              <p className="mt-1 text-xs text-stone-500">不选择时使用默认 info / warning / error。</p>
+            </div>
+            <div className="grid grid-cols-2 gap-2">
+              {logLevelOptions.map((level) => (
+                <label key={level} className="flex items-center gap-2 text-sm capitalize text-stone-700">
+                  <Checkbox
+                    checked={Boolean(config?.log_levels?.includes(level))}
+                    onCheckedChange={(checked) => setLogLevel(level, Boolean(checked))}
+                  />
+                  {level}
+                </label>
+              ))}
+            </div>
+          </div>
         </div>
 
         <div className="flex justify-end">

web/src/app/settings/store.ts

@@ -27,6 +27,7 @@ function normalizeConfig(config: SettingsConfig): SettingsConfig {
     refresh_account_interval_minute: Number(config.refresh_account_interval_minute || 5),
     image_retention_days: Number(config.image_retention_days || 30),
     auto_remove_invalid_accounts: Boolean(config.auto_remove_invalid_accounts),
+    log_levels: Array.isArray(config.log_levels) ? config.log_levels : [],
     proxy: typeof config.proxy === "string" ? config.proxy : "",
     base_url: typeof config.base_url === "string" ? config.base_url : "",
   };
@@ -82,6 +83,7 @@ type SettingsStore = {
   setRefreshAccountIntervalMinute: (value: string) => void;
   setImageRetentionDays: (value: string) => void;
   setAutoRemoveInvalidAccounts: (value: boolean) => void;
+  setLogLevel: (level: string, enabled: boolean) => void;
   setProxy: (value: string) => void;
   setBaseUrl: (value: string) => void;
 
@@ -200,6 +202,16 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
     set((state) => state.config ? { config: { ...state.config, auto_remove_invalid_accounts: value } } : {});
   },
 
+  setLogLevel: (level, enabled) => {
+    set((state) => {
+      if (!state.config) return {};
+      const levels = new Set(state.config.log_levels || []);
+      if (enabled) levels.add(level);
+      else levels.delete(level);
+      return { config: { ...state.config, log_levels: Array.from(levels) } };
+    });
+  },
+
   setProxy: (value) => {
     set((state) => {
       if (!state.config) {

web/src/lib/api.ts

@@ -2,7 +2,7 @@ import { httpRequest } from "@/lib/request";
 
 export type AccountType = "Free" | "Plus" | "ProLite" | "Pro" | "Team";
 export type AccountStatus = "正常" | "限流" | "异常" | "禁用";
-export type ImageModel = "auto" | "gpt-image-1" | "gpt-image-2";
+export type ImageModel = "gpt-image-2" | "codex-gpt-image-2";
 export type AuthRole = "admin" | "user";
 
 export type Account = {
@@ -56,6 +56,7 @@ export type SettingsConfig = {
   refresh_account_interval_minute?: number | string;
   image_retention_days?: number | string;
   auto_remove_invalid_accounts?: boolean;
+  log_levels?: string[];
   [key: string]: unknown;
 };
 
@@ -75,6 +76,11 @@ export type SystemLog = {
   [key: string]: unknown;
 };
 
+export type ImageResponse = {
+  created: number;
+  data: Array<{ b64_json: string; revised_prompt?: string }>;
+};
+
 export type LoginResponse = {
   ok: boolean;
   version: string;
@@ -147,7 +153,7 @@ export async function updateAccount(
 }
 
 export async function generateImage(prompt: string, model?: ImageModel, size?: string) {
-  return httpRequest<{ created: number; data: Array<{ b64_json: string; revised_prompt?: string }> }>(
+  return httpRequest<ImageResponse>(
     "/v1/images/generations",
     {
       method: "POST",
@@ -178,7 +184,7 @@ export async function editImage(files: File | File[], prompt: string, model?: Im
   }
   formData.append("n", "1");
 
-  return httpRequest<{ created: number; data: Array<{ b64_json: string; revised_prompt?: string }> }>(
+  return httpRequest<ImageResponse>(
     "/v1/images/edits",
     {
       method: "POST",

web/src/lib/request.ts

@@ -7,6 +7,27 @@ type RequestConfig = AxiosRequestConfig & {
     redirectOnUnauthorized?: boolean;
 };
 
+type ErrorPayload = {
+    detail?: string | { error?: string | { message?: string } };
+    error?: string | { message?: string };
+    message?: string;
+};
+
+function errorMessageFromValue(value: unknown): string {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (!value || typeof value !== "object") {
+        return "";
+    }
+
+    const item = value as { error?: unknown; message?: unknown };
+    if (typeof item.message === "string") {
+        return item.message;
+    }
+    return errorMessageFromValue(item.error);
+}
+
 const request = axios.create({
     baseURL: webConfig.apiUrl.replace(/\/$/, ""),
 });
@@ -26,7 +47,7 @@ request.interceptors.request.use(async (config) => {
 
 request.interceptors.response.use(
     (response) => response,
-    async (error: AxiosError<{ detail?: { error?: string }; error?: string; message?: string }>) => {
+    async (error: AxiosError<ErrorPayload>) => {
         const status = error.response?.status;
         const shouldRedirect = (error.config as RequestConfig | undefined)?.redirectOnUnauthorized !== false;
         if (status === 401 && shouldRedirect && typeof window !== "undefined") {
@@ -42,8 +63,8 @@ request.interceptors.response.use(
 
         const payload = error.response?.data;
         const message =
-            payload?.detail?.error ||
-            payload?.error ||
+            errorMessageFromValue(payload?.detail) ||
+            errorMessageFromValue(payload?.error) ||
             payload?.message ||
             error.message ||
             `请求失败 (${status || 500})`;

web/src/store/image-conversations.ts

@@ -120,7 +120,7 @@ function normalizeTurn(turn: ImageTurn & Record<string, unknown>): ImageTurn {
   return {
     id: String(turn.id || `${Date.now()}`),
     prompt: String(turn.prompt || ""),
-    model: (turn.model as ImageModel) || "auto",
+    model: (turn.model as ImageModel) || "gpt-image-2",
     mode: turn.mode === "edit" ? "edit" : "generate",
     referenceImages: getLegacyReferenceImages(turn),
     count: Math.max(1, Number(turn.count || normalizedImages.length || 1)),
@@ -145,7 +145,7 @@ function normalizeConversation(conversation: ImageConversation & Record<string,
         normalizeTurn({
           id: String(conversation.id || `${Date.now()}`),
           prompt: String(conversation.prompt || ""),
-          model: (conversation.model as ImageModel) || "auto",
+          model: (conversation.model as ImageModel) || "gpt-image-2",
           mode: conversation.mode === "edit" ? "edit" : "generate",
           referenceImages: getLegacyReferenceImages(conversation),
           count: Number(conversation.count || 1),
@@ -174,6 +174,15 @@ function sortImageConversations(conversations: ImageConversation[]): ImageConver
   return [...conversations].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
 }
 
+function getTimestamp(value: string) {
+  const time = new Date(value).getTime();
+  return Number.isFinite(time) ? time : 0;
+}
+
+function pickLatestConversation(current: ImageConversation, next: ImageConversation) {
+  return getTimestamp(next.updatedAt) >= getTimestamp(current.updatedAt) ? next : current;
+}
+
 function queueImageConversationWrite<T>(operation: () => Promise<T>): Promise<T> {
   const result = imageConversationWriteQueue.then(operation);
   imageConversationWriteQueue = result.then(
@@ -185,8 +194,9 @@ function queueImageConversationWrite<T>(operation: () => Promise<T>): Promise<T>
 
 async function readStoredImageConversations(): Promise<ImageConversation[]> {
   const items =
-    (await imageConversationStorage.getItem<Array<ImageConversation & Record<string, unknown>>>(IMAGE_CONVERSATIONS_KEY)) ||
-    [];
+    (await imageConversationStorage.getItem<Array<ImageConversation & Record<string, unknown>>>(
+      IMAGE_CONVERSATIONS_KEY,
+    )) || [];
   return items.map(normalizeConversation);
 }
 
@@ -196,17 +206,28 @@ export async function listImageConversations(): Promise<ImageConversation[]> {
 
 export async function saveImageConversations(conversations: ImageConversation[]): Promise<void> {
   await queueImageConversationWrite(async () => {
-    const normalizedItems = sortImageConversations(conversations.map(normalizeConversation));
-    await imageConversationStorage.setItem(IMAGE_CONVERSATIONS_KEY, normalizedItems);
+    const items = await readStoredImageConversations();
+    const conversationMap = new Map(items.map((item) => [item.id, item]));
+    for (const conversation of conversations.map(normalizeConversation)) {
+      const current = conversationMap.get(conversation.id);
+      conversationMap.set(conversation.id, current ? pickLatestConversation(current, conversation) : conversation);
+    }
+    await imageConversationStorage.setItem(
+      IMAGE_CONVERSATIONS_KEY,
+      sortImageConversations([...conversationMap.values()]),
+    );
   });
 }
 
 export async function saveImageConversation(conversation: ImageConversation): Promise<void> {
   await queueImageConversationWrite(async () => {
     const items = await readStoredImageConversations();
+    const nextConversation = normalizeConversation(conversation);
+    const current = items.find((item) => item.id === nextConversation.id);
+    const persistedConversation = current ? pickLatestConversation(current, nextConversation) : nextConversation;
     const nextItems = sortImageConversations([
-      normalizeConversation(conversation),
-      ...items.filter((item) => item.id !== conversation.id),
+      persistedConversation,
+      ...items.filter((item) => item.id !== persistedConversation.id),
     ]);
     await imageConversationStorage.setItem(IMAGE_CONVERSATIONS_KEY, nextItems);
   });