feat(core): 增加 token 池管理和请求重试逻辑

- 新增 token 池配置和管理逻辑，支持多 token 负载均衡
- 实现请求重试机制，包括处理网络错误、速率限制和服务器错误
- 优化上游 API 调用流程，增加错误处理和日志记录
- 调整流式响应处理逻辑，提高容错性和稳定性

app/api/admin.py

@@ -0,0 +1,60 @@
+"""
+Admin API endpoints for token management
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import HTTPBearer
+from fastapi.security.http import HTTPAuthorizationCredentials
+from typing import Dict, Any
+
+from app.core.config import settings
+from app.core.token_manager import token_manager
+
+router = APIRouter(prefix="/admin", tags=["admin"])
+security = HTTPBearer()
+
+
+def verify_admin_token(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
+    """Verify admin authentication token"""
+    if settings.SKIP_AUTH_TOKEN:
+        return credentials.credentials
+    
+    if credentials.credentials != settings.AUTH_TOKEN:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return credentials.credentials
+
+
+@router.get("/token-stats")
+async def get_token_stats(token: str = Depends(verify_admin_token)) -> Dict[str, Any]:
+    """Get token pool statistics"""
+    return token_manager.get_token_stats()
+
+
+@router.post("/reload-tokens")
+async def reload_tokens(token: str = Depends(verify_admin_token)) -> Dict[str, str]:
+    """Force reload tokens from file"""
+    try:
+        token_manager.reload_tokens()
+        return {"message": "Token池已重新加载"}
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"重新加载失败: {str(e)}"
+        )
+
+
+@router.post("/reset-tokens")
+async def reset_tokens(token: str = Depends(verify_admin_token)) -> Dict[str, str]:
+    """Reset all tokens (clear failure counts)"""
+    try:
+        token_manager.reset_all_tokens()
+        return {"message": "所有token状态已重置"}
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"重置失败: {str(e)}"
+        )

app/core/config.py

@@ -32,6 +32,20 @@ class Settings(BaseSettings):
     SCAN_LIMIT: int = int(os.getenv("SCAN_LIMIT", "200000"))
     SKIP_AUTH_TOKEN: bool = os.getenv("SKIP_AUTH_TOKEN", "false").lower() == "true"
     
+    # Token Pool Configuration
+    TOKEN_FILE_PATH: str = os.getenv("TOKEN_FILE_PATH", "./tokens.txt")
+    TOKEN_MAX_FAILURES: int = int(os.getenv("TOKEN_MAX_FAILURES", "3"))
+    TOKEN_RELOAD_INTERVAL: int = int(os.getenv("TOKEN_RELOAD_INTERVAL", "60"))
+    
+    # Request Configuration
+    REQUEST_TIMEOUT: int = int(os.getenv("REQUEST_TIMEOUT", "120"))
+    CONNECTION_TIMEOUT: int = int(os.getenv("CONNECTION_TIMEOUT", "30"))
+    MAX_RETRIES: int = int(os.getenv("MAX_RETRIES", "3"))
+    
+    # Proxy Configuration
+    HTTP_PROXY: Optional[str] = os.getenv("HTTP_PROXY")
+    HTTPS_PROXY: Optional[str] = os.getenv("HTTPS_PROXY")
+    
     # Browser Headers
     CLIENT_HEADERS: Dict[str, str] = {
         "Content-Type": "application/json",

app/core/response_handlers.py

@@ -15,6 +15,7 @@ from app.models.schemas import (
     UpstreamRequest, UpstreamData, UpstreamError, ModelItem
 )
 from app.utils.helpers import debug_log, call_upstream_api, transform_thinking_content
+from app.core.token_manager import token_manager
 from app.utils.sse_parser import SSEParser
 from app.utils.tools import extract_tool_invocations, remove_tool_json_content
 
@@ -61,11 +62,96 @@ class ResponseHandler:
     
     def _call_upstream(self) -> requests.Response:
         """Call upstream API with error handling"""
-        try:
-            return call_upstream_api(self.upstream_req, self.chat_id, self.auth_token)
-        except Exception as e:
-            debug_log(f"调用上游失败: {e}")
-            raise
+        max_retries = settings.MAX_RETRIES
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                debug_log(f"尝试调用上游API (第 {retry_count + 1}/{max_retries} 次)")
+                response = call_upstream_api(self.upstream_req, self.chat_id, self.auth_token)
+                
+                # Check if response is successful
+                if response.status_code == 200:
+                    # Mark token as successful
+                    token_manager.mark_token_success(self.auth_token)
+                    debug_log("上游API调用成功")
+                    return response
+                elif response.status_code in [401, 403]:
+                    # Authentication/authorization error - mark token as failed
+                    debug_log(f"Token认证失败 (状态码: {response.status_code}): {self.auth_token[:20]}...")
+                    token_manager.mark_token_failed(self.auth_token)
+                    
+                    # Try to get a new token
+                    new_token = token_manager.get_next_token()
+                    if new_token and new_token != self.auth_token:
+                        debug_log(f"尝试使用新token: {new_token[:20]}...")
+                        self.auth_token = new_token
+                        retry_count += 1
+                        continue
+                    else:
+                        debug_log("没有更多可用token")
+                        return response
+                elif response.status_code in [429]:
+                    # Rate limit - don't mark token as failed, just retry
+                    debug_log(f"遇到速率限制 (状态码: {response.status_code})，等待后重试")
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(2 ** retry_count)  # 指数退避
+                        retry_count += 1
+                        continue
+                    else:
+                        return response
+                elif response.status_code >= 500:
+                    # Server error - retry without marking token as failed
+                    debug_log(f"服务器错误 (状态码: {response.status_code})，稍后重试")
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(1)
+                        retry_count += 1
+                        continue
+                    else:
+                        return response
+                else:
+                    # Other client errors, return response as-is
+                    debug_log(f"客户端错误 (状态码: {response.status_code})")
+                    return response
+                    
+            except Exception as e:
+                error_msg = str(e)
+                debug_log(f"调用上游失败 (尝试 {retry_count + 1}/{max_retries}): {error_msg}")
+                
+                # 判断是否是连接问题还是token问题
+                is_connection_error = any(keyword in error_msg.lower() for keyword in [
+                    'connection', 'timeout', 'network', 'dns', 'socket', 'ssl'
+                ])
+                
+                if is_connection_error:
+                    debug_log("检测到网络连接问题，不标记token失败")
+                    # 网络问题不标记token失败，直接重试
+                    if retry_count < max_retries - 1:
+                        import time
+                        time.sleep(2)  # 等待2秒后重试
+                        retry_count += 1
+                        continue
+                    else:
+                        raise Exception(f"网络连接问题，重试{max_retries}次后仍失败: {error_msg}")
+                else:
+                    # 其他错误可能是token问题，标记失败并尝试新token
+                    debug_log("检测到可能的token问题，标记token失败")
+                    token_manager.mark_token_failed(self.auth_token)
+                    
+                    # Try to get a new token
+                    new_token = token_manager.get_next_token()
+                    if new_token and new_token != self.auth_token and retry_count < max_retries - 1:
+                        debug_log(f"尝试��用新token: {new_token[:20]}...")
+                        self.auth_token = new_token
+                        retry_count += 1
+                        continue
+                    else:
+                        raise
+        
+        # If we get here, all retries failed
+        raise Exception("所有重试尝试均失败")
     
     def _handle_upstream_error(self, response: requests.Response) -> None:
         """Handle upstream error response"""
@@ -108,28 +194,51 @@ class StreamResponseHandler(ResponseHandler):
         # Process stream
         debug_log("开始读取上游SSE流")
         sent_initial_answer = False
+        stream_ended_normally = False
         
-        with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
-            for event in parser.iter_json_data(UpstreamData):
-                upstream_data = event['data']
-                
-                # Check for errors
-                if self._has_error(upstream_data):
-                    error = self._get_error(upstream_data)
-                    yield from handle_upstream_error(error)
-                    break
-                
-                debug_log(f"解析成功 - 类型: {upstream_data.type}, 阶段: {upstream_data.data.phase}, "
-                         f"内容长度: {len(upstream_data.data.delta_content)}, 完成: {upstream_data.data.done}")
-                
-                # Process content
-                yield from self._process_content(upstream_data, sent_initial_answer)
-                
-                # Check if done
-                if upstream_data.data.done or upstream_data.data.phase == "done":
-                    debug_log("检测到流结束信号")
-                    yield from self._send_end_chunk()
-                    break
+        try:
+            with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
+                for event in parser.iter_json_data(UpstreamData):
+                    upstream_data = event['data']
+                    
+                    # Check for errors
+                    if self._has_error(upstream_data):
+                        error = self._get_error(upstream_data)
+                        yield from handle_upstream_error(error)
+                        stream_ended_normally = True
+                        break
+                    
+                    debug_log(f"解析成功 - 类型: {upstream_data.type}, 阶段: {upstream_data.data.phase}, "
+                             f"内容长度: {len(upstream_data.data.delta_content or '')}, 完成: {upstream_data.data.done}")
+                    
+                    # Process content
+                    yield from self._process_content(upstream_data, sent_initial_answer)
+                    
+                    # Update sent_initial_answer flag if we sent content
+                    if not sent_initial_answer and (upstream_data.data.delta_content or upstream_data.data.edit_content):
+                        sent_initial_answer = True
+                    
+                    # Check if done
+                    if upstream_data.data.done or upstream_data.data.phase == "done":
+                        debug_log("检测到流结束信号")
+                        yield from self._send_end_chunk()
+                        stream_ended_normally = True
+                        break
+                        
+        except Exception as e:
+            debug_log(f"SSE流处理异常: {e}")
+            # 流异常结束，发送错误响应
+            if not stream_ended_normally:
+                error_chunk = create_openai_response_chunk(
+                    model=settings.PRIMARY_MODEL,
+                    delta=Delta(content=f"\n\n[系统提示: 连接中断，响应可能不完整]")
+                )
+                yield f"data: {error_chunk.model_dump_json()}\n\n"
+        
+        # 确保流正常结束
+        if not stream_ended_normally:
+            debug_log("流未正常结束，发送结束信号")
+            yield from self._send_end_chunk(force_stop=True)
     
     def _has_error(self, upstream_data: UpstreamData) -> bool:
         """Check if upstream data contains error"""
@@ -203,15 +312,16 @@ class StreamResponseHandler(ResponseHandler):
         parts = edit_content.split("</details>")
         return parts[1] if len(parts) > 1 else ""
     
-    def _send_end_chunk(self) -> Generator[str, None, None]:
+    def _send_end_chunk(self, force_stop: bool = False) -> Generator[str, None, None]:
         """Send end chunk and DONE signal"""
         finish_reason = "stop"
         
-        if self.has_tools:
+        if self.has_tools and not force_stop:
             # Try to extract tool calls from buffered content
             self.tool_calls = extract_tool_invocations(self.buffered_content)
             
             if self.tool_calls:
+                debug_log(f"检测到工具调用: {len(self.tool_calls)} 个")
                 # Send tool calls with proper format
                 for i, tc in enumerate(self.tool_calls):
                     tool_call_delta = {
@@ -232,11 +342,21 @@ class StreamResponseHandler(ResponseHandler):
                 # Send regular content
                 trimmed_content = remove_tool_json_content(self.buffered_content)
                 if trimmed_content:
+                    debug_log(f"发送常规内容: {len(trimmed_content)} 字符")
                     content_chunk = create_openai_response_chunk(
                         model=settings.PRIMARY_MODEL,
                         delta=Delta(content=trimmed_content)
                     )
                     yield f"data: {content_chunk.model_dump_json()}\n\n"
+        elif force_stop:
+            # 强制结束时，发送缓冲的内容（如果有）
+            if self.buffered_content:
+                debug_log(f"强制结束，发送缓冲内容: {len(self.buffered_content)} 字符")
+                content_chunk = create_openai_response_chunk(
+                    model=settings.PRIMARY_MODEL,
+                    delta=Delta(content=self.buffered_content)
+                )
+                yield f"data: {content_chunk.model_dump_json()}\n\n"
         
         # Send final chunk
         end_chunk = create_openai_response_chunk(
@@ -245,7 +365,7 @@ class StreamResponseHandler(ResponseHandler):
         )
         yield f"data: {end_chunk.model_dump_json()}\n\n"
         yield "data: [DONE]\n\n"
-        debug_log("流式响应完成")
+        debug_log(f"流式响应完成 (finish_reason: {finish_reason})")
 
 
 class NonStreamResponseHandler(ResponseHandler):
@@ -272,23 +392,38 @@ class NonStreamResponseHandler(ResponseHandler):
         # Collect full response
         full_content = []
         debug_log("开始收集完整响应内容")
+        response_completed = False
         
-        with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
-            for event in parser.iter_json_data(UpstreamData):
-                upstream_data = event['data']
-                
-                if upstream_data.data.delta_content:
-                    content = upstream_data.data.delta_content
+        try:
+            with SSEParser(response, debug_mode=settings.DEBUG_LOGGING) as parser:
+                for event in parser.iter_json_data(UpstreamData):
+                    upstream_data = event['data']
                     
-                    if upstream_data.data.phase == "thinking":
-                        content = transform_thinking_content(content)
+                    if upstream_data.data.delta_content:
+                        content = upstream_data.data.delta_content
+                        
+                        if upstream_data.data.phase == "thinking":
+                            content = transform_thinking_content(content)
+                        
+                        if content:
+                            full_content.append(content)
                     
-                    if content:
-                        full_content.append(content)
-                
-                if upstream_data.data.done or upstream_data.data.phase == "done":
-                    debug_log("检测到完成信号，停止收集")
-                    break
+                    if upstream_data.data.done or upstream_data.data.phase == "done":
+                        debug_log("检测到完成信号，停止收集")
+                        response_completed = True
+                        break
+                        
+        except Exception as e:
+            debug_log(f"非流式响应收集异常: {e}")
+            if not full_content:
+                # 如果没有收集到任何内容，抛出异常
+                raise HTTPException(status_code=502, detail=f"Response collection failed: {str(e)}")
+            else:
+                debug_log(f"部分内容收集成功，继续处理 ({len(full_content)} 个片段)")
+        
+        if not response_completed and not full_content:
+            debug_log("响应未完成且无内容，可能是连接问题")
+            raise HTTPException(status_code=502, detail="Incomplete response from upstream")
         
         final_content = "".join(full_content)
         debug_log(f"内容收集完成，最终长度: {len(final_content)}")

app/core/token_manager.py

@@ -0,0 +1,233 @@
+"""
+Token pool management with load balancing and round-robin mechanism
+"""
+
+import os
+import time
+import threading
+from typing import List, Optional, Dict, Any, Set
+from dataclasses import dataclass, field
+
+
+def debug_log(message: str, *args) -> None:
+    """Log debug message if debug mode is enabled"""
+    # Import here to avoid circular import
+    try:
+        from app.core.config import settings
+        if settings.DEBUG_LOGGING:
+            if args:
+                print(f"[DEBUG] {message % args}")
+            else:
+                print(f"[DEBUG] {message}")
+    except:
+        # Fallback if settings not available
+        print(f"[DEBUG] {message}")
+
+
+@dataclass
+class TokenInfo:
+    """Token information with failure tracking"""
+    token: str
+    failure_count: int = 0
+    is_active: bool = True
+    last_failure_time: Optional[float] = None
+    last_used_time: Optional[float] = None
+
+
+class TokenManager:
+    """Token pool manager with load balancing and failure handling"""
+    
+    def __init__(self, token_file_path: str = None):
+        try:
+            from app.core.config import settings
+            self.token_file_path = token_file_path or getattr(settings, 'TOKEN_FILE_PATH', './tokens.txt')
+            self.max_failures = getattr(settings, 'TOKEN_MAX_FAILURES', 3)
+            self.reload_interval = getattr(settings, 'TOKEN_RELOAD_INTERVAL', 60)
+        except ImportError:
+            # Fallback values if settings not available
+            self.token_file_path = token_file_path or './tokens.txt'
+            self.max_failures = 3
+            self.reload_interval = 60
+        
+        self.tokens: List[TokenInfo] = []
+        self.current_index = 0
+        self.last_reload_time = 0
+        self._lock = threading.Lock()
+        
+        # Load tokens on initialization
+        self._load_tokens()
+    
+    def _load_tokens(self) -> None:
+        """Load tokens from file"""
+        try:
+            if not os.path.exists(self.token_file_path):
+                debug_log(f"Token文件不存在: {self.token_file_path}")
+                # Fallback to BACKUP_TOKEN if file doesn't exist
+                try:
+                    from app.core.config import settings
+                    if hasattr(settings, 'BACKUP_TOKEN') and settings.BACKUP_TOKEN:
+                        self.tokens = [TokenInfo(token=settings.BACKUP_TOKEN)]
+                        debug_log("使用配置文件中的BACKUP_TOKEN作为备用")
+                except ImportError:
+                    pass
+                return
+            
+            with open(self.token_file_path, 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+            
+            new_tokens = []
+            for line in lines:
+                token = line.strip()
+                if token and not token.startswith('#'):  # Skip empty lines and comments
+                    # Check if this token already exists to preserve failure count
+                    existing_token = next((t for t in self.tokens if t.token == token), None)
+                    if existing_token:
+                        new_tokens.append(existing_token)
+                    else:
+                        new_tokens.append(TokenInfo(token=token))
+            
+            if new_tokens:
+                with self._lock:
+                    self.tokens = new_tokens
+                    # Reset index if it's out of bounds
+                    if self.current_index >= len(self.tokens):
+                        self.current_index = 0
+                    self.last_reload_time = time.time()
+                
+                debug_log(f"成功加载 {len(self.tokens)} 个token")
+                active_count = sum(1 for t in self.tokens if t.is_active)
+                debug_log(f"活跃token数量: {active_count}")
+            else:
+                debug_log("Token文件为空或无有效token")
+                
+        except Exception as e:
+            debug_log(f"加载token文件失败: {e}")
+    
+    def _should_reload(self) -> bool:
+        """Check if tokens should be reloaded"""
+        return time.time() - self.last_reload_time > self.reload_interval
+    
+    def get_next_token(self) -> Optional[str]:
+        """Get next available token using round-robin with load balancing"""
+        # Reload tokens if needed
+        if self._should_reload():
+            self._load_tokens()
+        
+        with self._lock:
+            if not self.tokens:
+                debug_log("没有可用的token")
+                return None
+            
+            # Find active tokens
+            active_tokens = [i for i, t in enumerate(self.tokens) if t.is_active]
+            
+            if not active_tokens:
+                debug_log("没有活跃的token，尝试重置失败计数")
+                # Reset all tokens if none are active (maybe temporary network issues)
+                for token in self.tokens:
+                    token.is_active = True
+                    token.failure_count = 0
+                active_tokens = list(range(len(self.tokens)))
+            
+            # Round-robin selection from active tokens
+            attempts = 0
+            max_attempts = len(active_tokens)
+            
+            while attempts < max_attempts:
+                # Find next active token starting from current_index
+                token_index = None
+                for i in range(len(self.tokens)):
+                    idx = (self.current_index + i) % len(self.tokens)
+                    if idx in active_tokens:
+                        token_index = idx
+                        break
+                
+                if token_index is not None:
+                    self.current_index = (token_index + 1) % len(self.tokens)
+                    token_info = self.tokens[token_index]
+                    token_info.last_used_time = time.time()
+                    debug_log(f"选择token[{token_index}]: {token_info.token[:20]}...")
+                    return token_info.token
+                
+                attempts += 1
+            
+            debug_log("无法找到可用的token")
+            return None
+    
+    def mark_token_failed(self, token: str) -> None:
+        """Mark a token as failed and deactivate if necessary"""
+        with self._lock:
+            for token_info in self.tokens:
+                if token_info.token == token:
+                    token_info.failure_count += 1
+                    token_info.last_failure_time = time.time()
+                    
+                    if token_info.failure_count >= self.max_failures:
+                        token_info.is_active = False
+                        debug_log(f"Token失效 (失败{token_info.failure_count}次): {token[:20]}...")
+                    else:
+                        debug_log(f"Token失败 ({token_info.failure_count}/{self.max_failures}): {token[:20]}...")
+                    break
+    
+    def mark_token_success(self, token: str) -> None:
+        """Mark a token as successful (reset failure count)"""
+        with self._lock:
+            for token_info in self.tokens:
+                if token_info.token == token:
+                    if token_info.failure_count > 0:
+                        debug_log(f"Token恢复正常: {token[:20]}...")
+                    token_info.failure_count = 0
+                    token_info.is_active = True
+                    break
+    
+    def get_token_stats(self) -> Dict[str, Any]:
+        """Get token pool statistics"""
+        with self._lock:
+            if not self.tokens:
+                return {
+                    "total": 0,
+                    "active": 0,
+                    "failed": 0,
+                    "tokens": []
+                }
+            
+            active_count = sum(1 for t in self.tokens if t.is_active)
+            failed_count = len(self.tokens) - active_count
+            
+            token_details = []
+            for i, token_info in enumerate(self.tokens):
+                token_details.append({
+                    "index": i,
+                    "token_preview": token_info.token[:20] + "...",
+                    "is_active": token_info.is_active,
+                    "failure_count": token_info.failure_count,
+                    "last_failure_time": token_info.last_failure_time,
+                    "last_used_time": token_info.last_used_time
+                })
+            
+            return {
+                "total": len(self.tokens),
+                "active": active_count,
+                "failed": failed_count,
+                "current_index": self.current_index,
+                "last_reload_time": self.last_reload_time,
+                "tokens": token_details
+            }
+    
+    def reset_all_tokens(self) -> None:
+        """Reset all tokens (clear failure counts and reactivate)"""
+        with self._lock:
+            for token_info in self.tokens:
+                token_info.is_active = True
+                token_info.failure_count = 0
+                token_info.last_failure_time = None
+            debug_log("已重置所有token状态")
+    
+    def reload_tokens(self) -> None:
+        """Force reload tokens from file"""
+        debug_log("强制重新加载token文件")
+        self._load_tokens()
+
+
+# Global token manager instance
+token_manager = TokenManager()

app/utils/helpers.py

@@ -11,6 +11,7 @@ import requests
 from fake_useragent import UserAgent
 
 from app.core.config import settings
+from app.core.token_manager import token_manager
 
 # 全局 UserAgent 实例，避免每次调用都创建新实例
 _user_agent_instance = None
@@ -153,16 +154,23 @@ def get_anonymous_token() -> str:
 
 
 def get_auth_token() -> str:
-    """Get authentication token (anonymous or fixed)"""
+    """Get authentication token (anonymous or from token pool)"""
     if settings.ANONYMOUS_MODE:
         try:
             token = get_anonymous_token()
             debug_log(f"匿名token获取成功: {token[:10]}...")
             return token
         except Exception as e:
-            debug_log(f"匿名token获取失败，回退固定token: {e}")
+            debug_log(f"匿名token获取失败，使用token池: {e}")
     
-    return settings.BACKUP_TOKEN
+    # Use token pool for load balancing
+    token = token_manager.get_next_token()
+    if token:
+        debug_log(f"从token池获取token: {token[:10]}...")
+        return token
+    else:
+        debug_log("token池无可用token，使用配置文件备用token")
+        return settings.BACKUP_TOKEN
 
 
 def transform_thinking_content(content: str) -> str:
@@ -196,16 +204,56 @@ def call_upstream_api(
     headers = get_browser_headers(chat_id)
     headers["Authorization"] = f"Bearer {auth_token}"
     
+    # 准备请求数据
+    request_data = upstream_req.model_dump(exclude_none=True)
+    request_json = upstream_req.model_dump_json()
+    
     debug_log(f"调用上游API: {settings.API_ENDPOINT}")
-    debug_log(f"上游请求体: {upstream_req.model_dump_json()}")
-    
-    response = requests.post(
-        settings.API_ENDPOINT,
-        json=upstream_req.model_dump(exclude_none=True),
-        headers=headers,
-        timeout=60.0,
-        stream=True
-    )
-    
-    debug_log(f"上游响应状态: {response.status_code}")
-    return response
+    debug_log(f"请求体大小: {len(request_json)} 字符")
+    
+    # 如果请求体太大，只显示部分内容
+    if len(request_json) > 1000:
+        debug_log(f"上游请求体 (截断): {request_json[:500]}...{request_json[-200:]}")
+    else:
+        debug_log(f"上游请求体: {request_json}")
+    
+    # 设置代理（如果配置了）
+    proxies = {}
+    if settings.HTTP_PROXY:
+        proxies['http'] = settings.HTTP_PROXY
+    if settings.HTTPS_PROXY:
+        proxies['https'] = settings.HTTPS_PROXY
+    
+    try:
+        response = requests.post(
+            settings.API_ENDPOINT,
+            json=request_data,
+            headers=headers,
+            timeout=(settings.CONNECTION_TIMEOUT, settings.REQUEST_TIMEOUT),
+            stream=True,
+            proxies=proxies if proxies else None,
+            verify=True,
+        )
+        
+        debug_log(f"上游响应状态: {response.status_code}")
+        
+        # 检查响应头
+        if settings.DEBUG_LOGGING:
+            content_type = response.headers.get('content-type', 'unknown')
+            content_length = response.headers.get('content-length', 'unknown')
+            debug_log(f"响应类型: {content_type}, 长度: {content_length}")
+        
+        return response
+        
+    except requests.exceptions.Timeout as e:
+        debug_log(f"请求超时: {e}")
+        raise Exception(f"上游API请求超时: {e}")
+    except requests.exceptions.ConnectionError as e:
+        debug_log(f"连接错误: {e}")
+        raise Exception(f"上游API连接失败: {e}")
+    except requests.exceptions.RequestException as e:
+        debug_log(f"请求异常: {e}")
+        raise Exception(f"上游API请求失败: {e}")
+    except Exception as e:
+        debug_log(f"未知错误: {e}")
+        raise

deploy/Dockerfile

@@ -1,10 +0,0 @@
-FROM python:3.12-slim
-
-WORKDIR /app
-
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-CMD ["python", "main.py"]

deploy/docker-compose.yml

@@ -1,27 +0,0 @@
-version: '3.8'
-
-services:
-  api-server:
-    image: julienol/z-ai2api-python:latest
-    container_name: z-ai-api-server
-    ports:
-      - "8084:8080"
-    environment:
-      # Auth Configuration
-      - AUTH_TOKEN=sk-123456
-      # 是否跳过api key验证
-      - SKIP_AUTH_TOKEN=false
-      # Server Configurations
-      - DEBUG_LOGGING=true
-      # Feature Configuration
-      - THINKING_PROCESSING=think
-      - ANONYMOUS_MODE=true
-      - TOOL_SUPPORT=true
-      - SCAN_LIMIT=200000
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:8080/v1/models"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 10s

main.py

@@ -10,6 +10,7 @@ from fastapi.middleware.cors import CORSMiddleware
 
 from app.core.config import settings
 from app.core import openai
+from app.api import admin
 from app.utils.reload_config import RELOAD_CONFIG
 
 from granian import Granian
@@ -32,6 +33,7 @@ app.add_middleware(
 
 # Include API routers
 app.include_router(openai.router)
+app.include_router(admin.router)
 
 
 @app.options("/")