fix: report invalid token refresh failures

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

services/account_service.py

@@ -1,37 +1,21 @@
 from __future__ import annotations
 
 from concurrent.futures import ThreadPoolExecutor, as_completed
-import base64
-import hashlib
-import json
 from threading import Lock
 from typing import Any
 from datetime import datetime
 
-from curl_cffi.requests import Session
-
 from services.config import config
 from services.log_service import (
     LOG_TYPE_ACCOUNT,
     log_service,
 )
-from services.proxy_service import proxy_settings
 from services.storage.base import StorageBackend
 from utils.helper import anonymize_token
 
 
 class AccountService:
-    ACCOUNT_TYPE_MAP = {
-        "free": "Free",
-        "plus": "Plus",
-        "prolite": "ProLite",
-        "pro_lite": "ProLite",
-        "team": "Team",
-        "pro": "Pro",
-        "personal": "Plus",
-        "business": "Team",
-        "enterprise": "Team",
-    }
+    """账号池服务，使用 token -> account 的 dict 保存账号。"""
 
     def __init__(self, storage_backend: StorageBackend):
         self.storage = storage_backend
@@ -39,198 +23,61 @@ class AccountService:
         self._index = 0
         self._accounts = self._load_accounts()
 
-    @staticmethod
-    def _clean_token(value: Any) -> str:
-        return str(value or "").strip()
-
-    def _clean_tokens(self, tokens: list[str]) -> list[str]:
-        cleaned: list[str] = []
-        seen = set()
-        for token in tokens:
-            value = self._clean_token(token)
-            if value and value not in seen:
-                seen.add(value)
-                cleaned.append(value)
-        return cleaned
-
-    def _find_account_index(self, access_token: str) -> int:
-        for index, item in enumerate(self._accounts):
-            if self._clean_token(item.get("access_token")) == access_token:
-                return index
-        return -1
+    def _load_accounts(self) -> dict[str, dict]:
+        accounts = self.storage.load_accounts()
+        return {
+            normalized["access_token"]: normalized
+            for item in accounts
+            if (normalized := self._normalize_account(item)) is not None
+        }
+
+    def _save_accounts(self) -> None:
+        self.storage.save_accounts(list(self._accounts.values()))
 
     @staticmethod
     def _is_image_account_available(account: dict) -> bool:
         if not isinstance(account, dict):
             return False
-        status = str(account.get("status") or "").strip()
-        if status in {"禁用", "限流", "异常"}:
+        if account.get("status") in {"禁用", "限流", "异常"}:
             return False
         if bool(account.get("image_quota_unknown")):
             return True
         return int(account.get("quota") or 0) > 0
 
-    def _decode_access_token_payload(self, access_token: str) -> dict[str, Any]:
-        parts = self._clean_token(access_token).split(".")
-        if len(parts) < 2:
-            return {}
-        payload = parts[1]
-        payload += "=" * (-len(payload) % 4)
-        try:
-            decoded = base64.urlsafe_b64decode(payload.encode("utf-8"))
-            data = json.loads(decoded.decode("utf-8"))
-        except Exception:
-            return {}
-        return data if isinstance(data, dict) else {}
-
-    def _normalize_account_type(self, value: Any) -> str | None:
-        return self.ACCOUNT_TYPE_MAP.get(self._clean_token(value).lower())
-
-    def _search_account_type(self, value: Any) -> str | None:
-        if isinstance(value, dict):
-            for key, item in value.items():
-                key_text = self._clean_token(key).lower()
-                if any(flag in key_text for flag in ("plan", "type", "subscription", "workspace", "tier")):
-                    matched = self._normalize_account_type(item)
-                    if matched:
-                        return matched
-                    matched = self._search_account_type(item)
-                    if matched:
-                        return matched
-            return None
-        if isinstance(value, list):
-            for item in value:
-                matched = self._search_account_type(item)
-                if matched:
-                    return matched
-            return None
-        return None
-
-    def _detect_account_type(self, access_token: str, me_payload: Any, init_payload: Any) -> str:
-        token_payload = self._decode_access_token_payload(access_token)
-
-        auth_payload = token_payload.get("https://api.openai.com/auth")
-        print("检测账户类型响应", auth_payload)
-        if isinstance(auth_payload, dict):
-            matched = self._normalize_account_type(auth_payload.get("chatgpt_plan_type"))
-            if matched:
-                return matched
-
-        for payload in (me_payload, init_payload, token_payload):
-            matched = self._search_account_type(payload)
-            if matched:
-                return matched
-
-        return "Free"
-
     def _normalize_account(self, item: dict) -> dict | None:
         if not isinstance(item, dict):
             return None
-        access_token = self._clean_token(item.get("access_token"))
+        access_token = item.get("access_token") or ""
         if not access_token:
             return None
         normalized = dict(item)
         normalized["access_token"] = access_token
-        normalized["type"] = self._clean_token(normalized.get("type")) or "Free"
-        normalized["status"] = self._clean_token(normalized.get("status")) or "正常"
-        normalized["quota"] = int(normalized.get("quota") if normalized.get("quota") is not None else 0)
-        if normalized["quota"] < 0:
-            normalized["quota"] = 0
+        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"] = self._clean_token(normalized.get("email")) or None
-        normalized["user_id"] = self._clean_token(normalized.get("user_id")) or None
+        normalized["email"] = normalized.get("email") or None
+        normalized["user_id"] = normalized.get("user_id") or None
         limits_progress = normalized.get("limits_progress")
         normalized["limits_progress"] = limits_progress if isinstance(limits_progress, list) else []
-        normalized["default_model_slug"] = self._clean_token(normalized.get("default_model_slug")) or None
-        normalized["restore_at"] = self._clean_token(normalized.get("restore_at")) or None
+        normalized["default_model_slug"] = normalized.get("default_model_slug") or None
+        normalized["restore_at"] = normalized.get("restore_at") or None
         normalized["success"] = int(normalized.get("success") or 0)
         normalized["fail"] = int(normalized.get("fail") or 0)
         normalized["last_used_at"] = normalized.get("last_used_at")
         return normalized
 
-    @staticmethod
-    def _extract_quota_and_restore_at(limits_progress: list[Any]) -> tuple[int, str | None, bool]:
-        quota = 0
-        restore_at = None
-        for item in limits_progress:
-            if not isinstance(item, dict) or item.get("feature_name") != "image_gen":
-                continue
-            quota = int(item.get("remaining") or 0)
-            restore_at = str(item.get("reset_after") or "").strip() or None
-            return quota, restore_at, False
-        return quota, restore_at, True
-
-    def _load_accounts(self) -> list[dict]:
-        accounts = self.storage.load_accounts()
-        return [normalized for item in accounts if (normalized := self._normalize_account(item)) is not None]
-
-    def _save_accounts(self) -> None:
-        self.storage.save_accounts(self._accounts)
-
-    def _build_remote_headers(self, access_token: str) -> tuple[dict[str, str], str]:
-        account = self.get_account(access_token) or {}
-        user_agent = self._clean_token(account.get("user-agent") or account.get("user_agent"))
-        impersonate = self._clean_token(account.get("impersonate")) or "edge101"
-        headers = {
-            "authorization": f"Bearer {access_token}",
-            "accept": "*/*",
-            "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
-            "content-type": "application/json",
-            "oai-language": "zh-CN",
-            "origin": "https://chatgpt.com",
-            "referer": "https://chatgpt.com/",
-            "sec-fetch-dest": "empty",
-            "sec-fetch-mode": "cors",
-            "sec-fetch-site": "same-origin",
-            "user-agent": user_agent
-                          or "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
-                             "(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-            "sec-ch-ua": self._clean_token(account.get("sec-ch-ua"))
-                         or '"Google Chrome";v="147", "Not.A/Brand";v="8", "Chromium";v="147"',
-            "sec-ch-ua-mobile": self._clean_token(account.get("sec-ch-ua-mobile")) or "?0",
-            "sec-ch-ua-platform": self._clean_token(account.get("sec-ch-ua-platform")) or '"Windows"',
-        }
-        device_id = self._clean_token(account.get("oai-device-id") or account.get("oai_device_id"))
-        session_id = self._clean_token(account.get("oai-session-id") or account.get("oai_session_id"))
-        if device_id:
-            headers["oai-device-id"] = device_id
-        if session_id:
-            headers["oai-session-id"] = session_id
-        return headers, impersonate
-
-    def _public_items(self, accounts: list[dict]) -> list[dict]:
-        return [
-            {
-                "id": hashlib.sha1(access_token.encode("utf-8")).hexdigest()[:16],
-                "access_token": access_token,
-                "type": account.get("type") or "Free",
-                "status": account.get("status") or "正常",
-                "quota": account.get("quota") if account.get("quota") is not None else 0,
-                "imageQuotaUnknown": bool(account.get("image_quota_unknown")),
-                "email": account.get("email"),
-                "user_id": account.get("user_id"),
-                "limits_progress": account.get("limits_progress") or [],
-                "default_model_slug": account.get("default_model_slug"),
-                "restoreAt": account.get("restore_at"),
-                "success": int(account.get("success") or 0),
-                "fail": int(account.get("fail") or 0),
-                "lastUsedAt": account.get("last_used_at"),
-            }
-            for account in accounts
-            if (access_token := self._clean_token(account.get("access_token")))
-        ]
-
     def list_tokens(self) -> list[str]:
         with self._lock:
-            return [token for item in self._accounts if (token := self._clean_token(item.get("access_token")))]
+            return list(self._accounts)
 
     def _list_available_candidate_tokens(self, excluded_tokens: set[str] | None = None) -> list[str]:
-        excluded = {self._clean_token(token) for token in (excluded_tokens or set()) if self._clean_token(token)}
+        excluded = set(excluded_tokens or set())
         return [
             token
-            for item in self._accounts
+            for item in self._accounts.values()
             if self._is_image_account_available(item)
-               and (token := self._clean_token(item.get("access_token")))
+               and (token := item.get("access_token") or "")
                and token not in excluded
         ]
 
@@ -243,49 +90,26 @@ class AccountService:
             self._index += 1
             return access_token
 
-    def refresh_account_state(self, access_token: str) -> dict | None:
-        token_ref = anonymize_token(access_token)
-        try:
-            remote_info = self.fetch_remote_info(access_token)
-        except Exception as exc:
-            message = str(exc)
-            print(f"[account-available] refresh token={token_ref} fail {message}")
-            if "/backend-api/me failed: HTTP 401" in message:
-                if self.remove_invalid_token(access_token, "refresh_account_state"):
-                    return None
-                return self.update_account(
-                    access_token,
-                    {
-                        "status": "异常",
-                        "quota": 0,
-                    },
-                )
-            return None
-        return self.update_account(access_token, remote_info)
-
     def get_available_access_token(self) -> str:
         attempted_tokens: set[str] = set()
         while True:
             access_token = self._pick_next_candidate_token(excluded_tokens=attempted_tokens)
             attempted_tokens.add(access_token)
-            token_ref = anonymize_token(access_token)
-            account = self.refresh_account_state(access_token)
+            try:
+                account = self.fetch_remote_info(access_token, "get_available_access_token")
+            except Exception:
+                continue
             if self._is_image_account_available(account or {}):
                 return access_token
-            print(
-                f"[account-available] skip token={token_ref} "
-                f"quota={account.get('quota') if account else 'unknown'} "
-                f"status={account.get('status') if account else 'unknown'}"
-            )
 
     def get_text_access_token(self, excluded_tokens: set[str] | None = None) -> str:
-        excluded = {self._clean_token(token) for token in (excluded_tokens or set()) if self._clean_token(token)}
+        excluded = set(excluded_tokens or set())
         with self._lock:
             candidates = [
                 token
-                for account in self._accounts
-                if self._clean_token(account.get("status")) not in {"禁用", "异常"}
-                   and (token := self._clean_token(account.get("access_token")))
+                for account in self._accounts.values()
+                if account.get("status") not in {"禁用", "异常"}
+                   and (token := account.get("access_token") or "")
                    and token not in excluded
             ]
             if not candidates:
@@ -295,70 +119,62 @@ class AccountService:
             return access_token
 
     def mark_text_used(self, access_token: str) -> None:
-        access_token = self._clean_token(access_token)
         if not access_token:
             return
         with self._lock:
-            index = self._find_account_index(access_token)
-            if index < 0:
+            current = self._accounts.get(access_token)
+            if current is None:
                 return
-            next_item = dict(self._accounts[index])
+            next_item = dict(current)
             next_item["last_used_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             account = self._normalize_account(next_item)
             if account is None:
                 return
-            self._accounts[index] = account
+            self._accounts[access_token] = account
             self._save_accounts()
 
     def remove_invalid_token(self, access_token: str, event: str) -> bool:
         if not config.auto_remove_invalid_accounts:
+            self.update_account(access_token, {"status": "异常", "quota": 0})
             return False
-        removed = self.remove_token(access_token)
+        removed = bool(self.delete_accounts([access_token])["removed"])
         if removed:
-            log_service.add(LOG_TYPE_ACCOUNT, "自动移除异常账号", {"source": event, "token": anonymize_token(access_token)})
+            log_service.add(LOG_TYPE_ACCOUNT, "自动移除异常账号",
+                            {"source": event, "token": anonymize_token(access_token)})
+        elif access_token:
+            self.update_account(access_token, {"status": "异常", "quota": 0})
         return removed
 
-    def next_token(self) -> str:
-        return self.get_available_access_token()
-
-    def has_available_account(self) -> bool:
-        with self._lock:
-            return any(self._is_image_account_available(item) for item in self._accounts)
-
     def get_account(self, access_token: str) -> dict | None:
-        access_token = self._clean_token(access_token)
         if not access_token:
             return None
         with self._lock:
-            index = self._find_account_index(access_token)
-            if index >= 0:
-                return dict(self._accounts[index])
-        return None
+            account = self._accounts.get(access_token)
+            return dict(account) if account else None
 
     def list_accounts(self) -> list[dict]:
         with self._lock:
-            return self._public_items(self._accounts)
+            return [dict(item) for item in self._accounts.values()]
 
     def list_limited_tokens(self) -> list[str]:
         with self._lock:
             return [
                 token
-                for item in self._accounts
+                for item in self._accounts.values()
                 if item.get("status") == "限流"
-                   and (token := self._clean_token(item.get("access_token")))
+                   and (token := item.get("access_token") or "")
             ]
 
     def add_accounts(self, tokens: list[str]) -> dict:
-        cleaned_tokens = self._clean_tokens(tokens)
-        if not cleaned_tokens:
+        tokens = list(dict.fromkeys(token for token in tokens if token))
+        if not tokens:
             return {"added": 0, "skipped": 0, "items": self.list_accounts()}
 
         with self._lock:
-            indexed = {self._clean_token(item.get("access_token")): dict(item) for item in self._accounts}
             added = 0
             skipped = 0
-            for access_token in cleaned_tokens:
-                current = indexed.get(access_token)
+            for access_token in tokens:
+                current = self._accounts.get(access_token)
                 if current is None:
                     added += 1
                     current = {}
@@ -368,70 +184,63 @@ class AccountService:
                     {
                         **current,
                         "access_token": access_token,
-                        "type": str(current.get("type") or "Free"),
+                        "type": str(current.get("type") or "free"),
                     }
                 )
                 if account is not None:
-                    indexed[access_token] = account
-            self._accounts = list(indexed.values())
+                    self._accounts[access_token] = account
             self._save_accounts()
-            items = self._public_items(self._accounts)
-            log_service.add(LOG_TYPE_ACCOUNT, f"新增 {added} 个账号，跳过 {skipped} 个", {"added": added, "skipped": skipped})
+            items = [dict(item) for item in self._accounts.values()]
+            log_service.add(LOG_TYPE_ACCOUNT, f"新增 {added} 个账号，跳过 {skipped} 个",
+                            {"added": added, "skipped": skipped})
         return {"added": added, "skipped": skipped, "items": items}
 
     def delete_accounts(self, tokens: list[str]) -> dict:
-        target_set = set(self._clean_tokens(tokens))
+        target_set = set(token for token in tokens if token)
         if not target_set:
             return {"removed": 0, "items": self.list_accounts()}
         with self._lock:
-            before = len(self._accounts)
-            self._accounts = [item for item in self._accounts if
-                              self._clean_token(item.get("access_token")) not in target_set]
-            removed = before - len(self._accounts)
-            if self._accounts:
-                self._index %= len(self._accounts)
-            else:
-                self._index = 0
+            removed = sum(self._accounts.pop(token, None) is not None for token in target_set)
             if removed:
+                if self._accounts:
+                    self._index %= len(self._accounts)
+                else:
+                    self._index = 0
                 self._save_accounts()
                 log_service.add(LOG_TYPE_ACCOUNT, f"删除 {removed} 个账号", {"removed": removed})
-            items = self._public_items(self._accounts)
+            items = [dict(item) for item in self._accounts.values()]
         return {"removed": removed, "items": items}
 
-    def remove_token(self, access_token: str) -> bool:
-        return bool(self.delete_accounts([access_token])["removed"])
-
     def update_account(self, access_token: str, updates: dict) -> dict | None:
-        access_token = self._clean_token(access_token)
         if not access_token:
             return None
         with self._lock:
-            index = self._find_account_index(access_token)
-            if index < 0:
+            current = self._accounts.get(access_token)
+            if current is None:
                 return None
-            account = self._normalize_account({**self._accounts[index], **updates, "access_token": access_token})
+            account = self._normalize_account({**current, **updates, "access_token": access_token})
             if account is None:
                 return None
             if account.get("status") == "限流" and config.auto_remove_rate_limited_accounts:
-                del self._accounts[index]
+                self._accounts.pop(access_token, None)
                 self._save_accounts()
                 log_service.add(LOG_TYPE_ACCOUNT, "自动移除限流账号", {"token": anonymize_token(access_token)})
                 return None
-            self._accounts[index] = account
+            self._accounts[access_token] = account
             self._save_accounts()
-            log_service.add(LOG_TYPE_ACCOUNT, "更新账号", {"token": anonymize_token(access_token), "status": account.get("status")})
+            log_service.add(LOG_TYPE_ACCOUNT, "更新账号",
+                            {"token": anonymize_token(access_token), "status": account.get("status")})
             return dict(account)
         return None
 
     def mark_image_result(self, access_token: str, success: bool) -> dict | None:
-        access_token = self._clean_token(access_token)
         if not access_token:
             return None
         with self._lock:
-            index = self._find_account_index(access_token)
-            if index < 0:
+            current = self._accounts.get(access_token)
+            if current is None:
                 return None
-            next_item = dict(self._accounts[index])
+            next_item = dict(current)
             next_item["last_used_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             image_quota_unknown = bool(next_item.get("image_quota_unknown"))
             if success:
@@ -449,116 +258,50 @@ class AccountService:
             if account is None:
                 return None
             if account.get("status") == "限流" and config.auto_remove_rate_limited_accounts:
-                del self._accounts[index]
+                self._accounts.pop(access_token, None)
                 self._save_accounts()
                 log_service.add(LOG_TYPE_ACCOUNT, "自动移除限流账号", {"token": anonymize_token(access_token)})
                 return None
-            self._accounts[index] = account
+            self._accounts[access_token] = account
             self._save_accounts()
             return dict(account)
         return None
 
-    def fetch_remote_info(self, access_token: str) -> dict[str, Any]:
-        access_token = self._clean_token(access_token)
+    def fetch_remote_info(self, access_token: str, event: str = "fetch_remote_info") -> dict[str, Any] | None:
         if not access_token:
             raise ValueError("access_token is required")
 
-        headers, impersonate = self._build_remote_headers(access_token)
-        token_ref = anonymize_token(access_token)
-        print(f"[account-refresh] start {token_ref}")
-        session = Session(**proxy_settings.build_session_kwargs(impersonate=impersonate, verify=True))
-        session.headers.update(headers)
         try:
-            with ThreadPoolExecutor(max_workers=2) as executor:
-                me_future = executor.submit(
-                    session.get,
-                    "https://chatgpt.com/backend-api/me",
-                    headers={
-                        "x-openai-target-path": "/backend-api/me",
-                        "x-openai-target-route": "/backend-api/me",
-                    },
-                    timeout=20,
-                )
-                init_future = executor.submit(
-                    session.post,
-                    "https://chatgpt.com/backend-api/conversation/init",
-                    json={
-                        "gizmo_id": None,
-                        "requested_default_model": None,
-                        "conversation_id": None,
-                        "timezone_offset_min": -480,
-                    },
-                    timeout=20,
-                )
-
-                me_response = me_future.result()
-                init_response = init_future.result()
-
-            if me_response.status_code != 200:
-                raise RuntimeError(f"/backend-api/me failed: HTTP {me_response.status_code}")
-            me_payload = me_response.json()
-
-            if init_response.status_code != 200:
-                raise RuntimeError(f"/backend-api/conversation/init failed: HTTP {init_response.status_code}")
-            init_payload = init_response.json()
-
-            limits_progress = init_payload.get("limits_progress")
-            if not isinstance(limits_progress, list):
-                limits_progress = []
-
-            account_type = self._detect_account_type(access_token, me_payload, init_payload)
-            quota, restore_at, image_quota_unknown = self._extract_quota_and_restore_at(limits_progress)
-            status = "正常" if image_quota_unknown and account_type != "Free" else ("限流" if quota == 0 else "正常")
-
-            result = {
-                "email": me_payload.get("email"),
-                "user_id": me_payload.get("id"),
-                "type": account_type,
-                "quota": quota,
-                "image_quota_unknown": image_quota_unknown,
-                "limits_progress": limits_progress,
-                "default_model_slug": init_payload.get("default_model_slug"),
-                "restore_at": restore_at,
-                "status": status,
-            }
-            print(
-                "[account-refresh] ok",
-                token_ref,
-                f"quota={result.get('quota')}",
-                f"restore_at={result.get('restore_at')}",
-            )
-            return result
-        finally:
-            session.close()
+            from services.openai_backend_api import InvalidAccessTokenError, OpenAIBackendAPI
+            result = OpenAIBackendAPI(access_token).get_user_info()
+        except InvalidAccessTokenError:
+            self.remove_invalid_token(access_token, event)
+            raise
+        return self.update_account(access_token, result)
 
     def refresh_accounts(self, access_tokens: list[str]) -> dict[str, Any]:
-        cleaned_tokens = self._clean_tokens(access_tokens)
-        if not cleaned_tokens:
+        access_tokens = list(dict.fromkeys(token for token in access_tokens if token))
+        if not access_tokens:
             return {"refreshed": 0, "errors": [], "items": self.list_accounts()}
 
         refreshed = 0
-        errors: list[dict[str, str]] = []
-        max_workers = min(10, len(cleaned_tokens))
+        errors = []
+        max_workers = min(10, len(access_tokens))
 
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            future_map = {executor.submit(self.fetch_remote_info, access_token): access_token for access_token in
-                          cleaned_tokens}
-            for future in as_completed(future_map):
-                access_token = future_map[future]
+            futures = {
+                executor.submit(self.fetch_remote_info, token, "refresh_accounts"): token
+                for token in access_tokens
+            }
+            for future in as_completed(futures):
                 try:
-                    remote_info = future.result()
-                    if self.update_account(access_token, remote_info) is not None:
-                        refreshed += 1
+                    account = future.result()
                 except Exception as exc:
-                    message = str(exc)
-                    print(f"[account-refresh] fail {anonymize_token(access_token)} {message}")
-                    if "/backend-api/me failed: HTTP 401" in message:
-                        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})
-
-        print(f"[account-refresh] done refreshed={refreshed} errors={len(errors)} workers={max_workers}")
+                    errors.append({"token": anonymize_token(futures[future]), "error": str(exc)})
+                    continue
+                if account is not None:
+                    refreshed += 1
+
         return {
             "refreshed": refreshed,
             "errors": errors,

services/openai_backend_api.py

@@ -2,6 +2,7 @@ import base64
 import os
 import re
 import time
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from io import BytesIO
 from pathlib import Path
@@ -19,6 +20,10 @@ from utils.pow import build_legacy_requirements_token, build_proof_token, parse_
 from utils.turnstile import solve_turnstile_token
 
 
+class InvalidAccessTokenError(RuntimeError):
+    pass
+
+
 @dataclass
 class ChatRequirements:
     """保存一次对话请求所需的 sentinel token。"""
@@ -135,6 +140,93 @@ class OpenAIBackendAPI:
             headers.update(extra)
         return headers
 
+    @staticmethod
+    def _extract_quota_and_restore_at(limits_progress: list[Any]) -> tuple[int, str | None, bool]:
+        for item in limits_progress:
+            if isinstance(item, dict) and item.get("feature_name") == "image_gen":
+                return int(item.get("remaining") or 0), str(item.get("reset_after") or "") or None, False
+        return 0, None, True
+
+    def _get_me(self) -> Dict[str, Any]:
+        path = "/backend-api/me"
+        response = self.session.get(self.base_url + path, headers=self._headers(path), timeout=20)
+        if response.status_code != 200:
+            if response.status_code == 401:
+                raise InvalidAccessTokenError(f"{path} failed: HTTP {response.status_code}")
+            raise RuntimeError(f"{path} failed: HTTP {response.status_code}")
+        return response.json()
+
+    def _get_conversation_init(self) -> Dict[str, Any]:
+        path = "/backend-api/conversation/init"
+        response = self.session.post(
+            self.base_url + path,
+            headers=self._headers(path, {"Content-Type": "application/json"}),
+            json={
+                "gizmo_id": None,
+                "requested_default_model": None,
+                "conversation_id": None,
+                "timezone_offset_min": -480,
+            },
+            timeout=20,
+        )
+        if response.status_code != 200:
+            if response.status_code == 401:
+                raise InvalidAccessTokenError(f"{path} failed: HTTP {response.status_code}")
+            raise RuntimeError(f"{path} failed: HTTP {response.status_code}")
+        return response.json()
+
+    def _get_default_account(self) -> Dict[str, Any]:
+        route = "/backend-api/accounts/check/v4-2023-04-27"
+        response = self.session.get(self.base_url + route + "?timezone_offset_min=-480", headers=self._headers(route),
+                                    timeout=20)
+        if response.status_code != 200:
+            if response.status_code == 401:
+                raise InvalidAccessTokenError(f"{route} failed: HTTP {response.status_code}")
+            raise RuntimeError(f"/backend-api/accounts/check failed: HTTP {response.status_code}")
+        payload = response.json()
+        logger.debug({"event": "backend_user_info_account_payload", "account_payload": payload})
+        return ((payload.get("accounts") or {}).get("default") or {}).get("account") or {}
+
+    def get_user_info(self) -> Dict[str, Any]:
+        """获取当前 token 的账号信息。"""
+        if not self.access_token:
+            raise RuntimeError("access_token is required")
+        logger.debug({"event": "backend_user_info_start"})
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            me_future = executor.submit(self._get_me)
+            init_future = executor.submit(self._get_conversation_init)
+            account_future = executor.submit(self._get_default_account)
+            me_payload, init_payload, default_account = me_future.result(), init_future.result(), account_future.result()
+
+        plan_type = str(default_account.get("plan_type") or "free")
+
+        limits_progress = init_payload.get("limits_progress")
+        limits_progress = limits_progress if isinstance(limits_progress, list) else []
+        quota, restore_at, image_quota_unknown = self._extract_quota_and_restore_at(limits_progress)
+        result = {
+            "email": me_payload.get("email"),
+            "user_id": me_payload.get("id"),
+            "type": plan_type,
+            "quota": quota,
+            "image_quota_unknown": image_quota_unknown,
+            "limits_progress": limits_progress,
+            "default_model_slug": init_payload.get("default_model_slug"),
+            "restore_at": restore_at,
+            "status": "正常" if image_quota_unknown and plan_type.lower() != "free" else ("限流" if quota == 0 else "正常"),
+        }
+        logger.debug({
+            "event": "backend_user_info_result",
+            "email": result.get("email"),
+            "user_id": result.get("user_id"),
+            "type": result.get("type"),
+            "quota": result.get("quota"),
+            "image_quota_unknown": result.get("image_quota_unknown"),
+            "default_model_slug": result.get("default_model_slug"),
+            "restore_at": result.get("restore_at"),
+            "status": result.get("status"),
+        })
+        return result
+
     def _bootstrap_headers(self) -> Dict[str, str]:
         """构造首页预热请求头。"""
         return {
@@ -562,14 +654,18 @@ 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})
+            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})
+                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})
+                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)})
+            logger.debug({"event": "image_poll_wait", "conversation_id": conversation_id,
+                          "elapsed_secs": round(time.time() - start, 1)})
             time.sleep(4)
         logger.info({"event": "image_poll_timeout", "conversation_id": conversation_id, "timeout_secs": timeout_secs})
         return [], []
@@ -675,7 +771,8 @@ class OpenAIBackendAPI:
         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, config.image_poll_timeout_secs)
+            polled_file_ids, polled_sediment_ids = self._poll_image_results(conversation_id,
+                                                                            config.image_poll_timeout_secs)
             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)

services/register_service.py

@@ -118,7 +118,7 @@ class RegisterService:
         items = account_service.list_accounts()
         normal = [item for item in items if item.get("status") == "正常"]
         return {
-            "current_quota": sum(int(item.get("quota") or 0) for item in normal if not item.get("imageQuotaUnknown")),
+            "current_quota": sum(int(item.get("quota") or 0) for item in normal if not item.get("image_quota_unknown")),
             "current_available": len(normal),
         }
 

utils/log.py

@@ -1,5 +1,6 @@
 import base64
 import binascii
+import json
 import logging
 import re
 from typing import Any
@@ -83,21 +84,27 @@ class Logger:
             return self._sanitize_string(value)
         return value
 
+    def _message(self, value: Any) -> str:
+        sanitized = self._sanitize(value)
+        if isinstance(sanitized, str):
+            return sanitized
+        return json.dumps(sanitized, ensure_ascii=False, default=str)
+
     def debug(self, message: Any) -> None:
         if self._enabled("debug"):
-            self._logger.debug(self._sanitize(message))
+            self._logger.debug(self._message(message))
 
     def info(self, message: Any) -> None:
         if self._enabled("info"):
-            self._logger.info(self._sanitize(message))
+            self._logger.info(self._message(message))
 
     def warning(self, message: Any) -> None:
         if self._enabled("warning"):
-            self._logger.warning(self._sanitize(message))
+            self._logger.warning(self._message(message))
 
     def error(self, message: Any) -> None:
         if self._enabled("error"):
-            self._logger.error(self._sanitize(message))
+            self._logger.error(self._message(message))
 
 
 logger = Logger()

web/src/app/accounts/page.tsx

@@ -47,22 +47,12 @@ import {
   updateAccount,
   type Account,
   type AccountStatus,
-  type AccountType,
 } from "@/lib/api";
 import { useAuthGuard } from "@/lib/use-auth-guard";
 import { cn } from "@/lib/utils";
 
 import { AccountImportDialog } from "./components/account-import-dialog";
 
-const accountTypeOptions: { label: string; value: AccountType | "all" }[] = [
-  { label: "全部类型", value: "all" },
-  { label: "Free", value: "Free" },
-  { label: "Plus", value: "Plus" },
-  { label: "ProLite", value: "ProLite" },
-  { label: "Team", value: "Team" },
-  { label: "Pro", value: "Pro" },
-];
-
 const accountStatusOptions: { label: string; value: AccountStatus | "all" }[] = [
   { label: "全部状态", value: "all" },
   { label: "正常", value: "正常" },
@@ -94,7 +84,11 @@ const metricCards = [
 ] as const;
 
 function isUnlimitedImageQuotaAccount(account: Account) {
-  return account.type === "Pro" || account.type === "ProLite";
+  return account.type === "pro" || account.type === "prolite";
+}
+
+function imageQuotaUnknown(account: Account) {
+  return Boolean(account.image_quota_unknown);
 }
 
 function formatCompact(value: number) {
@@ -108,7 +102,7 @@ function formatQuota(account: Account) {
   if (isUnlimitedImageQuotaAccount(account)) {
     return "∞";
   }
-  if (account.imageQuotaUnknown) {
+  if (imageQuotaUnknown(account)) {
     return "未知";
   }
   return String(Math.max(0, account.quota));
@@ -143,7 +137,7 @@ function formatQuotaSummary(accounts: Account[]) {
   if (availableAccounts.some(isUnlimitedImageQuotaAccount)) {
     return "∞";
   }
-  if (availableAccounts.some((account) => account.imageQuotaUnknown)) {
+  if (availableAccounts.some(imageQuotaUnknown)) {
     return "未知";
   }
   return formatCompact(availableAccounts.reduce((sum, account) => sum + Math.max(0, account.quota), 0));
@@ -166,18 +160,8 @@ function downloadTokens(accounts: Account[]) {
   URL.revokeObjectURL(url);
 }
 
-function normalizeAccounts(items: Account[]): Account[] {
-  return items.map((item) => ({
-    ...item,
-    type:
-      item.type === "Plus" ||
-      item.type === "ProLite" ||
-      item.type === "Team" ||
-      item.type === "Pro" ||
-      item.type === "Free"
-        ? item.type
-        : "Free",
-  }));
+function displayAccountType(account: Account) {
+  return account.type || "Free";
 }
 
 function AccountsPageContent() {
@@ -185,14 +169,12 @@ function AccountsPageContent() {
   const [accounts, setAccounts] = useState<Account[]>([]);
   const [selectedIds, setSelectedIds] = useState<string[]>([]);
   const [query, setQuery] = useState("");
-  const [typeFilter, setTypeFilter] = useState<AccountType | "all">("all");
+  const [typeFilter, setTypeFilter] = useState("all");
   const [statusFilter, setStatusFilter] = useState<AccountStatus | "all">("all");
   const [page, setPage] = useState(1);
   const [pageSize, setPageSize] = useState("10");
   const [editingAccount, setEditingAccount] = useState<Account | null>(null);
-  const [editType, setEditType] = useState<AccountType>("Free");
   const [editStatus, setEditStatus] = useState<AccountStatus>("正常");
-  const [editQuota, setEditQuota] = useState("0");
   const [isLoading, setIsLoading] = useState(true);
   const [isRefreshing, setIsRefreshing] = useState(false);
   const [isDeleting, setIsDeleting] = useState(false);
@@ -204,8 +186,8 @@ function AccountsPageContent() {
     }
     try {
       const data = await fetchAccounts();
-      setAccounts(normalizeAccounts(data.items));
-      setSelectedIds((prev) => prev.filter((id) => data.items.some((item) => item.id === id)));
+      setAccounts(data.items);
+      setSelectedIds((prev) => prev.filter((id) => data.items.some((item) => item.access_token === id)));
     } catch (error) {
       const message = error instanceof Error ? error.message : "加载账户失败";
       toast.error(message);
@@ -229,7 +211,7 @@ function AccountsPageContent() {
     return accounts.filter((account) => {
       const searchMatched =
         normalizedQuery.length === 0 || (account.email ?? "").toLowerCase().includes(normalizedQuery);
-      const typeMatched = typeFilter === "all" || account.type === typeFilter;
+      const typeMatched = typeFilter === "all" || displayAccountType(account) === typeFilter;
       const statusMatched = statusFilter === "all" || account.status === statusFilter;
       return searchMatched && typeMatched && statusMatched;
     });
@@ -240,7 +222,7 @@ function AccountsPageContent() {
   const startIndex = (safePage - 1) * Number(pageSize);
   const currentRows = filteredAccounts.slice(startIndex, startIndex + Number(pageSize));
   const allCurrentSelected =
-    currentRows.length > 0 && currentRows.every((row) => selectedIds.includes(row.id));
+    currentRows.length > 0 && currentRows.every((row) => selectedIds.includes(row.access_token));
 
   const summary = useMemo(() => {
     const total = accounts.length;
@@ -253,9 +235,17 @@ function AccountsPageContent() {
     return { total, active, limited, abnormal, disabled, quota };
   }, [accounts]);
 
+  const accountTypeOptions = useMemo(
+    () => [
+      { label: "全部类型", value: "all" },
+      ...Array.from(new Set(accounts.map(displayAccountType))).map((type) => ({ label: type, value: type })),
+    ],
+    [accounts],
+  );
+
   const selectedTokens = useMemo(() => {
     const selectedSet = new Set(selectedIds);
-    return accounts.filter((item) => selectedSet.has(item.id)).map((item) => item.access_token);
+    return accounts.filter((item) => selectedSet.has(item.access_token)).map((item) => item.access_token);
   }, [accounts, selectedIds]);
 
   const abnormalTokens = useMemo(() => {
@@ -285,8 +275,8 @@ function AccountsPageContent() {
     setIsDeleting(true);
     try {
       const data = await deleteAccounts(tokens);
-      setAccounts(normalizeAccounts(data.items));
-      setSelectedIds((prev) => prev.filter((id) => data.items.some((item) => item.id === id)));
+      setAccounts(data.items);
+      setSelectedIds((prev) => prev.filter((id) => data.items.some((item) => item.access_token === id)));
       toast.success(`删除 ${data.removed ?? 0} 个账户`);
     } catch (error) {
       const message = error instanceof Error ? error.message : "删除账户失败";
@@ -305,8 +295,8 @@ function AccountsPageContent() {
     setIsRefreshing(true);
     try {
       const data = await refreshAccounts(accessTokens);
-      setAccounts(normalizeAccounts(data.items));
-      setSelectedIds((prev) => prev.filter((id) => data.items.some((item) => item.id === id)));
+      setAccounts(data.items);
+      setSelectedIds((prev) => prev.filter((id) => data.items.some((item) => item.access_token === id)));
       if (data.errors.length > 0) {
         const firstError = data.errors[0]?.error;
         toast.error(
@@ -325,9 +315,7 @@ function AccountsPageContent() {
 
   const openEditDialog = (account: Account) => {
     setEditingAccount(account);
-    setEditType(account.type);
     setEditStatus(account.status);
-    setEditQuota(String(account.quota));
   };
 
   const handleUpdateAccount = async () => {
@@ -338,12 +326,10 @@ function AccountsPageContent() {
     setIsUpdating(true);
     try {
       const data = await updateAccount(editingAccount.access_token, {
-        type: editType,
         status: editStatus,
-        quota: Number(editQuota || 0),
       });
-      setAccounts(normalizeAccounts(data.items));
-      setSelectedIds((prev) => prev.filter((id) => data.items.some((item) => item.id === id)));
+      setAccounts(data.items);
+      setSelectedIds((prev) => prev.filter((id) => data.items.some((item) => item.access_token === id)));
       setEditingAccount(null);
       toast.success("账号信息已更新");
     } catch (error) {
@@ -356,10 +342,10 @@ function AccountsPageContent() {
 
   const toggleSelectAll = (checked: boolean) => {
     if (checked) {
-      setSelectedIds((prev) => Array.from(new Set([...prev, ...currentRows.map((item) => item.id)])));
+      setSelectedIds((prev) => Array.from(new Set([...prev, ...currentRows.map((item) => item.access_token)])));
       return;
     }
-    setSelectedIds((prev) => prev.filter((id) => !currentRows.some((row) => row.id === id)));
+    setSelectedIds((prev) => prev.filter((id) => !currentRows.some((row) => row.access_token === id)));
   };
 
   return (
@@ -394,7 +380,7 @@ function AccountsPageContent() {
           <AccountImportDialog
             disabled={isLoading || isRefreshing || isDeleting}
             onImported={(items) => {
-              setAccounts(normalizeAccounts(items));
+              setAccounts(items);
               setSelectedIds([]);
               setPage(1);
             }}
@@ -416,7 +402,7 @@ function AccountsPageContent() {
           <DialogHeader className="gap-2">
             <DialogTitle>编辑账户</DialogTitle>
             <DialogDescription className="text-sm leading-6">
-              手动修改账号状态、类型和额度。
+              手动修改账号状态。
             </DialogDescription>
           </DialogHeader>
           <div className="space-y-4">
@@ -437,31 +423,6 @@ function AccountsPageContent() {
                 </SelectContent>
               </Select>
             </div>
-            <div className="space-y-2">
-              <label className="text-sm font-medium text-stone-700">类型</label>
-              <Select value={editType} onValueChange={(value) => setEditType(value as AccountType)}>
-                <SelectTrigger className="h-11 rounded-xl border-stone-200 bg-white">
-                  <SelectValue />
-                </SelectTrigger>
-                <SelectContent>
-                  {accountTypeOptions
-                    .filter((option) => option.value !== "all")
-                    .map((option) => (
-                      <SelectItem key={option.value} value={option.value}>
-                        {option.label}
-                      </SelectItem>
-                    ))}
-                </SelectContent>
-              </Select>
-            </div>
-            <div className="space-y-2">
-              <label className="text-sm font-medium text-stone-700">额度</label>
-              <Input
-                value={editQuota}
-                onChange={(event) => setEditQuota(event.target.value)}
-                className="h-11 rounded-xl border-stone-200 bg-white"
-              />
-            </div>
           </div>
           <DialogFooter className="pt-2">
             <Button
@@ -533,7 +494,7 @@ function AccountsPageContent() {
             <Select
               value={typeFilter}
               onValueChange={(value) => {
-                setTypeFilter(value as AccountType | "all");
+                setTypeFilter(value);
                 setPage(1);
               }}
             >
@@ -655,17 +616,17 @@ function AccountsPageContent() {
 
                     return (
                       <tr
-                        key={account.id}
+                        key={account.access_token}
                         className="border-b border-stone-100/80 text-sm text-stone-600 transition-colors hover:bg-stone-50/70"
                       >
                         <td className="px-4 py-3">
                           <Checkbox
-                            checked={selectedIds.includes(account.id)}
+                            checked={selectedIds.includes(account.access_token)}
                             onCheckedChange={(checked) => {
                               setSelectedIds((prev) =>
                                 checked
-                                  ? Array.from(new Set([...prev, account.id]))
-                                  : prev.filter((item) => item !== account.id),
+                                  ? Array.from(new Set([...prev, account.access_token]))
+                                  : prev.filter((item) => item !== account.access_token),
                               );
                             }}
                           />
@@ -689,7 +650,7 @@ function AccountsPageContent() {
                         </td>
                         <td className="px-4 py-3">
                           <Badge variant="secondary" className="rounded-md bg-stone-100 text-stone-700">
-                            {account.type}
+                            {displayAccountType(account)}
                           </Badge>
                         </td>
                         <td className="px-4 py-3">
@@ -711,7 +672,7 @@ function AccountsPageContent() {
                         </td>
                         <td className="px-4 py-3 text-xs leading-5 text-stone-500">
                           {(() => {
-                            const restore = formatRestoreAt(account.restoreAt);
+                            const restore = formatRestoreAt(account.restore_at);
                             return (
                               <div className="space-y-0.5">
                                 {restore.relative ? <div className="font-medium text-stone-700">{restore.relative}</div> : null}

web/src/lib/api.ts

@@ -1,17 +1,16 @@
 import { httpRequest } from "@/lib/request";
 
-export type AccountType = "Free" | "Plus" | "ProLite" | "Pro" | "Team";
+export type AccountType = string;
 export type AccountStatus = "正常" | "限流" | "异常" | "禁用";
 export type ImageModel = "gpt-image-2" | "codex-gpt-image-2";
 export type AuthRole = "admin" | "user";
 
 export type Account = {
-  id: string;
   access_token: string;
   type: AccountType;
   status: AccountStatus;
   quota: number;
-  imageQuotaUnknown?: boolean;
+  image_quota_unknown?: boolean;
   email?: string | null;
   user_id?: string | null;
   limits_progress?: Array<{
@@ -20,10 +19,10 @@ export type Account = {
     reset_after?: string;
   }>;
   default_model_slug?: string | null;
-  restoreAt?: string | null;
+  restore_at?: string | null;
   success: number;
   fail: number;
-  lastUsedAt: string | null;
+  last_used_at?: string | null;
 };
 
 type AccountListResponse = {