feat(accounts): 添加Codex账户支持和图像生成功能

- 在账户导入对话框中添加source_type字段，默认设置为codex
- 实现账户服务中的源类型匹配和计划类型匹配方法
- 重构Codex账户导入逻辑，将type转换为export_type并设置source_type
- 扩展API接口支持AccountImportPayload类型和批量账户创建
- 实现Codex图像响应流处理和事件解析功能
- 在CPA和Sub2API服务中更新Codex账户添加逻辑
- 添加Codex图像模型识别和验证工具函数
- 更新图像生成界面支持动态模型选择和Codex模型限制
- 实现Codex后端API集成和账户ID解析功能
- 调整模型列表动态生成逻辑以区分Web和Codex账户类型
- 添加Codex相关常量和请求头配置
- 实现Codex图像生成输入处理和响应失败日志记录

services/account_service.py

@@ -136,6 +136,28 @@ class AccountService:
             return False
         return normalized_plan.lower() == normalized_account.lower()
 
+    @classmethod
+    def _account_matches_source_type(cls, account: dict, source_type: str | None = None) -> bool:
+        if not source_type:
+            return True
+        return cls._normalize_source_type(account.get("source_type")) == cls._normalize_source_type(source_type)
+
+    @classmethod
+    def _account_matches_any_plan_type(cls, account: dict, plan_types: set[str] | tuple[str, ...] | None = None) -> bool:
+        if not plan_types:
+            return True
+        normalized_account = cls._normalize_account_type(account.get("type"))
+        normalized_plans = {
+            normalized
+            for plan_type in plan_types
+            if (normalized := cls._normalize_account_type(plan_type))
+        }
+        return bool(normalized_account and normalized_account in normalized_plans)
+
+    @staticmethod
+    def _normalize_source_type(value: object) -> str:
+        return str(value or "web").strip().lower() or "web"
+
     @staticmethod
     def _normalize_account_type(value: object) -> str | None:
         raw = str(value or "").strip()
@@ -180,13 +202,19 @@ class AccountService:
         normalized = dict(item)
         normalized.pop("accessToken", None)
         normalized["access_token"] = access_token
+        if str(normalized.get("type") or "").strip().lower() == "codex":
+            normalized["export_type"] = "codex"
+            normalized.pop("type", None)
         normalized["type"] = normalized.get("type") or "free"
         normalized["status"] = normalized.get("status") or "正常"
         normalized["quota"] = max(0, int(normalized.get("quota") if normalized.get("quota") is not None else 0))
         normalized["image_quota_unknown"] = bool(normalized.get("image_quota_unknown"))
         normalized["email"] = normalized.get("email") or None
         normalized["user_id"] = normalized.get("user_id") or None
-        normalized["source_type"] = str(normalized.get("source_type") or "web").strip() or "web"
+        source_type = normalized.get("source_type")
+        if not source_type and str(normalized.get("export_type") or "").strip().lower() == "codex":
+            source_type = "codex"
+        normalized["source_type"] = self._normalize_source_type(source_type)
         limits_progress = normalized.get("limits_progress")
         normalized["limits_progress"] = limits_progress if isinstance(limits_progress, list) else []
         normalized["default_model_slug"] = normalized.get("default_model_slug") or None
@@ -474,6 +502,8 @@ class AccountService:
             self,
             excluded_tokens: set[str] | None = None,
             plan_type: str | None = None,
+            source_type: str | None = None,
+            plan_types: set[str] | tuple[str, ...] | None = None,
     ) -> list[str]:
         excluded = set(excluded_tokens or set())
         return [
@@ -481,6 +511,8 @@ class AccountService:
             for item in self._accounts.values()
             if self._is_image_account_available(item)
                and self._account_matches_plan_type(item, plan_type)
+               and self._account_matches_any_plan_type(item, plan_types)
+               and self._account_matches_source_type(item, source_type)
                and (token := item.get("access_token") or "")
                and token not in excluded
         ]
@@ -489,11 +521,13 @@ class AccountService:
             self,
             excluded_tokens: set[str] | None = None,
             plan_type: str | None = None,
+            source_type: str | None = None,
+            plan_types: set[str] | tuple[str, ...] | None = None,
     ) -> list[str]:
         max_concurrency = max(1, int(config.image_account_concurrency or 1))
         return [
             token
-            for token in self._list_ready_candidate_tokens(excluded_tokens, plan_type)
+            for token in self._list_ready_candidate_tokens(excluded_tokens, plan_type, source_type, plan_types)
             if int(self._image_inflight.get(token, 0)) < max_concurrency
         ]
 
@@ -501,14 +535,17 @@ class AccountService:
             self,
             excluded_tokens: set[str] | None = None,
             plan_type: str | None = None,
+            source_type: str | None = None,
+            plan_types: set[str] | tuple[str, ...] | None = None,
     ) -> str:
         with self._image_slot_condition:
             while True:
-                if not self._list_ready_candidate_tokens(excluded_tokens, plan_type):
+                if not self._list_ready_candidate_tokens(excluded_tokens, plan_type, source_type, plan_types):
                     raise RuntimeError(
-                        f"no available {plan_type} image quota" if plan_type else "no available image quota"
+                        f"no available {plan_type or source_type or ''} image quota".replace("  ", " ").strip()
+                        if plan_type or source_type else "no available image quota"
                     )
-                tokens = self._list_available_candidate_tokens(excluded_tokens, plan_type)
+                tokens = self._list_available_candidate_tokens(excluded_tokens, plan_type, source_type, plan_types)
                 if tokens:
                     access_token = tokens[self._index % len(tokens)]
                     self._index += 1
@@ -528,12 +565,19 @@ class AccountService:
                 self._image_inflight[access_token] = current_inflight - 1
             self._image_slot_condition.notify_all()
 
-    def get_available_access_token(self, plan_type: str | None = None) -> str:
+    def get_available_access_token(
+            self,
+            plan_type: str | None = None,
+            source_type: str | None = None,
+            plan_types: set[str] | tuple[str, ...] | None = None,
+    ) -> str:
         attempted_tokens: set[str] = set()
         while True:
             access_token = self._acquire_next_candidate_token(
                 excluded_tokens=attempted_tokens,
                 plan_type=plan_type,
+                source_type=source_type,
+                plan_types=plan_types,
             )
             attempted_tokens.add(access_token)
             try:
@@ -541,7 +585,12 @@ class AccountService:
             except Exception:
                 self.release_image_slot(access_token)
                 continue
-            if self._is_image_account_available(account or {}):
+            if (
+                    self._is_image_account_available(account or {})
+                    and self._account_matches_plan_type(account or {}, plan_type)
+                    and self._account_matches_any_plan_type(account or {}, plan_types)
+                    and self._account_matches_source_type(account or {}, source_type)
+            ):
                 return str((account or {}).get("access_token") or access_token)
             self.release_image_slot(access_token)
 
@@ -627,7 +676,10 @@ class AccountService:
         # CPA/Codex 导出文件里的 `type=codex` 是导出格式，不是号池套餐类型。
         if str(payload.get("type") or "").strip().lower() == "codex":
             payload["export_type"] = "codex"
+            payload["source_type"] = "codex"
             payload.pop("type", None)
+        if str(payload.get("export_type") or "").strip().lower() == "codex":
+            payload["source_type"] = "codex"
         if payload.get("plan_type") and not payload.get("type"):
             payload["type"] = str(payload.get("plan_type") or "").strip()
         return payload
@@ -640,11 +692,14 @@ class AccountService:
         ]
         return self._add_account_payloads(payloads)
 
-    def add_accounts(self, tokens: list[str]) -> dict:
+    def add_accounts(self, tokens: list[str], source_type: str = "web") -> dict:
         tokens = list(dict.fromkeys(token for token in tokens if token))
         if not tokens:
             return {"added": 0, "skipped": 0, "items": self.list_accounts()}
-        return self._add_account_payloads([{"access_token": token, "source_type": "web"} for token in tokens])
+        return self._add_account_payloads([
+            {"access_token": token, "source_type": self._normalize_source_type(source_type)}
+            for token in tokens
+        ])
 
     def _add_account_payloads(self, payloads: list[dict]) -> dict:
         deduped: dict[str, dict] = {}

services/cpa_service.py

@@ -297,7 +297,7 @@ class CPAImportService:
             )
             return
 
-        add_result = account_service.add_accounts(tokens)
+        add_result = account_service.add_accounts(tokens, source_type="codex")
         refresh_result = account_service.refresh_accounts(tokens)
         current = self._config.get_import_job(pool_id) or {}
         self._update_job(

services/openai_backend_api.py

@@ -1,4 +1,5 @@
 import base64
+import json
 import os
 import random
 import re
@@ -43,6 +44,16 @@ 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_RESPONSES_MODEL = "gpt-5.5"
+CODEX_RESPONSES_VERSION = "0.122.0"
+CODEX_RESPONSES_USER_AGENT = (
+    "codex-tui/0.122.0 (Manjaro 26.1.0-pre; x86_64) "
+    "vscode/3.0.12 (codex-tui; 0.122.0)"
+)
+CODEX_RESPONSES_INSTRUCTIONS = (
+    "Use the image_generation tool to create exactly one image for the user's request. "
+    "Return the generated image result."
+)
 
 
 class OpenAIBackendAPI:
@@ -145,6 +156,26 @@ class OpenAIBackendAPI:
             headers.update(extra)
         return headers
 
+    @staticmethod
+    def _decode_token_payload(token: str) -> Dict[str, Any]:
+        try:
+            payload = str(token or "").split(".")[1]
+            payload += "=" * ((4 - len(payload) % 4) % 4)
+            data = json.loads(base64.urlsafe_b64decode(payload.encode("ascii")))
+            return data if isinstance(data, dict) else {}
+        except Exception:
+            return {}
+
+    def _chatgpt_account_id(self) -> str:
+        account = account_service.get_account(self.access_token) if self.access_token else {}
+        account = account if isinstance(account, dict) else {}
+        if str(account.get("account_id") or "").strip():
+            return str(account.get("account_id") or "").strip()
+        payload = self._decode_token_payload(self.access_token)
+        auth_claim = payload.get("https://api.openai.com/auth")
+        auth_claim = auth_claim if isinstance(auth_claim, dict) else {}
+        return str(auth_claim.get("chatgpt_account_id") or account.get("user_id") or "").strip()
+
     @staticmethod
     def _extract_quota_and_restore_at(limits_progress: list[Any]) -> tuple[int, str | None, bool]:
         for item in limits_progress:
@@ -424,6 +455,144 @@ class OpenAIBackendAPI:
             headers["X-Oai-Turn-Trace-Id"] = new_uuid()
         return self._headers(path, headers)
 
+    def _codex_responses_headers(self) -> Dict[str, str]:
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "User-Agent": CODEX_RESPONSES_USER_AGENT,
+            "version": CODEX_RESPONSES_VERSION,
+            "originator": "codex_cli_rs",
+            "session_id": self.session_id,
+            "Accept": "text/event-stream",
+            "Content-Type": "application/json",
+        }
+        account_id = self._chatgpt_account_id()
+        if account_id:
+            headers["chatgpt-account-id"] = account_id
+        return headers
+
+    def _ensure_codex_source_account(self) -> None:
+        account = account_service.get_account(self.access_token)
+        source_type = str((account or {}).get("source_type") or "web").strip().lower()
+        if source_type != "codex":
+            raise RuntimeError("codex responses endpoint requires a codex source account")
+
+    @staticmethod
+    def _codex_image_input(prompt: str, images: list[str]) -> list[Dict[str, Any]]:
+        content: list[Dict[str, Any]] = [{"type": "input_text", "text": prompt}]
+        for image in images:
+            payload = image if image.startswith("data:image/") else f"data:image/png;base64,{image}"
+            content.append({"type": "input_image", "image_url": payload})
+        return [{"role": "user", "content": content}]
+
+    @staticmethod
+    def _codex_body_preview(body: Any, limit: int = 4000) -> str:
+        if isinstance(body, (dict, list)):
+            try:
+                text = json.dumps(body, ensure_ascii=False)
+            except Exception:
+                text = repr(body)
+        else:
+            text = str(body or "")
+        return text if len(text) <= limit else text[:limit] + "...[truncated]"
+
+    def _log_codex_response_failure(
+            self,
+            path: str,
+            response: requests.Response,
+            payload: Dict[str, Any],
+            body: Any,
+    ) -> None:
+        request_headers = self._codex_responses_headers()
+        safe_request_headers = {
+            key: value for key, value in request_headers.items() if key.lower() != "authorization"
+        }
+        tool = ((payload.get("tools") or [{}])[0]) if isinstance(payload.get("tools"), list) else {}
+        logger.warning({
+            "event": "codex_responses_http_error",
+            "path": path,
+            "status_code": response.status_code,
+            "request": {
+                "model": payload.get("model"),
+                "tool_model": tool.get("model"),
+                "tool_action": tool.get("action"),
+                "size": tool.get("size"),
+                "quality": tool.get("quality"),
+                "image_input_count": max(len((payload.get("input") or [{}])[0].get("content") or []) - 1, 0),
+                "prompt_preview": self._codex_body_preview(
+                    (((payload.get("input") or [{}])[0].get("content") or [{}])[0].get("text") or ""),
+                    500,
+                ),
+                "headers": safe_request_headers,
+            },
+            "response": {
+                "headers": dict(response.headers or {}),
+                "body_preview": self._codex_body_preview(body),
+            },
+        })
+
+    def iter_codex_image_response_events(
+            self,
+            prompt: str,
+            images: list[str] | None = None,
+            size: str | None = None,
+            quality: str = "auto",
+    ) -> Iterator[Dict[str, Any]]:
+        if not self.access_token:
+            raise RuntimeError("access_token is required for codex image endpoints")
+        self._ensure_codex_source_account()
+        path = "/backend-api/codex/responses"
+        payload = {
+            "model": CODEX_RESPONSES_MODEL,
+            "instructions": CODEX_RESPONSES_INSTRUCTIONS,
+            "store": False,
+            "input": self._codex_image_input(prompt, images or []),
+            "tools": [{
+                "type": "image_generation",
+                "model": "gpt-image-2",
+                "action": "edit" if images else "generate",
+                "size": str(size or "1024x1024"),
+                "quality": str(quality or "auto"),
+                "output_format": "png",
+            }],
+            "tool_choice": {"type": "image_generation"},
+            "stream": True,
+        }
+        response = self.session.post(
+            self.base_url + path,
+            headers=self._codex_responses_headers(),
+            json=payload,
+            timeout=1200,
+            stream=True,
+        )
+        try:
+            if not 200 <= response.status_code < 300:
+                body: Any = response.text
+                try:
+                    body = response.json()
+                except Exception:
+                    pass
+                self._log_codex_response_failure(path, response, payload, body)
+                retry_after_header = response.headers.get("Retry-After") if hasattr(response, "headers") else None
+                retry_after = int(retry_after_header) if str(retry_after_header or "").isdigit() else None
+                raise UpstreamHTTPError(path, response.status_code, body, retry_after=retry_after)
+            content_type = str(response.headers.get("content-type") or "").lower()
+            if "application/json" in content_type:
+                data = response.json()
+                if isinstance(data, dict):
+                    yield data
+                return
+            for payload_text in iter_sse_payloads(response):
+                if payload_text == "[DONE]":
+                    break
+                try:
+                    data = json.loads(payload_text)
+                except Exception:
+                    continue
+                if isinstance(data, dict):
+                    yield data
+        finally:
+            response.close()
+
     def _prepare_image_conversation(self, prompt: str, requirements: ChatRequirements, model: str) -> str:
         """为图片生成准备 conduit token。"""
         path = "/backend-api/f/conversation/prepare"

services/protocol/conversation.py

@@ -13,7 +13,13 @@ from services.account_service import account_service
 from services.config import config
 from services.image_storage_service import image_storage_service
 from services.openai_backend_api import ImagePollTimeoutError, OpenAIBackendAPI
-from utils.helper import IMAGE_MODELS, extract_image_from_message_content, is_supported_image_model, split_image_model
+from utils.helper import (
+    IMAGE_MODELS,
+    extract_image_from_message_content,
+    is_codex_image_model,
+    is_supported_image_model,
+    split_image_model,
+)
 from utils.image_tokens import count_image_content_tokens
 from utils.log import logger
 
@@ -622,6 +628,77 @@ def stream_image_outputs(
         yield ImageOutput(kind="message", model=request.model, index=index, total=total, text=message)
 
 
+def _codex_response_images(value: Any) -> list[str]:
+    if isinstance(value, dict):
+        if value.get("type") == "image_generation_call" and isinstance(value.get("result"), str):
+            result = value["result"].strip()
+            if result:
+                return [result.split(",", 1)[1] if result.startswith("data:image/") else result]
+        images: list[str] = []
+        for item in value.values():
+            images.extend(_codex_response_images(item))
+        return images
+    if isinstance(value, list):
+        images: list[str] = []
+        for item in value:
+            images.extend(_codex_response_images(item))
+        return images
+    return []
+
+
+def stream_codex_image_outputs(
+        backend: OpenAIBackendAPI,
+        request: ConversationRequest,
+        index: int = 1,
+        total: int = 1,
+) -> Iterator[ImageOutput]:
+    prompt = prompt_with_global_system(build_image_prompt(request.prompt, request.size, request.quality))
+    text_parts: list[str] = []
+    for event in backend.iter_codex_image_response_events(
+            prompt=prompt,
+            images=request.images or [],
+            size=request.size,
+            quality=request.quality,
+    ):
+        event_type = str(event.get("type") or "")
+        if event_type == "response.output_text.delta":
+            delta = str(event.get("delta") or "")
+            if delta:
+                text_parts.append(delta)
+                yield ImageOutput(
+                    kind="progress",
+                    model=request.model,
+                    index=index,
+                    total=total,
+                    text=delta,
+                    upstream_event_type=event_type,
+                )
+            continue
+        images = _codex_response_images(event)
+        if images:
+            data = format_image_result(
+                [{"b64_json": item, "revised_prompt": request.prompt} for item in images],
+                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 event_type:
+            yield ImageOutput(
+                kind="progress",
+                model=request.model,
+                index=index,
+                total=total,
+                upstream_event_type=event_type,
+            )
+    message = "".join(text_parts).strip()
+    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 not is_supported_image_model(request.model):
         raise ImageGenerationError("unsupported image model,supported models: " + ", ".join(sorted(IMAGE_MODELS)))
@@ -632,7 +709,12 @@ def stream_image_outputs_with_pool(request: ConversationRequest) -> Iterator[Ima
         while True:
             try:
                 plan_type, _ = split_image_model(request.model)
-                token = account_service.get_available_access_token(plan_type=plan_type)
+                codex_model = is_codex_image_model(request.model)
+                token = account_service.get_available_access_token(
+                    plan_type=plan_type,
+                    source_type="codex" if codex_model else None,
+                    plan_types=("plus", "team", "pro") if codex_model and not plan_type else None,
+                )
             except RuntimeError as exc:
                 if emitted:
                     return
@@ -643,7 +725,8 @@ def stream_image_outputs_with_pool(request: ConversationRequest) -> Iterator[Ima
             returned_result = False
             try:
                 backend = OpenAIBackendAPI(access_token=token)
-                for output in stream_image_outputs(backend, request, index, request.n):
+                stream_fn = stream_codex_image_outputs if is_codex_image_model(request.model) else stream_image_outputs
+                for output in stream_fn(backend, request, index, request.n):
                     if output.kind == "message" and request.message_as_error:
                         raise ImageGenerationError(
                             output.text or "Image generation was rejected by upstream policy.",

services/protocol/openai_v1_models.py

@@ -15,22 +15,28 @@ def list_models() -> dict[str, Any]:
     seen = {str(item.get("id") or "").strip() for item in data if isinstance(item, dict)}
     dynamic_models: set[str] = set()
     accounts = account_service.list_accounts()
-    normalized_types = {
+    web_image_accounts = [
+        account
+        for account in accounts
+        if isinstance(account, dict)
+    ]
+    codex_types = {
         normalized
         for account in accounts
         if isinstance(account, dict)
+           and account_service._normalize_source_type(account.get("source_type")) == "codex"
            and (normalized := account_service._normalize_account_type(account.get("type")))
     }
 
-    if accounts:
+    if web_image_accounts:
         dynamic_models.add("gpt-image-2")
-    if normalized_types & {"Plus", "Team", "Pro"}:
+    if codex_types & {"Plus", "Team", "Pro"}:
         dynamic_models.add(CODEX_IMAGE_MODEL)
-    if "Plus" in normalized_types:
+    if "Plus" in codex_types:
         dynamic_models.add(f"plus-{CODEX_IMAGE_MODEL}")
-    if "Team" in normalized_types:
+    if "Team" in codex_types:
         dynamic_models.add(f"team-{CODEX_IMAGE_MODEL}")
-    if "Pro" in normalized_types:
+    if "Pro" in codex_types:
         dynamic_models.add(f"pro-{CODEX_IMAGE_MODEL}")
 
     for model in sorted(dynamic_models):

services/sub2api_service.py

@@ -505,7 +505,7 @@ class Sub2APIImportService:
             )
             return
 
-        add_result = account_service.add_accounts(tokens)
+        add_result = account_service.add_accounts(tokens, source_type="codex")
         refresh_result = account_service.refresh_accounts(tokens)
         current = self._config.get_import_job(server_id) or {}
         self._update_job(

test/test_v1_models.py

@@ -26,7 +26,8 @@ class ModelListTests(unittest.TestCase):
                 "list_accounts",
                 return_value=[
                     {"access_token": "token-free", "type": "free"},
-                    {"access_token": "token-team", "type": "Team"},
+                    {"access_token": "token-web-team", "type": "Team", "source_type": "web"},
+                    {"access_token": "token-codex-team", "type": "Team", "source_type": "codex"},
                 ],
             ),
         ):
@@ -39,6 +40,28 @@ class ModelListTests(unittest.TestCase):
         self.assertNotIn("plus-codex-gpt-image-2", ids)
         self.assertNotIn("pro-codex-gpt-image-2", ids)
 
+    def test_list_models_does_not_return_codex_models_for_web_plus_accounts(self):
+        with (
+            mock.patch.object(
+                openai_v1_models.OpenAIBackendAPI,
+                "list_models",
+                return_value={"object": "list", "data": []},
+            ),
+            mock.patch.object(
+                openai_v1_models.account_service,
+                "list_accounts",
+                return_value=[
+                    {"access_token": "token-web-plus", "type": "Plus", "source_type": "web"},
+                ],
+            ),
+        ):
+            result = openai_v1_models.list_models()
+
+        ids = {item["id"] for item in result["data"]}
+        self.assertIn("gpt-image-2", ids)
+        self.assertNotIn("codex-gpt-image-2", ids)
+        self.assertNotIn("plus-codex-gpt-image-2", ids)
+
     def test_list_models_function(self):
         """测试直接调用服务层获取模型列表。"""
         result = openai_v1_models.list_models()

utils/helper.py

@@ -122,6 +122,11 @@ def is_supported_image_model(model: object) -> bool:
     return base_model is not None
 
 
+def is_codex_image_model(model: object) -> bool:
+    _, base_model = split_image_model(model)
+    return base_model == CODEX_IMAGE_MODEL
+
+
 def is_image_chat_request(body: dict[str, object]) -> bool:
     model = str(body.get("model") or "").strip()
     modalities = body.get("modalities")

web/src/app/accounts/components/account-import-dialog.tsx

@@ -71,6 +71,7 @@ function getCpaAccount(value: unknown): AccountImportPayload | null {
   const payload: AccountImportPayload = {
     ...raw,
     access_token: token,
+    source_type: "codex",
   };
   delete payload.accessToken;
   if (payload.type === "codex") {

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

@@ -19,6 +19,7 @@ type ImageComposerProps = {
   imageHeight: string;
   imageQuality: string;
   imageModel: ImageModel;
+  imageModels: ImageModel[];
   availableQuota: string;
   activeTaskCount: number;
   referenceImages: Array<{ name: string; dataUrl: string }>;
@@ -62,14 +63,6 @@ const qualityOptions = [
   { value: "medium", label: "中" },
   { value: "high", label: "高" },
 ];
-const modelOptions: Array<{ value: ImageModel; label: string }> = [
-  { value: "gpt-image-2", label: "gpt-image-2" },
-  { value: "codex-gpt-image-2", label: "codex-gpt-image-2" },
-  { value: "plus-codex-gpt-image-2", label: "plus-codex-gpt-image-2" },
-  { value: "team-codex-gpt-image-2", label: "team-codex-gpt-image-2" },
-  { value: "pro-codex-gpt-image-2", label: "pro-codex-gpt-image-2" },
-];
-
 const aspectOptions = [
   { ratio: "1:1", tier: "1k", width: "1024", height: "1024", label: "1:1", icon: Square },
   { ratio: "2:3", tier: "1k", width: "1024", height: "1536", label: "2:3", icon: RectangleVertical },
@@ -96,6 +89,7 @@ export function ImageComposer({
   imageHeight,
   imageQuality,
   imageModel,
+  imageModels,
   availableQuota,
   activeTaskCount,
   referenceImages,
@@ -125,10 +119,15 @@ export function ImageComposer({
     () => referenceImages.map((image, index) => ({ id: `${image.name}-${index}`, src: image.dataUrl })),
     [referenceImages],
   );
+  const modelOptions = useMemo(
+    () => imageModels.map((model) => ({ value: model, label: model })),
+    [imageModels],
+  );
   const qualityLabel = qualityOptions.find((option) => option.value === imageQuality)?.label || "自动";
   const ratioLabel = imageRatio === "auto" ? "auto" : `${imageRatio}(${imageTier})`;
   const imageSizeLabel = `${qualityLabel} · ${ratioLabel} · ${imageCount || 1} 张`;
   const selectedModelLabel = modelOptions.find((option) => option.value === imageModel)?.label || imageModel;
+  const isCodexModel = imageModel.toLowerCase().includes("codex");
 
   useEffect(() => {
     if (!isSizeMenuOpen) {
@@ -453,15 +452,21 @@ export function ImageComposer({
                             {aspectOptions.map((option) => {
                               const active = option.ratio === imageRatio && option.tier === imageTier && option.width === imageWidth && option.height === imageHeight;
                               const Icon = option.icon;
+                              const disabled = !isCodexModel && (option.tier === "2k" || option.tier === "4k");
                               return (
                                 <button
                                   key={`${option.ratio}-${option.tier}-${option.label}`}
                                   type="button"
+                                  disabled={disabled}
                                   className={cn(
                                     "flex h-[64px] cursor-pointer flex-col items-center justify-center gap-1 rounded-2xl border border-stone-200 bg-white text-sm text-stone-800 transition hover:border-stone-300 hover:bg-stone-50",
                                     active && "border-stone-950",
+                                    disabled && "cursor-not-allowed border-stone-100 bg-stone-50 text-stone-300 hover:border-stone-100 hover:bg-stone-50",
                                   )}
                                   onClick={() => {
+                                    if (disabled) {
+                                      return;
+                                    }
                                     onImageRatioChange(option.ratio);
                                     onImageTierChange(option.tier);
                                     onImageWidthChange(option.width);

web/src/app/image/page.tsx

@@ -21,9 +21,11 @@ import {
   createImageEditTask,
   createImageGenerationTask,
   fetchAccounts,
+  fetchModels,
   fetchImageTasks,
   type Account,
   type ImageModel,
+  type Model,
   type ImageTask,
 } from "@/lib/api";
 import { useAuthGuard } from "@/lib/use-auth-guard";
@@ -50,13 +52,6 @@ const IMAGE_QUALITY_STORAGE_KEY = "chatgpt2api:image_last_quality";
 const IMAGE_MODEL_STORAGE_KEY = "chatgpt2api:image_last_model";
 const IMAGE_COUNT_STORAGE_KEY = "chatgpt2api:image_last_count";
 const SCROLL_TO_LATEST_THRESHOLD = 160;
-const SUPPORTED_IMAGE_MODELS: ImageModel[] = [
-  "gpt-image-2",
-  "codex-gpt-image-2",
-  "plus-codex-gpt-image-2",
-  "team-codex-gpt-image-2",
-  "pro-codex-gpt-image-2",
-];
 
 function clampImageCount(value: string) {
   return String(Math.min(100, Math.max(1, Math.floor(Number(value) || 1))));
@@ -125,8 +120,18 @@ function dataUrlToFile(dataUrl: string, fileName: string, mimeType?: string) {
   return new File([bytes], fileName, { type: mimeType || matchedMimeType || "image/png" });
 }
 
-function normalizeStoredImageModel(value: string | null): ImageModel {
-  return SUPPORTED_IMAGE_MODELS.includes(value as ImageModel) ? (value as ImageModel) : "gpt-image-2";
+function filterImageModels(items: Model[]): ImageModel[] {
+  return items
+    .map((item) => String(item.id || "").trim())
+    .filter((id, index, list) => id.toLowerCase().includes("image") && list.indexOf(id) === index);
+}
+
+function normalizeStoredImageModel(value: string | null, availableModels: ImageModel[]): ImageModel {
+  const normalized = String(value || "").trim();
+  if (normalized && availableModels.includes(normalized)) {
+    return normalized;
+  }
+  return availableModels[0] || "gpt-image-2";
 }
 
 function buildReferenceImageFromResult(image: StoredImage, fileName: string): StoredReferenceImage | null {
@@ -380,6 +385,7 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
   const [imageHeight, setImageHeight] = useState("1024");
   const [imageQuality, setImageQuality] = useState("auto");
   const [imageModel, setImageModel] = useState<ImageModel>("gpt-image-2");
+  const [imageModels, setImageModels] = useState<ImageModel[]>(["gpt-image-2"]);
   const [isHistoryOpen, setIsHistoryOpen] = useState(false);
   const [referenceImageFiles, setReferenceImageFiles] = useState<File[]>([]);
   const [referenceImages, setReferenceImages] = useState<StoredReferenceImage[]>([]);
@@ -485,14 +491,12 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
         const storedRatio = typeof window !== "undefined" ? window.localStorage.getItem(IMAGE_RATIO_STORAGE_KEY) : null;
         const storedTier = typeof window !== "undefined" ? window.localStorage.getItem(IMAGE_TIER_STORAGE_KEY) : null;
         const storedQuality = typeof window !== "undefined" ? window.localStorage.getItem(IMAGE_QUALITY_STORAGE_KEY) : null;
-        const storedModel = typeof window !== "undefined" ? window.localStorage.getItem(IMAGE_MODEL_STORAGE_KEY) : null;
         const storedCount = typeof window !== "undefined" ? window.localStorage.getItem(IMAGE_COUNT_STORAGE_KEY) : null;
         setImageRatio(storedRatio || "1:1");
         setImageTier(storedTier || "1k");
         setImageWidth("1024");
         setImageHeight("1024");
         setImageQuality(storedQuality || "auto");
-        setImageModel(normalizeStoredImageModel(storedModel));
         setImageCount(storedCount ? clampImageCount(storedCount) : "1");
 
         const items = await listImageConversations();
@@ -526,6 +530,37 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
     };
   }, []);
 
+  useEffect(() => {
+    let cancelled = false;
+
+    const loadImageModels = async () => {
+      try {
+        const data = await fetchModels();
+        const available = filterImageModels(Array.isArray(data.data) ? data.data : []);
+        if (cancelled || available.length === 0) {
+          return;
+        }
+        setImageModels(available);
+        const storedModel = typeof window !== "undefined" ? window.localStorage.getItem(IMAGE_MODEL_STORAGE_KEY) : null;
+        setImageModel((current) => {
+          if (available.includes(current)) {
+            return current;
+          }
+          return normalizeStoredImageModel(storedModel, available);
+        });
+      } catch {
+        if (!cancelled) {
+          setImageModels(["gpt-image-2"]);
+        }
+      }
+    };
+
+    void loadImageModels();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
   const loadQuota = useCallback(async () => {
     if (!isAdmin) {
       setAvailableQuota("--");
@@ -1364,6 +1399,7 @@ function ImagePageContent({ isAdmin }: { isAdmin: boolean }) {
             imageHeight={imageHeight}
             imageQuality={imageQuality}
             imageModel={imageModel}
+            imageModels={imageModels}
             availableQuota={availableQuota}
             activeTaskCount={activeTaskCount}
             referenceImages={referenceImages}

web/src/lib/api.ts

@@ -2,12 +2,7 @@ import { httpRequest, request } from "@/lib/request";
 
 export type AccountType = string;
 export type AccountStatus = "正常" | "限流" | "异常" | "禁用";
-export type ImageModel =
-  | "gpt-image-2"
-  | "codex-gpt-image-2"
-  | "plus-codex-gpt-image-2"
-  | "team-codex-gpt-image-2"
-  | "pro-codex-gpt-image-2";
+export type ImageModel = string;
 export type AuthRole = "admin" | "user";
 export type ImageStorageMode = "local" | "webdav" | "both";
 
@@ -42,6 +37,15 @@ export type Account = {
   last_used_at?: string | null;
 };
 
+export type AccountImportPayload = {
+  access_token: string;
+  accessToken?: string;
+  type?: string;
+  export_type?: string;
+  source_type?: string;
+  [key: string]: unknown;
+};
+
 export type Model = {
   id: string;
   object: string;
@@ -292,10 +296,10 @@ export async function fetchModels() {
   return httpRequest<ModelListResponse>("/v1/models");
 }
 
-export async function createAccounts(tokens: string[]) {
+export async function createAccounts(tokens: string[], accounts: AccountImportPayload[] = []) {
   return httpRequest<AccountMutationResponse>("/api/accounts", {
     method: "POST",
-    body: { tokens },
+    body: { tokens, accounts },
   });
 }