Upload 12 files

.dockerignore

@@ -0,0 +1,12 @@
+node_modules
+npm-debug.log
+.git
+.env
+.dockerignore
+Dockerfile
+index.js
+package.json
+logger.js
+docker-compose.yml
+start.bat
+start.sh

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN pip install --no-cache-dir flask requests curl_cffi werkzeug loguru 
+
+VOLUME ["/data"]
+
+COPY . .
+
+ENV PORT=3000
+EXPOSE 3000
+
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,189 @@
----
-title: Grok2api
-emoji: ⚡
-colorFrom: red
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# grok2API 接入指南：基于 python 的实现
+
+## 项目简介
+本项目提供了一种简单、高效的方式通过 Docker 部署 使用openAI的格式转换调用grok官网，进行api处理。
+
+>支持自动过cf屏蔽盾，需要自己ip没有被风控。如果被风控，将会升级为5秒盾，无法绕过。
+
+## 如何检测ip是否被风控？
+1. 打开无痕浏览器，输入https://grok.com
+2. 直接进入则没有被风控，如果出现下图所示画面，则表示已经被风控，该ip无法使用本项目
+   ![image](https://github.com/user-attachments/assets/0466aa57-9a31-4f7c-bd07-fece11f27646)
+   
+4. 如果风控后，过了5秒盾，会给与一个一年有效期的cf_clearance，可以将这个填入环境变量CF_CLEARANCE，这个cf_clearance和你的ip是绑定的，如果更换ip需要重新获取，可以提高破盾的稳定性（大概）。
+5. 如果ip没有风控，不要加cf_clearance，加了可能反而因为校验问题出盾
+
+### 功能特点
+实现的功能：
+1. 已支持文字生成图，使用grok-3-imageGen和grok-4-imageGen模型。
+2. 已支持全部模型识图和传图，只会识别存储用户消息最新的一个图，历史记录图全部为占位符替代。
+3. 已支持搜索功能，使用grok-3-search，可以选择是否关闭搜索结果
+4. 已支持深度搜索功能，使用grok-3-deepsearch,grok-4-deepsearch，深度搜索支持think过程显示
+5. 已支持推理模型功能，使用grok-3-reasoning
+6. 已支持真流式，上面全部功能都可以在流式情况调用
+7. 支持多账号轮询，在环境变量中配置
+8. 可以选择是否移除思考模型的思考过程。
+9. 支持自行设置轮询和负载均衡，而不依靠项目代码
+10. 自动过CF屏蔽盾
+11. 可自定义http和Socks5代理
+12. 上下文40k时自动转换为文件以提高上下文限制
+13. 已转换为openai格式。
+14. 支持super会员账号token单独导入，暂不支持浏览器面板方式导入
+
+## API 接口文档
+
+### 模型管理
+| 接口 | 方法 | 路径 | 描述 |
+|------|------|------|------|
+| 模型列表 | GET | `/v1/models` | 获取可用模型列表 |
+| 对话 | POST | `/v1/chat/completions` | 发起对话请求 |
+
+### SSO令牌管理与安全设置
+| 接口 | 方法 | 路径 | 请求体 | 描述 |
+|------|------|------|--------|------|
+| 添加SSO令牌 | POST | `/add/token` | `{sso: "eyXXXXXXXX"}` | 添加SSO认证令牌 |
+| 删除SSO令牌 | POST | `/delete/token` | `{sso: "eyXXXXXXXX"}` | 删除SSO认证令牌 |
+| 获取SSO令牌状态 | GET | `/get/tokens` | - | 查询所有SSO令牌状态 |
+| 修改cf_clearance | POST | `/set/cf_clearance` | `{cf_clearance: "cf_clearance=XXXXXXXX"}` | 更新cf_clearance Cookie |
+
+### TOKEN管理界面
+使用如下接口：http://127.0.0.1:3000/manager
+
+![image](https://github.com/user-attachments/assets/9caedf30-5075-4edb-b5c4-96852647a43d)
+
+
+### 环境变量具体配置
+
+|变量 | 说明 | 构建时是否必填 |示例|
+|--- | --- | ---| ---|
+|`MANAGER_SWITCH` | 是否开启管理界面 | （可以不填，默认是false） | `true/false`|
+|`ADMINPASSWORD` | 管理界面的管理员密码，请区别于API_KEY，并且设置高强度密码 | （MANAGER_SWITCH没有开启时可以不填，默认是无） | `OjB6*BLlT&nV2M$x`|
+|`IS_TEMP_CONVERSATION` | 是否开启临时会话，开启后会话历史记录不会保留在网页 | （可以不填，默认是false） | `true/false`|
+|`CF_CLEARANCE` | cf的5秒盾后的值，随便一个号过盾后的都可以，这个cf_clearance和你的ip是绑定的，如果更换ip需要重新获取。通用，可以提高破盾的稳定性 | （可以不填，默认无） | `cf_clearance=xxxxxx`|
+|`API_KEY` | 自定义认证鉴权密钥 | （可以不填，默认是sk-123456） | `sk-123456`|
+|`PROXY` | 代理设置，支持https和Socks5 | 可不填，默认无 | -|
+|`PICGO_KEY` | PicGo图床密钥，两个图床二选一 | 不填无法流式生图 | -|
+|`TUMY_KEY` | TUMY图床密钥，两个图床二选一 | 不填无法流式生图 | -|
+|`ISSHOW_SEARCH_RESULTS` | 是否显示搜索结果 | （可不填，默认关闭） | `true/false`|
+|`SSO` | Grok官网SSO Cookie,可以设置多个使用英文 , 分隔，我的代码里会对不同账号的SSO自动轮询和均衡 | （除非开启IS_CUSTOM_SSO否则和SSO_SUPER二选一） | `sso,sso`|
+|`SSO_SUPER` | Grok官网的会员账号的SSO Cookie,可以设置多个使用英文 , 分隔，我的代码里会对不同账号的SSO自动轮询和均衡 | （除非开启IS_CUSTOM_SSO否则否则和SSO二选一） | `sso,sso`|
+|`PORT` | 服务部署端口 | （可不填，默认3000） | `3000`|
+|`IS_CUSTOM_SSO` | 这是如果你想自己来自定义号池来轮询均衡，而不是通过我代码里已经内置的号池逻辑系统来为你轮询均衡启动的开关。开启后 API_KEY 需要设置为请求认证用的 sso cookie，同时SSO环境变量失效。一个apikey每次只能传入一个sso cookie 值，不支持一个请求里的apikey填入多个sso。想自动使用多个sso请关闭 IS_CUSTOM_SSO 这个环境变量，然后按照SSO环境变量要求在sso环境变量里填入多个sso，由我的代码里内置的号池系统来为你自动轮询 | （可不填，默认关闭） | `true/false`|
+|`SHOW_THINKING` | 是否显示思考模型的思考过程 | （可不填，默认关闭） | `true/false`|
+
+**注意事项**：
+- 所有POST请求需要在请求体中携带相应的认证信息
+- SSO令牌和cf_clearance是敏感信息，请妥善保管
+
+## 方法一：Docker部署
+
+### 1. 获取项目
+克隆我的仓库：[grok2api](https://github.com/xLmiler/grok2api)
+### 2. 部署选项
+
+#### 方式A：直接使用Docker镜像
+```bash
+docker run -it -d --name grok2api_python \
+  -p 3000:3000 \
+  -v $(pwd)/data:/data \
+  -e IS_TEMP_CONVERSATION=false \
+  -e API_KEY=your_api_key \
+  -e TUMY_KEY=你的图床key,和PICGO_KEY 二选一 \
+  -e PICGO_KEY=你的图床key,和TUMY_KEY二选一 \
+  -e IS_CUSTOM_SSO=false \
+  -e ISSHOW_SEARCH_RESULTS=false \
+  -e PORT=3000 \
+  -e SHOW_THINKING=true \
+  -e SSO=your_sso \
+  yxmiler/grok2api_python:latest
+```
+
+#### 方式B：使用Docker Compose
+````artifact
+version: '3.8'
+services:
+  grok2api_python:
+    image: yxmiler/grok2api_python:latest
+    container_name: grok2api_python
+    ports:
+      - "3000:3000"
+    volumes:
+      - ./data:/data
+    environment:
+      - API_KEY=your_api_key
+      - IS_TEMP_CONVERSATION=true
+      - IS_CUSTOM_SSO=false
+      - ISSHOW_SEARCH_RESULTS=false
+      - PORT=3000
+      - SHOW_THINKING=true
+      - SSO=your_sso
+    restart: unless-stopped
+````
+
+#### 方式C：自行构建
+1. 克隆仓库
+2. 构建镜像
+```bash
+docker build -t yourusername/grok2api .
+```
+3. 运行容器
+```bash
+docker run -it -d --name grok2api \
+  -p 3000:3000 \
+  -v $(pwd)/data:/data \
+  -e IS_TEMP_CONVERSATION=false \
+  -e API_KEY=your_api_key \
+  -e IS_CUSTOM_SSO=false \
+  -e ISSHOW_SEARCH_RESULTS=false \
+  -e PORT=3000 \
+  -e SHOW_THINKING=true \
+  -e SSO=your_sso \
+  yourusername/grok2api:latest
+```
+
+## 方法二：Hugging Face部署
+
+### 部署地址
+[GrokPythonService](https://huggingface.co/spaces/yxmiler/GrokPythonService)
+
+### 可用模型列表
+- `grok-4`
+- `grok-4-reasoning`
+- `grok-4-imageGen`
+- `grok-3`
+- `grok-3-search`
+- `grok-3-imageGen`
+- `grok-3-deepsearch`
+- `grok-3-deepersearch`
+- `grok-3-reasoning`
+
+### 模型可用次数参考
+- grok-4所有模型 合计一共：30次  每3小时刷新 仅grok会员可用
+- grok-3,grok-3-search,grok-3-imageGen 合计：20次  每3小时刷新
+- grok-3-deepsearch：8次 每24小时刷新
+- grok-3-deepersearch：3次 每24小时刷新
+- grok-3-reasoning：10次 每24小时刷新
+
+### cookie的获取办法：
+1. 打开[grok官网](https://grok.com/)
+2. 复制如下的SSO的cookie的值填入SSO变量即可
+![9EA{{UY6 PU~PENQHYO5JS7](https://github.com/user-attachments/assets/539d4a53-9352-49fd-8657-e942a94f44e9)
+
+### cf_clearance的获取办法：
+1. 随便登录一个账号打开[grok官网](https://grok.com/)
+2. 复制如下的cf_clearance的cookie的值填入CF_CLEARANCE变量即可，只需要填入一个，不可以多个,格式cf_clearance=xxxxx
+![W1F8FTBT`~17(TFP5LS173Q](https://github.com/user-attachments/assets/f5603267-316a-4126-8c77-a84a91ee6344)
+
+
+## 备注
+- 消息基于用户的伪造连续对话
+- 可能存在一定程度的降智
+- 生图模型不支持历史对话，仅支持生图。
+## 补充说明
+- 如需使用流式生图的图像功能，需在[PicGo图床](https://www.picgo.net/)或者[tumy图床](https://tu.my/)申请API Key，前者似乎无法注册了，没有前面图床账号的可以选择后一个图床。
+- 自动移除历史消息里的think过程，同时如果历史消息里包含里base64图片文本，而不是通过文件上传的方式上传，则自动转换为[图片]占用符。
+
+## 注意事项
+⚠️ 本项目仅供学习和研究目的，请遵守相关使用条款。
+

app.py

@@ -0,0 +1,1419 @@
+import os
+import json
+import uuid
+import time
+import base64
+import sys
+import inspect
+import secrets
+from loguru import logger
+from pathlib import Path
+
+import requests
+from flask import Flask, request, Response, jsonify, stream_with_context, render_template, redirect, session
+from curl_cffi import requests as curl_requests
+from werkzeug.middleware.proxy_fix import ProxyFix
+
+class Logger:
+    def __init__(self, level="INFO", colorize=True, format=None):
+        logger.remove()
+
+        if format is None:
+            format = (
+                "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+                "<level>{level: <8}</level> | "
+                "<cyan>{extra[filename]}</cyan>:<cyan>{extra[function]}</cyan>:<cyan>{extra[lineno]}</cyan> | "
+                "<level>{message}</level>"
+            )
+
+        logger.add(
+            sys.stderr,
+            level=level,
+            format=format,
+            colorize=colorize,
+            backtrace=True,
+            diagnose=True
+        )
+
+        self.logger = logger
+
+    def _get_caller_info(self):
+        frame = inspect.currentframe()
+        try:
+            caller_frame = frame.f_back.f_back
+            full_path = caller_frame.f_code.co_filename
+            function = caller_frame.f_code.co_name
+            lineno = caller_frame.f_lineno
+
+            filename = os.path.basename(full_path)
+
+            return {
+                'filename': filename,
+                'function': function,
+                'lineno': lineno
+            }
+        finally:
+            del frame
+
+    def info(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        self.logger.bind(**caller_info).info(f"[{source}] {message}")
+
+    def error(self, message, source="API"):
+        caller_info = self._get_caller_info()
+
+        if isinstance(message, Exception):
+            self.logger.bind(**caller_info).exception(f"[{source}] {str(message)}")
+        else:
+            self.logger.bind(**caller_info).error(f"[{source}] {message}")
+
+    def warning(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        self.logger.bind(**caller_info).warning(f"[{source}] {message}")
+
+    def debug(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        self.logger.bind(**caller_info).debug(f"[{source}] {message}")
+
+    async def request_logger(self, request):
+        caller_info = self._get_caller_info()
+        self.logger.bind(**caller_info).info(f"请求: {request.method} {request.path}", "Request")
+
+logger = Logger(level="INFO")
+DATA_DIR = Path("/data")
+
+if not DATA_DIR.exists():
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+CONFIG = {
+    "MODELS": {
+        "grok-3": "grok-3",
+        "grok-3-search": "grok-3",
+        "grok-3-imageGen": "grok-3",
+        "grok-3-deepsearch": "grok-3",
+        "grok-3-deepersearch": "grok-3",
+        "grok-3-reasoning": "grok-3",
+        'grok-4': 'grok-4',
+        'grok-4-reasoning': 'grok-4',
+        'grok-4-imageGen': 'grok-4',
+        'grok-4-deepsearch': 'grok-4'
+    },
+    "API": {
+        "IS_TEMP_CONVERSATION": os.environ.get("IS_TEMP_CONVERSATION", "true").lower() == "true",
+        "IS_CUSTOM_SSO": os.environ.get("IS_CUSTOM_SSO", "false").lower() == "true",
+        "BASE_URL": "https://grok.com",
+        "API_KEY": os.environ.get("API_KEY", "sk-123456"),
+        "SIGNATURE_COOKIE": None,
+        "PICGO_KEY": os.environ.get("PICGO_KEY") or None,
+        "TUMY_KEY": os.environ.get("TUMY_KEY") or None,
+        "RETRY_TIME": 1000,
+        "PROXY": os.environ.get("PROXY") or None
+    },
+    "ADMIN": {
+        "MANAGER_SWITCH": os.environ.get("MANAGER_SWITCH") or None,
+        "PASSWORD": os.environ.get("ADMINPASSWORD") or None 
+    },
+    "SERVER": {
+        "COOKIE": None,
+        "CF_CLEARANCE":os.environ.get("CF_CLEARANCE") or None,
+        "PORT": int(os.environ.get("PORT", 5200))
+    },
+    "RETRY": {
+        "RETRYSWITCH": False,
+        "MAX_ATTEMPTS": 2
+    },
+    "TOKEN_STATUS_FILE": str(DATA_DIR / "token_status.json"),
+    "SHOW_THINKING": os.environ.get("SHOW_THINKING").lower() == "true",
+    "IS_THINKING": False,
+    "IS_IMG_GEN": False,
+    "IS_IMG_GEN2": False,
+    "ISSHOW_SEARCH_RESULTS": os.environ.get("ISSHOW_SEARCH_RESULTS", "true").lower() == "true",
+    "IS_SUPER_GROK": os.environ.get("IS_SUPER_GROK", "false").lower() == "true"
+}
+
+
+DEFAULT_HEADERS = {
+    'Accept': '*/*',
+    'Accept-Language': 'zh-CN,zh;q=0.9',
+    'Accept-Encoding': 'gzip, deflate, br, zstd',
+    'Content-Type': 'text/plain;charset=UTF-8',
+    '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-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c',
+    'x-statsig-id': 'ZTpUeXBlRXJyb3I6IENhbm5vdCByZWFkIHByb3BlcnRpZXMgb2YgdW5kZWZpbmVkIChyZWFkaW5nICdjaGlsZE5vZGVzJyk='
+}
+
+class AuthTokenManager:
+    def __init__(self):
+        self.token_model_map = {}
+        self.expired_tokens = set()
+        self.token_status_map = {}
+        self.model_super_config = {
+                "grok-3": {
+                    "RequestFrequency": 100,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 3小时
+                },
+                "grok-3-deepsearch": {
+                    "RequestFrequency": 30,
+                    "ExpirationTime": 24 * 60 * 60 * 1000  # 3小时
+                },
+                "grok-3-deepersearch": {
+                    "RequestFrequency": 10,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 23小时
+                },
+                "grok-3-reasoning": {
+                    "RequestFrequency": 30,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 3小时
+                },
+                "grok-4": {
+                    "RequestFrequency": 20,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 3小时
+                }
+            }
+        self.model_normal_config = {
+                "grok-3": {
+                    "RequestFrequency": 20,
+                    "ExpirationTime": 3 * 60 * 60 * 1000  # 3小时
+                },
+                "grok-3-deepsearch": {
+                    "RequestFrequency": 10,
+                    "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+                },
+                "grok-3-deepersearch": {
+                    "RequestFrequency": 3,
+                    "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+                },
+                "grok-3-reasoning": {
+                    "RequestFrequency": 8,
+                    "ExpirationTime": 24 * 60 * 60 * 1000  # 24小时
+                }
+            }
+        self.model_config = self.model_normal_config
+        self.token_reset_switch = False
+        self.token_reset_timer = None
+    def save_token_status(self):
+        try:        
+            with open(CONFIG["TOKEN_STATUS_FILE"], 'w', encoding='utf-8') as f:
+                json.dump(self.token_status_map, f, indent=2, ensure_ascii=False)
+            logger.info("令牌状态已保存到配置文件", "TokenManager")
+        except Exception as error:
+            logger.error(f"保存令牌状态失败: {str(error)}", "TokenManager")
+            
+    def load_token_status(self):
+        try:
+            token_status_file = Path(CONFIG["TOKEN_STATUS_FILE"])
+            if token_status_file.exists():
+                with open(token_status_file, 'r', encoding='utf-8') as f:
+                    self.token_status_map = json.load(f)
+                logger.info("已从配置文件加载令牌状态", "TokenManager")
+        except Exception as error:
+            logger.error(f"加载令牌状态失败: {str(error)}", "TokenManager")
+    def add_token(self, tokens, isinitialization=False):
+        tokenType = tokens.get("type")
+        tokenSso = tokens.get("token")
+        if tokenType == "normal":
+            self.model_config = self.model_normal_config
+        else:
+            self.model_config = self.model_super_config
+        sso = tokenSso.split("sso=")[1].split(";")[0]
+
+        for model in self.model_config.keys():
+            if model not in self.token_model_map:
+                self.token_model_map[model] = []
+            if sso not in self.token_status_map:
+                self.token_status_map[sso] = {}
+
+            existing_token_entry = next((entry for entry in self.token_model_map[model] if entry["token"] == tokenSso), None)
+
+            if not existing_token_entry:
+                self.token_model_map[model].append({
+                    "token": tokenSso,
+                    "MaxRequestCount": self.model_config[model]["RequestFrequency"],
+                    "RequestCount": 0,
+                    "AddedTime": int(time.time() * 1000),
+                    "StartCallTime": None,
+                    "type": tokenType
+                })
+
+                if model not in self.token_status_map[sso]:
+                    self.token_status_map[sso][model] = {
+                        "isValid": True,
+                        "invalidatedTime": None,
+                        "totalRequestCount": 0,
+                        "isSuper":tokenType == "super"
+                    }
+        if not isinitialization:
+            self.save_token_status()
+
+    def set_token(self, tokens):
+        tokenType = tokens.get("type")
+        tokenSso = tokens.get("token")
+        if tokenType == "normal":
+            self.model_config = self.model_normal_config
+        else:
+            self.model_config = self.model_super_config
+
+        models = list(self.model_config.keys())
+        self.token_model_map = {model: [{
+            "token": tokenSso,
+            "MaxRequestCount": self.model_config[model]["RequestFrequency"],
+            "RequestCount": 0,
+            "AddedTime": int(time.time() * 1000),
+            "StartCallTime": None,
+            "type": tokenType
+        }] for model in models}
+
+        sso = tokenSso.split("sso=")[1].split(";")[0]
+        self.token_status_map[sso] = {model: {
+            "isValid": True,
+            "invalidatedTime": None,
+            "totalRequestCount": 0,
+            "isSuper":tokenType == "super"
+        } for model in models}
+
+    def delete_token(self, token):
+        try:
+            sso = token.split("sso=")[1].split(";")[0]
+            for model in self.token_model_map:
+                self.token_model_map[model] = [entry for entry in self.token_model_map[model] if entry["token"] != token]
+
+            if sso in self.token_status_map:
+                del self.token_status_map[sso]
+            
+            self.save_token_status()
+
+            logger.info(f"令牌已成功移除: {token}", "TokenManager")
+            return True
+        except Exception as error:
+            logger.error(f"令牌删除失败: {str(error)}")
+            return False
+    def reduce_token_request_count(self, model_id, count):
+        try:
+            normalized_model = self.normalize_model_name(model_id)
+            
+            if normalized_model not in self.token_model_map:
+                logger.error(f"模型 {normalized_model} 不存在", "TokenManager")
+                return False
+                
+            if not self.token_model_map[normalized_model]:
+                logger.error(f"模型 {normalized_model} 没有可用的token", "TokenManager")
+                return False
+                
+            token_entry = self.token_model_map[normalized_model][0]
+            
+            # 确保RequestCount不会小于0
+            new_count = max(0, token_entry["RequestCount"] - count)
+            reduction = token_entry["RequestCount"] - new_count
+            
+            token_entry["RequestCount"] = new_count
+            
+            # 更新token状态
+            if token_entry["token"]:
+                sso = token_entry["token"].split("sso=")[1].split(";")[0]
+                if sso in self.token_status_map and normalized_model in self.token_status_map[sso]:
+                    self.token_status_map[sso][normalized_model]["totalRequestCount"] = max(
+                        0, 
+                        self.token_status_map[sso][normalized_model]["totalRequestCount"] - reduction
+                    )
+            return True
+            
+        except Exception as error:
+            logger.error(f"重置校对token请求次数时发生错误: {str(error)}", "TokenManager")
+            return False
+    def get_next_token_for_model(self, model_id, is_return=False):
+        normalized_model = self.normalize_model_name(model_id)
+
+        if normalized_model not in self.token_model_map or not self.token_model_map[normalized_model]:
+            return None
+
+        token_entry = self.token_model_map[normalized_model][0]
+        logger.info(f"token_entry: {token_entry}", "TokenManager")
+        if is_return:
+            return token_entry["token"]
+
+        if token_entry:
+            if token_entry["type"] == "super":
+                self.model_config = self.model_super_config
+            else:
+                self.model_config = self.model_normal_config
+            if token_entry["StartCallTime"] is None:
+                token_entry["StartCallTime"] = int(time.time() * 1000)
+
+            if not self.token_reset_switch:
+                self.start_token_reset_process()
+                self.token_reset_switch = True
+
+            token_entry["RequestCount"] += 1
+
+            if token_entry["RequestCount"] > token_entry["MaxRequestCount"]:
+                self.remove_token_from_model(normalized_model, token_entry["token"])
+                next_token_entry = self.token_model_map[normalized_model][0] if self.token_model_map[normalized_model] else None
+                return next_token_entry["token"] if next_token_entry else None
+
+            sso = token_entry["token"].split("sso=")[1].split(";")[0]
+
+            if sso in self.token_status_map and normalized_model in self.token_status_map[sso]:
+                if token_entry["RequestCount"] == self.model_config[normalized_model]["RequestFrequency"]:
+                    self.token_status_map[sso][normalized_model]["isValid"] = False
+                    self.token_status_map[sso][normalized_model]["invalidatedTime"] = int(time.time() * 1000)
+                self.token_status_map[sso][normalized_model]["totalRequestCount"] += 1
+
+                
+
+                self.save_token_status()
+
+            return token_entry["token"]
+
+        return None
+
+    def remove_token_from_model(self, model_id, token):
+        normalized_model = self.normalize_model_name(model_id)
+
+        if normalized_model not in self.token_model_map:
+            logger.error(f"模型 {normalized_model} 不存在", "TokenManager")
+            return False
+
+        model_tokens = self.token_model_map[normalized_model]
+        token_index = next((i for i, entry in enumerate(model_tokens) if entry["token"] == token), -1)
+
+        if token_index != -1:
+            removed_token_entry = model_tokens.pop(token_index)
+            self.expired_tokens.add((
+                removed_token_entry["token"],
+                normalized_model,
+                int(time.time() * 1000),
+                removed_token_entry["type"]
+            ))
+
+            if not self.token_reset_switch:
+                self.start_token_reset_process()
+                self.token_reset_switch = True
+
+            logger.info(f"模型{model_id}的令牌已失效，已成功移除令牌: {token}", "TokenManager")
+            return True
+
+        logger.error(f"在模型 {normalized_model} 中未找到 token: {token}", "TokenManager")
+        return False
+
+    def get_expired_tokens(self):
+        return list(self.expired_tokens)
+
+    def normalize_model_name(self, model):
+        if model.startswith('grok-') and not any(keyword in model for keyword in ['deepsearch','deepersearch','reasoning']):
+            return '-'.join(model.split('-')[:2])
+        return model
+
+    def get_token_count_for_model(self, model_id):
+        normalized_model = self.normalize_model_name(model_id)
+        return len(self.token_model_map.get(normalized_model, []))
+
+    def get_remaining_token_request_capacity(self):
+        remaining_capacity_map = {}
+
+        for model in self.model_config.keys():
+            model_tokens = self.token_model_map.get(model, [])
+            
+            model_request_frequency = sum(token_entry.get("MaxRequestCount", 0) for token_entry in model_tokens)
+            total_used_requests = sum(token_entry.get("RequestCount", 0) for token_entry in model_tokens)
+
+            remaining_capacity = (len(model_tokens) * model_request_frequency) - total_used_requests
+            remaining_capacity_map[model] = max(0, remaining_capacity)
+
+        return remaining_capacity_map
+
+    def get_token_array_for_model(self, model_id):
+        normalized_model = self.normalize_model_name(model_id)
+        return self.token_model_map.get(normalized_model, [])
+
+    def start_token_reset_process(self):
+        def reset_expired_tokens():
+            now = int(time.time() * 1000)
+
+            model_config = self.model_normal_config
+            tokens_to_remove = set()
+            for token_info in self.expired_tokens:
+                token, model, expired_time ,type = token_info
+                if type == "super":
+                    model_config = self.model_super_config
+                expiration_time = model_config[model]["ExpirationTime"]
+
+                if now - expired_time >= expiration_time:
+                    if not any(entry["token"] == token for entry in self.token_model_map.get(model, [])):
+                        if model not in self.token_model_map:
+                            self.token_model_map[model] = []
+
+                        self.token_model_map[model].append({
+                            "token": token,
+                            "MaxRequestCount": model_config[model]["RequestFrequency"],
+                            "RequestCount": 0,
+                            "AddedTime": now,
+                            "StartCallTime": None,
+                            "type": type
+                        })
+
+                    sso = token.split("sso=")[1].split(";")[0]
+                    if sso in self.token_status_map and model in self.token_status_map[sso]:
+                        self.token_status_map[sso][model]["isValid"] = True
+                        self.token_status_map[sso][model]["invalidatedTime"] = None
+                        self.token_status_map[sso][model]["totalRequestCount"] = 0
+                        self.token_status_map[sso][model]["isSuper"] = type == "super"
+
+                    tokens_to_remove.add(token_info)
+
+            self.expired_tokens -= tokens_to_remove
+
+            for model in model_config.keys():
+                if model not in self.token_model_map:
+                    continue
+
+                for token_entry in self.token_model_map[model]:
+                    if not token_entry.get("StartCallTime"):
+                        continue
+
+                    expiration_time = model_config[model]["ExpirationTime"]
+                    if now - token_entry["StartCallTime"] >= expiration_time:
+                        sso = token_entry["token"].split("sso=")[1].split(";")[0]
+                        if sso in self.token_status_map and model in self.token_status_map[sso]:
+                            self.token_status_map[sso][model]["isValid"] = True
+                            self.token_status_map[sso][model]["invalidatedTime"] = None
+                            self.token_status_map[sso][model]["totalRequestCount"] = 0
+                            self.token_status_map[sso][model]["isSuper"] = token_entry["type"] == "super"
+
+                        token_entry["RequestCount"] = 0
+                        token_entry["StartCallTime"] = None
+
+        import threading
+        # 启动一个线程执行定时任务，每小时执行一次
+        def run_timer():
+            while True:
+                reset_expired_tokens()
+                time.sleep(3600)
+
+        timer_thread = threading.Thread(target=run_timer)
+        timer_thread.daemon = True
+        timer_thread.start()
+
+    def get_all_tokens(self):
+        all_tokens = set()
+        for model_tokens in self.token_model_map.values():
+            for entry in model_tokens:
+                all_tokens.add(entry["token"])
+        return list(all_tokens)
+    def get_current_token(self, model_id):
+        normalized_model = self.normalize_model_name(model_id)
+
+        if normalized_model not in self.token_model_map or not self.token_model_map[normalized_model]:
+            return None
+
+        token_entry = self.token_model_map[normalized_model][0]
+        return token_entry["token"]
+
+    def get_token_status_map(self):
+        return self.token_status_map
+
+class Utils:
+    @staticmethod
+    def organize_search_results(search_results):
+        if not search_results or 'results' not in search_results:
+            return ''
+
+        results = search_results['results']
+        formatted_results = []
+
+        for index, result in enumerate(results):
+            title = result.get('title', '未知标题')
+            url = result.get('url', '#')
+            preview = result.get('preview', '无预览内容')
+
+            formatted_result = f"\r\n<details><summary>资料[{index}]: {title}</summary>\r\n{preview}\r\n\n[Link]({url})\r\n</details>"
+            formatted_results.append(formatted_result)
+
+        return '\n\n'.join(formatted_results)
+
+    @staticmethod
+    def create_auth_headers(model, is_return=False):
+        return token_manager.get_next_token_for_model(model, is_return)
+
+    @staticmethod
+    def get_proxy_options():
+        proxy = CONFIG["API"]["PROXY"]
+        proxy_options = {}
+
+        if proxy:
+            logger.info(f"使用代理: {proxy}", "Server")
+            
+            if proxy.startswith("socks5://"):
+                proxy_options["proxy"] = proxy
+            
+                if '@' in proxy:
+                    auth_part = proxy.split('@')[0].split('://')[1]
+                    if ':' in auth_part:
+                        username, password = auth_part.split(':')
+                        proxy_options["proxy_auth"] = (username, password)
+            else:
+                proxy_options["proxies"] = {"https": proxy, "http": proxy}     
+        return proxy_options
+
+class GrokApiClient:
+    def __init__(self, model_id):
+        if model_id not in CONFIG["MODELS"]:
+            raise ValueError(f"不支持的模型: {model_id}")
+        self.model_id = CONFIG["MODELS"][model_id]
+
+    def process_message_content(self, content):
+        if isinstance(content, str):
+            return content
+        return None
+
+    def get_image_type(self, base64_string):
+        mime_type = 'image/jpeg'
+        if 'data:image' in base64_string:
+            import re
+            matches = re.search(r'data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+);base64,', base64_string)
+            if matches:
+                mime_type = matches.group(1)
+
+        extension = mime_type.split('/')[1]
+        file_name = f"image.{extension}"
+
+        return {
+            "mimeType": mime_type,
+            "fileName": file_name
+        }
+    def upload_base64_file(self, message, model):
+        try:
+            message_base64 = base64.b64encode(message.encode('utf-8')).decode('utf-8')
+            upload_data = {
+                "fileName": "message.txt",
+                "fileMimeType": "text/plain",
+                "content": message_base64
+            }
+
+            logger.info("发送文字文件请求", "Server")
+            cookie = f"{Utils.create_auth_headers(model, True)};{CONFIG['SERVER']['CF_CLEARANCE']}" 
+            proxy_options = Utils.get_proxy_options()
+            response = curl_requests.post(
+                "https://grok.com/rest/app-chat/upload-file",
+                headers={
+                    **DEFAULT_HEADERS,
+                    "Cookie":cookie
+                },
+                json=upload_data,
+                impersonate="chrome133a",
+                **proxy_options
+            )
+
+            if response.status_code != 200:
+                logger.error(f"上传文件失败,状态码:{response.status_code}", "Server")
+                raise Exception(f"上传文件失败,状态码:{response.status_code}")
+
+            result = response.json()
+            logger.info(f"上传文件成功: {result}", "Server")
+            return result.get("fileMetadataId", "")
+
+        except Exception as error:
+            logger.error(str(error), "Server")
+            raise Exception(f"上传文件失败,状态码:{response.status_code}")
+    def upload_base64_image(self, base64_data, url):
+        try:
+            if 'data:image' in base64_data:
+                image_buffer = base64_data.split(',')[1]
+            else:
+                image_buffer = base64_data
+
+            image_info = self.get_image_type(base64_data)
+            mime_type = image_info["mimeType"]
+            file_name = image_info["fileName"]
+
+            upload_data = {
+                "rpc": "uploadFile",
+                "req": {
+                    "fileName": file_name,
+                    "fileMimeType": mime_type,
+                    "content": image_buffer
+                }
+            }
+
+            logger.info("发送图片请求", "Server")
+
+            proxy_options = Utils.get_proxy_options()
+            response = curl_requests.post(
+                url,
+                headers={
+                    **DEFAULT_HEADERS,
+                    "Cookie":CONFIG["SERVER"]['COOKIE']
+                },
+                json=upload_data,
+                impersonate="chrome133a",
+                **proxy_options
+            )
+
+            if response.status_code != 200:
+                logger.error(f"上传图片失败,状态码:{response.status_code}", "Server")
+                return ''
+
+            result = response.json()
+            logger.info(f"上传图片成功: {result}", "Server")
+            return result.get("fileMetadataId", "")
+
+        except Exception as error:
+            logger.error(str(error), "Server")
+            return ''
+    # def convert_system_messages(self, messages):
+    #     try:
+    #         system_prompt = []
+    #         i = 0
+    #         while i < len(messages):
+    #             if messages[i].get('role') != 'system':
+    #                 break
+
+    #             system_prompt.append(self.process_message_content(messages[i].get('content')))
+    #             i += 1
+
+    #         messages = messages[i:]
+    #         system_prompt = '\n'.join(system_prompt)
+
+    #         if not messages:
+    #             raise ValueError("没有找到用户或者AI消息")
+    #         return {"system_prompt":system_prompt,"messages":messages}
+    #     except Exception as error:
+    #         logger.error(str(error), "Server")
+    #         raise ValueError(error)
+    def prepare_chat_request(self, request):
+        if ((request["model"] == 'grok-4-imageGen' or request["model"] == 'grok-3-imageGen') and
+            not CONFIG["API"]["PICGO_KEY"] and not CONFIG["API"]["TUMY_KEY"] and
+            request.get("stream", False)):
+            raise ValueError("该模型流式输出需要配置PICGO或者TUMY图床密钥!")
+
+        # system_message, todo_messages = self.convert_system_messages(request["messages"]).values()
+        todo_messages = request["messages"]
+        if request["model"] in ['grok-4-imageGen', 'grok-3-imageGen', 'grok-3-deepsearch']:
+            last_message = todo_messages[-1]
+            if last_message["role"] != 'user':
+                raise ValueError('此模型最后一条消息必须是用户消息!')
+            todo_messages = [last_message]
+        file_attachments = []
+        messages = ''
+        last_role = None
+        last_content = ''
+        message_length = 0
+        convert_to_file = False
+        last_message_content = ''
+        search = request["model"] in ['grok-4-deepsearch', 'grok-3-search']
+        deepsearchPreset = ''
+        if request["model"] == 'grok-3-deepsearch':
+            deepsearchPreset = 'default'
+        elif request["model"] == 'grok-3-deepersearch':
+            deepsearchPreset = 'deeper'
+
+        # 移除<think>标签及其内容和base64图片
+        def remove_think_tags(text):
+            import re
+            text = re.sub(r'<think>[\s\S]*?<\/think>', '', text).strip()
+            text = re.sub(r'!\[image\]\(data:.*?base64,.*?\)', '[图片]', text)
+            return text
+
+        def process_content(content):
+            if isinstance(content, list):
+                text_content = ''
+                for item in content:
+                    if item["type"] == 'image_url':
+                        text_content += ("[图片]" if not text_content else '\n[图片]')
+                    elif item["type"] == 'text':
+                        text_content += (remove_think_tags(item["text"]) if not text_content else '\n' + remove_think_tags(item["text"]))
+                return text_content
+            elif isinstance(content, dict) and content is not None:
+                if content["type"] == 'image_url':
+                    return "[图片]"
+                elif content["type"] == 'text':
+                    return remove_think_tags(content["text"])
+            return remove_think_tags(self.process_message_content(content))
+        for current in todo_messages:
+            role = 'assistant' if current["role"] == 'assistant' else 'user'
+            is_last_message = current == todo_messages[-1]
+
+            if is_last_message and "content" in current:
+                if isinstance(current["content"], list):
+                    for item in current["content"]:
+                        if item["type"] == 'image_url':
+                            processed_image = self.upload_base64_image(
+                                item["image_url"]["url"],
+                                f"{CONFIG['API']['BASE_URL']}/api/rpc"
+                            )
+                            if processed_image:
+                                file_attachments.append(processed_image)
+                elif isinstance(current["content"], dict) and current["content"].get("type") == 'image_url':
+                    processed_image = self.upload_base64_image(
+                        current["content"]["image_url"]["url"],
+                        f"{CONFIG['API']['BASE_URL']}/api/rpc"
+                    )
+                    if processed_image:
+                        file_attachments.append(processed_image)
+
+
+            text_content = process_content(current.get("content", ""))
+            if is_last_message and convert_to_file:
+                last_message_content = f"{role.upper()}: {text_content or '[图片]'}\n"
+                continue
+            if text_content or (is_last_message and file_attachments):
+                if role == last_role and text_content:
+                    last_content += '\n' + text_content
+                    messages = messages[:messages.rindex(f"{role.upper()}: ")] + f"{role.upper()}: {last_content}\n"
+                else:
+                    messages += f"{role.upper()}: {text_content or '[图片]'}\n"
+                    last_content = text_content
+                    last_role = role
+            message_length += len(messages)
+            if message_length >= 40000:
+                convert_to_file = True
+               
+        if convert_to_file:
+            file_id = self.upload_base64_file(messages, request["model"])
+            if file_id:
+                file_attachments.insert(0, file_id)
+            messages = last_message_content.strip()
+        if messages.strip() == '':
+            if convert_to_file:
+                messages = '基于txt文件内容进行回复：'
+            else:
+                raise ValueError('消息内容为空!')
+        return {
+            "temporary": CONFIG["API"].get("IS_TEMP_CONVERSATION", False),
+            "modelName": self.model_id,
+            "message": messages.strip(),
+            "fileAttachments": file_attachments[:4],
+            "imageAttachments": [],
+            "disableSearch": False,
+            "enableImageGeneration": True,
+            "returnImageBytes": False,
+            "returnRawGrokInXaiRequest": False,
+            "enableImageStreaming": False,
+            "imageGenerationCount": 1,
+            "forceConcise": False,
+            "toolOverrides": {
+                "imageGen": request["model"] in ['grok-4-imageGen', 'grok-3-imageGen'],
+                "webSearch": search,
+                "xSearch": search,
+                "xMediaSearch": search,
+                "trendsSearch": search,
+                "xPostAnalyze": search
+            },
+            "enableSideBySide": True,
+            "sendFinalMetadata": True,
+            "customPersonality": "",
+            "deepsearchPreset": deepsearchPreset,
+            "isReasoning": request["model"] == 'grok-3-reasoning',
+            "disableTextFollowUps": True
+        }
+
+class MessageProcessor:
+    @staticmethod
+    def create_chat_response(message, model, is_stream=False):
+        base_response = {
+            "id": f"chatcmpl-{uuid.uuid4()}",
+            "created": int(time.time()),
+            "model": model
+        }
+
+        if is_stream:
+            return {
+                **base_response,
+                "object": "chat.completion.chunk",
+                "choices": [{
+                    "index": 0,
+                    "delta": {
+                        "content": message
+                    }
+                }]
+            }
+
+        return {
+            **base_response,
+            "object": "chat.completion",
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": message
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": None
+        }
+
+def process_model_response(response, model):
+    result = {"token": None, "imageUrl": None}
+
+    if CONFIG["IS_IMG_GEN"]:
+        if response.get("cachedImageGenerationResponse") and not CONFIG["IS_IMG_GEN2"]:
+            result["imageUrl"] = response["cachedImageGenerationResponse"]["imageUrl"]
+        return result
+    if model == 'grok-3':
+        result["token"] = response.get("token")
+    elif model in ['grok-3-search']:
+        if response.get("webSearchResults") and CONFIG["ISSHOW_SEARCH_RESULTS"]:
+            result["token"] = f"\r\n<think>{Utils.organize_search_results(response['webSearchResults'])}</think>\r\n"
+        else:
+            result["token"] = response.get("token")
+    elif model in ['grok-3-deepsearch', 'grok-3-deepersearch','grok-4-deepsearch']:
+        if response.get("messageStepId") and not CONFIG["SHOW_THINKING"]:
+            return result
+        if response.get("messageStepId") and not CONFIG["IS_THINKING"]:
+            result["token"] = "<think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = True
+        elif not response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "final":
+            result["token"] = "</think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = False
+        elif (response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant") or response.get("messageTag") == "final":
+            result["token"] = response.get("token","")
+        elif (CONFIG["IS_THINKING"] and response.get("token","").get("action","") == "webSearch"):
+            result["token"] = response.get("token","").get("action_input","").get("query","")            
+        elif (CONFIG["IS_THINKING"] and response.get("webSearchResults")):
+            result["token"] = Utils.organize_search_results(response['webSearchResults'])
+    elif model == 'grok-3-reasoning':
+        if response.get("isThinking") and not CONFIG["SHOW_THINKING"]:
+            return result
+
+        if response.get("isThinking") and not CONFIG["IS_THINKING"]:
+            result["token"] = "<think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = True
+        elif not response.get("isThinking") and CONFIG["IS_THINKING"]:
+            result["token"] = "</think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = False
+        else:
+            result["token"] = response.get("token")
+
+    elif model == 'grok-4':
+        if response.get("isThinking"):
+            return result
+        result["token"] = response.get("token")
+    elif model == 'grok-4-reasoning':
+        if response.get("isThinking") and not CONFIG["SHOW_THINKING"]:
+            return result
+        if response.get("isThinking") and not CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant":
+            result["token"] = "<think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = True
+        elif not response.get("isThinking") and CONFIG["IS_THINKING"] and response.get("messageTag") == "final":
+            result["token"] = "</think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = False
+        else:
+            result["token"] = response.get("token")  
+    elif model in ['grok-4-deepsearch']:
+        if response.get("messageStepId") and not CONFIG["SHOW_THINKING"]:
+            return result
+        if response.get("messageStepId") and not CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant":
+            result["token"] = "<think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = True
+        elif not response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "final":
+            result["token"] = "</think>" + response.get("token", "")
+            CONFIG["IS_THINKING"] = False
+        elif (response.get("messageStepId") and CONFIG["IS_THINKING"] and response.get("messageTag") == "assistant") or response.get("messageTag") == "final":
+            result["token"] = response.get("token","")
+        elif (CONFIG["IS_THINKING"] and response.get("token","").get("action","") == "webSearch"):
+            result["token"] = response.get("token","").get("action_input","").get("query","")            
+        elif (CONFIG["IS_THINKING"] and response.get("webSearchResults")):
+            result["token"] = Utils.organize_search_results(response['webSearchResults'])      
+
+    return result
+
+def handle_image_response(image_url):
+    max_retries = 2
+    retry_count = 0
+    image_base64_response = None
+
+    while retry_count < max_retries:
+        try:
+            proxy_options = Utils.get_proxy_options()
+            image_base64_response = curl_requests.get(
+                f"https://assets.grok.com/{image_url}",
+                headers={
+                    **DEFAULT_HEADERS,
+                    "Cookie":CONFIG["SERVER"]['COOKIE']
+                },
+                impersonate="chrome133a",
+                **proxy_options
+            )
+
+            if image_base64_response.status_code == 200:
+                break
+
+            retry_count += 1
+            if retry_count == max_retries:
+                raise Exception(f"上游服务请求失败! status: {image_base64_response.status_code}")
+
+            time.sleep(CONFIG["API"]["RETRY_TIME"] / 1000 * retry_count)
+
+        except Exception as error:
+            logger.error(str(error), "Server")
+            retry_count += 1
+            if retry_count == max_retries:
+                raise
+
+            time.sleep(CONFIG["API"]["RETRY_TIME"] / 1000 * retry_count)
+
+    image_buffer = image_base64_response.content
+
+    if not CONFIG["API"]["PICGO_KEY"] and not CONFIG["API"]["TUMY_KEY"]:
+        base64_image = base64.b64encode(image_buffer).decode('utf-8')
+        image_content_type = image_base64_response.headers.get('content-type', 'image/jpeg')
+        return f"![image](data:{image_content_type};base64,{base64_image})"
+
+    logger.info("开始上传图床", "Server")
+
+    if CONFIG["API"]["PICGO_KEY"]:
+        files = {'source': ('image.jpg', image_buffer, 'image/jpeg')}
+        headers = {
+            "X-API-Key": CONFIG["API"]["PICGO_KEY"]
+        }
+
+        response_url = requests.post(
+            "https://www.picgo.net/api/1/upload",
+            files=files,
+            headers=headers
+        )
+
+        if response_url.status_code != 200:
+            return "生图失败，请查看PICGO图床密钥是否设置正确"
+        else:
+            logger.info("生图成功", "Server")
+            result = response_url.json()
+            return f"![image]({result['image']['url']})"
+
+
+    elif CONFIG["API"]["TUMY_KEY"]:
+        files = {'file': ('image.jpg', image_buffer, 'image/jpeg')}
+        headers = {
+            "Accept": "application/json",
+            'Authorization': f"Bearer {CONFIG['API']['TUMY_KEY']}"
+        }
+
+        response_url = requests.post(
+            "https://tu.my/api/v1/upload",
+            files=files,
+            headers=headers
+        )
+
+        if response_url.status_code != 200:
+            return "生图失败，请查看TUMY图床密钥是否设置正确"
+        else:
+            try:
+                result = response_url.json()
+                logger.info("生图成功", "Server")
+                return f"![image]({result['data']['links']['url']})"
+            except Exception as error:
+                logger.error(str(error), "Server")
+                return "生图失败，请查看TUMY图床密钥是否设置正确"
+
+def handle_non_stream_response(response, model):
+    try:
+        logger.info("开始处理非流式响应", "Server")
+
+        stream = response.iter_lines()
+        full_response = ""
+
+        CONFIG["IS_THINKING"] = False
+        CONFIG["IS_IMG_GEN"] = False
+        CONFIG["IS_IMG_GEN2"] = False
+
+        for chunk in stream:
+            if not chunk:
+                continue
+            try:
+                line_json = json.loads(chunk.decode("utf-8").strip())
+                if line_json.get("error"):
+                    logger.error(json.dumps(line_json, indent=2), "Server")
+                    return json.dumps({"error": "RateLimitError"}) + "\n\n"
+
+                response_data = line_json.get("result", {}).get("response")
+                if not response_data:
+                    continue
+
+                if response_data.get("doImgGen") or response_data.get("imageAttachmentInfo"):
+                    CONFIG["IS_IMG_GEN"] = True
+
+                result = process_model_response(response_data, model)
+
+                if result["token"]:
+                    full_response += result["token"]
+
+                if result["imageUrl"]:
+                    CONFIG["IS_IMG_GEN2"] = True
+                    return handle_image_response(result["imageUrl"])
+
+            except json.JSONDecodeError:
+                continue
+            except Exception as e:
+                logger.error(f"处理流式响应行时出错: {str(e)}", "Server")
+                continue
+
+        return full_response
+    except Exception as error:
+        logger.error(str(error), "Server")
+        raise
+def handle_stream_response(response, model):
+    def generate():
+        logger.info("开始处理流式响应", "Server")
+
+        stream = response.iter_lines()
+        CONFIG["IS_THINKING"] = False
+        CONFIG["IS_IMG_GEN"] = False
+        CONFIG["IS_IMG_GEN2"] = False
+
+        for chunk in stream:
+            if not chunk:
+                continue
+            try:
+                line_json = json.loads(chunk.decode("utf-8").strip())
+                print(line_json)
+                if line_json.get("error"):
+                    logger.error(json.dumps(line_json, indent=2), "Server")
+                    yield json.dumps({"error": "RateLimitError"}) + "\n\n"
+                    return
+
+                response_data = line_json.get("result", {}).get("response")
+                if not response_data:
+                    continue
+
+                if response_data.get("doImgGen") or response_data.get("imageAttachmentInfo"):
+                    CONFIG["IS_IMG_GEN"] = True
+
+                result = process_model_response(response_data, model)
+
+                if result["token"]:
+                    yield f"data: {json.dumps(MessageProcessor.create_chat_response(result['token'], model, True))}\n\n"
+
+                if result["imageUrl"]:
+                    CONFIG["IS_IMG_GEN2"] = True
+                    image_data = handle_image_response(result["imageUrl"])
+                    yield f"data: {json.dumps(MessageProcessor.create_chat_response(image_data, model, True))}\n\n"
+
+            except json.JSONDecodeError:
+                continue
+            except Exception as e:
+                logger.error(f"处理流式响应��时出错: {str(e)}", "Server")
+                continue
+
+        yield "data: [DONE]\n\n"
+    return generate()
+
+def initialization():
+    sso_array = os.environ.get("SSO", "").split(',')
+    sso_array_super = os.environ.get("SSO_SUPER", "").split(',')
+
+    combined_dict = []
+    for value in sso_array_super:
+        combined_dict.append({
+            "token": f"sso-rw={value};sso={value}", 
+            "type": "super"
+        })
+    for value in sso_array:
+        combined_dict.append({
+            "token": f"sso-rw={value};sso={value}", 
+            "type": "normal"
+        })
+    
+
+    logger.info("开始加载令牌", "Server")
+    token_manager.load_token_status()
+    for tokens in combined_dict:
+        if tokens:
+            token_manager.add_token(tokens,True)
+    token_manager.save_token_status()
+
+    logger.info(f"成功加载令牌: {json.dumps(token_manager.get_all_tokens(), indent=2)}", "Server")
+    logger.info(f"令牌加载完成，共加载: {len(sso_array)+len(sso_array_super)}个令牌", "Server")
+    logger.info(f"其中共加载: {len(sso_array_super)}个super会员令牌", "Server")
+
+    if CONFIG["API"]["PROXY"]:
+        logger.info(f"代理已设置: {CONFIG['API']['PROXY']}", "Server")
+
+    logger.info("初始化完成", "Server")
+
+
+app = Flask(__name__)
+app.wsgi_app = ProxyFix(app.wsgi_app)
+app.secret_key = os.environ.get('FLASK_SECRET_KEY') or secrets.token_hex(16)
+app.json.sort_keys = False
+
+@app.route('/manager/login', methods=['GET', 'POST'])
+def manager_login():
+    if CONFIG["ADMIN"]["MANAGER_SWITCH"]:
+        if request.method == 'POST':
+            password = request.form.get('password')
+            if password == CONFIG["ADMIN"]["PASSWORD"]:
+                session['is_logged_in'] = True
+                return redirect('/manager')
+            return render_template('login.html', error=True)
+        return render_template('login.html', error=False)
+    else:
+        return redirect('/')
+
+def check_auth():
+    return session.get('is_logged_in', False)
+
+@app.route('/manager')
+def manager():
+    if not check_auth():
+        return redirect('/manager/login')
+    return render_template('manager.html')
+
+@app.route('/manager/api/get')
+def get_manager_tokens():
+    if not check_auth():
+        return jsonify({"error": "Unauthorized"}), 401
+    return jsonify(token_manager.get_token_status_map())
+
+@app.route('/manager/api/add', methods=['POST'])
+def add_manager_token():
+    if not check_auth():
+        return jsonify({"error": "Unauthorized"}), 401
+    try:
+        sso = request.json.get('sso')
+        if not sso:
+            return jsonify({"error": "SSO token is required"}), 400
+        token_manager.add_token({"token":f"sso-rw={sso};sso={sso}","type":"normal"})
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/manager/api/delete', methods=['POST'])
+def delete_manager_token():
+    if not check_auth():
+        return jsonify({"error": "Unauthorized"}), 401
+    try:
+        sso = request.json.get('sso')
+        if not sso:
+            return jsonify({"error": "SSO token is required"}), 400
+        token_manager.delete_token(f"sso-rw={sso};sso={sso}")
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+    
+@app.route('/manager/api/cf_clearance', methods=['POST'])   
+def setCf_Manager_clearance():
+    if not check_auth():
+        return jsonify({"error": "Unauthorized"}), 401
+    try:
+        cf_clearance = request.json.get('cf_clearance')
+        if not cf_clearance:
+            return jsonify({"error": "cf_clearance is required"}), 400
+        CONFIG["SERVER"]['CF_CLEARANCE'] = cf_clearance
+        return jsonify({"success": True})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route('/get/tokens', methods=['GET'])
+def get_tokens():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+        return jsonify({"error": '自定义的SSO令牌模式无法获取轮询sso令牌状态'}), 403
+    elif auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+    return jsonify(token_manager.get_token_status_map())
+
+@app.route('/add/token', methods=['POST'])
+def add_token():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+        return jsonify({"error": '自定义的SSO令牌模式无法添加sso令牌'}), 403
+    elif auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+
+    try:
+        sso = request.json.get('sso')
+        token_manager.add_token({"token":f"sso-rw={sso};sso={sso}","type":"normal"})
+        return jsonify(token_manager.get_token_status_map().get(sso, {})), 200
+    except Exception as error:
+        logger.error(str(error), "Server")
+        return jsonify({"error": '添加sso令牌失败'}), 500
+    
+@app.route('/set/cf_clearance', methods=['POST'])
+def setCf_clearance():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+    try:
+        cf_clearance = request.json.get('cf_clearance')
+        CONFIG["SERVER"]['CF_CLEARANCE'] = cf_clearance
+        return jsonify({"message": '设置cf_clearance成功'}), 200
+    except Exception as error:
+        logger.error(str(error), "Server")
+        return jsonify({"error": '设置cf_clearance失败'}), 500
+    
+@app.route('/delete/token', methods=['POST'])
+def delete_token():
+    auth_token = request.headers.get('Authorization', '').replace('Bearer ', '')
+    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+        return jsonify({"error": '自定义的SSO令牌模式无法删除sso令牌'}), 403
+    elif auth_token != CONFIG["API"]["API_KEY"]:
+        return jsonify({"error": 'Unauthorized'}), 401
+
+    try:
+        sso = request.json.get('sso')
+        token_manager.delete_token(f"sso-rw={sso};sso={sso}")
+        return jsonify({"message": '删除sso令牌成功'}), 200
+    except Exception as error:
+        logger.error(str(error), "Server")
+        return jsonify({"error": '删除sso令牌失败'}), 500
+
+@app.route('/v1/models', methods=['GET'])
+def get_models():
+    return jsonify({
+        "object": "list",
+        "data": [
+            {
+                "id": model,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "grok"
+            }
+            for model in CONFIG["MODELS"].keys()
+        ]
+    })
+
+@app.route('/v1/chat/completions', methods=['POST'])
+def chat_completions():
+    response_status_code = 500
+    try:
+        auth_token = request.headers.get('Authorization',
+                                         '').replace('Bearer ', '')
+        if auth_token:
+            if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                result = f"sso={auth_token};sso-rw={auth_token}"
+                token_manager.set_token(result)
+            elif auth_token != CONFIG["API"]["API_KEY"]:
+                return jsonify({"error": 'Unauthorized'}), 401
+        else:
+            return jsonify({"error": 'API_KEY缺失'}), 401
+
+        data = request.json
+        model = data.get("model")
+        stream = data.get("stream", False)
+
+        retry_count = 0
+        grok_client = GrokApiClient(model)
+        request_payload = grok_client.prepare_chat_request(data)
+
+        logger.info(json.dumps(request_payload,indent=2))
+
+        while retry_count < CONFIG["RETRY"]["MAX_ATTEMPTS"]:
+            retry_count += 1
+            CONFIG["API"]["SIGNATURE_COOKIE"] = Utils.create_auth_headers(model)
+
+            if not CONFIG["API"]["SIGNATURE_COOKIE"]:
+                raise ValueError('该模型无可用令牌')
+
+            logger.info(
+                f"当前令牌: {json.dumps(CONFIG['API']['SIGNATURE_COOKIE'], indent=2)}","Server")
+            logger.info(
+                f"当前可用模型的全部可用数量: {json.dumps(token_manager.get_remaining_token_request_capacity(), indent=2)}","Server")
+            
+            if CONFIG['SERVER']['CF_CLEARANCE']:
+                CONFIG["SERVER"]['COOKIE'] = f"{CONFIG['API']['SIGNATURE_COOKIE']};{CONFIG['SERVER']['CF_CLEARANCE']}" 
+            else:
+                CONFIG["SERVER"]['COOKIE'] = CONFIG['API']['SIGNATURE_COOKIE']
+            logger.info(json.dumps(request_payload,indent=2),"Server")
+            try:
+                proxy_options = Utils.get_proxy_options()
+                response = curl_requests.post(
+                    f"{CONFIG['API']['BASE_URL']}/rest/app-chat/conversations/new",
+                    headers={
+                        **DEFAULT_HEADERS, 
+                        "Cookie":CONFIG["SERVER"]['COOKIE']
+                    },
+                    data=json.dumps(request_payload),
+                    impersonate="chrome133a",
+                    stream=True,
+                    **proxy_options)
+                logger.info(CONFIG["SERVER"]['COOKIE'],"Server")
+                if response.status_code == 200:
+                    response_status_code = 200
+                    logger.info("请求成功", "Server")
+                    logger.info(f"当前{model}剩余可用令牌数: {token_manager.get_token_count_for_model(model)}","Server")
+
+                    try:
+                        if stream:
+                            return Response(stream_with_context(
+                                handle_stream_response(response, model)),content_type='text/event-stream')
+                        else:
+                            content = handle_non_stream_response(response, model)
+                            return jsonify(
+                                MessageProcessor.create_chat_response(content, model))
+
+                    except Exception as error:
+                        logger.error(str(error), "Server")
+                        if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                            raise ValueError(f"自定义SSO令牌当前模型{model}的请求次数已失效")
+                        token_manager.remove_token_from_model(model, CONFIG["API"]["SIGNATURE_COOKIE"])
+                        if token_manager.get_token_count_for_model(model) == 0:
+                            raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
+                elif response.status_code == 403:
+                    response_status_code = 403
+                    token_manager.reduce_token_request_count(model,1)#重置去除当前因为错误未成功请求的次数，确保不会因为错误未成功请求的次数导致次数上限
+                    if token_manager.get_token_count_for_model(model) == 0:
+                        raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
+                    print("状态码:", response.status_code)
+                    print("响应头:", response.headers)
+                    print("响应内容:", response.text)
+                    raise ValueError(f"IP暂时被封无法破盾，请稍后重试或者更换ip")
+                elif response.status_code == 429:
+                    response_status_code = 429
+                    token_manager.reduce_token_request_count(model,1)
+                    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                        raise ValueError(f"自定义SSO令牌当前模型{model}的请求次数已失效")
+
+                    token_manager.remove_token_from_model(
+                        model, CONFIG["API"]["SIGNATURE_COOKIE"])
+                    if token_manager.get_token_count_for_model(model) == 0:
+                        raise ValueError(f"{model} 次数已达上限，请切换其他模型或者重新对话")
+
+                else:
+                    if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                        raise ValueError(f"自定义SSO令牌当前模型{model}的请求次数已失效")
+
+                    logger.error(f"令牌异常错误状态!status: {response.status_code}","Server")
+                    token_manager.remove_token_from_model(model, CONFIG["API"]["SIGNATURE_COOKIE"])
+                    logger.info(
+                        f"当前{model}剩余可用令牌数: {token_manager.get_token_count_for_model(model)}",
+                        "Server")
+
+            except Exception as e:
+                logger.error(f"请求处理异常: {str(e)}", "Server")
+                if CONFIG["API"]["IS_CUSTOM_SSO"]:
+                    raise
+                continue
+        if response_status_code == 403:
+            raise ValueError('IP暂时被封无法破盾，请稍后重试或者更换ip')
+        elif response_status_code == 500:
+            raise ValueError('当前模型所有令牌暂无可用，请稍后重试')    
+
+    except Exception as error:
+        logger.error(str(error), "ChatAPI")
+        return jsonify(
+            {"error": {
+                "message": str(error),
+                "type": "server_error"
+            }}), response_status_code
+
+@app.route('/', defaults={'path': ''})
+@app.route('/<path:path>')
+def catch_all(path):
+    return 'api运行正常', 200
+
+if __name__ == '__main__':
+    token_manager = AuthTokenManager()
+    initialization()
+
+    app.run(
+        host='0.0.0.0',
+        port=CONFIG["SERVER"]["PORT"],
+        debug=False
+    )

docker-compose.yml

@@ -0,0 +1,18 @@
+version: '3.8'
+services:
+  grok2api_python:
+    image: yxmiler/grok2api_python:latest
+    container_name: grok2api_python
+    ports:
+      - "3000:3000"
+    environment:
+      - API_KEY=your_api_key
+      - TUMY_KEY=你的图床key,和PICGO_KEY 二选一
+      - PICGO_KEY=你的图床key,和TUMY_KEY二选一
+      - IS_TEMP_CONVERSATION=true
+      - IS_CUSTOM_SSO=false
+      - ISSHOW_SEARCH_RESULTS=false
+      - PORT=3000
+      - SHOW_THINKING=true
+      - SSO=your_sso
+    restart: unless-stopped

index.js

@@ -0,0 +1,1319 @@
+import express from 'express';
+import fetch from 'node-fetch';
+import FormData from 'form-data';
+import dotenv from 'dotenv';
+import cors from 'cors';
+import puppeteer from 'puppeteer-extra'
+import StealthPlugin from 'puppeteer-extra-plugin-stealth'
+import { v4 as uuidv4 } from 'uuid';
+import Logger from './logger.js';
+
+dotenv.config();
+
+// 配置常量
+const CONFIG = {
+    MODELS: {
+        'grok-2': 'grok-latest',
+        'grok-2-imageGen': 'grok-latest',
+        'grok-2-search': 'grok-latest',
+        "grok-3": "grok-3",
+        "grok-3-search": "grok-3",
+        "grok-3-imageGen": "grok-3",
+        "grok-3-deepsearch": "grok-3",
+        "grok-3-reasoning": "grok-3"
+    },
+    API: {
+        IS_TEMP_CONVERSATION: process.env.IS_TEMP_CONVERSATION == undefined ? false : process.env.IS_TEMP_CONVERSATION == 'true',
+        IS_TEMP_GROK2: process.env.IS_TEMP_GROK2 == undefined ? true : process.env.IS_TEMP_GROK2 == 'true',
+        GROK2_CONCURRENCY_LEVEL: process.env.GROK2_CONCURRENCY_LEVEL || 4,
+        IS_CUSTOM_SSO: process.env.IS_CUSTOM_SSO == undefined ? false : process.env.IS_CUSTOM_SSO == 'true',
+        BASE_URL: "https://grok.com",
+        API_KEY: process.env.API_KEY || "sk-123456",
+        SIGNATURE_COOKIE: null,
+        TEMP_COOKIE: null,
+        PICGO_KEY: process.env.PICGO_KEY || null, //想要流式生图的话需要填入这个PICGO图床的key
+        TUMY_KEY: process.env.TUMY_KEY || null //想要流式生图的话需要填入这个TUMY图床的key 两个图床二选一，默认使用PICGO
+    },
+    SERVER: {
+        PORT: process.env.PORT || 3000,
+        BODY_LIMIT: '5mb'
+    },
+    RETRY: {
+        MAX_ATTEMPTS: 2//重试次数
+    },
+    SHOW_THINKING: process.env.SHOW_THINKING == undefined ? true : process.env.SHOW_THINKING == 'true',
+    IS_THINKING: false,
+    IS_IMG_GEN: false,
+    IS_IMG_GEN2: false,
+    TEMP_COOKIE_INDEX: 0,//临时cookie的下标
+    ISSHOW_SEARCH_RESULTS: process.env.ISSHOW_SEARCH_RESULTS == undefined ? true : process.env.ISSHOW_SEARCH_RESULTS == 'true',//是否显示搜索结果
+    CHROME_PATH: process.env.CHROME_PATH || null
+};
+puppeteer.use(StealthPlugin())
+
+// 请求头配置
+const DEFAULT_HEADERS = {
+    'accept': '*/*',
+    'accept-language': 'zh-CN,zh;q=0.9',
+    'accept-encoding': 'gzip, deflate, br, zstd',
+    'content-type': 'text/plain;charset=UTF-8',
+    'Connection': 'keep-alive',
+    'origin': 'https://grok.com',
+    'priority': 'u=1, i',
+    'sec-ch-ua': '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+    'sec-ch-ua-mobile': '?0',
+    'sec-ch-ua-platform': '"Windows"',
+    'sec-fetch-dest': 'empty',
+    'sec-fetch-mode': 'cors',
+    'sec-fetch-site': 'same-origin',
+    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
+    'baggage': 'sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c'
+};
+
+
+async function initialization() {
+    if (CONFIG.CHROME_PATH == null) {
+        try {
+            CONFIG.CHROME_PATH = puppeteer.executablePath();
+        } catch (error) {
+            CONFIG.CHROME_PATH = "/usr/bin/chromium";
+        }
+    }
+    Logger.info(`CHROME_PATH: ${CONFIG.CHROME_PATH}`, 'Server');
+    if (CONFIG.API.IS_CUSTOM_SSO) {
+        if (CONFIG.API.IS_TEMP_GROK2) {
+            await tempCookieManager.ensureCookies();
+        }
+        return;
+    }
+    const ssoArray = process.env.SSO.split(',');
+    const concurrencyLimit = 3;
+    for (let i = 0; i < ssoArray.length; i += concurrencyLimit) {
+        const batch = ssoArray.slice(i, i + concurrencyLimit);
+        const batchPromises = batch.map(sso =>
+            tokenManager.addToken(`sso-rw=${sso};sso=${sso}`)
+        );
+
+        await Promise.all(batchPromises);
+        Logger.info(`已加载令牌: ${i} 个`, 'Server');
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    Logger.info(`令牌加载完成: ${JSON.stringify(tokenManager.getAllTokens(), null, 2)}`, 'Server');
+    Logger.info(`共加载: ${tokenManager.getAllTokens().length}个令牌`, 'Server');
+    if (CONFIG.API.IS_TEMP_GROK2) {
+        await tempCookieManager.ensureCookies();
+        CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+    }
+    Logger.info("初始化完成", 'Server');
+}
+
+class AuthTokenManager {
+    constructor() {
+        this.tokenModelMap = {};
+        this.expiredTokens = new Set();
+        this.tokenStatusMap = {};
+
+        // 定义模型请求频率限制和过期时间
+        this.modelConfig = {
+            "grok-2": {
+                RequestFrequency: 30,
+                ExpirationTime: 1 * 60 * 60 * 1000 // 1小时
+            },
+            "grok-3": {
+                RequestFrequency: 20,
+                ExpirationTime: 2 * 60 * 60 * 1000 // 2小时
+            },
+            "grok-3-deepsearch": {
+                RequestFrequency: 10,
+                ExpirationTime: 24 * 60 * 60 * 1000 // 24小时
+            },
+            "grok-3-reasoning": {
+                RequestFrequency: 10,
+                ExpirationTime: 24 * 60 * 60 * 1000 // 24小时
+            }
+        };
+        this.tokenResetSwitch = false;
+        this.tokenResetTimer = null;
+    }
+    async fetchGrokStats(token, modelName) {
+        let requestKind = 'DEFAULT';
+        if (modelName == 'grok-2' || modelName == 'grok-3') {
+            requestKind = 'DEFAULT';
+        } else if (modelName == 'grok-3-deepsearch') {
+            requestKind = 'DEEPSEARCH';
+        } else if (modelName == 'grok-3-reasoning') {
+            requestKind = 'REASONING';
+        }
+        const response = await fetch('https://grok.com/rest/rate-limits', {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'Cookie': token,
+            },
+            body: JSON.stringify({
+                "requestKind": requestKind,
+                "modelName": modelName == 'grok-2' ? 'grok-latest' : "grok-3"
+            })
+        });
+
+        if (response.status != 200) {
+            return 0;
+        }
+        const data = await response.json();
+        return data.remainingQueries;
+    }
+    async addToken(token) {
+        const sso = token.split("sso=")[1].split(";")[0];
+
+        for (const model of Object.keys(this.modelConfig)) {
+            if (!this.tokenModelMap[model]) {
+                this.tokenModelMap[model] = [];
+            }
+            if (!this.tokenStatusMap[sso]) {
+                this.tokenStatusMap[sso] = {};
+            }
+            const existingTokenEntry = this.tokenModelMap[model].find(entry => entry.token === token);
+
+            if (!existingTokenEntry) {
+                try {
+                    const remainingQueries = await this.fetchGrokStats(token, model);
+
+                    const modelRequestFrequency = this.modelConfig[model].RequestFrequency;
+                    const usedRequestCount = modelRequestFrequency - remainingQueries;
+
+                    if (usedRequestCount === modelRequestFrequency) {
+                        this.expiredTokens.add({
+                            token: token,
+                            model: model,
+                            expiredTime: Date.now()
+                        });
+
+                        if (!this.tokenStatusMap[sso][model]) {
+                            this.tokenStatusMap[sso][model] = {
+                                isValid: false,
+                                invalidatedTime: Date.now(),
+                                totalRequestCount: Math.max(0, usedRequestCount)
+                            };
+                        }
+
+                        if (!this.tokenResetSwitch) {
+                            this.startTokenResetProcess();
+                            this.tokenResetSwitch = true;
+                        }
+                    } else {
+                        this.tokenModelMap[model].push({
+                            token: token,
+                            RequestCount: Math.max(0, usedRequestCount),
+                            AddedTime: Date.now(),
+                            StartCallTime: null
+                        });
+
+                        if (!this.tokenStatusMap[sso][model]) {
+                            this.tokenStatusMap[sso][model] = {
+                                isValid: true,
+                                invalidatedTime: null,
+                                totalRequestCount: Math.max(0, usedRequestCount)
+                            };
+                        }
+                    }
+                } catch (error) {
+                    this.tokenModelMap[model].push({
+                        token: token,
+                        RequestCount: 0,
+                        AddedTime: Date.now(),
+                        StartCallTime: null
+                    });
+
+                    if (!this.tokenStatusMap[sso][model]) {
+                        this.tokenStatusMap[sso][model] = {
+                            isValid: true,
+                            invalidatedTime: null,
+                            totalRequestCount: 0
+                        };
+                    }
+
+                    Logger.error(`获取模型 ${model} 的统计信息失败: ${error}`, 'TokenManager');
+                }
+                await Utils.delay(200);
+            }
+        }
+    }
+
+    setToken(token) {
+        const models = Object.keys(this.modelConfig);
+        this.tokenModelMap = models.reduce((map, model) => {
+            map[model] = [{
+                token,
+                RequestCount: 0,
+                AddedTime: Date.now(),
+                StartCallTime: null
+            }];
+            return map;
+        }, {});
+        const sso = token.split("sso=")[1].split(";")[0];
+        this.tokenStatusMap[sso] = models.reduce((statusMap, model) => {
+            statusMap[model] = {
+                isValid: true,
+                invalidatedTime: null,
+                totalRequestCount: 0
+            };
+            return statusMap;
+        }, {});
+    }
+
+    async deleteToken(token) {
+        try {
+            const sso = token.split("sso=")[1].split(";")[0];
+            await Promise.all([
+                new Promise((resolve) => {
+                    this.tokenModelMap = Object.fromEntries(
+                        Object.entries(this.tokenModelMap).map(([model, entries]) => [
+                            model,
+                            entries.filter(entry => entry.token !== token)
+                        ])
+                    );
+                    resolve();
+                }),
+
+                new Promise((resolve) => {
+                    delete this.tokenStatusMap[sso];
+                    resolve();
+                }),
+            ]);
+            Logger.info(`令牌已成功移除: ${token}`, 'TokenManager');
+            return true;
+        } catch (error) {
+            Logger.error('令牌删除失败：', error);
+            return false;
+        }
+    }
+    getNextTokenForModel(modelId) {
+        const normalizedModel = this.normalizeModelName(modelId);
+
+        if (!this.tokenModelMap[normalizedModel] || this.tokenModelMap[normalizedModel].length === 0) {
+            return null;
+        }
+        const tokenEntry = this.tokenModelMap[normalizedModel][0];
+
+        if (tokenEntry) {
+            if (tokenEntry.StartCallTime === null || tokenEntry.StartCallTime === undefined) {
+                tokenEntry.StartCallTime = Date.now();
+            }
+            if (!this.tokenResetSwitch) {
+                this.startTokenResetProcess();
+                this.tokenResetSwitch = true;
+            }
+            tokenEntry.RequestCount++;
+
+            if (tokenEntry.RequestCount > this.modelConfig[normalizedModel].RequestFrequency) {
+                this.removeTokenFromModel(normalizedModel, tokenEntry.token);
+                const nextTokenEntry = this.tokenModelMap[normalizedModel][0];
+                return nextTokenEntry ? nextTokenEntry.token : null;
+            }
+            const sso = tokenEntry.token.split("sso=")[1].split(";")[0];
+            if (this.tokenStatusMap[sso] && this.tokenStatusMap[sso][normalizedModel]) {
+                if (tokenEntry.RequestCount === this.modelConfig[normalizedModel].RequestFrequency) {
+                    this.tokenStatusMap[sso][normalizedModel].isValid = false;
+                    this.tokenStatusMap[sso][normalizedModel].invalidatedTime = Date.now();
+                }
+                this.tokenStatusMap[sso][normalizedModel].totalRequestCount++;
+            }
+            return tokenEntry.token;
+        }
+
+        return null;
+    }
+
+    removeTokenFromModel(modelId, token) {
+        const normalizedModel = this.normalizeModelName(modelId);
+
+        if (!this.tokenModelMap[normalizedModel]) {
+            Logger.error(`模型 ${normalizedModel} 不存在`, 'TokenManager');
+            return false;
+        }
+
+        const modelTokens = this.tokenModelMap[normalizedModel];
+        const tokenIndex = modelTokens.findIndex(entry => entry.token === token);
+
+        if (tokenIndex !== -1) {
+            const removedTokenEntry = modelTokens.splice(tokenIndex, 1)[0];
+            this.expiredTokens.add({
+                token: removedTokenEntry.token,
+                model: normalizedModel,
+                expiredTime: Date.now()
+            });
+
+            if (!this.tokenResetSwitch) {
+                this.startTokenResetProcess();
+                this.tokenResetSwitch = true;
+            }
+            Logger.info(`模型${modelId}的令牌已失效，已成功移除令牌: ${token}`, 'TokenManager');
+            return true;
+        }
+
+        Logger.error(`在模型 ${normalizedModel} 中未找到 token: ${token}`, 'TokenManager');
+        return false;
+    }
+
+    getExpiredTokens() {
+        return Array.from(this.expiredTokens);
+    }
+
+    normalizeModelName(model) {
+        if (model.startsWith('grok-') && !model.includes('deepsearch') && !model.includes('reasoning')) {
+            return model.split('-').slice(0, 2).join('-');
+        }
+        return model;
+    }
+
+    getTokenCountForModel(modelId) {
+        const normalizedModel = this.normalizeModelName(modelId);
+        return this.tokenModelMap[normalizedModel]?.length || 0;
+    }
+
+    getRemainingTokenRequestCapacity() {
+        const remainingCapacityMap = {};
+
+        Object.keys(this.modelConfig).forEach(model => {
+            const modelTokens = this.tokenModelMap[model] || [];
+
+            const modelRequestFrequency = this.modelConfig[model].RequestFrequency;
+
+            const totalUsedRequests = modelTokens.reduce((sum, tokenEntry) => {
+                return sum + (tokenEntry.RequestCount || 0);
+            }, 0);
+
+            // 计算剩余可用请求数量
+            const remainingCapacity = (modelTokens.length * modelRequestFrequency) - totalUsedRequests;
+            remainingCapacityMap[model] = Math.max(0, remainingCapacity);
+        });
+
+        return remainingCapacityMap;
+    }
+
+    getTokenArrayForModel(modelId) {
+        const normalizedModel = this.normalizeModelName(modelId);
+        return this.tokenModelMap[normalizedModel] || [];
+    }
+
+    startTokenResetProcess() {
+        if (this.tokenResetTimer) {
+            clearInterval(this.tokenResetTimer);
+        }
+
+        this.tokenResetTimer = setInterval(() => {
+            const now = Date.now();
+
+            this.expiredTokens.forEach(expiredTokenInfo => {
+                const { token, model, expiredTime } = expiredTokenInfo;
+                const expirationTime = this.modelConfig[model].ExpirationTime;
+                if (now - expiredTime >= expirationTime) {
+                    if (!this.tokenModelMap[model].some(entry => entry.token === token)) {
+                        this.tokenModelMap[model].push({
+                            token: token,
+                            RequestCount: 0,
+                            AddedTime: now,
+                            StartCallTime: null
+                        });
+                    }
+                    const sso = token.split("sso=")[1].split(";")[0];
+
+                    if (this.tokenStatusMap[sso] && this.tokenStatusMap[sso][model]) {
+                        this.tokenStatusMap[sso][model].isValid = true;
+                        this.tokenStatusMap[sso][model].invalidatedTime = null;
+                        this.tokenStatusMap[sso][model].totalRequestCount = 0;
+                    }
+
+                    this.expiredTokens.delete(expiredTokenInfo);
+                }
+            });
+
+            Object.keys(this.modelConfig).forEach(model => {
+                if (!this.tokenModelMap[model]) return;
+    
+                const processedTokens = this.tokenModelMap[model].map(tokenEntry => {
+                    if (!tokenEntry.StartCallTime) return tokenEntry;
+    
+                    const expirationTime = this.modelConfig[model].ExpirationTime;
+                    if (now - tokenEntry.StartCallTime >= expirationTime) {
+                        const sso = tokenEntry.token.split("sso=")[1].split(";")[0];
+                        if (this.tokenStatusMap[sso] && this.tokenStatusMap[sso][model]) {
+                            this.tokenStatusMap[sso][model].isValid = true;
+                            this.tokenStatusMap[sso][model].invalidatedTime = null;
+                            this.tokenStatusMap[sso][model].totalRequestCount = 0;
+                        }
+                        
+                        return {
+                            ...tokenEntry,
+                            RequestCount: 0,
+                            StartCallTime: null
+                        };
+                    }
+                    
+                    return tokenEntry;
+                });
+    
+                this.tokenModelMap[model] = processedTokens;
+            });
+        }, 1 * 60 * 60 * 1000); 
+    }
+
+    getAllTokens() {
+        const allTokens = new Set();
+        Object.values(this.tokenModelMap).forEach(modelTokens => {
+            modelTokens.forEach(entry => allTokens.add(entry.token));
+        });
+        return Array.from(allTokens);
+    }
+
+    getTokenStatusMap() {
+        return this.tokenStatusMap;
+    }
+}
+
+
+class Utils {
+    static delay(time) {
+        return new Promise(function (resolve) {
+            setTimeout(resolve, time)
+        });
+    }
+    static async organizeSearchResults(searchResults) {
+        // 确保传入的是有效的搜索结果对象
+        if (!searchResults || !searchResults.results) {
+            return '';
+        }
+
+        const results = searchResults.results;
+        const formattedResults = results.map((result, index) => {
+            // 处理可能为空的字段
+            const title = result.title || '未知标题';
+            const url = result.url || '#';
+            const preview = result.preview || '无预览内容';
+
+            return `\r\n<details><summary>资料[${index}]: ${title}</summary>\r\n${preview}\r\n\n[Link](${url})\r\n</details>`;
+        });
+        return formattedResults.join('\n\n');
+    }
+    static async createAuthHeaders(model) {
+        return await tokenManager.getNextTokenForModel(model);
+    }
+}
+class GrokTempCookieManager {
+    constructor() {
+        this.cookies = [];
+        this.currentIndex = 0;
+        this.isRefreshing = false;
+        this.initialCookieCount = CONFIG.API.GROK2_CONCURRENCY_LEVEL;
+        this.extractCount = 0;
+    }
+
+    async ensureCookies() {
+        // 如果 cookies 数量不足，则重新获取
+        if (this.cookies.length < this.initialCookieCount) {
+            await this.refreshCookies();
+        }
+    }
+    async extractGrokHeaders(browser) {
+        Logger.info("开始提取头信息", 'Server');
+        try {
+            const page = await browser.newPage();
+            await page.goto('https://grok.com/', { waitUntil: 'domcontentloaded' });
+            let waitTime = 0;
+            const targetHeaders = ['x-anonuserid', 'x-challenge', 'x-signature'];
+
+            while (true) {
+                const cookies = await page.cookies();
+                const extractedHeaders = cookies
+                    .filter(cookie => targetHeaders.includes(cookie.name.toLowerCase()))
+                    .map(cookie => `${cookie.name}=${cookie.value}`);
+
+                if (targetHeaders.every(header =>
+                    extractedHeaders.some(cookie => cookie && cookie.startsWith(header + '='))
+                )) {
+                    await browser.close();
+                    Logger.info('提取的头信息:', JSON.stringify(extractedHeaders, null, 2), 'Server');
+                    this.cookies.push(extractedHeaders.join(';'));
+                    this.extractCount++;
+                    return true;
+                }
+
+                await Utils.delay(500);
+                waitTime += 500;
+                if (waitTime >= 10000) {
+                    await browser.close();
+                    return null;
+                }
+            }
+        } catch (error) {
+            Logger.error('获取头信息出错:', error, 'Server');
+            return null;
+        }
+    }
+    async initializeTempCookies(count = 1) {
+        Logger.info(`开始初始化 ${count} 个临时账号认证信息`, 'Server');
+        const browserOptions = {
+            headless: true,
+            args: [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-gpu'
+            ],
+            executablePath: CONFIG.CHROME_PATH
+        };
+
+        const browsers = await Promise.all(
+            Array.from({ length: count }, () => puppeteer.launch(browserOptions))
+        );
+
+        const cookiePromises = browsers.map(browser => this.extractGrokHeaders(browser));
+        return Promise.all(cookiePromises);
+    }
+    async refreshCookies() {
+        if (this.isRefreshing) return;
+        this.isRefreshing = true;
+        this.extractCount = 0;
+        try {
+            // 获取新的 cookies
+            let retryCount = 0;
+            let remainingCount = this.initialCookieCount - this.cookies.length;
+
+            while (retryCount < CONFIG.RETRY.MAX_ATTEMPTS) {
+                await this.initializeTempCookies(remainingCount);
+                if (this.extractCount != remainingCount) {
+                    if (this.extractCount == 0) {
+                        Logger.error(`无法获取足够的有效 TempCookies，可能网络存在问题，当前数量：${this.cookies.length}`);
+                    } else if (this.extractCount < remainingCount) {
+                        remainingCount -= this.extractCount;
+                        this.extractCount = 0;
+                        retryCount++;
+                        await Utils.delay(1000 * retryCount);
+                    } else {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+            if (this.currentIndex >= this.cookies.length) {
+                this.currentIndex = 0;
+            }
+
+            if (this.cookies.length < this.initialCookieCount) {
+                if (this.cookies.length !== 0) {
+                    // 如果已经获取到一些 TempCookies，则只提示警告错误
+                    Logger.error(`无法获取足够的有效 TempCookies，可能网络存在问题，当前数量：${this.cookies.length}`);
+                } else {
+                    // 如果未获取到任何 TempCookies，则抛出错误
+                    throw new Error(`无法获取足够的有效 TempCookies，可能网络存在问题，当前数量：${this.cookies.length}`);
+                }
+            }
+        } catch (error) {
+            Logger.error('刷新 cookies 失败:', error);
+        } finally {
+            Logger.info(`已提取${this.cookies.length}个TempCookies`, 'Server');
+            Logger.info(`提取的TempCookies为${JSON.stringify(this.cookies, null, 2)}`, 'Server');
+            this.isRefreshing = false;
+        }
+    }
+}
+
+class GrokApiClient {
+    constructor(modelId) {
+        if (!CONFIG.MODELS[modelId]) {
+            throw new Error(`不支持的模型: ${modelId}`);
+        }
+        this.modelId = CONFIG.MODELS[modelId];
+    }
+
+    processMessageContent(content) {
+        if (typeof content === 'string') return content;
+        return null;
+    }
+    // 获取图片类型
+    getImageType(base64String) {
+        let mimeType = 'image/jpeg';
+        if (base64String.includes('data:image')) {
+            const matches = base64String.match(/data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+);base64,/);
+            if (matches) {
+                mimeType = matches[1];
+            }
+        }
+        const extension = mimeType.split('/')[1];
+        const fileName = `image.${extension}`;
+
+        return {
+            mimeType: mimeType,
+            fileName: fileName
+        };
+    }
+
+    async uploadBase64Image(base64Data, url) {
+        try {
+            // 处理 base64 数据
+            let imageBuffer;
+            if (base64Data.includes('data:image')) {
+                imageBuffer = base64Data.split(',')[1];
+            } else {
+                imageBuffer = base64Data
+            }
+            const { mimeType, fileName } = this.getImageType(base64Data);
+            let uploadData = {
+                rpc: "uploadFile",
+                req: {
+                    fileName: fileName,
+                    fileMimeType: mimeType,
+                    content: imageBuffer
+                }
+            };
+            Logger.info("发送图片请求", 'Server');
+            // 发送请求
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    ...CONFIG.DEFAULT_HEADERS,
+                    "cookie": CONFIG.API.SIGNATURE_COOKIE
+                },
+                body: JSON.stringify(uploadData)
+            });
+
+            if (!response.ok) {
+                Logger.error(`上传图片失败,状态码:${response.status},原因:${response.error}`, 'Server');
+                return '';
+            }
+
+            const result = await response.json();
+            Logger.info('上传图片成功:', result, 'Server');
+            return result.fileMetadataId;
+
+        } catch (error) {
+            Logger.error(error, 'Server');
+            return '';
+        }
+    }
+
+    async prepareChatRequest(request) {
+        if ((request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen') && !CONFIG.API.PICGO_KEY && !CONFIG.API.TUMY_KEY && request.stream) {
+            throw new Error(`该模型流式输出需要配置PICGO或者TUMY图床密钥!`);
+        }
+
+        // 处理画图模型的消息限制
+        let todoMessages = request.messages;
+        if (request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen') {
+            const lastMessage = todoMessages[todoMessages.length - 1];
+            if (lastMessage.role !== 'user') {
+                throw new Error('画图模型的最后一条消息必须是用户消息!');
+            }
+            todoMessages = [lastMessage];
+        }
+
+        const fileAttachments = [];
+        let messages = '';
+        let lastRole = null;
+        let lastContent = '';
+        const search = request.model === 'grok-2-search' || request.model === 'grok-3-search';
+
+        // 移除<think>标签及其内容和base64图片
+        const removeThinkTags = (text) => {
+            text = text.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            text = text.replace(/!\[image\]\(data:.*?base64,.*?\)/g, '[图片]');
+            return text;
+        };
+
+        const processImageUrl = async (content) => {
+            if (content.type === 'image_url' && content.image_url.url.includes('data:image')) {
+                const imageResponse = await this.uploadBase64Image(
+                    content.image_url.url,
+                    `${CONFIG.API.BASE_URL}/api/rpc`
+                );
+                return imageResponse;
+            }
+            return null;
+        };
+
+        const processContent = async (content) => {
+            if (Array.isArray(content)) {
+                let textContent = '';
+                for (const item of content) {
+                    if (item.type === 'image_url') {
+                        textContent += (textContent ? '\n' : '') + "[图片]";
+                    } else if (item.type === 'text') {
+                        textContent += (textContent ? '\n' : '') + removeThinkTags(item.text);
+                    }
+                }
+                return textContent;
+            } else if (typeof content === 'object' && content !== null) {
+                if (content.type === 'image_url') {
+                    return "[图片]";
+                } else if (content.type === 'text') {
+                    return removeThinkTags(content.text);
+                }
+            }
+            return removeThinkTags(this.processMessageContent(content));
+        };
+
+        for (const current of todoMessages) {
+            const role = current.role === 'assistant' ? 'assistant' : 'user';
+            const isLastMessage = current === todoMessages[todoMessages.length - 1];
+
+            // 处理图片附件
+            if (isLastMessage && current.content) {
+                if (Array.isArray(current.content)) {
+                    for (const item of current.content) {
+                        if (item.type === 'image_url') {
+                            const processedImage = await processImageUrl(item);
+                            if (processedImage) fileAttachments.push(processedImage);
+                        }
+                    }
+                } else if (current.content.type === 'image_url') {
+                    const processedImage = await processImageUrl(current.content);
+                    if (processedImage) fileAttachments.push(processedImage);
+                }
+            }
+
+            // 处理文本内容
+            const textContent = await processContent(current.content);
+
+            if (textContent || (isLastMessage && fileAttachments.length > 0)) {
+                if (role === lastRole && textContent) {
+                    lastContent += '\n' + textContent;
+                    messages = messages.substring(0, messages.lastIndexOf(`${role.toUpperCase()}: `)) +
+                        `${role.toUpperCase()}: ${lastContent}\n`;
+                } else {
+                    messages += `${role.toUpperCase()}: ${textContent || '[图片]'}\n`;
+                    lastContent = textContent;
+                    lastRole = role;
+                }
+            }
+        }
+
+        return {
+            temporary: CONFIG.API.IS_TEMP_CONVERSATION,
+            modelName: this.modelId,
+            message: messages.trim(),
+            fileAttachments: fileAttachments.slice(0, 4),
+            imageAttachments: [],
+            disableSearch: false,
+            enableImageGeneration: true,
+            returnImageBytes: false,
+            returnRawGrokInXaiRequest: false,
+            enableImageStreaming: false,
+            imageGenerationCount: 1,
+            forceConcise: false,
+            toolOverrides: {
+                imageGen: request.model === 'grok-2-imageGen' || request.model === 'grok-3-imageGen',
+                webSearch: search,
+                xSearch: search,
+                xMediaSearch: search,
+                trendsSearch: search,
+                xPostAnalyze: search
+            },
+            enableSideBySide: true,
+            isPreset: false,
+            sendFinalMetadata: true,
+            customInstructions: "",
+            deepsearchPreset: request.model === 'grok-3-deepsearch' ? "default" : "",
+            isReasoning: request.model === 'grok-3-reasoning'
+        };
+    }
+}
+
+class MessageProcessor {
+    static createChatResponse(message, model, isStream = false) {
+        const baseResponse = {
+            id: `chatcmpl-${uuidv4()}`,
+            created: Math.floor(Date.now() / 1000),
+            model: model
+        };
+
+        if (isStream) {
+            return {
+                ...baseResponse,
+                object: 'chat.completion.chunk',
+                choices: [{
+                    index: 0,
+                    delta: {
+                        content: message
+                    }
+                }]
+            };
+        }
+
+        return {
+            ...baseResponse,
+            object: 'chat.completion',
+            choices: [{
+                index: 0,
+                message: {
+                    role: 'assistant',
+                    content: message
+                },
+                finish_reason: 'stop'
+            }],
+            usage: null
+        };
+    }
+}
+async function processModelResponse(response, model) {
+    let result = { token: null, imageUrl: null }
+    if (CONFIG.IS_IMG_GEN) {
+        if (response?.cachedImageGenerationResponse && !CONFIG.IS_IMG_GEN2) {
+            result.imageUrl = response.cachedImageGenerationResponse.imageUrl;
+        }
+        return result;
+    }
+
+    //非生图模型的处理
+    switch (model) {
+        case 'grok-2':
+            result.token = response?.token;
+            return result;
+        case 'grok-2-search':
+        case 'grok-3-search':
+            if (response?.webSearchResults && CONFIG.ISSHOW_SEARCH_RESULTS) {
+                result.token = `\r\n<think>${await Utils.organizeSearchResults(response.webSearchResults)}</think>\r\n`;
+            } else {
+                result.token = response?.token;
+            }
+            return result;
+        case 'grok-3':
+            result.token = response?.token;
+            return result;
+        case 'grok-3-deepsearch':
+            if (response?.messageTag === "final") {
+                result.token = response?.token;
+            }
+            return result;
+        case 'grok-3-reasoning':
+            if (response?.isThinking && !CONFIG.SHOW_THINKING) return result;
+
+            if (response?.isThinking && !CONFIG.IS_THINKING) {
+                result.token = "<think>" + response?.token;
+                CONFIG.IS_THINKING = true;
+            } else if (!response.isThinking && CONFIG.IS_THINKING) {
+                result.token = "</think>" + response?.token;
+                CONFIG.IS_THINKING = false;
+            } else {
+                result.token = response?.token;
+            }
+            return result;
+    }
+    return result;
+}
+
+async function handleResponse(response, model, res, isStream) {
+    try {
+        const stream = response.body;
+        let buffer = '';
+        let fullResponse = '';
+        const dataPromises = [];
+        if (isStream) {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+        }
+        CONFIG.IS_THINKING = false;
+        CONFIG.IS_IMG_GEN = false;
+        CONFIG.IS_IMG_GEN2 = false;
+        Logger.info("开始处理流式响应", 'Server');
+
+        return new Promise((resolve, reject) => {
+            stream.on('data', async (chunk) => {
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+
+                for (const line of lines) {
+                    if (!line.trim()) continue;
+                    try {
+                        const linejosn = JSON.parse(line.trim());
+                        if (linejosn?.error) {
+                            Logger.error(JSON.stringify(linejosn, null, 2), 'Server');
+                            if (linejosn.error?.name === "RateLimitError") {
+                                CONFIG.API.TEMP_COOKIE = null;
+                            }
+                            stream.destroy();
+                            reject(new Error("RateLimitError"));
+                            return;
+                        }
+                        let response = linejosn?.result?.response;
+                        if (!response) continue;
+                        if (response?.doImgGen || response?.imageAttachmentInfo) {
+                            CONFIG.IS_IMG_GEN = true;
+                        }
+                        const processPromise = (async () => {
+                            const result = await processModelResponse(response, model);
+
+                            if (result.token) {
+                                if (isStream) {
+                                    res.write(`data: ${JSON.stringify(MessageProcessor.createChatResponse(result.token, model, true))}\n\n`);
+                                } else {
+                                    fullResponse += result.token;
+                                }
+                            }
+                            if (result.imageUrl) {
+                                CONFIG.IS_IMG_GEN2 = true;
+                                const dataImage = await handleImageResponse(result.imageUrl);
+                                if (isStream) {
+                                    res.write(`data: ${JSON.stringify(MessageProcessor.createChatResponse(dataImage, model, true))}\n\n`);
+                                } else {
+                                    res.json(MessageProcessor.createChatResponse(dataImage, model));
+                                }
+                            }
+                        })();
+                        dataPromises.push(processPromise);
+                    } catch (error) {
+                        Logger.error(error, 'Server');
+                        continue;
+                    }
+                }
+            });
+
+            stream.on('end', async () => {
+                try {
+                    await Promise.all(dataPromises);
+                    if (isStream) {
+                        res.write('data: [DONE]\n\n');
+                        res.end();
+                    } else {
+                        if (!CONFIG.IS_IMG_GEN2) {
+                            res.json(MessageProcessor.createChatResponse(fullResponse, model));
+                        }
+                    }
+                    resolve();
+                } catch (error) {
+                    Logger.error(error, 'Server');
+                    reject(error);
+                }
+            });
+
+            stream.on('error', (error) => {
+                Logger.error(error, 'Server');
+                reject(error);
+            });
+        });
+    } catch (error) {
+        Logger.error(error, 'Server');
+        throw new Error(error);
+    }
+}
+
+async function handleImageResponse(imageUrl) {
+    const MAX_RETRIES = 2;
+    let retryCount = 0;
+    let imageBase64Response;
+
+    while (retryCount < MAX_RETRIES) {
+        try {
+            imageBase64Response = await fetch(`https://assets.grok.com/${imageUrl}`, {
+                method: 'GET',
+                headers: {
+                    ...DEFAULT_HEADERS,
+                    "cookie": CONFIG.API.SIGNATURE_COOKIE
+                }
+            });
+
+            if (imageBase64Response.ok) break;
+            retryCount++;
+            if (retryCount === MAX_RETRIES) {
+                throw new Error(`上游服务请求失败! status: ${imageBase64Response.status}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, CONFIG.API.RETRY_TIME * retryCount));
+
+        } catch (error) {
+            Logger.error(error, 'Server');
+            retryCount++;
+            if (retryCount === MAX_RETRIES) {
+                throw error;
+            }
+            await new Promise(resolve => setTimeout(resolve, CONFIG.API.RETRY_TIME * retryCount));
+        }
+    }
+
+
+    const arrayBuffer = await imageBase64Response.arrayBuffer();
+    const imageBuffer = Buffer.from(arrayBuffer);
+
+    if (!CONFIG.API.PICGO_KEY && !CONFIG.API.TUMY_KEY) {
+        const base64Image = imageBuffer.toString('base64');
+        const imageContentType = imageBase64Response.headers.get('content-type');
+        return `![image](data:${imageContentType};base64,${base64Image})`
+    }
+
+    Logger.info("开始上传图床", 'Server');
+    const formData = new FormData();
+    if (CONFIG.API.PICGO_KEY) {
+        formData.append('source', imageBuffer, {
+            filename: `image-${Date.now()}.jpg`,
+            contentType: 'image/jpeg'
+        });
+        const formDataHeaders = formData.getHeaders();
+        const responseURL = await fetch("https://www.picgo.net/api/1/upload", {
+            method: "POST",
+            headers: {
+                ...formDataHeaders,
+                "Content-Type": "multipart/form-data",
+                "X-API-Key": CONFIG.API.PICGO_KEY
+            },
+            body: formData
+        });
+        if (!responseURL.ok) {
+            return "生图失败，请查看PICGO图床密钥是否设置正确"
+        } else {
+            Logger.info("生图成功", 'Server');
+            const result = await responseURL.json();
+            return `![image](${result.image.url})`
+        }
+    } else if (CONFIG.API.TUMY_KEY) {
+        const formData = new FormData();
+        formData.append('file', imageBuffer, {
+            filename: `image-${Date.now()}.jpg`,
+            contentType: 'image/jpeg'
+        });
+        const formDataHeaders = formData.getHeaders();
+        const responseURL = await fetch("https://tu.my/api/v1/upload", {
+            method: "POST",
+            headers: {
+                ...formDataHeaders,
+                "Accept": "application/json",
+                'Authorization': `Bearer ${CONFIG.API.TUMY_KEY}`
+            },
+            body: formData
+        });
+        if (!responseURL.ok) {
+            return "生图失败，请查看TUMY图床密钥是否设置正确"
+        } else {
+            try {
+                const result = await responseURL.json();
+                Logger.info("生图成功", 'Server');
+                return `![image](${result.data.links.url})`
+            } catch (error) {
+                Logger.error(error, 'Server');
+                return "生图失败，请查看TUMY图床密钥是否设置正确"
+            }
+        }
+    }
+}
+
+const tokenManager = new AuthTokenManager();
+const tempCookieManager = new GrokTempCookieManager();
+await initialization();
+
+// 中间件配置
+const app = express();
+app.use(Logger.requestLogger);
+app.use(express.json({ limit: CONFIG.SERVER.BODY_LIMIT }));
+app.use(express.urlencoded({ extended: true, limit: CONFIG.SERVER.BODY_LIMIT }));
+app.use(cors({
+    origin: '*',
+    methods: ['GET', 'POST', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization']
+}));
+
+
+app.get('/get/tokens', (req, res) => {
+    const authToken = req.headers.authorization?.replace('Bearer ', '');
+    if (CONFIG.API.IS_CUSTOM_SSO) {
+        return res.status(403).json({ error: '自定义的SSO令牌模式无法获取轮询sso令牌状态' });
+    } else if (authToken !== CONFIG.API.API_KEY) {
+        return res.status(401).json({ error: 'Unauthorized' });
+    }
+    res.json(tokenManager.getTokenStatusMap());
+});
+app.post('/add/token', async (req, res) => {
+    const authToken = req.headers.authorization?.replace('Bearer ', '');
+    if (CONFIG.API.IS_CUSTOM_SSO) {
+        return res.status(403).json({ error: '自定义的SSO令牌模式无法添加sso令牌' });
+    } else if (authToken !== CONFIG.API.API_KEY) {
+        return res.status(401).json({ error: 'Unauthorized' });
+    }
+    try {
+        const sso = req.body.sso;
+        await tokenManager.addToken(`sso-rw=${sso};sso=${sso}`);
+        res.status(200).json(tokenManager.getTokenStatusMap()[sso]);
+    } catch (error) {
+        Logger.error(error, 'Server');
+        res.status(500).json({ error: '添加sso令牌失败' });
+    }
+});
+app.post('/delete/token', async (req, res) => {
+    const authToken = req.headers.authorization?.replace('Bearer ', '');
+    if (CONFIG.API.IS_CUSTOM_SSO) {
+        return res.status(403).json({ error: '自定义的SSO令牌模式无法删除sso令牌' });
+    } else if (authToken !== CONFIG.API.API_KEY) {
+        return res.status(401).json({ error: 'Unauthorized' });
+    }
+    try {
+        const sso = req.body.sso;
+        await tokenManager.deleteToken(`sso-rw=${sso};sso=${sso}`);
+        res.status(200).json({ message: '删除sso令牌成功' });
+    } catch (error) {
+        Logger.error(error, 'Server');
+        res.status(500).json({ error: '删除sso令牌失败' });
+    }
+});
+
+app.get('/v1/models', (req, res) => {
+    res.json({
+        object: "list",
+        data: Object.keys(tokenManager.tokenModelMap).map((model, index) => ({
+            id: model,
+            object: "model",
+            created: Math.floor(Date.now() / 1000),
+            owned_by: "grok",
+        }))
+    });
+});
+
+
+app.post('/v1/chat/completions', async (req, res) => {
+    try {
+        const authToken = req.headers.authorization?.replace('Bearer ', '');
+        if (CONFIG.API.IS_CUSTOM_SSO) {
+            if (authToken) {
+                const result = `sso=${authToken};ssp_rw=${authToken}`;
+                tokenManager.setToken(result);
+            } else {
+                return res.status(401).json({ error: '自定义的SSO令牌缺失' });
+            }
+        } else if (authToken !== CONFIG.API.API_KEY) {
+            return res.status(401).json({ error: 'Unauthorized' });
+        }
+        const { model, stream } = req.body;
+        let isTempCookie = model.includes("grok-2") && CONFIG.API.IS_TEMP_GROK2;
+        let retryCount = 0;
+        const grokClient = new GrokApiClient(model);
+        const requestPayload = await grokClient.prepareChatRequest(req.body);
+        //Logger.info(`请求体: ${JSON.stringify(requestPayload, null, 2)}`, 'Server');
+
+        while (retryCount < CONFIG.RETRY.MAX_ATTEMPTS) {
+            retryCount++;
+            if (isTempCookie) {
+                CONFIG.API.SIGNATURE_COOKIE = CONFIG.API.TEMP_COOKIE;
+                Logger.info(`已切换为临时令牌`, 'Server');
+            } else {
+                CONFIG.API.SIGNATURE_COOKIE = await Utils.createAuthHeaders(model);
+            }
+            if (!CONFIG.API.SIGNATURE_COOKIE) {
+                throw new Error('该模型无可用令牌');
+            }
+            Logger.info(`当前令牌: ${JSON.stringify(CONFIG.API.SIGNATURE_COOKIE, null, 2)}`, 'Server');
+            Logger.info(`当前可用模型的全部可用数量: ${JSON.stringify(tokenManager.getRemainingTokenRequestCapacity(), null, 2)}`, 'Server');
+            const response = await fetch(`${CONFIG.API.BASE_URL}/rest/app-chat/conversations/new`, {
+                method: 'POST',
+                headers: {
+                    "accept": "text/event-stream",
+                    "baggage": "sentry-public_key=b311e0f2690c81f25e2c4cf6d4f7ce1c",
+                    "content-type": "text/plain;charset=UTF-8",
+                    "Connection": "keep-alive",
+                    "cookie": CONFIG.API.SIGNATURE_COOKIE
+                },
+                body: JSON.stringify(requestPayload)
+            });
+
+            if (response.ok) {
+                Logger.info(`请求成功`, 'Server');
+                Logger.info(`当前${model}剩余可用令牌数: ${tokenManager.getTokenCountForModel(model)}`, 'Server');
+                try {
+                    await handleResponse(response, model, res, stream);
+                    Logger.info(`请求结束`, 'Server');
+                    return;
+                } catch (error) {
+                    Logger.error(error, 'Server');
+                    if (isTempCookie) {
+                        tempCookieManager.cookies.splice(tempCookieManager.currentIndex, 1);
+                        if (tempCookieManager.cookies.length != 0) {
+                            tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                            CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            tempCookieManager.ensureCookies()
+                        } else {
+                            try {
+                                await tempCookieManager.ensureCookies();
+                                tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                                CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            } catch (error) {
+                                throw error;
+                            }
+                        }
+                    } else {
+                        if (CONFIG.API.IS_CUSTOM_SSO) throw new Error(`自定义SSO令牌当前模型${model}的请求次数已失效`);
+                        tokenManager.removeTokenFromModel(model, CONFIG.API.SIGNATURE_COOKIE.cookie);
+                        if (tokenManager.getTokenCountForModel(model) === 0) {
+                            throw new Error(`${model} 次数已达上限，请切换其他模型或者重新对话`);
+                        }
+                    }
+                }
+            } else {
+                if (response.status === 429) {
+                    if (isTempCookie) {
+                        // 移除当前失效的 cookie
+                        tempCookieManager.cookies.splice(tempCookieManager.currentIndex, 1);
+                        if (tempCookieManager.cookies.length != 0) {
+                            tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                            CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            tempCookieManager.ensureCookies()
+                        } else {
+                            try {
+                                await tempCookieManager.ensureCookies();
+                                tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                                CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            } catch (error) {
+                                throw error;
+                            }
+                        }
+                    } else {
+                        if (CONFIG.API.IS_CUSTOM_SSO) throw new Error(`自定义SSO令牌当前模型${model}的请求次数已失效`);
+                        tokenManager.removeTokenFromModel(model, CONFIG.API.SIGNATURE_COOKIE.cookie);
+                        if (tokenManager.getTokenCountForModel(model) === 0) {
+                            throw new Error(`${model} 次数已达上限，请切换其他模型或者重新对话`);
+                        }
+                    }
+                } else {
+                    // 非429错误直接抛出
+                    if (isTempCookie) {
+                        // 移除当前失效的 cookie
+                        tempCookieManager.cookies.splice(tempCookieManager.currentIndex, 1);
+                        if (tempCookieManager.cookies.length != 0) {
+                            tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                            CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            tempCookieManager.ensureCookies()
+                        } else {
+                            try {
+                                await tempCookieManager.ensureCookies();
+                                tempCookieManager.currentIndex = tempCookieManager.currentIndex % tempCookieManager.cookies.length;
+                                CONFIG.API.TEMP_COOKIE = tempCookieManager.cookies[tempCookieManager.currentIndex];
+                            } catch (error) {
+                                throw error;
+                            }
+                        }
+                    } else {
+                        if (CONFIG.API.IS_CUSTOM_SSO) throw new Error(`自定义SSO令牌当前模型${model}的请求次数已失效`);
+                        Logger.error(`令牌异常错误状态!status: ${response.status}`, 'Server');
+                        tokenManager.removeTokenFromModel(model, CONFIG.API.SIGNATURE_COOKIE.cookie);
+                        Logger.info(`当前${model}剩余可用令牌数: ${tokenManager.getTokenCountForModel(model)}`, 'Server');
+                    }
+                }
+            }
+        }
+        throw new Error('当前模型所有令牌都已耗尽');
+    } catch (error) {
+        Logger.error(error, 'ChatAPI');
+        res.status(500).json({
+            error: {
+                message: error.message || error,
+                type: 'server_error'
+            }
+        });
+    }
+});
+
+
+app.use((req, res) => {
+    res.status(200).send('api运行正常');
+});
+
+
+app.listen(CONFIG.SERVER.PORT, () => {
+    Logger.info(`服务器已启动，监听端口: ${CONFIG.SERVER.PORT}`, 'Server');
+});

logger.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import moment from 'moment';
+
+const LogLevel = {
+INFO: 'INFO',
+WARN: 'WARN',
+ERROR: 'ERROR',
+DEBUG: 'DEBUG'
+};
+
+class Logger {
+static formatMessage(level, message) {
+  const timestamp = moment().format('YYYY-MM-DD HH:mm:ss');
+  
+  switch(level) {
+    case LogLevel.INFO:
+      return chalk.blue(`[${timestamp}] [${level}] ${message}`);
+    case LogLevel.WARN:
+      return chalk.yellow(`[${timestamp}] [${level}] ${message}`);
+    case LogLevel.ERROR:
+      return chalk.red(`[${timestamp}] [${level}] ${message}`);
+    case LogLevel.DEBUG:
+      return chalk.gray(`[${timestamp}] [${level}] ${message}`);
+    default:
+      return message;
+  }
+}
+
+static info(message, context) {
+  console.log(this.formatMessage(LogLevel.INFO, context ? `[${context}] ${message}` : message));
+}
+
+static warn(message, context) {
+  console.warn(this.formatMessage(LogLevel.WARN, context ? `[${context}] ${message}` : message));
+}
+
+static error(message, context, error = null) {
+  const errorMessage = error ? ` - ${error.message}` : '';
+  console.error(this.formatMessage(LogLevel.ERROR, `${context ? `[${context}] ` : ''}${message}${errorMessage}`));
+}
+
+static debug(message, context) {
+  if (process.env.NODE_ENV === 'development') {
+    console.debug(this.formatMessage(LogLevel.DEBUG, context ? `[${context}] ${message}` : message));
+  }
+}
+
+static requestLogger(req, res, next) {
+  const startTime = Date.now();
+  
+  res.on('finish', () => {
+    const duration = Date.now() - startTime;
+    const logMessage = `${req.method} ${req.path} - ${res.statusCode} (${duration}ms)`;
+    
+    if (res.statusCode >= 400) {
+      Logger.error(logMessage, undefined, 'HTTP');
+    } else {
+      Logger.info(logMessage, 'HTTP');
+    }
+  });
+
+  next();
+}
+}
+
+export default Logger;

package.json

@@ -0,0 +1,23 @@
+{
+  "name": "grok2api",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "author": "yxmiler",
+  "dependencies": {
+    "express": "^4.18.2",
+    "node-fetch": "^3.3.2",
+    "dotenv": "^16.3.1",
+    "cors": "^2.8.5",
+    "form-data": "^4.0.0",
+    "puppeteer": "^22.8.2",
+    "puppeteer-extra": "^3.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "moment": "^2.30.1",
+    "chalk": "^5.4.1",
+    "uuid": "^9.0.0"
+  }
+}

start.bat

@@ -0,0 +1,73 @@
+@chcp 65001 >nul
+@echo off
+setlocal enabledelayedexpansion
+
+set "PYTHONIOENCODING=utf-8"
+
+set "GREEN=[92m"
+set "RED=[91m"
+set "YELLOW=[93m"
+set "RESET=[0m"
+
+set "VENV_NAME=myenv"
+
+:check_and_create_env
+if not exist ".env" (
+  echo %YELLOW%未找到 .env 文件，正在自动创建...%RESET%
+  
+  (
+      echo # 系统配置文件
+      echo IS_TEMP_CONVERSATION=true
+      echo IS_CUSTOM_SSO=false
+      echo API_KEY=your_api_key
+      echo PICGO_KEY=your_picgo_key
+      echo TUMY_KEY=your_tumy_key
+      echo PROXY=http://127.0.0.1:5200
+      echo MANAGER_SWITCH=false
+      echo ADMINPASSWORD=admin123
+      echo CF_CLEARANCE=your_cloudflare_clearance
+      echo PORT=5200
+      echo SHOW_THINKING=true
+      echo ISSHOW_SEARCH_RESULTS=true
+      echo SSO=ssoCookie1;ssoCookie2;ssoCookie3
+  ) > .env
+  
+  echo %GREEN%.env 文件已创建%RESET%
+  echo %YELLOW%请手动编辑 .env 文件并配置您的密钥和设置%RESET%
+  pause
+  exit /b 0
+)
+
+for /f "tokens=2 delims=." %%a in ('python --version 2^>^&1 ^| findstr /R "^Python [0-9]"') do set "PYTHON_VERSION=%%a"
+
+if %PYTHON_VERSION% LSS 8 (
+  echo %RED%错误：需要 Python 3.8 或更高版本%RESET%
+  pause
+  exit /b 1
+)
+
+if not exist "%VENV_NAME%" (
+  echo %GREEN%创建虚拟环境...%RESET%
+  python -m venv %VENV_NAME%
+)
+
+call %VENV_NAME%\Scripts\activate
+
+python -m pip install --upgrade pip
+
+echo %GREEN%安装依赖...%RESET%
+pip install --no-cache-dir flask flask_cors requests curl_cffi werkzeug datetime python-dotenv loguru
+
+if %ERRORLEVEL% NEQ 0 (
+  echo %RED%依赖安装失败%RESET%
+  deactivate
+  pause
+  exit /b 1
+)
+
+echo %GREEN%启动应用...%RESET%
+python app.py
+
+deactivate
+
+pause

start.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+RESET='\033[0m'
+
+VENV_NAME="myenv"
+
+check_python_version() {
+  python_version=$(python3 --version 2>&1 | awk '{print $2}' | cut -d. -f1-2)
+  
+  if [[ "$(printf '%s\n' "3.8" "$python_version" | sort -V | head -n1)" != "3.8" ]]; then
+      echo -e "${RED}错误：需要 Python 3.8 或更高版本${RESET}"
+      exit 1
+  fi
+}
+
+create_env_file() {
+  if [ ! -f ".env" ]; then
+      echo -e "${YELLOW}未找到 .env 文件，正在自动创建...${RESET}"
+      
+      cat > .env << EOL
+# 系统配置文件
+IS_TEMP_CONVERSATION=true
+IS_CUSTOM_SSO=false
+API_KEY=your_api_key
+PICGO_KEY=your_picgo_key
+TUMY_KEY=your_tumy_key
+PROXY=http://127.0.0.1:5200
+MANAGER_SWITCH=false
+ADMINPASSWORD=admin123
+CF_CLEARANCE=your_cloudflare_clearance
+PORT=5200
+SHOW_THINKING=true
+ISSHOW_SEARCH_RESULTS=true
+SSO=ssoCookie1;ssoCookie2;ssoCookie3
+EOL
+      
+      echo -e "${GREEN}.env 文件已创建${RESET}"
+      echo -e "${YELLOW}请手动编辑 .env 文件并配置您的密钥和设置${RESET}"
+      exit 0
+  fi
+}
+
+create_venv() {
+  if [ ! -d "$VENV_NAME" ]; then
+      echo -e "${GREEN}创建虚拟环境...${RESET}"
+      python3 -m venv "$VENV_NAME"
+  fi
+}
+
+main() {
+  create_env_file
+
+  check_python_version
+
+  create_venv
+
+  source "$VENV_NAME/bin/activate"
+
+  python3 -m pip install --upgrade pip
+
+  echo -e "${GREEN}安装依赖...${RESET}"
+  pip install --no-cache-dir \
+      flask flask_cors requests curl_cffi \
+      werkzeug datetime python-dotenv loguru
+
+  if [ $? -ne 0 ]; then
+      echo -e "${RED}依赖安装失败${RESET}"
+      deactivate
+      exit 1
+  fi
+
+  echo -e "${GREEN}启动应用...${RESET}"
+  python3 app.py
+
+  deactivate
+}
+
+chmod +x "$0"
+
+main

templates/login.html

@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <title>登录</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --bg-primary: #f4f6f9;
+            --card-bg: #ffffff;
+            --text-primary: #2c3e50;
+            --text-secondary: #6c757d;
+            --border-color: #e2e8f0;
+            --primary-color: #3498db;
+        }
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body {
+            font-family: 'Inter', sans-serif;
+            background-color: var(--bg-primary);
+            color: var(--text-primary);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+        }
+        .login-form {
+            background: var(--card-bg);
+            padding: 40px;
+            border-radius: 16px;
+            box-shadow: 0 10px 25px rgba(0, 0, 0, 0.08);
+            width: 100%;
+            max-width: 400px;
+        }
+        h2 {
+            text-align: center;
+            margin-bottom: 20px;
+            color: var(--text-primary);
+        }
+        input {
+            width: 100%;
+            padding: 12px 15px;
+            margin: 10px 0;
+            border: 1px solid var(--border-color);
+            border-radius: 8px;
+            font-size: 16px;
+        }
+        button {
+            width: 100%;
+            padding: 12px;
+            background-color: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: background-color 0.3s;
+        }
+        button:hover { background-color: #2980b9; }
+    </style>
+</head>
+<body>
+    <div class="login-form">
+        <h2>管理员登录</h2>
+        <form action="/manager/login" method="post">
+            <input type="password" name="password" placeholder="输入管理员密码" required>
+            <button type="submit">登录</button>
+        </form>
+    </div>
+    {% if error %}
+    <div id="notification" style="position: fixed; top: 20px; left: 50%; transform: translateX(-50%); background-color: #f44336; color: white; padding: 10px 20px; border-radius: 8px; box-shadow: 0 4px 8px rgba(0,0,0,0.2); display: block; z-index: 1000;">密码错误</div>
+    <script>
+        setTimeout(() => {
+            document.getElementById('notification').style.display = 'none';
+        }, 2000);
+    </script>
+    {% endif %}
+</body>
+</html>

templates/manager.html

@@ -0,0 +1,1081 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>GrokAPI管理面板</title>
+    <style type="text/css">@font-face {font-family:Inter;font-style:normal;font-weight:300;src:url(/cf-fonts/v/inter/5.0.16/vietnamese/wght/normal.woff2);unicode-range:U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:300;src:url(/cf-fonts/v/inter/5.0.16/cyrillic/wght/normal.woff2);unicode-range:U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:300;src:url(/cf-fonts/v/inter/5.0.16/greek-ext/wght/normal.woff2);unicode-range:U+1F00-1FFF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:300;src:url(/cf-fonts/v/inter/5.0.16/cyrillic-ext/wght/normal.woff2);unicode-range:U+0460-052F,U+1C80-1C88,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:300;src:url(/cf-fonts/v/inter/5.0.16/greek/wght/normal.woff2);unicode-range:U+0370-03FF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:300;src:url(/cf-fonts/v/inter/5.0.16/latin/wght/normal.woff2);unicode-range:U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+2074,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:300;src:url(/cf-fonts/v/inter/5.0.16/latin-ext/wght/normal.woff2);unicode-range:U+0100-02AF,U+0304,U+0308,U+0329,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20CF,U+2113,U+2C60-2C7F,U+A720-A7FF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:400;src:url(/cf-fonts/v/inter/5.0.16/latin/wght/normal.woff2);unicode-range:U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+2074,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:400;src:url(/cf-fonts/v/inter/5.0.16/greek-ext/wght/normal.woff2);unicode-range:U+1F00-1FFF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:400;src:url(/cf-fonts/v/inter/5.0.16/cyrillic-ext/wght/normal.woff2);unicode-range:U+0460-052F,U+1C80-1C88,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:400;src:url(/cf-fonts/v/inter/5.0.16/greek/wght/normal.woff2);unicode-range:U+0370-03FF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:400;src:url(/cf-fonts/v/inter/5.0.16/cyrillic/wght/normal.woff2);unicode-range:U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:400;src:url(/cf-fonts/v/inter/5.0.16/latin-ext/wght/normal.woff2);unicode-range:U+0100-02AF,U+0304,U+0308,U+0329,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20CF,U+2113,U+2C60-2C7F,U+A720-A7FF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:400;src:url(/cf-fonts/v/inter/5.0.16/vietnamese/wght/normal.woff2);unicode-range:U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:600;src:url(/cf-fonts/v/inter/5.0.16/cyrillic/wght/normal.woff2);unicode-range:U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:600;src:url(/cf-fonts/v/inter/5.0.16/latin-ext/wght/normal.woff2);unicode-range:U+0100-02AF,U+0304,U+0308,U+0329,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20CF,U+2113,U+2C60-2C7F,U+A720-A7FF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:600;src:url(/cf-fonts/v/inter/5.0.16/greek-ext/wght/normal.woff2);unicode-range:U+1F00-1FFF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:600;src:url(/cf-fonts/v/inter/5.0.16/latin/wght/normal.woff2);unicode-range:U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+2074,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:600;src:url(/cf-fonts/v/inter/5.0.16/vietnamese/wght/normal.woff2);unicode-range:U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:600;src:url(/cf-fonts/v/inter/5.0.16/greek/wght/normal.woff2);unicode-range:U+0370-03FF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:600;src:url(/cf-fonts/v/inter/5.0.16/cyrillic-ext/wght/normal.woff2);unicode-range:U+0460-052F,U+1C80-1C88,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:700;src:url(/cf-fonts/v/inter/5.0.16/cyrillic-ext/wght/normal.woff2);unicode-range:U+0460-052F,U+1C80-1C88,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:700;src:url(/cf-fonts/v/inter/5.0.16/greek-ext/wght/normal.woff2);unicode-range:U+1F00-1FFF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:700;src:url(/cf-fonts/v/inter/5.0.16/latin/wght/normal.woff2);unicode-range:U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+2074,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:700;src:url(/cf-fonts/v/inter/5.0.16/latin-ext/wght/normal.woff2);unicode-range:U+0100-02AF,U+0304,U+0308,U+0329,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20CF,U+2113,U+2C60-2C7F,U+A720-A7FF;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:700;src:url(/cf-fonts/v/inter/5.0.16/vietnamese/wght/normal.woff2);unicode-range:U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:700;src:url(/cf-fonts/v/inter/5.0.16/cyrillic/wght/normal.woff2);unicode-range:U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116;font-display:swap;}@font-face {font-family:Inter;font-style:normal;font-weight:700;src:url(/cf-fonts/v/inter/5.0.16/greek/wght/normal.woff2);unicode-range:U+0370-03FF;font-display:swap;}</style>
+    <style>
+        :root {
+            --primary: #3498db;
+            --primary-hover: #1575b5;
+            --secondary: #64748B;
+            --success: #10B981;
+            --danger: #EF4444;
+            --warning: #F59E0B;
+            --bg-light: #F8FAFC;
+            --bg-white: #FFFFFF;
+            --text-dark: #1F2937;
+            --text-muted: #64748B;
+            --border: #E2E8F0;
+            --shadow: 0 2px 10px rgba(0, 0, 0, 0.05);
+            --card-border: #E2E8F0;
+            --progress-bg: #E2E8F0;
+            --status-active-bg: rgba(16, 185, 129, 0.1);
+            --status-expired-bg: rgba(239, 68, 68, 0.1);
+            --progress-fill-success: #10B981;
+            --progress-fill-warning: #F59E0B;
+            --progress-fill-danger: #EF4444;
+        }
+
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { font-family: 'Inter', sans-serif; background: var(--bg-light); color: var(--text-dark); line-height: 1.6; min-height: 100vh; padding-top: 5rem; }
+        .container { max-width: 1280px; margin: 0 auto; padding: 0 1.5rem; }
+        .card { background: var(--bg-white); border-radius: 0.75rem; box-shadow: var(--shadow); padding: 1.5rem; margin-bottom: 1.5rem; border: 1px solid var(--card-border); }
+        
+        .search-section { 
+            position: fixed; 
+            top: 0; 
+            left: 0; 
+            right: 0; 
+            z-index: 100; 
+            background: var(--bg-white); 
+            box-shadow: var(--shadow); 
+            padding: 1rem 1.5rem; 
+            margin: 0; 
+        }
+        .search-section .card { 
+            padding: 0; 
+            margin: 0; 
+            box-shadow: none; 
+            border: none; 
+        }
+        .search-input { 
+            width: 100%; 
+            padding: 0.75rem 1rem 0.75rem 2.5rem; 
+            border: 1px solid #CBD5E1; 
+            border-radius: 0.5rem; 
+            font-size: 0.9rem; 
+            background: #F9FAFB url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="none" stroke="%2364748B" stroke-width="2"><circle cx="7" cy="7" r="5"/><path d="M11 11l4 4"/></svg>') no-repeat 0.75rem center; 
+            transition: border-color 0.2s ease, box-shadow 0.2s ease; 
+        }
+        .search-input:focus { 
+            border-color: #0f5fc3; 
+            outline: none; 
+            box-shadow: 0 0 0 3px rgba(139, 92, 246, 0.2); 
+        }
+        .btn-base { padding: 0.5rem 1rem; border-radius: 0.5rem; border: none; cursor: pointer; font-weight: 500; display: inline-flex; align-items: center; gap: 0.5rem; transition: transform 0.2s ease, background 0.3s ease, box-shadow 0.2s ease; }
+        .btn { background: linear-gradient(135deg, var(--primary) 0%, #0f5fc3 100%); color: white; }
+        .btn:hover { background: linear-gradient(135deg, var(--primary-hover) 0%, #0f5fc3 100%); transform: translateY(-2px); box-shadow: 0 4px 15px rgba(107, 70, 193, 0.3); }
+        .btn-secondary { background: linear-gradient(135deg, var(--primary) 0%, #0f5fc3 100%); color: white; width: 2rem; height: 2rem; padding: 0; justify-content: center; }
+        .btn-secondary:hover { background: linear-gradient(135deg, var(--primary-hover) 0%, #0f5fc3 100%); transform: translateY(-1px); box-shadow: 0 2px 8px rgba(107, 70, 193, 0.3); }
+        .btn-danger { background: var(--danger); width: 2rem; height: 2rem; padding: 0; justify-content: center; }
+        .btn-danger:hover { background: #DC2626; }
+        .token-manage-grid { display: grid; grid-template-columns: 1fr; gap: 1.5rem; margin-top: 1rem; }
+        .input-group { display: flex; gap: 0.75rem; flex-wrap: wrap; align-items: center; }
+        .input-field { flex: 1; min-width: 0; padding: 0.75rem; border: 1px solid #CBD5E1; border-radius: 0.5rem; font-size: 0.9rem; background: #F9FAFB; transition: border-color 0.2s ease, box-shadow 0.2s ease; }
+        .input-field:focus { border-color: #0f5fc3; outline: none; box-shadow: 0 0 0 3px rgba(139, 92, 246, 0.2); }
+        #statusFilter, #modelSelect { background: #F9FAFB; border: 1px solid #CBD5E1; color: var(--text-dark); }
+        #statusFilter:focus, #modelSelect:focus { border-color: #0f5fc3; box-shadow: 0 0 0 3px rgba(139, 92, 246, 0.2); }
+        .token-grid { display: grid; grid-template-columns: 1fr; gap: 1.5rem; }
+        .token-card { background: var(--bg-white); border: 1px solid var(--card-border); border-radius: 0.75rem; box-shadow: var(--shadow); padding: 1rem; display: flex; flex-direction: column; gap: 1rem; transition: transform 0.2s ease; max-width: 100%; overflow: hidden; }
+        .token-card:hover { transform: translateY(-4px); }
+        .token-checkbox { display: none; }
+        .token-checkbox.show { display: block; position: absolute; top: 1rem; left: 1rem; }
+        .token-header { display: flex; flex-wrap: wrap; justify-content: space-between; align-items: center; gap: 0.5rem; border-bottom: 1px solid var(--border); padding-bottom: 0.75rem; }
+        .token-title { font-weight: 600; font-size: 0.9rem; color: var(--text-dark); flex: 1 1 auto; max-width: calc(100% - 80px); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+        .token-actions { display: flex; gap: 0.5rem; flex-shrink: 0; }
+        .model-list { display: grid; gap: 0.75rem; }
+        .model-item { display: grid; grid-template-columns: 1fr 2fr 80px; gap: 0.5rem; align-items: center; padding: 0.5rem; background: rgba(248, 250, 252, 0.5); border-radius: 0.5rem; }
+        .model-name { font-size: 0.85rem; font-weight: 500; color: var(--text-dark); white-space: nowrap; overflow: hidden; text-overflow: ellipsis;}     
+        .progress-container { display: flex; align-items: center; gap: 0.5rem; }
+        .progress-bar { flex: 1; height: 0.375rem; background: var(--progress-bg); border-radius: 1rem; overflow: hidden; }
+        .progress-fill { height: 100%; border-radius: 1rem; transition: width 0.3s ease; }
+        .progress-text { font-size: 0.75rem; color: var(--text-muted); min-width: 40px; }
+        .status { font-size: 0.75rem; padding: 0.25rem 0.75rem; border-radius: 1rem; text-align: center; font-weight: 500; }
+        .status-active { background: var(--status-active-bg); color: var(--success); }
+        .status-expired { background: var(--status-expired-bg); color: var(--danger); position: relative; }
+        .status-expired .tooltip { position: absolute; bottom: 100%; left: 50%; transform: translateX(-50%); background: var(--text-dark); color: white; padding: 0.25rem 0.5rem; border-radius: 0.25rem; font-size: 0.75rem; white-space: nowrap; opacity: 0; visibility: hidden; transition: opacity 0.2s; margin-bottom: 0.5rem; }
+        .status-expired:hover .tooltip { opacity: 1; visibility: visible; }
+        .notification { position: fixed; top: 5rem; left: 50%; transform: translateX(-50%); background: var(--primary); color: white; padding: 0.75rem 1.5rem; border-radius: 0.5rem; box-shadow: var(--shadow); z-index: 1000; display: none; animation: slideIn 0.3s ease; }
+        @keyframes slideIn { from { transform: translateX(-50%) translateY(-100%); opacity: 0; } to { transform: translateX(-50%) translateY(0); opacity: 1; } }
+
+        .overview-section { background: var(--bg-white); border-radius: 1rem; padding: 1.5rem; box-shadow: 0 6px 20px rgba(0, 0, 0, 0.06); position: relative; overflow: hidden; }
+        .overview-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 1rem; }
+        .overview-title { font-size: 1.5rem; font-weight: 700; color: var(--text-dark); }
+        .overview-actions { display: flex; gap: 0.75rem; }
+        .overview-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 1rem; }
+        .overview-card { background: linear-gradient(135deg, #F9FAFB 0%, #F1F5F9 100%); border-radius: 0.75rem; padding: 1rem; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.04); transition: transform 0.2s ease, box-shadow 0.2s ease; display: flex; align-items: center; gap: 1rem; position: relative; border: 1px solid rgba(107, 70, 193, 0.1); }
+        .overview-card:hover { transform: translateY(-4px); box-shadow: 0 8px 20px rgba(107, 70, 193, 0.15); }
+        .overview-icon { width: 2.5rem; height: 2.5rem; background: linear-gradient(135deg, rgba(107, 70, 193, 0.1) 0%, rgba(139, 92, 246, 0.1) 100%); border-radius: 0.5rem; display: flex; align-items: center; justify-content: center; color: var(--primary); flex-shrink: 0; }
+        .overview-content { display: flex; flex-direction: column; gap: 0.25rem; }
+        .overview-label { font-size: 0.9rem; font-weight: 500; color: var(--text-muted); text-transform: uppercase; letter-spacing: 0.05px; }
+        .overview-value { font-size: 1.75rem; font-weight: 700; color: var(--primary); }
+        .overview-card::after { content: attr(data-tooltip); position: absolute; top: -2.5rem; left: 50%; transform: translateX(-50%); background: rgba(31, 41, 55, 0.9); color: white; padding: 0.5rem 1rem; border-radius: 0.5rem; font-size: 0.85rem; white-space: nowrap; opacity: 0; visibility: hidden; transition: opacity 0.2s ease; pointer-events: none; }
+        .overview-card:hover::after { opacity: 1; visibility: visible; }
+
+        .pagination { display: flex; justify-content: center; align-items: center; gap: 0.5rem; margin-top: 1.5rem; }
+        .pagination-btn { padding: 0.5rem 1rem; border-radius: 0.5rem; border: 1px solid var(--border); background: var(--bg-white); cursor: pointer; font-size: 0.9rem; transition: background 0.2s ease; }
+        .pagination-btn:hover { background: var(--bg-light); }
+        .pagination-btn:disabled { opacity: 0.5; cursor: not-allowed; }
+        .pagination-select { padding: 0.5rem; border: 1px solid var(--border); border-radius: 0.5rem; font-size: 0.9rem; }
+
+        @media (max-width: 768px) {
+            .overview-grid { grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 0.75rem; }
+            .overview-card { padding: 0.75rem; }
+            .overview-icon { width: 2rem; height: 2rem; }
+            .overview-value { font-size: 1.5rem; }
+            .overview-label { font-size: 0.85rem; }
+            .token-grid { grid-template-columns: 1fr; gap: 1rem; }
+            .token-card { padding: 0.75rem; }
+        }
+
+        @media (min-width: 768px) {
+            .token-grid { grid-template-columns: repeat(auto-fill, minmax(360px, 1fr)); }
+            .token-card { min-height: 240px; }
+            .token-manage-grid { grid-template-columns: repeat(2, 1fr); }
+        }
+
+        @media (max-width: 480px) {
+            body { padding: 5rem 1rem 1rem; }
+            .card { padding: 1rem; }
+            .overview-section { padding: 1rem; }
+            .overview-header { flex-direction: column; align-items: flex-start; gap: 1rem; }
+            .overview-actions { width: 100%; justify-content: flex-end; }
+            .overview-grid { grid-template-columns: 1fr; gap: 0.75rem; }
+            .overview-card { padding: 1rem; }
+            .overview-value { font-size: 1.5rem; }
+            .search-section { padding: 0.5rem 1rem; }
+            .search-section .input-group { flex-direction: column; gap: 0.5rem; }
+            .search-input, #statusFilter { width: 100%; }
+            .pagination { flex-wrap: wrap; gap: 0.75rem; }
+            .input-group label { width: 100%; margin-bottom: 0.5rem; }
+            .input-field { width: 100%; }
+        }
+    </style>
+</head>
+<body>
+    <div class="search-section">
+        <div class="card">
+            <div class="input-group">
+                <input type="text" class="search-input" id="searchInput" placeholder="搜索 Token..." aria-label="搜索 Token" style="flex: 1;">
+                <select class="input-field" id="statusFilter" style="width: 120px;" aria-label="筛选 Token 状态">
+                    <option value="all">全部</option>
+                    <option value="active">活跃</option>
+                    <option value="expired">失效</option>
+                </select>
+            </div>
+        </div>
+    </div>
+
+    <div class="container">
+        <div class="overview-section card">
+            <div class="overview-header">
+                <h2 class="overview-title">概览</h2>
+                <div class="overview-actions">
+                    <button class="btn btn-base" id="batchDeleteTokens" aria-label="批量删除选中的 Token">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M3 6h18M9 6V4a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2M10 11v6M14 11v6M4 6v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V6"/>
+                        </svg>
+                        批量删除
+                    </button>
+                    <button class="btn btn-base" id="refreshTokens" aria-label="刷新 Token 列表">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8"/>
+                            <path d="M21 3v5h-5"/>
+                            <path d="M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16"/>
+                            <path d="M3 21v-5h5"/>
+                        </svg>
+                        刷新
+                    </button>
+                </div>
+            </div>
+            <div class="overview-grid">
+                <div class="overview-card" data-tooltip="总共管理的Token数量">
+                    <div class="overview-icon">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"/>
+                            <rect x="8" y="2" width="8" height="4" rx="1"/>
+                        </svg>
+                    </div>
+                    <div class="overview-content">
+                        <span class="overview-label">Token 总数</span>
+                        <span class="overview-value" id="totalTokens">0</span>
+                    </div>
+                </div>
+                <div class="overview-card" data-tooltip="grok-2 模型剩余可用次数">
+                    <div class="overview-icon">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M12 2v20M2 12h20"/>
+                        </svg>
+                    </div>
+                    <div class="overview-content">
+                        <span class="overview-label">grok-2</span>
+                        <span class="overview-value" id="grok-2-count">0</span>
+                    </div>
+                </div>
+                <div class="overview-card" data-tooltip="grok-3 模型剩余可用次数">
+                    <div class="overview-icon">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <circle cx="12" cy="12" r="10"/>
+                            <path d="M12 2v4M12 18v4"/>
+                        </svg>
+                    </div>
+                    <div class="overview-content">
+                        <span class="overview-label">grok-3</span>
+                        <span class="overview-value" id="grok-3-count">0</span>
+                    </div>
+                </div>
+                <div class="overview-card" data-tooltip="grok-3-deepsearch 模型剩余可用次数">
+                    <div class="overview-icon">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <circle cx="11" cy="11" r="8"/>
+                            <path d="M21 21l-4.35-4.35"/>
+                        </svg>
+                    </div>
+                    <div class="overview-content">
+                        <span class="overview-label">grok-3-deepsearch</span>
+                        <span class="overview-value" id="grok-3-deepsearch-count">0</span>
+                    </div>
+                </div>
+                <div class="overview-card" data-tooltip="grok-3-deepersearch 模型剩余可用次数">
+                    <div class="overview-icon">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <circle cx="11" cy="11" r="8"/>
+                            <path d="M21 21l-4.35-4.35"/>
+                        </svg>
+                    </div>
+                    <div class="overview-content">
+                        <span class="overview-label">grok-3-deepersearch</span>
+                        <span class="overview-value" id="grok-3-deepersearch-count">0</span>
+                    </div>
+                </div>                
+                <div class="overview-card" data-tooltip="grok-3-reasoning 模型剩余可用次数">
+                    <div class="overview-icon">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M12 2a10 10 0 0 0-10 10c0 5 8 13 10 13s10-8 10-13a10 10 0 0 0-10-10z"/>
+                        </svg>
+                    </div>
+                    <div class="overview-content">
+                        <span class="overview-label">grok-3-reasoning</span>
+                        <span class="overview-value" id="grok-3-reasoning-count">0</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div class="card">
+            <h3>Token 管理</h3>
+            <div class="token-manage-grid">
+                <div>
+                    <h4 style="margin-bottom: 0.75rem;">添加单个 SSO Token</h4>
+                    <div class="input-group">
+                        <input type="text" class="input-field" id="singleTokenInput" placeholder="输入单个 SSO Token" aria-label="输入单个 SSO Token">
+                        <button class="btn btn-base" id="addSingleTokenBtn" aria-label="添加单个 SSO Token">添加</button>
+                    </div>
+                </div>
+                <div>
+                    <h4 style="margin-bottom: 0.75rem;">设置 CF Clearance</h4>
+                    <div class="input-group">
+                        <input type="text" class="input-field" id="cfInput" placeholder="输入 CF Clearance" aria-label="输入 CF Clearance">
+                        <button class="btn btn-base" id="setCfBtn" aria-label="设置 CF Clearance">设置</button>
+                    </div>
+                </div>
+                <div>
+                    <h4 style="margin-bottom: 0.75rem;">批量添加 SSO Token</h4>
+                    <div class="input-group">
+                        <input type="text" class="input-field" id="batchTokenInput" placeholder="输入多个 SSO Token（用逗号隔开，如 ey1,ey2）" aria-label="输入多个 SSO Token">
+                        <button class="btn btn-base" id="addBatchTokenBtn" aria-label="批量添加 SSO Token">添加</button>
+                    </div>
+                </div>
+                <div>
+                    <h4 style="margin-bottom: 0.75rem;">检测模型可用性</h4>
+                    <div class="input-group">
+                        <select class="input-field" id="modelSelect" style="width: 150px;" aria-label="选择要检测的模型">
+                            <option value="grok-2">grok-2</option>
+                            <option value="grok-3" selected>grok-3</option>
+                            <option value="grok-3-reasoning">grok-3-reasoning</option>
+                            <option value="grok-3-deepsearch">grok-3-deepsearch</option>
+                        </select>
+                        <button class="btn btn-base" id="testAvailabilityBtn" aria-label="检测模型可用性">检测</button>
+                    </div>
+                </div>
+                <div>
+                    <h4 style="margin-bottom: 0.75rem;">Base URL</h4>
+                    <div class="input-group">
+                        <input type="text" class="input-field" id="baseUrl" readonly aria-label="Base URL" value="">
+                        <button class="btn btn-base" id="copyBaseUrlBtn" aria-label="复制 Base URL">
+                            <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <rect x="9" y="9" width="13" height="13" rx="2"/>
+                                <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+                            </svg>
+                            复制
+                        </button>
+                    </div>
+                </div>
+                <div>
+                    <h4 style="margin-bottom: 0.75rem;">API Key</h4>
+                    <div class="input-group">
+                        <input type="text" class="input-field" id="apiKey" aria-label="API Key">
+                        <button class="btn btn-base" id="copyApiKeyBtn" aria-label="复制 API Key">
+                            <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <rect x="9" y="9" width="13" height="13" rx="2"/>
+                                <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>
+                            </svg>
+                            复制
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div class="token-grid" id="tokenGrid"></div>
+        <div class="pagination" id="pagination">
+            <button class="pagination-btn" id="prevPage" aria-label="上一页">上一页</button>
+            <select class="pagination-select" id="pageSelect" aria-label="选择页面"></select>
+            <button class="pagination-btn" id="nextPage" aria-label="下一页">下一页</button>
+        </div>
+    </div>
+
+    <div class="notification" id="notification"></div>
+
+    <script>
+        var modelConfig = {
+            "grok-3": { RequestFrequency: 20, ExpirationTime: 7200000 },
+            "grok-3-deepsearch": { RequestFrequency: 10, ExpirationTime: 86400000 },
+            "grok-3-deepersearch": { RequestFrequency: 3, ExpirationTime: 86400000 },
+            "grok-3-reasoning": { RequestFrequency: 10, ExpirationTime: 86400000 },
+            "grok-4": { RequestFrequency: 20, ExpirationTime: 7200000 }
+        };
+
+        let tokenMap = {};
+        let batchDeleteMode = false;
+        let lastUpdateTime = 0;
+        let currentPage = 1;
+        const itemsPerPage = 30;
+
+        function getProgressColor(percentage, isValid) {
+            if (!isValid) return '#94A3B8';
+            if (percentage > 70) return 'var(--progress-fill-danger)';
+            if (percentage > 30) return 'var(--progress-fill-warning)';
+            return 'var(--progress-fill-success)';
+        }
+
+        function calculateModelRemaining() {
+            const modelRemaining = {};
+            Object.keys(modelConfig).forEach(modelName => {
+                var maxRequests = modelConfig[modelName].RequestFrequency;
+                modelRemaining[modelName] = 0;
+                Object.values(tokenMap).forEach(tokenData => {
+                    const modelData = tokenData[modelName];
+                    if(modelData){
+                        if (!modelData.isSuper) {
+                            modelRemaining[modelName] = 0;
+                        }
+                        else if (modelData.isValid) {
+                            modelRemaining[modelName] += maxRequests - modelData.totalRequestCount;
+                        }
+                    }
+                });
+            });
+            return modelRemaining;
+        }
+
+        function updateTokenCounters() {
+            const totalTokensElement = document.getElementById('totalTokens');
+            if (totalTokensElement) {
+                totalTokensElement.textContent = Object.keys(tokenMap).length;
+            } else {
+                console.warn('Element with ID "totalTokens" not found.');
+            }
+
+            const modelRemaining = calculateModelRemaining();
+            const modelIds = ['grok-3', 'grok-3-deepsearch', 'grok-3-deepersearch', 'grok-3-reasoning','grok-4'];
+            modelIds.forEach(modelName => {
+                const countElement = document.getElementById(`${modelName}-count`);
+                if (countElement) {
+                    countElement.textContent = modelRemaining[modelName] || 0;
+                } else {
+                    console.warn(`Element with ID "${modelName}-count" not found.`);
+                }
+            });
+        }
+
+        async function updateExpiredTokenTimers() {
+            const currentTime = Date.now();
+            if (currentTime - lastUpdateTime < 5000) return;
+
+            let shouldRefresh = false;
+            Object.values(tokenMap).forEach(tokenData => {
+                Object.entries(tokenData).forEach(([modelName, modelData]) => {
+                    if (!modelData.isValid) {
+                        if(modelData.isSuper){
+                            ExpirationTime = 3 * 60 * 60 * 1000;
+                        }else{
+                            ExpirationTime = modelConfig[modelName].ExpirationTime;
+                        }
+                        const recoveryTime = modelData.invalidatedTime + ExpirationTime;
+                        if (recoveryTime <= currentTime) {
+                            shouldRefresh = true;
+                        }
+                    }
+                });
+            });
+
+            if (shouldRefresh) {
+                lastUpdateTime = currentTime;
+                await fetchTokenMap();
+                showNotification('Token 状态已自动更新');
+            } else {
+                renderTokenDiff(tokenMap);
+            }
+        }
+
+        function getTooltipText(invalidatedTime, expirationTime) {
+            const currentTime = Date.now();
+            const recoveryTime = invalidatedTime + expirationTime;
+            const remainingTime = recoveryTime - currentTime;
+            if (remainingTime > 0) {
+                const minutes = Math.floor(remainingTime / 60000);
+                const seconds = Math.floor((remainingTime % 60000) / 1000);
+                return `${minutes}分${seconds}秒后恢复`;
+            }
+            return '已可恢复';
+        }
+
+        function createTokenCard(token, tokenData) {
+            const tokenCard = document.createElement('div');
+            tokenCard.className = 'token-card';
+            tokenCard.setAttribute('data-token', token);
+
+            const checkbox = document.createElement('input');
+            checkbox.type = 'checkbox';
+            checkbox.className = `token-checkbox ${batchDeleteMode ? 'show' : ''}`;
+            checkbox.value = token;
+
+            const tokenHeader = document.createElement('div');
+            tokenHeader.className = 'token-header';
+
+            const tokenTitle = document.createElement('div');
+            tokenTitle.className = 'token-title';
+            tokenTitle.textContent = token;
+            tokenTitle.title = token;
+
+            const tokenActions = document.createElement('div');
+            tokenActions.className = 'token-actions';
+
+            const copyBtn = document.createElement('button');
+            copyBtn.className = 'btn btn-secondary btn-base';
+            copyBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/></svg>';
+            copyBtn.setAttribute('aria-label', '复制 Token 到剪贴板');
+            copyBtn.addEventListener('click', async () => {
+                try {
+                    await navigator.clipboard.writeText(token);
+                    showNotification('Token 已复制到剪贴板');
+                } catch (err) {
+                    showNotification('复制失败，请重试');
+                }
+            });
+
+            const deleteBtn = document.createElement('button');
+            deleteBtn.className = 'btn btn-danger btn-base';
+            deleteBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 6h18M9 6V4a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2M10 11v6M14 11v6M4 6v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V6"/></svg>';
+            deleteBtn.setAttribute('aria-label', `删除 Token ${token}`);
+            deleteBtn.addEventListener('click', async () => {
+                if (confirm(`确认删除 token: ${token}?`)) {
+                    try {
+                        const baseUrl = document.getElementById('baseUrl').value;
+                        const response = await fetch(`${baseUrl}/manager/api/delete`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ sso: token })
+                        });
+                        if (response.ok) {
+                            await fetchTokenMap();
+                            showNotification('Token 删除成功');
+                        } else {
+                            showNotification('删除 Token 失败');
+                        }
+                    } catch (error) {
+                        showNotification('删除 Token 出错');
+                    }
+                }
+            });
+
+            tokenActions.appendChild(copyBtn);
+            tokenActions.appendChild(deleteBtn);
+            tokenHeader.appendChild(tokenTitle);
+            tokenHeader.appendChild(tokenActions);
+
+            const modelList = document.createElement('div');
+            modelList.className = 'model-list';
+
+            Object.entries(modelConfig).forEach(([modelName, config]) => {
+                const modelItem = document.createElement('div');
+                modelItem.className = 'model-item';
+
+                const modelNameSpan = document.createElement('div');
+                modelNameSpan.className = 'model-name';
+                modelNameSpan.textContent = modelName;
+
+                const progressContainer = document.createElement('div');
+                progressContainer.className = 'progress-container';
+
+                const progressBar = document.createElement('div');
+                progressBar.className = 'progress-bar';
+                const progressFill = document.createElement('div');
+                progressFill.className = 'progress-fill';
+
+                const modelData = tokenData[modelName];
+                if(!modelData) return;
+                const isSuper = modelData.isSuper;
+                let requestCount = modelData.totalRequestCount;
+                let maxRequests = config.RequestFrequency;
+                if (isSuper) {
+                    switch (modelName) {
+                        case "grok-3":
+                            maxRequests = 100;
+                            break;
+                        case "grok-3-deepsearch":
+                            maxRequests = 30;
+                            break;
+                        case "grok-3-deepersearch":
+                            maxRequests = 10;
+                            break;
+                        case "grok-3-reasoning":
+                            maxRequests = 30;
+                            break;
+                        case "grok-4":
+                            maxRequests = 20;
+                    }
+                }
+                const percentage = Math.min((requestCount / maxRequests) * 100, 100);
+                
+                progressFill.style.width = `${percentage}%`;
+                progressFill.style.backgroundColor = getProgressColor(percentage, modelData.isValid);
+                progressBar.appendChild(progressFill);
+
+                const progressText = document.createElement('div');
+                progressText.className = 'progress-text';
+                progressText.textContent = `${requestCount}/${maxRequests}`;
+
+                const status = document.createElement('div');
+                status.className = 'status';
+                if (!modelData.isValid) {
+                    if(modelData.isSuper){
+                            ExpirationTime = 3 * 60 * 60 * 1000;
+                    }
+                    else{
+                            ExpirationTime = config.ExpirationTime;
+                    }
+                    status.classList.add('status-expired');
+                    status.textContent = '失效';
+                    status.setAttribute('data-invalidated-time', modelData.invalidatedTime);
+                    status.setAttribute('data-expiration-time', ExpirationTime);
+                    const tooltip = document.createElement('div');
+                    tooltip.className = 'tooltip';
+                    tooltip.textContent = getTooltipText(modelData.invalidatedTime, ExpirationTime);
+                    status.appendChild(tooltip);
+                } else {
+                    status.classList.add('status-active');
+                    status.textContent = '活跃';
+                }
+
+                progressContainer.appendChild(progressBar);
+                progressContainer.appendChild(progressText);
+
+                modelItem.appendChild(modelNameSpan);
+                modelItem.appendChild(progressContainer);
+                modelItem.appendChild(status);
+                modelList.appendChild(modelItem);
+            });
+
+            tokenCard.appendChild(checkbox);
+            tokenCard.appendChild(tokenHeader);
+            tokenCard.appendChild(modelList);
+            return tokenCard;
+        }
+
+        function updateTokenCard(token, tokenData) {
+            const tokenCard = document.querySelector(`[data-token="${token}"]`);
+            const modelItems = tokenCard.querySelectorAll('.model-item');
+            let index = 0;
+            Object.entries(modelConfig).forEach(([modelName, config]) => {
+                const modelItem = modelItems[index++];
+                const modelData = tokenData[modelName];
+                if(!modelData) return;
+                const isSuper = modelData.isSuper;
+                let requestCount = modelData.totalRequestCount;
+                let maxRequests = config.RequestFrequency;
+                if (isSuper) {
+                    switch (modelName) {
+                        case "grok-3":
+                            maxRequests = 100;
+                            break;
+                        case "grok-3-deepsearch":
+                            maxRequests = 30;
+                            break;
+                        case "grok-3-deepersearch":
+                            maxRequests = 10;
+                            break;
+                        case "grok-3-reasoning":
+                            maxRequests = 30;
+                            break;
+                        case "grok-4":
+                            maxRequests = 20;
+                    }
+                }
+                const percentage = Math.min((requestCount / maxRequests) * 100, 100);
+
+                const progressFill = modelItem.querySelector('.progress-fill');
+                progressFill.style.width = `${percentage}%`;
+                progressFill.style.backgroundColor = getProgressColor(percentage, modelData.isValid);
+
+                const progressText = modelItem.querySelector('.progress-text');
+                progressText.textContent = `${requestCount}/${maxRequests}`;
+
+                const status = modelItem.querySelector('.status');
+                status.className = 'status';
+                if (!modelData.isValid) {
+                    if(modelData.isSuper){
+                            ExpirationTime = 3 * 60 * 60 * 1000;
+                    }
+                    else{
+                            ExpirationTime = config.ExpirationTime;
+                    }
+                    status.classList.add('status-expired');
+                    status.textContent = '失效';
+                    status.setAttribute('data-invalidated-time', modelData.invalidatedTime);
+                    status.setAttribute('data-expiration-time', ExpirationTime);
+                    const tooltip = status.querySelector('.tooltip') || document.createElement('div');
+                    tooltip.className = 'tooltip';
+                    tooltip.textContent = getTooltipText(modelData.invalidatedTime, ExpirationTime);
+                    if (!status.contains(tooltip)) status.appendChild(tooltip);
+                } else {
+                    status.classList.add('status-active');
+                    status.textContent = '活跃';
+                    const tooltip = status.querySelector('.tooltip');
+                    if (tooltip) tooltip.remove();
+                }
+            });
+            const checkbox = tokenCard.querySelector('.token-checkbox');
+            checkbox.className = `token-checkbox ${batchDeleteMode ? 'show' : ''}`;
+        }
+
+        function renderTokenDiff(newTokenMap) {
+            const tokenGrid = document.getElementById('tokenGrid');
+            if (!tokenGrid) {
+                console.error('Token grid element not found.');
+                return;
+            }
+            const existingTokens = new Set(Array.from(tokenGrid.children).map(card => card.getAttribute('data-token')));
+            const filteredTokens = filterTokensArray(Object.entries(newTokenMap));
+            const totalItems = filteredTokens.length;
+            const totalPages = Math.ceil(totalItems / itemsPerPage);
+            currentPage = Math.min(currentPage, totalPages) || 1;
+
+            const startIndex = (currentPage - 1) * itemsPerPage;
+            const endIndex = Math.min(startIndex + itemsPerPage, totalItems);
+            const tokensToRender = filteredTokens.slice(startIndex, endIndex);
+
+            const newTokens = new Set(tokensToRender.map(([token]) => token));
+
+            existingTokens.forEach(token => {
+                if (!newTokens.has(token)) {
+                    tokenGrid.querySelector(`[data-token="${token}"]`).remove();
+                }
+            });
+
+            tokensToRender.forEach(([token, tokenData]) => {
+                if (!existingTokens.has(token)) {
+                    const tokenCard = createTokenCard(token, tokenData);
+                    tokenGrid.appendChild(tokenCard);
+                } else {
+                    updateTokenCard(token, tokenData);
+                }
+            });
+
+            updateTokenCounters();
+            renderPagination(totalPages);
+        }
+
+        function filterTokensArray(tokenEntries) {
+            const searchInput = document.getElementById('searchInput');
+            const statusFilter = document.getElementById('statusFilter');
+            if (!searchInput || !statusFilter) {
+                console.error('Search input or status filter element not found.');
+                return tokenEntries;
+            }
+            const searchTerm = searchInput.value.toLowerCase();
+            const statusFilterValue = statusFilter.value;
+
+            return tokenEntries.filter(([token, tokenData]) => {
+                const hasActive = Object.values(tokenData).some(data => data.isValid);
+                const hasExpired = Object.values(tokenData).some(data => !data.isValid);
+
+                let display = true;
+                if (!token.toLowerCase().includes(searchTerm)) display = false;
+                if (statusFilterValue === 'active' && !hasActive) display = false;
+                if (statusFilterValue === 'expired' && !hasExpired) display = false;
+
+                return display;
+            });
+        }
+
+        function renderPagination(totalPages) {
+            const pageSelect = document.getElementById('pageSelect');
+            if (!pageSelect) {
+                console.error('Page select element not found.');
+                return;
+            }
+            pageSelect.innerHTML = '';
+            for (let i = 1; i <= totalPages; i++) {
+                const option = document.createElement('option');
+                option.value = i;
+                option.textContent = `第 ${i} 页`;
+                if (i === currentPage) option.selected = true;
+                pageSelect.appendChild(option);
+            }
+
+            const prevPage = document.getElementById('prevPage');
+            const nextPage = document.getElementById('nextPage');
+            if (prevPage) prevPage.disabled = currentPage === 1;
+            if (nextPage) nextPage.disabled = currentPage === totalPages || totalPages === 0;
+        }
+
+        async function fetchTokenMap() {
+            console.log('开始获取 tokenMap');
+            try {
+                const baseUrlElement = document.getElementById('baseUrl');
+                if (!baseUrlElement) {
+                    throw new Error('Base URL 元素未找到');
+                }
+                const baseUrl = baseUrlElement.value;
+                console.log('请求 URL:', `${baseUrl}/manager/api/get`);
+                const response = await fetch(`${baseUrl}/manager/api/get`);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`获取 Token 失败: ${response.status} - ${errorText}`);
+                }
+                const data = await response.json();
+                console.log('获取到的数据:', data);
+                if (!data || typeof data !== 'object') {
+                    throw new Error('返回的数据不是有效的 Token Map');
+                }
+                tokenMap = data;
+                renderTokenDiff(tokenMap);
+                console.log('tokenMap 更新成功');
+            } catch (error) {
+                console.error('获取 Token 出错:', error);
+                showNotification(`获取 Token 出错: ${error.message}`);
+            }
+        }
+
+        document.addEventListener('DOMContentLoaded', () => {
+            const baseUrlInput = document.getElementById('baseUrl');
+            if (baseUrlInput) {
+                baseUrlInput.value = window.location.origin;
+            } else {
+                console.error('Base URL input element not found.');
+            }
+
+            const apiKeyInput = document.getElementById('apiKey');
+            if (apiKeyInput) {
+                const savedApiKey = localStorage.getItem('apiKey');
+                apiKeyInput.value = savedApiKey || 'sk-1234567';
+                apiKeyInput.addEventListener('change', () => {
+                    const newApiKey = apiKeyInput.value.trim();
+                    if (newApiKey) {
+                        localStorage.setItem('apiKey', newApiKey);
+                        showNotification(`API Key 已更新为: ${newApiKey}`);
+                    } else {
+                        apiKeyInput.value = localStorage.getItem('apiKey') || 'sk-1234567';
+                        showNotification('API Key 不能为空，已恢复为上次保存的值');
+                    }
+                });
+            } else {
+                console.error('API Key input element not found.');
+            }
+
+            const copyBaseUrlBtn = document.getElementById('copyBaseUrlBtn');
+            if (copyBaseUrlBtn) {
+                copyBaseUrlBtn.addEventListener('click', async () => {
+                    try {
+                        await navigator.clipboard.writeText(baseUrlInput.value);
+                        showNotification('Base URL 已复制到剪贴板');
+                    } catch (err) {
+                        showNotification('复制失败，请重试');
+                    }
+                });
+            }
+
+            const copyApiKeyBtn = document.getElementById('copyApiKeyBtn');
+            if (copyApiKeyBtn) {
+                copyApiKeyBtn.addEventListener('click', async () => {
+                    try {
+                        await navigator.clipboard.writeText(apiKeyInput.value);
+                        showNotification('API Key 已复制到剪贴板');
+                    } catch (err) {
+                        showNotification('复制失败，请重试');
+                    }
+                });
+            }
+
+            const addSingleTokenBtn = document.getElementById('addSingleTokenBtn');
+            if (addSingleTokenBtn) {
+                addSingleTokenBtn.addEventListener('click', async () => {
+                    const tokenInput = document.getElementById('singleTokenInput');
+                    const tokenText = tokenInput.value.trim();
+                    if (tokenText) {
+                        try {
+                            const baseUrl = document.getElementById('baseUrl').value;
+                            const response = await fetch(`${baseUrl}/manager/api/add`, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ sso: tokenText })
+                            });
+                            if (response.ok) {
+                                tokenInput.value = '';
+                                await fetchTokenMap();
+                                showNotification('Token 添加成功');
+                            } else {
+                                showNotification('添加 Token 失败');
+                            }
+                        } catch (error) {
+                            showNotification('添加 Token 出错');
+                        }
+                    } else {
+                        showNotification('请输入 Token');
+                    }
+                });
+            }
+
+            const addBatchTokenBtn = document.getElementById('addBatchTokenBtn');
+            if (addBatchTokenBtn) {
+                addBatchTokenBtn.addEventListener('click', async () => {
+                    const tokenInput = document.getElementById('batchTokenInput');
+                    const tokenText = tokenInput.value.trim();
+                    if (tokenText) {
+                        const tokens = tokenText.split(',').map(t => t.trim()).filter(t => t.length > 0);
+                        if (tokens.length === 0) {
+                            showNotification('请输入至少一个有效的 Token');
+                            return;
+                        }
+                        try {
+                            const baseUrl = document.getElementById('baseUrl').value;
+                            const successes = [];
+                            const failures = [];
+                            for (const token of tokens) {
+                                const response = await fetch(`${baseUrl}/manager/api/add`, {
+                                    method: 'POST',
+                                    headers: { 'Content-Type': 'application/json' },
+                                    body: JSON.stringify({ sso: token })
+                                });
+                                if (response.ok) {
+                                    successes.push(token);
+                                } else {
+                                    failures.push(token);
+                                }
+                            }
+                            tokenInput.value = '';
+                            await fetchTokenMap();
+                            if (successes.length > 0 && failures.length === 0) {
+                                showNotification(`成功添加 ${successes.length} 个 Token`);
+                            } else if (successes.length > 0 && failures.length > 0) {
+                                showNotification(`成功添加 ${successes.length} 个 Token，失败 ${failures.length} 个`);
+                            } else {
+                                showNotification('所有 Token 添加失败');
+                            }
+                        } catch (error) {
+                            showNotification('添加 Token 时出错');
+                        }
+                    } else {
+                        showNotification('请输入 Token');
+                    }
+                });
+            }
+
+            const setCfBtn = document.getElementById('setCfBtn');
+            if (setCfBtn) {
+                setCfBtn.addEventListener('click', async () => {
+                    const cfInput = document.getElementById('cfInput');
+                    const newCf = cfInput.value.trim();
+                    if (newCf) {
+                        try {
+                            const baseUrl = document.getElementById('baseUrl').value;
+                            const response = await fetch(`${baseUrl}/manager/api/cf_clearance`, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ cf_clearance: newCf })
+                            });
+                            if (response.ok) {
+                                cfInput.value = '';
+                                showNotification('CF Clearance 设置成功');
+                            } else {
+                                showNotification('设置 CF Clearance 失败');
+                            }
+                        } catch (error) {
+                            showNotification('设置 CF Clearance 出错');
+                        }
+                    }
+                });
+            }
+
+            const testAvailabilityBtn = document.getElementById('testAvailabilityBtn');
+            if (testAvailabilityBtn) {
+                testAvailabilityBtn.addEventListener('click', async () => {
+                    const selectedModel = document.getElementById('modelSelect').value;
+                    const baseUrl = document.getElementById('baseUrl').value;
+                    const apiKey = document.getElementById('apiKey').value.trim();
+                    const apiUrl = `${baseUrl}/v1/chat/completions`;
+                    try {
+                        const response = await fetch(apiUrl, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'Authorization': `Bearer ${apiKey}`
+                            },
+                            body: JSON.stringify({
+                                model: selectedModel,
+                                messages: [{ role: 'user', content: 'Hello' }],
+                                max_tokens: 10
+                            })
+                        });
+                        if (response.ok) {
+                            const data = await response.json();
+                            if (data.choices && data.choices.length > 0) {
+                                showNotification(`${selectedModel} 模型可用`);
+                            } else {
+                                showNotification(`${selectedModel} 模型不可用`);
+                            }
+                        } else {
+                            const errorText = await response.text();
+                            showNotification(`${selectedModel} 模型不可用（错误: ${response.status} - ${errorText}）`);
+                        }
+                    } catch (error) {
+                        console.error('检测模型出错:', error);
+                        showNotification(`检测 ${selectedModel} 失败，请检查网络或接口`);
+                    }
+                });
+            }
+
+            const batchDeleteTokens = document.getElementById('batchDeleteTokens');
+            if (batchDeleteTokens) {
+                batchDeleteTokens.addEventListener('click', async () => {
+                    if (!batchDeleteMode) {
+                        batchDeleteMode = true;
+                        renderTokenDiff(tokenMap);
+                        showNotification('请选择要删除的 Token');
+                    } else {
+                        const selectedTokens = Array.from(document.querySelectorAll('.token-checkbox:checked')).map(cb => cb.value);
+                        if (selectedTokens.length === 0) {
+                            showNotification('请至少选择一个 Token');
+                            return;
+                        }
+                        if (confirm(`确认删除 ${selectedTokens.length} 个 Token?`)) {
+                            try {
+                                const baseUrl = document.getElementById('baseUrl').value;
+                                const successes = [];
+                                const failures = [];
+                                for (const token of selectedTokens) {
+                                    const response = await fetch(`${baseUrl}/manager/api/delete`, {
+                                        method: 'POST',
+                                        headers: { 'Content-Type': 'application/json' },
+                                        body: JSON.stringify({ sso: token })
+                                    });
+                                    if (response.ok) {
+                                        successes.push(token);
+                                    } else {
+                                        failures.push(token);
+                                    }
+                                }
+                                batchDeleteMode = false;
+                                await fetchTokenMap();
+                                if (successes.length > 0 && failures.length === 0) {
+                                    showNotification(`成功删除 ${successes.length} 个 Token`);
+                                } else if (successes.length > 0 && failures.length > 0) {
+                                    showNotification(`成功删除 ${successes.length} 个 Token，失败 ${failures.length} 个`);
+                                } else {
+                                    showNotification('所有 Token 删除失败');
+                                }
+                            } catch (error) {
+                                showNotification('删除 Token 时出错');
+                            }
+                        }
+                    }
+                });
+            }
+
+            const searchInput = document.getElementById('searchInput');
+            if (searchInput) searchInput.addEventListener('input', () => renderTokenDiff(tokenMap));
+
+            const statusFilter = document.getElementById('statusFilter');
+            if (statusFilter) statusFilter.addEventListener('change', () => renderTokenDiff(tokenMap));
+
+            const refreshTokens = document.getElementById('refreshTokens');
+            if (refreshTokens) {
+                refreshTokens.addEventListener('click', async () => {
+                    await fetchTokenMap();
+                    showNotification('Token 列表已刷新');
+                });
+            } else {
+                console.error('Refresh Tokens button not found.');
+            }
+
+            const prevPage = document.getElementById('prevPage');
+            if (prevPage) {
+                prevPage.addEventListener('click', () => {
+                    if (currentPage > 1) {
+                        currentPage--;
+                        renderTokenDiff(tokenMap);
+                    }
+                });
+            }
+
+            const nextPage = document.getElementById('nextPage');
+            if (nextPage) {
+                nextPage.addEventListener('click', () => {
+                    const totalPages = Math.ceil(filterTokensArray(Object.entries(tokenMap)).length / itemsPerPage);
+                    if (currentPage < totalPages) {
+                        currentPage++;
+                        renderTokenDiff(tokenMap);
+                    }
+                });
+            }
+
+            const pageSelect = document.getElementById('pageSelect');
+            if (pageSelect) {
+                pageSelect.addEventListener('change', (e) => {
+                    currentPage = parseInt(e.target.value, 10);
+                    renderTokenDiff(tokenMap);
+                });
+            }
+
+            fetchTokenMap(); // 页面加载时获取 Token
+
+            let timer = setInterval(updateExpiredTokenTimers, 60000);
+            document.addEventListener('visibilitychange', () => {
+                if (document.hidden) {
+                    clearInterval(timer);
+                } else {
+                    timer = setInterval(updateExpiredTokenTimers, 60000);
+                }
+            });
+        });
+
+        function showNotification(message) {
+            const notification = document.getElementById('notification');
+            if (notification) {
+                notification.textContent = message;
+                notification.style.display = 'block';
+                const duration = Math.max(2000, message.length * 100);
+                setTimeout(() => {
+                    notification.style.display = 'none';
+                }, duration);
+            } else {
+                console.warn('Notification element not found.');
+            }
+        }
+    </script>
+</body>
+</html>