Upload 7 files

README_hf.md

@@ -0,0 +1,92 @@
+---
+title: Business Gemini Pool
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Business Gemini Pool 管理系统
+
+一个基于 Flask 的 Google Gemini Enterprise API 代理服务，现已部署到 Hugging Face Spaces！
+
+## 🌟 特性
+
+- **多账号轮询**: 支持配置多个 Gemini 账号，自动轮询使用
+- **OpenAI 兼容接口**: 提供与 OpenAI API 兼容的接口格式
+- **流式响应**: 支持 SSE 流式输出
+- **Web 管理控制台**: 美观的 Web 管理界面
+- **图片处理**: 支持图片输入输出
+- **代理支持**: 支持 HTTP/HTTPS 代理配置
+
+## 🚀 快速开始
+
+1. 访问此 Space：[Business Gemini Pool](https://huggingface.co/spaces/your-username/business-gemini-pool)
+
+2. 在 Web 界面中配置你的 Gemini 账号信息
+
+3. 开始使用 API 服务！
+
+## 📝 配置说明
+
+### 环境变量（可选）
+在 Space 设置中可以配置以下环境变量：
+- `PROXY_URL`: 代理服务器地址
+- `PROXY_ENABLED`: 是否启用代理 (true/false)
+
+### 账号配置
+在 Web 界面的"账号管理"页面��加你的 Gemini 账号：
+- Team ID
+- Secure Cookie
+- Host Cookie
+- Session Index
+- User Agent
+
+## 🔧 API 使用
+
+### 获取模型列表
+```bash
+curl https://your-space.hf.space/v1/models
+```
+
+### 聊天对话
+```bash
+curl -X POST https://your-space.hf.space/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemini-enterprise",
+    "messages": [
+      {"role": "user", "content": "Hello!"}
+    ]
+  }'
+```
+
+## 🛠️ 本地部署
+
+```bash
+# 克隆仓库
+git clone https://huggingface.co/spaces/your-username/business-gemini-pool
+cd business-gemini-pool
+
+# 安装依赖
+pip install -r requirements-hf.txt
+
+# 运行
+python app.py
+```
+
+## 📄 许可证
+
+MIT License
+
+## 🤝 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## ⚠️ 免责声明
+
+本工具仅供学习和研究使用，请遵守 Google 的使用条款。

app.py

@@ -0,0 +1,15 @@
+"""Hugging Face Spaces兼容的应用入口文件"""
+
+import os
+import sys
+
+# 将当前目录添加到Python路径
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# 导入主应用
+from gemini import app
+
+if __name__ == "__main__":
+    # Hugging Face Spaces通常需要运行在特定端口
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port)

business_gemini_session.json.example

@@ -0,0 +1,24 @@
+{
+    "proxy": "http://127.0.0.1:7890",
+    "proxy_enabled": false,
+	"image_base_url": "http://127.0.0.1:8000/",
+	"image_output_mode": "url",
+    "log_level": "INFO",
+    "admin_password_hash": "",
+    "admin_secret_key": "",
+    "api_tokens": [
+        "please_set_api_token_here"
+    ],
+    "accounts": [
+    ],
+    "models": [
+        {
+            "id": "gemini-3-pro-preview",
+            "name": "gemini-3-pro-preview",
+            "description": "gemini-3-pro-preview 模型",
+            "context_length": 32768,
+            "max_tokens": 8192,
+            "price_per_1k_tokens": 0.0015
+        }
+    ]
+}

gemini.py

@@ -0,0 +1,2498 @@
+"""Business Gemini OpenAPI 兼容服务
+整合JWT获取和聊天功能，提供OpenAPI接口
+支持多账号轮训
+支持图片输出（OpenAI格式）
+"""
+
+import json
+import time
+import hmac
+import hashlib
+import base64
+import uuid
+import threading
+import os
+import re
+import shutil
+import mimetypes
+import requests
+from pathlib import Path
+from datetime import datetime, timedelta, timezone
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any, Tuple
+import builtins
+import secrets
+from flask import Flask, request, Response, jsonify, send_from_directory, abort
+from flask_cors import CORS
+from functools import wraps
+from werkzeug.security import generate_password_hash, check_password_hash
+
+# 禁用SSL警告
+import urllib3
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# 配置
+CONFIG_FILE = Path(__file__).parent / "business_gemini_session.json"
+
+# 图片缓存配置
+IMAGE_CACHE_DIR = Path(__file__).parent / "image"
+IMAGE_CACHE_HOURS = 1  # 图片缓存时间（小时）
+IMAGE_CACHE_DIR.mkdir(exist_ok=True)
+
+# API endpoints
+BASE_URL = "https://biz-discoveryengine.googleapis.com/v1alpha/locations/global"
+CREATE_SESSION_URL = f"{BASE_URL}/widgetCreateSession"
+STREAM_ASSIST_URL = f"{BASE_URL}/widgetStreamAssist"
+LIST_FILE_METADATA_URL = f"{BASE_URL}/widgetListSessionFileMetadata"
+ADD_CONTEXT_FILE_URL = f"{BASE_URL}/widgetAddContextFile"
+GETOXSRF_URL = "https://business.gemini.google/auth/getoxsrf"
+
+# 账号错误冷却时间（秒）
+AUTH_ERROR_COOLDOWN_SECONDS = 900      # 凭证错误，15分钟
+RATE_LIMIT_COOLDOWN_SECONDS = 300      # 触发限额，5分钟
+GENERIC_ERROR_COOLDOWN_SECONDS = 120   # 其他错误的短暂冷却
+LOG_LEVELS = {"DEBUG": 10, "INFO": 20, "ERROR": 40}
+DEFAULT_LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+CURRENT_LOG_LEVEL_NAME = DEFAULT_LOG_LEVEL if DEFAULT_LOG_LEVEL in LOG_LEVELS else "INFO"
+CURRENT_LOG_LEVEL = LOG_LEVELS[CURRENT_LOG_LEVEL_NAME]
+ADMIN_SECRET_KEY = None
+API_TOKENS = set()
+
+try:
+    from zoneinfo import ZoneInfo
+except ImportError:
+    ZoneInfo = None
+
+# Flask应用
+app = Flask(__name__, static_folder='.')
+CORS(app)
+
+
+def _infer_log_level(text: str) -> str:
+    t = text.strip()
+    if t.startswith("[DEBUG]"):
+        return "DEBUG"
+    if t.startswith("[ERROR]") or t.startswith("[!]"):
+        return "ERROR"
+    return "INFO"
+
+
+_original_print = builtins.print
+
+
+def filtered_print(*args, **kwargs):
+    """简单的日志过滤，根据全局日志级别屏蔽低级别输出"""
+    level = kwargs.pop("_level", None)
+    sep = kwargs.get("sep", " ")
+    text = sep.join(str(a) for a in args)
+    level_name = (level or _infer_log_level(text)).upper()
+    if LOG_LEVELS.get(level_name, LOG_LEVELS["INFO"]) >= CURRENT_LOG_LEVEL:
+        _original_print(*args, **kwargs)
+
+
+builtins.print = filtered_print
+
+
+def set_log_level(level: str, persist: bool = False):
+    """设置全局日志级别"""
+    global CURRENT_LOG_LEVEL_NAME, CURRENT_LOG_LEVEL
+    lvl = (level or "").upper()
+    if lvl not in LOG_LEVELS:
+        raise ValueError(f"无效日志级别: {level}")
+    CURRENT_LOG_LEVEL_NAME = lvl
+    CURRENT_LOG_LEVEL = LOG_LEVELS[lvl]
+    if persist and globals().get("account_manager") and account_manager.config is not None:
+        account_manager.config["log_level"] = lvl
+        account_manager.save_config()
+    _original_print(f"[LOG] 当前日志级别: {CURRENT_LOG_LEVEL_NAME}")
+
+
+class AccountError(Exception):
+    """基础账号异常"""
+
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class AccountAuthError(AccountError):
+    """凭证/权限相关异常"""
+
+
+class AccountRateLimitError(AccountError):
+    """配额或限流异常"""
+
+
+class AccountRequestError(AccountError):
+    """其他请求异常"""
+
+
+class NoAvailableAccount(AccountError):
+    """无可用账号异常"""
+
+
+def get_admin_secret_key() -> str:
+    """获取/初始化后台密钥"""
+    global ADMIN_SECRET_KEY
+    if ADMIN_SECRET_KEY:
+        return ADMIN_SECRET_KEY
+    if account_manager.config is None:
+        ADMIN_SECRET_KEY = os.getenv("ADMIN_SECRET_KEY", "change_me_secret")
+        return ADMIN_SECRET_KEY
+    secret = account_manager.config.get("admin_secret_key") or os.getenv("ADMIN_SECRET_KEY")
+    if not secret:
+        secret = secrets.token_urlsafe(32)
+        account_manager.config["admin_secret_key"] = secret
+        account_manager.save_config()
+    ADMIN_SECRET_KEY = secret
+    return ADMIN_SECRET_KEY
+
+
+def load_api_tokens():
+    """从配置加载用户访问token"""
+    global API_TOKENS
+    API_TOKENS = set()
+    if not account_manager.config:
+        return
+    tokens = account_manager.config.get("api_tokens") or account_manager.config.get("api_token")
+    if isinstance(tokens, str):
+        API_TOKENS.add(tokens)
+    elif isinstance(tokens, list):
+        for t in tokens:
+            if isinstance(t, str):
+                API_TOKENS.add(t)
+
+
+def persist_api_tokens():
+    if account_manager.config is None:
+        account_manager.config = {}
+    account_manager.config["api_tokens"] = list(API_TOKENS)
+    account_manager.save_config()
+
+
+def get_admin_password_hash() -> Optional[str]:
+    if account_manager.config:
+        return account_manager.config.get("admin_password_hash")
+    return None
+
+
+def set_admin_password(password: str):
+    if not password:
+        raise ValueError("密码不能为空")
+    if account_manager.config is None:
+        account_manager.config = {}
+    account_manager.config["admin_password_hash"] = generate_password_hash(password)
+    account_manager.save_config()
+
+
+def is_valid_api_token(token: str) -> bool:
+    if not token:
+        return False
+    if verify_admin_token(token):
+        return True
+    return token in API_TOKENS
+
+
+def require_api_auth(func):
+    """开放接口需要 api_token 或 admin token"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        token = (
+            request.headers.get("X-API-Token")
+            or request.headers.get("Authorization", "").replace("Bearer ", "")
+            or request.cookies.get("admin_token")
+        )
+        if not is_valid_api_token(token):
+            return jsonify({"error": "未授权"}), 401
+        return func(*args, **kwargs)
+    return wrapper
+
+
+def create_admin_token(exp_seconds: int = 86400) -> str:
+    payload = {
+        "exp": time.time() + exp_seconds,
+        "ts": int(time.time())
+    }
+    payload_b = json.dumps(payload, separators=(",", ":")).encode()
+    b64 = base64.urlsafe_b64encode(payload_b).decode().rstrip("=")
+    secret = get_admin_secret_key().encode()
+    signature = hmac.new(secret, b64.encode(), hashlib.sha256).hexdigest()
+    return f"{b64}.{signature}"
+
+
+def verify_admin_token(token: str) -> bool:
+    if not token:
+        return False
+    try:
+        b64, sig = token.split(".", 1)
+    except ValueError:
+        return False
+    expected_sig = hmac.new(get_admin_secret_key().encode(), b64.encode(), hashlib.sha256).hexdigest()
+    if not hmac.compare_digest(expected_sig, sig):
+        return False
+    padding = '=' * (-len(b64) % 4)
+    try:
+        payload = json.loads(base64.urlsafe_b64decode(b64 + padding).decode())
+    except Exception:
+        return False
+    if payload.get("exp", 0) < time.time():
+        return False
+    return True
+
+
+def require_admin(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        token = (
+            request.headers.get("X-Admin-Token")
+            or request.headers.get("Authorization", "").replace("Bearer ", "")
+            or request.cookies.get("admin_token")
+        )
+        if not verify_admin_token(token):
+            return jsonify({"error": "未授权"}), 401
+        return func(*args, **kwargs)
+    return wrapper
+
+
+def seconds_until_next_pt_midnight(now_ts: Optional[float] = None) -> int:
+    """计算距离下一个 PT 午夜的秒数，用于配额冷却"""
+    now_utc = datetime.now(timezone.utc) if now_ts is None else datetime.fromtimestamp(now_ts, tz=timezone.utc)
+    if ZoneInfo:
+        pt_tz = ZoneInfo("America/Los_Angeles")
+        now_pt = now_utc.astimezone(pt_tz)
+    else:
+        # 兼容旧版本 Python 的简易回退（不考虑夏令时）
+        now_pt = now_utc - timedelta(hours=8)
+
+    tomorrow = (now_pt + timedelta(days=1)).date()
+    midnight_pt = datetime.combine(tomorrow, datetime.min.time(), tzinfo=now_pt.tzinfo)
+    delta = (midnight_pt - now_pt).total_seconds()
+    return max(0, int(delta))
+
+
+class AccountManager:
+    """多账号管理器，支持轮训策略"""
+    
+    def __init__(self):
+        self.config = None
+        self.accounts = []  # 账号列表
+        self.current_index = 0  # 当前轮训索引
+        self.account_states = {}  # 账号状态: {index: {jwt, jwt_time, session, available, cooldown_until, cooldown_reason}}
+        self.lock = threading.Lock()
+        self.auth_error_cooldown = AUTH_ERROR_COOLDOWN_SECONDS
+        self.rate_limit_cooldown = RATE_LIMIT_COOLDOWN_SECONDS
+        self.generic_error_cooldown = GENERIC_ERROR_COOLDOWN_SECONDS
+    
+    def load_config(self):
+        """加载配置"""
+        if CONFIG_FILE.exists():
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                self.config = json.load(f)
+                if "log_level" in self.config:
+                    try:
+                        set_log_level(self.config.get("log_level"), persist=False)
+                    except Exception:
+                        pass
+                if "admin_secret_key" in self.config:
+                    global ADMIN_SECRET_KEY
+                    ADMIN_SECRET_KEY = self.config.get("admin_secret_key")
+                load_api_tokens()
+                self.accounts = self.config.get("accounts", [])
+                # 初始化账号状态
+                for i, acc in enumerate(self.accounts):
+                    available = acc.get("available", True)  # 默认可用
+                    self.account_states[i] = {
+                        "jwt": None,
+                        "jwt_time": 0,
+                        "session": None,
+                        "available": available,
+                        "cooldown_until": acc.get("cooldown_until"),
+                        "cooldown_reason": acc.get("unavailable_reason") or acc.get("cooldown_reason") or ""
+                    }
+        return self.config
+    
+    def save_config(self):
+        """保存配置到文件"""
+        if self.config and CONFIG_FILE.exists():
+            with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+                json.dump(self.config, f, indent=4, ensure_ascii=False)
+    
+    def mark_account_unavailable(self, index: int, reason: str = ""):
+        """标记账号不可用"""
+        with self.lock:
+            if 0 <= index < len(self.accounts):
+                self.accounts[index]["available"] = False
+                self.accounts[index]["unavailable_reason"] = reason
+                self.accounts[index]["unavailable_time"] = datetime.now().isoformat()
+                self.account_states[index]["available"] = False
+                self.save_config()
+                print(f"[!] 账号 {index} 已标记为不可用: {reason}")
+
+    def mark_account_cooldown(self, index: int, reason: str = "", cooldown_seconds: Optional[int] = None):
+        """临时拉黑账号（冷却），在冷却时间内不会被选择"""
+        if cooldown_seconds is None:
+            cooldown_seconds = self.generic_error_cooldown
+
+        with self.lock:
+            if 0 <= index < len(self.accounts):
+                now_ts = time.time()
+                new_until = now_ts + cooldown_seconds
+                state = self.account_states.setdefault(index, {})
+                current_until = state.get("cooldown_until") or 0
+                # 如果已有更长的冷却，则不重复更新
+                if current_until > now_ts and current_until >= new_until:
+                    return
+
+                until = max(new_until, current_until)
+                state["cooldown_until"] = until
+                state["cooldown_reason"] = reason
+                state["jwt"] = None
+                state["jwt_time"] = 0
+                state["session"] = None
+
+                # 在配置中记录冷却信息，便于前端展示
+                self.accounts[index]["cooldown_until"] = until
+                self.accounts[index]["unavailable_reason"] = reason
+                self.accounts[index]["unavailable_time"] = datetime.now().isoformat()
+
+                self.save_config()
+                print(f"[!] 账号 {index} 进入冷却 {cooldown_seconds} 秒: {reason}")
+
+    def _is_in_cooldown(self, index: int, now_ts: Optional[float] = None) -> bool:
+        """检查账号是否处于冷却期"""
+        now_ts = now_ts or time.time()
+        state = self.account_states.get(index, {})
+        cooldown_until = state.get("cooldown_until")
+        if not cooldown_until:
+            return False
+        return now_ts < cooldown_until
+
+    def get_next_cooldown_info(self) -> Optional[dict]:
+        """获取最近即将结束冷却的账号信息"""
+        now_ts = time.time()
+        candidates = []
+        for idx, state in self.account_states.items():
+            cooldown_until = state.get("cooldown_until")
+            if cooldown_until and cooldown_until > now_ts and state.get("available", True):
+                candidates.append((cooldown_until, idx))
+        if not candidates:
+            return None
+        cooldown_until, idx = min(candidates, key=lambda x: x[0])
+        return {"index": idx, "cooldown_until": cooldown_until}
+
+    def is_account_available(self, index: int) -> bool:
+        """计算账号当前是否可用（考虑冷却和手动禁用）"""
+        state = self.account_states.get(index, {})
+        if not state.get("available", True):
+            return False
+        return not self._is_in_cooldown(index)
+    
+    def get_available_accounts(self):
+        """获取可用账号列表"""
+        now_ts = time.time()
+        available_accounts = []
+        for i, acc in enumerate(self.accounts):
+            state = self.account_states.get(i, {})
+            if not state.get("available", True):
+                continue
+            if self._is_in_cooldown(i, now_ts):
+                continue
+            available_accounts.append((i, acc))
+        return available_accounts
+    
+    def get_next_account(self):
+        """轮训获取下一个可用账号"""
+        with self.lock:
+            available = self.get_available_accounts()
+            if not available:
+                cooldown_info = self.get_next_cooldown_info()
+                if cooldown_info:
+                    remaining = int(max(0, cooldown_info["cooldown_until"] - time.time()))
+                    raise NoAvailableAccount(f"没有可用的账号（最近冷却账号 {cooldown_info['index']}��约 {remaining} 秒后可重试）")
+                raise NoAvailableAccount("没有可用的账号")
+            
+            # 轮训选择
+            self.current_index = self.current_index % len(available)
+            idx, account = available[self.current_index]
+            self.current_index = (self.current_index + 1) % len(available)
+            return idx, account
+    
+    def get_account_count(self):
+        """获取账号数量统计"""
+        total = len(self.accounts)
+        available = len(self.get_available_accounts())
+        return total, available
+
+
+# 全局账号管理器
+account_manager = AccountManager()
+
+
+class FileManager:
+    """文件管理器 - 管理上传文件的映射关系（OpenAI file_id <-> Gemini fileId）"""
+    
+    def __init__(self):
+        self.files: Dict[str, Dict] = {}  # openai_file_id -> {gemini_file_id, session_name, filename, mime_type, size, created_at}
+    
+    def add_file(self, openai_file_id: str, gemini_file_id: str, session_name: str, 
+                 filename: str, mime_type: str, size: int) -> Dict:
+        """添加文件映射"""
+        file_info = {
+            "id": openai_file_id,
+            "gemini_file_id": gemini_file_id,
+            "session_name": session_name,
+            "filename": filename,
+            "mime_type": mime_type,
+            "bytes": size,
+            "created_at": int(time.time()),
+            "purpose": "assistants",
+            "object": "file"
+        }
+        self.files[openai_file_id] = file_info
+        return file_info
+    
+    def get_file(self, openai_file_id: str) -> Optional[Dict]:
+        """获取文件信息"""
+        return self.files.get(openai_file_id)
+    
+    def get_gemini_file_id(self, openai_file_id: str) -> Optional[str]:
+        """获取 Gemini 文件ID"""
+        file_info = self.files.get(openai_file_id)
+        return file_info.get("gemini_file_id") if file_info else None
+    
+    def delete_file(self, openai_file_id: str) -> bool:
+        """删除文件映射"""
+        if openai_file_id in self.files:
+            del self.files[openai_file_id]
+            return True
+        return False
+    
+    def list_files(self) -> List[Dict]:
+        """列出所有文件"""
+        return list(self.files.values())
+    
+    def get_session_for_file(self, openai_file_id: str) -> Optional[str]:
+        """获取文件关联的会话名称"""
+        file_info = self.files.get(openai_file_id)
+        return file_info.get("session_name") if file_info else None
+
+
+# 全局文件管理器
+file_manager = FileManager()
+
+
+def check_proxy(proxy: str) -> bool:
+    """检测代理是否可用"""
+    if not proxy:
+        return False
+    try:
+        proxies = {"http": proxy, "https": proxy}
+        resp = requests.get("https://www.google.com", proxies=proxies, 
+                          verify=False, timeout=10)
+        return resp.status_code == 200
+    except:
+        return False
+
+
+def get_proxy() -> Optional[str]:
+    """获取代理配置，根据proxy_enabled开关决定是否返回代理地址
+    
+    Returns:
+        代理地址字符串，如果禁用代理则返回None
+    """
+    if account_manager.config is None:
+        return None
+    if not account_manager.config.get("proxy_enabled", False):
+        return None
+    return account_manager.config.get("proxy")
+
+
+def url_safe_b64encode(data: bytes) -> str:
+    """URL安全的Base64编码，不带padding"""
+    return base64.urlsafe_b64encode(data).decode('utf-8').rstrip('=')
+
+
+def kq_encode(s: str) -> str:
+    """模拟JS的kQ函数"""
+    byte_arr = bytearray()
+    for char in s:
+        val = ord(char)
+        if val > 255:
+            byte_arr.append(val & 255)
+            byte_arr.append(val >> 8)
+        else:
+            byte_arr.append(val)
+    return url_safe_b64encode(bytes(byte_arr))
+
+
+def decode_xsrf_token(xsrf_token: str) -> bytes:
+    """将 xsrfToken 解码为字节数组（用于HMAC签名）"""
+    padding = 4 - len(xsrf_token) % 4
+    if padding != 4:
+        xsrf_token += '=' * padding
+    return base64.urlsafe_b64decode(xsrf_token)
+
+
+def create_jwt(key_bytes: bytes, key_id: str, csesidx: str) -> str:
+    """创建JWT token"""
+    now = int(time.time())
+
+    header = {
+        "alg": "HS256",
+        "typ": "JWT",
+        "kid": key_id
+    }
+
+    payload = {
+        "iss": "https://business.gemini.google",
+        "aud": "https://biz-discoveryengine.googleapis.com",
+        "sub": f"csesidx/{csesidx}",
+        "iat": now,
+        "exp": now + 300,
+        "nbf": now
+    }
+
+    header_b64 = kq_encode(json.dumps(header, separators=(',', ':')))
+    payload_b64 = kq_encode(json.dumps(payload, separators=(',', ':')))
+    message = f"{header_b64}.{payload_b64}"
+
+    signature = hmac.new(key_bytes, message.encode('utf-8'), hashlib.sha256).digest()
+    signature_b64 = url_safe_b64encode(signature)
+
+    return f"{message}.{signature_b64}"
+
+
+def get_jwt_for_account(account: dict, proxy: str) -> str:
+    """为指定账号获取JWT"""
+    secure_c_ses = account.get("secure_c_ses")
+    host_c_oses = account.get("host_c_oses")
+    csesidx = account.get("csesidx")
+
+    if not secure_c_ses or not csesidx:
+        raise ValueError("缺少 secure_c_ses 或 csesidx")
+
+    url = f"{GETOXSRF_URL}?csesidx={csesidx}"
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+
+    headers = {
+        "accept": "*/*",
+        "user-agent": account.get('user_agent', 'Mozilla/5.0'),
+        "cookie": f'__Secure-C_SES={secure_c_ses}; __Host-C_OSES={host_c_oses}',
+    }
+
+    try:
+        resp = requests.get(url, headers=headers, proxies=proxies, verify=False, timeout=30)
+    except requests.RequestException as e:
+        raise AccountRequestError(f"获取JWT 请求失败: {e}") from e
+
+    if resp.status_code != 200:
+        raise_for_account_response(resp, "获取JWT")
+
+    # 处理Google安全前缀
+    text = resp.text
+    if text.startswith(")]}'\n") or text.startswith(")]}'"): 
+        text = text[4:].strip()
+
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError as e:
+        raise AccountAuthError(f"解析JWT响应失败: {e}") from e
+
+    key_id = data.get("keyId")
+    xsrf_token = data.get("xsrfToken")
+    if not key_id or not xsrf_token:
+        raise AccountAuthError(f"JWT 响应缺少 keyId/xsrfToken: {data}")
+
+    print(f"账号: {account.get('csesidx')} 账号可用! key_id: {key_id}")
+
+    key_bytes = decode_xsrf_token(xsrf_token)
+
+    return create_jwt(key_bytes, key_id, csesidx)
+
+
+def get_headers(jwt: str) -> dict:
+    """获取请求头"""
+    return {
+        "accept": "*/*",
+        "accept-encoding": "gzip, deflate, br, zstd",
+        "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
+        "authorization": f"Bearer {jwt}",
+        "content-type": "application/json",
+        "origin": "https://business.gemini.google",
+        "referer": "https://business.gemini.google/",
+        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+        "x-server-timeout": "1800",
+    }
+
+
+def raise_for_account_response(resp: requests.Response, action: str):
+    """根据响应状态抛出对应的账号异常"""
+    status = resp.status_code
+    body_preview = resp.text[:500] if resp.text else ""
+    lower_body = body_preview.lower()
+
+    if status in (401, 403):
+        raise AccountAuthError(f"{action} 认证失败: {status} - {body_preview}", status)
+    if status == 429 or "quota" in lower_body or "exceed" in lower_body or "limit" in lower_body:
+        raise AccountRateLimitError(f"{action} 触发限额: {status} - {body_preview}", status)
+
+    raise AccountRequestError(f"{action} 请求失败: {status} - {body_preview}", status)
+
+
+def ensure_jwt_for_account(account_idx: int, account: dict):
+    """确保指定账号的JWT有效，必要时刷新"""
+    print(f"[DEBUG][ensure_jwt_for_account] 开始 - 账号索引: {account_idx}, CSESIDX: {account.get('csesidx')}")
+    start_time = time.time()
+    with account_manager.lock:
+        state = account_manager.account_states[account_idx]
+        jwt_age = time.time() - state["jwt_time"] if state["jwt"] else float('inf')
+        print(f"[DEBUG][ensure_jwt_for_account] JWT状态 - 存在: {state['jwt'] is not None}, 年龄: {jwt_age:.2f}秒")
+        if state["jwt"] is None or jwt_age > 240:
+            print(f"[DEBUG][ensure_jwt_for_account] 需要刷新JWT...")
+            proxy = get_proxy()
+            try:
+                refresh_start = time.time()
+                state["jwt"] = get_jwt_for_account(account, proxy)
+                state["jwt_time"] = time.time()
+                print(f"[DEBUG][ensure_jwt_for_account] JWT刷新成功 - 耗时: {time.time() - refresh_start:.2f}秒")
+            except Exception as e:
+                print(f"[DEBUG][ensure_jwt_for_account] JWT刷新失败: {e}")
+                raise
+        else:
+            print(f"[DEBUG][ensure_jwt_for_account] 使用缓存JWT")
+        print(f"[DEBUG][ensure_jwt_for_account] 完成 - 总耗时: {time.time() - start_time:.2f}秒")
+        return state["jwt"]
+
+
+def create_chat_session(jwt: str, team_id: str, proxy: str) -> str:
+    """创建会话，返回session ID"""
+    print(f"[DEBUG][create_chat_session] 开始 - team_id: {team_id}")
+    start_time = time.time()
+    session_id = uuid.uuid4().hex[:12]
+    print(f"[DEBUG][create_chat_session] 生成session_id: {session_id}")
+    body = {
+        "configId": team_id,
+        "additionalParams": {"token": "-"},
+        "createSessionRequest": {
+            "session": {"name": session_id, "displayName": session_id}
+        }
+    }
+
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+    print(f"[DEBUG][create_chat_session] 发送请求到: {CREATE_SESSION_URL}")
+    print(f"[DEBUG][create_chat_session] 使用代理: {proxy}")
+    
+    request_start = time.time()
+    try:
+        resp = requests.post(
+            CREATE_SESSION_URL,
+            headers=get_headers(jwt),
+            json=body,
+            proxies=proxies,
+            verify=False,
+            timeout=30
+        )
+    except requests.RequestException as e:
+        raise AccountRequestError(f"创建会话请求失败: {e}") from e
+    print(f"[DEBUG][create_chat_session] 请求完成 - 状态码: {resp.status_code}, 耗时: {time.time() - request_start:.2f}秒")
+
+    if resp.status_code != 200:
+        print(f"[DEBUG][create_chat_session] 请求失败 - 响应: {resp.text[:500]}")
+        if resp.status_code == 401:
+            print(f"[DEBUG][create_chat_session] 401错误 - 可能是team_id填错了")
+        raise_for_account_response(resp, "创建会话")
+
+    data = resp.json()
+    session_name = data.get("session", {}).get("name")
+    print(f"[DEBUG][create_chat_session] 完成 - session_name: {session_name}, 总耗时: {time.time() - start_time:.2f}秒")
+    return session_name
+
+
+def ensure_session_for_account(account_idx: int, account: dict):
+    """确保指定账号的会话有效"""
+    print(f"[DEBUG][ensure_session_for_account] 开始 - 账号索引: {account_idx}")
+    start_time = time.time()
+    
+    jwt_start = time.time()
+    jwt = ensure_jwt_for_account(account_idx, account)
+    print(f"[DEBUG][ensure_session_for_account] JWT获取完成 - 耗时: {time.time() - jwt_start:.2f}秒")
+    
+    with account_manager.lock:
+        state = account_manager.account_states[account_idx]
+        print(f"[DEBUG][ensure_session_for_account] 当前session状态: {state['session'] is not None}")
+        if state["session"] is None:
+            print(f"[DEBUG][ensure_session_for_account] 需要创建新session...")
+            proxy = get_proxy()
+            team_id = account.get("team_id")
+            session_start = time.time()
+            state["session"] = create_chat_session(jwt, team_id, proxy)
+            print(f"[DEBUG][ensure_session_for_account] Session创建完成 - 耗时: {time.time() - session_start:.2f}秒")
+        else:
+            print(f"[DEBUG][ensure_session_for_account] 使用缓存session: {state['session']}")
+        
+        print(f"[DEBUG][ensure_session_for_account] 完成 - 总耗时: {time.time() - start_time:.2f}秒")
+        return state["session"], jwt, account.get("team_id")
+
+
+# ==================== 文件上传功能 ====================
+
+def upload_file_to_gemini(jwt: str, session_name: str, team_id: str, 
+                          file_content: bytes, filename: str, mime_type: str,
+                          proxy: str = None) -> str:
+    """
+    上传文件到 Gemini，返回 Gemini 的 fileId
+    
+    Args:
+        jwt: JWT 认证令牌
+        session_name: 会话名称
+        team_id: 团队ID
+        file_content: 文件内容（字节）
+        filename: 文件名
+        mime_type: MIME 类型
+        proxy: 代理地址
+    
+    Returns:
+        str: Gemini 返回的 fileId
+    """
+    start_time = time.time()
+    print(f"[DEBUG][upload_file_to_gemini] 开始上传文件: {filename}, MIME类型: {mime_type}, 文件大小: {len(file_content)} bytes")
+    
+    encode_start = time.time()
+    file_contents_b64 = base64.b64encode(file_content).decode('utf-8')
+    print(f"[DEBUG][upload_file_to_gemini] Base64编码完成 - 耗时: {time.time() - encode_start:.2f}秒, 编码后大小: {len(file_contents_b64)} chars")
+    
+    body = {
+        "addContextFileRequest": {
+            "fileContents": file_contents_b64,
+            "fileName": filename,
+            "mimeType": mime_type,
+            "name": session_name
+        },
+        "additionalParams": {"token": "-"},
+        "configId": team_id
+    }
+    
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+    print(f"[DEBUG][upload_file_to_gemini] 准备发送请求到: {ADD_CONTEXT_FILE_URL}")
+    print(f"[DEBUG][upload_file_to_gemini] 使用代理: {proxy if proxy else '无'}")
+    
+    request_start = time.time()
+    try:
+        resp = requests.post(
+            ADD_CONTEXT_FILE_URL,
+            headers=get_headers(jwt),
+            json=body,
+            proxies=proxies,
+            verify=False,
+            timeout=60
+        )
+    except requests.RequestException as e:
+        raise AccountRequestError(f"文件上传请求失败: {e}") from e
+    print(f"[DEBUG][upload_file_to_gemini] 请求完成 - 耗时: {time.time() - request_start:.2f}秒, 状态码: {resp.status_code}")
+    
+    if resp.status_code != 200:
+        print(f"[DEBUG][upload_file_to_gemini] 上传失败 - 响应内容: {resp.text[:500]}")
+        raise_for_account_response(resp, "文件上传")
+    
+    parse_start = time.time()
+    data = resp.json()
+    file_id = data.get("addContextFileResponse", {}).get("fileId")
+    print(f"[DEBUG][upload_file_to_gemini] 解析响应完成 - 耗时: {time.time() - parse_start:.2f}秒")
+    
+    if not file_id:
+        print(f"[DEBUG][upload_file_to_gemini] 响应中未找到fileId - 响应数据: {data}")
+        raise ValueError(f"响应中未找到 fileId: {data}")
+    
+    print(f"[DEBUG][upload_file_to_gemini] 上传成功 - fileId: {file_id}, 总耗时: {time.time() - start_time:.2f}秒")
+    return file_id
+
+
+# ==================== 图片处理功能 ====================
+
+@dataclass
+class ChatImage:
+    """表示生成的图片"""
+    url: Optional[str] = None
+    base64_data: Optional[str] = None
+    mime_type: str = "image/png"
+    local_path: Optional[str] = None
+    file_id: Optional[str] = None
+    file_name: Optional[str] = None
+
+
+@dataclass
+class ChatResponse:
+    """聊天响应，包含文本和图片"""
+    text: str = ""
+    images: List[ChatImage] = field(default_factory=list)
+    thoughts: List[str] = field(default_factory=list)
+
+
+def cleanup_expired_images():
+    """清理过期的缓存图片"""
+    if not IMAGE_CACHE_DIR.exists():
+        return
+    
+    now = time.time()
+    max_age_seconds = IMAGE_CACHE_HOURS * 3600
+    
+    for filepath in IMAGE_CACHE_DIR.iterdir():
+        if filepath.is_file():
+            try:
+                file_age = now - filepath.stat().st_mtime
+                if file_age > max_age_seconds:
+                    filepath.unlink()
+                    print(f"[图片缓存] 已删除过期图片: {filepath.name}")
+            except Exception as e:
+                print(f"[图片缓存] 删除失败: {filepath.name}, 错误: {e}")
+
+
+def save_image_to_cache(image_data: bytes, mime_type: str = "image/png", filename: Optional[str] = None) -> str:
+    """保存图片到缓存目录，返回文件名"""
+    IMAGE_CACHE_DIR.mkdir(exist_ok=True)
+    
+    # 确定文件扩展名
+    ext_map = {
+        "image/png": ".png",
+        "image/jpeg": ".jpg",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+    }
+    ext = ext_map.get(mime_type, ".png")
+    
+    if filename:
+        # 确保有正确的扩展名
+        if not any(filename.endswith(e) for e in ext_map.values()):
+            filename = f"{filename}{ext}"
+    else:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"gemini_{timestamp}_{uuid.uuid4().hex[:8]}{ext}"
+    
+    filepath = IMAGE_CACHE_DIR / filename
+    with open(filepath, "wb") as f:
+        f.write(image_data)
+    
+    return filename
+
+
+def parse_base64_data_url(data_url: str) -> Optional[Dict]:
+    """解析 base64 data URL，返回 {type, mime_type, data} 或 None"""
+    if not data_url or not data_url.startswith("data:"):
+        return None
+    
+    # base64格式: data:image/png;base64,xxxxx
+    match = re.match(r"data:([^;]+);base64,(.+)", data_url)
+    if match:
+        return {
+            "type": "base64",
+            "mime_type": match.group(1),
+            "data": match.group(2)
+        }
+    return None
+
+
+def extract_images_from_files_array(files: List[Dict]) -> List[Dict]:
+    """从 files 数组中提取图片（支持内联 base64 格式）
+    
+    支持格式:
+    {
+        "data": "data:image/png;base64,xxxxx",
+        "type": "image",
+        "detail": "high"  # 可选
+    }
+    
+    返回: 图片列表 [{type: 'base64', mime_type: ..., data: ...}]
+    """
+    images = []
+    for file_item in files:
+        if not isinstance(file_item, dict):
+            continue
+        
+        file_type = file_item.get("type", "")
+        
+        # 只处理图片类型
+        if file_type != "image":
+            continue
+        
+        data = file_item.get("data", "")
+        if data:
+            parsed = parse_base64_data_url(data)
+            if parsed:
+                images.append(parsed)
+    
+    return images
+
+
+def extract_images_from_openai_content(content: Any) -> Tuple[str, List[Dict]]:
+    """从OpenAI格式的content中提取文本和图片
+    
+    返回: (文本内容, 图片列表[{type: 'base64'|'url', data: ...}])
+    """
+    if isinstance(content, str):
+        return content, []
+    
+    if not isinstance(content, list):
+        return str(content), []
+    
+    text_parts = []
+    images = []
+    
+    for item in content:
+        if not isinstance(item, dict):
+            continue
+        
+        item_type = item.get("type", "")
+        
+        if item_type == "text":
+            text_parts.append(item.get("text", ""))
+        
+        elif item_type == "image_url":
+            image_url_obj = item.get("image_url", {})
+            if isinstance(image_url_obj, str):
+                url = image_url_obj
+            else:
+                url = image_url_obj.get("url", "")
+            
+            parsed = parse_base64_data_url(url)
+            if parsed:
+                images.append(parsed)
+            elif url:
+                # 普通URL
+                images.append({
+                    "type": "url",
+                    "url": url
+                })
+        
+        # 支持直接的 image 类型（带 data 字段）
+        elif item_type == "image" and item.get("data"):
+            parsed = parse_base64_data_url(item.get("data"))
+            if parsed:
+                images.append(parsed)
+    
+    return "\n".join(text_parts), images
+
+
+def download_image_from_url(url: str, proxy: Optional[str] = None) -> Tuple[bytes, str]:
+    """从URL下载图片，返回(图片数据, mime_type)"""
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+    resp = requests.get(url, proxies=proxies, verify=False, timeout=60)
+    resp.raise_for_status()
+    
+    content_type = resp.headers.get("Content-Type", "image/png")
+    # 提取主mime类型
+    mime_type = content_type.split(";")[0].strip()
+    
+    return resp.content, mime_type
+
+
+def get_session_file_metadata(jwt: str, session_name: str, team_id: str, proxy: Optional[str] = None) -> Dict:
+    """获取会话中的文件元数据（AI生成的图片）"""
+    body = {
+        "configId": team_id,
+        "additionalParams": {"token": "-"},
+        "listSessionFileMetadataRequest": {
+            "name": session_name,
+            "filter": "file_origin_type = AI_GENERATED"
+        }
+    }
+    
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+    resp = requests.post(
+        LIST_FILE_METADATA_URL,
+        headers=get_headers(jwt),
+        json=body,
+        proxies=proxies,
+        verify=False,
+        timeout=30
+    )
+    
+    if resp.status_code != 200:
+        print(f"[图片] 获取文件元数据失败: {resp.status_code}")
+        return {}
+    
+    data = resp.json()
+    # 返回 fileId -> metadata 的映射
+    result = {}
+    file_metadata_list = data.get("listSessionFileMetadataResponse", {}).get("fileMetadata", [])
+    for meta in file_metadata_list:
+        file_id = meta.get("fileId")
+        if file_id:
+            result[file_id] = meta
+    return result
+
+
+def build_download_url(session_name: str, file_id: str) -> str:
+    """构造正确的下载URL"""
+    return f"https://biz-discoveryengine.googleapis.com/v1alpha/{session_name}:downloadFile?fileId={file_id}&alt=media"
+
+
+def download_file_with_jwt(jwt: str, session_name: str, file_id: str, proxy: Optional[str] = None) -> bytes:
+    """使用JWT认证下载文件"""
+    url = build_download_url(session_name, file_id)
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+    
+    resp = requests.get(
+        url,
+        headers=get_headers(jwt),
+        proxies=proxies,
+        verify=False,
+        timeout=120,
+        allow_redirects=True
+    )
+    
+    resp.raise_for_status()
+    content = resp.content
+    
+    # 检测是否为base64编码的内容
+    try:
+        text_content = content.decode("utf-8", errors="ignore").strip()
+        if text_content.startswith("iVBORw0KGgo") or text_content.startswith("/9j/"):
+            # 是base64编码，需要解码
+            return base64.b64decode(text_content)
+    except Exception:
+        pass
+    
+    return content
+
+
+def upload_inline_image_to_gemini(jwt: str, session_name: str, team_id: str, 
+                                   image_data: Dict, proxy: str = None) -> Optional[str]:
+    """上传内联图片到 Gemini，返回 fileId"""
+    try:
+        ext_map = {"image/png": ".png", "image/jpeg": ".jpg", "image/gif": ".gif", "image/webp": ".webp"}
+        
+        if image_data.get("type") == "base64":
+            mime_type = image_data.get("mime_type", "image/png")
+            file_content = base64.b64decode(image_data.get("data", ""))
+            ext = ext_map.get(mime_type, ".png")
+            filename = f"inline_{uuid.uuid4().hex[:8]}{ext}"
+        elif image_data.get("type") == "url":
+            file_content, mime_type = download_image_from_url(image_data.get("url"), proxy)
+            ext = ext_map.get(mime_type, ".png")
+            filename = f"url_{uuid.uuid4().hex[:8]}{ext}"
+        else:
+            return None
+        
+        return upload_file_to_gemini(jwt, session_name, team_id, file_content, filename, mime_type, proxy)
+    except AccountError:
+        # 让账号相关错误向上抛出，以便触发冷却
+        raise
+    except Exception:
+        return None
+
+
+def stream_chat_with_images(jwt: str, sess_name: str, message: str, 
+                            proxy: str, team_id: str, file_ids: List[str] = None) -> ChatResponse:
+    """发送消息并流式接收响应"""
+    query_parts = [{"text": message}]
+    request_file_ids = file_ids if file_ids else []
+    
+    body = {
+        "configId": team_id,
+        "additionalParams": {"token": "-"},
+        "streamAssistRequest": {
+            "session": sess_name,
+            "query": {"parts": query_parts},
+            "filter": "",
+            "fileIds": request_file_ids,
+            "answerGenerationMode": "NORMAL",
+            "assistGenerationConfig":{
+                "modelId":"gemini-3-pro-preview"
+            },
+            "toolsSpec": {
+                "webGroundingSpec": {},
+                "toolRegistry": "default_tool_registry",
+                "imageGenerationSpec": {},
+                "videoGenerationSpec": {}
+            },
+            "languageCode": "zh-CN",
+            "userMetadata": {"timeZone": "Etc/GMT-8"},
+            "assistSkippingMode": "REQUEST_ASSIST"
+        }
+    }
+
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+    try:
+        resp = requests.post(
+            STREAM_ASSIST_URL,
+            headers=get_headers(jwt),
+            json=body,
+            proxies=proxies,
+            verify=False,
+            timeout=120,
+            stream=True
+        )
+    except requests.RequestException as e:
+        raise AccountRequestError(f"聊天请求失败: {e}") from e
+
+    if resp.status_code != 200:
+        raise_for_account_response(resp, "聊天请求")
+
+    # 收集完整响应
+    full_response = ""
+    for line in resp.iter_lines():
+        if line:
+            full_response += line.decode('utf-8') + "\n"
+
+    # 解析响应
+    result = ChatResponse()
+    texts = []
+    file_ids = []  # 收集需要下载的文件 {fileId, mimeType}
+    current_session = None
+    
+    try:
+        data_list = json.loads(full_response)
+        for data in data_list:
+            sar = data.get("streamAssistResponse")
+            if not sar:
+                continue
+            
+            # 获取session信息
+            session_info = sar.get("sessionInfo", {})
+            if session_info.get("session"):
+                current_session = session_info["session"]
+            
+            # 检查顶层的generatedImages
+            for gen_img in sar.get("generatedImages", []):
+                parse_generated_image(gen_img, result, proxy)
+            
+            answer = sar.get("answer") or {}
+            
+            # 检查answer级别的generatedImages
+            for gen_img in answer.get("generatedImages", []):
+                parse_generated_image(gen_img, result, proxy)
+            
+            for reply in answer.get("replies", []):
+                # 检查reply级别的generatedImages
+                for gen_img in reply.get("generatedImages", []):
+                    parse_generated_image(gen_img, result, proxy)
+                
+                gc = reply.get("groundedContent", {})
+                content = gc.get("content", {})
+                text = content.get("text", "")
+                thought = content.get("thought", False)
+                
+                # 检查file字段（图片生成的关键）
+                file_info = content.get("file")
+                if file_info and file_info.get("fileId"):
+                    file_ids.append({
+                        "fileId": file_info["fileId"],
+                        "mimeType": file_info.get("mimeType", "image/png"),
+                        "fileName": file_info.get("name")
+                    })
+                
+                # 解析图片数据
+                parse_image_from_content(content, result, proxy)
+                parse_image_from_content(gc, result, proxy)
+                
+                # 检查attachments
+                for att in reply.get("attachments", []) + gc.get("attachments", []) + content.get("attachments", []):
+                    parse_attachment(att, result, proxy)
+                
+                if text and not thought:
+                    texts.append(text)
+
+        # 处理通过fileId引用的图片
+        if file_ids and current_session:
+            try:
+                file_metadata = get_session_file_metadata(jwt, current_session, team_id, proxy)
+                for finfo in file_ids:
+                    fid = finfo["fileId"]
+                    mime = finfo["mimeType"]
+                    fname = finfo.get("fileName")
+                    meta = file_metadata.get(fid)
+
+                    if meta:
+                        fname = fname or meta.get("name")
+                        session_path = meta.get("session") or current_session
+                    else:
+                        session_path = current_session
+
+                    try:
+                        image_data = download_file_with_jwt(jwt, session_path, fid, proxy)
+                        filename = None
+                        local_path = None
+                        b64_data = base64.b64encode(image_data).decode("utf-8")
+
+                        # 仅在 URL 模式下缓存到本地以便通过 /image/ 访问
+                        if not is_base64_output_mode():
+                            filename = save_image_to_cache(image_data, mime, fname)
+                            local_path = str(IMAGE_CACHE_DIR / filename)
+
+                        img = ChatImage(
+                            file_id=fid,
+                            file_name=filename,
+                            mime_type=mime,
+                            local_path=local_path,
+                            base64_data=b64_data,
+                        )
+                        result.images.append(img)
+                        if filename:
+                            print(f"[图片] 已保存: {filename}")
+                    except Exception as e:
+                        print(f"[图片] 下载失败 (fileId={fid}): {e}")
+            except Exception as e:
+                print(f"[图片] 获取文件元数据失败: {e}")
+
+    except json.JSONDecodeError:
+        pass
+
+    result.text = "".join(texts)
+    return result
+
+
+def parse_generated_image(gen_img: Dict, result: ChatResponse, proxy: Optional[str] = None):
+    """解析generatedImages中的图片"""
+    image_data = gen_img.get("image")
+    if not image_data:
+        return
+    
+    # 检查base64数据
+    b64_data = image_data.get("bytesBase64Encoded")
+    if b64_data:
+        try:
+            mime_type = image_data.get("mimeType", "image/png")
+            filename = None
+            local_path = None
+
+            # 仅在 URL 模式下落盘缓存
+            if not is_base64_output_mode():
+                decoded = base64.b64decode(b64_data)
+                filename = save_image_to_cache(decoded, mime_type)
+                local_path = str(IMAGE_CACHE_DIR / filename)
+
+            img = ChatImage(
+                base64_data=b64_data,
+                mime_type=mime_type,
+                file_name=filename,
+                local_path=local_path,
+            )
+            result.images.append(img)
+            if filename:
+                print(f"[图片] 已保存: {filename}")
+        except Exception as e:
+            print(f"[图片] 解析base64失败: {e}")
+
+
+def parse_image_from_content(content: Dict, result: ChatResponse, proxy: Optional[str] = None):
+    """从content中解析图片"""
+    # 检查inlineData
+    inline_data = content.get("inlineData")
+    if inline_data:
+        b64_data = inline_data.get("data")
+        if b64_data:
+            try:
+                mime_type = inline_data.get("mimeType", "image/png")
+                filename = None
+                local_path = None
+
+                if not is_base64_output_mode():
+                    decoded = base64.b64decode(b64_data)
+                    filename = save_image_to_cache(decoded, mime_type)
+                    local_path = str(IMAGE_CACHE_DIR / filename)
+
+                img = ChatImage(
+                    base64_data=b64_data,
+                    mime_type=mime_type,
+                    file_name=filename,
+                    local_path=local_path,
+                )
+                result.images.append(img)
+                if filename:
+                    print(f"[图片] 已保存: {filename}")
+            except Exception as e:
+                print(f"[图片] 解析inlineData失败: {e}")
+
+
+def parse_attachment(att: Dict, result: ChatResponse, proxy: Optional[str] = None):
+    """解析attachment中的图片"""
+    # 检查是否是图片类型
+    mime_type = att.get("mimeType", "")
+    if not mime_type.startswith("image/"):
+        return
+    
+    # 检查base64数据
+    b64_data = att.get("data") or att.get("bytesBase64Encoded")
+    if b64_data:
+        try:
+            filename = None
+            local_path = None
+
+            if not is_base64_output_mode():
+                decoded = base64.b64decode(b64_data)
+                filename = att.get("name") or None
+                filename = save_image_to_cache(decoded, mime_type, filename)
+                local_path = str(IMAGE_CACHE_DIR / filename)
+
+            img = ChatImage(
+                base64_data=b64_data,
+                mime_type=mime_type,
+                file_name=filename,
+                local_path=local_path,
+            )
+            result.images.append(img)
+            if filename:
+                print(f"[图片] 已保存: {filename}")
+        except Exception as e:
+            print(f"[图片] 解析attachment失败: {e}")
+
+
+# ==================== OpenAPI 接口 ====================
+
+@app.route('/v1/models', methods=['GET'])
+@require_api_auth
+def list_models():
+    """获取模型列表"""
+    models_config = account_manager.config.get("models", [])
+    models_data = []
+    
+    for model in models_config:
+        models_data.append({
+            "id": model.get("id", "gemini-enterprise"),
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": model.get("id", "gemini-enterprise"),
+            "parent": None
+        })
+    
+    # 如果没有配置模型，返回默认模型
+    if not models_data:
+        models_data.append({
+            "id": "gemini-enterprise",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "google",
+            "permission": [],
+            "root": "gemini-enterprise",
+            "parent": None
+        })
+    
+    return jsonify({"object": "list", "data": models_data})
+
+
+@app.route('/v1/files', methods=['POST'])
+@require_api_auth
+def upload_file():
+    """OpenAI 兼容的文件上传接口"""
+    import traceback
+    request_start_time = time.time()
+    print(f"\n{'='*60}")
+    print(f"[文件上传] ===== 接口调用开始 =====")
+    print(f"[文件上传] 请求时间: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    try:
+        # 检查是否有文件
+        step_start = time.time()
+        print(f"[文件上传] 步骤1: 检查请求中的文件...")
+        if 'file' not in request.files:
+            print(f"[文件上传] 错误: 请求中没有文件")
+            return jsonify({"error": {"message": "No file provided", "type": "invalid_request_error"}}), 400
+        
+        file = request.files['file']
+        if file.filename == '':
+            print(f"[文件上传] 错误: 文件名为空")
+            return jsonify({"error": {"message": "No file selected", "type": "invalid_request_error"}}), 400
+        print(f"[文件上传] 步骤1完成: 文件名={file.filename}, 耗时={time.time()-step_start:.3f}秒")
+        
+        # 获取文件内容和MIME类型
+        step_start = time.time()
+        print(f"[文件上传] 步骤2: 读取文件内容...")
+        file_content = file.read()
+        mime_type = file.content_type or mimetypes.guess_type(file.filename)[0] or 'application/octet-stream'
+        print(f"[文件上传] 步骤2完成: 文件大小={len(file_content)}字节, MIME类型={mime_type}, 耗时={time.time()-step_start:.3f}秒")
+        
+        # 获取账号信息
+        available_accounts = account_manager.get_available_accounts()
+        if not available_accounts:
+            next_cd = account_manager.get_next_cooldown_info()
+            wait_msg = ""
+            if next_cd:
+                wait_msg = f"（最近冷却账号 {next_cd['index']}，约 {int(next_cd['cooldown_until']-time.time())} 秒后可重试）"
+            return jsonify({"error": {"message": f"没有可用的账号{wait_msg}", "type": "rate_limit"}}), 429
+
+        max_retries = len(available_accounts)
+        last_error = None
+        gemini_file_id = None
+        print(f"[文件上传] 步骤3: 开始尝试上传, 最大重试次数={max_retries}")
+        
+        for retry_idx in range(max_retries):
+            retry_start = time.time()
+            print(f"\n[文件上传] --- 第{retry_idx+1}次尝试 ---")
+            account_idx = None
+            try:
+                # 获取账号
+                step_start = time.time()
+                print(f"[文件上传] 步骤3.{retry_idx+1}.1: 获取下一个可用账号...")
+                account_idx, account = account_manager.get_next_account()
+                print(f"[文件上传] 步骤3.{retry_idx+1}.1完成: 账号索引={account_idx}, CSESIDX={account.get('csesidx')}, 耗时={time.time()-step_start:.3f}秒")
+                
+                # 确保会话有效
+                step_start = time.time()
+                print(f"[文件上传] 步骤3.{retry_idx+1}.2: 确保会话有效(JWT+Session)...")
+                session, jwt, team_id = ensure_session_for_account(account_idx, account)
+                print(f"[文件上传] 步骤3.{retry_idx+1}.2完成: session={session}, team_id={team_id}, 耗时={time.time()-step_start:.3f}秒")
+                
+                proxy = get_proxy()
+                print(f"[文件上传] 代理设置: {proxy}")
+                
+                # 上传文件到 Gemini
+                step_start = time.time()
+                print(f"[文件上传] 步骤3.{retry_idx+1}.3: 上传文件到Gemini...")
+                gemini_file_id = upload_file_to_gemini(jwt, session, team_id, file_content, file.filename, mime_type, proxy)
+                print(f"[文件上传] 步骤3.{retry_idx+1}.3完成: gemini_file_id={gemini_file_id}, 耗时={time.time()-step_start:.3f}秒")
+                
+                if gemini_file_id:
+                    # 生成 OpenAI 格式的 file_id
+                    step_start = time.time()
+                    print(f"[文件上传] 步骤4: 生成OpenAI格式响应...")
+                    openai_file_id = f"file-{uuid.uuid4().hex[:24]}"
+                    
+                    # 保存映射关系
+                    file_manager.add_file(
+                        openai_file_id=openai_file_id,
+                        gemini_file_id=gemini_file_id,
+                        session_name=session,
+                        filename=file.filename,
+                        mime_type=mime_type,
+                        size=len(file_content)
+                    )
+                    print(f"[文件上传] 步骤4完成: openai_file_id={openai_file_id}, 耗时={time.time()-step_start:.3f}秒")
+                    
+                    total_time = time.time() - request_start_time
+                    print(f"\n[文件上传] ===== 上传成功 =====")
+                    print(f"[文件上传] 总耗时: {total_time:.3f}秒")
+                    print(f"{'='*60}\n")
+                    
+                    # 返回 OpenAI 格式响应
+                    return jsonify({
+                        "id": openai_file_id,
+                        "object": "file",
+                        "bytes": len(file_content),
+                        "created_at": int(time.time()),
+                        "filename": file.filename,
+                        "purpose": request.form.get('purpose', 'assistants')
+                    })
+                else:
+                    print(f"[文件上传] 警告: gemini_file_id为空")
+            
+            except AccountRateLimitError as e:
+                last_error = e
+                if account_idx is not None:
+                    pt_wait = seconds_until_next_pt_midnight()
+                    cooldown_seconds = max(account_manager.rate_limit_cooldown, pt_wait)
+                    account_manager.mark_account_cooldown(account_idx, str(e), cooldown_seconds)
+                print(f"[文件上传] 第{retry_idx+1}次尝试失败(限额): {e}")
+                print(f"[文件上传] 本次尝试耗时: {time.time()-retry_start:.3f}秒")
+                continue
+            except AccountAuthError as e:
+                last_error = e
+                if account_idx is not None:
+                    account_manager.mark_account_cooldown(account_idx, str(e), account_manager.auth_error_cooldown)
+                print(f"[文件上传] 第{retry_idx+1}次尝试失败(凭证): {e}")
+                print(f"[文件上传] 本次尝试耗时: {time.time()-retry_start:.3f}秒")
+                continue
+            except AccountRequestError as e:
+                last_error = e
+                if account_idx is not None:
+                    account_manager.mark_account_cooldown(account_idx, str(e), account_manager.generic_error_cooldown)
+                print(f"[文件上传] 第{retry_idx+1}次尝试失败(请求异常): {e}")
+                print(f"[文件上传] 本次尝试耗时: {time.time()-retry_start:.3f}秒")
+                continue
+            except NoAvailableAccount as e:
+                last_error = e
+                print(f"[文件上传] 无可用账号: {e}")
+                break
+            except Exception as e:
+                last_error = e
+                print(f"[文件上传] 第{retry_idx+1}次尝试失败: {type(e).__name__}: {e}")
+                print(f"[文件上传] 堆栈跟踪:\n{traceback.format_exc()}")
+                print(f"[文件上传] 本次尝试耗时: {time.time()-retry_start:.3f}秒")
+                if account_idx is None:
+                    break
+                continue
+        
+        total_time = time.time() - request_start_time
+        print(f"\n[文件上传] ===== 所有重试均失败 =====")
+        error_message = last_error or "没有可用的账号"
+        print(f"[文件上传] 最后错误: {error_message}")
+        print(f"[文件上传] 总耗时: {total_time:.3f}秒")
+        print(f"{'='*60}\n")
+        status_code = 429 if isinstance(last_error, (AccountRateLimitError, NoAvailableAccount)) else 500
+        err_type = "rate_limit" if status_code == 429 else "api_error"
+        return jsonify({"error": {"message": f"文件上传失败: {error_message}", "type": err_type}}), status_code
+        
+    except Exception as e:
+        total_time = time.time() - request_start_time
+        print(f"\n[文件上传] ===== 发生异常 =====")
+        print(f"[文件上传] 错误类型: {type(e).__name__}")
+        print(f"[文件上传] 错误信息: {e}")
+        print(f"[文件上传] 堆栈跟踪:\n{traceback.format_exc()}")
+        print(f"[文件上传] 总耗时: {total_time:.3f}秒")
+        print(f"{'='*60}\n")
+        return jsonify({"error": {"message": str(e), "type": "api_error"}}), 500
+
+
+@app.route('/v1/files', methods=['GET'])
+@require_api_auth
+def list_files():
+    """获取已上传文件列表"""
+    files = file_manager.list_files()
+    return jsonify({
+        "object": "list",
+        "data": [{
+            "id": f["openai_file_id"],
+            "object": "file",
+            "bytes": f.get("size", 0),
+            "created_at": f.get("created_at", int(time.time())),
+            "filename": f.get("filename", ""),
+            "purpose": "assistants"
+        } for f in files]
+    })
+
+
+@app.route('/v1/files/<file_id>', methods=['GET'])
+@require_api_auth
+def get_file(file_id):
+    """获取文件信息"""
+    file_info = file_manager.get_file(file_id)
+    if not file_info:
+        return jsonify({"error": {"message": "File not found", "type": "invalid_request_error"}}), 404
+    
+    return jsonify({
+        "id": file_info["openai_file_id"],
+        "object": "file",
+        "bytes": file_info.get("size", 0),
+        "created_at": file_info.get("created_at", int(time.time())),
+        "filename": file_info.get("filename", ""),
+        "purpose": "assistants"
+    })
+
+
+@app.route('/v1/files/<file_id>', methods=['DELETE'])
+@require_api_auth
+def delete_file(file_id):
+    """删除文件"""
+    if file_manager.delete_file(file_id):
+        return jsonify({
+            "id": file_id,
+            "object": "file",
+            "deleted": True
+        })
+    return jsonify({"error": {"message": "File not found", "type": "invalid_request_error"}}), 404
+
+
+@app.route('/v1/chat/completions', methods=['POST'])
+@require_api_auth
+def chat_completions():
+    """聊天对话接口（支持图��输入输出）"""
+    try:
+        # 每次请求时清理过期图片
+        cleanup_expired_images()
+        
+        data = request.json
+        messages = data.get('messages', [])
+        prompts = data.get('prompts', [])  # 支持替代格式
+        stream = data.get('stream', False)
+
+        # 提取用户消息、图片和文件ID
+        user_message = ""
+        input_images = []
+        input_file_ids = []  # OpenAI file_id 列表
+        
+        # 处理标准 OpenAI messages 格式
+        for msg in messages:
+            if msg.get('role') == 'user':
+                content = msg.get('content', '')
+                text, images = extract_images_from_openai_content(content)
+                if text:
+                    user_message = text
+                input_images.extend(images)
+                
+                # 提取文件ID（支持多种格式）
+                if isinstance(content, list):
+                    for item in content:
+                        if isinstance(item, dict):
+                            # 格式1: {"type": "file", "file_id": "xxx"}
+                            if item.get('type') == 'file' and item.get('file_id'):
+                                input_file_ids.append(item['file_id'])
+                            # 格式2: {"type": "file", "file": {"file_id": "xxx"}}
+                            elif item.get('type') == 'file' and isinstance(item.get('file'), dict):
+                                file_obj = item['file']
+                                # 支持 file_id 或 id 两种字段名
+                                fid = file_obj.get('file_id') or file_obj.get('id')
+                                if fid:
+                                    input_file_ids.append(fid)
+        
+        # 处理替代 prompts 格式（支持内联 base64 图片）
+        # 格式: {"prompts": [{"role": "user", "text": "...", "files": [{"data": "data:image...", "type": "image"}]}]}
+        for prompt in prompts:
+            if prompt.get('role') == 'user':
+                # 提取文本
+                prompt_text = prompt.get('text', '')
+                if prompt_text and not user_message:
+                    user_message = prompt_text
+                elif prompt_text:
+                    user_message = prompt_text  # 使用最新的用户消息
+                
+                # 提取内联 files 数组中的图片
+                files_array = prompt.get('files', [])
+                if files_array:
+                    images_from_files = extract_images_from_files_array(files_array)
+                    input_images.extend(images_from_files)
+        
+        # 将 OpenAI file_id 转换为 Gemini fileId
+        gemini_file_ids = []
+        for fid in input_file_ids:
+            gemini_fid = file_manager.get_gemini_file_id(fid)
+            if gemini_fid:
+                gemini_file_ids.append(gemini_fid)
+        
+        if not user_message and not input_images and not gemini_file_ids:
+            return jsonify({"error": "No user message found"}), 400
+        
+        # 检查是否指定了特定账号
+        specified_account_id = data.get('account_id')
+        
+        if specified_account_id is not None:
+            # 使用指定的账号
+            accounts = account_manager.accounts
+            if specified_account_id < 0 or specified_account_id >= len(accounts):
+                return jsonify({"error": f"无效的账号ID: {specified_account_id}"}), 400
+            account = accounts[specified_account_id]
+            if not account.get('enabled', True):
+                return jsonify({"error": f"账号 {specified_account_id} 已禁用"}), 400
+            # 检查是否在冷却中
+            cooldown_until = account.get('cooldown_until', 0)
+            if cooldown_until > time.time():
+                return jsonify({"error": f"账号 {specified_account_id} 正在冷却中，请稍后重试"}), 429
+            
+            max_retries = 1
+            last_error = None
+            chat_response = None
+            account_idx = specified_account_id
+            try:
+                session, jwt, team_id = ensure_session_for_account(account_idx, account)
+                proxy = get_proxy()
+                
+                for img in input_images:
+                    uploaded_file_id = upload_inline_image_to_gemini(jwt, session, team_id, img, proxy)
+                    if uploaded_file_id:
+                        gemini_file_ids.append(uploaded_file_id)
+                
+                chat_response = stream_chat_with_images(jwt, session, user_message, proxy, team_id, gemini_file_ids)
+            except (AccountRateLimitError, AccountAuthError, AccountRequestError) as e:
+                last_error = e
+                account_manager.mark_account_cooldown(account_idx, str(e), account_manager.generic_error_cooldown)
+            except Exception as e:
+                last_error = e
+        else:
+            # 轮训获取账号
+            available_accounts = account_manager.get_available_accounts()
+            if not available_accounts:
+                next_cd = account_manager.get_next_cooldown_info()
+                wait_msg = ""
+                if next_cd:
+                    wait_msg = f"（最近冷却账号 {next_cd['index']}，约 {int(next_cd['cooldown_until']-time.time())} 秒后可重试）"
+                return jsonify({"error": f"没有可用的账号{wait_msg}"}), 429
+
+            max_retries = len(available_accounts)
+            last_error = None
+            chat_response = None
+            
+            for retry_idx in range(max_retries):
+                account_idx = None
+                try:
+                    account_idx, account = account_manager.get_next_account()
+                    session, jwt, team_id = ensure_session_for_account(account_idx, account)
+                    proxy = get_proxy()
+                    
+                    # 上传内联图片获取 fileId
+                    for img in input_images:
+                        uploaded_file_id = upload_inline_image_to_gemini(jwt, session, team_id, img, proxy)
+                        if uploaded_file_id:
+                            gemini_file_ids.append(uploaded_file_id)
+                    
+                    chat_response = stream_chat_with_images(jwt, session, user_message, proxy, team_id, gemini_file_ids)
+                    break
+                except AccountRateLimitError as e:
+                    last_error = e
+                    if account_idx is not None:
+                        pt_wait = seconds_until_next_pt_midnight()
+                        cooldown_seconds = max(account_manager.rate_limit_cooldown, pt_wait)
+                        account_manager.mark_account_cooldown(account_idx, str(e), cooldown_seconds)
+                    print(f"[聊天] 第{retry_idx+1}次尝试失败(限额): {e}")
+                    continue
+                except AccountAuthError as e:
+                    last_error = e
+                    if account_idx is not None:
+                        account_manager.mark_account_cooldown(account_idx, str(e), account_manager.auth_error_cooldown)
+                    print(f"[聊天] 第{retry_idx+1}次尝试失败(凭证): {e}")
+                    continue
+                except AccountRequestError as e:
+                    last_error = e
+                    if account_idx is not None:
+                        account_manager.mark_account_cooldown(account_idx, str(e), account_manager.generic_error_cooldown)
+                    print(f"[聊天] 第{retry_idx+1}次尝试失败(请求异常): {e}")
+                    continue
+                except Exception as e:
+                    last_error = e
+                    print(f"[聊天] 第{retry_idx+1}次尝试失败: {type(e).__name__}: {e}")
+                    if account_idx is None:
+                        break
+                    continue
+        
+        if chat_response is None:
+            error_message = last_error or "没有可用的账号"
+            status_code = 429 if isinstance(last_error, (AccountRateLimitError, NoAvailableAccount)) else 500
+            return jsonify({"error": f"所有账号请求失败: {error_message}"}), status_code
+
+        # 获取使用的账号csesidx
+        used_account_csesidx = None
+        if account_idx is not None and account_idx < len(account_manager.accounts):
+            used_account = account_manager.accounts[account_idx]
+            used_account_csesidx = used_account.get('csesidx', f'账号{account_idx}')
+
+        # 构建响应内容（包含图片）
+        response_content = build_openai_response_content(chat_response, request.host_url)
+
+        if stream:
+            # 流式响应
+            def generate():
+                chunk_id = f"chatcmpl-{uuid.uuid4().hex[:8]}"
+                chunk = {
+                    "id": chunk_id,
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": "gemini-enterprise",
+                    "account_csesidx": used_account_csesidx,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {"content": response_content},
+                        "finish_reason": None
+                    }]
+                }
+                yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+                
+                # 结束标记
+                end_chunk = {
+                    "id": chunk_id,
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": "gemini-enterprise",
+                    "choices": [{
+                        "index": 0,
+                        "delta": {},
+                        "finish_reason": "stop"
+                    }]
+                }
+                yield f"data: {json.dumps(end_chunk, ensure_ascii=False)}\n\n"
+                yield "data: [DONE]\n\n"
+
+            return Response(generate(), mimetype='text/event-stream')
+        else:
+            # 非流式响应
+            response = {
+                "id": f"chatcmpl-{uuid.uuid4().hex[:8]}",
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": "gemini-enterprise",
+                "account_csesidx": used_account_csesidx,
+                "choices": [{
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": response_content
+                    },
+                    "finish_reason": "stop"
+                }],
+                "usage": {
+                    "prompt_tokens": len(user_message),
+                    "completion_tokens": len(chat_response.text),
+                    "total_tokens": len(user_message) + len(chat_response.text)
+                }
+            }
+            return jsonify(response)
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+def get_image_base_url(fallback_host_url: str) -> str:
+    """获取图片基础URL
+    
+    优先使用配置文件中的 image_base_url，否则使用请求的 host_url
+    """
+    configured_url = account_manager.config.get("image_base_url", "").strip()
+    if configured_url:
+        # 确保以 / 结尾
+        if not configured_url.endswith("/"):
+            configured_url += "/"
+        return configured_url
+    return fallback_host_url
+
+
+def is_base64_output_mode() -> bool:
+    try:
+        if account_manager.config:
+            mode = account_manager.config.get("image_output_mode") or "url"
+            if isinstance(mode, str) and mode.lower() == "base64":
+                return True
+    except Exception:
+        pass
+    return False
+
+
+def build_openai_response_content(chat_response: ChatResponse, host_url: str) -> str:
+    """构建OpenAI格式的响应内容
+
+    返回纯文本，如果有图片可根据配置选择:
+    - url: 在文本末尾追加图片URL（默认行为）
+    - base64: 在文本末尾追加 data:image/...;base64,...
+    """
+    result_text = chat_response.text
+
+    if not chat_response.images:
+        return result_text
+
+    # 从配置读取图片输出模式，默认 url
+    image_mode = "base64" if is_base64_output_mode() else "url"
+
+    image_lines = []
+
+    if image_mode == "base64":
+        # 优先使用已有的base64数据（使用 Markdown 图片语法，方便前端渲染）
+        for img in chat_response.images:
+            if img.base64_data:
+                mime = img.mime_type or "image/png"
+                image_lines.append(f"![image](data:{mime};base64,{img.base64_data})")
+
+        # 若部分图片没有base64数据，降级为URL形式，同样用 Markdown 图片语法
+        base_url = get_image_base_url(host_url)
+        for img in chat_response.images:
+            if not img.base64_data and img.file_name:
+                image_lines.append(f"![image]({base_url}image/{img.file_name})")
+    else:
+        # 传统URL模式
+        base_url = get_image_base_url(host_url)
+        for img in chat_response.images:
+            if img.file_name:
+                image_lines.append(f"{base_url}image/{img.file_name}")
+
+    if image_lines:
+        if result_text:
+            result_text += "\n\n"
+        result_text += "\n".join(image_lines)
+
+    return result_text
+
+
+# ==================== 图片服务接口 ====================
+
+@app.route('/image/<path:filename>')
+def serve_image(filename):
+    """提供缓存图片的访问"""
+    # 安全检查：防止路径遍历
+    if '..' in filename or filename.startswith('/'):
+        abort(404)
+    
+    filepath = IMAGE_CACHE_DIR / filename
+    if not filepath.exists():
+        abort(404)
+    
+    # 确定Content-Type
+    ext = filepath.suffix.lower()
+    mime_types = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+    }
+    mime_type = mime_types.get(ext, 'application/octet-stream')
+    
+    return send_from_directory(IMAGE_CACHE_DIR, filename, mimetype=mime_type)
+
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """健康检查"""
+    return jsonify({"status": "ok", "timestamp": datetime.now().isoformat()})
+
+
+@app.route('/api/status', methods=['GET'])
+@require_admin
+def system_status():
+    """获取系统状态"""
+    total, available = account_manager.get_account_count()
+    proxy_url = account_manager.config.get("proxy")
+    proxy_enabled = account_manager.config.get("proxy_enabled", False)
+    effective_proxy = get_proxy()  # 实际使用的代理（考虑开关状态）
+    
+    return jsonify({
+        "status": "ok",
+        "timestamp": datetime.now().isoformat(),
+        "accounts": {
+            "total": total,
+            "available": available
+        },
+        "proxy": {
+            "url": proxy_url,
+            "enabled": proxy_enabled,
+            "effective": effective_proxy,  # 实际生效的代理地址
+            "available": check_proxy(effective_proxy) if effective_proxy else False
+        },
+        "models": account_manager.config.get("models", [])
+    })
+
+
+# ==================== 管理接口 ====================
+
+@app.route('/')
+def index():
+    """返回管理页面"""
+    return send_from_directory('.', 'index.html')
+
+@app.route('/chat_history.html')
+@require_admin
+def chat_history():
+    """返回聊天记录页面"""
+    return send_from_directory('.', 'chat_history.html')
+
+@app.route('/api/accounts', methods=['GET'])
+@require_admin
+def get_accounts():
+    """获取账号列表"""
+    accounts_data = []
+    now_ts = time.time()
+    for i, acc in enumerate(account_manager.accounts):
+        state = account_manager.account_states.get(i, {})
+        cooldown_until = state.get("cooldown_until")
+        cooldown_active = bool(cooldown_until and cooldown_until > now_ts)
+        effective_available = state.get("available", True) and not cooldown_active
+
+        # 返回完整值用于编辑，前端显示时再截断
+        accounts_data.append({
+            "id": i,
+            "team_id": acc.get("team_id", ""),
+            "secure_c_ses": acc.get("secure_c_ses", ""),
+            "host_c_oses": acc.get("host_c_oses", ""),
+            "csesidx": acc.get("csesidx", ""),
+            "user_agent": acc.get("user_agent", ""),
+            "available": effective_available,
+            "unavailable_reason": acc.get("unavailable_reason", ""),
+            "cooldown_until": cooldown_until if cooldown_active else None,
+            "cooldown_reason": state.get("cooldown_reason", ""),
+            "has_jwt": state.get("jwt") is not None
+        })
+    return jsonify({"accounts": accounts_data})
+
+
+@app.route('/api/accounts', methods=['POST'])
+@require_admin
+def add_account():
+    """添加账号"""
+    data = request.json
+    # 去重：基于 csesidx 或 team_id 检查
+    new_csesidx = data.get("csesidx", "")
+    new_team_id = data.get("team_id", "")
+    for acc in account_manager.accounts:
+        if new_csesidx and acc.get("csesidx") == new_csesidx:
+            return jsonify({"error": "账号已存在（同 csesidx）"}), 400
+        if new_team_id and acc.get("team_id") == new_team_id and new_csesidx == acc.get("csesidx"):
+            return jsonify({"error": "账号已存在（同 team_id + csesidx）"}), 400
+
+    new_account = {
+        "team_id": data.get("team_id", ""),
+        "secure_c_ses": data.get("secure_c_ses", ""),
+        "host_c_oses": data.get("host_c_oses", ""),
+        "csesidx": data.get("csesidx", ""),
+        "user_agent": data.get("user_agent", "Mozilla/5.0"),
+        "available": True
+    }
+    
+    account_manager.accounts.append(new_account)
+    idx = len(account_manager.accounts) - 1
+    account_manager.account_states[idx] = {
+        "jwt": None,
+        "jwt_time": 0,
+        "session": None,
+        "available": True,
+        "cooldown_until": None,
+        "cooldown_reason": ""
+    }
+    account_manager.config["accounts"] = account_manager.accounts
+    account_manager.save_config()
+    
+    return jsonify({"success": True, "id": idx})
+
+
+@app.route('/api/accounts/<int:account_id>', methods=['PUT'])
+@require_admin
+def update_account(account_id):
+    """更新账号"""
+    if account_id < 0 or account_id >= len(account_manager.accounts):
+        return jsonify({"error": "账号不存在"}), 404
+    
+    data = request.json
+    acc = account_manager.accounts[account_id]
+    
+    if "team_id" in data:
+        acc["team_id"] = data["team_id"]
+    if "secure_c_ses" in data:
+        acc["secure_c_ses"] = data["secure_c_ses"]
+    if "host_c_oses" in data:
+        acc["host_c_oses"] = data["host_c_oses"]
+    if "csesidx" in data:
+        acc["csesidx"] = data["csesidx"]
+    if "user_agent" in data:
+        acc["user_agent"] = data["user_agent"]
+    
+    # 同步更新config中的accounts
+    account_manager.config["accounts"] = account_manager.accounts
+    account_manager.save_config()
+    return jsonify({"success": True})
+
+
+@app.route('/api/accounts/<int:account_id>', methods=['DELETE'])
+@require_admin
+def delete_account(account_id):
+    """删除账号"""
+    if account_id < 0 or account_id >= len(account_manager.accounts):
+        return jsonify({"error": "账号不存在"}), 404
+    
+    account_manager.accounts.pop(account_id)
+    # 重建状态映射
+    new_states = {}
+    for i in range(len(account_manager.accounts)):
+        if i < account_id:
+            new_states[i] = account_manager.account_states.get(i, {})
+        else:
+            new_states[i] = account_manager.account_states.get(i + 1, {})
+    account_manager.account_states = new_states
+    account_manager.config["accounts"] = account_manager.accounts
+    account_manager.save_config()
+    
+    return jsonify({"success": True})
+
+
+@app.route('/api/accounts/<int:account_id>/toggle', methods=['POST'])
+@require_admin
+def toggle_account(account_id):
+    """��换账号状态"""
+    if account_id < 0 or account_id >= len(account_manager.accounts):
+        return jsonify({"error": "账号不存在"}), 404
+    
+    state = account_manager.account_states.get(account_id, {})
+    current = state.get("available", True)
+    state["available"] = not current
+    account_manager.accounts[account_id]["available"] = not current
+    
+    if not current:
+        # 重新启用时清除错误信息
+        account_manager.accounts[account_id].pop("unavailable_reason", None)
+        account_manager.accounts[account_id].pop("unavailable_time", None)
+        state.pop("cooldown_until", None)
+        state.pop("cooldown_reason", None)
+        account_manager.accounts[account_id].pop("cooldown_until", None)
+    
+    account_manager.save_config()
+    return jsonify({"success": True, "available": not current})
+
+
+@app.route('/api/accounts/<int:account_id>/refresh-cookie', methods=['POST'])
+@require_admin
+def refresh_account_cookies(account_id):
+    """刷新账号的secure_c_ses、host_c_oses和csesidx"""
+    if account_id < 0 or account_id >= len(account_manager.accounts):
+        return jsonify({"error": "账号不存在"}), 404
+    
+    data = request.json
+    acc = account_manager.accounts[account_id]
+    
+    # 更新Cookie字段
+    if "secure_c_ses" in data:
+        acc["secure_c_ses"] = data["secure_c_ses"]
+    if "host_c_oses" in data:
+        acc["host_c_oses"] = data["host_c_oses"]
+    if "csesidx" in data and data["csesidx"]:
+        acc["csesidx"] = data["csesidx"]
+    
+    # 清除JWT缓存，强制重新获取
+    state = account_manager.account_states.get(account_id, {})
+    state["jwt"] = None
+    state["jwt_time"] = 0
+    account_manager.account_states[account_id] = state
+    
+    account_manager.config["accounts"] = account_manager.accounts
+    account_manager.save_config()
+    
+    return jsonify({"success": True, "message": "Cookie已刷新"})
+
+
+@app.route('/api/accounts/<int:account_id>/test', methods=['GET'])
+@require_admin
+def test_account(account_id):
+    """测试账号JWT获取"""
+    if account_id < 0 or account_id >= len(account_manager.accounts):
+        return jsonify({"error": "账号不存在"}), 404
+    
+    account = account_manager.accounts[account_id]
+    proxy = account_manager.config.get("proxy")
+    
+    try:
+        jwt = get_jwt_for_account(account, proxy)
+        return jsonify({"success": True, "message": "JWT获取成功"})
+    except AccountRateLimitError as e:
+        pt_wait = seconds_until_next_pt_midnight()
+        cooldown_seconds = max(account_manager.rate_limit_cooldown, pt_wait)
+        account_manager.mark_account_cooldown(account_id, str(e), cooldown_seconds)
+        return jsonify({"success": False, "message": str(e), "cooldown": cooldown_seconds})
+    except AccountAuthError as e:
+        account_manager.mark_account_cooldown(account_id, str(e), account_manager.auth_error_cooldown)
+        return jsonify({"success": False, "message": str(e), "cooldown": account_manager.auth_error_cooldown})
+    except AccountRequestError as e:
+        account_manager.mark_account_cooldown(account_id, str(e), account_manager.generic_error_cooldown)
+        return jsonify({"success": False, "message": str(e), "cooldown": account_manager.generic_error_cooldown})
+    except Exception as e:
+        return jsonify({"success": False, "message": str(e)})
+
+
+@app.route('/api/models', methods=['GET'])
+@require_admin
+def get_models_config():
+    """获取模型配置"""
+    models = account_manager.config.get("models", [])
+    return jsonify({"models": models})
+
+
+@app.route('/api/models', methods=['POST'])
+@require_admin
+def add_model():
+    """添加模型"""
+    data = request.json
+    new_model = {
+        "id": data.get("id", ""),
+        "name": data.get("name", ""),
+        "description": data.get("description", ""),
+        "context_length": data.get("context_length", 32768),
+        "max_tokens": data.get("max_tokens", 8192),
+        "enabled": data.get("enabled", True)
+    }
+    
+    if "models" not in account_manager.config:
+        account_manager.config["models"] = []
+    
+    account_manager.config["models"].append(new_model)
+    account_manager.save_config()
+    
+    return jsonify({"success": True})
+
+
+@app.route('/api/models/<model_id>', methods=['PUT'])
+@require_admin
+def update_model(model_id):
+    """更新模型"""
+    models = account_manager.config.get("models", [])
+    for model in models:
+        if model.get("id") == model_id:
+            data = request.json
+            if "name" in data:
+                model["name"] = data["name"]
+            if "description" in data:
+                model["description"] = data["description"]
+            if "context_length" in data:
+                model["context_length"] = data["context_length"]
+            if "max_tokens" in data:
+                model["max_tokens"] = data["max_tokens"]
+            if "enabled" in data:
+                model["enabled"] = data["enabled"]
+            account_manager.save_config()
+            return jsonify({"success": True})
+    
+    return jsonify({"error": "模型不存在"}), 404
+
+
+@app.route('/api/models/<model_id>', methods=['DELETE'])
+@require_admin
+def delete_model(model_id):
+    """删除模型"""
+    models = account_manager.config.get("models", [])
+    for i, model in enumerate(models):
+        if model.get("id") == model_id:
+            models.pop(i)
+            account_manager.save_config()
+            return jsonify({"success": True})
+    
+    return jsonify({"error": "模型不存在"}), 404
+
+
+@app.route('/api/config', methods=['GET'])
+@require_admin
+def get_config():
+    """获取完整配置"""
+    return jsonify(account_manager.config)
+
+
+@app.route('/api/config', methods=['PUT'])
+@require_admin
+def update_config():
+    """更新配置"""
+    data = request.json or {}
+    if "proxy" in data:
+        account_manager.config["proxy"] = data["proxy"]
+    if "log_level" in data:
+        try:
+            set_log_level(data["log_level"], persist=True)
+        except Exception as e:
+            return jsonify({"error": str(e)}), 400
+    if "image_output_mode" in data:
+        mode = data["image_output_mode"]
+        if isinstance(mode, str) and mode.lower() in ("url", "base64"):
+            account_manager.config["image_output_mode"] = mode.lower()
+    account_manager.save_config()
+    return jsonify({"success": True})
+
+
+@app.route('/api/logging', methods=['GET', 'POST'])
+@require_admin
+def logging_config():
+    """获取或设置日志级别"""
+    if request.method == 'GET':
+        return jsonify({
+            "level": CURRENT_LOG_LEVEL_NAME,
+            "levels": list(LOG_LEVELS.keys())
+        })
+    
+    data = request.json or {}
+    level = data.get("level", "").upper()
+    if level not in LOG_LEVELS:
+        return jsonify({"error": "无效日志级别"}), 400
+    
+    set_log_level(level, persist=True)
+    return jsonify({"success": True, "level": CURRENT_LOG_LEVEL_NAME})
+
+
+@app.route('/api/auth/login', methods=['POST'])
+def admin_login():
+    """后台登录，返回 token。若尚未设置密码，则首次设置。"""
+    data = request.json or {}
+    password = data.get("password", "")
+    if not password:
+        return jsonify({"error": "密码不能为空"}), 400
+    
+    stored_hash = get_admin_password_hash()
+    if stored_hash:
+        if not check_password_hash(stored_hash, password):
+            return jsonify({"error": "密码错误"}), 401
+    else:
+        # 首次设置密码
+        set_admin_password(password)
+    
+    token = create_admin_token()
+    resp = jsonify({"token": token, "level": CURRENT_LOG_LEVEL_NAME})
+    resp.set_cookie(
+        "admin_token",
+        token,
+        max_age=86400,
+        httponly=True,
+        secure=False,
+        samesite="Lax",
+        path="/"
+    )
+    return resp
+
+
+@app.route('/api/tokens', methods=['GET', 'POST'])
+@require_admin
+def manage_tokens():
+    """获取或创建API访问Token"""
+    if request.method == 'GET':
+        return jsonify({"tokens": list(API_TOKENS)})
+    
+    data = request.json or {}
+    token = data.get("token")
+    if not token:
+        token = secrets.token_urlsafe(32)
+    if not isinstance(token, str) or len(token) < 8:
+        return jsonify({"error": "Token格式不合法"}), 400
+    if token in API_TOKENS:
+        return jsonify({"error": "Token已存在"}), 400
+    
+    API_TOKENS.add(token)
+    persist_api_tokens()
+    return jsonify({"success": True, "token": token})
+
+
+@app.route('/api/tokens/<token>', methods=['DELETE'])
+@require_admin
+def delete_token(token):
+    """删除指定API Token"""
+    if token in API_TOKENS:
+        API_TOKENS.remove(token)
+        persist_api_tokens()
+        return jsonify({"success": True})
+    return jsonify({"error": "Token不存在"}), 404
+
+
+@app.route('/api/config/import', methods=['POST'])
+@require_admin
+def import_config():
+    """导入配置"""
+    try:
+        data = request.json
+        account_manager.config = data
+        if data.get("log_level"):
+            try:
+                set_log_level(data.get("log_level"), persist=False)
+            except Exception:
+                pass
+        if data.get("admin_secret_key"):
+            global ADMIN_SECRET_KEY
+            ADMIN_SECRET_KEY = data.get("admin_secret_key")
+        else:
+            get_admin_secret_key()
+        load_api_tokens()
+        account_manager.accounts = data.get("accounts", [])
+        # 重建账号状态
+        account_manager.account_states = {}
+        for i, acc in enumerate(account_manager.accounts):
+            available = acc.get("available", True)
+            account_manager.account_states[i] = {
+                "jwt": None,
+                "jwt_time": 0,
+                "session": None,
+                "available": available,
+                "cooldown_until": acc.get("cooldown_until"),
+                "cooldown_reason": acc.get("unavailable_reason") or acc.get("cooldown_reason") or ""
+            }
+        account_manager.save_config()
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400
+
+
+@app.route('/api/proxy/test', methods=['POST'])
+@require_admin
+def test_proxy():
+    """测试代理"""
+    data = request.json
+    proxy_url = data.get("proxy") or account_manager.config.get("proxy")
+    
+    if not proxy_url:
+        return jsonify({"success": False, "message": "未配置代理地址"})
+    
+    available = check_proxy(proxy_url)
+    return jsonify({
+        "success": available,
+        "message": "代理可用" if available else "代理不可用或连接超时"
+    })
+
+
+@app.route('/api/proxy/status', methods=['GET'])
+@require_admin
+def get_proxy_status():
+    """获取代理状态"""
+    proxy = account_manager.config.get("proxy")
+    if not proxy:
+        return jsonify({"enabled": False, "url": None, "available": False})
+    
+    available = check_proxy(proxy)
+    return jsonify({
+        "enabled": True,
+        "url": proxy,
+        "available": available
+    })
+
+
+@app.route('/api/config/export', methods=['GET'])
+@require_admin
+def export_config():
+    """导出配置"""
+    return jsonify(account_manager.config)
+
+
+def print_startup_info():
+    """打印启动信息"""
+    print("="*60)
+    print("Business Gemini OpenAPI 服务 (多账号轮训版)")
+    print("支持图片输入输出 (OpenAI格式)")
+    print("="*60)
+    
+    # 检测配置文件是否存在，不存在则从 .example 复制初始化
+    example_file = Path(__file__).parent / "business_gemini_session.json.example"
+    if not CONFIG_FILE.exists():
+        if example_file.exists():
+            shutil.copy(example_file, CONFIG_FILE)
+            print(f"\n[初始化] 配置文件不存在，已从 {example_file.name} 复制创建")
+        else:
+            print(f"\n[警告] 配置文件和示例文件都不存在，请创建 {CONFIG_FILE.name}")
+    
+    # 加载配置
+    account_manager.load_config()
+    get_admin_secret_key()
+    
+    # 代理信息
+    proxy = account_manager.config.get("proxy")
+    print(f"\n[代理配置]")
+    print(f"  地址: {proxy or '未配置'}")
+    if proxy:
+        proxy_available = check_proxy(proxy)
+        print(f"  状态: {'✓ 可用' if proxy_available else '✗ 不可用'}")
+    
+    # 图片缓存信息
+    print(f"\n[图片缓存]")
+    print(f"  目录: {IMAGE_CACHE_DIR}")
+    print(f"  缓存时间: {IMAGE_CACHE_HOURS} 小时")
+    
+    # 账号信息
+    total, available = account_manager.get_account_count()
+    print(f"\n[账号配置]")
+    print(f"  总数量: {total}")
+    print(f"  可用数量: {available}")
+    
+    for i, acc in enumerate(account_manager.accounts):
+        state = account_manager.account_states.get(i, {})
+        is_available = account_manager.is_account_available(i)
+        status = "✓" if is_available else "✗"
+        team_id = acc.get("team_id", "未知") + "..."
+        cooldown_until = state.get("cooldown_until")
+        extra = ""
+        if cooldown_until and cooldown_until > time.time():
+            remaining = int(cooldown_until - time.time())
+            extra = f" (冷却中 ~{remaining}s)"
+        print(f"  [{i}] {status} team_id: {team_id}{extra}")
+    
+    # 模型信息
+    models = account_manager.config.get("models", [])
+    print(f"\n[模型配置]")
+    if models:
+        for model in models:
+            print(f"  - {model.get('id')}: {model.get('name', '')}")
+    else:
+        print("  - gemini-enterprise (默认)")
+    
+    print(f"\n[接口列表]")
+    print("  GET  /v1/models           - 获取模型列表")
+    print("  POST /v1/chat/completions - 聊天对话 (支持图片)")
+    print("  GET  /v1/status           - 系统状态")
+    print("  GET  /health              - 健康检查")
+    print("  GET  /image/<filename>    - 获取缓存图片")
+    print("\n" + "="*60)
+    print("启动服务...")
+
+
+if __name__ == '__main__':
+    print_startup_info()
+
+    if not account_manager.accounts:
+        print("[!] 警告: 没有配置任何账号")
+
+    # 支持Hugging Face Spaces的端口配置
+    port = int(os.environ.get("PORT", 8000))
+    host = os.environ.get("HOST", "0.0.0.0")
+
+    app.run(host=host, port=port, debug=False)

hf_manual_deploy.md

@@ -0,0 +1,97 @@
+# Hugging Face 手动部署指南
+
+由于网络连接问题，请按照以下步骤手动部署到 Hugging Face Spaces：
+
+## 方法 1: 通过 Web 界面上传文件（推荐）
+
+1. **访问你的 Space**
+   - 打开浏览器访问: https://huggingface.co/spaces/Maynor996/gg2
+
+2. **上传文件**
+   - 点击页面上的 "Files" 标签
+   - 点击 "Upload file" 按钮
+   - 上传以下文件（从 `/Users/chinamanor/Downloads/cursor编程/gg2/` 目录）：
+     - `app.py`
+     - `gemini.py`
+     - `index.html`
+     - `requirements.txt`（使用 requirements-hf.txt 的内容）
+     - `README.md`（使用 README_hf.md 的内容）
+     - `business_gemini_session.json.example`
+
+3. **文件内容参考**
+   - `requirements.txt` 内容：
+     ```
+     flask>=2.0.0
+     flask-cors>=3.0.0
+     requests>=2.25.0
+     urllib3>=1.26.0
+     ```
+
+   - `README.md` 开头需要添加：
+     ```yaml
+     ---
+     title: Business Gemini Pool
+     emoji: 🚀
+     colorFrom: blue
+     colorTo: green
+     sdk: gradio
+     sdk_version: 4.44.0
+     app_file: app.py
+     pinned: false
+     license: mit
+     ---
+     ```
+
+## 方法 2: 使用 Git 命令（如果网络允许）
+
+```bash
+# 1. 克隆你的 Space
+git clone https://huggingface.co/spaces/Maynor996/gg2
+cd gg2
+
+# 2. 复制文件（从项目目录）
+cp /Users/chinamanor/Downloads/cursor编程/gg2/app.py ./
+cp /Users/chinamanor/Downloads/cursor编程/gg2/gemini.py ./
+cp /Users/chinamanor/Downloads/cursor编程/gg2/index.html ./
+cp /Users/chinamanor/Downloads/cursor编程/gg2/requirements-hf.txt ./requirements.txt
+cp /Users/chinamanor/Downloads/cursor编程/gg2/README_hf.md ./README.md
+cp /Users/chinamanor/Downloads/cursor编程/gg2/business_gemini_session.json.example ./
+
+# 3. 提交并推送
+git add .
+git commit -m "Deploy Business Gemini Pool"
+git push
+```
+
+## 部署后配置
+
+部署成功后：
+
+1. **访问应用**
+   - URL: https://Maynor996-gg2.hf.space
+
+2. **配置 Gemini 账号**
+   - 在 Web 界面点击"账号管理"
+   - 添加你的 Gemini 账号信息：
+     - Team ID
+     - Secure Cookie
+     - Host Cookie
+     - Session Index
+     - User Agent
+
+3. **测试 API**
+   ```bash
+   curl -X POST https://Maynor996-gg2.hf.space/v1/chat/completions \
+     -H "Content-Type: application/json" \
+     -d '{
+       "model": "gemini-enterprise",
+       "messages": [{"role": "user", "content": "Hello!"}]
+     }'
+   ```
+
+## 注意事项
+
+- Hugging Face 会自动构建和部署你的应用
+- 构建过程通常需要 2-5 分钟
+- 可以在 Space 页面查看构建日志
+- 免费的 CPU Space 有一些限制，但足够基本使用

index.html

@@ -0,0 +1,2025 @@
+<!DOCTYPE html>
+<html lang="zh-CN" data-theme="light">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Business Gemini Pool 管理控制台</title>
+    <style>
+        /* [OPTIMIZATION] 1. 全局样式优化与变量调整 */
+        :root {
+            /* 核心颜色保持不变 */
+            --primary: #4285f4;
+            --primary-hover: #3367d6;
+            --primary-light: rgba(66, 133, 244, 0.1);
+            --success: #34a853;
+            --success-light: rgba(52, 168, 83, 0.1);
+            --danger: #ea4335;
+            --danger-light: rgba(234, 67, 53, 0.1);
+            --warning: #fbbc04;
+            --warning-light: rgba(251, 188, 4, 0.1);
+
+            /* [NEW] 引入更精细的变量控制 */
+            --radius-sm: 6px;
+            --radius-md: 12px; /* 增大圆角，更柔和 */
+            --radius-lg: 16px;
+            --transition-ease: all 0.25s cubic-bezier(0.4, 0, 0.2, 1); /* [NEW] 现代化的缓动函数 */
+
+            --font-main: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; /* [NEW] 引入更适合UI的字体 */
+        }
+
+        /* [OPTIMIZATION] 2. Light & Dark Theme 优化，增强对比度和质感 */
+        [data-theme="light"] {
+            --bg-color: #f7f8fc; /* 更柔和的背景色 */
+            --card-bg: #ffffff;
+            --text-main: #1f2328;
+            --text-muted: #656d76;
+            --border: #e4e7eb; /* 更浅的边框色 */
+            --hover-bg: #f2f3f5;
+            --input-bg: #ffffff;
+            --shadow-sm: 0 1px 2px 0 rgba(27, 31, 35, 0.04);
+            --shadow-md: 0 4px 8px 0 rgba(27, 31, 35, 0.06), 0 1px 2px 0 rgba(27, 31, 35, 0.05); /* 更柔和的阴影 */
+            --shadow-lg: 0 10px 20px 0 rgba(27, 31, 35, 0.07), 0 3px 6px 0 rgba(27, 31, 35, 0.05);
+        }
+
+        [data-theme="dark"] {
+            --bg-color: #1a1b1e;
+            --card-bg: #242528;
+            --text-main: #e8eaed;
+            --text-muted: #9aa0a6;
+            --border: #3a3c40;
+            --hover-bg: #303134;
+            --input-bg: #2f3033;
+            --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.1);
+            --shadow-md: 0 4px 8px 0 rgba(0, 0, 0, 0.15), 0 1px 2px 0 rgba(0, 0, 0, 0.1);
+            --shadow-lg: 0 10px 20px 0 rgba(0, 0, 0, 0.2), 0 3px 6px 0 rgba(0, 0, 0, 0.15);
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: var(--font-main);
+            background-color: var(--bg-color);
+            color: var(--text-main);
+            min-height: 100vh;
+            transition: background-color 0.3s, color 0.3s;
+            -webkit-font-smoothing: antialiased;
+            -moz-osx-font-smoothing: grayscale;
+        }
+
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
+            padding: 32px; /* 增加页面内边距 */
+        }
+
+        /* [OPTIMIZATION] 3. Header 重新设计，更简洁大气 */
+        .header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 32px;
+            /* 移除背景和阴影，使其融入页面 */
+        }
+
+        .header-left { display: flex; align-items: center; gap: 16px; }
+
+        .logo {
+            width: 44px;
+            height: 44px;
+            background: linear-gradient(135deg, #4285f4, #34a853, #fbbc04, #ea4335);
+            border-radius: var(--radius-md);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-weight: 600;
+            font-size: 22px;
+            transform: rotate(-10deg); /* [NEW] 增加一点趣味性 */
+            transition: var(--transition-ease);
+        }
+        .logo:hover { transform: rotate(0deg) scale(1.05); }
+
+        .header h1 {
+            font-size: 26px; /* 增大标题字号 */
+            font-weight: 600;
+            color: var(--text-main);
+        }
+
+        .header h1 span {
+            color: var(--text-muted);
+            font-weight: 400;
+            font-size: 16px;
+            margin-left: 10px;
+        }
+
+        .header-right { display: flex; align-items: center; gap: 16px; }
+
+        .status-indicator {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 8px 16px;
+            background: var(--success-light);
+            border: 1px solid rgba(52, 168, 83, 0.2);
+            border-radius: 50px; /* 改为胶囊形状 */
+            font-size: 14px;
+            color: var(--success);
+            font-weight: 500;
+        }
+        .status-indicator::before {
+            content: ''; width: 8px; height: 8px;
+            background: var(--success); border-radius: 50%;
+            animation: pulse 2s infinite;
+        }
+        @keyframes pulse { 0%, 100% { opacity: 1; transform: scale(1); } 50% { opacity: 0.7; transform: scale(0.9); } }
+
+        .theme-toggle {
+            width: 44px; height: 44px; border: 1px solid var(--border);
+            background: var(--card-bg); border-radius: var(--radius-md);
+            cursor: pointer; display: flex; align-items: center; justify-content: center;
+            font-size: 20px; transition: var(--transition-ease);
+        }
+        .theme-toggle:hover { background: var(--hover-bg); border-color: var(--primary); transform: translateY(-2px); }
+
+        /* [OPTIMIZATION] 4. Tabs 重新设计，更现代、更 subtle */
+        .tabs {
+            display: flex;
+            gap: 16px;
+            border-bottom: 1px solid var(--border); /* 底部线条导航 */
+            margin-bottom: 32px;
+        }
+        .tab {
+            padding: 14px 4px; /* 减少水平padding，通过gap控制间距 */
+            border: none; border-bottom: 2px solid transparent;
+            background: transparent; color: var(--text-muted);
+            font-size: 15px; font-weight: 500;
+            cursor: pointer; border-radius: 0;
+            transition: var(--transition-ease);
+            display: flex; align-items: center; justify-content: center;
+            gap: 8px;
+        }
+        .tab:hover { color: var(--primary); }
+        .tab.active { color: var(--primary); border-bottom-color: var(--primary); }
+        .tab-icon { font-size: 20px; }
+
+
+        /* Status Badge */
+        .badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            padding: 6px 12px;
+            border-radius: 20px;
+            font-size: 12px;
+            font-weight: 500;
+        }
+
+        .badge::before {
+            content: '';
+            width: 6px;
+            height: 6px;
+            border-radius: 50%;
+        }
+
+        .badge-success {
+            background: var(--success-light);
+            color: var(--success);
+        }
+
+        .badge-success::before {
+            background: var(--success);
+        }
+
+        .badge-danger {
+            background: var(--danger-light);
+            color: var(--danger);
+        }
+
+        .badge-danger::before {
+            background: var(--danger);
+        }
+
+        .cooldown-hint {
+            display: block;
+            color: var(--text-muted);
+            font-size: 12px;
+            margin-top: 4px;
+        }
+
+        .log-level-control {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            background: var(--card-bg);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-md);
+            padding: 6px 10px;
+        }
+        .log-level-control label {
+            font-size: 12px;
+            color: var(--text-muted);
+        }
+        .log-level-select {
+            border: 1px solid var(--border);
+            background: var(--input-bg);
+            color: var(--text-main);
+            border-radius: var(--radius-sm);
+            padding: 6px 8px;
+        }
+
+        .token-actions {
+            display: flex;
+            gap: 8px;
+            flex-wrap: wrap;
+            margin-bottom: 12px;
+        }
+        .token-input {
+            flex: 1;
+            min-width: 240px;
+        }
+
+        .badge-warning {
+            background: var(--warning-light);
+            color: #b06000;
+        }
+
+        .badge-warning::before {
+            background: var(--warning);
+        }
+        
+        /* [OPTIMIZATION] 5. 动画效果增强 */
+        .tab-content { display: none; }
+        .tab-content.active { display: block; animation: contentFadeIn 0.5s cubic-bezier(0.4, 0, 0.2, 1) forwards; }
+        @keyframes contentFadeIn { from { opacity: 0; transform: translateY(15px); } to { opacity: 1; transform: translateY(0); } }
+
+        /* [OPTIMIZATION] 6. Card 样式优化 */
+        .card {
+            background: var(--card-bg);
+            border-radius: var(--radius-lg);
+            box-shadow: var(--shadow-md);
+            border: 1px solid var(--border);
+            margin-bottom: 32px;
+            overflow: hidden;
+            transition: var(--transition-ease);
+        }
+        .card:hover { border-color: var(--primary-light); box-shadow: var(--shadow-lg); }
+
+        .card-header {
+            display: flex; justify-content: space-between; align-items: center;
+            padding: 20px 24px; border-bottom: 1px solid var(--border);
+        }
+        .card-title {
+            font-size: 18px; font-weight: 600; color: var(--text-main);
+            display: flex; align-items: center; gap: 12px;
+        }
+        .card-title-icon { font-size: 22px; color: var(--text-muted); }
+        .card-body { padding: 24px; }
+
+        /* [OPTIMIZATION] 7. Button 样式优化 */
+        .btn {
+            padding: 10px 20px; border: none; border-radius: var(--radius-md);
+            cursor: pointer; font-size: 14px; font-weight: 500;
+            display: inline-flex; align-items: center; justify-content: center; gap: 8px;
+            transition: var(--transition-ease); text-decoration: none;
+        }
+        .btn:disabled { opacity: 0.5; cursor: not-allowed; }
+        .btn:hover:not(:disabled) { transform: translateY(-2px); box-shadow: var(--shadow-md); }
+        .btn-primary { background: var(--primary); color: white; }
+        .btn-primary:hover:not(:disabled) { background: var(--primary-hover); }
+
+        .btn-outline {
+            background: transparent; color: var(--text-muted);
+            border: 1px solid var(--border);
+        }
+        .btn-outline:hover:not(:disabled) { border-color: var(--text-main); color: var(--text-main); }
+        /* 其他按钮颜色保持 */
+        .btn-success { background: var(--success-light); color: var(--success); border: 1px solid rgba(52, 168, 83, 0.2); }
+        .btn-success:hover:not(:disabled) { background: var(--success); color: white; border-color: var(--success); }
+        .btn-danger { background: var(--danger-light); color: var(--danger); border: 1px solid rgba(234, 67, 53, 0.2); }
+        .btn-danger:hover:not(:disabled) { background: var(--danger); color: white; border-color: var(--danger); }
+        
+        .btn-sm { padding: 6px 14px; font-size: 13px; border-radius: var(--radius-sm); }
+        .btn-icon { width: 32px; height: 32px; padding: 0; border-radius: var(--radius-md); display: inline-flex; align-items: center; justify-content: center; vertical-align: middle; }
+        .btn-warning { background: #fff3cd; color: #856404; border: 1px solid rgba(133, 100, 4, 0.2); }
+        .btn-warning:hover:not(:disabled) { background: #ffc107; color: #212529; border-color: #ffc107; }
+
+        /* [OPTIMIZATION] 8. Table 样式优化，增强可读性 */
+        .table-container { overflow-x: auto; }
+        table { width: 100%; border-collapse: collapse; }
+        th {
+            text-align: left; padding: 16px 24px; font-size: 13px;
+            font-weight: 500; color: var(--text-muted); text-transform: uppercase;
+            letter-spacing: 0.5px; background: transparent; /* 移除背景色 */
+            border-bottom: 2px solid var(--border); /* 加粗底部边框 */
+        }
+        td {
+            padding: 18px 24px; border-bottom: 1px solid var(--border);
+            font-size: 14px; color: var(--text-main);
+            transition: background-color 0.2s;
+        }
+        tr:last-child td { border-bottom: none; }
+        tr:hover td { background: var(--hover-bg); }
+
+        /* [OPTIMIZATION] 9. Form 样式优化 */
+        .form-group { 
+            display: flex;
+            flex-direction: column;
+            margin-bottom: 20px; 
+        }
+        .form-group label,
+        .form-label { 
+            display: block;
+            margin-bottom: 12px; 
+            font-size: 14px; 
+            font-weight: 600; 
+            color: var(--text-main);
+            letter-spacing: 0.2px;
+        }
+        .form-group input, .form-group textarea, .form-group select,
+        .form-input,
+        .form-textarea {
+            width: 100%;
+            padding: 14px 16px; 
+            border-radius: var(--radius-md);
+            border: 1px solid var(--border);
+            background: var(--bg);
+            color: var(--text-main);
+            font-size: 14px;
+            transition: var(--transition-ease);
+            box-sizing: border-box;
+            line-height: 1.5;
+        }
+        .form-textarea {
+            min-height: 90px;
+            resize: vertical;
+            font-family: inherit;
+        }
+        .form-group input:focus, .form-group textarea:focus, .form-group select:focus {
+            outline: none; 
+            border-color: var(--primary);
+            box-shadow: 0 0 0 3px var(--primary-light), 0 1px 2px rgba(0,0,0,0.05) inset;
+        }
+        .form-group input:disabled {
+            background: var(--hover-bg);
+            color: var(--text-muted);
+            cursor: not-allowed;
+        }
+        .form-group small { 
+            display: block;
+            margin-top: 6px; 
+            font-size: 13px; 
+            color: var(--text-muted);
+        }
+        .form-row { 
+            display: grid; 
+            grid-template-columns: 1fr 1fr; 
+            gap: 24px; 
+        }
+        
+        /* Settings Section 样式 */
+        .settings-section {
+            background: var(--bg);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-lg);
+            padding: 28px;
+            margin-bottom: 28px;
+        }
+        .settings-section:last-child {
+            margin-bottom: 0;
+        }
+        .settings-section h3 {
+            font-size: 17px;
+            font-weight: 600;
+            color: var(--text-main);
+            margin-bottom: 24px;
+            padding-bottom: 16px;
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+        }
+        .settings-section .form-group {
+            margin-bottom: 24px;
+        }
+        .settings-section .form-group:last-of-type {
+            margin-bottom: 20px;
+        }
+
+        /* [OPTIMIZATION] 10. Modal 动画与样式优化 */
+        .modal {
+            display: flex; /* 改为flex，便于控制 */
+            align-items: center; justify-content: center;
+            position: fixed; top: 0; left: 0; width: 100%; height: 100%;
+            background: rgba(0, 0, 0, 0.4); backdrop-filter: blur(5px);
+            z-index: 1000; opacity: 0; visibility: hidden;
+            transition: opacity 0.3s, visibility 0.3s;
+        }
+        .modal.show { opacity: 1; visibility: visible; }
+        .modal-content {
+            background: var(--card-bg); border-radius: var(--radius-lg);
+            width: 600px; max-width: 90vw; max-height: 90vh;
+            overflow-y: auto; box-shadow: var(--shadow-lg);
+            transform: translateY(20px) scale(0.98);
+            transition: transform 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+        }
+        .modal.show .modal-content { transform: translateY(0) scale(1); }
+        .modal-header { padding: 24px; border-bottom: 1px solid var(--border); }
+        .modal-header h3 { font-size: 20px; font-weight: 600; display: inline-block; }
+        .modal-close {
+            width: 36px; height: 36px; border: none; background: transparent;
+            color: var(--text-muted); cursor: pointer; border-radius: 50%;
+            display: flex; align-items: center; justify-content: center;
+            font-size: 22px; transition: var(--transition-ease);
+            float: right;
+        }
+        .modal-close:hover { background: var(--hover-bg); color: var(--text-main); transform: rotate(90deg); }
+        .modal-body { padding: 24px; }
+        .modal-footer {
+            display: flex; justify-content: flex-end; gap: 12px;
+            padding: 20px 24px; border-top: 1px solid var(--border);
+            background: var(--hover-bg);
+            border-bottom-left-radius: var(--radius-lg);
+            border-bottom-right-radius: var(--radius-lg);
+        }
+
+
+        /* [OPTIMIZATION] 11. Stats Card 优化 */
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+            gap: 24px;
+            margin-bottom: 32px;
+        }
+        .stat-card {
+            background: var(--card-bg); border: 1px solid var(--border);
+            border-radius: var(--radius-lg); padding: 24px;
+            display: flex; flex-direction: column; /* 垂直布局 */
+            align-items: flex-start; gap: 16px;
+            transition: var(--transition-ease);
+            /* [NEW] 入场动画 */
+            opacity: 0;
+            transform: translateY(20px);
+            animation: fadeIn-up 0.5s ease-out forwards;
+        }
+        /* [NEW] Staggered Animation for Stats Cards */
+        .stat-card:nth-child(1) { animation-delay: 0.1s; }
+        .stat-card:nth-child(2) { animation-delay: 0.2s; }
+        .stat-card:nth-child(3) { animation-delay: 0.3s; }
+        .stat-card:nth-child(4) { animation-delay: 0.4s; }
+
+        @keyframes fadeIn-up {
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+        .stat-card:hover { transform: translateY(-5px); box-shadow: var(--shadow-md); border-color: var(--primary); }
+
+        .stat-info-top { display: flex; justify-content: space-between; align-items: center; width: 100%; }
+        .stat-info-top p { font-size: 14px; font-weight: 500; color: var(--text-muted); }
+        
+        .stat-icon {
+            width: 40px; height: 40px; border-radius: var(--radius-md);
+            display: flex; align-items: center; justify-content: center; font-size: 20px;
+        }
+
+        .stat-info-bottom h3 { font-size: 32px; font-weight: 600; color: var(--text-main); }
+        .stat-icon.blue { background: var(--primary-light); color: var(--primary); }
+        .stat-icon.green { background: var(--success-light); color: var(--success); }
+        .stat-icon.red { background: var(--danger-light); color: var(--danger); }
+        .stat-icon.yellow { background: var(--warning-light); color: #b06000; }
+        
+        /* 其他样式保持或微调 */
+        .badge {
+            padding: 5px 12px; border-radius: 50px;
+            font-size: 12px; font-weight: 500;
+        }
+        .empty-state { text-align: center; padding: 80px 20px; color: var(--text-muted); }
+        .empty-state-icon { font-size: 56px; margin-bottom: 20px; opacity: 0.4; }
+
+        .toast {
+            position: fixed; bottom: 32px; left: 50%;
+            transform: translateX(-50%) translateY(100px);
+            background: var(--card-bg); border: 1px solid var(--border);
+            border-radius: var(--radius-md); padding: 16px 24px;
+            box-shadow: var(--shadow-lg); min-width: 320px;
+            z-index: 2000; opacity: 0; visibility: hidden;
+            transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+            display: flex; align-items: center; gap: 12px;
+        }
+        .toast.show { transform: translateX(-50%) translateY(0); opacity: 1; visibility: visible; }
+        
+        /* [NEW] SVG Icon Styles */
+        .icon {
+            width: 1em;
+            height: 1em;
+            stroke-width: 2;
+            fill: none;
+            stroke: currentColor;
+            stroke-linecap: round;
+            stroke-linejoin: round;
+        }
+
+        /* Responsive */
+        @media (max-width: 768px) {
+            .container { padding: 24px 16px; }
+            .header { flex-direction: column; gap: 24px; text-align: center; }
+            .tabs {
+                gap: 8px;
+                /* [NEW] 允许在移动端横向滚动 */
+                overflow-x: auto;
+                white-space: nowrap;
+                -ms-overflow-style: none; /* IE and Edge */
+                scrollbar-width: none; /* Firefox */
+            }
+            .tabs::-webkit-scrollbar { display: none; } /* Chrome, Safari, and Opera */
+            .tab { flex-shrink: 0; }
+            .form-row { grid-template-columns: 1fr; }
+            .stats-grid { gap: 16px; }
+        }
+    </style>
+</head>
+<body>
+    <!-- [NEW] SVG Icon Definitions -->
+    <svg width="0" height="0" style="display: none;">
+        <symbol id="icon-users" viewBox="0 0 24 24"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"></path><circle cx="9" cy="7" r="4"></circle><path d="M23 21v-2a4 4 0 0 0-3-3.87"></path><path d="M16 3.13a4 4 0 0 1 0 7.75"></path></symbol>
+        <symbol id="icon-robot" viewBox="0 0 24 24"><path d="M12 8V4H8"></path><rect x="4" y="12" width="16" height="8" rx="2"></rect><path d="M2 12h20"></path><path d="M12 12V8a4 4 0 0 0-4-4"></path></symbol>
+        <symbol id="icon-settings" viewBox="0 0 24 24"><path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 0 2l-.15.08a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l-.22-.38a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1 0-2l.15-.08a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"></path><circle cx="12" cy="12" r="3"></circle></symbol>
+        <symbol id="icon-server" viewBox="0 0 24 24"><rect x="2" y="2" width="20" height="8" rx="2" ry="2"></rect><rect x="2" y="14" width="20" height="8" rx="2" ry="2"></rect><line x1="6" y1="6" x2="6.01" y2="6"></line><line x1="6" y1="18" x2="6.01" y2="18"></line></symbol>
+        <symbol id="icon-list" viewBox="0 0 24 24"><line x1="8" y1="6" x2="21" y2="6"></line><line x1="8" y1="12" x2="21" y2="12"></line><line x1="8" y1="18" x2="21" y2="18"></line><line x1="3" y1="6" x2="3.01" y2="6"></line><line x1="3" y1="12" x2="3.01" y2="12"></line><line x1="3" y1="18" x2="3.01" y2="18"></line></symbol>
+        <symbol id="icon-plus" viewBox="0 0 24 24"><line x1="12" y1="5" x2="12" y2="19"></line><line x1="5" y1="12" x2="19" y2="12"></line></symbol>
+        <symbol id="icon-check" viewBox="0 0 24 24"><polyline points="20 6 9 17 4 12"></polyline></symbol>
+        <symbol id="icon-x" viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></symbol>
+        <symbol id="icon-refresh" viewBox="0 0 24 24"><polyline points="23 4 23 10 17 10"></polyline><path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"></path></symbol>
+        <symbol id="icon-sun" viewBox="0 0 24 24"><circle cx="12" cy="12" r="5"></circle><line x1="12" y1="1" x2="12" y2="3"></line><line x1="12" y1="21" x2="12" y2="23"></line><line x1="4.22" y1="4.22" x2="5.64" y2="5.64"></line><line x1="18.36" y1="18.36" x2="19.78" y2="19.78"></line><line x1="1" y1="12" x2="3" y2="12"></line><line x1="21" y1="12" x2="23" y2="12"></line><line x1="4.22" y1="19.78" x2="5.64" y2="18.36"></line><line x1="18.36" y1="5.64" x2="19.78" y2="4.22"></line></symbol>
+        <symbol id="icon-moon" viewBox="0 0 24 24"><path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z"></path></symbol>
+        <symbol id="icon-message" viewBox="0 0 24 24"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path></symbol>
+        <symbol id="icon-play" viewBox="0 0 24 24"><polygon points="5 3 19 12 5 21 5 3"></polygon></symbol>
+        <symbol id="icon-pause" viewBox="0 0 24 24"><rect x="6" y="4" width="4" height="16"></rect><rect x="14" y="4" width="4" height="16"></rect></symbol>
+        <symbol id="icon-zap" viewBox="0 0 24 24"><polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"></polygon></symbol>
+        <symbol id="icon-key" viewBox="0 0 24 24"><path d="M21 2l-2 2"></path><path d="M9 6l-2 2"></path><circle cx="7.5" cy="15.5" r="5.5"></circle><path d="M21 2l-9.6 9.6"></path><path d="M15.5 7.5l3 3"></path><path d="M16 13l-3-3"></path></symbol>
+    </svg>
+
+    <div class="container">
+        <!-- Header -->
+        <header class="header">
+            <div class="header-left">
+                <div class="logo">G</div>
+                <h1>Business Gemini Pool <span>管理控制台</span></h1>
+            </div>
+            <div class="header-right">
+                <div class="status-indicator" id="serviceStatus">服务运行中</div>
+                <div class="log-level-control">
+                    <label for="logLevelSelect">日志</label>
+                    <select id="logLevelSelect" class="log-level-select" onchange="updateLogLevel(this.value)">
+                        <option value="DEBUG">DEBUG</option>
+                        <option value="INFO" selected>INFO</option>
+                        <option value="ERROR">ERROR</option>
+                    </select>
+                </div>
+                <button class="btn btn-outline" id="loginButton" style="padding: 8px 12px;" onclick="showLoginModal()">登录</button>
+                <a href="chat_history.html" class="btn btn-primary" style="padding: 8px 16px; font-size: 14px; text-decoration: none; display: flex; align-items: center; gap: 6px;" title="进入在线对话">
+                    <svg class="icon" style="width: 16px; height: 16px;"><use xlink:href="#icon-message"></use></svg>
+                    在线对话
+                </a>
+                <button class="theme-toggle" onclick="toggleTheme()" title="切换主题">
+                    <span id="themeIconContainer">
+                        <svg class="icon"><use xlink:href="#icon-sun"></use></svg>
+                    </span>
+                </button>
+            </div>
+        </header>
+
+        <!-- Tabs -->
+        <div class="tabs">
+            <button class="tab active" onclick="switchTab('accounts')">
+                <svg class="icon tab-icon"><use xlink:href="#icon-users"></use></svg>
+                账号管理
+            </button>
+            <button class="tab" onclick="switchTab('models')">
+                <svg class="icon tab-icon"><use xlink:href="#icon-robot"></use></svg>
+                模型管理
+            </button>
+            <button class="tab" onclick="switchTab('settings')">
+                <svg class="icon tab-icon"><use xlink:href="#icon-settings"></use></svg>
+                系统设置
+            </button>
+            <button class="tab" onclick="switchTab('tokens')">
+                <svg class="icon tab-icon"><use xlink:href="#icon-key"></use></svg>
+                Token 管理
+            </button>
+        </div>
+
+        <!-- 账号管理 -->
+        <div id="accounts" class="tab-content active">
+            <!-- Stats -->
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <div class="stat-info-top">
+                        <p>总账号数</p>
+                        <div class="stat-icon blue"><svg class="icon"><use xlink:href="#icon-users"></use></svg></div>
+                    </div>
+                    <div class="stat-info-bottom">
+                        <h3 id="totalAccounts">0</h3>
+                    </div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-info-top">
+                        <p>可用账号</p>
+                        <div class="stat-icon green"><svg class="icon"><use xlink:href="#icon-check"></use></svg></div>
+                    </div>
+                    <div class="stat-info-bottom">
+                        <h3 id="availableAccounts">0</h3>
+                    </div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-info-top">
+                        <p>不可用账号</p>
+                        <div class="stat-icon red"><svg class="icon"><use xlink:href="#icon-x"></use></svg></div>
+                    </div>
+                    <div class="stat-info-bottom">
+                        <h3 id="unavailableAccounts">0</h3>
+                    </div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-info-top">
+                        <p>当前轮训索引</p>
+                        <div class="stat-icon yellow"><svg class="icon"><use xlink:href="#icon-refresh"></use></svg></div>
+                    </div>
+                    <div class="stat-info-bottom">
+                        <h3 id="currentIndex">0</h3>
+                    </div>
+                </div>
+            </div>
+
+            <div class="card">
+                <div class="card-header">
+                    <div class="card-title">
+                        <svg class="icon card-title-icon"><use xlink:href="#icon-list"></use></svg>
+                        账号列表
+                    </div>
+                    <button class="btn btn-primary" onclick="showAddAccountModal()">
+                        <svg class="icon"><use xlink:href="#icon-plus"></use></svg>
+                        添加账号
+                    </button>
+                </div>
+                <div class="table-container">
+                    <table id="accountsTable">
+                        <thead>
+                            <tr>
+                                <th>序号</th>
+                                <th>Team ID</th>
+                                <th>csesidx</th>
+                                <th>User Agent</th>
+                                <th>状态</th>
+                                <th>操作</th>
+                            </tr>
+                        </thead>
+                        <tbody id="accountsTableBody"></tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+
+        <!-- 模型管理 (HTML结构类似，图标已替换) -->
+        <div id="models" class="tab-content">
+            <div class="card">
+                <div class="card-header">
+                    <div class="card-title">
+                        <svg class="icon card-title-icon"><use xlink:href="#icon-robot"></use></svg>
+                        模型列表
+                    </div>
+                    <button class="btn btn-primary" onclick="showAddModelModal()">
+                        <svg class="icon"><use xlink:href="#icon-plus"></use></svg>
+                        添加模型
+                    </button>
+                </div>
+                <div class="table-container">
+                    <table id="modelsTable">
+                        <thead>
+                            <tr>
+                                <th>模型ID</th>
+                                <th>名称</th>
+                                <th>描述</th>
+                                <th>上下文长度</th>
+                                <th>最大Token</th>
+                                <th>状态</th>
+                                <th>操作</th>
+                            </tr>
+                        </thead>
+                        <tbody id="modelsTableBody"></tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+
+        <!-- 系统设置 (HTML结构类似，图标已替换) -->
+        <div id="settings" class="tab-content">
+            <div class="card">
+                <div class="card-header">
+                    <div class="card-title">
+                         <svg class="icon card-title-icon"><use xlink:href="#icon-settings"></use></svg>
+                        系统配置
+                    </div>
+                </div>
+                <div class="card-body">
+                    <form id="settingsForm">
+                        <div class="settings-section">
+                            <h3>代理设置</h3>
+                            <div class="form-group">
+                                <label class="form-label" for="proxyUrl">代理地址</label>
+                                <input type="text" class="form-input" id="proxyUrl" placeholder="http://127.0.0.1:7890">
+                                <small>用于访问Google API的代理服务器地址</small>
+                                <div class="proxy-status" id="proxyStatus"></div>
+                            </div>
+                            <div class="form-group">
+                                <label class="form-label" for="imageOutputMode">图片输出模式</label>
+                                <select class="form-input" id="imageOutputMode">
+                                    <option value="url">图片URL（默认）</option>
+                                    <option value="base64">Base64 Data URL</option>
+                                </select>
+                                <small>控制聊天接口返回的图片是以URL形式还是以 data:image/...;base64,... 形式输出</small>
+                            </div>
+                            <div style="display: flex; gap: 12px;">
+                                <button type="button" class="btn btn-outline" onclick="testProxy()">
+                                    测试代理
+                                </button>
+                                <button type="button" class="btn btn-primary" onclick="saveSettings()">
+                                    保存设置
+                                </button>
+                            </div>
+                        </div>
+
+                        <div class="settings-section">
+                            <h3><svg class="icon" style="width: 1em; height: 1em; vertical-align: -2px; margin-right: 8px;"><use xlink:href="#icon-server"></use></svg>服务信息</h3>
+                            <div class="form-row">
+                                <div class="form-group">
+                                    <label class="form-label">服务端口</label>
+                                    <input type="text" class="form-input" value="8000" disabled>
+                                </div>
+                                <div class="form-group">
+                                    <label class="form-label">API地址</label>
+                                    <input type="text" class="form-input" value="http://localhost:8000/v1" disabled>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="settings-section">
+                            <h3>配置文件</h3>
+                             <div class="form-group">
+                                <label class="form-label" for="configJson">当前配置 (JSON)</label>
+                                <textarea class="form-textarea" id="configJson" rows="15" readonly></textarea>
+                                <small>配置文件路径: business_gemini_session.json</small>
+                            </div>
+                             <div style="display: flex; gap: 12px; flex-wrap: wrap;">
+                                <button type="button" class="btn btn-outline" onclick="refreshConfig()">
+                                    刷新配置
+                                </button>
+                                <button type="button" class="btn btn-outline" onclick="downloadConfig()">
+                                    下载配置
+                                </button>
+                                <button type="button" class="btn btn-primary" onclick="uploadConfig()">
+                                    导入配置
+                                </button>
+                                <input type="file" id="configFileInput" accept=".json" style="display: none;" onchange="handleConfigUpload(event)">
+                            </div>
+                        </div>
+                    </form>
+                </div>
+            </div>
+        </div>
+
+        <!-- Token 管理 -->
+        <div id="tokens" class="tab-content">
+            <div class="card">
+                <div class="card-header" style="display:flex; justify-content:space-between; align-items:center;">
+                    <div class="card-title" style="display:flex; align-items:center; gap:8px;">
+                        <svg class="icon card-title-icon"><use xlink:href="#icon-key"></use></svg>
+                        Token 管理
+                    </div>
+                    <div class="token-actions">
+                        <input id="manualToken" class="form-input token-input" placeholder="手动输入 Token（留空自动生成）">
+                        <button class="btn btn-outline" type="button" onclick="generateToken()">生成 Token</button>
+                        <button class="btn btn-primary" type="button" onclick="addToken()">添加 Token</button>
+                    </div>
+                </div>
+                <table class="table">
+                    <thead>
+                        <tr>
+                            <th style="width:70%;">Token</th>
+                            <th>操作</th>
+                        </tr>
+                    </thead>
+                    <tbody id="tokensTableBody">
+                        <tr><td colspan="2" class="empty-state">加载中...</td></tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+
+    <!-- 模态框 (已优化关闭按钮) -->
+    <div class="modal" id="addAccountModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3>添加账号</h3>
+                <button class="modal-close" onclick="closeModal('addAccountModal')" title="关闭">&times;</button>
+            </div>
+            <!-- Modal Body and Footer ... (No functional changes needed) -->
+            <div class="modal-body">
+                <div class="form-group">
+                    <label class="form-label" for="newAccountJson">粘贴账号JSON（可直接复制工具输出）</label>
+                    <textarea class="form-textarea" id="newAccountJson" placeholder='{"team_id":"...","secure_c_ses":"...","host_c_oses":"...","csesidx":"...","user_agent":"..."}' rows="4"></textarea>
+                    <div style="display:flex; gap:8px; margin-top:8px;">
+                        <button class="btn btn-outline btn-sm" type="button" onclick="parseAccountJson()">解析填充</button>
+                        <button class="btn btn-outline btn-sm" type="button" onclick="pasteAccountJson()">从剪贴板读取并填充</button>
+                    </div>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="newTeamId">Team ID</label>
+                    <input type="text" class="form-input" id="newTeamId" placeholder="输入Team ID">
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="newSecureCses">Cookie中的__Secure-C_SES</label>
+                    <textarea class="form-textarea" id="newSecureCses" placeholder="输入Cookie中的__Secure-C_SES" rows="3"></textarea>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="newHostCoses">Cookie中的__Host-C_OSES</label>
+                    <textarea class="form-textarea" id="newHostCoses" placeholder="输入Cookie中的__Host-C_OSES" rows="3"></textarea>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="newCsesidx">CSESIDX</label>
+                    <input type="text" class="form-input" id="newCsesidx" placeholder="输入CSESIDX">
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="newUserAgent">User Agent</label>
+                    <input type="text" class="form-input" id="newUserAgent" placeholder="输入User Agent">
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button class="btn btn-outline" onclick="closeModal('addAccountModal')">取消</button>
+                <button class="btn btn-primary" onclick="saveNewAccount()">保存</button>
+            </div>
+        </div>
+    </div>
+    <!-- 编辑账号模态框 -->
+    <div class="modal" id="editAccountModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3>编辑账号</h3>
+                <button class="modal-close" onclick="closeModal('editAccountModal')" title="关闭">&times;</button>
+            </div>
+            <div class="modal-body">
+                <input type="hidden" id="editAccountId">
+                <div class="form-group">
+                    <label class="form-label" for="editTeamId">Team ID</label>
+                    <input type="text" class="form-input" id="editTeamId" placeholder="输入Team ID">
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="editSecureCses">Cookie中的__Secure-C_SES</label>
+                    <textarea class="form-textarea" id="editSecureCses" placeholder="输入Secure C Ses" rows="3"></textarea>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="editHostCoses">Cookie中的__Host-C_OSES</label>
+                    <textarea class="form-textarea" id="editHostCoses" placeholder="输入Host C Oses" rows="3"></textarea>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="editCsesidx">CSESIDX</label>
+                    <input type="text" class="form-input" id="editCsesidx" placeholder="输入CSESIDX">
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="editUserAgent">User Agent</label>
+                    <input type="text" class="form-input" id="editUserAgent" placeholder="输入User Agent">
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button class="btn btn-outline" onclick="closeModal('editAccountModal')">取消</button>
+                <button class="btn btn-primary" onclick="updateAccount()">保存</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 刷新Cookie模态框 -->
+    <div class="modal" id="refreshCookieModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3>刷新账号Cookie</h3>
+                <button class="modal-close" onclick="closeModal('refreshCookieModal')" title="关闭">&times;</button>
+            </div>
+            <div class="modal-body">
+                <input type="hidden" id="refreshAccountId">
+                <p class="text-muted" style="margin-bottom: 16px;">请输入新的Cookie值来刷新账号认证信息。刷新后将清除JWT缓存。</p>
+                <div class="form-group">
+                    <label class="form-label" for="refreshSecureCses">Cookie中的__Secure-C_SES <span style="color: var(--danger);">*</span></label>
+                    <textarea class="form-textarea" id="refreshSecureCses" placeholder="输入新的__Secure-C_SES值" rows="3"></textarea>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="refreshHostCoses">Cookie中的__Host-C_OSES <span style="color: var(--danger);">*</span></label>
+                    <textarea class="form-textarea" id="refreshHostCoses" placeholder="输入新的__Host-C_OSES值" rows="3"></textarea>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="refreshCsesidx">CSESIDX (可选)</label>
+                    <input type="text" class="form-input" id="refreshCsesidx" placeholder="输入CSESIDX值">
+                </div>
+                <div class="form-group">
+                    <label class="form-label">从JSON粘贴 (可选)</label>
+                    <textarea class="form-textarea" id="refreshCookieJson" placeholder="粘贴Cookie JSON数据" rows="3"></textarea>
+                    <div style="display:flex; gap:8px; margin-top:8px;">
+                        <button class="btn btn-outline btn-sm" type="button" onclick="parseRefreshCookieJson()">解析填充</button>
+                        <button class="btn btn-outline btn-sm" type="button" onclick="pasteRefreshCookieJson()">📋 粘贴并解析</button>
+                    </div>
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button class="btn btn-outline" onclick="closeModal('refreshCookieModal')">取消</button>
+                <button class="btn btn-primary" onclick="refreshAccountCookie()">刷新Cookie</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 添加模型模态框 -->
+    <div class="modal" id="addModelModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3>添加模型</h3>
+                <button class="modal-close" onclick="closeModal('addModelModal')" title="关闭">&times;</button>
+            </div>
+            <div class="modal-body">
+                <div class="form-row">
+                    <div class="form-group">
+                        <label class="form-label" for="newModelId">模型ID</label>
+                        <input type="text" class="form-input" id="newModelId" placeholder="如: gemini-pro">
+                    </div>
+                    <div class="form-group">
+                        <label class="form-label" for="newModelName">模型名称</label>
+                        <input type="text" class="form-input" id="newModelName" placeholder="如: Gemini Pro">
+                    </div>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="newModelDesc">描述</label>
+                    <input type="text" class="form-input" id="newModelDesc" placeholder="模型描述">
+                </div>
+                <div class="form-row">
+                    <div class="form-group">
+                        <label class="form-label" for="newContextLength">上下文长度</label>
+                        <input type="number" class="form-input" id="newContextLength" value="32768">
+                    </div>
+                    <div class="form-group">
+                        <label class="form-label" for="newMaxTokens">最大Token</label>
+                        <input type="number" class="form-input" id="newMaxTokens" value="8192">
+                    </div>
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button class="btn btn-outline" onclick="closeModal('addModelModal')">取消</button>
+                <button class="btn btn-primary" onclick="saveNewModel()">保存</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 登录模态框 -->
+    <div class="modal" id="loginModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3>管理员登录</h3>
+                <button class="modal-close" onclick="closeModal('loginModal')" title="关闭">&times;</button>
+            </div>
+            <div class="modal-body">
+                <div class="form-group">
+                    <label class="form-label" for="loginPassword">后台密码</label>
+                    <input type="password" class="form-input" id="loginPassword" placeholder="输入后台密码">
+                </div>
+                <p class="text-muted" style="font-size: 12px;">首次登录将设置当前密码为后台密码。</p>
+            </div>
+            <div class="modal-footer">
+                <button class="btn btn-outline" onclick="closeModal('loginModal')">取消</button>
+                <button class="btn btn-primary" onclick="submitLogin()">登录</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 编辑模型模态框 -->
+    <div class="modal" id="editModelModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3>编辑模型</h3>
+                <button class="modal-close" onclick="closeModal('editModelModal')" title="关闭">&times;</button>
+            </div>
+            <div class="modal-body">
+                <input type="hidden" id="editModelOriginalId">
+                <div class="form-row">
+                    <div class="form-group">
+                        <label class="form-label" for="editModelId">模型ID</label>
+                        <input type="text" class="form-input" id="editModelId" placeholder="如: gemini-pro" readonly style="background-color: var(--bg-tertiary); cursor: not-allowed;">
+                    </div>
+                    <div class="form-group">
+                        <label class="form-label" for="editModelName">模型名称</label>
+                        <input type="text" class="form-input" id="editModelName" placeholder="如: Gemini Pro">
+                    </div>
+                </div>
+                <div class="form-group">
+                    <label class="form-label" for="editModelDesc">描述</label>
+                    <input type="text" class="form-input" id="editModelDesc" placeholder="模型描述">
+                </div>
+                <div class="form-row">
+                    <div class="form-group">
+                        <label class="form-label" for="editContextLength">上下文长度</label>
+                        <input type="number" class="form-input" id="editContextLength">
+                    </div>
+                    <div class="form-group">
+                        <label class="form-label" for="editMaxTokens">最大Token</label>
+                        <input type="number" class="form-input" id="editMaxTokens">
+                    </div>
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button class="btn btn-outline" onclick="closeModal('editModelModal')">取消</button>
+                <button class="btn btn-primary" onclick="updateModel()">保存</button>
+            </div>
+        </div>
+    </div>
+
+
+    <!-- Toast通知 -->
+    <div id="toastContainer" class="toast-container">
+        <!-- Toasts will be injected here by JS -->
+    </div>
+    <div class="toast" id="toast"></div>
+
+    <script>
+        // [OPTIMIZATION] 1. 脚本微调以适应新的图标
+        function updateThemeIcon(theme) {
+            const iconContainer = document.getElementById('themeIconContainer');
+            if (iconContainer) {
+                const iconId = theme === 'dark' ? 'icon-sun' : 'icon-moon';
+                iconContainer.innerHTML = `<svg class="icon"><use xlink:href="#${iconId}"></use></svg>`;
+            }
+        }
+
+        // [OPTIMIZATION] 2. 改进Toast通知
+        let toastTimeout;
+        function showToast(message, type = 'info') {
+            const toast = document.getElementById('toast');
+            if (!toast) return;
+
+            let icon = '';
+            let borderType = type; // 'success', 'error', 'info'
+            switch(type) {
+                case 'success':
+                    icon = '<svg class="icon" style="color: var(--success);"><use xlink:href="#icon-check"></use></svg>';
+                    break;
+                case 'error':
+                    icon = '<svg class="icon" style="color: var(--danger);"><use xlink:href="#icon-x"></use></svg>';
+                    break;
+                default:
+                    icon = '<svg class="icon" style="color: var(--primary);"><use xlink:href="#icon-server"></use></svg>';
+                    borderType = 'primary';
+                    break;
+            }
+
+            toast.innerHTML = `${icon} <span class="toast-message">${message}</span>`;
+            toast.className = `toast show`;
+            toast.style.borderLeft = `4px solid var(--${borderType})`;
+
+            clearTimeout(toastTimeout);
+            toastTimeout = setTimeout(() => {
+                toast.classList.remove('show');
+            }, 3500);
+        }
+
+        // =======================================================
+        // [FULL SCRIPT] 以下是完整的、未删减的功能性 JavaScript 代码
+        // =======================================================
+
+        // API 基础 URL
+        const API_BASE = '.';
+
+        // 全局数据缓存
+        let accountsData = [];
+        let modelsData = [];
+        let configData = {};
+        let currentEditAccountId = null;
+        let currentEditModelId = null;
+        const ADMIN_TOKEN_KEY = 'admin_token';
+        let tokensData = [];
+
+        // --- 初始化 ---
+        document.addEventListener('DOMContentLoaded', () => {
+            initTheme();
+            loadAllData();
+            setInterval(checkServerStatus, 30000); // 每30秒检查一次服务状态
+            updateLoginButton();
+        });
+
+        // --- 核心加载与渲染 ---
+        async function loadAllData() {
+            await Promise.all([
+                loadAccounts(),
+                loadModels(),
+                loadConfig(),
+                checkServerStatus(),
+                loadLogLevel(),
+                loadTokens()
+            ]);
+        }
+
+        function getAuthHeaders() {
+            const token = localStorage.getItem(ADMIN_TOKEN_KEY);
+            return token ? { 'X-Admin-Token': token } : {};
+        }
+
+        function updateLoginButton() {
+            const token = localStorage.getItem(ADMIN_TOKEN_KEY);
+            const btn = document.getElementById('loginButton');
+            if (!btn) return;
+            if (token) {
+                btn.textContent = '注销';
+                btn.disabled = false;
+                btn.classList.remove('btn-disabled');
+                btn.title = '注销登录';
+                btn.onclick = logoutAdmin;
+            } else {
+                btn.textContent = '登录';
+                btn.disabled = false;
+                btn.classList.remove('btn-disabled');
+                btn.title = '管理员登录';
+                btn.onclick = showLoginModal;
+            }
+        }
+
+        async function apiFetch(url, options = {}) {
+            const headers = Object.assign({}, options.headers || {}, getAuthHeaders());
+            const res = await fetch(url, { ...options, headers });
+            if (res.status === 401 || res.status === 403) {
+                showLoginModal();
+                updateLoginButton();
+                throw new Error('需要登录');
+            }
+            return res;
+        }
+
+        // --- 主题控制 ---
+        function initTheme() {
+            const savedTheme = localStorage.getItem('theme') || 'light';
+            document.documentElement.setAttribute('data-theme', savedTheme);
+            updateThemeIcon(savedTheme);
+        }
+
+        function toggleTheme() {
+            const current = document.documentElement.getAttribute('data-theme');
+            const newTheme = current === 'dark' ? 'light' : 'dark';
+            document.documentElement.setAttribute('data-theme', newTheme);
+            localStorage.setItem('theme', newTheme);
+            updateThemeIcon(newTheme);
+        }
+
+        // --- 标签页控制 ---
+        function switchTab(tabName) {
+            document.querySelectorAll('.tab').forEach(btn => btn.classList.remove('active'));
+            document.querySelectorAll('.tab-content').forEach(content => content.classList.remove('active'));
+            
+            const tabBtn = document.querySelector(`[onclick="switchTab('${tabName}')"]`);
+            const tabContent = document.getElementById(tabName);
+            
+            if (tabBtn) tabBtn.classList.add('active');
+            if (tabContent) tabContent.classList.add('active');
+        }
+
+        // --- 状态检查 ---
+        async function checkServerStatus() {
+            const indicator = document.getElementById('serviceStatus');
+            if (!indicator) return;
+            try {
+                const res = await apiFetch(`${API_BASE}/api/status`);
+                console.log('Server Status Response:', res);
+            if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);
+            const data = await res.json();
+            indicator.textContent = '服务运行中';
+            indicator.classList.remove('offline');
+            indicator.title = '服务连接正常 - ' + new Date().toLocaleString();
+            } catch (e) {
+                indicator.textContent = '服务离线';
+                indicator.classList.add('offline');
+                indicator.title = '无法连接到后端服务';
+            }
+        }
+
+        // --- 账号管理 (Accounts) ---
+        async function loadAccounts() {
+            try {
+                const res = await apiFetch(`${API_BASE}/api/accounts`);
+                const data = await res.json();
+                accountsData = data.accounts || [];
+                document.getElementById('currentIndex').textContent = data.current_index || 0;
+                renderAccounts();
+                updateAccountStats();
+            } catch (e) {
+                showToast('加载账号列表失败: ' + e.message, 'error');
+            }
+        }
+
+        function renderAccounts() {
+            const tbody = document.getElementById('accountsTableBody');
+            if (!tbody) return;
+
+            if (accountsData.length === 0) {
+                tbody.innerHTML = `<tr><td colspan="6" class="empty-state">
+                    <div class="empty-state-icon"><svg class="icon"><use xlink:href="#icon-users"></use></svg></div>
+                    <h3>暂无账号</h3><p>点击 "添加账号" 按钮来创建一个。</p>
+                </td></tr>`;
+                return;
+            }
+
+            tbody.innerHTML = accountsData.map((acc, index) => `
+                <tr>
+                    <td>${index + 1}</td>
+                    <td><code>${acc.team_id || '-'}</code></td>
+                    <td><code>${acc.csesidx || '-'}</code></td>
+                    <td title="${acc.user_agent}">${acc.user_agent ? acc.user_agent.substring(0, 30) + '...' : '-'}</td>
+                    <td>
+                        <span class="badge ${acc.available ? 'badge-success' : 'badge-danger'}">${acc.available ? '可用' : '不可用'}</span>
+                        ${renderNextRefresh(acc)}
+                    </td>
+                    <td style="white-space: nowrap;">
+                        <button class="btn btn-sm ${acc.enabled !== false ? 'btn-warning' : 'btn-success'} btn-icon" onclick="toggleAccount(${acc.id})" title="${acc.enabled !== false ? '停用' : '启用'}"><svg class="icon" style="width:16px; height:16px;"><use xlink:href="#icon-${acc.enabled !== false ? 'pause' : 'play'}"></use></svg></button>
+                        <button class="btn btn-sm btn-outline btn-icon" onclick="testAccount(${acc.id})" title="测试连接"><svg class="icon" style="width:16px; height:16px;"><use xlink:href="#icon-zap"></use></svg></button>
+                        <button class="btn btn-sm btn-outline btn-icon" onclick="showRefreshCookieModal(${acc.id})" title="刷新Cookie"><svg class="icon" style="width:16px; height:16px;"><use xlink:href="#icon-refresh"></use></svg></button>
+                        <button class="btn btn-sm btn-outline btn-icon" onclick="showEditAccountModal(${acc.id})" title="编辑"><svg class="icon" style="width:16px; height:16px;"><use xlink:href="#icon-settings"></use></svg></button>
+                        <button class="btn btn-sm btn-danger btn-icon" onclick="deleteAccount(${acc.id})" title="删除"><svg class="icon" style="width:16px; height:16px;"><use xlink:href="#icon-x"></use></svg></button>
+                    </td>
+                </tr>
+            `).join('');
+        }
+
+        function updateAccountStats() {
+            document.getElementById('totalAccounts').textContent = accountsData.length;
+            document.getElementById('availableAccounts').textContent = accountsData.filter(a => a.available).length;
+            document.getElementById('unavailableAccounts').textContent = accountsData.length - accountsData.filter(a => a.available).length;
+        }
+
+        function renderNextRefresh(acc) {
+            if (!acc || !acc.cooldown_until) return '';
+            const now = Date.now();
+            const ts = acc.cooldown_until * 1000;
+            if (ts <= now) return '';
+            const next = new Date(ts);
+            const remaining = Math.max(0, ts - now);
+            const minutes = Math.floor(remaining / 60000);
+            const label = minutes >= 60
+                ? `${Math.floor(minutes / 60)}小时${minutes % 60}分`
+                : `${minutes}分`;
+            return `<span class="cooldown-hint">下次恢复: ${next.toLocaleString()}（约${label}）</span>`;
+        }
+
+        function showAddAccountModal() {
+            // 清空表单字段
+            document.getElementById('newAccountJson').value = '';
+            document.getElementById('newTeamId').value = '';
+            document.getElementById('newSecureCses').value = '';
+            document.getElementById('newHostCoses').value = '';
+            document.getElementById('newCsesidx').value = '';
+            document.getElementById('newUserAgent').value = '';
+            openModal('addAccountModal');
+        }
+
+        function showEditAccountModal(id) {
+            const acc = accountsData.find(a => a.id === id);
+            if (!acc) return;
+            
+            document.getElementById('editAccountId').value = id;
+            document.getElementById('editTeamId').value = acc.team_id || '';
+            document.getElementById('editSecureCses').value = acc.secure_c_ses || '';
+            document.getElementById('editHostCoses').value = acc.host_c_oses || '';
+            document.getElementById('editCsesidx').value = acc.csesidx || '';
+            document.getElementById('editUserAgent').value = acc.user_agent ? acc.user_agent.replace('...', '') : '';
+            
+            openModal('editAccountModal');
+        }
+
+        async function updateAccount() {
+            const id = document.getElementById('editAccountId').value;
+            const account = {};
+            
+            const teamId = document.getElementById('editTeamId').value;
+            const secureCses = document.getElementById('editSecureCses').value;
+            const hostCoses = document.getElementById('editHostCoses').value;
+            const csesidx = document.getElementById('editCsesidx').value;
+            const userAgent = document.getElementById('editUserAgent').value;
+            
+            if (teamId) account.team_id = teamId;
+            if (secureCses) account.secure_c_ses = secureCses;
+            if (hostCoses) account.host_c_oses = hostCoses;
+            if (csesidx) account.csesidx = csesidx;
+            if (userAgent) account.user_agent = userAgent;
+            
+            try {
+                const res = await apiFetch(`${API_BASE}/api/accounts/${id}`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(account)
+                });
+                const data = await res.json();
+                
+                if (data.success) {
+                    showToast('账号更新成功', 'success');
+                    closeModal('editAccountModal');
+                    loadAccounts();
+                } else {
+                    showToast('更新失败: ' + (data.error || '未知错误'), 'error');
+                }
+            } catch (e) {
+                showToast('更新失败: ' + e.message, 'error');
+            }
+        }
+
+        async function saveNewAccount() {
+            const teamId = document.getElementById('newTeamId').value;
+            const secureCses = document.getElementById('newSecureCses').value;
+            const hostCoses = document.getElementById('newHostCoses').value;
+            const csesidx = document.getElementById('newCsesidx').value;
+            const userAgent = document.getElementById('newUserAgent').value;
+
+            try {
+                const res = await apiFetch(`${API_BASE}/api/accounts`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ 
+                        team_id: teamId, 
+                        "secure_c_ses": secureCses, 
+                        "host_c_oses": hostCoses, 
+                        "csesidx": csesidx, 
+                        "user_agent": userAgent })
+                });
+                const data = await res.json();
+                if (!res.ok || data.error) throw new Error(data.error || data.detail || '添加失败');
+                showToast('账号添加成功!', 'success');
+                closeModal('addAccountModal');
+                loadAccounts();
+            } catch (e) {
+                showToast('添加失败: ' + e.message, 'error');
+            }
+        }
+
+        function parseAccountJson(text) {
+            const textarea = document.getElementById('newAccountJson');
+            const raw = (typeof text === 'string' ? text : textarea.value || '').trim();
+            if (!raw) {
+                showToast('请先粘贴账号JSON', 'warning');
+                return;
+            }
+            let acc;
+            try {
+                const parsed = JSON.parse(raw);
+                acc = Array.isArray(parsed) ? parsed[0] : parsed;
+                if (!acc || typeof acc !== 'object') throw new Error('格式不正确');
+            } catch (err) {
+                showToast('解析失败: ' + err.message, 'error');
+                return;
+            }
+
+            document.getElementById('newTeamId').value = acc.team_id || '';
+            document.getElementById('newSecureCses').value = acc.secure_c_ses || '';
+            document.getElementById('newHostCoses').value = acc.host_c_oses || '';
+            document.getElementById('newCsesidx').value = acc.csesidx || '';
+            document.getElementById('newUserAgent').value = acc.user_agent || '';
+            showToast('已填充账号信息', 'success');
+        }
+
+        async function pasteAccountJson() {
+            try {
+                if (!navigator.clipboard || !navigator.clipboard.readText) {
+                    showToast('当前环境不支持剪贴板API，请使用HTTPS或手动粘贴', 'warning');
+                    return;
+                }
+                const text = await navigator.clipboard.readText();
+                document.getElementById('newAccountJson').value = text;
+                parseAccountJson(text);
+            } catch (e) {
+                showToast('无法读取剪贴板: ' + e.message, 'error');
+            }
+        }
+        
+        async function deleteAccount(id) {
+            if (!confirm('确定要删除这个账号吗？')) return;
+            try {
+                const res = await apiFetch(`${API_BASE}/api/accounts/${id}`, { method: 'DELETE' });
+                if (!res.ok) throw new Error((await res.json()).detail);
+                showToast('账号删除成功!', 'success');
+                loadAccounts();
+            } catch (e) {
+                showToast('删除失败: ' + e.message, 'error');
+            }
+        }
+
+        async function testAccount(id) {
+            showToast(`正在测试账号ID: ${id}...`, 'info');
+            try {
+                const res = await apiFetch(`${API_BASE}/api/accounts/${id}/test`);
+                const data = await res.json();
+                if (res.ok && data.success) {
+                    showToast(`账号 ${id} 测试成功!`, 'success');
+                } else {
+                    throw new Error(data.detail || '未知错误');
+                }
+                loadAccounts();
+            } catch (e) {
+                showToast(`账号 ${id} 测试失败: ${e.message}`, 'error');
+            }
+        }
+
+        async function toggleAccount(id) {
+            const acc = accountsData.find(a => a.id === id);
+            const action = acc && acc.enabled !== false ? '停用' : '启用';
+            try {
+                const res = await apiFetch(`${API_BASE}/api/accounts/${id}/toggle`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+                const data = await res.json();
+                if (res.ok && data.success) {
+                    showToast(`账号 ${id} ${action}成功!`, 'success');
+                    loadAccounts();
+                } else {
+                    throw new Error(data.error || data.detail || '未知错误');
+                }
+            } catch (e) {
+                showToast(`账号 ${id} ${action}失败: ${e.message}`, 'error');
+            }
+        }
+
+        /**
+         * 显示刷新Cookie的模态框
+         * @param {number} id - 账号ID
+         */
+        function showRefreshCookieModal(id) {
+            const acc = accountsData.find(a => a.id === id);
+            if (!acc) {
+                showToast('账号不存在', 'error');
+                return;
+            }
+            
+            document.getElementById('refreshAccountId').value = id;
+            document.getElementById('refreshSecureCses').value = '';
+            document.getElementById('refreshHostCoses').value = '';
+            document.getElementById('refreshCsesidx').value = '';
+            document.getElementById('refreshCookieJson').value = '';
+            
+            openModal('refreshCookieModal');
+        }
+
+        /**
+         * 从JSON解析并填充刷新Cookie表单
+         * @param {string} text - JSON字符串
+         */
+        function parseRefreshCookieJson(text) {
+            const textarea = document.getElementById('refreshCookieJson');
+            const raw = (typeof text === 'string' ? text : textarea.value || '').trim();
+            if (!raw) {
+                showToast('请先粘贴Cookie JSON', 'warning');
+                return;
+            }
+            let acc;
+            try {
+                const parsed = JSON.parse(raw);
+                acc = Array.isArray(parsed) ? parsed[0] : parsed;
+                if (!acc || typeof acc !== 'object') throw new Error('格式不正确');
+            } catch (err) {
+                showToast('解析失败: ' + err.message, 'error');
+                return;
+            }
+
+            document.getElementById('refreshSecureCses').value = acc.secure_c_ses || '';
+            document.getElementById('refreshHostCoses').value = acc.host_c_oses || '';
+            document.getElementById('refreshCsesidx').value = acc.csesidx || '';
+            showToast('已填充Cookie信息', 'success');
+        }
+
+        /**
+         * 从剪贴板粘贴并解析刷新Cookie JSON
+         */
+        async function pasteRefreshCookieJson() {
+            try {
+                if (!navigator.clipboard || !navigator.clipboard.readText) {
+                    showToast('当前环境不支持剪贴板API，请使用HTTPS或手动粘贴', 'warning');
+                    return;
+                }
+                const text = await navigator.clipboard.readText();
+                document.getElementById('refreshCookieJson').value = text;
+                parseRefreshCookieJson(text);
+            } catch (e) {
+                showToast('无法读取剪贴板: ' + e.message, 'error');
+            }
+        }
+
+        /**
+         * 刷新账号Cookie
+         * 调用后端API更新账号的Cookie信息
+         */
+        async function refreshAccountCookie() {
+            const id = document.getElementById('refreshAccountId').value;
+            const secureCses = document.getElementById('refreshSecureCses').value.trim();
+            const hostCoses = document.getElementById('refreshHostCoses').value.trim();
+            const csesidx = document.getElementById('refreshCsesidx').value.trim();
+
+            // 验证必填字段
+            if (!secureCses || !hostCoses) {
+                showToast('secure_c_ses 和 host_c_oses 为必填项', 'warning');
+                return;
+            }
+
+            try {
+                const res = await apiFetch(`${API_BASE}/api/accounts/${id}/refresh-cookie`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        secure_c_ses: secureCses,
+                        host_c_oses: hostCoses,
+                        csesidx: csesidx || undefined
+                    })
+                });
+                const data = await res.json();
+                
+                if (res.ok && data.success) {
+                    showToast('Cookie刷新成功!', 'success');
+                    closeModal('refreshCookieModal');
+                    loadAccounts();
+                } else {
+                    throw new Error(data.error || data.detail || '未知错误');
+                }
+            } catch (e) {
+                showToast('Cookie刷新失败: ' + e.message, 'error');
+            }
+        }
+
+        // --- 模型管理 (Models) ---
+        async function loadModels() {
+            try {
+                const res = await apiFetch(`${API_BASE}/api/models`);
+                const data = await res.json();
+                modelsData = data.models || [];
+                renderModels();
+            } catch (e) {
+                showToast('加载模型列表失败: ' + e.message, 'error');
+            }
+        }
+        
+        function escapeHtml(str) {
+            if (!str) return '';
+            return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#039;');
+        }
+
+        function renderModels() {
+            const tbody = document.getElementById('modelsTableBody');
+            if (!tbody) return;
+            if (modelsData.length === 0) {
+                tbody.innerHTML = `<tr><td colspan="7" class="empty-state">
+                    <div class="empty-state-icon"><svg class="icon"><use xlink:href="#icon-robot"></use></svg></div>
+                    <h3>暂无模型</h3><p>点击 "添加模型" 按钮来创建一个。</p>
+                </td></tr>`;
+                return;
+            }
+            tbody.innerHTML = modelsData.map((model, index) => {
+                const safeId = escapeHtml(model.id);
+                const safeName = escapeHtml(model.name);
+                const safeDesc = escapeHtml(model.description);
+                return `
+                <tr>
+                    <td><code>${safeId}</code></td>
+                    <td>${safeName}</td>
+                    <td title="${safeDesc}">${model.description ? safeDesc.substring(0, 40) + '...' : ''}</td>
+                    <td>${model.context_length}</td>
+                    <td>${model.max_tokens}</td>
+                    <td><span class="badge ${model.is_public ? 'badge-success' : 'badge-warning'}">${model.is_public ? '公共' : '私有'}</span></td>
+                    <td>
+                        <button class="btn btn-sm btn-outline btn-icon" onclick="showEditModelModalByIndex(${index})" title="编辑">✏️</button>
+                        <button class="btn btn-sm btn-danger btn-icon" onclick="deleteModelByIndex(${index})" title="删除">🗑️</button>
+                    </td>
+                </tr>
+            `;
+            }).join('');
+        }
+
+        function showAddModelModal() {
+            openModal('addModelModal');
+        }
+
+        function showEditModelModalByIndex(index) {
+            const model = modelsData[index];
+            if (!model) return;
+            
+            document.getElementById('editModelOriginalId').value = model.id;
+            document.getElementById('editModelId').value = model.id;
+            document.getElementById('editModelName').value = model.name || '';
+            document.getElementById('editModelDesc').value = model.description || '';
+            document.getElementById('editContextLength').value = model.context_length || '';
+            document.getElementById('editMaxTokens').value = model.max_tokens || '';
+            
+            openModal('editModelModal');
+        }
+
+        async function updateModel() {
+            const originalId = document.getElementById('editModelOriginalId').value;
+            const model = {
+                name: document.getElementById('editModelName').value,
+                description: document.getElementById('editModelDesc').value,
+                context_length: parseInt(document.getElementById('editContextLength').value) || 32000,
+                max_tokens: parseInt(document.getElementById('editMaxTokens').value) || 8096
+            };
+            
+            try {
+                const res = await apiFetch(`${API_BASE}/api/models/${encodeURIComponent(originalId)}`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(model)
+                });
+                const data = await res.json();
+                
+                if (data.success) {
+                    showToast('模型更新成功', 'success');
+                    closeModal('editModelModal');
+                    loadModels();
+                } else {
+                    showToast('更新失败: ' + (data.error || '未知错误'), 'error');
+                }
+            } catch (e) {
+                showToast('更新失败: ' + e.message, 'error');
+            }
+        }
+
+        /**
+         * 保存新模型
+         * 从添加模型模态框获取数据并调用API创建新模型
+         */
+        async function saveNewModel() {
+            const modelId = document.getElementById('newModelId').value.trim();
+            const modelName = document.getElementById('newModelName').value.trim();
+            const modelDesc = document.getElementById('newModelDesc').value.trim();
+            const contextLength = parseInt(document.getElementById('newContextLength').value) || 32000;
+            const maxTokens = parseInt(document.getElementById('newMaxTokens').value) || 8096;
+
+            // 验证必填字段
+            if (!modelId) {
+                showToast('请输入模型ID', 'warning');
+                return;
+            }
+            if (!modelName) {
+                showToast('请输入模型名称', 'warning');
+                return;
+            }
+
+            const model = {
+                id: modelId,
+                name: modelName,
+                description: modelDesc,
+                context_length: contextLength,
+                max_tokens: maxTokens
+            };
+
+            try {
+                const res = await apiFetch(`${API_BASE}/api/models`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(model)
+                });
+                const data = await res.json();
+                
+                if (res.ok && (data.success || !data.error)) {
+                    showToast('模型添加成功', 'success');
+                    closeModal('addModelModal');
+                    // 清空表单
+                    document.getElementById('newModelId').value = '';
+                    document.getElementById('newModelName').value = '';
+                    document.getElementById('newModelDesc').value = '';
+                    document.getElementById('newContextLength').value = '';
+                    document.getElementById('newMaxTokens').value = '';
+                    loadModels();
+                } else {
+                    throw new Error(data.error || '添加失败');
+                }
+            } catch (e) {
+                showToast('添加模型失败: ' + e.message, 'error');
+            }
+        }
+
+        /**
+         * 删除模型
+         * @param {string} id - 模型ID
+         */
+        async function deleteModelByIndex(index) {
+            const model = modelsData[index];
+            if (!model) return;
+            const id = model.id;
+            if (!confirm(`确定要删除模型 "${id}" 吗？此操作不可恢复。`)) {
+                return;
+            }
+
+            try {
+                const res = await apiFetch(`${API_BASE}/api/models/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                });
+                const data = await res.json();
+                
+                if (res.ok && (data.success || !data.error)) {
+                    showToast('模型删除成功', 'success');
+                    loadModels();
+                } else {
+                    throw new Error(data.error || '删除失败');
+                }
+            } catch (e) {
+                showToast('删除模型失败: ' + e.message, 'error');
+            }
+        }
+        
+        // --- 系统设置 (Settings) ---
+        async function loadConfig() {
+            try {
+                const res = await apiFetch(`${API_BASE}/api/config`);
+                configData = await res.json();
+                document.getElementById('proxyUrl').value = configData.proxy || '';
+                const imageModeSelect = document.getElementById('imageOutputMode');
+                if (imageModeSelect) {
+                    const mode = (configData.image_output_mode || 'url');
+                    imageModeSelect.value = mode === 'base64' ? 'base64' : 'url';
+                }
+                document.getElementById('configJson').value = JSON.stringify(configData, null, 2);
+            } catch (e) {
+                showToast('加载配置失败: ' + e.message, 'error');
+            }
+        }
+
+        async function loadLogLevel() {
+            try {
+                const res = await apiFetch(`${API_BASE}/api/logging`);
+                const data = await res.json();
+                const select = document.getElementById('logLevelSelect');
+                if (select && data.level) {
+                    select.value = data.level;
+                }
+            } catch (e) {
+                console.warn('日志级别加载失败', e);
+            }
+        }
+
+        async function updateLogLevel(level) {
+            try {
+                const res = await apiFetch(`${API_BASE}/api/logging`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ level })
+                });
+                const data = await res.json();
+                if (!res.ok || data.error) {
+                    throw new Error(data.error || '设置失败');
+                }
+                showToast(`日志级别已切换为 ${data.level}`, 'success');
+            } catch (e) {
+                showToast('日志级别设置失败: ' + e.message, 'error');
+            }
+        }
+
+        // --- Token 管理 ---
+        async function loadTokens() {
+            try {
+                const res = await apiFetch(`${API_BASE}/api/tokens`);
+                const data = await res.json();
+                tokensData = data.tokens || [];
+                renderTokens();
+            } catch (e) {
+                showToast('加载 Token 失败: ' + e.message, 'error');
+            }
+        }
+
+        function renderTokens() {
+            const tbody = document.getElementById('tokensTableBody');
+            if (!tbody) return;
+            if (!tokensData.length) {
+                tbody.innerHTML = `<tr><td colspan="2" class="empty-state">暂无 Token</td></tr>`;
+                return;
+            }
+            tbody.innerHTML = tokensData.map(token => `
+                <tr>
+                    <td><code>${token}</code></td>
+                    <td style="white-space: nowrap;">
+                        <button class="btn btn-outline btn-sm" data-token="${token}" onclick="copyToken(this.dataset.token)" title="复制Token">复制</button>
+                        <button class="btn btn-danger btn-sm" data-token="${token}" onclick="deleteToken(this.dataset.token)" title="删除Token">删除</button>
+                    </td>
+                </tr>
+            `).join('');
+        }
+
+        async function addToken() {
+            const manual = document.getElementById('manualToken').value.trim();
+            try {
+                const res = await apiFetch(`${API_BASE}/api/tokens`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(manual ? { token: manual } : {})
+                });
+                const data = await res.json();
+                if (!res.ok || data.error) throw new Error(data.error || '创建失败');
+                document.getElementById('manualToken').value = data.token;
+                showToast('Token 创建成功', 'success');
+                loadTokens();
+            } catch (e) {
+                showToast('创建 Token 失败: ' + e.message, 'error');
+            }
+        }
+
+        function generateToken() {
+            if (window.crypto && crypto.randomUUID) {
+                document.getElementById('manualToken').value = crypto.randomUUID().replace(/-/g, '');
+            } else {
+                document.getElementById('manualToken').value = Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+            }
+        }
+
+        async function deleteToken(token) {
+            if (!confirm('确定删除该 Token 吗？')) return;
+            try {
+                const res = await apiFetch(`${API_BASE}/api/tokens/${token}`, { method: 'DELETE' });
+                const data = await res.json();
+                if (!res.ok || data.error) throw new Error(data.error || '删除失败');
+                showToast('Token 删除成功', 'success');
+                loadTokens();
+            } catch (e) {
+                showToast('删除 Token 失败: ' + e.message, 'error');
+            }
+        }
+
+        function copyToken(token) {
+            if (!token) {
+                showToast('无效的 Token', 'warning');
+                return;
+            }
+            if (navigator.clipboard && navigator.clipboard.writeText) {
+                navigator.clipboard.writeText(token).then(() => {
+                    showToast('已复制', 'success');
+                }).catch(() => {
+                    fallbackCopy(token);
+                });
+            } else {
+                fallbackCopy(token);
+            }
+        }
+
+        function fallbackCopy(text) {
+            try {
+                const textarea = document.createElement('textarea');
+                textarea.value = text;
+                document.body.appendChild(textarea);
+                textarea.select();
+                document.execCommand('copy');
+                document.body.removeChild(textarea);
+                showToast('已复制', 'success');
+            } catch (err) {
+                showToast('复制失败', 'error');
+            }
+        }
+
+        function logoutAdmin() {
+            localStorage.removeItem(ADMIN_TOKEN_KEY);
+            document.cookie = 'admin_token=; Max-Age=0; path=/';
+            showToast('已注销', 'success');
+            updateLoginButton();
+        }
+
+        function showLoginModal() {
+            document.getElementById('loginPassword').value = '';
+            openModal('loginModal');
+        }
+
+        async function submitLogin() {
+            const pwd = document.getElementById('loginPassword').value;
+            if (!pwd) {
+                showToast('请输入密码', 'warning');
+                return;
+            }
+            try {
+                const res = await fetch(`${API_BASE}/api/auth/login`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ password: pwd })
+                });
+                const data = await res.json();
+                if (!res.ok || data.error) {
+                    throw new Error(data.error || '登录失败');
+                }
+                localStorage.setItem(ADMIN_TOKEN_KEY, data.token);
+                showToast('登录成功', 'success');
+                closeModal('loginModal');
+                loadAllData();
+                updateLoginButton();
+            } catch (e) {
+                showToast('登录失败: ' + e.message, 'error');
+            }
+        }
+
+        async function saveSettings() {
+            const proxyUrl = document.getElementById('proxyUrl').value;
+            const imageModeSelect = document.getElementById('imageOutputMode');
+            const imageOutputMode = imageModeSelect ? imageModeSelect.value : 'url';
+            try {
+                const res = await apiFetch(`${API_BASE}/api/config`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ proxy: proxyUrl, image_output_mode: imageOutputMode })
+                });
+                if (!res.ok) throw new Error((await res.json()).detail);
+                showToast('设置保存成功!', 'success');
+                loadConfig();
+            } catch (e) {
+                showToast('保存失败: ' + e.message, 'error');
+            }
+        }
+
+        async function testProxy() {
+            const proxyUrl = document.getElementById('proxyUrl').value;
+            const proxyStatus = document.getElementById('proxyStatus');
+            proxyStatus.textContent = '测试中...';
+            proxyStatus.style.color = 'var(--text-muted)';
+            try {
+                const res = await apiFetch(`${API_BASE}/api/proxy/test`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ proxy: proxyUrl })
+                });
+                const data = await res.json();
+                if (res.ok && data.success) {
+                    proxyStatus.textContent = `测试成功! (${data.delay_ms}ms)`;
+                    proxyStatus.style.color = 'var(--success)';
+                } else {
+                    throw new Error(data.detail);
+                }
+            } catch (e) {
+                proxyStatus.textContent = `测试失败: ${e.message}`;
+                proxyStatus.style.color = 'var(--danger)';
+            }
+        }
+
+        function refreshConfig() {
+            loadConfig();
+            showToast('配置已刷新', 'info');
+        }
+
+        function downloadConfig() {
+            const dataStr = "data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(configData, null, 2));
+            const downloadAnchorNode = document.createElement('a');
+            downloadAnchorNode.setAttribute("href", dataStr);
+            downloadAnchorNode.setAttribute("download", "business_gemini_session.json");
+            document.body.appendChild(downloadAnchorNode);
+            downloadAnchorNode.click();
+            downloadAnchorNode.remove();
+            showToast('配置文件已开始下载', 'success');
+        }
+        
+        function uploadConfig() {
+            document.getElementById('configFileInput').click();
+        }
+
+        function handleConfigUpload(event) {
+            const file = event.target.files[0];
+            if (!file) return;
+            const reader = new FileReader();
+            reader.onload = async (e) => {
+                try {
+                    const newConfig = JSON.parse(e.target.result);
+                    const res = await apiFetch(`${API_BASE}/api/config/import`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(newConfig)
+                    });
+                    if (!res.ok) throw new Error((await res.json()).detail);
+                    showToast('配置导入成功!', 'success');
+                    loadAllData();
+                } catch (err) {
+                    showToast('导入失败: ' + err.message, 'error');
+                }
+            };
+            reader.readAsText(file);
+        }
+        
+        // --- 模态框控制 ---
+        function openModal(modalId) {
+            const modal = document.getElementById(modalId);
+            if (modal) modal.classList.add('show');
+        }
+
+        function closeModal(modalId) {
+            const modal = document.getElementById(modalId);
+            if (modal) modal.classList.remove('show');
+        }
+
+        document.querySelectorAll('.modal').forEach(modal => {
+            modal.addEventListener('click', (e) => {
+                if (e.target.classList.contains('modal')) {
+                    closeModal(modal.id);
+                }
+            });
+        });
+    </script>
+
+</body>
+</html>

requirements-hf.txt

@@ -0,0 +1,5 @@
+# Hugging Face Spaces requirements
+flask>=2.0.0
+flask-cors>=3.0.0
+requests>=2.25.0
+urllib3>=1.26.0