🌟 feat(core): 功能：实现token池管理，以改进身份验证处理

- 添加了 TokenPool 类，用于管理身份验证token，并实现负载均衡和容错。
- 引入了从文件加载token、将token标记为成功或失败以及对token执行健康检查的方法。
- 更新了 Settings 类，使其包含token管理配置，例如token文件路径和健康检查间隔。
- 增强了 chat_completions 函数，使其更有效地处理令牌重试和失败。
- 添加了新的 API 端点，用于检查token池的状态并手动触发健康检查。
- 更新了 Docker Compose 配置，删除了已弃用的环境变量。
- 创建了示例令牌配置文件，以指导用户设置令牌。
- 更新了requirements.txt，使其包含用于异步 HTTP 请求的 httpx

.env.example

@@ -11,20 +11,32 @@ AUTH_TOKEN=sk-your-api-key
 # 跳过客户端认证（仅开发环境使用）
 SKIP_AUTH_TOKEN=false
 
-# Z.ai 备用访问令牌（当匿名模式失败时使用）
-# 注意：这是用于访问 Z.ai 服务的令牌，不是客户端认证密钥
-BACKUP_TOKEN=eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ
+# ========== Token池配置 ==========
+# Token失败阈值（失败多少次后标记为不可用）
+TOKEN_FAILURE_THRESHOLD=3
+
+# Token恢复超时时间（秒，失败token在此时间后重新尝试）
+TOKEN_RECOVERY_TIMEOUT=1800
+
+# Token健康检查间隔（秒，定期检查token状态）
+TOKEN_HEALTH_CHECK_INTERVAL=300
+
+# Z.ai 认证token配置（当匿名模式失败时使用）
+#
+# 使用独立的token文件配置
+# 在项目根目录创建 tokens.txt 文件，每行一个token或逗号分隔
+AUTH_TOKENS_FILE=tokens.txt
 
 # ========== 服务器配置 ==========
 # 服务监听端口
 LISTEN_PORT=8080
 
-# 调试日志开关
+# 调试日志
 DEBUG_LOGGING=true
 
-# 匿名模式开关（推荐启用）
+# 匿名用户模式
+# false: 使用认证用户令牌
 # true: 自动从 Z.ai 获取临时访问令牌，避免对话历史共享
-# false: 使用固定令牌 BACKUP_TOKEN
 ANONYMOUS_MODE=true
 
 # Function Call 功能开关

README.md

@@ -1,30 +1,34 @@
 # Z.AI OpenAI API 代理服务
 
 ![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python: 3.8+](https://img.shields.io/badge/python-3.8+-green.svg)
+![Python: 3.9-3.12](https://img.shields.io/badge/python-3.9--3.12-green.svg)
 ![FastAPI](https://img.shields.io/badge/framework-FastAPI-009688.svg)
-![Version: 1.2.0](https://img.shields.io/badge/version-1.2.0-brightgreen.svg)
+![Version: 0.1.0](https://img.shields.io/badge/version-0.1.0-brightgreen.svg)
 
-轻量级 OpenAI API 兼容代理服务，通过 Claude Code Router 接入 Z.AI，支持 GLM-4.5 系列模型的完整功能。
+> 🎯 **项目愿景**：提供完全兼容 OpenAI API 的 Z.AI 代理服务，让用户无需修改现有代码即可接入 GLM-4.5 系列模型。
+
+轻量级、高性能的 OpenAI API 兼容代理服务，通过 Claude Code Router 接入 Z.AI，支持 GLM-4.5 系列模型的完整功能。
 
 ## ✨ 核心特性
 
 - 🔌 **完全兼容 OpenAI API** - 无缝集成现有应用
 - 🤖 **Claude Code 支持** - 通过 Claude Code Router 接入 Claude Code (**CCR 工具请升级到 v1.0.47 以上**)
 - 🚀 **高性能流式响应** - Server-Sent Events (SSE) 支持
-- 🛠️ **增强工具调用** - 改进的 Function Call 实现
+- 🛠️ **增强工具调用** - 改进的 Function Call 实现，支持复杂工具链
 - 🧠 **思考模式支持** - 智能处理模型推理过程
 - 🔍 **搜索模型集成** - GLM-4.5-Search 网络搜索能力
 - 🐳 **Docker 部署** - 一键容器化部署
 - 🛡️ **会话隔离** - 匿名模式保护隐私
 - 🔧 **灵活配置** - 环境变量灵活配置
 - 📊 **多模型映射** - 智能上游模型路由
+- 🔄 **Token 池管理** - 自动轮询、容错恢复、动态更新
+- 🛡️ **错误处理** - 完善的异常捕获和重试机制
 
 ## 🚀 快速开始
 
 ### 环境要求
 
-- Python 3.8+
+- Python 3.9-3.12
 - pip 或 uv (推荐)
 
 ### 安装运行
@@ -44,7 +48,9 @@ pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
 python main.py
 ```
 
-服务启动后访问：http://localhost:8080/docs
+>  服务启动后访问接口文档：http://localhost:8080/docs  
+> 💡 **提示**：默认端口为 8080，可通过环境变量 `LISTEN_PORT` 修改  
+> ⚠️ **注意**：请勿将 `AUTH_TOKEN` 泄露给其他人，请使用 `AUTH_TOKENS` 配置多个认证令牌  
 
 ### 基础使用
 
@@ -145,18 +151,65 @@ for chunk in response:
 | `API_ENDPOINT`        | `https://chat.z.ai/api/chat/completions`  | 上游 API 地址          |
 | `LISTEN_PORT`         | `8080`                                    | 服务监听端口           |
 | `DEBUG_LOGGING`       | `true`                                    | 调试日志开关           |
-| `THINKING_PROCESSING` | `think`                                   | 思考内容处理策略       |
-| `ANONYMOUS_MODE`      | `true`                                    | 匿名模式开关           |
+| `ANONYMOUS_MODE`      | `true`                                    | 匿名用户模式开关           |
 | `TOOL_SUPPORT`        | `true`                                    | Function Call 功能开关 |
 | `SKIP_AUTH_TOKEN`     | `false`                                   | 跳过认证令牌验证       |
 | `SCAN_LIMIT`          | `200000`                                  | 扫描限制               |
-| `BACKUP_TOKEN`        | `eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9...` | Z.ai 固定访问令牌      |
+| `AUTH_TOKENS_FILE`  | `tokens.txt`                              | 认证token文件路径 |
+
+> 💡 详细配置请查看 `.env.example` 文件  
+
+## 🔄 Token池机制
+
+### 功能特性
+
+- **负载均衡**：轮询使用多个auth token，分散请求负载
+- **自动容错**：token失败时自动切换到下一个可用token
+- **健康监控**：基于Z.AI API的role字段精确验证token类型
+- **自动恢复**：失败token在超时后自动重新尝试
+- **动态管理**：支持运行时更新token池
+- **智能去重**：自动检测和去除重复token
+- **类型验证**：只接受认证用户token (role: "user")，拒绝匿名token (role: "guest")
+
+### Token配置方式
 
-### 思考内容处理策略
+创建 `tokens.txt` 文件，支持两种格式：
+
+**格式1：每行一个token**
+```txt
+# 认证token配置文件
+# 支持注释行（以#开头）和空行
+# 只添加认证用户token (role: "user")
+
+eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItMTIzIn0.signature1
+eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItNDU2In0.signature2
+eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItNzg5In0.signature3
+```
+
+**格式2：逗号分隔**
+```txt
+# 认证token配置文件
+eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItMTIzIn0.signature1,
+eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItNDU2In0.signature2,
+eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItNzg5In0.signature3
+```
 
-- `think` - 转换为 `<thinking>` 标签（OpenAI 兼容）
-- `strip` - 移除思考内容
-- `raw` - 保留原始格式
+## 监控API
+
+```bash
+# 查看token池状态
+curl http://localhost:8080/v1/token-pool/status
+
+# 手动健康检查
+curl -X POST http://localhost:8080/v1/token-pool/health-check
+
+# 动态更新token池
+curl -X POST http://localhost:8080/v1/token-pool/update \
+  -H "Content-Type: application/json" \
+  -d '["new_token1", "new_token2"]'
+```
+
+详细文档请参考：[Token池功能说明](TOKEN_POOL_README.md)
 
 ## 🎯 使用场景
 
@@ -203,6 +256,12 @@ if response.choices[0].message.tool_calls:
 **Q: 如何获取 AUTH_TOKEN？**
 A: `AUTH_TOKEN` 为自己自定义的 api key，在环境变量中配置，需要保证客户端与服务端一致。
 
+**Q: 遇到 "Illegal header value b'Bearer '" 错误怎么办？**
+A: 这通常是因为 Token 获取失败导致的。请检查：
+- 匿名模式是否正确配置（`ANONYMOUS_MODE=true`）
+- Token 文件是否存在且格式正确（`tokens.txt`）
+- 网络连接是否正常，能否访问 Z.AI API
+
 **Q: 如何通过 Claude Code 使用本服务？**
 
 A: 创建 [zai.js](https://gist.githubusercontent.com/musistudio/b35402d6f9c95c64269c7666b8405348/raw/f108d66fa050f308387938f149a2b14a295d29e9/gistfile1.txt) 这个 ccr 插件放在`./.claude-code-router/plugins`目录下，配置 `./.claude-code-router/config.json` 指向本服务地址，使用 `AUTH_TOKEN` 进行认证。
@@ -287,32 +346,25 @@ A: 通过环境变量配置，推荐使用 `.env` 文件。
 
 要使用完整的多模态功能，需要获取正式的 Z.ai API Token：
 
-### 方式 1: 通过 Z.ai 网站
-
-1. 访问 [Z.ai 官网](https://chat.z.ai)
-2. 注册账户并登录，进入 [Z.ai API Keys](https://z.ai/manage-apikey/apikey-list) 设置页面，在该页面设置 _**个人 API Token**_
-3. 将 Token 放置在 `BACKUP_TOKEN` 环境变量中
-
-### 方式 2: 浏览器开发者工具（临时方案）
-
 1. 打开 [Z.ai 聊天界面](https://chat.z.ai)
 2. 按 F12 打开开发者工具
 3. 切换到 "Application" 或 "存储" 标签
 4. 查看 Local Storage 中的认证 token
 5. 复制 token 值设置为环境变量
 
-> ⚠️ **注意**: 方式 2 获取的 token 可能有时效性，建议使用方式 1 获取长期有效的 API Token。  
-> ❗ **重要提示**: 多模态模型需要**官方 Z.ai API 非匿名 Token**，匿名 token 不支持多媒体处理。
+> ❗ **重要提示**: 获取的 token 可能有时效性，多模态模型需要**官方 Z.ai API 非匿名 Token**，匿名 token 不支持多媒体处理  
 
 ## 🛠️ 技术栈
 
 | 组件            | 技术                                                                              | 版本    | 说明                                       |
 | --------------- | --------------------------------------------------------------------------------- | ------- | ------------------------------------------ |
-| **Web 框架**    | [FastAPI](https://fastapi.tiangolo.com/)                                          | 0.104.1 | 高性能异步 Web 框架，支持自动 API 文档生成 |
+| **Web 框架**    | [FastAPI](https://fastapi.tiangolo.com/)                                          | 0.116.1 | 高性能异步 Web 框架，支持自动 API 文档生成 |
 | **ASGI 服务器** | [Granian](https://github.com/emmett-framework/granian)                            | 2.5.2   | 基于 Rust 的高性能 ASGI 服务器，支持热重载 |
-| **HTTP 客户端** | [Requests](https://requests.readthedocs.io/)                                      | 2.32.5  | 简洁易用的 HTTP 库，用于上游 API 调用      |
+| **HTTP 客户端** | [HTTPX](https://www.python-httpx.org/) / [Requests](https://requests.readthedocs.io/) | 0.27.0 / 2.32.5 | 异步/同步 HTTP 库，用于上游 API 调用      |
 | **数据验证**    | [Pydantic](https://pydantic.dev/)                                                 | 2.11.7  | 类型安全的数据验证与序列化                 |
 | **配置管理**    | [Pydantic Settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) | 2.10.1  | 基于 Pydantic 的配置管理                   |
+| **日志系统**    | [Loguru](https://loguru.readthedocs.io/)                                          | 0.7.3   | 高性能结构化日志库                         |
+| **用户代理**    | [Fake UserAgent](https://pypi.org/project/fake-useragent/)                        | 2.2.0   | 动态用户代理生成                           |
 
 ## 🏗️ 技术架构
 
@@ -338,27 +390,27 @@ A: 通过环境变量配置，推荐使用 `.env` 文件。
 
 ```
 z.ai2api_python/
-├── app/
-│   ├── core/
-│   │   ├── __init__.py
-│   │   ├── config.py          # 配置管理
-│   │   ├── openai.py          # OpenAI API 实现
-│   │   └── response_handlers.py  # 响应处理器
-│   ├── models/
-│   │   ├── __init__.py
-│   │   └── schemas.py         # Pydantic 模型定义
-│   ├── utils/
-│   │   ├── __init__.py
-│   │   ├── helpers.py         # 辅助函数
-│   │   ├── tools.py           # 增强工具调���处理
-│   │   └── sse_parser.py      # SSE 流式解析器
-│   └── __init__.py
-├── tests/                     # 单元测试
-├── deploy/                    # Docker 部署配置
-├── main.py                    # FastAPI 应用入口
-├── requirements.txt           # Python 依赖
-├── .env.example              # 环境变量示例
-└── README.md                  # 项目文档
+├── app/                          # 主应用模块
+│   ├── core/                     # 核心模块
+│   │   ├── config.py            # 配置管理（Pydantic Settings）
+│   │   ├── openai.py            # OpenAI API 兼容层
+│   │   └── zai_transformer.py   # Z.AI 请求/响应转换器
+│   ├── models/                   # 数据模型
+│   │   └── schemas.py           # Pydantic 数据模型
+│   └── utils/                    # 工具模块
+│       ├── logger.py            # Loguru 日志系统
+│       ├── reload_config.py     # 热重载配置
+│       ├── sse_tool_handler.py  # SSE 工具调用处理器
+│       └── token_pool.py        # Token 池管理
+├── tests/                        # 测试文件
+├── deploy/                       # 部署配置
+│   ├── Dockerfile               # Docker 镜像构建
+│   └── docker-compose.yml       # 容器编排
+├── main.py                       # FastAPI 应用入口
+├── requirements.txt              # 依赖清单
+├── pyproject.toml               # 项目配置
+├── tokens.txt.example           # Token 配置文件
+└── .env.example                 # 环境变量示例
 ```
 
 ## 🤝 贡献指南

app/core/config.py

@@ -2,8 +2,9 @@
 # -*- coding: utf-8 -*-
 
 import os
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 from pydantic_settings import BaseSettings
+from app.utils.logger import logger
 
 
 class Settings(BaseSettings):
@@ -12,10 +13,102 @@ class Settings(BaseSettings):
     # API Configuration
     API_ENDPOINT: str = os.getenv("API_ENDPOINT", "https://chat.z.ai/api/chat/completions")
     AUTH_TOKEN: str = os.getenv("AUTH_TOKEN", "sk-your-api-key")
-    BACKUP_TOKEN: str = os.getenv(
-        "BACKUP_TOKEN",
-        "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ",
-    )
+
+    # 认证token文件路径
+    AUTH_TOKENS_FILE: str = os.getenv("AUTH_TOKENS_FILE", "tokens.txt")
+
+    # Token池配置
+    TOKEN_HEALTH_CHECK_INTERVAL: int = int(os.getenv("TOKEN_HEALTH_CHECK_INTERVAL", "300"))  # 5分钟
+    TOKEN_FAILURE_THRESHOLD: int = int(os.getenv("TOKEN_FAILURE_THRESHOLD", "3"))  # 失败3次后标记为不可用
+    TOKEN_RECOVERY_TIMEOUT: int = int(os.getenv("TOKEN_RECOVERY_TIMEOUT", "1800"))  # 30分钟后重试失败的token
+
+    def _load_tokens_from_file(self, file_path: str) -> List[str]:
+        """
+        从文件加载token列表
+
+        支持两种格式：
+        1. 每行一个token（原格式）
+        2. 逗号分隔的token（新格式）
+
+        处理规则：
+        - 跳过空行和注释行（以#开头）
+        - 自动检测并处理逗号分隔格式
+        - 去除空格和换行符
+        """
+        tokens = []
+        try:
+            if os.path.exists(file_path):
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read().strip()
+
+                    if not content:
+                        logger.debug(f"📄 Token文件为空: {file_path}")
+                        return tokens
+
+                    # 检查是否包含逗号分隔格式
+                    if ',' in content:
+                        # 逗号分隔格式：将整个文件内容按逗号分割
+                        logger.debug(f"📄 检测到逗号分隔格式: {file_path}")
+
+                        # 移除注释行后再分割
+                        lines = content.split('\n')
+                        clean_content = []
+                        for line in lines:
+                            line = line.strip()
+                            if line and not line.startswith('#'):
+                                clean_content.append(line)
+
+                        # 合并所有非注释内容，然后按逗号分割
+                        merged_content = ' '.join(clean_content)
+                        raw_tokens = merged_content.split(',')
+
+                        for token in raw_tokens:
+                            token = token.strip()
+                            if token:  # 跳过空token
+                                tokens.append(token)
+                    else:
+                        # 每行一个token格式（原格式）
+                        logger.debug(f"📄 使用每行一个token格式: {file_path}")
+                        for line in content.split('\n'):
+                            line = line.strip()
+                            # 跳过空行和注释行
+                            if line and not line.startswith('#'):
+                                tokens.append(line)
+
+                logger.info(f"📄 从文件加载了 {len(tokens)} 个token: {file_path}")
+            else:
+                logger.debug(f"📄 Token文件不存在: {file_path}")
+        except Exception as e:
+            logger.error(f"❌ 读取token文件失败 {file_path}: {e}")
+        return tokens
+
+    @property
+    def auth_token_list(self) -> List[str]:
+        """
+        解析认证token列表
+
+        仅从AUTH_TOKENS_FILE指定的文件加载token
+        """
+        # 从文件加载token
+        tokens = self._load_tokens_from_file(self.AUTH_TOKENS_FILE)
+
+        # 去重，保持顺序
+        if tokens:
+            seen = set()
+            unique_tokens = []
+            for token in tokens:
+                if token not in seen:
+                    unique_tokens.append(token)
+                    seen.add(token)
+
+            # 记录去重信息
+            duplicate_count = len(tokens) - len(unique_tokens)
+            if duplicate_count > 0:
+                logger.warning(f"⚠️ 检测到 {duplicate_count} 个重复token，已自动去重")
+
+            return unique_tokens
+
+        return []
 
     # Model Configuration
     PRIMARY_MODEL: str = os.getenv("PRIMARY_MODEL", "GLM-4.5")

app/core/openai.py

@@ -15,6 +15,7 @@ from app.models.schemas import OpenAIRequest, Message, ModelsResponse, Model
 from app.utils.logger import get_logger
 from app.core.zai_transformer import ZAITransformer, generate_uuid
 from app.utils.sse_tool_handler import SSEToolHandler
+from app.utils.token_pool import get_token_pool
 
 logger = get_logger()
 
@@ -90,6 +91,7 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
             """流式响应生成器（包含重试机制）"""
             retry_count = 0
             last_error = None
+            current_token = transformed.get("token", "")  # 获取当前使用的token
 
             while retry_count <= settings.MAX_RETRIES:
                 try:
@@ -102,12 +104,19 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                         )
                         await asyncio.sleep(delay)
 
-                        # 在匿名模式下，重新获取令牌
-                        if settings.ANONYMOUS_MODE:
-                            logger.info("🔑 重新获取访客令牌用于重试...")
-                            new_token = await transformer.get_token()
-                            transformed["config"]["headers"]["Authorization"] = f"Bearer {new_token}"
-                            logger.debug(f"  新令牌: {new_token[:20] if new_token else 'None'}...")
+                        # 标记前一个token失败（如果不是匿名模式）
+                        if current_token and not settings.ANONYMOUS_MODE:
+                            transformer.mark_token_failure(current_token, Exception(f"Retry {retry_count}: {last_error}"))
+
+                        # 重新获取令牌
+                        logger.info("🔑 重新获取令牌用于重试...")
+                        new_token = await transformer.get_token()
+                        if not new_token:
+                            logger.error("❌ 重试时无法获取有效的认证令牌")
+                            raise Exception("重试时无法获取有效的认证令牌")
+                        transformed["config"]["headers"]["Authorization"] = f"Bearer {new_token}"
+                        current_token = new_token
+                        logger.debug(f"  新令牌: {new_token[:20] if new_token else 'None'}...")
 
                     async with httpx.AsyncClient(timeout=60.0) as client:
                         # 发送请求到上游
@@ -173,6 +182,10 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                             if retry_count > 0:
                                 logger.info(f"✨ 第 {retry_count} 次重试成功")
 
+                            # 标记token使用成功（如果不是匿名模式）
+                            if current_token and not settings.ANONYMOUS_MODE:
+                                transformer.mark_token_success(current_token)
+
                             # 初始化工具处理器（如果需要）
                             has_tools = transformed["body"].get("tools") is not None
                             tool_handler = None
@@ -443,6 +456,10 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
                     import traceback
                     logger.error(traceback.format_exc())
 
+                    # 标记token失败（如果不是匿名模式）
+                    if current_token and not settings.ANONYMOUS_MODE:
+                        transformer.mark_token_failure(current_token, e)
+
                     # 检查是否还可以重试
                     retry_count += 1
                     last_error = str(e)
@@ -494,3 +511,113 @@ async def chat_completions(request: OpenAIRequest, authorization: str = Header(.
 
         logger.error(f"错误堆栈: {traceback.format_exc()}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+@router.get("/v1/token-pool/status")
+async def get_token_pool_status():
+    """获取token池状态信息"""
+    try:
+        token_pool = get_token_pool()
+        if not token_pool:
+            return {
+                "status": "disabled",
+                "message": "Token池未初始化，当前仅使用匿名模式",
+                "anonymous_mode": settings.ANONYMOUS_MODE,
+                "auth_tokens_file": settings.AUTH_TOKENS_FILE,
+                "auth_tokens_configured": len(settings.auth_token_list) > 0
+            }
+
+        pool_status = token_pool.get_pool_status()
+        return {
+            "status": "active",
+            "pool_info": pool_status,
+            "config": {
+                "anonymous_mode": settings.ANONYMOUS_MODE,
+                "failure_threshold": settings.TOKEN_FAILURE_THRESHOLD,
+                "recovery_timeout": settings.TOKEN_RECOVERY_TIMEOUT,
+                "health_check_interval": settings.TOKEN_HEALTH_CHECK_INTERVAL
+            }
+        }
+    except Exception as e:
+        logger.error(f"获取token池状态失败: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get token pool status: {str(e)}")
+
+
+@router.post("/v1/token-pool/health-check")
+async def trigger_health_check():
+    """手动触发token池健康检查"""
+    try:
+        token_pool = get_token_pool()
+        if not token_pool:
+            raise HTTPException(status_code=404, detail="Token池未初始化")
+
+        # 记录开始时间
+        import time
+        start_time = time.time()
+
+        logger.info("🔍 API触发Token池健康检查...")
+        await token_pool.health_check_all()
+
+        # 计算耗时
+        duration = time.time() - start_time
+
+        pool_status = token_pool.get_pool_status()
+
+        # 统计健康检查结果 - 基于实际的健康状态
+        total_tokens = pool_status['total_tokens']
+        healthy_tokens = sum(1 for token_info in pool_status['tokens'] if token_info['is_healthy'])
+        unhealthy_tokens = total_tokens - healthy_tokens
+
+        # 构建响应
+        response = {
+            "status": "completed",
+            "message": f"健康检查已完成，耗时 {duration:.2f} 秒",
+            "summary": {
+                "total_tokens": total_tokens,
+                "healthy_tokens": healthy_tokens,
+                "unhealthy_tokens": unhealthy_tokens,
+                "health_rate": f"{(healthy_tokens/total_tokens*100):.1f}%" if total_tokens > 0 else "0%",
+                "duration_seconds": round(duration, 2)
+            },
+            "pool_info": pool_status
+        }
+
+        # 添加建议
+        if unhealthy_tokens > 0:
+            response["recommendations"] = []
+            if unhealthy_tokens == total_tokens:
+                response["recommendations"].append("所有token都不健康，请检查token配置和网络连接")
+            else:
+                response["recommendations"].append(f"有 {unhealthy_tokens} 个token不健康，建议检查这些token的有效性")
+
+        logger.info(f"✅ API健康检查完成: {healthy_tokens}/{total_tokens} 个token健康")
+        return response
+    except Exception as e:
+        logger.error(f"健康检查失败: {e}")
+        raise HTTPException(status_code=500, detail=f"Health check failed: {str(e)}")
+
+
+@router.post("/v1/token-pool/update")
+async def update_token_pool(tokens: List[str]):
+    """动态更新token池"""
+    try:
+        from app.utils.token_pool import update_token_pool
+
+        # 过滤空token
+        valid_tokens = [token.strip() for token in tokens if token.strip()]
+        if not valid_tokens:
+            raise HTTPException(status_code=400, detail="至少需要提供一个有效的token")
+
+        update_token_pool(valid_tokens)
+
+        token_pool = get_token_pool()
+        pool_status = token_pool.get_pool_status() if token_pool else None
+
+        return {
+            "status": "updated",
+            "message": f"Token池已更新，共 {len(valid_tokens)} 个token",
+            "pool_info": pool_status
+        }
+    except Exception as e:
+        logger.error(f"更新token池失败: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to update token pool: {str(e)}")

app/core/zai_transformer.py

@@ -14,6 +14,7 @@ from fake_useragent import UserAgent
 
 from app.core.config import settings
 from app.utils.logger import get_logger
+from app.utils.token_pool import get_token_pool, initialize_token_pool
 
 logger = get_logger()
 
@@ -116,9 +117,17 @@ def get_auth_token_sync() -> str:
         except Exception as e:
             logger.warning(f"获取访客令牌失败: {e}")
 
-    # 使用备份令牌
-    logger.debug("使用备份令牌")
-    return settings.BACKUP_TOKEN
+    # 使用token池获取备份令牌
+    token_pool = get_token_pool()
+    if token_pool:
+        token = token_pool.get_next_token()
+        if token:
+            logger.debug(f"从token池获取令牌: {token[:20]}...")
+            return token
+
+    # 没有可用的token
+    logger.warning("⚠️ 没有可用的备份token")
+    return ""
 
 
 class ZAITransformer:
@@ -156,9 +165,29 @@ class ZAITransformer:
             except Exception as e:
                 logger.warning(f"异步获取访客令牌失败: {e}")
 
-        # 使用备份令牌
-        logger.debug("使用备份令牌")
-        return settings.BACKUP_TOKEN
+        # 使用token池获取备份令牌
+        token_pool = get_token_pool()
+        if token_pool:
+            token = token_pool.get_next_token()
+            if token:
+                logger.debug(f"从token池获取令牌: {token[:20]}...")
+                return token
+
+        # 没有可用的token
+        logger.warning("⚠️ 没有可用的备份token")
+        return ""
+
+    def mark_token_success(self, token: str):
+        """标记token使用成功"""
+        token_pool = get_token_pool()
+        if token_pool:
+            token_pool.mark_token_success(token)
+
+    def mark_token_failure(self, token: str, error: Exception = None):
+        """标记token使用失败"""
+        token_pool = get_token_pool()
+        if token_pool:
+            token_pool.mark_token_failure(token, error)
 
     async def transform_request_in(self, request: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -171,6 +200,11 @@ class ZAITransformer:
         token = await self.get_token()
         logger.debug(f"  使用令牌: {token[:20] if token else 'None'}...")
 
+        # 检查token是否有效
+        if not token:
+            logger.error("❌ 无法获取有效的认证令牌")
+            raise Exception("无法获取有效的认证令牌，请检查匿名模式配置或token池配置")
+
         # 确定请求的模型特性
         requested_model = request.get("model", settings.PRIMARY_MODEL)
         is_thinking = requested_model == settings.THINKING_MODEL or request.get("reasoning", False)
@@ -308,8 +342,8 @@ class ZAITransformer:
         logger.debug(f"  目标URL: {config['url']}")
         logger.debug(f"  请求头数量: {len(config['headers'])}")
         logger.debug(f"  消息数: {len(body['messages'])}, 工具数: {len(body.get('tools', [])) if body.get('tools') else 0}")
-        
-        return {"body": body, "config": config}
+
+        return {"body": body, "config": config, "token": token}
 
     async def transform_response_out(
         self, response_stream: Generator, context: Dict[str, Any]

app/utils/token_pool.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Token池管理器
+实现AUTH_TOKEN的轮询机制，提供负载均衡和容错功能
+"""
+
+import asyncio
+import time
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, field
+from threading import Lock
+import httpx
+import requests
+
+from app.utils.logger import logger
+
+
+@dataclass
+class TokenStatus:
+    """Token状态信息"""
+    token: str
+    is_available: bool = True
+    failure_count: int = 0
+    last_failure_time: float = 0.0
+    last_success_time: float = 0.0
+    total_requests: int = 0
+    successful_requests: int = 0
+    token_type: str = "unknown"  # "user", "guest", "unknown"
+    
+    @property
+    def success_rate(self) -> float:
+        """成功率"""
+        if self.total_requests == 0:
+            return 1.0
+        return self.successful_requests / self.total_requests
+    
+    @property
+    def is_healthy(self) -> bool:
+        """
+        是否健康
+
+        健康的定义：
+        1. 必须是认证用户token (token_type = "user")
+        2. 当前可用 (is_available = True)
+        3. 成功率 >= 50% 或者总请求数 <= 3（新token容错）
+
+        注意：guest token不应该在AUTH_TOKENS中
+        """
+        # guest token永远不健康
+        if self.token_type == "guest":
+            return False
+
+        # 未知类型token不健康
+        if self.token_type != "user":
+            return False
+
+        # 不可用的token不健康
+        if not self.is_available:
+            return False
+
+        # 对于认证用户token，基于成功率判断
+        # 新token或请求数很少时，给予容错
+        if self.total_requests <= 3:
+            return self.failure_count == 0
+
+        # 基于成功率判断健康状态
+        return self.success_rate >= 0.5
+
+
+class TokenPool:
+    """Token池管理器"""
+    
+    def __init__(self, tokens: List[str], failure_threshold: int = 3, recovery_timeout: int = 1800):
+        """
+        初始化Token池
+        
+        Args:
+            tokens: token列表
+            failure_threshold: 失败阈值，超过此次数将标记为不可用
+            recovery_timeout: 恢复超时时间（秒），失败token在此时间后重新尝试
+        """
+        self.failure_threshold = failure_threshold
+        self.recovery_timeout = recovery_timeout
+        self._lock = Lock()
+        self._current_index = 0
+        
+        # 初始化token状态
+        self.token_statuses: Dict[str, TokenStatus] = {}
+        original_count = len(tokens)
+        unique_tokens = []
+
+        # 去重处理
+        for token in tokens:
+            if token and token not in self.token_statuses:  # 过滤空token和重复token
+                self.token_statuses[token] = TokenStatus(token=token)
+                unique_tokens.append(token)
+
+        duplicate_count = original_count - len(unique_tokens)
+        if duplicate_count > 0:
+            logger.warning(f"⚠️ 检测到 {duplicate_count} 个重复token，已自动去重")
+
+        if not self.token_statuses:
+            logger.warning("⚠️ Token池为空，将依赖匿名模式")
+        else:
+            logger.info(f"🔧 初始化Token池，共 {len(self.token_statuses)} 个token")
+    
+    def get_next_token(self) -> Optional[str]:
+        """
+        获取下一个可用的token（轮询算法）
+        
+        Returns:
+            可用的token，如果没有可用token则返回None
+        """
+        with self._lock:
+            if not self.token_statuses:
+                return None
+            
+            available_tokens = self._get_available_tokens()
+            if not available_tokens:
+                # 尝试恢复过期的失败token
+                self._try_recover_failed_tokens()
+                available_tokens = self._get_available_tokens()
+                
+                if not available_tokens:
+                    logger.warning("⚠️ 没有可用的token")
+                    return None
+            
+            # 轮询选择token
+            token = available_tokens[self._current_index % len(available_tokens)]
+            self._current_index = (self._current_index + 1) % len(available_tokens)
+
+            return token
+    
+    def _get_available_tokens(self) -> List[str]:
+        """
+        获取当前可用的认证用户token列表
+
+        只返回满足以下条件的token：
+        1. is_available = True (可用状态)
+        2. token_type = "user" (认证用户token)
+
+        这确保轮询机制只会选择有效的认证用户token，跳过匿名用户token
+        """
+        available_user_tokens = [
+            status.token for status in self.token_statuses.values()
+            if status.is_available and status.token_type == "user"
+        ]
+
+        # 如果没有可用的认证用户token
+        if not available_user_tokens and self.token_statuses:
+            guest_tokens = [
+                status.token for status in self.token_statuses.values()
+                if status.token_type == "guest"
+            ]
+            if guest_tokens:
+                logger.warning(f"⚠️ 检测到 {len(guest_tokens)} 个匿名用户token，轮询机制将跳过这些token")
+
+        return available_user_tokens
+    
+    def _try_recover_failed_tokens(self):
+        """尝试恢复失败的token"""
+        current_time = time.time()
+        recovered_count = 0
+        
+        for status in self.token_statuses.values():
+            if (not status.is_available and 
+                current_time - status.last_failure_time > self.recovery_timeout):
+                status.is_available = True
+                status.failure_count = 0
+                recovered_count += 1
+                logger.info(f"🔄 恢复失败token: {status.token[:20]}...")
+        
+        if recovered_count > 0:
+            logger.info(f"✅ 恢复了 {recovered_count} 个失败的token")
+    
+    def mark_token_success(self, token: str):
+        """标记token使用成功"""
+        with self._lock:
+            if token in self.token_statuses:
+                status = self.token_statuses[token]
+                status.total_requests += 1
+                status.successful_requests += 1
+                status.last_success_time = time.time()
+                status.failure_count = 0  # 重置失败计数
+                
+                if not status.is_available:
+                    status.is_available = True
+                    logger.info(f"✅ Token恢复可用: {token[:20]}...")
+    
+    def mark_token_failure(self, token: str, error: Exception = None):
+        """标记token使用失败"""
+        with self._lock:
+            if token in self.token_statuses:
+                status = self.token_statuses[token]
+                status.total_requests += 1
+                status.failure_count += 1
+                status.last_failure_time = time.time()
+                
+                if status.failure_count >= self.failure_threshold:
+                    status.is_available = False
+                    logger.warning(f"🚫 Token已禁用: {token[:20]}... (失败 {status.failure_count} 次)")
+    
+    def get_pool_status(self) -> Dict:
+        """获取token池状态信息"""
+        with self._lock:
+            available_count = len(self._get_available_tokens())
+            total_count = len(self.token_statuses)
+
+            # 统计健康token数量
+            healthy_count = sum(1 for status in self.token_statuses.values() if status.is_healthy)
+
+            status_info = {
+                "total_tokens": total_count,
+                "available_tokens": available_count,
+                "unavailable_tokens": total_count - available_count,
+                "healthy_tokens": healthy_count,
+                "unhealthy_tokens": total_count - healthy_count,
+                "current_index": self._current_index,
+                "tokens": []
+            }
+
+            for token, status in self.token_statuses.items():
+                status_info["tokens"].append({
+                    "token": f"{token[:10]}...{token[-10:]}",
+                    "token_type": status.token_type,
+                    "is_available": status.is_available,
+                    "failure_count": status.failure_count,
+                    "success_count": status.successful_requests,
+                    "success_rate": f"{status.success_rate:.2%}",
+                    "total_requests": status.total_requests,
+                    "is_healthy": status.is_healthy,
+                    "last_failure_time": status.last_failure_time,
+                    "last_success_time": status.last_success_time
+                })
+
+            return status_info
+    
+    def update_tokens(self, new_tokens: List[str]):
+        """动态更新token列表"""
+        with self._lock:
+            # 保留现有token的状态信息
+            old_statuses = self.token_statuses.copy()
+            self.token_statuses.clear()
+
+            original_count = len(new_tokens)
+            unique_tokens = []
+
+            # 去重并添加新token，保留已存在token的状态
+            for token in new_tokens:
+                if token and token not in self.token_statuses:  # 过滤空token和重复token
+                    if token in old_statuses:
+                        self.token_statuses[token] = old_statuses[token]
+                    else:
+                        self.token_statuses[token] = TokenStatus(token=token)
+                    unique_tokens.append(token)
+
+            # 记录去重信息
+            duplicate_count = original_count - len(unique_tokens)
+            if duplicate_count > 0:
+                logger.warning(f"⚠️ 更新时检测到 {duplicate_count} 个重复token，已自动去重")
+
+            # 重置索引
+            self._current_index = 0
+
+            logger.info(f"🔄 更新Token池，共 {len(self.token_statuses)} 个token")
+    
+    async def health_check_token(self, token: str, auth_url: str = "https://chat.z.ai/api/v1/auths/") -> bool:
+        """
+        异步健康检查单个token
+
+        使用Z.AI认证API验证token的有效性，通过检查响应内容判断token是否有效
+
+        Args:
+            token: 要检查的token
+            auth_url: 认证URL
+
+        Returns:
+            token是否健康
+        """
+        try:
+            # 构建完整的请求头，模拟真实浏览器请求
+            headers = {
+                "Accept": "*/*",
+                "Accept-Language": "zh-CN,zh;q=0.9",
+                "Authorization": f"Bearer {token}",
+                "Connection": "keep-alive",
+                "Content-Type": "application/json",
+                "DNT": "1",
+                "Referer": "https://chat.z.ai/",
+                "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/140.0.0.0 Safari/537.36",
+                "sec-ch-ua": '"Chromium";v="140", "Not=A?Brand";v="24", "Google Chrome";v="140"',
+                "sec-ch-ua-mobile": "?0",
+                "sec-ch-ua-platform": "Windows"
+            }
+
+            async with httpx.AsyncClient(timeout=15.0) as client:
+                response = await client.get(auth_url, headers=headers)
+
+                # 验证token有效性并获取类型
+                token_type, is_healthy = self._validate_token_response(response)
+
+                # 更新token类型
+                if token in self.token_statuses:
+                    self.token_statuses[token].token_type = token_type
+
+                if is_healthy:
+                    self.mark_token_success(token)
+                else:
+                    # 简化错误信息，只记录关键错误类型
+                    if token_type == "guest":
+                        error_msg = "匿名用户token"
+                    elif response.status_code != 200:
+                        error_msg = f"HTTP {response.status_code}"
+                    else:
+                        error_msg = "认证失败"
+
+                    self.mark_token_failure(token, Exception(error_msg))
+
+                return is_healthy
+
+        except (httpx.TimeoutException, httpx.ConnectError, Exception) as e:
+            self.mark_token_failure(token, e)
+            return False
+
+    def _validate_token_response(self, response: httpx.Response) -> bool:
+        """
+        基于Z.AI API响应中的role字段验证token类型
+
+        验证规则：
+        - role: "user" = 认证用户token（有效，可用于AUTH_TOKENS）
+        - role: "guest" = 匿名用户token（无效，不应在AUTH_TOKENS中）
+        - 无role字段或其他值 = 无效token
+
+        Args:
+            response: HTTP响应对象
+
+        Returns:
+            token是否为有效的认证用户token
+        """
+        # 首先检查HTTP状态码
+        if response.status_code != 200:
+            return ("unknown", False)
+
+        try:
+            # 尝试解析JSON响应
+            response_data = response.json()
+
+            if not isinstance(response_data, dict):
+                return ("unknown", False)
+
+            # 检查是否包含错误信息
+            if "error" in response_data:
+                return ("unknown", False)
+
+            if "message" in response_data and "error" in response_data.get("message", "").lower():
+                return ("unknown", False)
+
+            # 核心验证：检查role字段
+            role = response_data.get("role")
+
+            if role == "user":
+                return ("user", True)
+            elif role == "guest":
+            
+                if not hasattr(self, '_guest_token_warned'):
+                    logger.warning("⚠️ 检测到匿名用户token，建议仅在AUTH_TOKENS中配置认证用户token")
+                    self._guest_token_warned = True
+                return ("guest", False)
+            else:
+                return ("unknown", False)
+
+        except (ValueError, Exception):
+            return ("unknown", False)
+
+    async def health_check_all(self, auth_url: str = "https://chat.z.ai/api/v1/auths/"):
+        """异步健康检查所有token"""
+        if not self.token_statuses:
+            logger.warning("⚠️ Token池为空，跳过健康检查")
+            return
+
+        total_tokens = len(self.token_statuses)
+        logger.info(f"🔍 开始Token池健康检查... (共 {total_tokens} 个token)")
+
+        # 并发执行所有token的健康检查
+        tasks = []
+        token_list = list(self.token_statuses.keys())
+
+        for token in token_list:
+            task = self.health_check_token(token, auth_url)
+            tasks.append(task)
+
+        # 执行并收集结果
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # 统计结果
+        healthy_count = 0
+        failed_count = 0
+        exception_count = 0
+
+        for i, result in enumerate(results):
+            if result is True:
+                healthy_count += 1
+            elif result is False:
+                failed_count += 1
+            else:
+                # 异常情况
+                exception_count += 1
+                token = token_list[i]
+                logger.error(f"💥 Token {token[:20]}... 健康检查异常: {result}")
+
+        health_rate = (healthy_count / total_tokens) * 100 if total_tokens > 0 else 0
+
+        if healthy_count == 0 and total_tokens > 0:
+            logger.warning(f"⚠️ 健康检查完成: 0/{total_tokens} 个token健康 - 请检查token配置")
+        elif failed_count > 0:
+            logger.warning(f"⚠️ 健康检查完成: {healthy_count}/{total_tokens} 个token健康 ({health_rate:.1f}%)")
+        else:
+            logger.info(f"✅ 健康检查完成: {healthy_count}/{total_tokens} 个token健康")
+
+        if exception_count > 0:
+            logger.error(f"💥 {exception_count} 个token检查异常")
+
+
+# 全局token池实例
+_token_pool: Optional[TokenPool] = None
+_pool_lock = Lock()
+
+
+def get_token_pool() -> Optional[TokenPool]:
+    """获取全局token池实例"""
+    return _token_pool
+
+
+def initialize_token_pool(tokens: List[str], failure_threshold: int = 3, recovery_timeout: int = 1800) -> TokenPool:
+    """初始化全局token池"""
+    global _token_pool
+    with _pool_lock:
+        _token_pool = TokenPool(tokens, failure_threshold, recovery_timeout)
+        return _token_pool
+
+
+def update_token_pool(tokens: List[str]):
+    """更新全局token池"""
+    global _token_pool
+    with _pool_lock:
+        if _token_pool:
+            _token_pool.update_tokens(tokens)
+        else:
+            _token_pool = TokenPool(tokens)

deploy/docker-compose.yml

@@ -15,8 +15,6 @@ services:
       - SKIP_AUTH_TOKEN=false
       # Server Configurations
       - DEBUG_LOGGING=true
-      # Feature Configuration
-      - THINKING_PROCESSING=think
       - ANONYMOUS_MODE=true
       - TOOL_SUPPORT=true
       - SCAN_LIMIT=200000

main.py

@@ -1,13 +1,15 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from fastapi import FastAPI, Request, Response
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Response
 from fastapi.middleware.cors import CORSMiddleware
 
 from app.core.config import settings
 from app.core import openai
 from app.utils.reload_config import RELOAD_CONFIG
 from app.utils.logger import setup_logger
+from app.utils.token_pool import initialize_token_pool
 
 from granian import Granian
 
@@ -15,8 +17,24 @@ from granian import Granian
 # Setup logger
 logger = setup_logger(log_dir="logs", debug_mode=settings.DEBUG_LOGGING)
 
-# Create FastAPI app
-app = FastAPI()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    token_list = settings.auth_token_list
+    if token_list:
+        token_pool = initialize_token_pool(
+            tokens=token_list,
+            failure_threshold=settings.TOKEN_FAILURE_THRESHOLD,
+            recovery_timeout=settings.TOKEN_RECOVERY_TIMEOUT
+        )
+
+    yield
+
+    logger.info("🔄 应用正在关闭...")
+
+
+# Create FastAPI app with lifespan
+app = FastAPI(lifespan=lifespan)
 
 # Add CORS middleware
 app.add_middleware(

pyproject.toml

@@ -33,6 +33,7 @@ dependencies = [
     "typing-inspection==0.4.1",
     "fake-useragent==2.2.0",
     "loguru==0.7.3",
+    "httpx==0.27.0"
 ]
 
 [project.scripts]

requirements.txt

@@ -1,6 +1,7 @@
 fastapi==0.116.1
 granian[reload]==2.5.2
 requests==2.32.5
+httpx==0.27.0
 pydantic==2.11.7
 pydantic-settings==2.10.1
 pydantic-core==2.33.2

tokens.txt.example

@@ -0,0 +1,21 @@
+# 认证Token配置文件
+#
+# 说明：
+# 1. 支持两种格式：每行一个token 或 逗号分隔的token
+# 2. 只包含认证用户token (role: "user")，不要添加匿名用户token (role: "guest")
+# 3. 系统会自动去重和验证token有效性
+# 4. 修改此文件后无需重启服务，系统会自动重新加载
+# 5. 自动跳过空格、换行符和空token
+#
+# 格式1：每行一个token
+# eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItMTIzIn0.signature1
+# eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItNDU2In0.signature2
+# eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItNzg5In0.signature3
+#
+# 格式2：逗号分隔（推荐，更紧凑）
+# eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItMTIzIn0.signature1,
+# eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItNDU2In0.signature2,
+# eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6InVzZXItNzg5In0.signature3
+
+# 请在下方添加您的认证用户token（使用任一格式）：
+