Upload 45 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+app/template/favicon.png filter=lfs diff=lfs merge=lfs -text
+data/temp/video/users-8522ce45-679b-4e0e-a0f7-bb18f434eb6b-generated-15f7113f-5d16-4ff1-bdaa-a2eabd66671c-generated_video.mp4 filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,55 @@
+# 构建阶段
+FROM python:3.11-slim AS builder
+
+WORKDIR /build
+
+# 安装依赖到独立目录
+COPY requirements.txt .
+RUN pip install --no-cache-dir --only-binary=:all: --prefix=/install -r requirements.txt && \
+  find /install -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true && \
+  find /install -type d -name "tests" -exec rm -rf {} + 2>/dev/null || true && \
+  find /install -type d -name "test" -exec rm -rf {} + 2>/dev/null || true && \
+  find /install -type d -name "*.dist-info" -exec sh -c 'rm -f "$1"/RECORD "$1"/INSTALLER' _ {} \; && \
+  find /install -type f -name "*.pyc" -delete && \
+  find /install -type f -name "*.pyo" -delete && \
+  find /install -name "*.so" -exec strip --strip-unneeded {} \; 2>/dev/null || true
+
+# 运行阶段 - 使用最小镜像
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# 清理基础镜像中的冗余文件
+RUN rm -rf /usr/share/doc/* \
+  /usr/share/man/* \
+  /usr/share/locale/* \
+  /var/cache/apt/* \
+  /var/lib/apt/lists/* \
+  /tmp/* \
+  /var/tmp/*
+
+# 从构建阶段复制已安装的包
+COPY --from=builder /install /usr/local
+
+# 创建必要的目录（包括用于挂载的data目录）
+RUN mkdir -p /app/logs /app/data/temp/image /app/data/temp/video
+
+# 复制应用代码
+COPY app/ ./app/
+COPY main.py .
+
+# 复制并设置 entrypoint 脚本
+COPY docker-entrypoint.sh /usr/local/bin/
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+# 删除 Python 字节码和缓存
+ENV PYTHONDONTWRITEBYTECODE=1 \
+  PYTHONUNBUFFERED=1
+
+EXPOSE 8000
+
+# 使用 entrypoint 脚本初始化配置
+ENTRYPOINT ["docker-entrypoint.sh"]
+
+# 默认启动命令
+CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chenyme
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app/api/admin/manage.py

@@ -0,0 +1,1017 @@
+"""管理接口 - Token管理和系统配置"""
+
+import secrets
+import time
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+from pathlib import Path
+from fastapi import APIRouter, HTTPException, Depends, Header, Query
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+
+from app.core.config import setting
+from app.core.logger import logger
+from app.services.grok.token import token_manager
+from app.services.request_stats import request_stats
+from app.models.grok_models import TokenType
+
+
+router = APIRouter(tags=["管理"])
+
+# 常量
+STATIC_DIR = Path(__file__).parents[2] / "template"
+TEMP_DIR = Path(__file__).parents[3] / "data" / "temp"
+IMAGE_CACHE_DIR = TEMP_DIR / "image"
+VIDEO_CACHE_DIR = TEMP_DIR / "video"
+SESSION_EXPIRE_HOURS = 24
+BYTES_PER_KB = 1024
+BYTES_PER_MB = 1024 * 1024
+
+# 会话存储
+_sessions: Dict[str, datetime] = {}
+
+
+# === 请求/响应模型 ===
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class LoginResponse(BaseModel):
+    success: bool
+    token: Optional[str] = None
+    message: str
+
+
+class AddTokensRequest(BaseModel):
+    tokens: List[str]
+    token_type: str
+
+
+class DeleteTokensRequest(BaseModel):
+    tokens: List[str]
+    token_type: str
+
+
+class TokenInfo(BaseModel):
+    token: str
+    token_type: str
+    created_time: Optional[int] = None
+    remaining_queries: int
+    heavy_remaining_queries: int
+    status: str
+    tags: List[str] = []
+    note: str = ""
+    cooldown_until: Optional[int] = None
+    cooldown_remaining: int = 0
+    last_failure_time: Optional[int] = None
+    last_failure_reason: str = ""
+    limit_reason: str = ""
+
+
+class TokenListResponse(BaseModel):
+    success: bool
+    data: List[TokenInfo]
+    total: int
+
+
+class UpdateSettingsRequest(BaseModel):
+    global_config: Optional[Dict[str, Any]] = None
+    grok_config: Optional[Dict[str, Any]] = None
+
+
+class UpdateTokenTagsRequest(BaseModel):
+    token: str
+    token_type: str
+    tags: List[str]
+
+
+class UpdateTokenNoteRequest(BaseModel):
+    token: str
+    token_type: str
+    note: str
+
+
+class TestTokenRequest(BaseModel):
+    token: str
+    token_type: str
+
+
+# === 辅助函数 ===
+
+def validate_token_type(token_type_str: str) -> TokenType:
+    """验证Token类型"""
+    if token_type_str not in ["sso", "ssoSuper"]:
+        raise HTTPException(
+            status_code=400,
+            detail={"error": "无效的Token类型", "code": "INVALID_TYPE"}
+        )
+    return TokenType.NORMAL if token_type_str == "sso" else TokenType.SUPER
+
+
+def parse_created_time(created_time) -> Optional[int]:
+    """解析创建时间"""
+    if isinstance(created_time, str):
+        return int(created_time) if created_time else None
+    elif isinstance(created_time, int):
+        return created_time
+    return None
+
+
+def _get_cooldown_remaining_ms(token_data: Dict[str, Any], now_ms: Optional[int] = None) -> int:
+    """获取冷却剩余时间（毫秒）."""
+    cooldown_until = token_data.get("cooldownUntil")
+    if not cooldown_until:
+        return 0
+
+    try:
+        now = now_ms if now_ms is not None else int(time.time() * 1000)
+        remaining = int(cooldown_until) - now
+        return remaining if remaining > 0 else 0
+    except (TypeError, ValueError):
+        return 0
+
+
+def _is_token_in_cooldown(token_data: Dict[str, Any], now_ms: Optional[int] = None) -> bool:
+    """判断Token是否处于429冷却中."""
+    return _get_cooldown_remaining_ms(token_data, now_ms) > 0
+
+
+def calculate_token_stats(tokens: Dict[str, Any], token_type: str) -> Dict[str, int]:
+    """计算Token统计."""
+    total = len(tokens)
+    expired = sum(1 for t in tokens.values() if t.get("status") == "expired")
+    now_ms = int(time.time() * 1000)
+    cooldown = 0
+    exhausted = 0
+    unused = 0
+    active = 0
+
+    for token_data in tokens.values():
+        if token_data.get("status") == "expired":
+            continue
+
+        if _is_token_in_cooldown(token_data, now_ms):
+            cooldown += 1
+            continue
+
+        remaining = token_data.get("remainingQueries", -1)
+        heavy_remaining = token_data.get("heavyremainingQueries", -1)
+
+        if token_type == "normal":
+            if remaining == -1:
+                unused += 1
+            elif remaining == 0:
+                exhausted += 1
+            else:
+                active += 1
+        else:
+            if remaining == -1 and heavy_remaining == -1:
+                unused += 1
+            elif remaining == 0 or heavy_remaining == 0:
+                exhausted += 1
+            else:
+                active += 1
+
+    limited = cooldown + exhausted
+    return {
+        "total": total,
+        "unused": unused,
+        "limited": limited,
+        "cooldown": cooldown,
+        "exhausted": exhausted,
+        "expired": expired,
+        "active": active
+    }
+
+
+def verify_admin_session(authorization: Optional[str] = Header(None)) -> bool:
+    """验证管理员会话"""
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail={"error": "未授权访问", "code": "UNAUTHORIZED"})
+    
+    token = authorization[7:]
+    
+    if token not in _sessions:
+        raise HTTPException(status_code=401, detail={"error": "会话无效", "code": "SESSION_INVALID"})
+    
+    if datetime.now() > _sessions[token]:
+        del _sessions[token]
+        raise HTTPException(status_code=401, detail={"error": "会话已过期", "code": "SESSION_EXPIRED"})
+    
+    return True
+
+
+def get_token_status(token_data: Dict[str, Any], token_type: str) -> str:
+    """获取Token状态."""
+    if token_data.get("status") == "expired":
+        return "失效"
+
+    if _is_token_in_cooldown(token_data):
+        return "冷却中"
+
+    remaining = token_data.get("remainingQueries", -1)
+    heavy_remaining = token_data.get("heavyremainingQueries", -1)
+
+    if token_type == "ssoSuper":
+        if remaining == -1 and heavy_remaining == -1:
+            return "未使用"
+        if remaining == 0 or heavy_remaining == 0:
+            return "额度耗尽"
+        return "正常"
+
+    if remaining == -1:
+        return "未使用"
+    if remaining == 0:
+        return "额度耗尽"
+    return "正常"
+
+
+def _calculate_dir_size(directory: Path) -> int:
+    """计算目录大小"""
+    total = 0
+    for file_path in directory.iterdir():
+        if file_path.is_file():
+            try:
+                total += file_path.stat().st_size
+            except Exception as e:
+                logger.warning(f"[Admin] 无法获取文件大小: {file_path.name}, {e}")
+    return total
+
+
+def _format_size(size_bytes: int) -> str:
+    """格式化文件大小"""
+    size_mb = size_bytes / BYTES_PER_MB
+    if size_mb < 1:
+        return f"{size_bytes / BYTES_PER_KB:.1f} KB"
+    return f"{size_mb:.1f} MB"
+
+
+# === 页面路由 ===
+
+@router.get("/login", response_class=HTMLResponse)
+async def login_page():
+    """登录页面"""
+    login_html = STATIC_DIR / "login.html"
+    if login_html.exists():
+        return login_html.read_text(encoding="utf-8")
+    raise HTTPException(status_code=404, detail="登录页面不存在")
+
+
+@router.get("/manage", response_class=HTMLResponse)
+async def manage_page():
+    """管理页面"""
+    admin_html = STATIC_DIR / "admin.html"
+    if admin_html.exists():
+        return admin_html.read_text(encoding="utf-8")
+    raise HTTPException(status_code=404, detail="管理页面不存在")
+
+
+# === API端点 ===
+
+@router.post("/api/login", response_model=LoginResponse)
+async def admin_login(request: LoginRequest) -> LoginResponse:
+    """管理员登录"""
+    try:
+        logger.debug(f"[Admin] 登录尝试: {request.username}")
+
+        expected_user = setting.global_config.get("admin_username", "")
+        expected_pass = setting.global_config.get("admin_password", "")
+
+        if request.username != expected_user or request.password != expected_pass:
+            logger.warning(f"[Admin] 登录失败: {request.username}")
+            return LoginResponse(success=False, message="用户名或密码错误")
+
+        session_token = secrets.token_urlsafe(32)
+        _sessions[session_token] = datetime.now() + timedelta(hours=SESSION_EXPIRE_HOURS)
+
+        logger.debug(f"[Admin] 登录成功: {request.username}")
+        return LoginResponse(success=True, token=session_token, message="登录成功")
+
+    except Exception as e:
+        logger.error(f"[Admin] 登录异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"登录失败: {e}", "code": "LOGIN_ERROR"})
+
+
+@router.post("/api/logout")
+async def admin_logout(_: bool = Depends(verify_admin_session), authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
+    """管理员登出"""
+    try:
+        if authorization and authorization.startswith("Bearer "):
+            token = authorization[7:]
+            if token in _sessions:
+                del _sessions[token]
+                logger.debug("[Admin] 登出成功")
+                return {"success": True, "message": "登出成功"}
+
+        logger.warning("[Admin] 登出失败: 无效会话")
+        return {"success": False, "message": "无效的会话"}
+
+    except Exception as e:
+        logger.error(f"[Admin] 登出异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"登出失败: {e}", "code": "LOGOUT_ERROR"})
+
+
+@router.get("/api/tokens", response_model=TokenListResponse)
+async def list_tokens(_: bool = Depends(verify_admin_session)) -> TokenListResponse:
+    """获取Token列表"""
+    try:
+        logger.debug("[Admin] 获取Token列表")
+
+        all_tokens = token_manager.get_tokens()
+        token_list: List[TokenInfo] = []
+        now_ms = int(time.time() * 1000)
+
+        # 普通Token
+        for token, data in all_tokens.get(TokenType.NORMAL.value, {}).items():
+            cooldown_remaining_ms = _get_cooldown_remaining_ms(data, now_ms)
+            cooldown_until = data.get("cooldownUntil") if cooldown_remaining_ms else None
+            limit_reason = "cooldown" if cooldown_remaining_ms else ""
+            if not limit_reason and data.get("remainingQueries", -1) == 0:
+                limit_reason = "exhausted"
+            token_list.append(TokenInfo(
+                token=token,
+                token_type="sso",
+                created_time=parse_created_time(data.get("createdTime")),
+                remaining_queries=data.get("remainingQueries", -1),
+                heavy_remaining_queries=data.get("heavyremainingQueries", -1),
+                status=get_token_status(data, "sso"),
+                tags=data.get("tags", []),
+                note=data.get("note", ""),
+                cooldown_until=cooldown_until,
+                cooldown_remaining=(cooldown_remaining_ms + 999) // 1000 if cooldown_remaining_ms else 0,
+                last_failure_time=data.get("lastFailureTime") or None,
+                last_failure_reason=data.get("lastFailureReason") or "",
+                limit_reason=limit_reason
+            ))
+
+        # Super Token
+        for token, data in all_tokens.get(TokenType.SUPER.value, {}).items():
+            cooldown_remaining_ms = _get_cooldown_remaining_ms(data, now_ms)
+            cooldown_until = data.get("cooldownUntil") if cooldown_remaining_ms else None
+            limit_reason = "cooldown" if cooldown_remaining_ms else ""
+            if not limit_reason and (data.get("remainingQueries", -1) == 0 or data.get("heavyremainingQueries", -1) == 0):
+                limit_reason = "exhausted"
+            token_list.append(TokenInfo(
+                token=token,
+                token_type="ssoSuper",
+                created_time=parse_created_time(data.get("createdTime")),
+                remaining_queries=data.get("remainingQueries", -1),
+                heavy_remaining_queries=data.get("heavyremainingQueries", -1),
+                status=get_token_status(data, "ssoSuper"),
+                tags=data.get("tags", []),
+                note=data.get("note", ""),
+                cooldown_until=cooldown_until,
+                cooldown_remaining=(cooldown_remaining_ms + 999) // 1000 if cooldown_remaining_ms else 0,
+                last_failure_time=data.get("lastFailureTime") or None,
+                last_failure_reason=data.get("lastFailureReason") or "",
+                limit_reason=limit_reason
+            ))
+
+        logger.debug(f"[Admin] Token列表获取成功: {len(token_list)}个")
+        return TokenListResponse(success=True, data=token_list, total=len(token_list))
+
+    except Exception as e:
+        logger.error(f"[Admin] 获取Token列表异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}", "code": "LIST_ERROR"})
+
+
+@router.post("/api/tokens/add")
+async def add_tokens(request: AddTokensRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """批量添加Token"""
+    try:
+        logger.debug(f"[Admin] 添加Token: {request.token_type}, {len(request.tokens)}个")
+
+        token_type = validate_token_type(request.token_type)
+        await token_manager.add_token(request.tokens, token_type)
+
+        logger.debug(f"[Admin] Token添加成功: {len(request.tokens)}个")
+        return {"success": True, "message": f"成功添加 {len(request.tokens)} 个Token", "count": len(request.tokens)}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[Admin] Token添加异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"添加失败: {e}", "code": "ADD_ERROR"})
+
+
+@router.post("/api/tokens/delete")
+async def delete_tokens(request: DeleteTokensRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """批量删除Token"""
+    try:
+        logger.debug(f"[Admin] 删除Token: {request.token_type}, {len(request.tokens)}个")
+
+        token_type = validate_token_type(request.token_type)
+        await token_manager.delete_token(request.tokens, token_type)
+
+        logger.debug(f"[Admin] Token删除成功: {len(request.tokens)}个")
+        return {"success": True, "message": f"成功删除 {len(request.tokens)} 个Token", "count": len(request.tokens)}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[Admin] Token删除异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"删除失败: {e}", "code": "DELETE_ERROR"})
+
+
+@router.get("/api/settings")
+async def get_settings(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取配置"""
+    try:
+        logger.debug("[Admin] 获取配置")
+        return {"success": True, "data": {"global": setting.global_config, "grok": setting.grok_config}}
+    except Exception as e:
+        logger.error(f"[Admin] 获取配置失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}", "code": "GET_SETTINGS_ERROR"})
+
+
+@router.post("/api/settings")
+async def update_settings(request: UpdateSettingsRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """更新配置"""
+    try:
+        logger.debug("[Admin] 更新配置")
+        await setting.save(global_config=request.global_config, grok_config=request.grok_config)
+        logger.debug("[Admin] 配置更新成功")
+        return {"success": True, "message": "配置更新成功"}
+    except Exception as e:
+        logger.error(f"[Admin] 更新配置失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"更新失败: {e}", "code": "UPDATE_SETTINGS_ERROR"})
+
+
+@router.get("/api/cache/size")
+async def get_cache_size(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取缓存大小"""
+    try:
+        logger.debug("[Admin] 获取缓存大小")
+
+        image_size = _calculate_dir_size(IMAGE_CACHE_DIR) if IMAGE_CACHE_DIR.exists() else 0
+        video_size = _calculate_dir_size(VIDEO_CACHE_DIR) if VIDEO_CACHE_DIR.exists() else 0
+        total_size = image_size + video_size
+
+        logger.debug(f"[Admin] 缓存大小: 图片{_format_size(image_size)}, 视频{_format_size(video_size)}")
+        
+        return {
+            "success": True,
+            "data": {
+                "image_size": _format_size(image_size),
+                "video_size": _format_size(video_size),
+                "total_size": _format_size(total_size),
+                "image_size_bytes": image_size,
+                "video_size_bytes": video_size,
+                "total_size_bytes": total_size
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"[Admin] 获取缓存大小异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}", "code": "CACHE_SIZE_ERROR"})
+
+
+@router.get("/api/cache/list")
+async def list_cache_files(
+    cache_type: str = Query("image", alias="type"),
+    limit: int = 50,
+    offset: int = 0,
+    _: bool = Depends(verify_admin_session)
+) -> Dict[str, Any]:
+    """List cached files for admin preview."""
+    try:
+        cache_type = cache_type.lower()
+        if cache_type not in ("image", "video"):
+            raise HTTPException(status_code=400, detail={"error": "Invalid cache type", "code": "INVALID_CACHE_TYPE"})
+
+        if limit < 1:
+            limit = 1
+        if limit > 200:
+            limit = 200
+        if offset < 0:
+            offset = 0
+
+        cache_dir = IMAGE_CACHE_DIR if cache_type == "image" else VIDEO_CACHE_DIR
+        if not cache_dir.exists():
+            return {"success": True, "data": {"total": 0, "items": [], "offset": offset, "limit": limit, "has_more": False}}
+
+        files = []
+        for file_path in cache_dir.iterdir():
+            if not file_path.is_file():
+                continue
+            try:
+                stat = file_path.stat()
+            except Exception as e:
+                logger.warning(f"[Admin] Skip cache file: {file_path.name}, {e}")
+                continue
+            files.append((file_path, stat.st_mtime, stat.st_size))
+
+        files.sort(key=lambda item: item[1], reverse=True)
+        total = len(files)
+        sliced = files[offset:offset + limit]
+
+        items = [
+            {
+                "name": file_path.name,
+                "size": _format_size(size),
+                "size_bytes": size,
+                "mtime": int(mtime * 1000),
+                "url": f"/images/{file_path.name}",
+                "type": cache_type
+            }
+            for file_path, mtime, size in sliced
+        ]
+
+        return {
+            "success": True,
+            "data": {
+                "total": total,
+                "items": items,
+                "offset": offset,
+                "limit": limit,
+                "has_more": offset + limit < total
+            }
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[Admin] 获取缓存列表异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}", "code": "CACHE_LIST_ERROR"})
+
+
+@router.post("/api/cache/clear")
+async def clear_cache(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """清理所有缓存"""
+    try:
+        logger.debug("[Admin] 清理缓存")
+
+        image_count = 0
+        video_count = 0
+
+        # 清理图片
+        if IMAGE_CACHE_DIR.exists():
+            for file_path in IMAGE_CACHE_DIR.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        image_count += 1
+                    except Exception as e:
+                        logger.error(f"[Admin] 删除失败: {file_path.name}, {e}")
+
+        # 清理视频
+        if VIDEO_CACHE_DIR.exists():
+            for file_path in VIDEO_CACHE_DIR.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        video_count += 1
+                    except Exception as e:
+                        logger.error(f"[Admin] 删除失败: {file_path.name}, {e}")
+
+        total = image_count + video_count
+        logger.debug(f"[Admin] 缓存清理完成: 图片{image_count}, 视频{video_count}")
+
+        return {
+            "success": True,
+            "message": f"成功清理缓存，删除图片 {image_count} 个，视频 {video_count} 个，共 {total} 个文件",
+            "data": {"deleted_count": total, "image_count": image_count, "video_count": video_count}
+        }
+
+    except Exception as e:
+        logger.error(f"[Admin] 清理缓存异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"清理失败: {e}", "code": "CACHE_CLEAR_ERROR"})
+
+
+@router.post("/api/cache/clear/images")
+async def clear_image_cache(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """清理图片缓存"""
+    try:
+        logger.debug("[Admin] 清理图片缓存")
+
+        count = 0
+        if IMAGE_CACHE_DIR.exists():
+            for file_path in IMAGE_CACHE_DIR.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        count += 1
+                    except Exception as e:
+                        logger.error(f"[Admin] 删除失败: {file_path.name}, {e}")
+
+        logger.debug(f"[Admin] 图片缓存清理完成: {count}个")
+        return {"success": True, "message": f"成功清理图片缓存，删除 {count} 个文件", "data": {"deleted_count": count, "type": "images"}}
+
+    except Exception as e:
+        logger.error(f"[Admin] 清理图片缓存异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"清理失败: {e}", "code": "IMAGE_CACHE_CLEAR_ERROR"})
+
+
+@router.post("/api/cache/clear/videos")
+async def clear_video_cache(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """清理视频缓存"""
+    try:
+        logger.debug("[Admin] 清理视频缓存")
+
+        count = 0
+        if VIDEO_CACHE_DIR.exists():
+            for file_path in VIDEO_CACHE_DIR.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        count += 1
+                    except Exception as e:
+                        logger.error(f"[Admin] 删除失败: {file_path.name}, {e}")
+
+        logger.debug(f"[Admin] 视频缓存清理完成: {count}个")
+        return {"success": True, "message": f"成功清理视频缓存，删除 {count} 个文件", "data": {"deleted_count": count, "type": "videos"}}
+
+    except Exception as e:
+        logger.error(f"[Admin] 清理视频缓存异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"清理失败: {e}", "code": "VIDEO_CACHE_CLEAR_ERROR"})
+
+
+@router.get("/api/stats")
+async def get_stats(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取统计信息"""
+    try:
+        logger.debug("[Admin] 开始获取统计信息")
+
+        all_tokens = token_manager.get_tokens()
+        normal_stats = calculate_token_stats(all_tokens.get(TokenType.NORMAL.value, {}), "normal")
+        super_stats = calculate_token_stats(all_tokens.get(TokenType.SUPER.value, {}), "super")
+        total = normal_stats["total"] + super_stats["total"]
+
+        logger.debug(f"[Admin] 统计信息获取成功 - 普通Token: {normal_stats['total']}, Super Token: {super_stats['total']}, 总计: {total}")
+        return {"success": True, "data": {"normal": normal_stats, "super": super_stats, "total": total}}
+
+    except Exception as e:
+        logger.error(f"[Admin] 获取统计信息异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}", "code": "STATS_ERROR"})
+
+
+@router.get("/api/storage/mode")
+async def get_storage_mode(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取存储模式"""
+    try:
+        logger.debug("[Admin] 获取存储模式")
+        import os
+        mode = os.getenv("STORAGE_MODE", "file").upper()
+        return {"success": True, "data": {"mode": mode}}
+    except Exception as e:
+        logger.error(f"[Admin] 获取存储模式异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}", "code": "STORAGE_MODE_ERROR"})
+
+
+@router.post("/api/tokens/tags")
+async def update_token_tags(request: UpdateTokenTagsRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """更新Token标签"""
+    try:
+        logger.debug(f"[Admin] 更新Token标签: {request.token[:10]}..., {request.tags}")
+
+        token_type = validate_token_type(request.token_type)
+        await token_manager.update_token_tags(request.token, token_type, request.tags)
+
+        logger.debug(f"[Admin] Token标签更新成功: {request.token[:10]}...")
+        return {"success": True, "message": "标签更新成功", "tags": request.tags}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[Admin] Token标签更新异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"更新失败: {e}", "code": "UPDATE_TAGS_ERROR"})
+
+
+@router.get("/api/tokens/tags/all")
+async def get_all_tags(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取所有标签"""
+    try:
+        logger.debug("[Admin] 获取所有标签")
+
+        all_tokens = token_manager.get_tokens()
+        tags_set = set()
+
+        for token_type_data in all_tokens.values():
+            for token_data in token_type_data.values():
+                tags = token_data.get("tags", [])
+                if isinstance(tags, list):
+                    tags_set.update(tags)
+
+        tags_list = sorted(list(tags_set))
+        logger.debug(f"[Admin] 标签获取成功: {len(tags_list)}个")
+        return {"success": True, "data": tags_list}
+
+    except Exception as e:
+        logger.error(f"[Admin] 获取标签异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}", "code": "GET_TAGS_ERROR"})
+
+
+@router.post("/api/tokens/note")
+async def update_token_note(request: UpdateTokenNoteRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """更新Token备注"""
+    try:
+        logger.debug(f"[Admin] 更新Token备注: {request.token[:10]}...")
+
+        token_type = validate_token_type(request.token_type)
+        await token_manager.update_token_note(request.token, token_type, request.note)
+
+        logger.debug(f"[Admin] Token备注更新成功: {request.token[:10]}...")
+        return {"success": True, "message": "备注更新成功", "note": request.note}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[Admin] Token备注更新异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"更新失败: {e}", "code": "UPDATE_NOTE_ERROR"})
+
+
+@router.post("/api/tokens/test")
+async def test_token(request: TestTokenRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """测试Token可用性"""
+    try:
+        logger.debug(f"[Admin] 测试Token: {request.token[:10]}...")
+
+        token_type = validate_token_type(request.token_type)
+        auth_token = f"sso-rw={request.token};sso={request.token}"
+
+        result = await token_manager.check_limits(auth_token, "grok-4-fast")
+
+        if result:
+            logger.debug(f"[Admin] Token测试成功: {request.token[:10]}...")
+            return {
+                "success": True,
+                "message": "Token有效",
+                "data": {
+                    "valid": True,
+                    "remaining_queries": result.get("remainingTokens", -1),
+                    "limit": result.get("limit", -1)
+                }
+            }
+        else:
+            logger.warning(f"[Admin] Token测试失败: {request.token[:10]}...")
+
+            all_tokens = token_manager.get_tokens()
+            token_data = all_tokens.get(token_type.value, {}).get(request.token)
+
+            if token_data:
+                if token_data.get("status") == "expired":
+                    return {"success": False, "message": "Token已失效", "data": {"valid": False, "error_type": "expired", "error_code": 401}}
+                cooldown_remaining_ms = _get_cooldown_remaining_ms(token_data)
+                if cooldown_remaining_ms:
+                    return {
+                        "success": False,
+                        "message": "Token处于冷却中",
+                        "data": {
+                            "valid": False,
+                            "error_type": "cooldown",
+                            "error_code": 429,
+                            "cooldown_remaining": (cooldown_remaining_ms + 999) // 1000
+                        }
+                    }
+
+                exhausted = token_data.get("remainingQueries") == 0
+                if token_type == TokenType.SUPER and token_data.get("heavyremainingQueries") == 0:
+                    exhausted = True
+                if exhausted:
+                    return {
+                        "success": False,
+                        "message": "Token额度耗尽",
+                        "data": {"valid": False, "error_type": "exhausted", "error_code": "quota_exhausted"}
+                    }
+                else:
+                    return {"success": False, "message": "服务器被block或网络错误", "data": {"valid": False, "error_type": "blocked", "error_code": 403}}
+            else:
+                return {"success": False, "message": "Token数据异常", "data": {"valid": False, "error_type": "unknown", "error_code": "data_error"}}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[Admin] Token测试异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"测试失败: {e}", "code": "TEST_TOKEN_ERROR"})
+
+
+@router.post("/api/tokens/refresh-all")
+async def refresh_all_tokens(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """一键刷新所有Token的剩余次数（后台执行）"""
+    import asyncio
+    
+    try:
+        # 检查是否已在刷新
+        progress = token_manager.get_refresh_progress()
+        if progress.get("running"):
+            return {
+                "success": False,
+                "message": "刷新任务正在进行中",
+                "data": progress
+            }
+        
+        # 后台启动刷新任务
+        logger.info("[Admin] 启动后台刷新任务")
+        asyncio.create_task(token_manager.refresh_all_limits())
+        
+        # 立即返回，让前端轮询进度
+        return {
+            "success": True,
+            "message": "刷新任务已启动",
+            "data": {"started": True}
+        }
+    except Exception as e:
+        logger.error(f"[Admin] 刷新Token异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"刷新失败: {e}", "code": "REFRESH_ALL_ERROR"})
+
+
+@router.get("/api/tokens/refresh-progress")
+async def get_refresh_progress(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取Token刷新进度"""
+    try:
+        progress = token_manager.get_refresh_progress()
+        return {"success": True, "data": progress}
+    except Exception as e:
+        logger.error(f"[Admin] 获取刷新进度异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取进度失败: {e}"})
+
+
+@router.get("/api/request-stats")
+async def get_request_stats(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取请求统计数据"""
+    try:
+        stats = request_stats.get_stats(hours=24, days=7)
+        return {"success": True, "data": stats}
+    except Exception as e:
+        logger.error(f"[Admin] 获取请求统计异常: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取统计失败: {e}"})
+
+
+# === API Key 管理 ===
+
+class AddKeyRequest(BaseModel):
+    name: str
+
+
+class UpdateKeyNameRequest(BaseModel):
+    key: str
+    name: str
+
+
+class UpdateKeyStatusRequest(BaseModel):
+    key: str
+    is_active: bool
+
+
+class BatchAddKeyRequest(BaseModel):
+    name_prefix: str
+    count: int
+
+
+class BatchDeleteKeyRequest(BaseModel):
+    keys: List[str]
+
+
+class BatchUpdateKeyStatusRequest(BaseModel):
+    keys: List[str]
+    is_active: bool
+
+
+@router.get("/api/keys")
+async def list_keys(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取 Key 列表"""
+    try:
+        from app.services.api_keys import api_key_manager
+        if not api_key_manager._loaded:
+             await api_key_manager.init()
+             
+        keys = api_key_manager.get_all_keys()
+        
+        # 添加默认 Key (可选)
+        global_key = setting.grok_config.get("api_key")
+        result_keys = []
+        
+        # 转换并脱敏
+        for k in keys:
+            result_keys.append({
+                **k,
+                "display_key": f"{k['key'][:6]}...{k['key'][-4:]}"
+            })
+            
+        return {
+            "success": True, 
+            "data": result_keys, 
+            "global_key_set": bool(global_key)
+        }
+    except Exception as e:
+        logger.error(f"[Admin] 获取Key列表失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}"})
+
+
+@router.post("/api/keys/add")
+async def add_key(request: AddKeyRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """添加 Key"""
+    try:
+        from app.services.api_keys import api_key_manager
+        new_key = await api_key_manager.add_key(request.name)
+        return {"success": True, "data": new_key, "message": "Key创建成功"}
+    except Exception as e:
+        logger.error(f"[Admin] 添加Key失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"添加失败: {e}"})
+
+
+@router.post("/api/keys/delete")
+async def delete_key(request: Dict[str, str], _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """删除 Key"""
+    try:
+        from app.services.api_keys import api_key_manager
+        key = request.get("key")
+        if not key:
+             raise ValueError("Key cannot be empty")
+             
+        if await api_key_manager.delete_key(key):
+            return {"success": True, "message": "Key删除成功"}
+        return {"success": False, "message": "Key不存在"}
+    except Exception as e:
+        logger.error(f"[Admin] 删除Key失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"删除失败: {e}"})
+
+
+@router.post("/api/keys/status")
+async def update_key_status(request: UpdateKeyStatusRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """更新 Key 状态"""
+    try:
+        from app.services.api_keys import api_key_manager
+        if await api_key_manager.update_key_status(request.key, request.is_active):
+            return {"success": True, "message": "状态更新成功"}
+        return {"success": False, "message": "Key不存在"}
+    except Exception as e:
+        logger.error(f"[Admin] 更新Key状态失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"更新失败: {e}"})
+        
+
+@router.post("/api/keys/name")
+async def update_key_name(request: UpdateKeyNameRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """更新 Key 备注"""
+    try:
+        from app.services.api_keys import api_key_manager
+        if await api_key_manager.update_key_name(request.key, request.name):
+            return {"success": True, "message": "备注更新成功"}
+        return {"success": False, "message": "Key不存在"}
+    except Exception as e:
+        logger.error(f"[Admin] 更新Key备注失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"更新失败: {e}"})
+
+
+@router.post("/api/keys/batch-add")
+async def batch_add_keys(request: BatchAddKeyRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """批量添加 Key"""
+    try:
+        from app.services.api_keys import api_key_manager
+        new_keys = await api_key_manager.batch_add_keys(request.name_prefix, request.count)
+        return {"success": True, "data": new_keys, "message": f"成功创建 {len(new_keys)} 个 Key"}
+    except Exception as e:
+        logger.error(f"[Admin] 批量添加Key失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"批量添加失败: {e}"})
+
+
+@router.post("/api/keys/batch-delete")
+async def batch_delete_keys(request: BatchDeleteKeyRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """批量删除 Key"""
+    try:
+        from app.services.api_keys import api_key_manager
+        deleted_count = await api_key_manager.batch_delete_keys(request.keys)
+        return {"success": True, "message": f"成功删除 {deleted_count} 个 Key"}
+    except Exception as e:
+        logger.error(f"[Admin] 批量删除Key失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"批量删除失败: {e}"})
+
+
+@router.post("/api/keys/batch-status")
+async def batch_update_key_status(request: BatchUpdateKeyStatusRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """批量更新 Key 状态"""
+    try:
+        from app.services.api_keys import api_key_manager
+        updated_count = await api_key_manager.batch_update_keys_status(request.keys, request.is_active)
+        return {"success": True, "message": f"成功更新 {updated_count} 个 Key 状态"}
+    except Exception as e:
+        logger.error(f"[Admin] 批量更新Key状态失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"批量更新失败: {e}"})
+
+
+# === 日志审计 ===
+
+@router.get("/api/logs")
+async def get_logs(limit: int = 1000, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """获取请求日志"""
+    try:
+        from app.services.request_logger import request_logger
+        logs = await request_logger.get_logs(limit)
+        return {"success": True, "data": logs}
+    except Exception as e:
+        logger.error(f"[Admin] 获取日志失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"获取失败: {e}"})
+
+@router.post("/api/logs/clear")
+async def clear_logs(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """清空日志"""
+    try:
+        from app.services.request_logger import request_logger
+        await request_logger.clear_logs()
+        return {"success": True, "message": "日志已清空"}
+    except Exception as e:
+        logger.error(f"[Admin] 清空日志失败: {e}")
+        raise HTTPException(status_code=500, detail={"error": f"清空失败: {e}"})
+

app/api/v1/chat.py

@@ -0,0 +1,107 @@
+"""聊天API路由 - OpenAI兼容的聊天接口"""
+
+import time
+from fastapi import APIRouter, Depends, HTTPException, Request
+from typing import Optional, Dict, Any
+from fastapi.responses import StreamingResponse
+
+from app.core.auth import auth_manager
+from app.core.exception import GrokApiException
+from app.core.logger import logger
+from app.services.grok.client import GrokClient
+from app.models.openai_schema import OpenAIChatRequest
+from app.services.request_stats import request_stats
+from app.services.request_logger import request_logger
+
+
+router = APIRouter(prefix="/chat", tags=["聊天"])
+
+
+@router.post("/completions", response_model=None)
+async def chat_completions(
+    request: Request,
+    body: OpenAIChatRequest, 
+    auth_info: Dict[str, Any] = Depends(auth_manager.verify)
+):
+    """创建聊天补全（支持流式和非流式）"""
+    start_time = time.time()
+    model = body.model
+    ip = request.client.host
+    key_name = auth_info.get("name", "Unknown")
+    
+    status_code = 200
+    error_msg = ""
+    
+    try:
+        logger.info(f"[Chat] 收到聊天请求: {key_name} @ {ip}")
+
+        # 调用Grok客户端
+        result = await GrokClient.openai_to_grok(body.model_dump())
+        
+        # 记录成功统计
+        await request_stats.record_request(model, success=True)
+        
+        # 流式响应
+        if body.stream:
+            async def stream_wrapper():
+                try:
+                    async for chunk in result:
+                        yield chunk
+                finally:
+                    # 流式结束记录日志
+                    duration = time.time() - start_time
+                    await request_logger.add_log(ip, model, duration, 200, key_name)
+
+            return StreamingResponse(
+                content=stream_wrapper(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no"
+                }
+            )
+        
+        # 非流式响应 - 记录日志
+        duration = time.time() - start_time
+        await request_logger.add_log(ip, model, duration, 200, key_name)
+        return result
+        
+    except GrokApiException as e:
+        status_code = e.status_code or 500
+        error_msg = str(e)
+        await request_stats.record_request(model, success=False)
+        logger.error(f"[Chat] Grok API错误: {e} - 详情: {e.details}")
+        
+        duration = time.time() - start_time
+        await request_logger.add_log(ip, model, duration, status_code, key_name, error=error_msg)
+        
+        raise HTTPException(
+            status_code=status_code,
+            detail={
+                "error": {
+                    "message": error_msg,
+                    "type": e.error_code or "grok_api_error",
+                    "code": e.error_code or "unknown"
+                }
+            }
+        )
+    except Exception as e:
+        status_code = 500
+        error_msg = str(e)
+        await request_stats.record_request(model, success=False)
+        logger.error(f"[Chat] 处理失败: {e}")
+        
+        duration = time.time() - start_time
+        await request_logger.add_log(ip, model, duration, status_code, key_name, error=error_msg)
+        
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": {
+                    "message": "服务器内部错误",
+                    "type": "internal_error",
+                    "code": "internal_server_error"
+                }
+            }
+        )

app/api/v1/images.py

@@ -0,0 +1,53 @@
+"""图片服务API - 提供缓存的图片和视频文件"""
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+from app.core.logger import logger
+from app.services.grok.cache import image_cache_service, video_cache_service
+
+
+router = APIRouter()
+
+
+@router.get("/images/{img_path:path}")
+async def get_image(img_path: str):
+    """获取缓存的图片或视频
+    
+    Args:
+        img_path: 文件路径（格式：users-xxx-generated-xxx-image.jpg）
+    """
+    try:
+        # 转换路径（短横线→斜杠）
+        original_path = "/" + img_path.replace('-', '/')
+
+        # 判断类型
+        is_video = any(original_path.lower().endswith(ext) for ext in ['.mp4', '.webm', '.mov', '.avi'])
+        
+        if is_video:
+            cache_path = video_cache_service.get_cached(original_path)
+            media_type = "video/mp4"
+        else:
+            cache_path = image_cache_service.get_cached(original_path)
+            media_type = "image/jpeg"
+
+        if cache_path and cache_path.exists():
+            logger.debug(f"[MediaAPI] 返回缓存: {cache_path}")
+            return FileResponse(
+                path=str(cache_path),
+                media_type=media_type,
+                headers={
+                    "Cache-Control": "public, max-age=86400",
+                    "Access-Control-Allow-Origin": "*"
+                }
+            )
+
+        # 文件不存在
+        logger.warning(f"[MediaAPI] 未找到: {original_path}")
+        raise HTTPException(status_code=404, detail="File not found")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[MediaAPI] 获取失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

app/api/v1/models.py

@@ -0,0 +1,114 @@
+"""模型接口 - OpenAI兼容的模型列表端点"""
+
+import time
+from typing import Dict, Any, List, Optional
+from fastapi import APIRouter, HTTPException, Depends
+
+from app.models.grok_models import Models
+from app.core.auth import auth_manager
+from app.core.logger import logger
+
+
+router = APIRouter(tags=["模型"])
+
+
+@router.get("/models")
+async def list_models(_: Optional[str] = Depends(auth_manager.verify)) -> Dict[str, Any]:
+    """获取可用模型列表"""
+    try:
+        logger.debug("[Models] 请求模型列表")
+
+        timestamp = int(time.time())
+        model_data: List[Dict[str, Any]] = []
+        
+        for model in Models:
+            model_id = model.value
+            config = Models.get_model_info(model_id)
+            
+            model_info = {
+                "id": model_id,
+                "object": "model", 
+                "created": timestamp,
+                "owned_by": "x-ai",
+                "display_name": config.get("display_name", model_id),
+                "description": config.get("description", ""),
+                "raw_model_path": config.get("raw_model_path", f"xai/{model_id}"),
+                "default_temperature": config.get("default_temperature", 1.0),
+                "default_max_output_tokens": config.get("default_max_output_tokens", 8192),
+                "supported_max_output_tokens": config.get("supported_max_output_tokens", 131072),
+                "default_top_p": config.get("default_top_p", 0.95)
+            }
+            
+            model_data.append(model_info)
+        
+        logger.debug(f"[Models] 返回 {len(model_data)} 个模型")
+        return {"object": "list", "data": model_data}
+        
+    except Exception as e:
+        logger.error(f"[Models] 获取列表失败: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": {
+                    "message": f"Failed to retrieve models: {e}",
+                    "type": "internal_error",
+                    "code": "model_list_error"
+                }
+            }
+        )
+
+
+@router.get("/models/{model_id}")
+async def get_model(model_id: str, _: Optional[str] = Depends(auth_manager.verify)) -> Dict[str, Any]:
+    """获取特定模型信息"""
+    try:
+        logger.debug(f"[Models] 请求模型: {model_id}")
+
+        # 验证模型
+        if not Models.is_valid_model(model_id):
+            logger.warning(f"[Models] 模型不存在: {model_id}")
+            raise HTTPException(
+                status_code=404,
+                detail={
+                    "error": {
+                        "message": f"Model '{model_id}' not found",
+                        "type": "invalid_request_error", 
+                        "code": "model_not_found"
+                    }
+                }
+            )
+        
+        timestamp = int(time.time())
+        config = Models.get_model_info(model_id)
+        
+        model_info = {
+            "id": model_id,
+            "object": "model",
+            "created": timestamp,
+            "owned_by": "x-ai",
+            "display_name": config.get("display_name", model_id),
+            "description": config.get("description", ""),
+            "raw_model_path": config.get("raw_model_path", f"xai/{model_id}"),
+            "default_temperature": config.get("default_temperature", 1.0),
+            "default_max_output_tokens": config.get("default_max_output_tokens", 8192),
+            "supported_max_output_tokens": config.get("supported_max_output_tokens", 131072),
+            "default_top_p": config.get("default_top_p", 0.95)
+        }
+
+        logger.debug(f"[Models] 返回模型: {model_id}")
+        return model_info
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[Models] 获取模型失败: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": {
+                    "message": f"Failed to retrieve model: {e}",
+                    "type": "internal_error",
+                    "code": "model_retrieve_error"
+                }
+            }
+        )

app/core/auth.py

@@ -0,0 +1,66 @@
+"""认证模块 - API令牌验证"""
+
+from typing import Optional, Dict
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+from app.core.config import setting
+from app.core.logger import logger
+from app.services.api_keys import api_key_manager
+
+
+# Bearer安全方案
+security = HTTPBearer(auto_error=False)
+
+
+def _build_error(message: str, code: str = "invalid_token") -> dict:
+    """构建认证错误"""
+    return {
+        "error": {
+            "message": message,
+            "type": "authentication_error",
+            "code": code
+        }
+    }
+
+
+class AuthManager:
+    """认证管理器 - 验证API令牌"""
+
+    @staticmethod
+    async def verify(credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)) -> Dict:
+        """验证令牌，返回 Key 信息"""
+        api_key = setting.grok_config.get("api_key")
+        
+        # 初始化检查
+        if not hasattr(api_key_manager, '_keys'):
+           await api_key_manager.init()
+
+        # 检查令牌
+        if not credentials:
+            # 如果未设置全局Key且没有多Key，则跳过（开发模式）
+            if not api_key and not api_key_manager.get_all_keys():
+                logger.debug("[Auth] 未设置API_KEY，跳过验证")
+                return {"key": None, "name": "Anonymous"}
+                
+            raise HTTPException(
+                status_code=401,
+                detail=_build_error("缺少认证令牌", "missing_token")
+            )
+
+        token = credentials.credentials
+        
+        # 验证令牌 (支持多 Key)
+        key_info = api_key_manager.validate_key(token)
+        
+        if key_info:
+            return key_info
+
+        raise HTTPException(
+            status_code=401,
+            detail=_build_error(f"令牌无效，长度: {len(token)}", "invalid_token")
+        )
+
+
+# 全局实例
+auth_manager = AuthManager()

app/core/config.py

@@ -0,0 +1,203 @@
+"""配置管理器 - 管理应用配置的读写"""
+
+import toml
+from pathlib import Path
+from typing import Dict, Any, Optional, Literal
+
+
+# 默认配置
+DEFAULT_GROK = {
+    "api_key": "",
+    "proxy_url": "",
+    "proxy_pool_url": "",
+    "proxy_pool_interval": 300,
+    "cache_proxy_url": "",
+    "cf_clearance": "",
+    "x_statsig_id": "",
+    "dynamic_statsig": True,
+    "filtered_tags": "xaiartifact,xai:tool_usage_card",
+    "show_thinking": True,
+    "temporary": False,
+    "max_upload_concurrency": 20,
+    "max_request_concurrency": 100,
+    "stream_first_response_timeout": 30,
+    "stream_chunk_timeout": 120,
+    "stream_total_timeout": 600,
+    "retry_status_codes": [401, 429],  # 可重试的HTTP状态码
+}
+
+DEFAULT_GLOBAL = {
+    "base_url": "http://localhost:8000",
+    "log_level": "INFO",
+    "image_mode": "url",
+    "admin_password": "admin",
+    "admin_username": "admin",
+    "image_cache_max_size_mb": 512,
+    "video_cache_max_size_mb": 1024,
+    "max_upload_concurrency": 20,  # 最大并发上传数
+    "max_request_concurrency": 50,  # 最大并发请求数
+    "batch_save_interval": 1.0,  # 批量保存间隔（秒）
+    "batch_save_threshold": 10  # 触发批量保存的变更数阈值
+}
+
+
+class ConfigManager:
+    """配置管理器"""
+
+    def __init__(self) -> None:
+        """初始化配置"""
+        self.config_path: Path = Path(__file__).parents[2] / "data" / "setting.toml"
+        self._storage: Optional[Any] = None
+        self._ensure_exists()
+        self.global_config: Dict[str, Any] = self.load("global")
+        self.grok_config: Dict[str, Any] = self.load("grok")
+    
+    def _ensure_exists(self) -> None:
+        """确保配置存在"""
+        if not self.config_path.exists():
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+            self._create_default()
+    
+    def _create_default(self) -> None:
+        """创建默认配置"""
+        default = {"grok": DEFAULT_GROK.copy(), "global": DEFAULT_GLOBAL.copy()}
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            toml.dump(default, f)
+    
+    def _normalize_proxy(self, proxy: str) -> str:
+        """标准化代理URL（sock5/socks5 → socks5h://）"""
+        if not proxy:
+            return proxy
+
+        proxy = proxy.strip()
+        if proxy.startswith("sock5h://"):
+            proxy = proxy.replace("sock5h://", "socks5h://", 1)
+        if proxy.startswith("sock5://"):
+            proxy = proxy.replace("sock5://", "socks5://", 1)
+        if proxy.startswith("socks5://"):
+            return proxy.replace("socks5://", "socks5h://", 1)
+        return proxy
+    
+    def _normalize_cf(self, cf: str) -> str:
+        """标准化CF Clearance（自动添加前缀）"""
+        if cf and not cf.startswith("cf_clearance="):
+            return f"cf_clearance={cf}"
+        return cf
+
+    def set_storage(self, storage: Any) -> None:
+        """设置存储实例"""
+        self._storage = storage
+
+    def load(self, section: Literal["global", "grok"]) -> Dict[str, Any]:
+        """加载配置节"""
+        try:
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                config = toml.load(f)[section]
+
+            # 标准化Grok配置
+            if section == "grok":
+                if "proxy_url" in config:
+                    config["proxy_url"] = self._normalize_proxy(config["proxy_url"])
+                if "cache_proxy_url" in config:
+                    config["cache_proxy_url"] = self._normalize_proxy(config["cache_proxy_url"])
+                if "cf_clearance" in config:
+                    config["cf_clearance"] = self._normalize_cf(config["cf_clearance"])
+
+            return config
+        except Exception as e:
+            raise Exception(f"[Setting] 配置加载失败: {e}") from e
+    
+    async def reload(self) -> None:
+        """重新加载配置"""
+        self.global_config = self.load("global")
+        self.grok_config = self.load("grok")
+    
+    async def _save_file(self, updates: Dict[str, Dict[str, Any]]) -> None:
+        """保存到文件"""
+        import aiofiles
+        
+        async with aiofiles.open(self.config_path, "r", encoding="utf-8") as f:
+            config = toml.loads(await f.read())
+        
+        for section, data in updates.items():
+            if section in config:
+                config[section].update(data)
+        
+        async with aiofiles.open(self.config_path, "w", encoding="utf-8") as f:
+            await f.write(toml.dumps(config))
+    
+    async def _save_storage(self, updates: Dict[str, Dict[str, Any]]) -> None:
+        """保存到存储"""
+        config = await self._storage.load_config()
+        
+        for section, data in updates.items():
+            if section in config:
+                config[section].update(data)
+        
+        await self._storage.save_config(config)
+    
+    def _prepare_grok(self, grok: Dict[str, Any]) -> Dict[str, Any]:
+        """准备Grok配置（移除前缀）"""
+        processed = grok.copy()
+        if "cf_clearance" in processed:
+            cf = processed["cf_clearance"]
+            if cf and cf.startswith("cf_clearance="):
+                processed["cf_clearance"] = cf.replace("cf_clearance=", "", 1)
+        return processed
+
+    async def save(self, global_config: Optional[Dict[str, Any]] = None, grok_config: Optional[Dict[str, Any]] = None) -> None:
+        """保存配置"""
+        updates = {}
+        
+        if global_config:
+            updates["global"] = global_config
+        if grok_config:
+            updates["grok"] = self._prepare_grok(grok_config)
+        
+        # 选择存储方式
+        if self._storage:
+            await self._save_storage(updates)
+        else:
+            await self._save_file(updates)
+        
+        await self.reload()
+    
+    async def get_proxy_async(self, proxy_type: Literal["service", "cache"] = "service") -> str:
+        """异步获取代理URL（支持代理池）
+        
+        Args:
+            proxy_type: 代理类型
+                - service: 服务代理（client/upload）
+                - cache: 缓存代理（cache）
+        """
+        from app.core.proxy_pool import proxy_pool
+        
+        if proxy_type == "cache":
+            cache_proxy = self.grok_config.get("cache_proxy_url", "")
+            if cache_proxy:
+                return cache_proxy
+        
+        # 从代理池获取
+        return await proxy_pool.get_proxy() or ""
+    
+    def get_proxy(self, proxy_type: Literal["service", "cache"] = "service") -> str:
+        """获取代理URL（同步方法，用于向后兼容）
+        
+        Args:
+            proxy_type: 代理类型
+                - service: 服务代理（client/upload）
+                - cache: 缓存代理（cache）
+        """
+        from app.core.proxy_pool import proxy_pool
+        
+        if proxy_type == "cache":
+            cache_proxy = self.grok_config.get("cache_proxy_url", "")
+            if cache_proxy:
+                return cache_proxy
+        
+        # 返回当前代理（如果是代理池，返回最后一次获取的）
+        return proxy_pool.get_current_proxy() or self.grok_config.get("proxy_url", "")
+
+
+# 全局实例
+setting = ConfigManager()

app/core/exception.py

@@ -0,0 +1,119 @@
+"""异常处理器 - OpenAI兼容的错误响应"""
+
+from fastapi import Request, status
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+
+# HTTP错误映射
+HTTP_ERROR_MAP = {
+    400: ("invalid_request_error", "请求格式错误或缺少必填参数"),
+    401: ("invalid_request_error", "令牌认证失败"),
+    403: ("permission_error", "没有权限访问此资源"),
+    404: ("invalid_request_error", "请求的资源不存在"),
+    429: ("rate_limit_error", "请求频率超出限制，请稍后再试"),
+    500: ("api_error", "内部服务器错误"),
+    503: ("api_error", "服务暂时不可用"),
+}
+
+# Grok错误码映射
+GROK_STATUS_MAP = {
+    "NO_AUTH_TOKEN": status.HTTP_401_UNAUTHORIZED,
+    "INVALID_TOKEN": status.HTTP_401_UNAUTHORIZED,
+    "HTTP_ERROR": status.HTTP_502_BAD_GATEWAY,
+    "NETWORK_ERROR": status.HTTP_503_SERVICE_UNAVAILABLE,
+    "JSON_ERROR": status.HTTP_502_BAD_GATEWAY,
+    "API_ERROR": status.HTTP_502_BAD_GATEWAY,
+    "STREAM_ERROR": status.HTTP_502_BAD_GATEWAY,
+    "NO_RESPONSE": status.HTTP_502_BAD_GATEWAY,
+    "TOKEN_SAVE_ERROR": status.HTTP_500_INTERNAL_SERVER_ERROR,
+    "NO_AVAILABLE_TOKEN": status.HTTP_503_SERVICE_UNAVAILABLE,
+}
+
+GROK_TYPE_MAP = {
+    "NO_AUTH_TOKEN": "authentication_error",
+    "INVALID_TOKEN": "authentication_error",
+    "HTTP_ERROR": "api_error",
+    "NETWORK_ERROR": "api_error",
+    "JSON_ERROR": "api_error",
+    "API_ERROR": "api_error",
+    "STREAM_ERROR": "api_error",
+    "NO_RESPONSE": "api_error",
+    "TOKEN_SAVE_ERROR": "api_error",
+    "NO_AVAILABLE_TOKEN": "api_error",
+}
+
+
+class GrokApiException(Exception):
+    """Grok API业务异常"""
+
+    def __init__(self, message: str, error_code: str = None, details: dict = None, context: dict = None, status_code: int = None):
+        self.message = message
+        self.error_code = error_code
+        self.details = details or {}
+        self.context = context or {}
+        self.status_code = status_code or GROK_STATUS_MAP.get(error_code)
+        super().__init__(self.message)
+
+
+def build_error_response(message: str, error_type: str, code: str = None, param: str = None) -> dict:
+    """构建OpenAI兼容的错误响应"""
+    error = {"message": message, "type": error_type}
+    
+    if code:
+        error["code"] = code
+    if param:
+        error["param"] = param
+
+    return {"error": error}
+
+
+async def http_exception_handler(_: Request, exc: StarletteHTTPException) -> JSONResponse:
+    """处理HTTP异常"""
+    error_type, default_msg = HTTP_ERROR_MAP.get(exc.status_code, ("api_error", str(exc.detail)))
+    message = str(exc.detail) if exc.detail else default_msg
+
+    return JSONResponse(
+        status_code=exc.status_code,
+        content=build_error_response(message, error_type)
+    )
+
+
+async def validation_exception_handler(_: Request, exc: RequestValidationError) -> JSONResponse:
+    """处理验证错误"""
+    errors = exc.errors()
+    param = errors[0]["loc"][-1] if errors and errors[0].get("loc") else None
+    message = errors[0]["msg"] if errors and errors[0].get("msg") else "请求参数错误"
+
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content=build_error_response(message, "invalid_request_error", param=param)
+    )
+
+
+async def grok_api_exception_handler(_: Request, exc: GrokApiException) -> JSONResponse:
+    """处理Grok API异常"""
+    http_status = GROK_STATUS_MAP.get(exc.error_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
+    error_type = GROK_TYPE_MAP.get(exc.error_code, "api_error")
+
+    return JSONResponse(
+        status_code=http_status,
+        content=build_error_response(exc.message, error_type, exc.error_code)
+    )
+
+
+async def global_exception_handler(_: Request, exc: Exception) -> JSONResponse:
+    """处理未捕获异常"""
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content=build_error_response("服务器遇到意外错误，请重试", "api_error")
+    )
+
+
+def register_exception_handlers(app) -> None:
+    """注册异常处理器"""
+    app.add_exception_handler(StarletteHTTPException, http_exception_handler)
+    app.add_exception_handler(RequestValidationError, validation_exception_handler)
+    app.add_exception_handler(GrokApiException, grok_api_exception_handler)
+    app.add_exception_handler(Exception, global_exception_handler)

app/core/logger.py

@@ -0,0 +1,130 @@
+"""全局日志模块 - 单例模式的日志管理器"""
+
+import sys
+import logging
+from pathlib import Path
+from logging.handlers import RotatingFileHandler
+
+from app.core.config import setting
+
+
+# 过滤模式
+FILTER_PATTERNS = [
+    "chunk: b'",  # SSE原始字节
+    "Got event:",  # SSE事件
+    "Closing",  # SSE关闭
+]
+
+
+class MCPLogFilter(logging.Filter):
+    """MCP日志过滤器 - 过滤大量数据的DEBUG日志"""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """过滤日志"""
+        # 过滤SSE的DEBUG日志
+        if record.name == "sse_starlette.sse" and record.levelno == logging.DEBUG:
+            msg = record.getMessage()
+            return not any(p in msg for p in FILTER_PATTERNS)
+
+        # 过滤MCP streamable_http的DEBUG日志
+        if "mcp.server.streamable_http" in record.name and record.levelno == logging.DEBUG:
+            return False
+
+        return True
+
+
+class LoggerManager:
+    """日志管理器（单例）"""
+
+    _instance = None
+    _initialized = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        """初始化日志系统"""
+        if LoggerManager._initialized:
+            return
+
+        # 配置
+        log_dir = Path(__file__).parents[2] / "logs"
+        log_dir.mkdir(exist_ok=True)
+        log_level = setting.global_config.get("log_level", "INFO").upper()
+        log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        log_file = log_dir / "app.log"
+
+        # 根日志器
+        self.logger = logging.getLogger()
+        self.logger.setLevel(log_level)
+
+        # 避免重复添加
+        if self.logger.handlers:
+            return
+
+        # 格式器和过滤器
+        formatter = logging.Formatter(log_format)
+        mcp_filter = MCPLogFilter()
+
+        # 控制台处理器
+        console = logging.StreamHandler(sys.stdout)
+        console.setLevel(log_level)
+        console.setFormatter(formatter)
+        console.addFilter(mcp_filter)
+
+        # 文件处理器（10MB，5个备份）
+        file_handler = RotatingFileHandler(
+            log_file, maxBytes=10*1024*1024, backupCount=5, encoding="utf-8"
+        )
+        file_handler.setLevel(log_level)
+        file_handler.setFormatter(formatter)
+        file_handler.addFilter(mcp_filter)
+
+        # 添加处理器
+        self.logger.addHandler(console)
+        self.logger.addHandler(file_handler)
+
+        # 配置第三方库
+        self._configure_third_party()
+
+        LoggerManager._initialized = True
+    
+    def _configure_third_party(self):
+        """配置第三方库日志级别"""
+        config = {
+            "asyncio": logging.WARNING,
+            "uvicorn": logging.INFO,
+            "fastapi": logging.INFO,
+            "aiomysql": logging.WARNING,
+            "mcp": logging.CRITICAL,
+            "fastmcp": logging.CRITICAL,
+        }
+        
+        for name, level in config.items():
+            logging.getLogger(name).setLevel(level)
+
+    def debug(self, msg: str) -> None:
+        """调试日志"""
+        self.logger.debug(msg)
+
+    def info(self, msg: str) -> None:
+        """信息日志"""
+        self.logger.info(msg)
+
+    def warning(self, msg: str) -> None:
+        """警告日志"""
+        self.logger.warning(msg)
+
+    def error(self, msg: str) -> None:
+        """错误日志"""
+        self.logger.error(msg)
+
+    def critical(self, msg: str) -> None:
+        """严重错误日志"""
+        self.logger.critical(msg)
+
+
+# 全局实例
+logger = LoggerManager()

app/core/proxy_pool.py

@@ -0,0 +1,170 @@
+"""代理池管理器 - 从URL动态获取代理IP"""
+
+import asyncio
+import aiohttp
+import time
+from typing import Optional, List
+from app.core.logger import logger
+
+
+class ProxyPool:
+    """代理池管理器"""
+    
+    def __init__(self):
+        self._pool_url: Optional[str] = None
+        self._static_proxy: Optional[str] = None
+        self._current_proxy: Optional[str] = None
+        self._last_fetch_time: float = 0
+        self._fetch_interval: int = 300  # 5分钟刷新一次
+        self._enabled: bool = False
+        self._lock = asyncio.Lock()
+    
+    def configure(self, proxy_url: str, proxy_pool_url: str = "", proxy_pool_interval: int = 300):
+        """配置代理池
+        
+        Args:
+            proxy_url: 静态代理URL（socks5h://xxx 或 http://xxx）
+            proxy_pool_url: 代理池API URL，返回单个代理地址
+            proxy_pool_interval: 代理池刷新间隔（秒）
+        """
+        self._static_proxy = self._normalize_proxy(proxy_url) if proxy_url else None
+        pool_url = proxy_pool_url.strip() if proxy_pool_url else None
+        if pool_url and self._looks_like_proxy_url(pool_url):
+            normalized_proxy = self._normalize_proxy(pool_url)
+            if not self._static_proxy:
+                self._static_proxy = normalized_proxy
+                logger.warning("[ProxyPool] proxy_pool_url看起来是代理地址，已作为静态代理使用，请改用proxy_url")
+            else:
+                logger.warning("[ProxyPool] proxy_pool_url看起来是代理地址，已忽略（使用proxy_url）")
+            pool_url = None
+        self._pool_url = pool_url
+        self._fetch_interval = proxy_pool_interval
+        self._enabled = bool(self._pool_url)
+        
+        if self._enabled:
+            logger.info(f"[ProxyPool] 代理池已启用: {self._pool_url}, 刷新间隔: {self._fetch_interval}s")
+        elif self._static_proxy:
+            logger.info(f"[ProxyPool] 使用静态代理: {self._static_proxy}")
+            self._current_proxy = self._static_proxy
+        else:
+            logger.info("[ProxyPool] 未配置代理")
+    
+    async def get_proxy(self) -> Optional[str]:
+        """获取代理地址
+        
+        Returns:
+            代理URL或None
+        """
+        # 如果未启用代理池，返回静态代理
+        if not self._enabled:
+            return self._static_proxy
+        
+        # 检查是否需要刷新
+        now = time.time()
+        if not self._current_proxy or (now - self._last_fetch_time) >= self._fetch_interval:
+            async with self._lock:
+                # 双重检查
+                if not self._current_proxy or (now - self._last_fetch_time) >= self._fetch_interval:
+                    await self._fetch_proxy()
+        
+        return self._current_proxy
+    
+    async def force_refresh(self) -> Optional[str]:
+        """强制刷新代理（用于403错误重试）
+        
+        Returns:
+            新的代理URL或None
+        """
+        if not self._enabled:
+            return self._static_proxy
+        
+        async with self._lock:
+            await self._fetch_proxy()
+        
+        return self._current_proxy
+    
+    async def _fetch_proxy(self):
+        """从代理池URL获取新的代理"""
+        try:
+            logger.debug(f"[ProxyPool] 正在从代理池获取新代理: {self._pool_url}")
+            
+            timeout = aiohttp.ClientTimeout(total=10)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.get(self._pool_url) as response:
+                    if response.status == 200:
+                        proxy_text = await response.text()
+                        proxy = self._normalize_proxy(proxy_text.strip())
+                        
+                        # 验证代理格式
+                        if self._validate_proxy(proxy):
+                            self._current_proxy = proxy
+                            self._last_fetch_time = time.time()
+                            logger.info(f"[ProxyPool] 成功获取新代理: {proxy}")
+                        else:
+                            logger.error(f"[ProxyPool] 代理格式无效: {proxy}")
+                            # 降级到静态代理
+                            if not self._current_proxy:
+                                self._current_proxy = self._static_proxy
+                    else:
+                        logger.error(f"[ProxyPool] 获取代理失败: HTTP {response.status}")
+                        # 降级到静态代理
+                        if not self._current_proxy:
+                            self._current_proxy = self._static_proxy
+        
+        except asyncio.TimeoutError:
+            logger.error("[ProxyPool] 获取代理超时")
+            if not self._current_proxy:
+                self._current_proxy = self._static_proxy
+        
+        except Exception as e:
+            logger.error(f"[ProxyPool] 获取代理异常: {e}")
+            # 降级到静态代理
+            if not self._current_proxy:
+                self._current_proxy = self._static_proxy
+    
+    def _validate_proxy(self, proxy: str) -> bool:
+        """验证代理格式
+        
+        Args:
+            proxy: 代理URL
+        
+        Returns:
+            是否有效
+        """
+        if not proxy:
+            return False
+        
+        # 支持的协议
+        valid_protocols = ['http://', 'https://', 'socks5://', 'socks5h://']
+        
+        return any(proxy.startswith(proto) for proto in valid_protocols)
+
+    def _normalize_proxy(self, proxy: str) -> str:
+        """标准化代理URL（sock5/socks5 → socks5h://）"""
+        if not proxy:
+            return proxy
+
+        proxy = proxy.strip()
+        if proxy.startswith("sock5h://"):
+            proxy = proxy.replace("sock5h://", "socks5h://", 1)
+        if proxy.startswith("sock5://"):
+            proxy = proxy.replace("sock5://", "socks5://", 1)
+        if proxy.startswith("socks5://"):
+            return proxy.replace("socks5://", "socks5h://", 1)
+        return proxy
+
+    def _looks_like_proxy_url(self, url: str) -> bool:
+        """判断URL是否像代理地址（避免误把代理池API当代理）"""
+        return url.startswith(("sock5://", "sock5h://", "socks5://", "socks5h://"))
+    
+    def get_current_proxy(self) -> Optional[str]:
+        """获取当前使用的代理（同步方法）
+        
+        Returns:
+            当前代理URL或None
+        """
+        return self._current_proxy or self._static_proxy
+
+
+# 全局代理池实例
+proxy_pool = ProxyPool()

app/core/storage.py

@@ -0,0 +1,445 @@
+"""存储抽象层 - 支持文件、MySQL和Redis存储"""
+
+import os
+import orjson
+import toml
+import asyncio
+import warnings
+import aiofiles
+from pathlib import Path
+from typing import Dict, Any, Optional, Literal
+from abc import ABC, abstractmethod
+from urllib.parse import urlparse, unquote
+
+from app.core.logger import logger
+
+
+StorageMode = Literal["file", "mysql", "redis"]
+
+
+class BaseStorage(ABC):
+    """存储基类"""
+
+    @abstractmethod
+    async def init_db(self) -> None:
+        """初始化数据库"""
+        pass
+
+    @abstractmethod
+    async def load_tokens(self) -> Dict[str, Any]:
+        """加载token数据"""
+        pass
+
+    @abstractmethod
+    async def save_tokens(self, data: Dict[str, Any]) -> None:
+        """保存token数据"""
+        pass
+
+    @abstractmethod
+    async def load_config(self) -> Dict[str, Any]:
+        """加载配置数据"""
+        pass
+
+    @abstractmethod
+    async def save_config(self, data: Dict[str, Any]) -> None:
+        """保存配置数据"""
+        pass
+
+
+class FileStorage(BaseStorage):
+    """文件存储"""
+
+    def __init__(self, data_dir: Path):
+        self.data_dir = data_dir
+        self.token_file = data_dir / "token.json"
+        self.config_file = data_dir / "setting.toml"
+        self._token_lock = asyncio.Lock()
+        self._config_lock = asyncio.Lock()
+
+    async def init_db(self) -> None:
+        """初始化文件存储"""
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+        if not self.token_file.exists():
+            await self._write(self.token_file, orjson.dumps({"sso": {}, "ssoSuper": {}}, option=orjson.OPT_INDENT_2).decode())
+            logger.info("[Storage] 创建token文件")
+
+        if not self.config_file.exists():
+            default = {
+                "global": {"api_keys": [], "admin_username": "admin", "admin_password": "admin"},
+                "grok": {"proxy_url": "", "cf_clearance": "", "x_statsig_id": ""}
+            }
+            await self._write(self.config_file, toml.dumps(default))
+            logger.info("[Storage] 创建配置文件")
+
+    async def _read(self, path: Path) -> str:
+        """读取文件"""
+        async with aiofiles.open(path, "r", encoding="utf-8") as f:
+            return await f.read()
+
+    async def _write(self, path: Path, content: str) -> None:
+        """写入文件"""
+        async with aiofiles.open(path, "w", encoding="utf-8") as f:
+            await f.write(content)
+
+    async def _load_json(self, path: Path, default: Dict, lock: asyncio.Lock) -> Dict[str, Any]:
+        """加载JSON"""
+        try:
+            async with lock:
+                if not path.exists():
+                    return default
+                return orjson.loads(await self._read(path))
+        except Exception as e:
+            logger.error(f"[Storage] 加载{path.name}失败: {e}")
+            return default
+
+    async def _save_json(self, path: Path, data: Dict, lock: asyncio.Lock) -> None:
+        """保存JSON"""
+        try:
+            async with lock:
+                await self._write(path, orjson.dumps(data, option=orjson.OPT_INDENT_2).decode())
+        except Exception as e:
+            logger.error(f"[Storage] 保存{path.name}失败: {e}")
+            raise
+
+    async def _load_toml(self, path: Path, default: Dict, lock: asyncio.Lock) -> Dict[str, Any]:
+        """加载TOML"""
+        try:
+            async with lock:
+                if not path.exists():
+                    return default
+                return toml.loads(await self._read(path))
+        except Exception as e:
+            logger.error(f"[Storage] 加载{path.name}失败: {e}")
+            return default
+
+    async def _save_toml(self, path: Path, data: Dict, lock: asyncio.Lock) -> None:
+        """保存TOML"""
+        try:
+            async with lock:
+                await self._write(path, toml.dumps(data))
+        except Exception as e:
+            logger.error(f"[Storage] 保存{path.name}失败: {e}")
+            raise
+
+    async def load_tokens(self) -> Dict[str, Any]:
+        """加载token"""
+        return await self._load_json(self.token_file, {"sso": {}, "ssoSuper": {}}, self._token_lock)
+
+    async def save_tokens(self, data: Dict[str, Any]) -> None:
+        """保存token"""
+        await self._save_json(self.token_file, data, self._token_lock)
+
+    async def load_config(self) -> Dict[str, Any]:
+        """加载配置"""
+        return await self._load_toml(self.config_file, {"global": {}, "grok": {}}, self._config_lock)
+
+    async def save_config(self, data: Dict[str, Any]) -> None:
+        """保存配置"""
+        await self._save_toml(self.config_file, data, self._config_lock)
+
+
+class MysqlStorage(BaseStorage):
+    """MySQL存储"""
+
+    def __init__(self, database_url: str, data_dir: Path):
+        self.database_url = database_url
+        self.data_dir = data_dir
+        self._pool = None
+        self._file = FileStorage(data_dir)
+
+    async def init_db(self) -> None:
+        """初始化MySQL"""
+        try:
+            import aiomysql
+            parsed = self._parse_url(self.database_url)
+            logger.info(f"[Storage] MySQL: {parsed['user']}@{parsed['host']}:{parsed['port']}/{parsed['db']}")
+
+            await self._create_db(parsed)
+            self._pool = await aiomysql.create_pool(
+                host=parsed['host'], port=parsed['port'], user=parsed['user'],
+                password=parsed['password'], db=parsed['db'], charset="utf8mb4",
+                autocommit=True, maxsize=10
+            )
+            await self._create_tables()
+            await self._file.init_db()
+            await self._sync_data()
+
+        except ImportError:
+            raise Exception("aiomysql未安装")
+        except Exception as e:
+            logger.error(f"[Storage] MySQL初始化失败: {e}")
+            raise
+
+    def _parse_url(self, url: str) -> Dict[str, Any]:
+        """解析URL"""
+        p = urlparse(url)
+        return {
+            'user': unquote(p.username) if p.username else "",
+            'password': unquote(p.password) if p.password else "",
+            'host': p.hostname,
+            'port': p.port or 3306,
+            'db': p.path[1:] if p.path else "grok2api"
+        }
+
+    async def _create_db(self, parsed: Dict) -> None:
+        """创建数据库"""
+        import aiomysql
+        pool = await aiomysql.create_pool(
+            host=parsed['host'], port=parsed['port'], user=parsed['user'],
+            password=parsed['password'], charset="utf8mb4", autocommit=True, maxsize=1
+        )
+
+        try:
+            async with pool.acquire() as conn:
+                async with conn.cursor() as cursor:
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings('ignore', message='.*database exists')
+                        await cursor.execute(
+                            f"CREATE DATABASE IF NOT EXISTS `{parsed['db']}` "
+                            f"CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci"
+                        )
+                    logger.info(f"[Storage] 数据库 '{parsed['db']}' 就绪")
+        finally:
+            pool.close()
+            await pool.wait_closed()
+
+    async def _create_tables(self) -> None:
+        """创建表"""
+        tables = {
+            "grok_tokens": """
+                CREATE TABLE IF NOT EXISTS grok_tokens (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    data JSON NOT NULL,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+            """,
+            "grok_settings": """
+                CREATE TABLE IF NOT EXISTS grok_settings (
+                    id INT AUTO_INCREMENT PRIMARY KEY,
+                    data JSON NOT NULL,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+            """
+        }
+
+        async with self._pool.acquire() as conn:
+            async with conn.cursor() as cursor:
+                with warnings.catch_warnings():
+                    warnings.filterwarnings('ignore', message='.*already exists')
+                    for sql in tables.values():
+                        await cursor.execute(sql)
+                logger.info("[Storage] MySQL表就绪")
+
+    async def _sync_data(self) -> None:
+        """同步数据"""
+        try:
+            for table, key in [("grok_tokens", "sso"), ("grok_settings", "global")]:
+                data = await self._load_db(table)
+                if data:
+                    if table == "grok_tokens":
+                        await self._file.save_tokens(data)
+                    else:
+                        await self._file.save_config(data)
+                    logger.info(f"[Storage] {table.split('_')[1]}数据已从DB同步")
+                else:
+                    file_data = await (self._file.load_tokens() if table == "grok_tokens" else self._file.load_config())
+                    if file_data.get(key) or (table == "grok_tokens" and file_data.get("ssoSuper")):
+                        await self._save_db(table, file_data)
+                        logger.info(f"[Storage] {table.split('_')[1]}数据已初始化到DB")
+        except Exception as e:
+            logger.warning(f"[Storage] 同步失败: {e}")
+
+    async def _load_db(self, table: str) -> Optional[Dict]:
+        """从DB加载"""
+        try:
+            async with self._pool.acquire() as conn:
+                async with conn.cursor() as cursor:
+                    await cursor.execute(f"SELECT data FROM {table} ORDER BY id DESC LIMIT 1")
+                    result = await cursor.fetchone()
+                    return orjson.loads(result[0]) if result else None
+        except Exception as e:
+            logger.error(f"[Storage] 加载{table}失败: {e}")
+            return None
+
+    async def _save_db(self, table: str, data: Dict) -> None:
+        """保存到DB"""
+        try:
+            async with self._pool.acquire() as conn:
+                async with conn.cursor() as cursor:
+                    json_data = orjson.dumps(data).decode()
+                    await cursor.execute(f"SELECT id FROM {table} ORDER BY id DESC LIMIT 1")
+                    result = await cursor.fetchone()
+
+                    if result:
+                        await cursor.execute(f"UPDATE {table} SET data = %s WHERE id = %s", (json_data, result[0]))
+                    else:
+                        await cursor.execute(f"INSERT INTO {table} (data) VALUES (%s)", (json_data,))
+        except Exception as e:
+            logger.error(f"[Storage] 保存{table}失败: {e}")
+            raise
+
+    async def load_tokens(self) -> Dict[str, Any]:
+        """加载token"""
+        return await self._file.load_tokens()
+
+    async def save_tokens(self, data: Dict[str, Any]) -> None:
+        """保存token"""
+        await self._file.save_tokens(data)
+        await self._save_db("grok_tokens", data)
+
+    async def load_config(self) -> Dict[str, Any]:
+        """加载配置"""
+        return await self._file.load_config()
+
+    async def save_config(self, data: Dict[str, Any]) -> None:
+        """保存配置"""
+        await self._file.save_config(data)
+        await self._save_db("grok_settings", data)
+
+    async def close(self) -> None:
+        """关闭连接"""
+        if self._pool:
+            self._pool.close()
+            await self._pool.wait_closed()
+            logger.info("[Storage] MySQL已关闭")
+
+
+class RedisStorage(BaseStorage):
+    """Redis存储"""
+
+    def __init__(self, redis_url: str, data_dir: Path):
+        self.redis_url = redis_url
+        self.data_dir = data_dir
+        self._redis = None
+        self._file = FileStorage(data_dir)
+
+    async def init_db(self) -> None:
+        """初始化Redis"""
+        try:
+            import redis.asyncio as aioredis
+            parsed = urlparse(self.redis_url)
+            db = int(parsed.path.lstrip('/')) if parsed.path and parsed.path != '/' else 0
+            logger.info(f"[Storage] Redis: {parsed.hostname}:{parsed.port or 6379}/{db}")
+
+            self._redis = aioredis.Redis.from_url(
+                self.redis_url, encoding="utf-8", decode_responses=True
+            )
+
+            await self._redis.ping()
+            logger.info(f"[Storage] Redis连接成功")
+
+            await self._file.init_db()
+            await self._sync_data()
+
+        except ImportError:
+            raise Exception("redis未安装")
+        except Exception as e:
+            logger.error(f"[Storage] Redis初始化失败: {e}")
+            raise
+
+    async def _sync_data(self) -> None:
+        """同步数据"""
+        try:
+            for key, file_func, key_name in [
+                ("grok:tokens", self._file.load_tokens, "sso"),
+                ("grok:settings", self._file.load_config, "global")
+            ]:
+                data = await self._redis.get(key)
+                if data:
+                    parsed = orjson.loads(data)
+                    if key == "grok:tokens":
+                        await self._file.save_tokens(parsed)
+                    else:
+                        await self._file.save_config(parsed)
+                    logger.info(f"[Storage] {key.split(':')[1]}数据已从Redis同步")
+                else:
+                    file_data = await file_func()
+                    if file_data.get(key_name) or (key == "grok:tokens" and file_data.get("ssoSuper")):
+                        await self._redis.set(key, orjson.dumps(file_data).decode())
+                        logger.info(f"[Storage] {key.split(':')[1]}数据已初始化到Redis")
+        except Exception as e:
+            logger.warning(f"[Storage] 同步失败: {e}")
+
+    async def _save_redis(self, key: str, data: Dict) -> None:
+        """保存到Redis"""
+        try:
+            await self._redis.set(key, orjson.dumps(data).decode())
+        except Exception as e:
+            logger.error(f"[Storage] 保存Redis失败: {e}")
+            raise
+
+    async def load_tokens(self) -> Dict[str, Any]:
+        """加载token"""
+        return await self._file.load_tokens()
+
+    async def save_tokens(self, data: Dict[str, Any]) -> None:
+        """保存token"""
+        await self._file.save_tokens(data)
+        await self._save_redis("grok:tokens", data)
+
+    async def load_config(self) -> Dict[str, Any]:
+        """加载配置"""
+        return await self._file.load_config()
+
+    async def save_config(self, data: Dict[str, Any]) -> None:
+        """保存配置"""
+        await self._file.save_config(data)
+        await self._save_redis("grok:settings", data)
+
+    async def close(self) -> None:
+        """关闭连接"""
+        if self._redis:
+            await self._redis.close()
+            logger.info("[Storage] Redis已关闭")
+
+
+class StorageManager:
+    """存储管理器（单例）"""
+
+    _instance: Optional['StorageManager'] = None
+    _storage: Optional[BaseStorage] = None
+    _initialized: bool = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    async def init(self) -> None:
+        """初始化存储"""
+        if self._initialized:
+            return
+
+        mode = os.getenv("STORAGE_MODE", "file").lower()
+        url = os.getenv("DATABASE_URL", "")
+        data_dir = Path(__file__).parents[2] / "data"
+
+        classes = {"mysql": MysqlStorage, "redis": RedisStorage, "file": FileStorage}
+
+        if mode in ("mysql", "redis") and not url:
+            raise ValueError(f"{mode.upper()}模式需要DATABASE_URL")
+
+        storage_class = classes.get(mode, FileStorage)
+        self._storage = storage_class(url, data_dir) if mode != "file" else storage_class(data_dir)
+
+        await self._storage.init_db()
+        self._initialized = True
+        logger.info(f"[Storage] 使用{mode}模式")
+
+    def get_storage(self) -> BaseStorage:
+        """获取存储实例"""
+        if not self._initialized or not self._storage:
+            raise RuntimeError("StorageManager未初始化")
+        return self._storage
+
+    async def close(self) -> None:
+        """关闭存储"""
+        if self._storage and hasattr(self._storage, 'close'):
+            await self._storage.close()
+
+
+# 全局实例
+storage_manager = StorageManager()

app/models/grok_models.py

@@ -0,0 +1,163 @@
+"""Grok 模型配置和枚举定义"""
+
+from enum import Enum
+from typing import Dict, Any, Tuple
+
+
+# 模型配置
+_MODEL_CONFIG: Dict[str, Dict[str, Any]] = {
+    "grok-3-fast": {
+        "grok_model": ("grok-3", "MODEL_MODE_FAST"),
+        "rate_limit_model": "grok-3",
+        "cost": {"type": "low_cost", "multiplier": 1, "description": "计1次调用"},
+        "requires_super": False,
+        "display_name": "Grok 3 Fast",
+        "description": "Fast and efficient Grok 3 model",
+        "raw_model_path": "xai/grok-3",
+        "default_temperature": 1.0,
+        "default_max_output_tokens": 8192,
+        "supported_max_output_tokens": 131072,
+        "default_top_p": 0.95
+    },
+    "grok-4-fast": {
+        "grok_model": ("grok-4-mini-thinking-tahoe", "MODEL_MODE_GROK_4_MINI_THINKING"),
+        "rate_limit_model": "grok-4-mini-thinking-tahoe",
+        "cost": {"type": "low_cost", "multiplier": 1, "description": "计1次调用"},
+        "requires_super": False,
+        "display_name": "Grok 4 Fast",
+        "description": "Fast version of Grok 4 with mini thinking capabilities",
+        "raw_model_path": "xai/grok-4-mini-thinking-tahoe",
+        "default_temperature": 1.0,
+        "default_max_output_tokens": 8192,
+        "supported_max_output_tokens": 131072,
+        "default_top_p": 0.95
+    },
+    "grok-4-fast-expert": {
+        "grok_model": ("grok-4-mini-thinking-tahoe", "MODEL_MODE_EXPERT"),
+        "rate_limit_model": "grok-4-mini-thinking-tahoe",
+        "cost": {"type": "high_cost", "multiplier": 4, "description": "计4次调用"},
+        "requires_super": False,
+        "display_name": "Grok 4 Fast Expert",
+        "description": "Expert mode of Grok 4 Fast with enhanced reasoning",
+        "raw_model_path": "xai/grok-4-mini-thinking-tahoe",
+        "default_temperature": 1.0,
+        "default_max_output_tokens": 32768,
+        "supported_max_output_tokens": 131072,
+        "default_top_p": 0.95
+    },
+    "grok-4-expert": {
+        "grok_model": ("grok-4", "MODEL_MODE_EXPERT"),
+        "rate_limit_model": "grok-4",
+        "cost": {"type": "high_cost", "multiplier": 4, "description": "计4次调用"},
+        "requires_super": False,
+        "display_name": "Grok 4 Expert",
+        "description": "Full Grok 4 model with expert mode capabilities",
+        "raw_model_path": "xai/grok-4",
+        "default_temperature": 1.0,
+        "default_max_output_tokens": 32768,
+        "supported_max_output_tokens": 131072,
+        "default_top_p": 0.95
+    },
+    "grok-4-heavy": {
+        "grok_model": ("grok-4-heavy", "MODEL_MODE_HEAVY"),
+        "rate_limit_model": "grok-4-heavy",
+        "cost": {"type": "independent", "multiplier": 1, "description": "独立计费，只有Super用户可用"},
+        "requires_super": True,
+        "display_name": "Grok 4 Heavy",
+        "description": "Most powerful Grok 4 model with heavy computational capabilities. Requires Super Token for access.",
+        "raw_model_path": "xai/grok-4-heavy",
+        "default_temperature": 1.0,
+        "default_max_output_tokens": 65536,
+        "supported_max_output_tokens": 131072,
+        "default_top_p": 0.95
+    },
+    "grok-4.1": {
+        "grok_model": ("grok-4-1-non-thinking-w-tool", "MODEL_MODE_GROK_4_1"),
+        "rate_limit_model": "grok-4-1-non-thinking-w-tool",
+        "cost": {"type": "low_cost", "multiplier": 1, "description": "计1次调用"},
+        "requires_super": False,
+        "display_name": "Grok 4.1",
+        "description": "Latest Grok 4.1 model with tool capabilities",
+        "raw_model_path": "xai/grok-4-1-non-thinking-w-tool",
+        "default_temperature": 1.0,
+        "default_max_output_tokens": 8192,
+        "supported_max_output_tokens": 131072,
+        "default_top_p": 0.95
+    },
+    "grok-4.1-thinking": {
+        "grok_model": ("grok-4-1-thinking-1108b", "MODEL_MODE_AUTO"),
+        "rate_limit_model": "grok-4-1-thinking-1108b",
+        "cost": {"type": "high_cost", "multiplier": 1, "description": "计1次调用"},
+        "requires_super": False,
+        "display_name": "Grok 4.1 Thinking",
+        "description": "Grok 4.1 model with advanced thinking and tool capabilities",
+        "raw_model_path": "xai/grok-4-1-thinking-1108b",
+        "default_temperature": 1.0,
+        "default_max_output_tokens": 32768,
+        "supported_max_output_tokens": 131072,
+        "default_top_p": 0.95
+    },
+    "grok-imagine-0.9": {
+        "grok_model": ("grok-3", "MODEL_MODE_FAST"),
+        "rate_limit_model": "grok-3",
+        "cost": {"type": "low_cost", "multiplier": 1, "description": "计1次调用"},
+        "requires_super": False,
+        "display_name": "Grok Imagine 0.9",
+        "description": "Image and video generation model. Supports text-to-image and image-to-video generation.",
+        "raw_model_path": "xai/grok-imagine-0.9",
+        "default_temperature": 1.0,
+        "default_max_output_tokens": 8192,
+        "supported_max_output_tokens": 131072,
+        "default_top_p": 0.95,
+        "is_video_model": True
+    }
+}
+
+
+class TokenType(Enum):
+    """Token类型"""
+    NORMAL = "ssoNormal"
+    SUPER = "ssoSuper"
+
+
+class Models(Enum):
+    """支持的模型"""
+    GROK_3_FAST = "grok-3-fast"
+    GROK_4_1 = "grok-4.1"
+    GROK_4_1_THINKING = "grok-4.1-thinking"
+    GROK_4_FAST = "grok-4-fast"
+    GROK_4_FAST_EXPERT = "grok-4-fast-expert"
+    GROK_4_EXPERT = "grok-4-expert"
+    GROK_4_HEAVY = "grok-4-heavy"
+    GROK_IMAGINE_0_9 = "grok-imagine-0.9"
+
+    @classmethod
+    def get_model_info(cls, model: str) -> Dict[str, Any]:
+        """获取模型配置"""
+        return _MODEL_CONFIG.get(model, {})
+
+    @classmethod
+    def is_valid_model(cls, model: str) -> bool:
+        """检查模型是否有效"""
+        return model in _MODEL_CONFIG
+    
+    @classmethod
+    def to_grok(cls, model: str) -> Tuple[str, str]:
+        """转换为Grok内部模型名和模式
+        
+        Returns:
+            (模型名, 模式类型) 元组
+        """
+        config = _MODEL_CONFIG.get(model)
+        return config["grok_model"] if config else (model, "MODEL_MODE_FAST")
+    
+    @classmethod
+    def to_rate_limit(cls, model: str) -> str:
+        """转换为速率限制模型名"""
+        config = _MODEL_CONFIG.get(model)
+        return config["rate_limit_model"] if config else model
+    
+    @classmethod
+    def get_all_model_names(cls) -> list[str]:
+        """获取所有模型名称"""
+        return list(_MODEL_CONFIG.keys())

app/models/openai_schema.py

@@ -0,0 +1,103 @@
+"""OpenAI 请求-响应模型定义"""
+
+from fastapi import HTTPException
+from typing import Optional, List, Union, Dict, Any
+from pydantic import BaseModel, Field, field_validator
+
+from app.models.grok_models import Models
+
+
+class OpenAIChatRequest(BaseModel):
+    """OpenAI聊天请求"""
+
+    model: str = Field(..., description="模型名称", min_length=1)
+    messages: List[Dict[str, Any]] = Field(..., description="消息列表", min_length=1)
+    stream: bool = Field(False, description="流式响应")
+    temperature: Optional[float] = Field(0.7, ge=0, le=2, description="采样温度")
+    max_tokens: Optional[int] = Field(None, ge=1, le=100000, description="最大Token数")
+    top_p: Optional[float] = Field(1.0, ge=0, le=1, description="采样参数")
+
+    @classmethod
+    @field_validator('messages')
+    def validate_messages(cls, v):
+        """验证消息格式"""
+        if not v:
+            raise HTTPException(status_code=400, detail="消息列表不能为空")
+
+        for msg in v:
+            if not isinstance(msg, dict):
+                raise HTTPException(status_code=400, detail="每个消息必须是字典")
+            if 'role' not in msg:
+                raise HTTPException(status_code=400, detail="消息缺少 'role' 字段")
+            if 'content' not in msg:
+                raise HTTPException(status_code=400, detail="消息缺少 'content' 字段")
+            if msg['role'] not in ['system', 'user', 'assistant']:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"无效角色 '{msg['role']}', 必须是 system/user/assistant"
+                )
+
+        return v
+
+    @classmethod
+    @field_validator('model')
+    def validate_model(cls, v):
+        """验证模型名称"""
+        if not Models.is_valid_model(v):
+            supported = Models.get_all_model_names()
+            raise HTTPException(
+                status_code=400,
+                detail=f"不支持的模型 '{v}', 支持: {', '.join(supported)}"
+            )
+        return v
+
+
+class OpenAIChatCompletionMessage(BaseModel):
+    """聊天完成消息"""
+    role: str = Field(..., description="角色")
+    content: str = Field(..., description="内容")
+    reference_id: Optional[str] = Field(default=None, description="参考ID")
+    annotations: Optional[List[str]] = Field(default=None, description="注释")
+
+
+class OpenAIChatCompletionChoice(BaseModel):
+    """聊天完成选项"""
+    index: int = Field(..., description="索引")
+    message: OpenAIChatCompletionMessage = Field(..., description="消息")
+    logprobs: Optional[float] = Field(default=None, description="对数概率")
+    finish_reason: str = Field(default="stop", description="完成原因")
+
+
+class OpenAIChatCompletionResponse(BaseModel):
+    """聊天完成响应"""
+    id: str = Field(..., description="响应ID")
+    object: str = Field("chat.completion", description="对象类型")
+    created: int = Field(..., description="创建时间戳")
+    model: str = Field(..., description="模型")
+    choices: List[OpenAIChatCompletionChoice] = Field(..., description="选项")
+    usage: Optional[Dict[str, Any]] = Field(None, description="令牌使用")
+
+
+class OpenAIChatCompletionChunkMessage(BaseModel):
+    """流式消息片段"""
+    role: str = Field(..., description="角色")
+    content: str = Field(..., description="内容")
+
+
+class OpenAIChatCompletionChunkChoice(BaseModel):
+    """流式选项"""
+    index: int = Field(..., description="索引")
+    delta: Optional[Union[Dict[str, Any], OpenAIChatCompletionChunkMessage]] = Field(
+        None, description="Delta数据"
+    )
+    finish_reason: Optional[str] = Field(None, description="完成原因")
+
+
+class OpenAIChatCompletionChunkResponse(BaseModel):
+    """流式聊天响应"""
+    id: str = Field(..., description="响应ID")
+    object: str = Field(default="chat.completion.chunk", description="对象类型")
+    created: int = Field(..., description="创建时间戳")
+    model: str = Field(..., description="模型")
+    system_fingerprint: Optional[str] = Field(default=None, description="系统指纹")
+    choices: List[OpenAIChatCompletionChunkChoice] = Field(..., description="选项")

app/services/api_keys.py

@@ -0,0 +1,195 @@
+"""API Key 管理器 - 多用户密钥管理"""
+
+import orjson
+import time
+import secrets
+import asyncio
+from typing import List, Dict, Optional
+from pathlib import Path
+
+from app.core.logger import logger
+from app.core.config import setting
+
+
+class ApiKeyManager:
+    """API Key 管理服务"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if hasattr(self, '_initialized'):
+            return
+            
+        self.file_path = Path(__file__).parents[2] / "data" / "api_keys.json"
+        self._keys: List[Dict] = []
+        self._lock = asyncio.Lock()
+        self._loaded = False
+        
+        self._initialized = True
+        logger.debug(f"[ApiKey] 初始化完成: {self.file_path}")
+
+    async def init(self):
+        """初始化加载数据"""
+        if not self._loaded:
+            await self._load_data()
+
+    async def _load_data(self):
+        """加载 API Keys"""
+        if self._loaded:
+            return
+
+        if not self.file_path.exists():
+            self._keys = []
+            self._loaded = True
+            return
+
+        try:
+            async with self._lock:
+                if self.file_path.exists():
+                    content = await asyncio.to_thread(self.file_path.read_bytes)
+                    if content:
+                        self._keys = orjson.loads(content)
+                        self._loaded = True
+                        logger.debug(f"[ApiKey] 加载了 {len(self._keys)} 个 API Key")
+        except Exception as e:
+            logger.error(f"[ApiKey] 加载失败: {e}")
+            self._keys = []
+            self._loaded = True # 即使加载失败也认为已尝试加载，防止后续保存清空数据（或者抛出异常）
+
+    async def _save_data(self):
+        """保存 API Keys"""
+        if not self._loaded:
+            logger.warning("[ApiKey] 尝试在数据未加载时保存，已取消操作以防覆盖数据")
+            return
+            
+        try:
+            # 确保目录存在
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            async with self._lock:
+                content = orjson.dumps(self._keys, option=orjson.OPT_INDENT_2)
+                await asyncio.to_thread(self.file_path.write_bytes, content)
+        except Exception as e:
+            logger.error(f"[ApiKey] 保存失败: {e}")
+
+    def generate_key(self) -> str:
+        """生成一个新的 sk- 开头的 key"""
+        return f"sk-{secrets.token_urlsafe(24)}"
+
+    async def add_key(self, name: str) -> Dict:
+        """添加 API Key"""
+        new_key = {
+            "key": self.generate_key(),
+            "name": name,
+            "created_at": int(time.time()),
+            "is_active": True
+        }
+        self._keys.append(new_key)
+        await self._save_data()
+        logger.info(f"[ApiKey] 添加新Key: {name}")
+        return new_key
+
+    async def batch_add_keys(self, name_prefix: str, count: int) -> List[Dict]:
+        """批量添加 API Key"""
+        new_keys = []
+        for i in range(1, count + 1):
+            name = f"{name_prefix}-{i}" if count > 1 else name_prefix
+            new_keys.append({
+                "key": self.generate_key(),
+                "name": name,
+                "created_at": int(time.time()),
+                "is_active": True
+            })
+        
+        self._keys.extend(new_keys)
+        await self._save_data()
+        logger.info(f"[ApiKey] 批量添加 {count} 个 Key, 前缀: {name_prefix}")
+        return new_keys
+
+    async def delete_key(self, key: str) -> bool:
+        """删除 API Key"""
+        initial_len = len(self._keys)
+        self._keys = [k for k in self._keys if k["key"] != key]
+        
+        if len(self._keys) != initial_len:
+            await self._save_data()
+            logger.info(f"[ApiKey] 删除Key: {key[:10]}...")
+            return True
+        return False
+
+    async def batch_delete_keys(self, keys: List[str]) -> int:
+        """批量删除 API Key"""
+        initial_len = len(self._keys)
+        self._keys = [k for k in self._keys if k["key"] not in keys]
+        
+        deleted_count = initial_len - len(self._keys)
+        if deleted_count > 0:
+            await self._save_data()
+            logger.info(f"[ApiKey] 批量删除 {deleted_count} 个 Key")
+        return deleted_count
+
+    async def update_key_status(self, key: str, is_active: bool) -> bool:
+        """更新 Key 状态"""
+        for k in self._keys:
+            if k["key"] == key:
+                k["is_active"] = is_active
+                await self._save_data()
+                return True
+        return False
+        
+    async def batch_update_keys_status(self, keys: List[str], is_active: bool) -> int:
+        """批量更新 Key 状态"""
+        updated_count = 0
+        for k in self._keys:
+            if k["key"] in keys:
+                if k["is_active"] != is_active:
+                    k["is_active"] = is_active
+                    updated_count += 1
+        
+        if updated_count > 0:
+            await self._save_data()
+            logger.info(f"[ApiKey] 批量更新 {updated_count} 个 Key 状态为: {is_active}")
+        return updated_count
+
+    async def update_key_name(self, key: str, name: str) -> bool:
+        """更新 Key 备注"""
+        for k in self._keys:
+            if k["key"] == key:
+                k["name"] = name
+                await self._save_data()
+                return True
+        return False
+
+    def validate_key(self, key: str) -> Optional[Dict]:
+        """验证 Key，返回 Key 信息"""
+        # 1. 检查全局配置的 Key (作为默认 admin key)
+        global_key = setting.grok_config.get("api_key")
+        if global_key and key == global_key:
+            return {
+                "key": global_key,
+                "name": "默认管理员",
+                "is_active": True,
+                "is_admin": True
+            }
+            
+        # 2. 检查多 Key 列表
+        for k in self._keys:
+            if k["key"] == key:
+                if k["is_active"]:
+                    return {**k, "is_admin": False} # 普通 Key 也可以视为非管理员? 暂不区分权限，只做身份识别
+                return None
+                
+        return None
+
+    def get_all_keys(self) -> List[Dict]:
+        """获取所有 Keys"""
+        return self._keys
+
+
+# 全局实例
+api_key_manager = ApiKeyManager()

app/services/grok/cache.py

@@ -0,0 +1,243 @@
+"""缓存服务模块 - 提供图片和视频的下载、缓存和清理功能"""
+
+import asyncio
+import base64
+from pathlib import Path
+from typing import Optional, Tuple
+from curl_cffi.requests import AsyncSession
+
+from app.core.config import setting
+from app.core.logger import logger
+from app.services.grok.statsig import get_dynamic_headers
+
+
+# 常量定义
+MIME_TYPES = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp',
+}
+DEFAULT_MIME = 'image/jpeg'
+ASSETS_URL = "https://assets.grok.com"
+
+
+class CacheService:
+    """缓存服务基类"""
+
+    def __init__(self, cache_type: str, timeout: float = 30.0):
+        self.cache_type = cache_type
+        self.cache_dir = Path(f"data/temp/{cache_type}")
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.timeout = timeout
+        self._cleanup_lock = asyncio.Lock()
+
+    def _get_path(self, file_path: str) -> Path:
+        """转换文件路径为缓存路径"""
+        return self.cache_dir / file_path.lstrip('/').replace('/', '-')
+
+    def _log(self, level: str, msg: str):
+        """统一日志输出"""
+        getattr(logger, level)(f"[{self.cache_type.upper()}Cache] {msg}")
+
+    def _build_headers(self, file_path: str, auth_token: str) -> dict:
+        """构建请求头"""
+        cf = setting.grok_config.get("cf_clearance", "")
+        return {
+            **get_dynamic_headers(pathname=file_path),
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+            "Sec-Fetch-Dest": "document",
+            "Sec-Fetch-Mode": "navigate",
+            "Sec-Fetch-Site": "same-site",
+            "Sec-Fetch-User": "?1",
+            "Upgrade-Insecure-Requests": "1",
+            "Referer": "https://grok.com/",
+            "Cookie": f"{auth_token};{cf}" if cf else auth_token
+        }
+
+    async def download(self, file_path: str, auth_token: str, timeout: Optional[float] = None) -> Optional[Path]:
+        """下载并缓存文件"""
+        cache_path = self._get_path(file_path)
+        if cache_path.exists():
+            self._log("debug", "文件已缓存")
+            return cache_path
+
+        # 外层重试：可配置状态码（401/429等）
+        retry_codes = setting.grok_config.get("retry_status_codes", [401, 429])
+        MAX_OUTER_RETRY = 3
+        
+        for outer_retry in range(MAX_OUTER_RETRY + 1):  # +1 确保实际重试3次
+            try:
+                # 内层重试：403代理池重试（cache使用缓存代理，不支持代理池，所以403只重试一次）
+                max_403_retries = 5
+                retry_403_count = 0
+                
+                while retry_403_count <= max_403_retries:
+                    proxy = await setting.get_proxy_async("cache")
+                    proxies = {"http": proxy, "https": proxy} if proxy else {}
+                    
+                    if proxy and outer_retry == 0 and retry_403_count == 0:
+                        self._log("debug", f"使用代理: {proxy.split('@')[-1] if '@' in proxy else proxy}")
+
+                    async with AsyncSession() as session:
+                        url = f"{ASSETS_URL}{file_path}"
+                        if outer_retry == 0 and retry_403_count == 0:
+                            self._log("debug", f"下载: {url}")
+                        
+                        response = await session.get(
+                            url,
+                            headers=self._build_headers(file_path, auth_token),
+                            proxies=proxies,
+                            timeout=timeout or self.timeout,
+                            allow_redirects=True,
+                            impersonate="chrome133a"
+                        )
+                        
+                        # 检查403错误 - 内层重试(cache不使用代理池，所以直接失败)
+                        if response.status_code == 403:
+                            retry_403_count += 1
+                            
+                            if retry_403_count <= max_403_retries:
+                                self._log("warning", f"遇到403错误，正在重试 ({retry_403_count}/{max_403_retries})...")
+                                await asyncio.sleep(0.5)
+                                continue
+                            
+                            self._log("error", f"403错误，已重试{retry_403_count-1}次，放弃")
+                            return None
+                        
+                        # 检查可配置状态码错误 - 外层重试
+                        if response.status_code in retry_codes:
+                            if outer_retry < MAX_OUTER_RETRY:
+                                delay = (outer_retry + 1) * 0.1  # 渐进延迟：0.1s, 0.2s, 0.3s
+                                self._log("warning", f"遇到{response.status_code}错误，外层重试 ({outer_retry+1}/{MAX_OUTER_RETRY})，等待{delay}s...")
+                                await asyncio.sleep(delay)
+                                break  # 跳出内层循环，进入外层重试
+                            else:
+                                self._log("error", f"{response.status_code}错误，已重试{outer_retry}次，放弃")
+                                return None
+                        
+                        response.raise_for_status()
+                        await asyncio.to_thread(cache_path.write_bytes, response.content)
+                        
+                        if outer_retry > 0 or retry_403_count > 0:
+                            self._log("info", f"重试成功！")
+                        else:
+                            self._log("debug", "缓存成功")
+                        
+                        # 异步清理（带错误处理）
+                        asyncio.create_task(self._safe_cleanup())
+                        return cache_path
+                        
+            except Exception as e:
+                if outer_retry < MAX_OUTER_RETRY - 1:
+                    self._log("warning", f"下载异常: {e}，外层重试 ({outer_retry+1}/{MAX_OUTER_RETRY})...")
+                    await asyncio.sleep(0.5)
+                    continue
+                
+                self._log("error", f"下载失败: {e}（已重试{outer_retry}次）")
+                return None
+        
+        return None
+
+    def get_cached(self, file_path: str) -> Optional[Path]:
+        """获取已缓存的文件"""
+        path = self._get_path(file_path)
+        return path if path.exists() else None
+
+    async def _safe_cleanup(self):
+        """安全清理（捕获异常）"""
+        try:
+            await self.cleanup()
+        except Exception as e:
+            self._log("error", f"后台清理失败: {e}")
+
+    async def cleanup(self):
+        """清理超限缓存"""
+        if self._cleanup_lock.locked():
+            return
+        
+        async with self._cleanup_lock:
+            try:
+                max_mb = setting.global_config.get(f"{self.cache_type}_cache_max_size_mb", 500)
+                max_bytes = max_mb * 1024 * 1024
+
+                # 获取文件信息 (path, size, mtime)
+                files = [(f, (s := f.stat()).st_size, s.st_mtime) 
+                        for f in self.cache_dir.glob("*") if f.is_file()]
+                total = sum(size for _, size, _ in files)
+
+                if total <= max_bytes:
+                    return
+
+                self._log("info", f"清理缓存 {total/1024/1024:.1f}MB -> {max_mb}MB")
+                
+                # 删除最旧的文件
+                for path, size, _ in sorted(files, key=lambda x: x[2]):
+                    if total <= max_bytes:
+                        break
+                    await asyncio.to_thread(path.unlink)
+                    total -= size
+                
+                self._log("info", f"清理完成: {total/1024/1024:.1f}MB")
+            except Exception as e:
+                self._log("error", f"清理失败: {e}")
+
+
+class ImageCache(CacheService):
+    """图片缓存服务"""
+
+    def __init__(self):
+        super().__init__("image", timeout=30.0)
+
+    async def download_image(self, path: str, token: str) -> Optional[Path]:
+        """下载图片"""
+        return await self.download(path, token)
+
+    @staticmethod
+    def to_base64(image_path: Path) -> Optional[str]:
+        """图片转base64"""
+        try:
+            if not image_path.exists():
+                logger.error(f"[ImageCache] 文件不存在: {image_path}")
+                return None
+
+            data = base64.b64encode(image_path.read_bytes()).decode()
+            mime = MIME_TYPES.get(image_path.suffix.lower(), DEFAULT_MIME)
+            return f"data:{mime};base64,{data}"
+        except Exception as e:
+            logger.error(f"[ImageCache] 转换失败: {e}")
+            return None
+
+    async def download_base64(self, path: str, token: str) -> Optional[str]:
+        """下载并转为base64（自动删除临时文件）"""
+        try:
+            cache_path = await self.download(path, token)
+            if not cache_path:
+                return None
+
+            result = self.to_base64(cache_path)
+            
+            # 清理临时文件
+            try:
+                cache_path.unlink()
+            except Exception as e:
+                logger.warning(f"[ImageCache] 删除临时文件失败: {e}")
+
+            return result
+        except Exception as e:
+            logger.error(f"[ImageCache] 下载base64失败: {e}")
+            return None
+
+
+class VideoCache(CacheService):
+    """视频缓存服务"""
+
+    def __init__(self):
+        super().__init__("video", timeout=60.0)
+
+    async def download_video(self, path: str, token: str) -> Optional[Path]:
+        """下载视频"""
+        return await self.download(path, token)
+
+
+# 全局实例
+image_cache_service = ImageCache()
+video_cache_service = VideoCache()

app/services/grok/client.py

@@ -0,0 +1,358 @@
+"""Grok API 客户端 - 处理OpenAI到Grok的请求转换和响应处理"""
+
+import asyncio
+import orjson
+from typing import Dict, List, Tuple, Any, Optional
+from curl_cffi.requests import AsyncSession as curl_AsyncSession
+
+from app.core.config import setting
+from app.core.logger import logger
+from app.models.grok_models import Models
+from app.services.grok.processer import GrokResponseProcessor
+from app.services.grok.statsig import get_dynamic_headers
+from app.services.grok.token import token_manager
+from app.services.grok.upload import ImageUploadManager
+from app.services.grok.create import PostCreateManager
+from app.core.exception import GrokApiException
+
+
+# 常量
+API_ENDPOINT = "https://grok.com/rest/app-chat/conversations/new"
+TIMEOUT = 120
+BROWSER = "chrome133a"
+MAX_RETRY = 3
+MAX_UPLOADS = 20  # 提高并发上传限制以支持更高并发
+
+
+class GrokClient:
+    """Grok API 客户端"""
+    
+    _upload_sem = None  # 延迟初始化
+
+    @staticmethod
+    def _get_upload_semaphore():
+        """获取上传信号量（动态配置）"""
+        if GrokClient._upload_sem is None:
+            # 从配置读取，如果不可用则使用默认值
+            max_concurrency = setting.global_config.get("max_upload_concurrency", MAX_UPLOADS)
+            GrokClient._upload_sem = asyncio.Semaphore(max_concurrency)
+            logger.debug(f"[Client] 初始化上传并发限制: {max_concurrency}")
+        return GrokClient._upload_sem
+
+    @staticmethod
+    async def openai_to_grok(request: dict):
+        """转换OpenAI请求为Grok请求"""
+        model = request["model"]
+        content, images = GrokClient._extract_content(request["messages"])
+        stream = request.get("stream", False)
+        
+        # 获取模型信息
+        info = Models.get_model_info(model)
+        grok_model, mode = Models.to_grok(model)
+        is_video = info.get("is_video_model", False)
+        
+        # 视频模型限制
+        if is_video and len(images) > 1:
+            logger.warning(f"[Client] 视频模型仅支持1张图片，已截取前1张")
+            images = images[:1]
+        
+        return await GrokClient._retry(model, content, images, grok_model, mode, is_video, stream)
+
+    @staticmethod
+    async def _retry(model: str, content: str, images: List[str], grok_model: str, mode: str, is_video: bool, stream: bool):
+        """重试请求"""
+        last_err = None
+
+        for i in range(MAX_RETRY):
+            try:
+                token = await token_manager.get_token(model)
+                img_ids, img_uris = await GrokClient._upload(images, token)
+
+                # 视频模型创建会话
+                post_id = None
+                if is_video and img_ids and img_uris:
+                    post_id = await GrokClient._create_post(img_ids[0], img_uris[0], token)
+
+                payload = GrokClient._build_payload(content, grok_model, mode, img_ids, img_uris, is_video, post_id)
+                return await GrokClient._request(payload, token, model, stream, post_id)
+
+            except GrokApiException as e:
+                last_err = e
+                # 检查是否可重试
+                if e.error_code not in ["HTTP_ERROR", "NO_AVAILABLE_TOKEN"]:
+                    raise
+
+                status = e.context.get("status") if e.context else None
+                retry_codes = setting.grok_config.get("retry_status_codes", [401, 429])
+                
+                if status not in retry_codes:
+                    raise
+
+                if i < MAX_RETRY - 1:
+                    logger.warning(f"[Client] 失败(状态:{status}), 重试 {i+1}/{MAX_RETRY}")
+                    await asyncio.sleep(0.5)
+
+        raise last_err or GrokApiException("请求失败", "REQUEST_ERROR")
+
+    @staticmethod
+    def _extract_content(messages: List[Dict]) -> Tuple[str, List[str]]:
+        """提取文本和图片，保留角色结构"""
+        formatted_messages = []
+        images = []
+
+        # 角色映射
+        role_map = {
+            "system": "系统",
+            "user": "用户",
+            "assistant": "grok"
+        }
+        
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            role_prefix = role_map.get(role, role)
+            
+            # 提取文本内容
+            text_parts = []
+            if isinstance(content, list):
+                for item in content:
+                    if item.get("type") == "text":
+                        text_parts.append(item.get("text", ""))
+                    elif item.get("type") == "image_url":
+                        if url := item.get("image_url", {}).get("url"):
+                            images.append(url)
+            else:
+                text_parts.append(content)
+            
+            # 合并该消息的文本并添加角色前缀
+            msg_text = "".join(text_parts).strip()
+            if msg_text:
+                formatted_messages.append(f"{role_prefix}：{msg_text}")
+        
+        # 用换行符连接所有消息
+        return "\n".join(formatted_messages), images
+
+    @staticmethod
+    async def _upload(urls: List[str], token: str) -> Tuple[List[str], List[str]]:
+        """并发上传图片"""
+        if not urls:
+            return [], []
+        
+        async def upload_limited(url):
+            async with GrokClient._get_upload_semaphore():
+                return await ImageUploadManager.upload(url, token)
+        
+        results = await asyncio.gather(*[upload_limited(u) for u in urls], return_exceptions=True)
+        
+        ids, uris = [], []
+        for url, result in zip(urls, results):
+            if isinstance(result, Exception):
+                logger.warning(f"[Client] 上传失败: {url} - {result}")
+            elif isinstance(result, tuple) and len(result) == 2:
+                fid, furi = result
+                if fid:
+                    ids.append(fid)
+                    uris.append(furi)
+        
+        return ids, uris
+
+    @staticmethod
+    async def _create_post(file_id: str, file_uri: str, token: str) -> Optional[str]:
+        """创建视频会话"""
+        try:
+            result = await PostCreateManager.create(file_id, file_uri, token)
+            if result and result.get("success"):
+                return result.get("post_id")
+        except Exception as e:
+            logger.warning(f"[Client] 创建会话失败: {e}")
+        return None
+
+    @staticmethod
+    def _build_payload(content: str, model: str, mode: str, img_ids: List[str], img_uris: List[str], is_video: bool = False, post_id: str = None) -> Dict:
+        """构建请求载荷"""
+        # 视频模型特殊处理
+        if is_video and img_uris:
+            img_msg = f"https://grok.com/imagine/{post_id}" if post_id else f"https://assets.grok.com/post/{img_uris[0]}"
+            return {
+                "temporary": True,
+                "modelName": "grok-3",
+                "message": f"{img_msg}  {content} --mode=custom",
+                "fileAttachments": img_ids,
+                "toolOverrides": {"videoGen": True}
+            }
+        
+        # 标准载荷
+        return {
+            "temporary": setting.grok_config.get("temporary", True),
+            "modelName": model,
+            "message": content,
+            "fileAttachments": img_ids,
+            "imageAttachments": [],
+            "disableSearch": False,
+            "enableImageGeneration": True,
+            "returnImageBytes": False,
+            "returnRawGrokInXaiRequest": False,
+            "enableImageStreaming": True,
+            "imageGenerationCount": 2,
+            "forceConcise": False,
+            "toolOverrides": {},
+            "enableSideBySide": True,
+            "sendFinalMetadata": True,
+            "isReasoning": False,
+            "webpageUrls": [],
+            "disableTextFollowUps": True,
+            "responseMetadata": {"requestModelDetails": {"modelId": model}},
+            "disableMemory": False,
+            "forceSideBySide": False,
+            "modelMode": mode,
+            "isAsyncChat": False
+        }
+
+    @staticmethod
+    async def _request(payload: dict, token: str, model: str, stream: bool, post_id: str = None):
+        """发送请求"""
+        if not token:
+            raise GrokApiException("认证令牌缺失", "NO_AUTH_TOKEN")
+
+        # 外层重试：可配置状态码（401/429等）
+        retry_codes = setting.grok_config.get("retry_status_codes", [401, 429])
+        MAX_OUTER_RETRY = 3
+        
+        for outer_retry in range(MAX_OUTER_RETRY + 1):  # +1 确保实际重试3次
+            # 内层重试：403代理池重试
+            max_403_retries = 5
+            retry_403_count = 0
+            
+            while retry_403_count <= max_403_retries:
+                # 异步获取代理
+                from app.core.proxy_pool import proxy_pool
+                
+                # 如果是403重试且使用代理池，强制刷新代理
+                if retry_403_count > 0 and proxy_pool._enabled:
+                    logger.info(f"[Client] 403重试 {retry_403_count}/{max_403_retries}，刷新代理...")
+                    proxy = await proxy_pool.force_refresh()
+                else:
+                    proxy = await setting.get_proxy_async("service")
+                
+                proxies = {"http": proxy, "https": proxy} if proxy else None
+                
+                # 构建请求头（放在循环内以支持重试新Token）
+                headers = GrokClient._build_headers(token)
+                if model == "grok-imagine-0.9":
+                    file_attachments = payload.get("fileAttachments", [])
+                    ref_id = post_id or (file_attachments[0] if file_attachments else "")
+                    if ref_id:
+                        headers["Referer"] = f"https://grok.com/imagine/{ref_id}"
+
+                # 创建会话并执行请求
+                session = curl_AsyncSession(impersonate=BROWSER)
+                try:
+                    response = await session.post(
+                        API_ENDPOINT,
+                        headers=headers,
+                        data=orjson.dumps(payload),
+                        timeout=TIMEOUT,
+                        stream=True,
+                        proxies=proxies
+                    )
+                    
+                    # 内层403重试：仅当有代理池时触发
+                    if response.status_code == 403 and proxy_pool._enabled:
+                        retry_403_count += 1
+                        if retry_403_count <= max_403_retries:
+                            logger.warning(f"[Client] 遇到403错误，正在重试 ({retry_403_count}/{max_403_retries})...")
+                            await session.close()
+                            await asyncio.sleep(0.5)
+                            continue
+                        logger.error(f"[Client] 403错误，已重试{retry_403_count-1}次，放弃")
+                    
+                    # 检查可配置状态码错误 - 外层重试
+                    if response.status_code in retry_codes:
+                        if outer_retry < MAX_OUTER_RETRY:
+                            delay = (outer_retry + 1) * 0.1
+                            logger.warning(f"[Client] 遇到{response.status_code}错误，外层重试 ({outer_retry+1}/{MAX_OUTER_RETRY})，等待{delay}s...")
+                            await session.close()
+                            await asyncio.sleep(delay)
+                            break  # 跳出内层循环，进入外层重试
+                        else:
+                            logger.error(f"[Client] {response.status_code}错误，已重试{outer_retry}次，放弃")
+                            try:
+                                GrokClient._handle_error(response, token)
+                            finally:
+                                await session.close()
+                    
+                    # 检查其他响应状态
+                    if response.status_code != 200:
+                        try:
+                            GrokClient._handle_error(response, token)
+                        finally:
+                            await session.close()
+                    
+                    # 成功 - 重置失败计数
+                    asyncio.create_task(token_manager.reset_failure(token))
+                    
+                    if outer_retry > 0 or retry_403_count > 0:
+                        logger.info(f"[Client] 重试成功！")
+                    
+                    # 处理响应
+                    if stream:
+                        # 流式响应由迭代器负责关闭 session
+                        result = GrokResponseProcessor.process_stream(response, token, session)
+                    else:
+                        # 普通响应处理完立即关闭 session
+                        try:
+                            result = await GrokResponseProcessor.process_normal(response, token, model)
+                        finally:
+                            await session.close()
+                    
+                    asyncio.create_task(GrokClient._update_limits(token, model))
+                    return result
+                    
+                except Exception as e:
+                    await session.close()
+                    if "RequestsError" in str(type(e)):
+                        logger.error(f"[Client] 网络错误: {e}")
+                        raise GrokApiException(f"网络错误: {e}", "NETWORK_ERROR") from e
+                    raise
+        
+        raise GrokApiException("请求失败：已达到最大重试次数", "MAX_RETRIES_EXCEEDED")
+
+
+    @staticmethod
+    def _build_headers(token: str) -> Dict[str, str]:
+        """构建请求头"""
+        headers = get_dynamic_headers("/rest/app-chat/conversations/new")
+        cf = setting.grok_config.get("cf_clearance", "")
+        headers["Cookie"] = f"{token};{cf}" if cf else token
+        return headers
+
+    @staticmethod
+    def _handle_error(response, token: str):
+        """处理错误"""
+        if response.status_code == 403:
+            msg = "您的IP被拦截，请尝试以下方法之一: 1.更换IP 2.使用代理 3.配置CF值"
+            data = {"cf_blocked": True, "status": 403}
+            logger.warning(f"[Client] {msg}")
+        else:
+            try:
+                data = response.json()
+                msg = str(data)
+            except:
+                data = response.text
+                msg = data[:200] if data else "未知错误"
+        
+        asyncio.create_task(token_manager.record_failure(token, response.status_code, msg))
+        asyncio.create_task(token_manager.apply_cooldown(token, response.status_code))
+        raise GrokApiException(
+            f"请求失败: {response.status_code} - {msg}",
+            "HTTP_ERROR",
+            {"status": response.status_code, "data": data}
+        )
+
+    @staticmethod
+    async def _update_limits(token: str, model: str):
+        """更新速率限制"""
+        try:
+            await token_manager.check_limits(token, model)
+        except Exception as e:
+            logger.error(f"[Client] 更新限制失败: {e}")

app/services/grok/create.py

@@ -0,0 +1,140 @@
+"""Post创建管理器 - 用于视频生成前的会话创建"""
+
+import asyncio
+import orjson
+from typing import Dict, Any, Optional
+from curl_cffi.requests import AsyncSession
+
+from app.services.grok.statsig import get_dynamic_headers
+from app.core.exception import GrokApiException
+from app.core.config import setting
+from app.core.logger import logger
+
+
+# 常量
+ENDPOINT = "https://grok.com/rest/media/post/create"
+TIMEOUT = 30
+BROWSER = "chrome133a"
+
+
+class PostCreateManager:
+    """会话创建管理器"""
+
+    @staticmethod
+    async def create(file_id: str, file_uri: str, auth_token: str) -> Optional[Dict[str, Any]]:
+        """创建会话记录
+        
+        Args:
+            file_id: 文件ID
+            file_uri: 文件URI
+            auth_token: 认证令牌
+            
+        Returns:
+            会话信息字典，包含post_id等
+        """
+        # 参数验证
+        if not file_id or not file_uri:
+            raise GrokApiException("文件ID或URI缺失", "INVALID_PARAMS")
+        if not auth_token:
+            raise GrokApiException("认证令牌缺失", "NO_AUTH_TOKEN")
+
+        try:
+            # 构建请求
+            data = {
+                "media_url": f"https://assets.grok.com/{file_uri}",
+                "media_type": "MEDIA_POST_TYPE_IMAGE"
+            }
+            
+            cf = setting.grok_config.get("cf_clearance", "")
+            headers = {
+                **get_dynamic_headers("/rest/media/post/create"),
+                "Cookie": f"{auth_token};{cf}" if cf else auth_token
+            }
+            
+            # 外层重试：可配置状态码（401/429等）
+            retry_codes = setting.grok_config.get("retry_status_codes", [401, 429])
+            MAX_OUTER_RETRY = 3
+            
+            for outer_retry in range(MAX_OUTER_RETRY + 1):  # +1 确保实际重试3次
+                # 内层重试：403代理池重试
+                max_403_retries = 5
+                retry_403_count = 0
+                
+                while retry_403_count <= max_403_retries:
+                    # 异步获取代理（支持代理池）
+                    from app.core.proxy_pool import proxy_pool
+                    
+                    # 如果是403重试且使用代理池，强制刷新代理
+                    if retry_403_count > 0 and proxy_pool._enabled:
+                        logger.info(f"[PostCreate] 403重试 {retry_403_count}/{max_403_retries}，刷新代理...")
+                        proxy = await proxy_pool.force_refresh()
+                    else:
+                        proxy = await setting.get_proxy_async("service")
+                    
+                    proxies = {"http": proxy, "https": proxy} if proxy else None
+
+                    # 发送请求
+                    async with AsyncSession() as session:
+                        response = await session.post(
+                            ENDPOINT,
+                            headers=headers,
+                            json=data,
+                            impersonate=BROWSER,
+                            timeout=TIMEOUT,
+                            proxies=proxies
+                        )
+
+                        # 内层403重试：仅当有代理池时触发
+                        if response.status_code == 403 and proxy_pool._enabled:
+                            retry_403_count += 1
+                            
+                            if retry_403_count <= max_403_retries:
+                                logger.warning(f"[PostCreate] 遇到403错误，正在重试 ({retry_403_count}/{max_403_retries})...")
+                                await asyncio.sleep(0.5)
+                                continue
+                            
+                            # 内层重试全部失败
+                            logger.error(f"[PostCreate] 403错误，已重试{retry_403_count-1}次，放弃")
+                        
+                        # 检查可配置状态码错误 - 外层重试
+                        if response.status_code in retry_codes:
+                            if outer_retry < MAX_OUTER_RETRY:
+                                delay = (outer_retry + 1) * 0.1  # 渐进延迟：0.1s, 0.2s, 0.3s
+                                logger.warning(f"[PostCreate] 遇到{response.status_code}错误，外层重试 ({outer_retry+1}/{MAX_OUTER_RETRY})，等待{delay}s...")
+                                await asyncio.sleep(delay)
+                                break  # 跳出内层循环，进入外层重试
+                            else:
+                                logger.error(f"[PostCreate] {response.status_code}错误，已重试{outer_retry}次，放弃")
+                                raise GrokApiException(f"创建失败: {response.status_code}错误", "CREATE_ERROR")
+
+                        if response.status_code == 200:
+                            result = response.json()
+                            post_id = result.get("post", {}).get("id", "")
+                            
+                            if outer_retry > 0 or retry_403_count > 0:
+                                logger.info(f"[PostCreate] 重试成功！")
+                            
+                            logger.debug(f"[PostCreate] 成功，会话ID: {post_id}")
+                            return {
+                                "post_id": post_id,
+                                "file_id": file_id,
+                                "file_uri": file_uri,
+                                "success": True,
+                                "data": result
+                            }
+                        
+                        # 其他错误处理
+                        try:
+                            error = response.json()
+                            msg = f"状态码: {response.status_code}, 详情: {error}"
+                        except:
+                            msg = f"状态码: {response.status_code}, 详情: {response.text[:200]}"
+                        
+                        logger.error(f"[PostCreate] 失败: {msg}")
+                        raise GrokApiException(f"创建失败: {msg}", "CREATE_ERROR")
+
+        except GrokApiException:
+            raise
+        except Exception as e:
+            logger.error(f"[PostCreate] 异常: {e}")
+            raise GrokApiException(f"创建异常: {e}", "CREATE_ERROR") from e

app/services/grok/processer.py

@@ -0,0 +1,430 @@
+"""Grok API 响应处理器 - 处理流式和非流式响应"""
+
+import orjson
+import uuid
+import time
+import asyncio
+from typing import AsyncGenerator, Tuple, Any
+
+from app.core.config import setting
+from app.core.exception import GrokApiException
+from app.core.logger import logger
+from app.models.openai_schema import (
+    OpenAIChatCompletionResponse,
+    OpenAIChatCompletionChoice,
+    OpenAIChatCompletionMessage,
+    OpenAIChatCompletionChunkResponse,
+    OpenAIChatCompletionChunkChoice,
+    OpenAIChatCompletionChunkMessage
+)
+from app.services.grok.cache import image_cache_service, video_cache_service
+
+
+class StreamTimeoutManager:
+    """流式响应超时管理"""
+    
+    def __init__(self, chunk_timeout: int = 120, first_timeout: int = 30, total_timeout: int = 600):
+        self.chunk_timeout = chunk_timeout
+        self.first_timeout = first_timeout
+        self.total_timeout = total_timeout
+        self.start_time = asyncio.get_event_loop().time()
+        self.last_chunk_time = self.start_time
+        self.first_received = False
+    
+    def check_timeout(self) -> Tuple[bool, str]:
+        """检查超时"""
+        now = asyncio.get_event_loop().time()
+        
+        if not self.first_received and now - self.start_time > self.first_timeout:
+            return True, f"首次响应超时({self.first_timeout}秒)"
+        
+        if self.total_timeout > 0 and now - self.start_time > self.total_timeout:
+            return True, f"总超时({self.total_timeout}秒)"
+        
+        if self.first_received and now - self.last_chunk_time > self.chunk_timeout:
+            return True, f"数据块超时({self.chunk_timeout}秒)"
+        
+        return False, ""
+    
+    def mark_received(self):
+        """标记收到数据"""
+        self.last_chunk_time = asyncio.get_event_loop().time()
+        self.first_received = True
+    
+    def duration(self) -> float:
+        """获取总耗时"""
+        return asyncio.get_event_loop().time() - self.start_time
+
+
+class GrokResponseProcessor:
+    """Grok响应处理器"""
+
+    @staticmethod
+    async def process_normal(response, auth_token: str, model: str = None) -> OpenAIChatCompletionResponse:
+        """处理非流式响应"""
+        response_closed = False
+        try:
+            async for chunk in response.aiter_lines():
+                if not chunk:
+                    continue
+
+                data = orjson.loads(chunk)
+
+                # 错误检查
+                if error := data.get("error"):
+                    raise GrokApiException(
+                        f"API错误: {error.get('message', '未知错误')}",
+                        "API_ERROR",
+                        {"code": error.get("code")}
+                    )
+
+                grok_resp = data.get("result", {}).get("response", {})
+                
+                # 视频响应
+                if video_resp := grok_resp.get("streamingVideoGenerationResponse"):
+                    if video_url := video_resp.get("videoUrl"):
+                        content = await GrokResponseProcessor._build_video_content(video_url, auth_token)
+                        result = GrokResponseProcessor._build_response(content, model or "grok-imagine-0.9")
+                        response_closed = True
+                        response.close()
+                        return result
+
+                # 模型响应
+                model_response = grok_resp.get("modelResponse")
+                if not model_response:
+                    continue
+
+                if error_msg := model_response.get("error"):
+                    raise GrokApiException(f"模型错误: {error_msg}", "MODEL_ERROR")
+
+                # 构建内容
+                content = model_response.get("message", "")
+                model_name = model_response.get("model")
+
+                # 处理图片
+                if images := model_response.get("generatedImageUrls"):
+                    content = await GrokResponseProcessor._append_images(content, images, auth_token)
+
+                result = GrokResponseProcessor._build_response(content, model_name)
+                response_closed = True
+                response.close()
+                return result
+
+            raise GrokApiException("无响应数据", "NO_RESPONSE")
+
+        except orjson.JSONDecodeError as e:
+            logger.error(f"[Processor] JSON解析失败: {e}")
+            raise GrokApiException(f"JSON解析失败: {e}", "JSON_ERROR") from e
+        except Exception as e:
+            logger.error(f"[Processor] 处理错误: {type(e).__name__}: {e}")
+            raise GrokApiException(f"响应处理错误: {e}", "PROCESS_ERROR") from e
+        finally:
+            if not response_closed and hasattr(response, 'close'):
+                try:
+                    response.close()
+                except Exception as e:
+                    logger.warning(f"[Processor] 关闭响应失败: {e}")
+
+    @staticmethod
+    async def process_stream(response, auth_token: str, session: Any = None) -> AsyncGenerator[str, None]:
+        """处理流式响应"""
+        # 状态变量
+        is_image = False
+        is_thinking = False
+        thinking_finished = False
+        model = None
+        filtered_tags = setting.grok_config.get("filtered_tags", "").split(",")
+        video_progress_started = False
+        last_video_progress = -1
+        response_closed = False
+        show_thinking = setting.grok_config.get("show_thinking", True)
+
+        # 超时管理
+        timeout_mgr = StreamTimeoutManager(
+            chunk_timeout=setting.grok_config.get("stream_chunk_timeout", 120),
+            first_timeout=setting.grok_config.get("stream_first_response_timeout", 30),
+            total_timeout=setting.grok_config.get("stream_total_timeout", 600)
+        )
+
+        def make_chunk(content: str, finish: str = None):
+            """生成响应块"""
+            chunk_data = OpenAIChatCompletionChunkResponse(
+                id=f"chatcmpl-{uuid.uuid4()}",
+                created=int(time.time()),
+                model=model or "grok-4-mini-thinking-tahoe",
+                choices=[OpenAIChatCompletionChunkChoice(
+                    index=0,
+                    delta=OpenAIChatCompletionChunkMessage(
+                        role="assistant",
+                        content=content
+                    ) if content else {},
+                    finish_reason=finish
+                )]
+            )
+            return f"data: {chunk_data.model_dump_json()}\n\n"
+
+        try:
+            async for chunk in response.aiter_lines():
+                # 超时检查
+                is_timeout, timeout_msg = timeout_mgr.check_timeout()
+                if is_timeout:
+                    logger.warning(f"[Processor] {timeout_msg}")
+                    yield make_chunk("", "stop")
+                    yield "data: [DONE]\n\n"
+                    return
+
+                logger.debug(f"[Processor] 收到数据块: {len(chunk)} bytes")
+                if not chunk:
+                    continue
+
+                try:
+                    data = orjson.loads(chunk)
+
+                    # 错误检查
+                    if error := data.get("error"):
+                        error_msg = error.get('message', '未知错误')
+                        logger.error(f"[Processor] API错误: {error_msg}")
+                        yield make_chunk(f"Error: {error_msg}", "stop")
+                        yield "data: [DONE]\n\n"
+                        return
+
+                    grok_resp = data.get("result", {}).get("response", {})
+                    logger.debug(f"[Processor] 解析响应: {len(grok_resp)} bytes")
+                    if not grok_resp:
+                        continue
+                    
+                    timeout_mgr.mark_received()
+
+                    # 更新模型
+                    if user_resp := grok_resp.get("userResponse"):
+                        if m := user_resp.get("model"):
+                            model = m
+
+                    # 视频处理
+                    if video_resp := grok_resp.get("streamingVideoGenerationResponse"):
+                        progress = video_resp.get("progress", 0)
+                        v_url = video_resp.get("videoUrl")
+                        
+                        # 进度更新
+                        if progress > last_video_progress:
+                            last_video_progress = progress
+                            if show_thinking:
+                                if not video_progress_started:
+                                    content = f"<think>视频已生成{progress}%\n"
+                                    video_progress_started = True
+                                elif progress < 100:
+                                    content = f"视频已生成{progress}%\n"
+                                else:
+                                    content = f"视频已生成{progress}%</think>\n"
+                                yield make_chunk(content)
+                        
+                        # 视频URL
+                        if v_url:
+                            logger.debug("[Processor] 视频生成完成")
+                            video_content = await GrokResponseProcessor._build_video_content(v_url, auth_token)
+                            yield make_chunk(video_content)
+                        
+                        continue
+
+                    # 图片模式
+                    if grok_resp.get("imageAttachmentInfo"):
+                        is_image = True
+
+                    token = grok_resp.get("token", "")
+
+                    # 图片处理
+                    if is_image:
+                        if model_resp := grok_resp.get("modelResponse"):
+                            image_mode = setting.global_config.get("image_mode", "url")
+                            content = ""
+
+                            for img in model_resp.get("generatedImageUrls", []):
+                                try:
+                                    if image_mode == "base64":
+                                        # Base64模式 - 分块发送
+                                        base64_str = await image_cache_service.download_base64(f"/{img}", auth_token)
+                                        if base64_str:
+                                            # 分块发送大数据
+                                            if not base64_str.startswith("data:"):
+                                                parts = base64_str.split(",", 1)
+                                                if len(parts) == 2:
+                                                    yield make_chunk(f"![Generated Image](data:{parts[0]},")
+                                                    # 8KB分块
+                                                    for i in range(0, len(parts[1]), 8192):
+                                                        yield make_chunk(parts[1][i:i+8192])
+                                                    yield make_chunk(")\n")
+                                                else:
+                                                    yield make_chunk(f"![Generated Image]({base64_str})\n")
+                                            else:
+                                                yield make_chunk(f"![Generated Image]({base64_str})\n")
+                                        else:
+                                            yield make_chunk(f"![Generated Image](https://assets.grok.com/{img})\n")
+                                    else:
+                                        # URL模式
+                                        await image_cache_service.download_image(f"/{img}", auth_token)
+                                        img_path = img.replace('/', '-')
+                                        base_url = setting.global_config.get("base_url", "")
+                                        img_url = f"{base_url}/images/{img_path}" if base_url else f"/images/{img_path}"
+                                        content += f"![Generated Image]({img_url})\n"
+                                except Exception as e:
+                                    logger.warning(f"[Processor] 处理图片失败: {e}")
+                                    content += f"![Generated Image](https://assets.grok.com/{img})\n"
+
+                            yield make_chunk(content.strip(), "stop")
+                            return
+                        elif token:
+                            yield make_chunk(token)
+
+                    # 对话处理
+                    else:
+                        if isinstance(token, list):
+                            continue
+
+                        if any(tag in token for tag in filtered_tags if token):
+                            continue
+
+                        current_is_thinking = grok_resp.get("isThinking", False)
+                        message_tag = grok_resp.get("messageTag")
+
+                        if thinking_finished and current_is_thinking:
+                            continue
+
+                        # 搜索结果处理
+                        if grok_resp.get("toolUsageCardId"):
+                            if web_search := grok_resp.get("webSearchResults"):
+                                if current_is_thinking:
+                                    if show_thinking:
+                                        for result in web_search.get("results", []):
+                                            title = result.get("title", "")
+                                            url = result.get("url", "")
+                                            preview = result.get("preview", "")
+                                            preview_clean = preview.replace("\n", "") if isinstance(preview, str) else ""
+                                            token += f'\n- [{title}]({url} "{preview_clean}")'
+                                        token += "\n"
+                                    else:
+                                        continue
+                                else:
+                                    continue
+                            else:
+                                continue
+
+                        if token:
+                            content = token
+
+                            if message_tag == "header":
+                                content = f"\n\n{token}\n\n"
+
+                            # Thinking状态切换
+                            should_skip = False
+                            if not is_thinking and current_is_thinking:
+                                if show_thinking:
+                                    content = f"<think>\n{content}"
+                                else:
+                                    should_skip = True
+                            elif is_thinking and not current_is_thinking:
+                                if show_thinking:
+                                    content = f"\n</think>\n{content}"
+                                thinking_finished = True
+                            elif current_is_thinking:
+                                if not show_thinking:
+                                    should_skip = True
+
+                            if not should_skip:
+                                yield make_chunk(content)
+                            
+                            is_thinking = current_is_thinking
+
+                except (orjson.JSONDecodeError, UnicodeDecodeError) as e:
+                    logger.warning(f"[Processor] 解析失败: {e}")
+                    continue
+                except Exception as e:
+                    logger.warning(f"[Processor] 处理出错: {e}")
+                    continue
+
+            yield make_chunk("", "stop")
+            yield "data: [DONE]\n\n"
+            logger.info(f"[Processor] 流式完成，耗时: {timeout_mgr.duration():.2f}秒")
+
+        except Exception as e:
+            logger.error(f"[Processor] 严重错误: {e}")
+            yield make_chunk(f"处理错误: {e}", "error")
+            yield "data: [DONE]\n\n"
+        finally:
+            if not response_closed and hasattr(response, 'close'):
+                try:
+                    response.close()
+                    logger.debug("[Processor] 响应已关闭")
+                except Exception as e:
+                    logger.warning(f"[Processor] 关闭失败: {e}")
+            
+            if session:
+                try:
+                    await session.close()
+                    logger.debug("[Processor] 会话已关闭")
+                except Exception as e:
+                    logger.warning(f"[Processor] 关闭会话失败: {e}")
+
+    @staticmethod
+    async def _build_video_content(video_url: str, auth_token: str) -> str:
+        """构建视频内容"""
+        logger.debug(f"[Processor] 检测到视频: {video_url}")
+        full_url = f"https://assets.grok.com/{video_url}"
+        
+        try:
+            cache_path = await video_cache_service.download_video(f"/{video_url}", auth_token)
+            if cache_path:
+                video_path = video_url.replace('/', '-')
+                base_url = setting.global_config.get("base_url", "")
+                local_url = f"{base_url}/images/{video_path}" if base_url else f"/images/{video_path}"
+                return f'<video src="{local_url}" controls="controls" width="500" height="300"></video>\n'
+        except Exception as e:
+            logger.warning(f"[Processor] 缓存视频失败: {e}")
+        
+        return f'<video src="{full_url}" controls="controls" width="500" height="300"></video>\n'
+
+    @staticmethod
+    async def _append_images(content: str, images: list, auth_token: str) -> str:
+        """追加图片到内容"""
+        image_mode = setting.global_config.get("image_mode", "url")
+        
+        for img in images:
+            try:
+                if image_mode == "base64":
+                    base64_str = await image_cache_service.download_base64(f"/{img}", auth_token)
+                    if base64_str:
+                        content += f"\n![Generated Image]({base64_str})"
+                    else:
+                        content += f"\n![Generated Image](https://assets.grok.com/{img})"
+                else:
+                    cache_path = await image_cache_service.download_image(f"/{img}", auth_token)
+                    if cache_path:
+                        img_path = img.replace('/', '-')
+                        base_url = setting.global_config.get("base_url", "")
+                        img_url = f"{base_url}/images/{img_path}" if base_url else f"/images/{img_path}"
+                        content += f"\n![Generated Image]({img_url})"
+                    else:
+                        content += f"\n![Generated Image](https://assets.grok.com/{img})"
+            except Exception as e:
+                logger.warning(f"[Processor] 处理图片失败: {e}")
+                content += f"\n![Generated Image](https://assets.grok.com/{img})"
+        
+        return content
+
+    @staticmethod
+    def _build_response(content: str, model: str) -> OpenAIChatCompletionResponse:
+        """构建响应对象"""
+        return OpenAIChatCompletionResponse(
+            id=f"chatcmpl-{uuid.uuid4()}",
+            object="chat.completion",
+            created=int(time.time()),
+            model=model,
+            choices=[OpenAIChatCompletionChoice(
+                index=0,
+                message=OpenAIChatCompletionMessage(
+                    role="assistant",
+                    content=content
+                ),
+                finish_reason="stop"
+            )],
+            usage=None
+        )

app/services/grok/statsig.py

@@ -0,0 +1,80 @@
+"""Grok 请求头管理 - 生成动态请求头和Statsig ID"""
+
+import base64
+import random
+import string
+import uuid
+from typing import Dict
+
+from app.core.logger import logger
+from app.core.config import setting
+
+
+# 基础请求头
+BASE_HEADERS = {
+    "Accept": "*/*",
+    "Accept-Language": "zh-CN,zh;q=0.9",
+    "Accept-Encoding": "gzip, deflate, br, zstd",
+    "Connection": "keep-alive",
+    "Origin": "https://grok.com",
+    "Priority": "u=1, i",
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
+    "Sec-Ch-Ua": '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"',
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Platform": '"macOS"',
+    "Sec-Fetch-Dest": "empty",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "same-origin",
+    "Baggage": "sentry-environment=production,sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c",
+}
+
+
+def _random_string(length: int, letters_only: bool = True) -> str:
+    """生成随机字符串"""
+    chars = string.ascii_lowercase if letters_only else string.ascii_lowercase + string.digits
+    return ''.join(random.choices(chars, k=length))
+
+
+def _generate_statsig_id() -> str:
+    """生成x-statsig-id
+    
+    随机选择两种格式：
+    1. e:TypeError: Cannot read properties of null (reading 'children['xxxxx']')
+    2. e:TypeError: Cannot read properties of undefined (reading 'xxxxxxxxxx')
+    """
+    if random.choice([True, False]):
+        rand = _random_string(5, letters_only=False)
+        msg = f"e:TypeError: Cannot read properties of null (reading 'children['{rand}']')"
+    else:
+        rand = _random_string(10)
+        msg = f"e:TypeError: Cannot read properties of undefined (reading '{rand}')"
+    
+    return base64.b64encode(msg.encode()).decode()
+
+
+def get_dynamic_headers(pathname: str = "/rest/app-chat/conversations/new") -> Dict[str, str]:
+    """获取请求头
+    
+    Args:
+        pathname: 请求路径
+        
+    Returns:
+        完整的请求头字典
+    """
+    # 获取或生成statsig-id
+    if setting.grok_config.get("dynamic_statsig", False):
+        statsig_id = _generate_statsig_id()
+        logger.debug(f"[Statsig] 动态生成: {statsig_id}")
+    else:
+        statsig_id = setting.grok_config.get("x_statsig_id")
+        if not statsig_id:
+            raise ValueError("配置文件中未设置 x_statsig_id")
+        logger.debug(f"[Statsig] 使用固定值: {statsig_id}")
+
+    # 构建请求头
+    headers = BASE_HEADERS.copy()
+    headers["x-statsig-id"] = statsig_id
+    headers["x-xai-request-id"] = str(uuid.uuid4())
+    headers["Content-Type"] = "text/plain;charset=UTF-8" if "upload-file" in pathname else "application/json"
+
+    return headers

app/services/grok/token.py

@@ -0,0 +1,619 @@
+"""Grok Token 管理器 - 单例模式的Token负载均衡和状态管理"""
+
+import orjson
+import time
+import asyncio
+import aiofiles
+import portalocker
+from pathlib import Path
+from curl_cffi.requests import AsyncSession
+from typing import Dict, Any, Optional, Tuple
+
+from app.models.grok_models import TokenType, Models
+from app.core.exception import GrokApiException
+from app.core.logger import logger
+from app.core.config import setting
+from app.services.grok.statsig import get_dynamic_headers
+
+
+# 常量
+RATE_LIMIT_API = "https://grok.com/rest/rate-limits"
+TIMEOUT = 30
+BROWSER = "chrome133a"
+MAX_FAILURES = 3
+TOKEN_INVALID = 401
+STATSIG_INVALID = 403
+
+# 冷却常量
+COOLDOWN_REQUESTS = 5              # 普通失败冷却请求数
+COOLDOWN_429_WITH_QUOTA = 3600     # 429+有额度冷却1小时（秒）
+COOLDOWN_429_NO_QUOTA = 36000      # 429+无额度冷却10小时（秒）
+
+
+class GrokTokenManager:
+    """Token管理器（单例）"""
+    
+    _instance: Optional['GrokTokenManager'] = None
+    _lock = asyncio.Lock()
+
+    def __new__(cls) -> 'GrokTokenManager':
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if hasattr(self, '_initialized'):
+            return
+
+        self.token_file = Path(__file__).parents[3] / "data" / "token.json"
+        self._file_lock = asyncio.Lock()
+        self.token_file.parent.mkdir(parents=True, exist_ok=True)
+        self._storage = None
+        self.token_data = None  # 延迟加载
+        
+        # 批量保存队列
+        self._save_pending = False  # 标记是否有待保存的数据
+        self._save_task = None  # 后台保存任务
+        self._shutdown = False  # 关闭标志
+        
+        # 冷却状态
+        self._cooldown_counts: Dict[str, int] = {}  # Token -> 剩余冷却次数
+        self._request_counter = 0  # 全局请求计数器
+        
+        # 刷新状态
+        self._refresh_lock = False  # 刷新锁
+        self._refresh_progress: Dict[str, Any] = {"running": False, "current": 0, "total": 0, "success": 0, "failed": 0}
+        
+        self._initialized = True
+        logger.debug(f"[Token] 初始化完成: {self.token_file}")
+
+    def set_storage(self, storage) -> None:
+        """设置存储实例"""
+        self._storage = storage
+
+    async def _load_data(self) -> None:
+        """异步加载Token数据（支持多进程）"""
+        default = {TokenType.NORMAL.value: {}, TokenType.SUPER.value: {}}
+        
+        def load_sync():
+            with open(self.token_file, "r", encoding="utf-8") as f:
+                portalocker.lock(f, portalocker.LOCK_SH)
+                try:
+                    return orjson.loads(f.read())
+                finally:
+                    portalocker.unlock(f)
+
+        try:
+            if self.token_file.exists():
+                # 使用进程锁读取文件
+                async with self._file_lock:
+                    self.token_data = await asyncio.to_thread(load_sync)
+            else:
+                self.token_data = default
+                logger.debug("[Token] 创建新数据文件")
+        except Exception as e:
+            logger.error(f"[Token] 加载失败: {e}")
+            self.token_data = default
+
+    async def _save_data(self) -> None:
+        """保存Token数据（支持多进程）"""
+        def save_sync(data):
+            with open(self.token_file, "w", encoding="utf-8") as f:
+                portalocker.lock(f, portalocker.LOCK_EX)
+                try:
+                    content = orjson.dumps(data, option=orjson.OPT_INDENT_2).decode()
+                    f.write(content)
+                    f.flush()
+                finally:
+                    portalocker.unlock(f)
+
+        try:
+            if not self._storage:
+                async with self._file_lock:
+                    await asyncio.to_thread(save_sync, self.token_data)
+            else:
+                await self._storage.save_tokens(self.token_data)
+        except Exception as e:
+            logger.error(f"[Token] 保存失败: {e}")
+            raise GrokApiException(f"保存失败: {e}", "TOKEN_SAVE_ERROR")
+
+    def _mark_dirty(self) -> None:
+        """标记有待保存的数据"""
+        self._save_pending = True
+
+    async def _batch_save_worker(self) -> None:
+        """批量保存后台任务"""
+        from app.core.config import setting
+        
+        interval = setting.global_config.get("batch_save_interval", 1.0)
+        logger.info(f"[Token] 存储任务已启动，间隔: {interval}s")
+        
+        while not self._shutdown:
+            await asyncio.sleep(interval)
+            
+            if self._save_pending and not self._shutdown:
+                try:
+                    await self._save_data()
+                    self._save_pending = False
+                    logger.debug("[Token] 存储完成")
+                except Exception as e:
+                    logger.error(f"[Token] 存储失败: {e}")
+
+    async def start_batch_save(self) -> None:
+        """启动批量保存任务"""
+        if self._save_task is None:
+            self._save_task = asyncio.create_task(self._batch_save_worker())
+            logger.info("[Token] 存储任务已创建")
+
+    async def shutdown(self) -> None:
+        """关闭并刷新所有待保存数据"""
+        self._shutdown = True
+        
+        if self._save_task:
+            self._save_task.cancel()
+            try:
+                await self._save_task
+            except asyncio.CancelledError:
+                pass
+        
+        # 最终刷新
+        if self._save_pending:
+            await self._save_data()
+            logger.info("[Token] 关闭时刷新完成")
+
+    @staticmethod
+    def _extract_sso(auth_token: str) -> Optional[str]:
+        """提取SSO值"""
+        if "sso=" in auth_token:
+            return auth_token.split("sso=")[1].split(";")[0]
+        logger.warning("[Token] 无法提取SSO值")
+        return None
+
+    def _find_token(self, sso: str) -> Tuple[Optional[str], Optional[Dict]]:
+        """查找Token"""
+        for token_type in [TokenType.NORMAL.value, TokenType.SUPER.value]:
+            if sso in self.token_data[token_type]:
+                return token_type, self.token_data[token_type][sso]
+        return None, None
+
+    async def add_token(self, tokens: list[str], token_type: TokenType) -> None:
+        """添加Token"""
+        if not tokens:
+            return
+
+        count = 0
+        for token in tokens:
+            if not token or not token.strip():
+                continue
+
+            self.token_data[token_type.value][token] = {
+                "createdTime": int(time.time() * 1000),
+                "remainingQueries": -1,
+                "heavyremainingQueries": -1,
+                "status": "active",
+                "failedCount": 0,
+                "lastFailureTime": None,
+                "lastFailureReason": None,
+                "tags": [],
+                "note": ""
+            }
+            count += 1
+
+        self._mark_dirty()  # 批量保存
+        logger.info(f"[Token] 添加 {count} 个 {token_type.value} Token")
+
+    async def delete_token(self, tokens: list[str], token_type: TokenType) -> None:
+        """删除Token"""
+        if not tokens:
+            return
+
+        count = 0
+        for token in tokens:
+            if token in self.token_data[token_type.value]:
+                del self.token_data[token_type.value][token]
+                count += 1
+
+        self._mark_dirty()  # 批量保存
+        logger.info(f"[Token] 删除 {count} 个 {token_type.value} Token")
+
+    async def update_token_tags(self, token: str, token_type: TokenType, tags: list[str]) -> None:
+        """更新Token标签"""
+        if token not in self.token_data[token_type.value]:
+            raise GrokApiException("Token不存在", "TOKEN_NOT_FOUND", {"token": token[:10]})
+        
+        cleaned = [t.strip() for t in tags if t and t.strip()]
+        self.token_data[token_type.value][token]["tags"] = cleaned
+        self._mark_dirty()  # 批量保存
+        logger.info(f"[Token] 更新标签: {token[:10]}... -> {cleaned}")
+
+    async def update_token_note(self, token: str, token_type: TokenType, note: str) -> None:
+        """更新Token备注"""
+        if token not in self.token_data[token_type.value]:
+            raise GrokApiException("Token不存在", "TOKEN_NOT_FOUND", {"token": token[:10]})
+        
+        self.token_data[token_type.value][token]["note"] = note.strip()
+        self._mark_dirty()  # 批量保存
+        logger.info(f"[Token] 更新备注: {token[:10]}...")
+    
+    def get_tokens(self) -> Dict[str, Any]:
+        """获取所有Token"""
+        return self.token_data.copy()
+
+    async def _reload_if_needed(self) -> None:
+        """在多进程模式下重新加载数据"""
+        # 只在文件模式且多进程环境下才重新加载
+        if self._storage:
+            return
+        
+        def reload_sync():
+            with open(self.token_file, "r", encoding="utf-8") as f:
+                portalocker.lock(f, portalocker.LOCK_SH)
+                try:
+                    return orjson.loads(f.read())
+                finally:
+                    portalocker.unlock(f)
+
+        try:
+            if self.token_file.exists():
+                self.token_data = await asyncio.to_thread(reload_sync)
+        except Exception as e:
+            logger.warning(f"[Token] 重新加载失败: {e}")
+
+    async def get_token(self, model: str) -> str:
+        """获取Token"""
+        jwt = await self.select_token(model)
+        return f"sso-rw={jwt};sso={jwt}"
+    
+    async def select_token(self, model: str) -> str:
+        """选择最优Token（多进程安全，支持冷却）"""
+        # 重新加载最新数据（多进程模式）
+        await self._reload_if_needed()
+        
+        # 递减所有次数冷却计数
+        self._request_counter += 1
+        for token in list(self._cooldown_counts.keys()):
+            self._cooldown_counts[token] -= 1
+            if self._cooldown_counts[token] <= 0:
+                del self._cooldown_counts[token]
+                logger.debug(f"[Token] 冷却结束: {token[:10]}...")
+        
+        current_time = time.time() * 1000  # 毫秒
+        
+        def select_best(tokens: Dict[str, Any], field: str) -> Tuple[Optional[str], Optional[int]]:
+            """选择最佳Token"""
+            unused, used = [], []
+
+            for key, data in tokens.items():
+                # 跳过已失效的token
+                if data.get("status") == "expired":
+                    continue
+                
+                # 跳过失败次数过多的token（任何错误状态码）
+                if data.get("failedCount", 0) >= MAX_FAILURES:
+                    continue
+                
+                # 跳过次数冷却中的token
+                if key in self._cooldown_counts:
+                    continue
+                
+                # 跳过时间冷却中的token（429）
+                cooldown_until = data.get("cooldownUntil", 0)
+                if cooldown_until and cooldown_until > current_time:
+                    continue
+
+                remaining = int(data.get(field, -1))
+                if remaining == 0:
+                    continue
+
+                if remaining == -1:
+                    unused.append(key)
+                elif remaining > 0:
+                    used.append((key, remaining))
+
+            if unused:
+                return unused[0], -1
+            if used:
+                used.sort(key=lambda x: x[1], reverse=True)
+                return used[0][0], used[0][1]
+            return None, None
+
+        # 快照
+        snapshot = {
+            TokenType.NORMAL.value: self.token_data[TokenType.NORMAL.value].copy(),
+            TokenType.SUPER.value: self.token_data[TokenType.SUPER.value].copy()
+        }
+
+        # 选择策略
+        if model == "grok-4-heavy":
+            field = "heavyremainingQueries"
+            token_key, remaining = select_best(snapshot[TokenType.SUPER.value], field)
+        else:
+            field = "remainingQueries"
+            token_key, remaining = select_best(snapshot[TokenType.NORMAL.value], field)
+            if token_key is None:
+                token_key, remaining = select_best(snapshot[TokenType.SUPER.value], field)
+
+        if token_key is None:
+            raise GrokApiException(
+                f"没有可用Token: {model}",
+                "NO_AVAILABLE_TOKEN",
+                {
+                    "model": model,
+                    "normal": len(snapshot[TokenType.NORMAL.value]),
+                    "super": len(snapshot[TokenType.SUPER.value]),
+                    "cooldown_count": len(self._cooldown_counts)
+                }
+            )
+
+        status = "未使用" if remaining == -1 else f"剩余{remaining}次"
+        logger.debug(f"[Token] 分配Token: {model} ({status})")
+        return token_key
+    
+    async def check_limits(self, auth_token: str, model: str) -> Optional[Dict[str, Any]]:
+        """检查速率限制"""
+        try:
+            rate_model = Models.to_rate_limit(model)
+            payload = {"requestKind": "DEFAULT", "modelName": rate_model}
+            
+            cf = setting.grok_config.get("cf_clearance", "")
+            headers = get_dynamic_headers("/rest/rate-limits")
+            headers["Cookie"] = f"{auth_token};{cf}" if cf else auth_token
+
+            # 外层重试：可配置状态码（401/429等）
+            retry_codes = setting.grok_config.get("retry_status_codes", [401, 429])
+            MAX_OUTER_RETRY = 3
+            
+            for outer_retry in range(MAX_OUTER_RETRY + 1):  # +1 确保实际重试3次
+                # 内层重试：403代理池重试
+                max_403_retries = 5
+                retry_403_count = 0
+                
+                while retry_403_count <= max_403_retries:
+                    # 异步获取代理（支持代理池）
+                    from app.core.proxy_pool import proxy_pool
+                    
+                    # 如果是403重试且使用代理池，强制刷新代理
+                    if retry_403_count > 0 and proxy_pool._enabled:
+                        logger.info(f"[Token] 403重试 {retry_403_count}/{max_403_retries}，刷新代理...")
+                        proxy = await proxy_pool.force_refresh()
+                    else:
+                        proxy = await setting.get_proxy_async("service")
+                    
+                    proxies = {"http": proxy, "https": proxy} if proxy else None
+                    
+                    async with AsyncSession() as session:
+                        response = await session.post(
+                            RATE_LIMIT_API,
+                            headers=headers,
+                            json=payload,
+                            impersonate=BROWSER,
+                            timeout=TIMEOUT,
+                            proxies=proxies
+                        )
+
+                        # 内层403重试：仅当有代理池时触发
+                        if response.status_code == 403 and proxy_pool._enabled:
+                            retry_403_count += 1
+                            
+                            if retry_403_count <= max_403_retries:
+                                logger.warning(f"[Token] 遇到403错误，正在重试 ({retry_403_count}/{max_403_retries})...")
+                                await asyncio.sleep(0.5)
+                                continue
+                            
+                            # 内层重试全部失败
+                            logger.error(f"[Token] 403错误，已重试{retry_403_count-1}次，放弃")
+                            sso = self._extract_sso(auth_token)
+                            if sso:
+                                await self.record_failure(auth_token, 403, "服务器被Block")
+                        
+                        # 检查可配置状态码错误 - 外层重试
+                        if response.status_code in retry_codes:
+                            if outer_retry < MAX_OUTER_RETRY:
+                                delay = (outer_retry + 1) * 0.1  # 渐进延迟：0.1s, 0.2s, 0.3s
+                                logger.warning(f"[Token] 遇到{response.status_code}错误，外层重试 ({outer_retry+1}/{MAX_OUTER_RETRY})，等待{delay}s...")
+                                await asyncio.sleep(delay)
+                                break  # 跳出内层循环，进入外层重试
+                            else:
+                                logger.error(f"[Token] {response.status_code}错误，已重试{outer_retry}次，放弃")
+                                sso = self._extract_sso(auth_token)
+                                if sso:
+                                    if response.status_code == 401:
+                                        await self.record_failure(auth_token, 401, "Token失效")
+                                    else:
+                                        await self.record_failure(auth_token, response.status_code, f"错误: {response.status_code}")
+                                return None
+
+                        if response.status_code == 200:
+                            data = response.json()
+                            sso = self._extract_sso(auth_token)
+                            
+                            if outer_retry > 0 or retry_403_count > 0:
+                                logger.info(f"[Token] 重试成功！")
+                            
+                            if sso:
+                                if model == "grok-4-heavy":
+                                    await self.update_limits(sso, normal=None, heavy=data.get("remainingQueries", -1))
+                                    logger.info(f"[Token] 更新限制: {sso[:10]}..., heavy={data.get('remainingQueries', -1)}")
+                                else:
+                                    await self.update_limits(sso, normal=data.get("remainingTokens", -1), heavy=None)
+                                    logger.info(f"[Token] 更新限制: {sso[:10]}..., basic={data.get('remainingTokens', -1)}")
+                            
+                            return data
+                        else:
+                            # 其他错误
+                            logger.warning(f"[Token] 获取限制失败: {response.status_code}")
+                            sso = self._extract_sso(auth_token)
+                            if sso:
+                                await self.record_failure(auth_token, response.status_code, f"错误: {response.status_code}")
+                            return None
+
+        except Exception as e:
+            logger.error(f"[Token] 检查限制错误: {e}")
+            return None
+
+    async def update_limits(self, sso: str, normal: Optional[int] = None, heavy: Optional[int] = None) -> None:
+        """更新限制"""
+        try:
+            for token_type in [TokenType.NORMAL.value, TokenType.SUPER.value]:
+                if sso in self.token_data[token_type]:
+                    if normal is not None:
+                        self.token_data[token_type][sso]["remainingQueries"] = normal
+                    if heavy is not None:
+                        self.token_data[token_type][sso]["heavyremainingQueries"] = heavy
+                    self._mark_dirty()  # 批量保存
+                    logger.info(f"[Token] 更新限制: {sso[:10]}...")
+                    return
+            logger.warning(f"[Token] 未找到: {sso[:10]}...")
+        except Exception as e:
+            logger.error(f"[Token] 更新限制错误: {e}")
+    
+    async def record_failure(self, auth_token: str, status: int, msg: str) -> None:
+        """记录失败"""
+        try:
+            if status == STATSIG_INVALID:
+                logger.warning("[Token] IP被Block，请: 1.更换IP 2.使用代理 3.配置CF值")
+                return
+
+            sso = self._extract_sso(auth_token)
+            if not sso:
+                return
+
+            _, data = self._find_token(sso)
+            if not data:
+                logger.warning(f"[Token] 未找到: {sso[:10]}...")
+                return
+
+            data["failedCount"] = data.get("failedCount", 0) + 1
+            data["lastFailureTime"] = int(time.time() * 1000)
+            data["lastFailureReason"] = f"{status}: {msg}"
+
+            logger.warning(
+                f"[Token] 失败: {sso[:10]}... (状态:{status}), "
+                f"次数: {data['failedCount']}/{MAX_FAILURES}, 原因: {msg}"
+            )
+
+            if 400 <= status < 500 and data["failedCount"] >= MAX_FAILURES:
+                data["status"] = "expired"
+                logger.error(f"[Token] 标记失效: {sso[:10]}... (连续{status}错误{data['failedCount']}次)")
+
+            self._mark_dirty()  # 批量保存
+
+        except Exception as e:
+            logger.error(f"[Token] 记录失败错误: {e}")
+
+    async def reset_failure(self, auth_token: str) -> None:
+        """重置失败计数"""
+        try:
+            sso = self._extract_sso(auth_token)
+            if not sso:
+                return
+
+            _, data = self._find_token(sso)
+            if not data:
+                return
+
+            if data.get("failedCount", 0) > 0:
+                data["failedCount"] = 0
+                data["lastFailureTime"] = None
+                data["lastFailureReason"] = None
+                self._mark_dirty()  # 批量保存
+                logger.info(f"[Token] 重置失败计数: {sso[:10]}...")
+
+        except Exception as e:
+            logger.error(f"[Token] 重置失败错误: {e}")
+
+    async def apply_cooldown(self, auth_token: str, status_code: int) -> None:
+        """应用冷却策略
+        - 429 错误：使用时间冷却（有额度1小时，无额度10小时）
+        - 其他错误：使用次数冷却（5次请求）
+        """
+        try:
+            sso = self._extract_sso(auth_token)
+            if not sso:
+                return
+            
+            _, data = self._find_token(sso)
+            if not data:
+                return
+            
+            remaining = data.get("remainingQueries", -1)
+            
+            if status_code == 429:
+                # 429 使用时间冷却
+                if remaining > 0 or remaining == -1:
+                    # 有额度：冷却1小时
+                    cooldown_until = time.time() + COOLDOWN_429_WITH_QUOTA
+                    logger.info(f"[Token] 429冷却(有额度): {sso[:10]}... 冷却1小时")
+                else:
+                    # 无额度：冷却10小时
+                    cooldown_until = time.time() + COOLDOWN_429_NO_QUOTA
+                    logger.info(f"[Token] 429冷却(无额度): {sso[:10]}... 冷却10小时")
+                data["cooldownUntil"] = int(cooldown_until * 1000)
+                self._mark_dirty()
+            else:
+                # 其他错误使用次数冷却（有额度时才冷却）
+                if remaining != 0:
+                    self._cooldown_counts[sso] = COOLDOWN_REQUESTS
+                    logger.info(f"[Token] 次数冷却: {sso[:10]}... 冷却{COOLDOWN_REQUESTS}次请求")
+        
+        except Exception as e:
+            logger.error(f"[Token] 应用冷却错误: {e}")
+
+    async def refresh_all_limits(self) -> Dict[str, Any]:
+        """刷新所有 Token 的剩余次数"""
+        # 检查是否已在刷新
+        if self._refresh_lock:
+            return {"error": "refresh_in_progress", "message": "已有刷新任务在进行中", "progress": self._refresh_progress}
+        
+        # 获取锁
+        self._refresh_lock = True
+        
+        try:
+            # 计算总数
+            all_tokens = []
+            for token_type in [TokenType.NORMAL.value, TokenType.SUPER.value]:
+                for sso in list(self.token_data[token_type].keys()):
+                    all_tokens.append((token_type, sso))
+            
+            total = len(all_tokens)
+            self._refresh_progress = {"running": True, "current": 0, "total": total, "success": 0, "failed": 0}
+            
+            success_count = 0
+            fail_count = 0
+            
+            for i, (token_type, sso) in enumerate(all_tokens):
+                auth_token = f"sso-rw={sso};sso={sso}"
+                try:
+                    result = await self.check_limits(auth_token, "grok-4-fast")
+                    if result:
+                        success_count += 1
+                    else:
+                        fail_count += 1
+                except Exception as e:
+                    logger.warning(f"[Token] 刷新失败: {sso[:10]}... - {e}")
+                    fail_count += 1
+                
+                # 更新进度
+                self._refresh_progress = {
+                    "running": True,
+                    "current": i + 1,
+                    "total": total,
+                    "success": success_count,
+                    "failed": fail_count
+                }
+                await asyncio.sleep(0.1)  # 避免请求过快
+            
+            logger.info(f"[Token] 批量刷新完成: 成功{success_count}, 失败{fail_count}")
+            self._refresh_progress = {"running": False, "current": total, "total": total, "success": success_count, "failed": fail_count}
+            return {"success": success_count, "failed": fail_count, "total": total}
+        
+        finally:
+            self._refresh_lock = False
+    
+    def get_refresh_progress(self) -> Dict[str, Any]:
+        """获取刷新进度"""
+        return self._refresh_progress.copy()
+
+
+# 全局实例
+token_manager = GrokTokenManager()

app/services/grok/upload.py

@@ -0,0 +1,209 @@
+"""图片上传管理器 - 支持Base64和URL图片上传"""
+
+import asyncio
+import base64
+import re
+from typing import Tuple, Optional
+from urllib.parse import urlparse
+from curl_cffi.requests import AsyncSession
+
+from app.services.grok.statsig import get_dynamic_headers
+from app.core.exception import GrokApiException
+from app.core.config import setting
+from app.core.logger import logger
+
+
+# 常量
+UPLOAD_API = "https://grok.com/rest/app-chat/upload-file"
+TIMEOUT = 30
+BROWSER = "chrome133a"
+
+# MIME类型
+MIME_TYPES = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+    '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp',
+}
+DEFAULT_MIME = "image/jpeg"
+DEFAULT_EXT = "jpg"
+
+
+class ImageUploadManager:
+    """图片上传管理器"""
+
+    @staticmethod
+    async def upload(image_input: str, auth_token: str) -> Tuple[str, str]:
+        """上传图片（支持Base64或URL）
+        
+        Returns:
+            (file_id, file_uri) 元组
+        """
+        try:
+            # 判断类型并处理
+            if ImageUploadManager._is_url(image_input):
+                buffer, mime = await ImageUploadManager._download(image_input)
+                filename, _ = ImageUploadManager._get_info("", mime)
+            else:
+                buffer = image_input.split(",")[1] if "data:image" in image_input else image_input
+                filename, mime = ImageUploadManager._get_info(image_input)
+
+            # 构建数据
+            data = {
+                "fileName": filename,
+                "fileMimeType": mime,
+                "content": buffer,
+            }
+
+
+            if not auth_token:
+                raise GrokApiException("认证令牌缺失", "NO_AUTH_TOKEN")
+
+            # 外层重试：可配置状态码（401/429等）
+            retry_codes = setting.grok_config.get("retry_status_codes", [401, 429])
+            MAX_OUTER_RETRY = 3
+            
+            for outer_retry in range(MAX_OUTER_RETRY + 1):  # +1 确保实际重试3次
+                try:
+                    # 内层重试：403代理池重试
+                    max_403_retries = 5
+                    retry_403_count = 0
+                    
+                    while retry_403_count <= max_403_retries:
+                        # 请求配置
+                        cf = setting.grok_config.get("cf_clearance", "")
+                        headers = {
+                            **get_dynamic_headers("/rest/app-chat/upload-file"),
+                            "Cookie": f"{auth_token};{cf}" if cf else auth_token,
+                        }
+                        
+                        # 异步获取代理（支持代理池）
+                        from app.core.proxy_pool import proxy_pool
+                        
+                        # 如果是403重试且使用代理池，强制刷新代理
+                        if retry_403_count > 0 and proxy_pool._enabled:
+                            logger.info(f"[Upload] 403重试 {retry_403_count}/{max_403_retries}，刷新代理...")
+                            proxy = await proxy_pool.force_refresh()
+                        else:
+                            proxy = await setting.get_proxy_async("service")
+                        
+                        proxies = {"http": proxy, "https": proxy} if proxy else None
+
+                        # 上传
+                        async with AsyncSession() as session:
+                            response = await session.post(
+                                UPLOAD_API,
+                                headers=headers,
+                                json=data,
+                                impersonate=BROWSER,
+                                timeout=TIMEOUT,
+                                proxies=proxies,
+                            )
+
+                            # 内层403重试：仅当有代理池时触发
+                            if response.status_code == 403 and proxy_pool._enabled:
+                                retry_403_count += 1
+                                
+                                if retry_403_count <= max_403_retries:
+                                    logger.warning(f"[Upload] 遇到403错误，正在重试 ({retry_403_count}/{max_403_retries})...")
+                                    await asyncio.sleep(0.5)
+                                    continue
+                                
+                                # 内层重试全部失败
+                                logger.error(f"[Upload] 403错误，已重试{retry_403_count-1}次，放弃")
+                            
+                            # 检查可配置状态码错误 - 外层重试
+                            if response.status_code in retry_codes:
+                                if outer_retry < MAX_OUTER_RETRY:
+                                    delay = (outer_retry + 1) * 0.1  # 渐进延迟：0.1s, 0.2s, 0.3s
+                                    logger.warning(f"[Upload] 遇到{response.status_code}错误，外层重试 ({outer_retry+1}/{MAX_OUTER_RETRY})，等待{delay}s...")
+                                    await asyncio.sleep(delay)
+                                    break  # 跳出内层循环，进入外层重试
+                                else:
+                                    logger.error(f"[Upload] {response.status_code}错误，已重试{outer_retry}次，放弃")
+                                    return "", ""
+                            
+                            if response.status_code == 200:
+                                result = response.json()
+                                file_id = result.get("fileMetadataId", "")
+                                file_uri = result.get("fileUri", "")
+                                
+                                if outer_retry > 0 or retry_403_count > 0:
+                                    logger.info(f"[Upload] 重试成功！")
+                                
+                                logger.debug(f"[Upload] 成功，ID: {file_id}")
+                                return file_id, file_uri
+                            
+                            # 其他错误直接返回
+                            logger.error(f"[Upload] 失败，状态码: {response._status_code}")
+                            return "", ""
+                    
+                    # 内层循环正常结束（非break），说明403重试全部失败
+                    return "", ""
+                
+                except Exception as e:
+                    if outer_retry < MAX_OUTER_RETRY - 1:
+                        logger.warning(f"[Upload] 异常: {e}，外层重试 ({outer_retry+1}/{MAX_OUTER_RETRY})...")
+                        await asyncio.sleep(0.5)
+                        continue
+                    
+                    logger.warning(f"[Upload] 失败: {e}")
+                    return "", ""
+            
+            return "", ""
+
+        except Exception as e:
+            logger.warning(f"[Upload] 失败: {e}")
+            return "", ""
+
+    @staticmethod
+    def _is_url(input_str: str) -> bool:
+        """检查是否为URL"""
+        try:
+            result = urlparse(input_str)
+            return all([result.scheme, result.netloc]) and result.scheme in ['http', 'https']
+        except:
+            return False
+
+    @staticmethod
+    async def _download(url: str) -> Tuple[str, str]:
+        """下载图片并转Base64
+        
+        Returns:
+            (base64_string, mime_type) 元组
+        """
+        try:
+            async with AsyncSession() as session:
+                response = await session.get(url, timeout=5)
+                response.raise_for_status()
+
+                content_type = response.headers.get('content-type', DEFAULT_MIME)
+                if not content_type.startswith('image/'):
+                    content_type = DEFAULT_MIME
+
+                b64 = base64.b64encode(response.content).decode()
+                return b64, content_type
+        except Exception as e:
+            logger.warning(f"[Upload] 下载失败: {e}")
+            return "", ""
+
+    @staticmethod
+    def _get_info(image_data: str, mime_type: Optional[str] = None) -> Tuple[str, str]:
+        """获取文件名和MIME类型
+        
+        Returns:
+            (file_name, mime_type) 元组
+        """
+        # 已提供MIME类型
+        if mime_type:
+            ext = mime_type.split("/")[1] if "/" in mime_type else DEFAULT_EXT
+            return f"image.{ext}", mime_type
+
+        # 从Base64提取
+        mime = DEFAULT_MIME
+        ext = DEFAULT_EXT
+
+        if "data:image" in image_data:
+            if match := re.search(r"data:([a-zA-Z0-9]+/[a-zA-Z0-9-.+]+);base64,", image_data):
+                mime = match.group(1)
+                ext = mime.split("/")[1]
+
+        return f"image.{ext}", mime

app/services/mcp/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""MCP模块初始化"""
+
+from app.services.mcp.server import mcp
+
+__all__ = ["mcp"]

app/services/mcp/server.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+"""FastMCP服务器实例"""
+
+from fastmcp import FastMCP
+from fastmcp.server.auth.providers.jwt import StaticTokenVerifier
+from app.services.mcp.tools import ask_grok_impl
+from app.core.config import setting
+
+
+def create_mcp_server() -> FastMCP:
+    """创建MCP服务器实例，如果配置了API密钥则启用认证"""
+    # 检查是否配置了API密钥
+    api_key = setting.grok_config.get("api_key")
+    
+    # 如果配置了API密钥，则启用静态token验证
+    auth = None
+    if api_key:
+        auth = StaticTokenVerifier(
+            tokens={
+                api_key: {
+                    "client_id": "grok2api-client",
+                    "scopes": ["read", "write", "admin"]
+                }
+            },
+            required_scopes=["read"]
+        )
+    
+    # 创建FastMCP实例
+    return FastMCP(
+        name="Grok2API-MCP",
+        instructions="MCP server providing Grok AI chat capabilities. Use ask_grok tool to interact with Grok AI models.",
+        auth=auth
+    )
+
+
+# 创建全局MCP实例
+mcp = create_mcp_server()
+
+
+# 注册ask_grok工具
+@mcp.tool
+async def ask_grok(
+    query: str,
+    model: str = "grok-3-fast",
+    system_prompt: str = None
+) -> str:
+    """
+    调用Grok AI进行对话，尤其适用于当用户询问最新信息，需要调用搜索功能，或是想了解社交平台动态（如Twitter(X)、Reddit等）时。
+
+    Args:
+        query: 用户的问题或指令
+        model: Grok模型名称,可选值: grok-3-fast(默认), grok-4-fast, grok-4-fast-expert, grok-4-expert, grok-4-heavy
+        system_prompt: 可选的系统提示词,用于设定AI的角色或行为约束
+
+    Returns:
+        Grok AI的完整回复内容,可能包括文本和图片链接(Markdown格式)
+
+    Examples:
+        - 简单问答: ask_grok("什么是Python?")
+        - 指定模型: ask_grok("解释量子计算", model="grok-4-fast")
+        - 带系统提示: ask_grok("写一首诗", system_prompt="你是一位古典诗人")
+    """
+    return await ask_grok_impl(query, model, system_prompt)

app/services/mcp/tools.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+"""MCP Tools - Grok AI 对话工具"""
+
+import json
+from typing import Optional
+from app.services.grok.client import GrokClient
+from app.core.logger import logger
+from app.core.exception import GrokApiException
+
+
+async def ask_grok_impl(
+    query: str,
+    model: str = "grok-3-fast",
+    system_prompt: Optional[str] = None
+) -> str:
+    """
+    内部实现: 调用Grok API并收集完整响应
+
+    Args:
+        query: 用户问题
+        model: 模型名称
+        system_prompt: 系统提示词
+
+    Returns:
+        str: 完整的Grok响应内容
+    """
+    try:
+        # 构建消息列表
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": query})
+
+        # 构建请求
+        request_data = {
+            "model": model,
+            "messages": messages,
+            "stream": True
+        }
+
+        logger.info(f"[MCP] ask_grok 调用, 模型: {model}")
+
+        # 调用Grok客户端(流式)
+        response_iterator = await GrokClient.openai_to_grok(request_data)
+
+        # 收集所有流式响应块
+        content_parts = []
+        async for chunk in response_iterator:
+            if isinstance(chunk, bytes):
+                chunk = chunk.decode('utf-8')
+
+            # 解析SSE格式
+            if chunk.startswith("data: "):
+                data_str = chunk[6:].strip()
+                if data_str == "[DONE]":
+                    break
+
+                try:
+                    data = json.loads(data_str)
+                    choices = data.get("choices", [])
+                    if choices:
+                        delta = choices[0].get("delta", {})
+                        if content := delta.get("content"):
+                            content_parts.append(content)
+                except json.JSONDecodeError:
+                    continue
+
+        result = "".join(content_parts)
+        logger.info(f"[MCP] ask_grok 完成, 响应长度: {len(result)}")
+        return result
+
+    except GrokApiException as e:
+        logger.error(f"[MCP] Grok API错误: {str(e)}")
+        raise Exception(f"Grok API调用失败: {str(e)}")
+    except Exception as e:
+        logger.error(f"[MCP] ask_grok异常: {str(e)}", exc_info=True)
+        raise Exception(f"处理请求时出错: {str(e)}")

app/services/request_logger.py

@@ -0,0 +1,143 @@
+"""请求日志审计 - 记录近期请求"""
+
+import time
+import asyncio
+import orjson
+from typing import List, Dict, Deque
+from collections import deque
+from dataclasses import dataclass, asdict
+from pathlib import Path
+
+from app.core.logger import logger
+
+@dataclass
+class RequestLog:
+    id: str
+    time: str
+    timestamp: float
+    ip: str
+    model: str
+    duration: float
+    status: int
+    key_name: str
+    token_suffix: str
+    error: str = ""
+
+class RequestLogger:
+    """请求日志记录器"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self, max_len: int = 1000):
+        if hasattr(self, '_initialized'):
+            return
+            
+        self.file_path = Path(__file__).parents[2] / "data" / "logs.json"
+        self._logs: Deque[Dict] = deque(maxlen=max_len)
+        self._lock = asyncio.Lock()
+        self._loaded = False
+        
+        self._initialized = True
+
+    async def init(self):
+        """初始化加载数据"""
+        if not self._loaded:
+            await self._load_data()
+
+    async def _load_data(self):
+        """从磁盘加载日志数据"""
+        if self._loaded:
+            return
+
+        if not self.file_path.exists():
+            self._loaded = True
+            return
+
+        try:
+            async with self._lock:
+                content = await asyncio.to_thread(self.file_path.read_bytes)
+                if content:
+                    data = orjson.loads(content)
+                    if isinstance(data, list):
+                        self._logs.clear()
+                        self._logs.extend(data)
+                    self._loaded = True
+                    logger.debug(f"[Logger] 加载日志成功: {len(self._logs)} 条")
+        except Exception as e:
+            logger.error(f"[Logger] 加载日志失败: {e}")
+            self._loaded = True
+
+    async def _save_data(self):
+        """保存日志数据到磁盘"""
+        if not self._loaded:
+            return
+
+        try:
+            # 确保目录存在
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            async with self._lock:
+                # 转换为列表保存
+                content = orjson.dumps(list(self._logs))
+                await asyncio.to_thread(self.file_path.write_bytes, content)
+        except Exception as e:
+            logger.error(f"[Logger] 保存日志失败: {e}")
+
+    async def add_log(self, 
+                     ip: str, 
+                     model: str, 
+                     duration: float, 
+                     status: int, 
+                     key_name: str, 
+                     token_suffix: str = "",
+                     error: str = ""):
+        """添加日志"""
+        if not self._loaded:
+            await self.init()
+            
+        try:
+            now = time.time()
+            # 格式化时间
+            time_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(now))
+            
+            log = {
+                "id": str(int(now * 1000)),
+                "time": time_str,
+                "timestamp": now,
+                "ip": ip,
+                "model": model,
+                "duration": round(duration, 2),
+                "status": status,
+                "key_name": key_name,
+                "token_suffix": token_suffix,
+                "error": error
+            }
+            
+            async with self._lock:
+                self._logs.appendleft(log) # 最新的在前
+                
+            # 异步保存
+            asyncio.create_task(self._save_data())
+                
+        except Exception as e:
+            logger.error(f"[Logger] 记录日志失败: {e}")
+
+    async def get_logs(self, limit: int = 1000) -> List[Dict]:
+        """获取日志"""
+        async with self._lock:
+            return list(self._logs)[:limit]
+    
+    async def clear_logs(self):
+        """清空日志"""
+        async with self._lock:
+            self._logs.clear()
+        await self._save_data()
+
+
+# 全局实例
+request_logger = RequestLogger()

app/services/request_stats.py

@@ -0,0 +1,205 @@
+"""请求统计模块 - 按小时/天统计请求数据"""
+
+import time
+import asyncio
+import orjson
+from datetime import datetime
+from typing import Dict, Any
+from pathlib import Path
+from collections import defaultdict
+
+from app.core.logger import logger
+
+
+class RequestStats:
+    """请求统计管理器（单例）"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if hasattr(self, '_initialized'):
+            return
+        
+        self.file_path = Path(__file__).parents[2] / "data" / "stats.json"
+        
+        # 统计数据
+        self._hourly: Dict[str, Dict[str, int]] = defaultdict(lambda: {"total": 0, "success": 0, "failed": 0})
+        self._daily: Dict[str, Dict[str, int]] = defaultdict(lambda: {"total": 0, "success": 0, "failed": 0})
+        self._models: Dict[str, int] = defaultdict(int)
+        
+        # 保留策略
+        self._hourly_keep = 48  # 保留48小时
+        self._daily_keep = 30   # 保留30天
+        
+        self._lock = asyncio.Lock()
+        self._loaded = False
+        self._initialized = True
+
+    async def init(self):
+        """初始化加载数据"""
+        if not self._loaded:
+            await self._load_data()
+
+    async def _load_data(self):
+        """从磁盘加载统计数据"""
+        if self._loaded:
+            return
+
+        if not self.file_path.exists():
+            self._loaded = True
+            return
+
+        try:
+            async with self._lock:
+                content = await asyncio.to_thread(self.file_path.read_bytes)
+                if content:
+                    data = orjson.loads(content)
+                    
+                    # 恢复 defaultdict 结构
+                    self._hourly = defaultdict(lambda: {"total": 0, "success": 0, "failed": 0})
+                    self._hourly.update(data.get("hourly", {}))
+                    
+                    self._daily = defaultdict(lambda: {"total": 0, "success": 0, "failed": 0})
+                    self._daily.update(data.get("daily", {}))
+                    
+                    self._models = defaultdict(int)
+                    self._models.update(data.get("models", {}))
+                    
+                    self._loaded = True
+                    logger.debug(f"[Stats] 加载统计数据成功")
+        except Exception as e:
+            logger.error(f"[Stats] 加载数据失败: {e}")
+            self._loaded = True # 防止覆盖
+
+    async def _save_data(self):
+        """保存统计数据到磁盘"""
+        if not self._loaded:
+            return
+
+        try:
+            # 确保目录存在
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            async with self._lock:
+                data = {
+                    "hourly": dict(self._hourly),
+                    "daily": dict(self._daily),
+                    "models": dict(self._models)
+                }
+                content = orjson.dumps(data)
+                await asyncio.to_thread(self.file_path.write_bytes, content)
+        except Exception as e:
+            logger.error(f"[Stats] 保存数据失败: {e}")
+    
+    async def record_request(self, model: str, success: bool) -> None:
+        """记录一次请求"""
+        if not self._loaded:
+            await self.init()
+            
+        now = datetime.now()
+        hour_key = now.strftime("%Y-%m-%dT%H")
+        day_key = now.strftime("%Y-%m-%d")
+        
+        # 小时统计
+        self._hourly[hour_key]["total"] += 1
+        if success:
+            self._hourly[hour_key]["success"] += 1
+        else:
+            self._hourly[hour_key]["failed"] += 1
+        
+        # 天统计
+        self._daily[day_key]["total"] += 1
+        if success:
+            self._daily[day_key]["success"] += 1
+        else:
+            self._daily[day_key]["failed"] += 1
+        
+        # 模型统计
+        self._models[model] += 1
+        
+        # 定期清理旧数据
+        self._cleanup()
+        
+        # 异步保存
+        asyncio.create_task(self._save_data())
+    
+    def _cleanup(self) -> None:
+        """清理过期数据"""
+        now = datetime.now()
+        
+        # 清理小时数据
+        hour_keys = list(self._hourly.keys())
+        if len(hour_keys) > self._hourly_keep:
+            for key in sorted(hour_keys)[:-self._hourly_keep]:
+                del self._hourly[key]
+        
+        # 清理天数据
+        day_keys = list(self._daily.keys())
+        if len(day_keys) > self._daily_keep:
+            for key in sorted(day_keys)[:-self._daily_keep]:
+                del self._daily[key]
+    
+    def get_stats(self, hours: int = 24, days: int = 7) -> Dict[str, Any]:
+        """获取统计数据"""
+        now = datetime.now()
+        
+        # 获取最近N小时数据
+        hourly_data = []
+        for i in range(hours - 1, -1, -1):
+            from datetime import timedelta
+            dt = now - timedelta(hours=i)
+            key = dt.strftime("%Y-%m-%dT%H")
+            data = self._hourly.get(key, {"total": 0, "success": 0, "failed": 0})
+            hourly_data.append({
+                "hour": dt.strftime("%H:00"),
+                "date": dt.strftime("%m-%d"),
+                **data
+            })
+        
+        # 获取最近N天数据
+        daily_data = []
+        for i in range(days - 1, -1, -1):
+            from datetime import timedelta
+            dt = now - timedelta(days=i)
+            key = dt.strftime("%Y-%m-%d")
+            data = self._daily.get(key, {"total": 0, "success": 0, "failed": 0})
+            daily_data.append({
+                "date": dt.strftime("%m-%d"),
+                **data
+            })
+        
+        # 模型统计（取 Top 10）
+        model_data = sorted(self._models.items(), key=lambda x: x[1], reverse=True)[:10]
+        
+        # 总计
+        total_requests = sum(d["total"] for d in self._hourly.values())
+        total_success = sum(d["success"] for d in self._hourly.values())
+        total_failed = sum(d["failed"] for d in self._hourly.values())
+        
+        return {
+            "hourly": hourly_data,
+            "daily": daily_data,
+            "models": [{"model": m, "count": c} for m, c in model_data],
+            "summary": {
+                "total": total_requests,
+                "success": total_success,
+                "failed": total_failed,
+                "success_rate": round(total_success / total_requests * 100, 1) if total_requests > 0 else 0
+            }
+        }
+    
+    async def reset(self) -> None:
+        """重置所有统计"""
+        self._hourly.clear()
+        self._daily.clear()
+        self._models.clear()
+        await self._save_data()
+
+
+# 全局实例
+request_stats = RequestStats()

app/template/login.html

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="zh-CN" class="h-full">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>登录 - Grok2API</title>
+    <link rel="icon" type="image/png" href="/static/favicon.png">
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+        tailwind.config = { theme: { extend: { colors: { border: "hsl(0 0% 89%)", input: "hsl(0 0% 89%)", ring: "hsl(0 0% 3.9%)", background: "hsl(0 0% 100%)", foreground: "hsl(0 0% 3.9%)", primary: { DEFAULT: "hsl(0 0% 9%)", foreground: "hsl(0 0% 98%)" }, secondary: { DEFAULT: "hsl(0 0% 96.1%)", foreground: "hsl(0 0% 9%)" }, muted: { DEFAULT: "hsl(0 0% 96.1%)", foreground: "hsl(0 0% 45.1%)" }, destructive: { DEFAULT: "hsl(0 84.2% 60.2%)", foreground: "hsl(0 0% 98%)" } } } } }
+    </script>
+    <style>
+        @keyframes slide-up {
+            from {
+                transform: translateY(100%);
+                opacity: 0
+            }
+
+            to {
+                transform: translateY(0);
+                opacity: 1
+            }
+        }
+
+        .animate-slide-up {
+            animation: slide-up .3s ease-out
+        }
+    </style>
+</head>
+
+<body class="h-full bg-background text-foreground antialiased">
+    <div class="flex min-h-full flex-col justify-center py-12 px-4 sm:px-6 lg:px-8">
+        <div class="sm:mx-auto sm:w-full sm:max-w-md">
+            <div class="text-center">
+                <h1 class="text-4xl font-bold">Grok2API</h1>
+                <p class="mt-2 text-sm text-muted-foreground">管理员控制台</p>
+            </div>
+        </div>
+
+        <div class="sm:mx-auto sm:w-full sm:max-w-md">
+            <div class="bg-background py-8 px-4 sm:px-10 rounded-lg">
+                <form id="loginForm" class="space-y-6">
+                    <div class="space-y-2">
+                        <label for="username" class="text-sm font-medium">账户</label>
+                        <input type="text" id="username" name="username" required
+                            class="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
+                            placeholder="请输入账户">
+                    </div>
+                    <div class="space-y-2">
+                        <label for="password" class="text-sm font-medium">密码</label>
+                        <input type="password" id="password" name="password" required
+                            class="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:opacity-50"
+                            placeholder="请输入密码">
+                    </div>
+                    <button type="submit" id="loginButton"
+                        class="inline-flex items-center justify-center rounded-md font-medium transition-colors bg-primary text-primary-foreground hover:bg-primary/90 h-10 w-full disabled:opacity-50">登录</button>
+                </form>
+
+                <div class="mt-6 text-center text-xs text-muted-foreground space-y-1">
+                    <p>Created By Chenyme © 2025</p>
+                    <p>Fork 维护: @Tomiya233</p>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const form = document.getElementById('loginForm'), btn = document.getElementById('loginButton');
+        form.addEventListener('submit', async (e) => { e.preventDefault(); btn.disabled = true; btn.textContent = '登录中...'; try { const fd = new FormData(form), r = await fetch('/api/login', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ username: fd.get('username'), password: fd.get('password') }) }); const d = await r.json(); d.success ? (localStorage.setItem('adminToken', d.token), location.href = '/manage') : showToast(d.message || '登录失败', 'error') } catch (e) { showToast('网络错误，请稍后重试', 'error') } finally { btn.disabled = false; btn.textContent = '登录' } });
+        function showToast(m, t = 'error') { const d = document.createElement('div'), bc = { success: 'bg-green-600', error: 'bg-destructive', info: 'bg-primary' }; d.className = `fixed bottom-4 right-4 ${bc[t] || bc.error} text-white px-4 py-2.5 rounded-lg shadow-lg text-sm font-medium z-50 animate-slide-up`; d.textContent = m; document.body.appendChild(d); setTimeout(() => { d.style.opacity = '0'; d.style.transition = 'opacity .3s'; setTimeout(() => d.parentNode && document.body.removeChild(d), 300) }, 2000) }
+        window.addEventListener('DOMContentLoaded', () => { const t = localStorage.getItem('adminToken'); t && fetch('/api/stats', { headers: { Authorization: `Bearer ${t}` } }).then(r => { if (r.ok) location.href = '/manage' }) });
+    </script>
+</body>
+
+</html>

data/setting.toml

@@ -0,0 +1,25 @@
+[grok]
+api_key = ""
+proxy_url = ""
+cache_proxy_url = ""
+cf_clearance = ""
+x_statsig_id = "ZTpUeXBlRXJyb3I6IENhbm5vdCByZWFkIHByb3BlcnRpZXMgb2YgdW5kZWZpbmVkIChyZWFkaW5nICdjaGlsZE5vZGVzJyk="
+filtered_tags = "xaiartifact,xai:tool_usage_card,grok:render"
+stream_chunk_timeout = 120
+stream_total_timeout = 600
+stream_first_response_timeout = 30
+temporary = true
+show_thinking = true
+dynamic_statsig = true
+proxy_pool_url = ""
+proxy_pool_interval = 300
+retry_status_codes = [ 401, 429,]
+
+[global]
+base_url = ""
+log_level = "INFO"
+image_mode = "url"
+admin_password = "admin"
+admin_username = "admin"
+image_cache_max_size_mb = 512
+video_cache_max_size_mb = 1024

data/temp/video/users-8522ce45-679b-4e0e-a0f7-bb18f434eb6b-generated-15f7113f-5d16-4ff1-bdaa-a2eabd66671c-generated_video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fc94cc9cb116f2e561baa62d006d5a8c96a30dc7671acbcbcf7f4b6de11696a
+size 313620

data/token.json

@@ -0,0 +1,4 @@
+{
+  "ssoSuper": {},
+  "ssoNormal": {}
+}

docker-compose.yml

@@ -0,0 +1,25 @@
+services:
+  grok2api:
+    image: ghcr.io/chenyme/grok2api:latest
+    ports:
+      - "8000:8000"
+    volumes:
+      - grok_data:/app/data
+      - ./logs:/app/logs
+    environment:
+      # ===== 存储模式 =====
+      # 支持 file, mysql 或 redis
+      - STORAGE_MODE=file
+
+      # ===== 数据库 =====
+      # 仅在STORAGE_MODE=mysql或redis时需要
+      # - DATABASE_URL=mysql://user:password@host:3306/grok2api
+      # MySQL格式: mysql://user:password@host:port/database
+      # Redis格式: redis://host:port/db 或 redis://user:password@host:port/db
+
+      # ===== Worker数量 =====
+      # 默认1，建议：CPU核心数 * 2，多进程模式下建议使用MySQL/Redis存储
+      - WORKERS=1
+
+volumes:
+  grok_data:

docker-entrypoint.sh

@@ -0,0 +1,56 @@
+#!/bin/sh
+set -e
+
+# 初始化配置文件（如果不存在）
+echo "[Grok2API] 检查配置文件..."
+
+# 确保数据目录存在
+mkdir -p /app/data/temp/image /app/data/temp/video /app/logs
+
+# 如果 setting.toml 不存在，创建默认配置
+if [ ! -f /app/data/setting.toml ]; then
+    echo "[Grok2API] 初始化 setting.toml..."
+    cat > /app/data/setting.toml << 'EOF'
+[global]
+base_url = "http://localhost:8000"
+log_level = "INFO"
+image_mode = "url"
+admin_password = "admin"
+admin_username = "admin"
+image_cache_max_size_mb = 512
+video_cache_max_size_mb = 1024
+max_upload_concurrency = 20
+max_request_concurrency = 50
+batch_save_interval = 1.0
+batch_save_threshold = 10
+
+[grok]
+api_key = ""
+proxy_url = ""
+cache_proxy_url = ""
+cf_clearance = ""
+x_statsig_id = ""
+dynamic_statsig = true
+filtered_tags = "xaiartifact,xai:tool_usage_card,grok:render"
+stream_chunk_timeout = 120
+stream_total_timeout = 600
+stream_first_response_timeout = 30
+temporary = true
+show_thinking = true
+proxy_pool_url = ""
+proxy_pool_interval = 300
+retry_status_codes = [401, 429]
+EOF
+fi
+
+# 如果 token.json 不存在，创建空token文件
+if [ ! -f /app/data/token.json ]; then
+    echo "[Grok2API] 初始化 token.json..."
+    echo '{"ssoNormal": {}, "ssoSuper": {}}' > /app/data/token.json
+fi
+
+echo "[Grok2API] 配置文件检查完成"
+echo "[Grok2API] 启动应用..."
+
+# 执行传入的命令
+exec "$@"

main.py

@@ -0,0 +1,187 @@
+"""Grok2API"""
+
+import os
+import sys
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from app.core.logger import logger
+from app.core.exception import register_exception_handlers
+from app.core.storage import storage_manager
+from app.core.config import setting
+from app.services.grok.token import token_manager
+from app.api.v1.chat import router as chat_router
+from app.api.v1.models import router as models_router
+from app.api.v1.images import router as images_router
+from app.api.admin.manage import router as admin_router
+from app.services.mcp import mcp
+
+# 0. 兼容性检测
+try:
+    if sys.platform != 'win32':
+        import uvloop
+        uvloop.install()
+        logger.info("[Grok2API] 启用uvloop高性能事件循环")
+    else:
+        logger.info("[Grok2API] Windows系统，使用默认asyncio事件循环")
+except ImportError:
+    logger.info("[Grok2API] uvloop未安装，使用默认asyncio事件循环")
+
+# 1. 创建MCP的FastAPI应用实例
+mcp_app = mcp.http_app(stateless_http=True, transport="streamable-http")
+
+# 2. 定义应用生命周期
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    启动顺序:
+    1. 初始化核心服务 (storage, settings, token_manager)
+    2. 异步加载 token 数据
+    3. 启动批量保存任务
+    4. 启动MCP服务生命周期
+    
+    关闭顺序 (LIFO):
+    1. 关闭MCP服务生命周期
+    2. 关闭批量保存任务并刷新数据
+    3. 关闭核心服务
+    """
+    # --- 启动过程 ---
+    # 1. 初始化核心服务
+    await storage_manager.init()
+
+    # 设置存储到配置和token管理器
+    storage = storage_manager.get_storage()
+    setting.set_storage(storage)
+    token_manager.set_storage(storage)
+    
+    # 2. 重新加载配置
+    await setting.reload()
+    logger.info("[Grok2API] 核心服务初始化完成")
+    
+    # 2.5. 初始化代理池
+    from app.core.proxy_pool import proxy_pool
+    proxy_url = setting.grok_config.get("proxy_url", "")
+    proxy_pool_url = setting.grok_config.get("proxy_pool_url", "")
+    proxy_pool_interval = setting.grok_config.get("proxy_pool_interval", 300)
+    proxy_pool.configure(proxy_url, proxy_pool_url, proxy_pool_interval)
+    
+    # 3. 异步加载 token 数据
+    await token_manager._load_data()
+    logger.info("[Grok2API] Token数据加载完成")
+    
+    # 3.5. 加载 API Key 数据
+    from app.services.api_keys import api_key_manager
+    await api_key_manager.init()
+    logger.info("[Grok2API] API Key数据加载完成")
+
+    # 3.6. 加载统计和日志数据
+    from app.services.request_stats import request_stats
+    from app.services.request_logger import request_logger
+    await request_stats.init()
+    await request_logger.init()
+    logger.info("[Grok2API] 统计和日志数据加载完成")
+    
+    # 4. 启动批量保存任务
+    await token_manager.start_batch_save()
+
+    # 5. 管理MCP服务的生命周期
+    mcp_lifespan_context = mcp_app.lifespan(app)
+    await mcp_lifespan_context.__aenter__()
+    logger.info("[MCP] MCP服务初始化完成")
+
+    logger.info("[Grok2API] 应用启动成功")
+    
+    try:
+        yield
+    finally:
+        # --- 关闭过程 ---
+        # 1. 退出MCP服务的生命周期
+        await mcp_lifespan_context.__aexit__(None, None, None)
+        logger.info("[MCP] MCP服务已关闭")
+        
+        # 2. 关闭批量保存任务并刷新数据
+        await token_manager.shutdown()
+        logger.info("[Token] Token管理器已关闭")
+        
+        # 3. 关闭核心服务
+        await storage_manager.close()
+        logger.info("[Grok2API] 应用关闭成功")
+
+
+# 初始化日志
+logger.info("[Grok2API] 应用正在启动...")
+logger.info("[Grok2API] Fork 版本维护: @Tomiya233")
+
+# 创建FastAPI应用
+app = FastAPI(
+    title="Grok2API",
+    description="Grok API 转换服务",
+    version="1.3.1",
+    lifespan=lifespan
+)
+
+# 注册全局异常处理器
+register_exception_handlers(app)
+
+# 注册路由
+app.include_router(chat_router, prefix="/v1")
+app.include_router(models_router, prefix="/v1")
+app.include_router(images_router)
+app.include_router(admin_router)
+
+# 挂载静态文件
+app.mount("/static", StaticFiles(directory="app/template"), name="template")
+
+@app.get("/")
+async def root():
+    """根路径"""
+    from fastapi.responses import RedirectResponse
+    return RedirectResponse(url="/login")
+
+
+@app.get("/health")
+async def health_check():
+    """健康检查接口"""
+    return {
+        "status": "healthy",
+        "service": "Grok2API",
+        "version": "1.0.3"
+    }
+
+# 挂载MCP服务器 
+app.mount("", mcp_app)
+
+
+if __name__ == "__main__":
+    import uvicorn
+    import os
+    
+    # 读取 worker 数量，默认为 1
+    workers = int(os.getenv("WORKERS", "1"))
+    
+    # 提示多进程模式
+    if workers > 1:
+        logger.info(
+            f"[Grok2API] 多进程模式已启用 (workers={workers})。"
+            f"建议使用 Redis/MySQL 存储以获得最佳性能。"
+        )
+    
+    # 确定事件循环类型
+    loop_type = "auto"
+    if workers == 1 and sys.platform != 'win32':
+        try:
+            import uvloop
+            loop_type = "uvloop"
+        except ImportError:
+            pass
+    
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        workers=workers,
+        loop=loop_type
+    )

pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "grok2api"
+version = "1.4.3"
+description = "基于 FastAPI 重构的 Grok2API，适配最新的Web调用格式，支持流式对话、图像生成、图像编辑、联网搜索、视频生成、深度思考，支持号池并发调用和自动负载均衡。"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "aiofiles==25.1.0",
+    "aiomysql==0.2.0",
+    "curl-cffi==0.13.0",
+    "fastapi==0.119.0",
+    "pydantic==2.12.2",
+    "python-dotenv==1.1.1",
+    "redis==6.4.0",
+    "requests==2.32.5",
+    "starlette==0.48.0",
+    "toml==0.10.2",
+    "uvloop==0.21.0 ; sys_platform != 'win32'",
+    "uvicorn==0.37.0",
+    "portalocker==3.0.0",
+    "fastmcp==2.12.4",
+    "cryptography==46.0.3",
+    "orjson==3.11.4",
+    "aiohttp==3.13.2",
+]

readme.md

@@ -0,0 +1,254 @@
+---
+title: Grok2api
+emoji: 🦀
+colorFrom: indigo
+colorTo: red
+sdk: docker
+pinned: false
+---
+# Grok2API
+
+基于 **FastAPI** 重构的 Grok2API，全面适配最新 Web 调用格式，支持流式对话、图像生成、图像编辑、联网搜索、深度思考，号池并发与自动负载均衡一体化。
+
+## 🆕 Fork 增强功能
+
+本 Fork 在原版基础上新增以下功能：
+
+- **多 Key 管理与持久化**：支持管理员批量创建、备注、删除 API Key，支持多选批量操作。所有密钥均实现持久化存储，重启不丢失。
+- **日志审计支持**：实时记录请求细节，且日志数据支持文件持久化存储。
+- **并发性能优化 (Critical)**：重构了底层的 Grok 请求和响应处理逻辑。采用全异步流式迭代 (`aiter_lines`)，彻底解决了在消息生成过程中后台管理面板“卡死”或响应缓慢的问题。
+- **Token 智能冷却**：请求失败后自动冷却，避免连续使用故障 Token
+  - 普通错误：冷却 5 次请求
+  - 429 限流 + 有额度：冷却 1 小时
+  - 429 限流 + 无额度：冷却 10 小时
+- **一键刷新所有 Token**：后台按钮批量刷新剩余次数，带实时进度显示
+- **并发保护**：刷新任务进行中自动拒绝重复请求
+- **请求统计与持久化**：按小时/天统计请求趋势，包含成功率和模型分布图表，统计数据支持持久化。
+- **缓存预览**：后台添加缓存预览板块，可查看缓存的图片/视频
+<br>
+
+## 使用说明
+
+### 调用次数与配额
+
+- **普通账号（Basic）**：免费使用 **80 次 / 20 小时**
+- **Super 账号**：配额待定（作者未测）
+- 系统自动负载均衡各账号调用次数，可在**管理页面**实时查看用量与状态
+
+### 图像生成功能
+
+- 在对话内容中输入如“给我画一个月亮”自动触发图片生成
+- 每次以 **Markdown 格式返回两张图片**，共消耗 4 次额度
+- **注意：Grok 的图片直链受 403 限制，系统自动缓存图片到本地。必须正确设置 `Base Url` 以确保图片能正常显示！**
+
+### 视频生成功能
+- 选择 `grok-imagine-0.9` 模型，传入图片和提示词即可（方式和 OpenAI 的图片分析调用格式一致）
+- 返回格式为 `<video src="{full_video_url}" controls="controls"></video>`
+- **注意：Grok 的视频直链受 403 限制，系统自动缓存图片到本地。必须正确设置 `Base Url` 以确保视频能正常显示！**
+
+```
+curl https://你的服务器地址/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $GROK2API_API_KEY" \
+  -d '{
+    "model": "grok-imagine-0.9",
+    "messages": [
+      {
+        "role": "user",
+        "content": [
+          {
+            "type": "text",
+            "text": "让太阳升起来"
+          },
+          {
+            "type": "image_url",
+            "image_url": {
+              "url": "https://your-image.jpg"
+            }
+          }
+        ]
+      }
+    ]
+  }'
+```
+
+### 关于 `x_statsig_id`
+
+- `x_statsig_id` 是 Grok 用于反机器人的 Token，有逆向资料可参考
+- **建议新手勿修改配置，保留默认值即可**
+- 尝试用 Camoufox 绕过 403 自动获 id，但 grok 现已限制非登陆的`x_statsig_id`，故弃用，采用固定值以兼容所有请求
+
+<br>
+
+## 如何部署
+
+### 方式一：Docker Compose（推荐）
+
+由于本项目包含修改，建议直接构建运行：
+
+1. 克隆本仓库
+```bash
+git clone https://github.com/Tomiya233/grok2api.git
+cd grok2api
+```
+
+2. 启动服务
+```bash
+docker-compose up -d --build
+```
+
+**docker-compose.yml 参考：**
+```yaml
+services:
+  grok2api:
+    build: .
+    image: grok2api:latest
+    container_name: grok2api
+    restart: always
+    ports:
+      - "8000:8000"
+    volumes:
+      - grok_data:/app/data
+      - ./logs:/app/logs
+    environment:
+      - LOG_LEVEL=INFO
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+volumes:
+  grok_data:
+```
+
+### 方式二：Python 直接运行
+
+**前置要求**：Python 3.10+，建议使用 `uv` 包管理器
+
+1. 安装 uv
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+2. 运行服务
+```bash
+# 安装依赖并运行
+uv sync
+uv run python main.py
+```
+
+服务默认运行在 `http://127.0.0.1:8000`
+
+### 环境变量说明
+
+| 环境变量      | 必填 | 说明                                    | 示例 |
+|---------------|------|-----------------------------------------|------|
+| STORAGE_MODE  | 否   | 存储模式：file/mysql/redis               | file |
+| DATABASE_URL  | 否   | 数据库连接URL（MySQL/Redis模式时必需）   | mysql://user:pass@host:3306/db |
+
+**存储模式：**
+- `file`: 本地文件存储（默认）
+- `mysql`: MySQL数据库存储，需设置DATABASE_URL
+- `redis`: Redis缓存存储，需设置DATABASE_URL
+
+<br>
+
+## 接口说明
+
+> 与 OpenAI 官方接口完全兼容���API 请求需通过 **Authorization header** 认证
+
+| 方法  | 端点                         | 描述                               | 是否需要认证 |
+|-------|------------------------------|------------------------------------|------|
+| POST  | `/v1/chat/completions`       | 创建聊天对话（流式/非流式）         | ✅   |
+| GET   | `/v1/models`                 | 获取全部支持模型                   | ✅   |
+| GET   | `/images/{img_path}`         | 获取生成图片文件                   | ❌   |
+
+<br>
+
+<details>
+<summary>管理与统计接口（展开查看更多）</summary>
+
+| 方法  | 端点                    | 描述               | 认证 |
+|-------|-------------------------|--------------------|------|
+| GET   | /login                  | 管理员登录页面     | ❌   |
+| GET   | /manage                 | 管理控制台页面     | ❌   |
+| POST  | /api/login              | 管理员登录认证     | ❌   |
+| POST  | /api/logout             | 管理员登出         | ✅   |
+| GET   | /api/tokens             | 获取 Token 列表    | ✅   |
+| POST  | /api/tokens/add         | 批量添加 Token     | ✅   |
+| POST  | /api/tokens/delete      | 批量删除 Token     | ✅   |
+| GET   | /api/settings           | 获取系统配置       | ✅   |
+| POST  | /api/settings           | 更新系统配置       | ✅   |
+| GET   | /api/cache/size         | 获取缓存大小       | ✅   |
+| POST  | /api/cache/clear        | 清理所有缓存       | ✅   |
+| POST  | /api/cache/clear/images | 清理图片缓存       | ✅   |
+| POST  | /api/cache/clear/videos | 清理视频缓存       | ✅   |
+| GET   | /api/stats              | 获取统计信息       | ✅   |
+| POST  | /api/tokens/tags        | 更新 Token 标签     | ✅   |
+| POST  | /api/tokens/note        | 更新 Token 备注     | ✅   |
+| POST  | /api/tokens/test        | 测试 Token 可用性   | ✅   |
+| GET   | /api/tokens/tags/all    | 获取所有标签列表    | ✅   |
+| GET   | /api/storage/mode       | 获取存储模式信息    | ✅   |
+| POST  | /api/tokens/refresh-all | 一键刷新所有Token   | ✅   |
+| GET   | /api/tokens/refresh-progress | 获取刷新进度       | ✅   |
+| GET   | /api/keys               | 获取 API Key 列表  | ✅   |
+| POST  | /api/keys/add           | 创建新 API Key     | ✅   |
+| POST  | /api/keys/delete        | 删除 API Key       | ✅   |
+| POST  | /api/keys/status        | 切换 Key 启用状态  | ✅   |
+| POST  | /api/keys/name          | 修改 Key 备注名称  | ✅   |
+| GET   | /api/logs               | 获取请求日志(1000条)| ✅   |
+| POST  | /api/logs/clear         | 清空所有审计日志   | ✅   |
+
+</details>
+
+<br>
+
+## 可用模型一览
+
+| 模型名称               | 计次   | 账户类型      | 图像生成/编辑 | 深度思考 | 联网搜索 | 视频生成 |
+|------------------------|--------|--------------|--------------|----------|----------|----------|
+| `grok-4.1`             | 1      | Basic/Super  | ✅           | ✅       | ✅       | ❌       |
+| `grok-4.1-thinking`    | 1      | Basic/Super  | ✅           | ✅       | ✅       | ❌       |
+| `grok-imagine-0.9`     | -      | Basic/Super  | ✅           | ❌       | ❌       | ✅       |
+| `grok-4-fast`          | 1      | Basic/Super  | ✅           | ✅       | ✅       | ❌       |
+| `grok-4-fast-expert`   | 4      | Basic/Super  | ✅           | ✅       | ✅       | ❌       |
+| `grok-4-expert`        | 4      | Basic/Super  | ✅           | ✅       | ✅       | ❌       |
+| `grok-4-heavy`         | 1      | Super        | ✅           | ✅       | ✅       | ❌       |
+| `grok-3-fast`          | 1      | Basic/Super  | ✅           | ❌       | ✅       | ❌       |
+
+<br>
+
+## 配置参数说明
+
+> 服务启动后，登录 `/login` 管理后台进行参数配置
+
+| 参数名                     | 作用域  | 必填 | 说明                                    | 默认值 |
+|----------------------------|---------|------|-----------------------------------------|--------|
+| admin_username             | global  | 否   | 管理后台登录用户名                      | "admin"|
+| admin_password             | global  | 否   | 管理后台登录密码                        | "admin"|
+| log_level                  | global  | 否   | 日志级别：DEBUG/INFO/...                | "INFO" |
+| image_mode                 | global  | 否   | 图片返回模式：url/base64                | "url"  |
+| image_cache_max_size_mb    | global  | 否   | 图片缓存最大容量(MB)                     | 512    |
+| video_cache_max_size_mb    | global  | 否   | 视频缓存最大容量(MB)                     | 1024   |
+| base_url                   | global  | 否   | 服务基础URL/图片访问基准                 | ""     |
+| api_key                    | grok    | 否   | API 密钥（可选加强安全）                | ""     |
+| proxy_url                  | grok    | 否   | HTTP代理服务器地址                      | ""     |
+| stream_chunk_timeout       | grok    | 否   | 流式分块超时时间(秒)                     | 120    |
+| stream_first_response_timeout | grok | 否   | 流式首次响应超时时间(秒)                 | 30     |
+| stream_total_timeout       | grok    | 否   | 流式总超时时间(秒)                       | 600    |
+| cf_clearance               | grok    | 否   | Cloudflare安全令牌                      | ""     |
+| x_statsig_id               | grok    | 是   | 反机器人唯一标识符                      | "ZTpUeXBlRXJyb3I6IENhbm5vdCByZWFkIHByb3BlcnRpZXMgb2YgdW5kZWZpbmVkIChyZWFkaW5nICdjaGlsZE5vZGVzJyk=" |
+| filtered_tags              | grok    | 否   | 过滤响应标签（逗号分隔）                | "xaiartifact,xai:tool_usage_card,grok:render" |
+| show_thinking              | grok    | 否   | 显示思考过程 true(显示)/false(隐藏)     | true   |
+| temporary                  | grok    | 否   | 会话模式 true(临时)/false               | true   |
+
+<br>
+
+## ⚠️ 注意事项
+
+本项目仅供学习与研究，请遵守相关使用条款！
+
+<br>
+
+> 本项目基于以下项目学习重构，特别感谢：[LINUX DO](https://linux.do)、[VeroFess/grok2api](https://github.com/VeroFess/grok2api)、[xLmiler/grok2api_python](https://github.com/xLmiler/grok2api_python)

requirements.txt

@@ -0,0 +1,17 @@
+toml==0.10.2
+fastapi==0.119.0
+uvicorn==0.37.0
+uvloop==0.21.0; sys_platform != 'win32'
+python-dotenv==1.1.1
+curl_cffi==0.13.0
+requests==2.32.5
+starlette==0.48.0
+pydantic==2.12.2
+aiofiles==25.1.0
+portalocker==3.0.0
+aiomysql==0.2.0
+redis==6.4.0
+fastmcp==2.12.4
+cryptography==46.0.3
+orjson==3.11.4
+aiohttp==3.13.2

test/test_concurrency.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""
+Grok2API 并发性能测试脚本
+
+测试不同并发级别下的API性能表现
+"""
+
+import asyncio
+import aiohttp
+import time
+import statistics
+import argparse
+from datetime import datetime
+from typing import List, Dict, Any
+import json
+
+
+class ConcurrencyTester:
+    """并发测试器"""
+    
+    def __init__(self, base_url: str, api_key: str = None):
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+        self.results: List[Dict[str, Any]] = []
+    
+    async def test_request(self, session: aiohttp.ClientSession, request_id: int) -> Dict[str, Any]:
+        """发送单个测试请求"""
+        url = f"{self.base_url}/v1/chat/completions"
+        
+        headers = {
+            "Content-Type": "application/json"
+        }
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        
+        payload = {
+            "model": "grok-3-fast",
+            "messages": [
+                {"role": "user", "content": f"测试请求 #{request_id}，请简短回复OK"}
+            ],
+            "stream": False,
+            "max_tokens": 10
+        }
+        
+        start_time = time.time()
+        
+        try:
+            async with session.post(url, json=payload, headers=headers, timeout=30) as response:
+                status = response.status
+                
+                if status == 200:
+                    data = await response.json()
+                    elapsed = time.time() - start_time
+                    
+                    return {
+                        "id": request_id,
+                        "status": "success",
+                        "http_status": status,
+                        "elapsed": elapsed,
+                        "response_length": len(json.dumps(data))
+                    }
+                else:
+                    elapsed = time.time() - start_time
+                    error_text = await response.text()
+                    
+                    return {
+                        "id": request_id,
+                        "status": "error",
+                        "http_status": status,
+                        "elapsed": elapsed,
+                        "error": error_text[:200]
+                    }
+        
+        except asyncio.TimeoutError:
+            elapsed = time.time() - start_time
+            return {
+                "id": request_id,
+                "status": "timeout",
+                "elapsed": elapsed,
+                "error": "Request timeout"
+            }
+        
+        except Exception as e:
+            elapsed = time.time() - start_time
+            return {
+                "id": request_id,
+                "status": "exception",
+                "elapsed": elapsed,
+                "error": str(e)
+            }
+    
+    async def run_concurrent_test(self, concurrency: int, total_requests: int):
+        """运行并发测试"""
+        print(f"\n{'='*60}")
+        print(f"📊 测试配置：并发数 {concurrency}, 总请求数 {total_requests}")
+        print(f"{'='*60}")
+        
+        connector = aiohttp.TCPConnector(limit=concurrency, limit_per_host=concurrency)
+        timeout = aiohttp.ClientTimeout(total=60)
+        
+        async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
+            # 预热
+            print("🔥 预热中...")
+            await self.test_request(session, 0)
+            
+            # 开始测试
+            print(f"🚀 开始并发测试...")
+            start_time = time.time()
+            
+            # 创建任务
+            tasks = []
+            for i in range(1, total_requests + 1):
+                task = asyncio.create_task(self.test_request(session, i))
+                tasks.append(task)
+                
+                # 控制并发数
+                if len(tasks) >= concurrency:
+                    results = await asyncio.gather(*tasks)
+                    self.results.extend(results)
+                    tasks = []
+                    
+                    # 显示进度
+                    print(f"  进度: {i}/{total_requests} ({i/total_requests*100:.1f}%)", end='\r')
+            
+            # 处理剩余任务
+            if tasks:
+                results = await asyncio.gather(*tasks)
+                self.results.extend(results)
+            
+            total_time = time.time() - start_time
+            
+            # 统计和输出
+            self.print_statistics(concurrency, total_requests, total_time)
+    
+    def print_statistics(self, concurrency: int, total_requests: int, total_time: float):
+        """打印统计信息"""
+        success_results = [r for r in self.results if r["status"] == "success"]
+        error_results = [r for r in self.results if r["status"] != "success"]
+        
+        success_count = len(success_results)
+        error_count = len(error_results)
+        
+        if success_results:
+            latencies = [r["elapsed"] for r in success_results]
+            avg_latency = statistics.mean(latencies)
+            min_latency = min(latencies)
+            max_latency = max(latencies)
+            p50_latency = statistics.median(latencies)
+            p95_latency = sorted(latencies)[int(len(latencies) * 0.95)] if len(latencies) > 1 else latencies[0]
+            p99_latency = sorted(latencies)[int(len(latencies) * 0.99)] if len(latencies) > 1 else latencies[0]
+        else:
+            avg_latency = min_latency = max_latency = p50_latency = p95_latency = p99_latency = 0
+        
+        throughput = total_requests / total_time if total_time > 0 else 0
+        
+        print(f"\n\n{'='*60}")
+        print(f"📈 测试结果统计")
+        print(f"{'='*60}")
+        print(f"  测试时间: {total_time:.2f}s")
+        print(f"  总请求数: {total_requests}")
+        print(f"  并发数: {concurrency}")
+        print(f"")
+        print(f"  成功请求: {success_count} ({success_count/total_requests*100:.1f}%)")
+        print(f"  失败请求: {error_count} ({error_count/total_requests*100:.1f}%)")
+        print(f"")
+        print(f"  吞吐量: {throughput:.2f} req/s")
+        print(f"")
+        print(f"  延迟统计:")
+        print(f"    最小: {min_latency*1000:.0f}ms")
+        print(f"    平均: {avg_latency*1000:.0f}ms")
+        print(f"    最大: {max_latency*1000:.0f}ms")
+        print(f"    P50:  {p50_latency*1000:.0f}ms")
+        print(f"    P95:  {p95_latency*1000:.0f}ms")
+        print(f"    P99:  {p99_latency*1000:.0f}ms")
+        
+        # 错误详情
+        if error_results:
+            print(f"\n  ⚠️  错误详情:")
+            error_types = {}
+            for r in error_results:
+                error_type = r.get("status", "unknown")
+                error_types[error_type] = error_types.get(error_type, 0) + 1
+            
+            for error_type, count in error_types.items():
+                print(f"    {error_type}: {count}")
+        
+        print(f"{'='*60}\n")
+        
+        # 性能评级
+        self.print_performance_rating(throughput, avg_latency)
+    
+    def print_performance_rating(self, throughput: float, avg_latency: float):
+        """打印性能评级"""
+        print(f"🎯 性能评级:")
+        
+        # 吞吐量评级
+        if throughput >= 100:
+            rating = "⭐⭐⭐⭐⭐ 优秀"
+        elif throughput >= 60:
+            rating = "⭐⭐⭐⭐ 良好"
+        elif throughput >= 30:
+            rating = "⭐⭐⭐ 中等"
+        elif throughput >= 10:
+            rating = "⭐⭐ 较低"
+        else:
+            rating = "⭐ 需优化"
+        
+        print(f"  吞吐量 ({throughput:.1f} req/s): {rating}")
+        
+        # 延迟评级
+        if avg_latency < 0.5:
+            rating = "⭐⭐⭐⭐⭐ 优秀"
+        elif avg_latency < 1.0:
+            rating = "⭐⭐⭐⭐ 良好"
+        elif avg_latency < 2.0:
+            rating = "⭐⭐⭐ 中等"
+        elif avg_latency < 5.0:
+            rating = "⭐⭐ 较高"
+        else:
+            rating = "⭐ 需优化"
+        
+        print(f"  平均延迟 ({avg_latency*1000:.0f}ms): {rating}")
+        print()
+
+
+async def main():
+    """主函数"""
+    parser = argparse.ArgumentParser(description='Grok2API 并发性能测试')
+    parser.add_argument('--url', default='http://localhost:8000', help='API 基础URL')
+    parser.add_argument('--key', default='', help='API Key（可选）')
+    parser.add_argument('-c', '--concurrency', type=int, default=10, help='并发数')
+    parser.add_argument('-n', '--requests', type=int, default=50, help='总请求数')
+    parser.add_argument('--multi-test', action='store_true', help='运行多级并发测试')
+    
+    args = parser.parse_args()
+    
+    print(f"""
+╔══════════════════════════════════════════════════════════╗
+║          Grok2API 并发性能测试工具                        ║
+╚══════════════════════════════════════════════════════════╝
+
+🔗 测试目标: {args.url}
+🔑 API Key: {'已设置' if args.key else '未设置'}
+⏰ 开始时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+""")
+    
+    tester = ConcurrencyTester(args.url, args.key)
+    
+    if args.multi_test:
+        # 多级并发测试
+        test_configs = [
+            (5, 20),    # 5并发，20请求
+            (10, 50),   # 10并发，50请求
+            (20, 100),  # 20并发，100请求
+            (50, 200),  # 50并发，200请求
+        ]
+        
+        for concurrency, requests in test_configs:
+            tester.results = []  # 清空结果
+            await tester.run_concurrent_test(concurrency, requests)
+            await asyncio.sleep(2)  # 间隔2秒
+    else:
+        # 单次测试
+        await tester.run_concurrent_test(args.concurrency, args.requests)
+    
+    print(f"\n✅ 测试完成！")
+    print(f"⏰ 结束时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n\n⚠️  测试被用户中断")
+    except Exception as e:
+        print(f"\n\n❌ 测试失败: {e}")

test/test_concurrency.sh

@@ -0,0 +1,177 @@
+#!/bin/bash
+
+# Grok2API 并发测试脚本（Shell版本）
+# 使用 curl 和 GNU parallel 进行并发测试
+
+set -e
+
+# 配置
+BASE_URL="${BASE_URL:-http://localhost:8000}"
+API_KEY="${API_KEY:-}"
+CONCURRENCY="${CONCURRENCY:-10}"
+TOTAL_REQUESTS="${TOTAL_REQUESTS:-50}"
+
+# 颜色
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}╔══════════════════════════════════════════════════════════╗${NC}"
+echo -e "${BLUE}║          Grok2API 并发性能测试工具 (Shell版)             ║${NC}"
+echo -e "${BLUE}╚══════════════════════════════════════════════════════════╝${NC}"
+echo ""
+echo -e "${GREEN}🔗 测试目标:${NC} $BASE_URL"
+echo -e "${GREEN}🔑 API Key:${NC} ${API_KEY:-(未设置)}"
+echo -e "${GREEN}📊 并发数:${NC} $CONCURRENCY"
+echo -e "${GREEN}📈 总请求数:${NC} $TOTAL_REQUESTS"
+echo ""
+
+# 检查依赖
+if ! command -v curl &> /dev/null; then
+    echo -e "${RED}❌ 错误: 需要安装 curl${NC}"
+    exit 1
+fi
+
+# 创建临时目录
+TMP_DIR=$(mktemp -d)
+trap "rm -rf $TMP_DIR" EXIT
+
+# 单个请求函数
+test_request() {
+    local request_id=$1
+    local start_time=$(date +%s.%N)
+    
+    # 构建请求
+    local headers="Content-Type: application/json"
+    if [ -n "$API_KEY" ]; then
+        headers="${headers}\nAuthorization: Bearer ${API_KEY}"
+    fi
+    
+    local response=$(curl -s -w "\n%{http_code}\n%{time_total}" \
+        -X POST "${BASE_URL}/v1/chat/completions" \
+        -H "Content-Type: application/json" \
+        ${API_KEY:+-H "Authorization: Bearer $API_KEY"} \
+        -d "{
+            \"model\": \"grok-3-fast\",
+            \"messages\": [{\"role\": \"user\", \"content\": \"测试请求 #${request_id}，请简短回复OK\"}],
+            \"stream\": false,
+            \"max_tokens\": 10
+        }" 2>&1)
+    
+    local http_code=$(echo "$response" | tail -n 2 | head -n 1)
+    local time_total=$(echo "$response" | tail -n 1)
+    
+    # 记录结果
+    echo "${request_id},${http_code},${time_total}" >> "$TMP_DIR/results.csv"
+    
+    # 显示进度
+    echo -ne "\r  进度: ${request_id}/${TOTAL_REQUESTS}"
+}
+
+# 导出函数供 parallel 使用
+export -f test_request
+export BASE_URL API_KEY TMP_DIR
+
+# 清空结果文件
+echo "id,status,time" > "$TMP_DIR/results.csv"
+
+echo -e "${YELLOW}🚀 开始并发测试...${NC}"
+START_TIME=$(date +%s.%N)
+
+# 使用 GNU parallel（如果可用），否则使用简单循环
+if command -v parallel &> /dev/null; then
+    seq 1 $TOTAL_REQUESTS | parallel -j $CONCURRENCY test_request {}
+else
+    # 简单的后台任务并发
+    for i in $(seq 1 $TOTAL_REQUESTS); do
+        test_request $i &
+        
+        # 控制并发数
+        if (( i % CONCURRENCY == 0 )); then
+            wait
+        fi
+    done
+    wait
+fi
+
+END_TIME=$(date +%s.%N)
+TOTAL_TIME=$(echo "$END_TIME - $START_TIME" | bc)
+
+echo -e "\n"
+
+# 统计结果
+echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
+echo -e "${BLUE}📈 测试结果统计${NC}"
+echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
+
+# 统计成功/失败
+SUCCESS_COUNT=$(awk -F',' '$2 == 200 {count++} END {print count+0}' "$TMP_DIR/results.csv")
+ERROR_COUNT=$((TOTAL_REQUESTS - SUCCESS_COUNT))
+
+echo -e "  测试时间: ${TOTAL_TIME}s"
+echo -e "  总请求数: ${TOTAL_REQUESTS}"
+echo -e "  并发数: ${CONCURRENCY}"
+echo ""
+echo -e "  成功请求: ${GREEN}${SUCCESS_COUNT}${NC} ($(echo "scale=1; $SUCCESS_COUNT * 100 / $TOTAL_REQUESTS" | bc)%)"
+echo -e "  失败请求: ${RED}${ERROR_COUNT}${NC} ($(echo "scale=1; $ERROR_COUNT * 100 / $TOTAL_REQUESTS" | bc)%)"
+echo ""
+
+# 计算吞吐量
+THROUGHPUT=$(echo "scale=2; $TOTAL_REQUESTS / $TOTAL_TIME" | bc)
+echo -e "  吞吐量: ${GREEN}${THROUGHPUT}${NC} req/s"
+echo ""
+
+# 延迟统计（只统计成功的请求）
+if [ $SUCCESS_COUNT -gt 0 ]; then
+    echo -e "  延迟统计:"
+    
+    # 提取成功请求的延迟时间
+    awk -F',' '$2 == 200 {print $3}' "$TMP_DIR/results.csv" | sort -n > "$TMP_DIR/latencies.txt"
+    
+    MIN=$(head -n 1 "$TMP_DIR/latencies.txt" | awk '{printf "%.0f", $1*1000}')
+    MAX=$(tail -n 1 "$TMP_DIR/latencies.txt" | awk '{printf "%.0f", $1*1000}')
+    AVG=$(awk '{sum+=$1; count++} END {printf "%.0f", sum/count*1000}' "$TMP_DIR/latencies.txt")
+    
+    # P50
+    P50_LINE=$((SUCCESS_COUNT / 2))
+    P50=$(sed -n "${P50_LINE}p" "$TMP_DIR/latencies.txt" | awk '{printf "%.0f", $1*1000}')
+    
+    # P95
+    P95_LINE=$(echo "scale=0; $SUCCESS_COUNT * 0.95 / 1" | bc)
+    P95=$(sed -n "${P95_LINE}p" "$TMP_DIR/latencies.txt" | awk '{printf "%.0f", $1*1000}')
+    
+    # P99
+    P99_LINE=$(echo "scale=0; $SUCCESS_COUNT * 0.99 / 1" | bc)
+    P99=$(sed -n "${P99_LINE}p" "$TMP_DIR/latencies.txt" | awk '{printf "%.0f", $1*1000}')
+    
+    echo -e "    最小: ${MIN}ms"
+    echo -e "    平均: ${AVG}ms"
+    echo -e "    最大: ${MAX}ms"
+    echo -e "    P50:  ${P50}ms"
+    echo -e "    P95:  ${P95}ms"
+    echo -e "    P99:  ${P99}ms"
+fi
+
+echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
+
+# 性能评级
+echo -e "${YELLOW}🎯 性能评级:${NC}"
+
+if (( $(echo "$THROUGHPUT >= 100" | bc -l) )); then
+    RATING="⭐⭐⭐⭐⭐ 优秀"
+elif (( $(echo "$THROUGHPUT >= 60" | bc -l) )); then
+    RATING="⭐⭐⭐⭐ 良好"
+elif (( $(echo "$THROUGHPUT >= 30" | bc -l) )); then
+    RATING="⭐⭐⭐ 中等"
+elif (( $(echo "$THROUGHPUT >= 10" | bc -l) )); then
+    RATING="⭐⭐ 较低"
+else
+    RATING="⭐ 需优化"
+fi
+
+echo -e "  吞吐量 (${THROUGHPUT} req/s): ${RATING}"
+
+echo ""
+echo -e "${GREEN}✅ 测试完成！${NC}"

test_key.py

@@ -0,0 +1,50 @@
+import requests
+import json
+import uuid
+
+# ================= 配置区 =================
+# 1. 在管理后台 [Key 管理] 页面创建一个新 Key
+# 2. 将新生成的 sk-... 填入下方
+API_KEY = "YOUR_NEW_API_KEY" 
+BASE_URL = "http://127.0.0.1:8000"
+# ==========================================
+
+def test_chat_completion():
+    print(f"开始测试 Key: {API_KEY[:10]}...")
+    
+    url = f"{BASE_URL}/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": "grok-4-fast",
+        "messages": [
+            {"role": "user", "content": "Hello, who are you? Tell me a joke."}
+        ],
+        "stream": False
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        print(f"状态码: {response.status_code}")
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = result['choices'][0]['message']['content']
+            print("--- 响应成功 ---")
+            print(content)
+            print("---------------")
+            print("测试通过！现在去管理后台 [日志审计] 确认日志中是否记录了该请求。")
+        else:
+            print(f"请求失败: {response.text}")
+            
+    except Exception as e:
+        print(f"发生错误: {e}")
+
+if __name__ == "__main__":
+    if API_KEY == "YOUR_NEW_API_KEY":
+        print("请先将代码中的 API_KEY 替换为你刚才生成的 Key！")
+    else:
+        test_chat_completion()