Upload 28 files

app/api/__init__.py

@@ -0,0 +1,9 @@
+from app.api.routes import router, init_router
+from app.api.dashboard import dashboard_router, init_dashboard_router
+
+__all__ = [
+    'router',
+    'init_router',
+    'dashboard_router',
+    'init_dashboard_router'
+]

app/api/dashboard.py

@@ -0,0 +1,111 @@
+from fastapi import APIRouter
+from datetime import datetime, timedelta
+from app.utils import (
+    log_manager,
+    ResponseCacheManager,
+    ActiveRequestsManager,
+    clean_expired_stats
+)
+from app.config.settings import (
+    api_call_stats,
+    client_request_history,
+    API_KEY_DAILY_LIMIT
+)
+from app.services import GeminiClient
+
+# 创建路由器
+dashboard_router = APIRouter(prefix="/api", tags=["dashboard"])
+
+# 全局变量引用，将在init_dashboard_router中设置
+key_manager = None
+response_cache_manager = None
+active_requests_manager = None
+
+def init_dashboard_router(
+    key_mgr,
+    cache_mgr,
+    active_req_mgr
+):
+    """初始化仪表盘路由器"""
+    global key_manager, response_cache_manager, active_requests_manager
+    key_manager = key_mgr
+    response_cache_manager = cache_mgr
+    active_requests_manager = active_req_mgr
+    return dashboard_router
+
+@dashboard_router.get("/dashboard-data")
+async def get_dashboard_data():
+    """获取仪表盘数据的API端点，用于动态刷新"""
+    # 先清理过期数据，确保统计数据是最新的
+    clean_expired_stats(api_call_stats)
+    response_cache_manager.clean_expired()  # 使用管理器清理缓存
+    active_requests_manager.clean_completed()  # 使用管理器清理活跃请求
+    
+    # 获取当前统计数据
+    now = datetime.now()
+    
+    # 计算过去24小时的调用总数
+    last_24h_calls = sum(api_call_stats['last_24h']['total'].values())
+    
+    # 计算过去一小时内的调用总数
+    one_hour_ago = now - timedelta(hours=1)
+    hourly_calls = 0
+    for hour_key, count in api_call_stats['hourly']['total'].items():
+        try:
+            hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+            if hour_time >= one_hour_ago:
+                hourly_calls += count
+        except ValueError:
+            continue
+    
+    # 计算过去一分钟内的调用总数
+    one_minute_ago = now - timedelta(minutes=1)
+    minute_calls = 0
+    for minute_key, count in api_call_stats['minute']['total'].items():
+        try:
+            minute_time = datetime.strptime(minute_key, '%Y-%m-%d %H:%M')
+            if minute_time >= one_minute_ago:
+                minute_calls += count
+        except ValueError:
+            continue
+    
+    # 获取API密钥使用统计
+    api_key_stats = []
+    for api_key in key_manager.api_keys:
+        # 获取API密钥前8位作为标识
+        api_key_id = api_key[:8]
+        
+        # 计算24小时内的调用次数
+        calls_24h = 0
+        if 'by_endpoint' in api_call_stats['last_24h'] and api_key in api_call_stats['last_24h']['by_endpoint']:
+            calls_24h = sum(api_call_stats['last_24h']['by_endpoint'][api_key].values())
+        
+        # 计算使用百分比
+        usage_percent = (calls_24h / API_KEY_DAILY_LIMIT) * 100 if API_KEY_DAILY_LIMIT > 0 else 0
+        
+        # 添加到结果列表
+        api_key_stats.append({
+            'api_key': api_key_id,
+            'calls_24h': calls_24h,
+            'limit': API_KEY_DAILY_LIMIT,
+            'usage_percent': round(usage_percent, 2)
+        })
+    
+    # 按使用百分比降序排序
+    api_key_stats.sort(key=lambda x: x['usage_percent'], reverse=True)
+    
+    # 获取最近的日志
+    recent_logs = log_manager.get_recent_logs(50)  # 获取最近50条日志
+    
+    # 返回JSON格式的数据
+    return {
+        "key_count": len(key_manager.api_keys),
+        "model_count": len(GeminiClient.AVAILABLE_MODELS),
+        "retry_count": len(key_manager.api_keys),
+        "last_24h_calls": last_24h_calls,
+        "hourly_calls": hourly_calls,
+        "minute_calls": minute_calls,
+        "current_time": datetime.now().strftime('%H:%M:%S'),
+        "logs": recent_logs,
+        "api_key_stats": api_key_stats
+    }

app/api/routes.py

@@ -0,0 +1,916 @@
+from fastapi import APIRouter, HTTPException, Request, Depends, status
+from fastapi.responses import JSONResponse, StreamingResponse
+from app.models import ChatCompletionRequest, ChatCompletionResponse, ErrorResponse, ModelList
+from app.services import GeminiClient, ResponseWrapper
+from app.utils import (
+    handle_gemini_error, 
+    protect_from_abuse, 
+    APIKeyManager, 
+    test_api_key, 
+    format_log_message, 
+    log_manager,
+    generate_cache_key,
+    cache_response,
+    create_chat_response,
+    create_error_response,
+    handle_api_error,
+    update_api_call_stats
+)
+import json
+import asyncio
+import time
+import logging
+import random
+from typing import Literal
+from app.config.settings import (
+    api_call_stats
+)
+# 获取logger
+logger = logging.getLogger("my_logger")
+
+# 创建路由器
+router = APIRouter()
+
+# 全局变量引用 - 这些将在main.py中初始化并传递给路由
+key_manager = None
+response_cache_manager = None
+active_requests_manager = None
+safety_settings = None
+safety_settings_g2 = None
+current_api_key = None
+FAKE_STREAMING = None
+FAKE_STREAMING_INTERVAL = None
+PASSWORD = None
+MAX_REQUESTS_PER_MINUTE = None
+MAX_REQUESTS_PER_DAY_PER_IP = None
+
+# 初始化路由器的函数
+def init_router(
+    _key_manager,
+    _response_cache_manager,
+    _active_requests_manager,
+    _safety_settings,
+    _safety_settings_g2,
+    _current_api_key,
+    _fake_streaming,
+    _fake_streaming_interval,
+    _password,
+    _max_requests_per_minute,
+    _max_requests_per_day_per_ip
+):
+    global key_manager, response_cache_manager, active_requests_manager
+    global safety_settings, safety_settings_g2, current_api_key
+    global FAKE_STREAMING, FAKE_STREAMING_INTERVAL
+    global PASSWORD, MAX_REQUESTS_PER_MINUTE, MAX_REQUESTS_PER_DAY_PER_IP
+    
+    key_manager = _key_manager
+    response_cache_manager = _response_cache_manager
+    active_requests_manager = _active_requests_manager
+    safety_settings = _safety_settings
+    safety_settings_g2 = _safety_settings_g2
+    current_api_key = _current_api_key
+    FAKE_STREAMING = _fake_streaming
+    FAKE_STREAMING_INTERVAL = _fake_streaming_interval
+    PASSWORD = _password
+    MAX_REQUESTS_PER_MINUTE = _max_requests_per_minute
+    MAX_REQUESTS_PER_DAY_PER_IP = _max_requests_per_day_per_ip
+
+# 日志记录函数
+def log(level: str, message: str, **extra):
+    """简化日志记录的统一函数"""
+    msg = format_log_message(level.upper(), message, extra=extra)
+    getattr(logger, level.lower())(msg)
+
+# 密码验证依赖
+async def verify_password(request: Request):
+    if PASSWORD:
+        auth_header = request.headers.get("Authorization")
+        if not auth_header or not auth_header.startswith("Bearer "):
+            raise HTTPException(
+                status_code=401, detail="Unauthorized: Missing or invalid token")
+        token = auth_header.split(" ")[1]
+        if token != PASSWORD:
+            raise HTTPException(
+                status_code=401, detail="Unauthorized: Invalid token")
+
+# API路由
+@router.get("/v1/models", response_model=ModelList)
+def list_models():
+    log('info', "Received request to list models", extra={'request_type': 'list_models', 'status_code': 200})
+    return ModelList(data=[{"id": model, "object": "model", "created": 1678888888, "owned_by": "organization-owner"} for model in GeminiClient.AVAILABLE_MODELS])
+
+@router.post("/v1/chat/completions", response_model=ChatCompletionResponse)
+async def chat_completions(request: ChatCompletionRequest, http_request: Request, _: None = Depends(verify_password)):
+    # 获取客户端IP
+    client_ip = http_request.client.host if http_request.client else "unknown"
+    
+    # 流式请求直接处理，不使用缓存
+    if request.stream:
+        return await process_request(request, http_request, "stream")
+    
+    # 生成完整缓存键 - 用于精确匹配
+    cache_key = generate_cache_key(request)
+    
+    # 记录请求缓存键信息
+    log('info', f"请求缓存键: {cache_key[:8]}...", 
+        extra={'cache_key': cache_key[:8], 'request_type': 'non-stream'})
+    
+    # 检查精确缓存是否存在且未过期
+    cached_response, cache_hit = response_cache_manager.get(cache_key)
+    if cache_hit:
+        # 精确缓存命中
+        log('info', f"精确缓存命中: {cache_key[:8]}...", 
+            extra={'cache_operation': 'hit', 'request_type': 'non-stream'})
+        
+        # 同时清理相关的活跃任务，避免后续请求等待已经不需要的任务
+        active_requests_manager.remove_by_prefix(f"cache:{cache_key}")
+        
+        # 安全删除缓存
+        if cache_key in response_cache_manager.cache:
+            del response_cache_manager.cache[cache_key]
+            log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
+                extra={'cache_operation': 'used-and-removed', 'request_type': 'non-stream'})
+        
+        # 返回缓存响应
+        return cached_response
+    
+    # 构建包含���存键的活跃请求池键
+    pool_key = f"cache:{cache_key}"
+    
+    # 查找所有使用相同缓存键的活跃任务
+    active_task = active_requests_manager.get(pool_key)
+    if active_task and not active_task.done():
+        log('info', f"发现相同请求的进行中任务", 
+            extra={'request_type': 'non-stream', 'model': request.model})
+        
+        # 等待已有任务完成
+        try:
+            # 设置超时，避免无限等待
+            await asyncio.wait_for(active_task, timeout=180)
+            
+            # 通过缓存管理器获取已完成任务的结果
+            cached_response, cache_hit = response_cache_manager.get(cache_key)
+            if cache_hit:
+                # 安全删除缓存
+                if cache_key in response_cache_manager.cache:
+                    del response_cache_manager.cache[cache_key]
+                    log('info', f"使用已完成任务的缓存后删除: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'used-and-removed', 'request_type': 'non-stream'})
+                
+                return cached_response
+                
+            # 如果缓存已被清除或不存在，使用任务结果
+            if active_task.done() and not active_task.cancelled():
+                result = active_task.result()
+                if result:
+                    # 使用原始结果时，我们需要创建一个新的响应对象
+                    # 避免使用可能已被其他请求修改的对象
+                    new_response = ChatCompletionResponse(
+                        id=f"chatcmpl-{int(time.time()*1000)}",
+                        object="chat.completion", 
+                        created=int(time.time()),
+                        model=result.model,
+                        choices=result.choices
+                    )
+                    
+                    # 不要缓存此结果，因为它很可能是一个已存在但被使用后清除的缓存
+                    return new_response
+        except (asyncio.TimeoutError, asyncio.CancelledError) as e:
+            # 任务超时或被取消的情况下，记录日志然后让代码继续执行
+            error_type = "超时" if isinstance(e, asyncio.TimeoutError) else "被取消"
+            log('warning', f"等待已有任务{error_type}: {pool_key}", 
+                extra={'request_type': 'non-stream', 'model': request.model})
+            
+            # 从活跃请求池移除该任务
+            if active_task.done() or active_task.cancelled():
+                active_requests_manager.remove(pool_key)
+                log('info', f"已从活跃请求池移除{error_type}任务: {pool_key}", 
+                    extra={'request_type': 'non-stream'})
+     
+    # 创建请求处理任务
+    process_task = asyncio.create_task(
+        process_request(request, http_request, "non-stream", cache_key=cache_key, client_ip=client_ip)
+    )
+    
+    # 将任务添加到活跃请求池
+    active_requests_manager.add(pool_key, process_task)
+    
+    # 等待任务完成
+    try:
+        response = await process_task
+        return response
+    except Exception as e:
+        # 如果任务失败，从活跃请求池中移除
+        active_requests_manager.remove(pool_key)
+        
+        # 检查是否已有缓存的结果（可能是由另一个任务创建的）
+        cached_response, cache_hit = response_cache_manager.get(cache_key)
+        if cache_hit:
+            log('info', f"任务失败但找到缓存，使用缓存结果: {cache_key[:8]}...", 
+                extra={'request_type': 'non-stream', 'model': request.model})
+            return cached_response
+        
+        # 重新抛出异常
+        raise
+
+# 请求处理函数
+async def process_request(chat_request: ChatCompletionRequest, http_request: Request, request_type: Literal['stream', 'non-stream'], cache_key: str = None, client_ip: str = None):
+    """处理API请求的主函数，根据需要处理流式或非流式请求"""
+    global current_api_key
+    
+    # 请求前基本检查
+    protect_from_abuse(
+        http_request, MAX_REQUESTS_PER_MINUTE, MAX_REQUESTS_PER_DAY_PER_IP)
+    if chat_request.model not in GeminiClient.AVAILABLE_MODELS:
+        error_msg = "无效的模型"
+        extra_log = {'request_type': request_type, 'model': chat_request.model, 'status_code': 400, 'error_message': error_msg}
+        log('error', error_msg, extra=extra_log)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=error_msg)
+
+    # 重置已尝试的密钥
+    key_manager.reset_tried_keys_for_request()
+    
+    # 转换消息格式
+    contents, system_instruction = GeminiClient.convert_messages(
+        GeminiClient, chat_request.messages)
+
+    # 设置重试次数（使用可用API密钥数量作为最大重试次数）
+    retry_attempts = len(key_manager.api_keys) if key_manager.api_keys else 1
+    
+    # 尝试使用不同API密钥
+    for attempt in range(1, retry_attempts + 1):
+        # 获取下一个密钥
+        current_api_key = key_manager.get_available_key()
+        
+        # 检查API密钥是否可用
+        if current_api_key is None:
+            log('warning', "没有可用的 API 密钥，跳过本次尝试", 
+                extra={'request_type': request_type, 'model': chat_request.model, 'status_code': 'N/A'})
+            break
+        
+        # 记录当前尝试的密钥信息
+        log('info', f"第 {attempt}/{retry_attempts} 次尝试 ... 使用密钥: {current_api_key[:8]}...", 
+            extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+
+        # 服务器错误重试逻辑
+        server_error_retries = 3
+        for server_retry in range(1, server_error_retries + 1):
+            try:
+                # 根据请求类型分别处理
+                if chat_request.stream:
+                    try:
+                        return await process_stream_request(
+                            chat_request,
+                            http_request,
+                            contents,
+                            system_instruction,
+                            current_api_key
+                        )
+                    except Exception as e:
+                        # 捕获流式请求的异常，但不立即返回错误
+                        # 记录错误并继续尝试下一个API密钥
+                        error_detail = handle_gemini_error(e, current_api_key, key_manager)
+                        log('error', f"流式请求失败: {error_detail}",
+                            extra={'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+                        # 不返回错误，而是抛出异常让外层循环处理
+                        raise
+                else:
+                    return await process_nonstream_request(
+                        chat_request,
+                        http_request,
+                        request_type,
+                        contents,
+                        system_instruction,
+                        current_api_key,
+                        cache_key,
+                        client_ip
+                    )
+            except HTTPException as e:
+                if e.status_code == status.HTTP_408_REQUEST_TIMEOUT:
+                    log('error', "客户端连接中断", 
+                        extra={'key': current_api_key[:8], 'request_type': request_type, 
+                              'model': chat_request.model, 'status_code': 408})
+                    raise
+                else:
+                    raise
+            except Exception as e:
+                # 使用统一的API错误处理函数
+                error_result = await handle_api_error(
+                    e, 
+                    current_api_key, 
+                    key_manager, 
+                    request_type, 
+                    chat_request.model, 
+                    server_retry - 1
+                )
+                
+                # 如果需要删除缓存，清除缓存
+                if error_result.get('remove_cache', False) and cache_key and cache_key in response_cache_manager.cache:
+                    log('info', f"因API错误，删除缓存: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
+                    del response_cache_manager.cache[cache_key]
+                
+                if error_result.get('should_retry', False):
+                    # 服务器错误需要重试（等待已在handle_api_error中完成）
+                    continue
+                elif error_result.get('should_switch_key', False) and attempt < retry_attempts:
+                    # 跳出服务器错误重试循环，获取下一个可用密钥
+                    log('info', f"API密钥 {current_api_key[:8]}... 失败，准备尝试下一个密钥", 
+                        extra={'key': current_api_key[:8], 'request_type': request_type})
+                    break  
+                else:
+                    # 无法处理的错误或已达到重试上限
+                    break
+
+    # 如果所有尝试都失败
+    msg = "所有API密钥均请求失败,请稍后重试"
+    log('error', "API key 替换失败，所有API key都已尝试，请重新配置或稍后重试", extra={'key': 'N/A', 'request_type': 'switch_key', 'status_code': 'N/A'})
+    
+    # 对于流式请求，创建一个特殊的StreamingResponse返回错误
+    if chat_request.stream:
+        async def error_generator():
+            error_json = json.dumps({'error': {'message': msg, 'type': 'api_error'}})
+            yield f"data: {error_json}\n\n"
+            yield "data: [DONE]\n\n"
+        
+        return StreamingResponse(error_generator(), media_type="text/event-stream")
+    else:
+        # 非流式请求使用标准HTTP异常
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=msg)
+
+# 流式请求处理函数
+async def process_stream_request(
+    chat_request: ChatCompletionRequest,
+    http_request: Request,
+    contents,
+    system_instruction,
+    current_api_key: str
+) -> StreamingResponse:
+    """处理流式API请求"""
+    
+    # 创建一个直接流式响应的生成器函数
+    async def stream_response_generator():
+        # 如果启用了假流式模式，使用随机遍历API密钥的方式
+        if FAKE_STREAMING:
+            # 创建一个队列用于在任务之间传递数据
+            queue = asyncio.Queue()
+            keep_alive_task = None
+            api_request_task = None
+            
+            try:
+                # 创建一个保持连接的任务，持续发送换行符
+                async def keep_alive_sender():
+                    try:
+                        # 创建一个Gemini客户端用于发送保持连接的换行符
+                        keep_alive_client = GeminiClient(current_api_key)
+                        
+                        # 启动保持连接的生成器
+                        keep_alive_generator = keep_alive_client.stream_chat(
+                            chat_request,
+                            contents,
+                            safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
+                            system_instruction
+                        )
+                        
+                        # 持续发送换行符直到被取消
+                        async for line in keep_alive_generator:
+                            if line == "\n":
+                                # 将换行符格式化为SSE格式
+                                formatted_chunk = {
+                                    "id": "chatcmpl-keepalive",
+                                    "object": "chat.completion.chunk",
+                                    "created": int(time.time()),
+                                    "model": chat_request.model,
+                                    "choices": [{"delta": {"content": ""}, "index": 0, "finish_reason": None}]
+                                }
+                                # 将格式化的换行符放入队列
+                                await queue.put(f"data: {json.dumps(formatted_chunk)}\n\n")
+                    except asyncio.CancelledError:
+                        log('info', "保持连接任务被取消",
+                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                        raise
+                    except Exception as e:
+                        log('error', f"保持连接任务出错: {str(e)}",
+                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                        # 将错误放入队列
+                        await queue.put(None)
+                        raise
+                
+                # 创建一个任务来随机遍历API密钥并请求内容
+                async def api_request_handler():
+                    success = False
+                    try:
+                        # 重置已尝试的密钥
+                        key_manager.reset_tried_keys_for_request()
+                        
+                        # 获取可用的API密钥
+                        available_keys = key_manager.api_keys.copy()
+                        random.shuffle(available_keys)  # 随机打乱密钥顺序
+                        
+                        # 遍历所有API密钥尝试获取响应
+                        for attempt, api_key in enumerate(available_keys, 1):
+                            try:
+                                log('info', f"假流式模式: 尝试API密钥 {api_key[:8]}... ({attempt}/{len(available_keys)})",
+                                    extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+                                
+                                # 创建一个新的客户端使用当前API密钥
+                                non_stream_client = GeminiClient(api_key)
+                                
+                                # 使用非流式方式请求内容
+                                response_content = await asyncio.to_thread(
+                                    non_stream_client.complete_chat,
+                                    chat_request,
+                                    contents,
+                                    safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
+                                    system_instruction
+                                )
+                                
+                                # 检查响应是否有效
+                                if response_content and response_content.text:
+                                    log('info', f"假流式模式: API密钥 {api_key[:8]}... 成功获取响应",
+                                        extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+                                    
+                                    # 将完整响应分割成小块，模拟流式返回
+                                    full_text = response_content.text
+                                    chunk_size = max(len(full_text) // 10, 1)  # 至少分成10块，每块至少1个字符
+                                    
+                                    for i in range(0, len(full_text), chunk_size):
+                                        chunk = full_text[i:i+chunk_size]
+                                        formatted_chunk = {
+                                            "id": "chatcmpl-someid",
+                                            "object": "chat.completion.chunk",
+                                            "created": int(time.time()),
+                                            "model": chat_request.model,
+                                            "choices": [{"delta": {"role": "assistant", "content": chunk}, "index": 0, "finish_reason": None}]
+                                        }
+                                        # 将格式化的内容块放入队列
+                                        await queue.put(f"data: {json.dumps(formatted_chunk)}\n\n")
+                                    
+                                    success = True
+                                    # 更新API调用统计
+                                    from app.utils.stats import update_api_call_stats
+                                    update_api_call_stats(api_call_stats,api_key)
+                                    break  # 成功获取响应，退出循环
+                                else:
+                                    log('warning', f"假流式模式: API密钥 {api_key[:8]}... 返回空响应",
+                                        extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+                            except Exception as e:
+                                error_detail = handle_gemini_error(e, api_key, key_manager)
+                                log('error', f"假流式模式: API密钥 {api_key[:8]}... 请求失败: {error_detail}",
+                                    extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+                                # 继续尝试下一个API密钥
+                        
+                        # 如果所有API密钥都尝试失败
+                        if not success:
+                            error_msg = "所有API密钥均请求失败，请稍后重试"
+                            log('error', error_msg,
+                                extra={'key': 'ALL', 'request_type': 'fake-stream', 'model': chat_request.model})
+                            
+                            # 添加错误信息到队列
+                            error_json = {
+                                "id": "chatcmpl-error",
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": chat_request.model,
+                                "choices": [{"delta": {"content": f"\n\n[错误: {error_msg}]"}, "index": 0, "finish_reason": "error"}]
+                            }
+                            await queue.put(f"data: {json.dumps(error_json)}\n\n")
+                        
+                        # 添加完成标记到队列
+                        await queue.put("data: [DONE]\n\n")
+                        # 添加None表示队列结束
+                        await queue.put(None)
+                        
+                    except asyncio.CancelledError:
+                        log('info', "API请求任务被取消",
+                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                        # 添加None表示队列结束
+                        await queue.put(None)
+                        raise
+                    except Exception as e:
+                        log('error', f"API请求任务出错: {str(e)}",
+                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                        # 添加错误信息到队列
+                        error_json = {
+                            "id": "chatcmpl-error",
+                            "object": "chat.completion.chunk",
+                            "created": int(time.time()),
+                            "model": chat_request.model,
+                            "choices": [{"delta": {"content": f"\n\n[错误: {str(e)}]"}, "index": 0, "finish_reason": "error"}]
+                        }
+                        await queue.put(f"data: {json.dumps(error_json)}\n\n")
+                        await queue.put("data: [DONE]\n\n")
+                        # 添加None表示队列结束
+                        await queue.put(None)
+                        raise
+                
+                # 启动保持连接的任务
+                keep_alive_task = asyncio.create_task(keep_alive_sender())
+                # 启动API请求任务
+                api_request_task = asyncio.create_task(api_request_handler())
+                
+                # 从队列中获取数据并发送给客户端
+                while True:
+                    chunk = await queue.get()
+                    if chunk is None:  # None表示队列结束
+                        break
+                    yield chunk
+                    
+                    # 如果API请求任务已完成，取消保持连接任务
+                    if api_request_task.done() and not keep_alive_task.done():
+                        keep_alive_task.cancel()
+                
+            except asyncio.CancelledError:
+                log('info', "流式响应生成器被取消",
+                    extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                # 取消所有任务
+                if keep_alive_task and not keep_alive_task.done():
+                    keep_alive_task.cancel()
+                if api_request_task and not api_request_task.done():
+                    api_request_task.cancel()
+            except Exception as e:
+                log('error', f"流式响应生成器出错: {str(e)}",
+                    extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                # 取消所有任务
+                if keep_alive_task and not keep_alive_task.done():
+                    keep_alive_task.cancel()
+                if api_request_task and not api_request_task.done():
+                    api_request_task.cancel()
+                # 发送错误信息给客户端
+                error_json = {
+                    "id": "chatcmpl-error",
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": chat_request.model,
+                    "choices": [{"delta": {"content": f"\n\n[错误: {str(e)}]"}, "index": 0, "finish_reason": "error"}]
+                }
+                yield f"data: {json.dumps(error_json)}\n\n"
+                yield "data: [DONE]\n\n"
+            finally:
+                # 确保所有任务都被取消
+                if keep_alive_task and not keep_alive_task.done():
+                    keep_alive_task.cancel()
+                if api_request_task and not api_request_task.done():
+                    api_request_task.cancel()
+        else:
+            # 原始流式请求处理逻辑
+            gemini_client = GeminiClient(current_api_key)
+            success = False
+            
+            try:
+                # 直接迭代生成器并发送响应块
+                async for chunk in gemini_client.stream_chat(
+                    chat_request,
+                    contents,
+                    safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
+                    system_instruction
+                ):
+                    # 空字符串跳过
+                    if not chunk:
+                        continue
+                        
+                    formatted_chunk = {
+                        "id": "chatcmpl-someid",
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": chat_request.model,
+                        "choices": [{"delta": {"role": "assistant", "content": chunk}, "index": 0, "finish_reason": None}]
+                    }
+                    success = True  # 只要有一个chunk成功，就标记为成功
+                    yield f"data: {json.dumps(formatted_chunk)}\n\n"
+                
+                # 如果成功获取到响应，更新API调用统计
+                if success:
+                    from app.utils.stats import update_api_call_stats
+                    update_api_call_stats(api_call_stats, current_api_key)
+                    
+                yield "data: [DONE]\n\n"
+                
+            except asyncio.CancelledError:
+                extra_log_cancel = {'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model, 'error_message': '客户端已断开连接'}
+                log('info', "客户端连接已中断", extra=extra_log_cancel)
+            except Exception as e:
+                error_detail = handle_gemini_error(e, current_api_key, key_manager)
+                log('error', f"流式请求失败: {error_detail}",
+                    extra={'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+                # 发送错误信息给客户端
+                error_json = {
+                    "id": "chatcmpl-error",
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": chat_request.model,
+                    "choices": [{"delta": {"content": f"\n\n[错误: {error_detail}]"}, "index": 0, "finish_reason": "error"}]
+                }
+                yield f"data: {json.dumps(error_json)}\n\n"
+                yield "data: [DONE]\n\n"
+                # 重新抛出异常，这样process_request可以捕获它
+                raise e
+    
+    return StreamingResponse(stream_response_generator(), media_type="text/event-stream")
+
+# Gemini完成请求函数
+async def run_gemini_completion(
+    gemini_client, 
+    chat_request: ChatCompletionRequest, 
+    contents,
+    system_instruction,
+    request_type: str,
+    current_api_key: str
+):
+    """运行Gemini非流式请求"""
+    # 记录函数调用状态
+    run_fn = run_gemini_completion
+    
+    try:
+        # 创建一个不会被客户端断开影响的任务
+        response_future = asyncio.create_task(
+            asyncio.to_thread(
+                gemini_client.complete_chat, 
+                chat_request, 
+                contents, 
+                safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings, 
+                system_instruction
+            )
+        )
+        
+        # 使用shield防止任务被外部取消
+        response_content = await asyncio.shield(response_future)
+        
+        # 只在第一次调用时记录完成日志
+        if not hasattr(run_fn, 'logged_complete'):
+            log('info', "非流式请求成功完成", extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+            run_fn.logged_complete = True
+        return response_content
+    except asyncio.CancelledError:
+        # 即使任务被取消，我们也确保正在进行的API请求能够完成
+        if 'response_future' in locals() and not response_future.done():
+            try:
+                # 使用shield确保任务不被取消，并等待它完成
+                response_content = await asyncio.shield(response_future)
+                log('info', "API请求在客户端断开后完成", extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+                return response_content
+            except Exception as e:
+                extra_log_gemini_cancel = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': f'API请求在客户端断开后失败: {str(e)}'}
+                log('info', "API调用因客户端断开而失败", extra=extra_log_gemini_cancel)
+                raise
+        
+        # 如果任务尚未开始或已经失败，记录日志
+        extra_log_gemini_cancel = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': '客户端断开导致API调用取消'}
+        log('info', "API调用因客户端断开而取消", extra=extra_log_gemini_cancel)
+        raise
+
+# 客户端断开检测函数
+async def check_client_disconnect(http_request: Request, current_api_key: str, request_type: str, model: str):
+    """检查客户端是否断开连接"""
+    while True:
+        if await http_request.is_disconnected():
+            extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': model, 'error_message': '检测到客户端断开连接'}
+            log('info', "客户端连接已中断，等待API请求完成", extra=extra_log)
+            return True
+        await asyncio.sleep(0.5)
+
+# 客户端断开处理函数
+async def handle_client_disconnect(
+    gemini_task: asyncio.Task, 
+    chat_request: ChatCompletionRequest, 
+    request_type: str, 
+    current_api_key: str,
+    cache_key: str = None,
+    client_ip: str = None
+):
+    try:
+        # 等待API任务完成，使用shield防止它被取消
+        response_content = await asyncio.shield(gemini_task)
+        
+        # 检查响应文本是否为空
+        if response_content is None or response_content.text == "":
+            if response_content is None:
+                log('info', "客户端断开后API任务返回None", 
+                    extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+            else:
+                extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'status_code': 204}
+                log('info', "客户端断开后Gemini API 返回空响应", extra=extra_log)
+            
+            # 删除任何现有缓存，因为响应为空
+            if cache_key and cache_key in response_cache_manager.cache:
+                log('info', f"因空响应，删除缓存: {cache_key[:8]}...", 
+                    extra={'cache_operation': 'remove-on-empty', 'request_type': request_type})
+                del response_cache_manager.cache[cache_key]
+                
+            # 返回错误响应而不是None
+            return create_error_response(chat_request.model, "AI未返回任何内容，请重试")
+        
+        # 首先检查是否有现有缓存
+        cached_response, cache_hit = response_cache_manager.get(cache_key)
+        if cache_hit:
+            log('info', f"客户端断开但找到已存在缓存��将删除: {cache_key[:8]}...", 
+                extra={'cache_operation': 'disconnect-found-cache', 'request_type': request_type})
+            
+            # 安全删除缓存
+            if cache_key in response_cache_manager.cache:
+                del response_cache_manager.cache[cache_key]
+            
+            # 不返回缓存，而是创建新响应并缓存
+        
+        # 创建新响应
+        from app.utils.response import create_response
+        response = create_response(chat_request, response_content)
+        
+        # 客户端已断开，此响应不会实际发送，可以考虑将其缓存以供后续使用
+        # 如果确实需要缓存，则可以取消下面的注释
+        # cache_response(response, cache_key, client_ip)
+        
+        return response
+    except asyncio.CancelledError:
+        # 对于取消异常，仍然尝试继续完成任务
+        log('info', "客户端断开后任务被取消，但我们仍会尝试完成", 
+            extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+        
+        # 检查任务是否已经完成
+        if gemini_task.done() and not gemini_task.cancelled():
+            try:
+                response_content = gemini_task.result()
+                
+                # 首先检查是否有现有缓存
+                cached_response, cache_hit = response_cache_manager.get(cache_key)
+                if cache_hit:
+                    log('info', f"任务被取消但找到已存在缓存，将删除: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'cancel-found-cache', 'request_type': request_type})
+                    
+                    # 安全删除缓存
+                    if cache_key in response_cache_manager.cache:
+                        del response_cache_manager.cache[cache_key]
+                
+                # 创建但不缓存响应
+                from app.utils.response import create_response
+                response = create_response(chat_request, response_content)
+                return response
+            except Exception as inner_e:
+                log('error', f"客户端断开后从已完成任务获取结果失败: {str(inner_e)}", 
+                    extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+                
+                # 删除缓存，因为出现错误
+                if cache_key and cache_key in response_cache_manager.cache:
+                    log('info', f"因任务获取结果失败，删除缓存: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
+                    del response_cache_manager.cache[cache_key]
+        
+        # 创建错误响应而不是返回None
+        return create_error_response(chat_request.model, "请求处理过程中发生错误，请重试")
+    except Exception as e:
+        # 处理API任务异常
+        error_msg = str(e)
+        extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': error_msg}
+        log('error', f"客户端断开后处理API响应时出错: {error_msg}", extra=extra_log)
+        
+        # 删除缓存，因为出现错误
+        if cache_key and cache_key in response_cache_manager.cache:
+            log('info', f"因API响应错误，删除缓存: {cache_key[:8]}...", 
+                extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
+            del response_cache_manager.cache[cache_key]
+            
+        # 创建错误响应而不是返回None
+        return create_error_response(chat_request.model, f"请求处理错误: {error_msg}")
+
+# 非流式请求处理函数
+async def process_nonstream_request(
+    chat_request: ChatCompletionRequest, 
+    http_request: Request, 
+    request_type: str,
+    contents,
+    system_instruction,
+    current_api_key: str,
+    cache_key: str = None,
+    client_ip: str = None
+):
+    """处理非流式API请求"""
+    gemini_client = GeminiClient(current_api_key)
+    
+    # 创建任务
+    gemini_task = asyncio.create_task(
+        run_gemini_completion(
+            gemini_client,
+            chat_request,
+            contents,
+            system_instruction,
+            request_type,
+            current_api_key
+        )
+    )
+    
+    disconnect_task = asyncio.create_task(
+        check_client_disconnect(
+            http_request,
+            current_api_key,
+            request_type,
+            chat_request.model
+        )
+    )
+
+    try:
+        # 先等待看是否API任务先完成，或者客户端先断开连接
+        done, pending = await asyncio.wait(
+            [gemini_task, disconnect_task],
+            return_when=asyncio.FIRST_COMPLETED
+        )
+
+        if disconnect_task in done:
+            # 客户端已断开连接，但我们仍继续完成API请求以便缓存结果
+            return await handle_client_disconnect(
+                gemini_task,
+                chat_request,
+                request_type,
+                current_api_key,
+                cache_key,
+                client_ip
+            )
+        else:
+            # API任务先完成，取消断开检测任务
+            disconnect_task.cancel()
+            
+            # 获取响应内容
+            response_content = await gemini_task
+            
+            # 检查缓存是否已经存在，如果存在则不再创建新缓存
+            cached_response, cache_hit = response_cache_manager.get(cache_key)
+            if cache_hit:
+                log('info', f"缓存已存在，直接返回: {cache_key[:8]}...", 
+                    extra={'cache_operation': 'use-existing', 'request_type': request_type})
+                
+                # 安全删除缓存
+                if cache_key in response_cache_manager.cache:
+                    del response_cache_manager.cache[cache_key]
+                    log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'used-and-removed', 'request_type': request_type})
+                
+                return cached_response
+            
+            # 创建响应
+            from app.utils.response import create_response
+            response = create_response(chat_request, response_content)
+            
+            # 缓存响应
+            cache_response(response, cache_key, client_ip, response_cache_manager, update_api_call_stats, api_key=current_api_key)
+            
+            # 立即删除缓存，确保只能使用一次
+            if cache_key and cache_key in response_cache_manager.cache:
+                del response_cache_manager.cache[cache_key]
+                log('info', f"缓存创建后立即删除: {cache_key[:8]}...", 
+                    extra={'cache_operation': 'store-and-remove', 'request_type': request_type})
+            
+            # 返回响应
+            return response
+
+    except asyncio.CancelledError:
+        extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message':"请求被取消"}
+        log('info', "请求取消", extra=extra_log)
+        
+        # 在请求被取消时先检查缓存中是否已有结果
+        cached_response, cache_hit = response_cache_manager.get(cache_key)
+        if cache_hit:
+            log('info', f"请求取消但找到有效缓存，使用缓存响应: {cache_key[:8]}...", 
+                extra={'cache_operation': 'use-cache-on-cancel', 'request_type': request_type})
+            
+            # 安全删除缓存
+            if cache_key in response_cache_manager.cache:
+                del response_cache_manager.cache[cache_key]
+                log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
+                    extra={'cache_operation': 'used-and-removed', 'request_type': request_type})
+            
+            return cached_response
+            
+        # 尝试完成正在进行的API请求
+        if not gemini_task.done():
+            log('info', "请求取消但API请求尚未完成，继续等待...", 
+                extra={'key': current_api_key[:8], 'request_type': request_type})
+            
+            # 使用shield确保任务不会被取消
+            response_content = await asyncio.shield(gemini_task)
+            
+            # 创建响应
+            from app.utils.response import create_response
+            response = create_response(chat_request, response_content)
+            
+            # 不缓存这个响应，直接返回
+            return response
+        else:
+            # 任务已完成，获取结果
+            response_content = gemini_task.result()
+            
+            # 创建响应
+            from app.utils.response import create_response
+            response = create_response(chat_request, response_content)
+            
+            # 不缓存这个响应，直接返回
+            return response
+
+    except HTTPException as e:
+        if e.status_code == status.HTTP_408_REQUEST_TIMEOUT:
+            extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 
+                        'status_code': 408, 'error_message': '客户端连接中断'}
+            log('error', "客户端连接中断，终止后续重试", extra=extra_log)
+            raise  
+        else:
+            raise

app/config/__init__.py

@@ -0,0 +1,3 @@
+# 配置模块初始化文件
+from app.config.settings import *
+from app.config.safety import *

app/config/safety.py

@@ -0,0 +1,49 @@
+# 安全设置配置
+
+# Gemini 1.0 安全设置
+SAFETY_SETTINGS = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'BLOCK_NONE'
+    }
+]
+
+# Gemini 2.0 安全设置
+SAFETY_SETTINGS_G2 = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "OFF"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'OFF'
+    }
+]

app/config/settings.py

@@ -0,0 +1,60 @@
+import os
+import pathlib
+import logging
+from datetime import datetime, timedelta
+
+# 基础目录设置
+BASE_DIR = pathlib.Path(__file__).parent.parent
+
+# 流式响应配置
+FAKE_STREAMING = os.environ.get("FAKE_STREAMING", "true").lower() in ["true", "1", "yes"]
+# 假流式请求的空内容返回间隔（秒）
+FAKE_STREAMING_INTERVAL = float(os.environ.get("FAKE_STREAMING_INTERVAL", "1"))
+
+# 日志配置
+logging.getLogger("uvicorn").disabled = True
+logging.getLogger("uvicorn.access").disabled = True
+
+# 安全配置
+PASSWORD = os.environ.get("PASSWORD", "123").strip('"')
+MAX_REQUESTS_PER_MINUTE = int(os.environ.get("MAX_REQUESTS_PER_MINUTE", "30"))
+MAX_REQUESTS_PER_DAY_PER_IP = int(os.environ.get("MAX_REQUESTS_PER_DAY_PER_IP", "600"))
+RETRY_DELAY = 1
+MAX_RETRY_DELAY = 16
+
+# API密钥使用限制
+# 默认每个API密钥每24小时可使用次数
+API_KEY_DAILY_LIMIT = int(os.environ.get("API_KEY_DAILY_LIMIT", "25"))
+
+# 缓存配置
+CACHE_EXPIRY_TIME = int(os.environ.get("CACHE_EXPIRY_TIME", "1200"))  # 默认20分钟
+MAX_CACHE_ENTRIES = int(os.environ.get("MAX_CACHE_ENTRIES", "500"))  # 默认最多缓存500条响应
+REMOVE_CACHE_AFTER_USE = os.environ.get("REMOVE_CACHE_AFTER_USE", "true").lower() in ["true", "1", "yes"]
+
+# 请求历史配置
+REQUEST_HISTORY_EXPIRY_TIME = int(os.environ.get("REQUEST_HISTORY_EXPIRY_TIME", "600"))  # 默认10分钟
+ENABLE_RECONNECT_DETECTION = os.environ.get("ENABLE_RECONNECT_DETECTION", "true").lower() in ["true", "1", "yes"]
+
+# 版本信息
+local_version = "0.0.4"
+remote_version = "0.0.4"
+has_update = False
+
+# API调用统计
+api_call_stats = {
+    'last_24h': {
+        'total': {},  # 按小时统计过去24小时总调用次数
+        'by_endpoint': {}  # 按API端点分类的24小时统计（也用于API密钥统计）
+    },
+    'hourly': {
+        'total': {},  # 按小时统计过去一小时总调用次数
+        'by_endpoint': {}  # 按API端点分类的小时统计（也用于API密钥统计）
+    },
+    'minute': {
+        'total': {},  # 按分钟统计过去一分钟总调用次数
+        'by_endpoint': {}  # 按API端点分类的分钟统计（也用于API密钥统计）
+    }
+}
+
+# 客户端IP到最近请求的映射，用于识别重连请求
+client_request_history = {}

app/main.py

@@ -1,312 +1,84 @@
-from fastapi import FastAPI, HTTPException, Request, Depends, status
-from fastapi.responses import JSONResponse, StreamingResponse, HTMLResponse
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.responses import JSONResponse, HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from .models import ChatCompletionRequest, ChatCompletionResponse, ErrorResponse, ModelList
-from .gemini import GeminiClient, ResponseWrapper
-from .utils import handle_gemini_error, protect_from_abuse, APIKeyManager, test_api_key, format_log_message, log_manager
+from app.models import ErrorResponse
+from app.services import GeminiClient
+from app.utils import (
+    APIKeyManager, 
+    test_api_key, 
+    format_log_message, 
+    log_manager,
+    ResponseCacheManager,
+    ActiveRequestsManager,
+    clean_expired_stats,
+    update_api_call_stats,
+    check_version,
+    schedule_cache_cleanup,
+    handle_exception,
+    log
+)
+from app.api import router, init_router, dashboard_router, init_dashboard_router
+from app.config.settings import (
+    FAKE_STREAMING,
+    FAKE_STREAMING_INTERVAL,
+    PASSWORD,
+    MAX_REQUESTS_PER_MINUTE,
+    MAX_REQUESTS_PER_DAY_PER_IP,
+    RETRY_DELAY,
+    MAX_RETRY_DELAY,
+    CACHE_EXPIRY_TIME,
+    MAX_CACHE_ENTRIES,
+    REMOVE_CACHE_AFTER_USE,
+    REQUEST_HISTORY_EXPIRY_TIME,
+    ENABLE_RECONNECT_DETECTION,
+    api_call_stats,
+    client_request_history,
+    local_version,
+    remote_version,
+    has_update,
+    API_KEY_DAILY_LIMIT
+)
+from app.config.safety import SAFETY_SETTINGS, SAFETY_SETTINGS_G2
 import os
 import json
 import asyncio
-from typing import Literal, Dict, Any, Optional
-import random
-import requests
+import time
+import logging
 from datetime import datetime, timedelta
-from apscheduler.schedulers.background import BackgroundScheduler
 import sys
-import logging
-from collections import defaultdict
 import pathlib
-import hashlib
-import time
-FAKE_STREAMING = os.environ.get("FAKE_STREAMING", "true").lower() in ["true", "1", "yes"]
-# 假流式请求的空内容返回间隔（秒）
-FAKE_STREAMING_INTERVAL = float(os.environ.get("FAKE_STREAMING_INTERVAL", "1"))
-logging.getLogger("uvicorn").disabled = True
-logging.getLogger("uvicorn.access").disabled = True
-
-# 配置 logger
-logger = logging.getLogger("my_logger")
-logger.setLevel(logging.DEBUG)
 
 # 设置模板目录
 BASE_DIR = pathlib.Path(__file__).parent
-templates = Jinja2Templates(directory=str(BASE_DIR))
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
 
 app = FastAPI()
 
-# --------------- 缓存管理类 ---------------
-
-class ResponseCacheManager:
-    """管理API响应缓存的类"""
-    
-    def __init__(self, expiry_time: int, max_entries: int, remove_after_use: bool = True, 
-                cache_dict: Dict[str, Dict[str, Any]] = None):
-        self.cache = cache_dict if cache_dict is not None else {}  # 使用传入的缓存字典或创建新字典
-        self.expiry_time = expiry_time
-        self.max_entries = max_entries
-        self.remove_after_use = remove_after_use
-    
-    def get(self, cache_key: str):
-        """获取缓存项，如果存在且未过期"""
-        now = time.time()
-        if cache_key in self.cache and now < self.cache[cache_key].get('expiry_time', 0):
-            cached_item = self.cache[cache_key]
-            
-            # 获取响应但先不删除
-            response = cached_item['response']
-            
-            # 返回响应
-            return response, True
-        
-        return None, False
-    
-    def store(self, cache_key: str, response, client_ip: str = None):
-        """存储响应到缓存"""
-        now = time.time()
-        self.cache[cache_key] = {
-            'response': response,
-            'expiry_time': now + self.expiry_time,
-            'created_at': now,
-            'client_ip': client_ip
-        }
-        
-        log('info', f"响应已缓存: {cache_key[:8]}...", 
-            extra={'cache_operation': 'store', 'request_type': 'non-stream'})
-        
-        # 如果缓存超过限制，清理最旧的
-        self.clean_if_needed()
-    
-    def clean_expired(self):
-        """清理所有过期的缓存项"""
-        now = time.time()
-        expired_keys = [k for k, v in self.cache.items() if now > v.get('expiry_time', 0)]
-        
-        for key in expired_keys:
-            del self.cache[key]
-            log('info', f"清理过期缓存: {key[:8]}...", extra={'cache_operation': 'clean'})
-    
-    def clean_if_needed(self):
-        """如果缓存数量超过限制，清理最旧的项目"""
-        if len(self.cache) <= self.max_entries:
-            return
-        
-        # 按创建时间排序
-        sorted_keys = sorted(self.cache.keys(),
-                           key=lambda k: self.cache[k].get('created_at', 0))
-        
-        # 计算需要删除的数量
-        to_remove = len(self.cache) - self.max_entries
-        
-        # 删除最旧的项
-        for key in sorted_keys[:to_remove]:
-            del self.cache[key]
-            log('info', f"缓存容量限制，删除旧缓存: {key[:8]}...", extra={'cache_operation': 'limit'})
-
-# --------------- 活跃请求管理类 ---------------
-
-class ActiveRequestsManager:
-    """管理活跃API请求的类"""
-    
-    def __init__(self, requests_pool: Dict[str, asyncio.Task] = None):
-        self.active_requests = requests_pool if requests_pool is not None else {}  # 存储活跃请求
-    
-    def add(self, key: str, task: asyncio.Task):
-        """添加新的活跃请求任务"""
-        task.creation_time = time.time()  # 添加创建时间属性
-        self.active_requests[key] = task
-    
-    def get(self, key: str):
-        """获取活跃请求任务"""
-        return self.active_requests.get(key)
-    
-    def remove(self, key: str):
-        """移除活跃请求任务"""
-        if key in self.active_requests:
-            del self.active_requests[key]
-            return True
-        return False
-    
-    def remove_by_prefix(self, prefix: str):
-        """移除所有以特定前缀开头的活跃请求任务"""
-        keys_to_remove = [k for k in self.active_requests.keys() if k.startswith(prefix)]
-        for key in keys_to_remove:
-            self.remove(key)
-        return len(keys_to_remove)
-    
-    def clean_completed(self):
-        """清理所有已完成或已取消的任务"""
-        keys_to_remove = []
-        
-        for key, task in self.active_requests.items():
-            if task.done() or task.cancelled():
-                keys_to_remove.append(key)
-        
-        for key in keys_to_remove:
-            self.remove(key)
-        
-        # if keys_to_remove:
-        #    log('info', f"清理已完成请求任务: {len(keys_to_remove)}个", cleanup='active_requests')
-    
-    def clean_long_running(self, max_age_seconds: int = 300):
-        """清理长时间运行的任务"""
-        now = time.time()
-        long_running_keys = []
-        
-        for key, task in list(self.active_requests.items()):
-            if (hasattr(task, 'creation_time') and
-                task.creation_time < now - max_age_seconds and
-                not task.done() and not task.cancelled()):
-                
-                long_running_keys.append(key)
-                task.cancel()  # 取消长时间运行的任务
-        
-        if long_running_keys:
-            log('warning', f"取消长时间运行的任务: {len(long_running_keys)}个", cleanup='long_running_tasks')
-
-
-
 # --------------- 全局实例 ---------------
 
-PASSWORD = os.environ.get("PASSWORD", "123").strip('"')
-MAX_REQUESTS_PER_MINUTE = int(os.environ.get("MAX_REQUESTS_PER_MINUTE", "30"))
-MAX_REQUESTS_PER_DAY_PER_IP = int(
-    os.environ.get("MAX_REQUESTS_PER_DAY_PER_IP", "600"))
-# MAX_RETRIES = int(os.environ.get('MaxRetries', '3').strip() or '3')
-RETRY_DELAY = 1
-MAX_RETRY_DELAY = 16
-MAX_RETRY_DELAY = 16
-safety_settings = [
-    {
-        "category": "HARM_CATEGORY_HARASSMENT",
-        "threshold": "BLOCK_NONE"
-    },
-    {
-        "category": "HARM_CATEGORY_HATE_SPEECH",
-        "threshold": "BLOCK_NONE"
-    },
-    {
-        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-        "threshold": "BLOCK_NONE"
-    },
-    {
-        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-        "threshold": "BLOCK_NONE"
-    },
-    {
-        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
-        "threshold": 'BLOCK_NONE'
-    }
-]
-safety_settings_g2 = [
-    {
-        "category": "HARM_CATEGORY_HARASSMENT",
-        "threshold": "OFF"
-    },
-    {
-        "category": "HARM_CATEGORY_HATE_SPEECH",
-        "threshold": "OFF"
-    },
-    {
-        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-        "threshold": "OFF"
-    },
-    {
-        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-        "threshold": "OFF"
-    },
-    {
-        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
-        "threshold": 'OFF'
-    }
-]
-
-key_manager = APIKeyManager() # 实例化 APIKeyManager，栈会在 __init__ 中初始化
+# 初始化API密钥管理器
+key_manager = APIKeyManager()
 current_api_key = key_manager.get_available_key()
 
-# 初始化缓存管理器
-CACHE_EXPIRY_TIME = int(os.environ.get("CACHE_EXPIRY_TIME", "1200"))  # 默认20分钟
-MAX_CACHE_ENTRIES = int(os.environ.get("MAX_CACHE_ENTRIES", "500"))  # 默认最多缓存500条响应
-REMOVE_CACHE_AFTER_USE = os.environ.get("REMOVE_CACHE_AFTER_USE", "true").lower() in ["true", "1", "yes"]
-
 # 创建全局缓存字典，将作为缓存管理器的内部存储
-# 注意：所有缓存操作都应通过 response_cache_manager 进行，不要直接操作此字典
-response_cache: Dict[str, Dict[str, Any]] = {}
+response_cache = {}
 
 # 初始化缓存管理器，使用全局字典作为存储
 response_cache_manager = ResponseCacheManager(
     expiry_time=CACHE_EXPIRY_TIME,
     max_entries=MAX_CACHE_ENTRIES,
     remove_after_use=REMOVE_CACHE_AFTER_USE,
-    cache_dict=response_cache  # 使用同一个��典实例，确保统一
+    cache_dict=response_cache
 )
 
 # 活跃请求池 - 将作为活跃请求管理器的内部存储
-# 注意：所有活跃请求操作都应通过 active_requests_manager 进行，不要直接操作此字典
-active_requests_pool: Dict[str, asyncio.Task] = {}
+active_requests_pool = {}
 
 # 初始化活跃请求管理器
 active_requests_manager = ActiveRequestsManager(requests_pool=active_requests_pool)
 
-# 添加API调用计数器
-api_call_stats = {
-    'last_24h': defaultdict(int),  # 按小时统计过去24小时
-    'hourly': defaultdict(int),    # 按小时统计过去一小时
-    'minute': defaultdict(int),    # 按分钟统计过去一分钟
-}
-
-# 清理过期统计数据的函数
-def clean_expired_stats():
-    now = datetime.now()
-    
-    # 清理24小时前的数据
-    for hour_key in list(api_call_stats['last_24h'].keys()):
-        try:
-            hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
-            if (now - hour_time).total_seconds() > 24 * 3600:  # 超过24小时
-                del api_call_stats['last_24h'][hour_key]
-        except ValueError:
-            # 如果键格式不正确，直接删除
-            del api_call_stats['last_24h'][hour_key]
-    
-    # 清理一小时前的小时统计数据
-    one_hour_ago = now - timedelta(hours=1)
-    for hour_key in list(api_call_stats['hourly'].keys()):
-        try:
-            hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
-            if hour_time < one_hour_ago:
-                del api_call_stats['hourly'][hour_key]
-        except ValueError:
-            # 如果键格式不正确，直接删除
-            del api_call_stats['hourly'][hour_key]
-    
-    # 清理一分钟前的分钟统计数据
-    one_minute_ago = now - timedelta(minutes=1)
-    for minute_key in list(api_call_stats['minute'].keys()):
-        try:
-            minute_time = datetime.strptime(minute_key, '%Y-%m-%d %H:%M')
-            if minute_time < one_minute_ago:
-                del api_call_stats['minute'][minute_key]
-        except ValueError:
-            # 如果键格式不正确，直接删除
-            del api_call_stats['minute'][minute_key]
-
-# 更新API调用统计的函数
-def update_api_call_stats():
-    now = datetime.now()
-    hour_key = now.strftime('%Y-%m-%d %H:00')
-    minute_key = now.strftime('%Y-%m-%d %H:%M')
-    
-    # 检查并清理过期统计
-    clean_expired_stats()
-    
-    # 更新统计
-    api_call_stats['last_24h'][hour_key] += 1
-    api_call_stats['hourly'][hour_key] += 1
-    api_call_stats['minute'][minute_key] += 1
-    
-    log('info', "API调用统计已更新: 24小时=%s, 1小时=%s, 1分钟=%s" % (sum(api_call_stats['last_24h'].values()), sum(api_call_stats['hourly'].values()), sum(api_call_stats['minute'].values())))
-
+# --------------- 工具函数 ---------------
 
 def switch_api_key():
     global current_api_key
@@ -317,7 +89,6 @@ def switch_api_key():
     else:
         log('error', "API key 替换失败，所有API key都已尝试，请重新配置或稍后重试", extra={'key': 'N/A', 'request_type': 'switch_key', 'status_code': 'N/A'})
 
-
 async def check_keys():
     available_keys = []
     for key in key_manager.api_keys:
@@ -330,110 +101,17 @@ async def check_keys():
         log('error', "没有可用的 API 密钥！", extra={'key': 'N/A', 'request_type': 'startup', 'status_code': 'N/A'})
     return available_keys
 
-
-# 存储版本信息的全局变量
-local_version = "0.0.0"
-remote_version = "0.0.0"
-has_update = False
-
-# 检查版本更新
-async def check_version():
-    global local_version, remote_version, has_update
-    try:
-        # 读取本地版本
-        with open("version.txt", "r") as f:
-            version_line = f.read().strip()
-            local_version = version_line.split("=")[1] if "=" in version_line else "0.0.0"
-        
-        # 获取远程版本
-        github_url = "https://raw.githubusercontent.com/wyeeeee/hajimi/refs/heads/main/version.txt"
-        response = requests.get(github_url, timeout=5)
-        if response.status_code == 200:
-            version_line = response.text.strip()
-            remote_version = version_line.split("=")[1] if "=" in version_line else "0.0.0"
-            
-            # 比较版本号
-            local_parts = [int(x) for x in local_version.split(".")]
-            remote_parts = [int(x) for x in remote_version.split(".")]
-            
-            # 确保两个列表长度相同
-            while len(local_parts) < len(remote_parts):
-                local_parts.append(0)
-            while len(remote_parts) < len(local_parts):
-                remote_parts.append(0)
-                
-            # 比较版本号
-            for i in range(len(local_parts)):
-                if remote_parts[i] > local_parts[i]:
-                    has_update = True
-                    break
-                elif remote_parts[i] < local_parts[i]:
-                    break
-            
-            log('info', f"版本检查: 本地版本 {local_version}, 远程版本 {remote_version}, 有更新: {has_update}")
-        else:
-            log('warning', f"无法获取远程版本信息，HTTP状态码: {response.status_code}")
-    except Exception as e:
-        log('error', f"版本检查失败: {str(e)}")
-
-
-# --------------- 工具函数 ---------------
-
-def log(level: str, message: str, **extra):
-    """简化日志记录的统一函数"""
-    msg = format_log_message(level.upper(), message, extra=extra)
-    getattr(logger, level.lower())(msg)
-
-def translate_error(message: str) -> str:
-    if "quota exceeded" in message.lower():
-        return "API 密钥配额已用尽"
-    if "invalid argument" in message.lower():
-        return "无效参数"
-    if "internal server error" in message.lower():
-        return "服务器内部错误"
-    if "service unavailable" in message.lower():
-        return "服务不可用"
-    return message
-
-def create_chat_response(model: str, choices: list, id: str = None) -> ChatCompletionResponse:
-    """创建标准响应对象的工厂函数"""
-    return ChatCompletionResponse(
-        id=id or f"chatcmpl-{int(time.time()*1000)}",
-        object="chat.completion",
-        created=int(time.time()),
-        model=model,
-        choices=choices
-    )
-
-def create_error_response(model: str, error_message: str) -> ChatCompletionResponse:
-    """创建错误响应对象的工厂函数"""
-    return create_chat_response(
-        model=model,
-        choices=[{
-            "index": 0,
-            "message": {
-                "role": "assistant",
-                "content": error_message
-            },
-            "finish_reason": "error"
-        }]
-    )
-
-def handle_exception(exc_type, exc_value, exc_traceback):
-    if issubclass(exc_type, KeyboardInterrupt):
-        sys.excepthook(exc_type, exc_value, exc_traceback)
-        return
-    error_message = translate_error(str(exc_value))
-    log('error', f"未捕获的异常: {error_message}", status_code=500, error_message=error_message)
-
+# 设置全局异常处理
 sys.excepthook = handle_exception
 
+# --------------- 事件处理 ---------------
+
 @app.on_event("startup")
 async def startup_event():
     log('info', "Starting Gemini API proxy...")
     
     # 启动缓存清理定时任务
-    schedule_cache_cleanup()
+    schedule_cache_cleanup(response_cache_manager, active_requests_manager)
     
     # 检查版本
     await check_version()
@@ -444,301 +122,67 @@ async def startup_event():
         key_manager._reset_key_stack() # 启动时也确保创建随机栈
         key_manager.show_all_keys()
         log('info', f"可用 API 密钥数量：{len(key_manager.api_keys)}")
-        # MAX_RETRIES = len(key_manager.api_keys)
-        log('info', f"最大重试次数设置为：{len(key_manager.api_keys)}") # 添加日志
+        log('info', f"最大重试次数设置为：{len(key_manager.api_keys)}")
         if key_manager.api_keys:
             all_models = await GeminiClient.list_available_models(key_manager.api_keys[0])
             GeminiClient.AVAILABLE_MODELS = [model.replace(
                 "models/", "") for model in all_models]
             log('info', "Available models loaded.")
-
-@app.get("/v1/models", response_model=ModelList)
-def list_models():
-    log('info', "Received request to list models", extra={'request_type': 'list_models', 'status_code': 200})
-    return ModelList(data=[{"id": model, "object": "model", "created": 1678888888, "owned_by": "organization-owner"} for model in GeminiClient.AVAILABLE_MODELS])
-
-
-async def verify_password(request: Request):
-    if PASSWORD:
-        auth_header = request.headers.get("Authorization")
-        if not auth_header or not auth_header.startswith("Bearer "):
-            raise HTTPException(
-                status_code=401, detail="Unauthorized: Missing or invalid token")
-        token = auth_header.split(" ")[1]
-        if token != PASSWORD:
-            raise HTTPException(
-                status_code=401, detail="Unauthorized: Invalid token")
-
-
-@app.post("/v1/chat/completions", response_model=ChatCompletionResponse)
-async def chat_completions(request: ChatCompletionRequest, http_request: Request, _: None = Depends(verify_password)):
-    # 获取客户端IP
-    client_ip = http_request.client.host if http_request.client else "unknown"
-    
-    # 流式请求直接处理，不使用缓存
-    if request.stream:
-        return await process_request(request, http_request, "stream")
     
-    # 生成完整缓存键 - 用于精确匹配
-    cache_key = generate_cache_key(request)
-    
-    # 记录请求缓存键信息
-    log('info', f"请求缓存键: {cache_key[:8]}...", 
-        extra={'cache_key': cache_key[:8], 'request_type': 'non-stream'})
-    
-    # 检查精确缓存是否存在且未过期
-    cached_response, cache_hit = response_cache_manager.get(cache_key)
-    if cache_hit:
-        # 精确缓存命中
-        log('info', f"精确缓存命中: {cache_key[:8]}...", 
-            extra={'cache_operation': 'hit', 'request_type': 'non-stream'})
-        
-        # 同时清理相关的活跃任务，避免后续请求等待已经不需要的任务
-        active_requests_manager.remove_by_prefix(f"cache:{cache_key}")
-        
-        # 安全删除缓存
-        if cache_key in response_cache_manager.cache:
-            del response_cache_manager.cache[cache_key]
-            log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
-                extra={'cache_operation': 'used-and-removed', 'request_type': 'non-stream'})
-        
-        # 返回缓存响应
-        return cached_response
-    
-    # 构建包含缓存键的活跃请求池键
-    pool_key = f"cache:{cache_key}"
-    
-    # 查找所有使用相同缓存键的活跃任务
-    active_task = active_requests_manager.get(pool_key)
-    if active_task and not active_task.done():
-        log('info', f"发现相同请求的进行中任务", 
-            extra={'request_type': 'non-stream', 'model': request.model})
-        
-        # 等待已有任务完成
-        try:
-            # 设置超时，避免无限等待
-            await asyncio.wait_for(active_task, timeout=180)
-            
-            # 通过缓存管理器获取已完成任务的结果
-            cached_response, cache_hit = response_cache_manager.get(cache_key)
-            if cache_hit:
-                # 安全删除缓存
-                if cache_key in response_cache_manager.cache:
-                    del response_cache_manager.cache[cache_key]
-                    log('info', f"使用已完成任务的缓存后删除: {cache_key[:8]}...", 
-                        extra={'cache_operation': 'used-and-removed', 'request_type': 'non-stream'})
-                
-                return cached_response
-                
-            # 如果缓存已被清除或不存在，使用任务结果
-            if active_task.done() and not active_task.cancelled():
-                result = active_task.result()
-                if result:
-                    # log('info', f"使用已完成任务的原始结果", 
-                    #     extra={'request_type': 'non-stream', 'model': request.model})
-                    
-                    # 使用原始结果时，我们需要创建一个新的响应对象
-                    # 避免使用可能已被其他请求修改的对象
-                    new_response = ChatCompletionResponse(
-                        id=f"chatcmpl-{int(time.time()*1000)}",
-                        object="chat.completion", 
-                        created=int(time.time()),
-                        model=result.model,
-                        choices=result.choices
-                    )
-                    
-                    # 不要缓存此结果，因为它很可能是一个已存在但被使用后清除的缓存
-                    return new_response
-        except (asyncio.TimeoutError, asyncio.CancelledError) as e:
-            # 任务超时或被取消的情况下，记录日志然后让代码继续执行
-            error_type = "超时" if isinstance(e, asyncio.TimeoutError) else "被取消"
-            log('warning', f"等待已有任务{error_type}: {pool_key}", 
-                extra={'request_type': 'non-stream', 'model': request.model})
-            
-            # 从活跃请求池移除该任务
-            if active_task.done() or active_task.cancelled():
-                active_requests_manager.remove(pool_key)
-                log('info', f"已从活跃请求池移除{error_type}任务: {pool_key}", 
-                    extra={'request_type': 'non-stream'})
-     
-    # 创建请求处理任务
-    process_task = asyncio.create_task(
-        process_request(request, http_request, "non-stream", cache_key=cache_key, client_ip=client_ip)
+    # 初始化路由器
+    init_router(
+        key_manager,
+        response_cache_manager,
+        active_requests_manager,
+        SAFETY_SETTINGS,
+        SAFETY_SETTINGS_G2,
+        current_api_key,
+        FAKE_STREAMING,
+        FAKE_STREAMING_INTERVAL,
+        PASSWORD,
+        MAX_REQUESTS_PER_MINUTE,
+        MAX_REQUESTS_PER_DAY_PER_IP
     )
     
-    # 将任务添加到活跃请求池
-    active_requests_manager.add(pool_key, process_task)
-    
-    # 等待任务完成
-    try:
-        response = await process_task
-        return response
-    except Exception as e:
-        # 如果任务失败，从活跃请求池中移除
-        active_requests_manager.remove(pool_key)
-        
-        # 检查是否已有缓存的结果（可能是由另一个任务创建的）
-        cached_response, cache_hit = response_cache_manager.get(cache_key)
-        if cache_hit:
-            log('info', f"任务失败但找到缓存，使用缓存结果: {cache_key[:8]}...", 
-                extra={'request_type': 'non-stream', 'model': request.model})
-            return cached_response
-        
-        # 重新抛出异常
-        raise
-
-async def process_request(chat_request: ChatCompletionRequest, http_request: Request, request_type: Literal['stream', 'non-stream'], cache_key: str = None, client_ip: str = None):
-    """处理API请求的主函数，根据需要处理流式或非流式请求"""
-    global current_api_key
-    
-    # 请求前基本检查
-    protect_from_abuse(
-        http_request, MAX_REQUESTS_PER_MINUTE, MAX_REQUESTS_PER_DAY_PER_IP)
-    if chat_request.model not in GeminiClient.AVAILABLE_MODELS:
-        error_msg = "无效的模型"
-        extra_log = {'request_type': request_type, 'model': chat_request.model, 'status_code': 400, 'error_message': error_msg}
-        log('error', error_msg, extra=extra_log)
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST, detail=error_msg)
-
-    # 重置已尝试的密钥
-    key_manager.reset_tried_keys_for_request()
-    
-    # 转换消息格式
-    contents, system_instruction = GeminiClient.convert_messages(
-        GeminiClient, chat_request.messages)
-
-    # 设置重试次数（使用可用API密钥数量作为最大重试次数）
-    retry_attempts = len(key_manager.api_keys) if key_manager.api_keys else 1
-    
-    # 尝试使用不同API密钥
-    for attempt in range(1, retry_attempts + 1):
-        # 获取下一个密钥
-        current_api_key = key_manager.get_available_key()
-        
-        # 检查API密钥是否可用
-        if current_api_key is None:
-            log('warning', "没有可用的 API 密钥，跳过本次尝试", 
-                extra={'request_type': request_type, 'model': chat_request.model, 'status_code': 'N/A'})
-            break
-        
-        # 记录当前尝试的密钥信息
-        log('info', f"第 {attempt}/{retry_attempts} 次尝试 ... 使用密钥: {current_api_key[:8]}...", 
-            extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
-
-        # 服务器错误重试逻辑
-        server_error_retries = 3
-        for server_retry in range(1, server_error_retries + 1):
-            try:
-                # 根据请求类型分别处理
-                if chat_request.stream:
-                    try:
-                        return await process_stream_request(
-                            chat_request,
-                            http_request,
-                            contents,
-                            system_instruction,
-                            current_api_key
-                        )
-                    except Exception as e:
-                        # 捕获流式请求的异常，但不立即返回错误
-                        # 记录错误并继续尝试下一个API密钥
-                        error_detail = handle_gemini_error(e, current_api_key, key_manager)
-                        log('error', f"流式请求失败: {error_detail}",
-                            extra={'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
-                        # 不返回错误，而是抛出异常让外层循环处理
-                        raise
-                else:
-                    return await process_nonstream_request(
-                        chat_request,
-                        http_request,
-                        request_type,
-                        contents,
-                        system_instruction,
-                        current_api_key,
-                        cache_key,
-                        client_ip
-                    )
-            except HTTPException as e:
-                if e.status_code == status.HTTP_408_REQUEST_TIMEOUT:
-                    log('error', "客户端连接中断", 
-                        extra={'key': current_api_key[:8], 'request_type': request_type, 
-                              'model': chat_request.model, 'status_code': 408})
-                    raise
-                else:
-                    raise
-            except Exception as e:
-                # 使用统一的API错误处理函数
-                error_result = await handle_api_error(
-                    e, 
-                    current_api_key, 
-                    key_manager, 
-                    request_type, 
-                    chat_request.model, 
-                    server_retry - 1
-                )
-                
-                # 如果需要删除缓存，清除缓存
-                if error_result.get('remove_cache', False) and cache_key and cache_key in response_cache_manager.cache:
-                    log('info', f"因API错误，删除缓存: {cache_key[:8]}...", 
-                        extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
-                    del response_cache_manager.cache[cache_key]
-                
-                if error_result.get('should_retry', False):
-                    # 服务器错误需要重试（等待已在handle_api_error中完成）
-                    continue
-                elif error_result.get('should_switch_key', False) and attempt < retry_attempts:
-                    # 跳出服务器错误重试循环，获取下一个可用密钥
-                    log('info', f"API密钥 {current_api_key[:8]}... 失败，准备尝试下一个密钥", 
-                        extra={'key': current_api_key[:8], 'request_type': request_type})
-                    break  
-                else:
-                    # 无法处理的错误或已达到重试上限
-                    break
-
-    # 如果所有尝试都失败
-    msg = "所有API密钥均请求失败,请稍后重试"
-    log('error', "API key 替换失败，所有API key都已尝试，请重新配置或稍后重试", extra={'key': 'N/A', 'request_type': 'switch_key', 'status_code': 'N/A'})
-    
-    # 对于流式请求，创建一个特殊的StreamingResponse返回错误
-    if chat_request.stream:
-        async def error_generator():
-            error_json = json.dumps({'error': {'message': msg, 'type': 'api_error'}})
-            yield f"data: {error_json}\n\n"
-            yield "data: [DONE]\n\n"
-        
-        return StreamingResponse(error_generator(), media_type="text/event-stream")
-    else:
-        # 非流式请求使用标准HTTP异常
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=msg)
+    # 初始化仪表盘路由器
+    init_dashboard_router(
+        key_manager,
+        response_cache_manager,
+        active_requests_manager
+    )
 
+# --------------- 异常处理 ---------------
 
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
+    from app.utils import translate_error
     error_message = translate_error(str(exc))
     extra_log_unhandled_exception = {'status_code': 500, 'error_message': error_message}
     log('error', f"Unhandled exception: {error_message}", extra=extra_log_unhandled_exception)
     return JSONResponse(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=ErrorResponse(message=str(exc), type="internal_error").dict())
 
+# --------------- 路由 ---------------
+
+# 包含API路由
+app.include_router(router)
+app.include_router(dashboard_router)
 
 @app.get("/", response_class=HTMLResponse)
 async def root(request: Request):
     # 先清理过期数据，确保统计数据是最新的
-    clean_expired_stats()
+    clean_expired_stats(api_call_stats)
     response_cache_manager.clean_expired()  # 使用管理器清理缓存
     active_requests_manager.clean_completed()  # 使用管理器清理活跃请求
-    await check_version()
     # 获取当前统计数据
     now = datetime.now()
     
     # 计算过去24小时的调用总数
-    last_24h_calls = sum(api_call_stats['last_24h'].values())
+    last_24h_calls = sum(api_call_stats['last_24h']['total'].values())
     
     # 计算过去一小时内的调用总数
     one_hour_ago = now - timedelta(hours=1)
     hourly_calls = 0
-    for hour_key, count in api_call_stats['hourly'].items():
+    for hour_key, count in api_call_stats['hourly']['total'].items():
         try:
             hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
             if hour_time >= one_hour_ago:
@@ -749,7 +193,7 @@ async def root(request: Request):
     # 计算过去一分钟内的调用总数
     one_minute_ago = now - timedelta(minutes=1)
     minute_calls = 0
-    for minute_key, count in api_call_stats['minute'].items():
+    for minute_key, count in api_call_stats['minute']['total'].items():
         try:
             minute_time = datetime.strptime(minute_key, '%Y-%m-%d %H:%M')
             if minute_time >= one_minute_ago:
@@ -785,6 +229,31 @@ async def root(request: Request):
     active_done = sum(1 for task in active_requests_manager.active_requests.values() if task.done())
     active_pending = active_count - active_done
     
+    # 获取API密钥使用统计
+    api_key_stats = []
+    for api_key in key_manager.api_keys:
+        # 获取API密钥前8位作为标识
+        api_key_id = api_key[:8]
+        
+        # 计算24小时内的调用次数
+        calls_24h = 0
+        if 'by_endpoint' in api_call_stats['last_24h'] and api_key in api_call_stats['last_24h']['by_endpoint']:
+            calls_24h = sum(api_call_stats['last_24h']['by_endpoint'][api_key].values())
+        
+        # 计算使用百分比
+        usage_percent = (calls_24h / API_KEY_DAILY_LIMIT) * 100 if API_KEY_DAILY_LIMIT > 0 else 0
+        
+        # 添加到结果列表
+        api_key_stats.append({
+            'api_key': api_key_id,
+            'calls_24h': calls_24h,
+            'limit': API_KEY_DAILY_LIMIT,
+            'usage_percent': round(usage_percent, 2)
+        })
+    
+    # 按使用百分比降序排序
+    api_key_stats.sort(key=lambda x: x['usage_percent'], reverse=True)
+    
     # 准备模板上下文
     context = {
         "key_count": len(key_manager.api_keys),
@@ -815,692 +284,9 @@ async def root(request: Request):
         "active_count": active_count,
         "active_done": active_done,
         "active_pending": active_pending,
+        # 添加API密钥统计
+        "api_key_stats": api_key_stats,
     }
     
     # 使用Jinja2模板引擎正确渲染HTML
-    return templates.TemplateResponse("index.html", {"request": request, **context})
-
-# 客户端IP到最近请求的映射，用于识别重连请求
-client_request_history: Dict[str, Dict[str, Any]] = {}
-# 请求历史记录保留时间（秒）
-REQUEST_HISTORY_EXPIRY_TIME = int(os.environ.get("REQUEST_HISTORY_EXPIRY_TIME", "600"))  # 默认10分钟
-# 是否启用重连检测
-ENABLE_RECONNECT_DETECTION = os.environ.get("ENABLE_RECONNECT_DETECTION", "true").lower() in ["true", "1", "yes"]
-
-# 定期清理缓存的定时任务
-def schedule_cache_cleanup():
-    scheduler = BackgroundScheduler()
-    scheduler.add_job(response_cache_manager.clean_expired, 'interval', minutes=1)  # 每分钟清理过期缓存
-    scheduler.add_job(active_requests_manager.clean_completed, 'interval', seconds=30)  # 每30秒清理已完成的活跃请求
-    scheduler.add_job(active_requests_manager.clean_long_running, 'interval', minutes=5, args=[300])  # 每5分钟清理运行超过5分钟的任务
-    scheduler.add_job(clean_expired_stats, 'interval', minutes=5)  # 每5分钟清理过期的统计数据
-    scheduler.start()
-
-# 生成请求的唯一缓存键
-def generate_cache_key(chat_request: ChatCompletionRequest) -> str:
-    # 创建包含请求关键信息的字典
-    request_data = {
-        'model': chat_request.model, 
-        'messages': []
-    }
-    
-    # 添加消息内容
-    for msg in chat_request.messages:
-        if isinstance(msg.content, str):
-            message_data = {'role': msg.role, 'content': msg.content}
-            request_data['messages'].append(message_data)
-        elif isinstance(msg.content, list):
-            content_list = []
-            for item in msg.content:
-                if item.get('type') == 'text':
-                    content_list.append({'type': 'text', 'text': item.get('text')})
-                # 对于图像数据，我们只使用标识符而不是全部数据
-                elif item.get('type') == 'image_url':
-                    image_data = item.get('image_url', {}).get('url', '')
-                    if image_data.startswith('data:image/'):
-                        # 对于base64图像，使用前32字符作为标识符
-                        content_list.append({'type': 'image_url', 'hash': hashlib.md5(image_data[:32].encode()).hexdigest()})
-                    else:
-                        content_list.append({'type': 'image_url', 'url': image_data})
-            request_data['messages'].append({'role': msg.role, 'content': content_list})
-    
-    # 将字典转换为JSON字符串并计算哈希值
-    json_data = json.dumps(request_data, sort_keys=True)
-    return hashlib.md5(json_data.encode()).hexdigest()
-
-# 拆分process_request为更小的函数
-
-async def process_stream_request(
-    chat_request: ChatCompletionRequest,
-    http_request: Request,
-    contents,
-    system_instruction,
-    current_api_key: str
-) -> StreamingResponse:
-    """处理流式API请求"""
-    
-    # 创建一个直接流式响应的生成器函数
-    async def stream_response_generator():
-        # 如果启用了假流式模式，使用随机遍历API密钥的方式
-        if FAKE_STREAMING:
-            # 创建一个队列用于在任务之间传递数据
-            queue = asyncio.Queue()
-            keep_alive_task = None
-            api_request_task = None
-            
-            try:
-                # 创建一个保持连接的任务，持续发送换行符
-                async def keep_alive_sender():
-                    try:
-                        # 创建一个Gemini客户端用于发送保持连接的换行符
-                        keep_alive_client = GeminiClient(current_api_key)
-                        
-                        # 启动保持连接的生成器
-                        keep_alive_generator = keep_alive_client.stream_chat(
-                            chat_request,
-                            contents,
-                            safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
-                            system_instruction
-                        )
-                        
-                        # 持续发送换行符直到被取消
-                        async for line in keep_alive_generator:
-                            if line == "\n":
-                                # 将换行符格式化为SSE格式
-                                formatted_chunk = {
-                                    "id": "chatcmpl-keepalive",
-                                    "object": "chat.completion.chunk",
-                                    "created": int(time.time()),
-                                    "model": chat_request.model,
-                                    "choices": [{"delta": {"content": ""}, "index": 0, "finish_reason": None}]
-                                }
-                                # 将格式化的换行符放入队列
-                                await queue.put(f"data: {json.dumps(formatted_chunk)}\n\n")
-                    except asyncio.CancelledError:
-                        log('info', "保持连接任务被取消",
-                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
-                        raise
-                    except Exception as e:
-                        log('error', f"保持连接任务出错: {str(e)}",
-                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
-                        # 将错误放入队列
-                        await queue.put(None)
-                        raise
-                
-                # 创建一个任务来随机遍历API密钥并请求内容
-                async def api_request_handler():
-                    success = False
-                    try:
-                        # 重置已尝试的密钥
-                        key_manager.reset_tried_keys_for_request()
-                        
-                        # 获取可用的API密钥
-                        available_keys = key_manager.api_keys.copy()
-                        random.shuffle(available_keys)  # 随机打乱密钥顺序
-                        
-                        # 遍历所有API密钥尝试获取响应
-                        for attempt, api_key in enumerate(available_keys, 1):
-                            try:
-                                log('info', f"假流式模式: 尝试API密钥 {api_key[:8]}... ({attempt}/{len(available_keys)})",
-                                    extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
-                                
-                                # 创建一个新的客户端使用当前API密钥
-                                non_stream_client = GeminiClient(api_key)
-                                
-                                # 使用非流式方式请求内容
-                                response_content = await asyncio.to_thread(
-                                    non_stream_client.complete_chat,
-                                    chat_request,
-                                    contents,
-                                    safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
-                                    system_instruction
-                                )
-                                
-                                # 检查响应是否有效
-                                if response_content and response_content.text:
-                                    log('info', f"假流式模式: API密钥 {api_key[:8]}... 成功获取响应",
-                                        extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
-                                    
-                                    # 将完整响应分割成小块，模拟流式返回
-                                    full_text = response_content.text
-                                    chunk_size = max(len(full_text) // 10, 1)  # 至少分成10块，每块至少1个字符
-                                    
-                                    for i in range(0, len(full_text), chunk_size):
-                                        chunk = full_text[i:i+chunk_size]
-                                        formatted_chunk = {
-                                            "id": "chatcmpl-someid",
-                                            "object": "chat.completion.chunk",
-                                            "created": int(time.time()),
-                                            "model": chat_request.model,
-                                            "choices": [{"delta": {"role": "assistant", "content": chunk}, "index": 0, "finish_reason": None}]
-                                        }
-                                        # 将格式化的内容块放入队列
-                                        await queue.put(f"data: {json.dumps(formatted_chunk)}\n\n")
-                                    
-                                    success = True
-                                    # 更新API调用统计
-                                    update_api_call_stats()
-                                    break  # 成功获取响应，退出循环
-                                else:
-                                    log('warning', f"假流式模式: API密钥 {api_key[:8]}... 返回空响应",
-                                        extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
-                            except Exception as e:
-                                error_detail = handle_gemini_error(e, api_key, key_manager)
-                                log('error', f"假流式模式: API密钥 {api_key[:8]}... 请求失败: {error_detail}",
-                                    extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
-                                # 继续尝试下一个API密钥
-                        
-                        # 如果所有API密钥都尝试失败
-                        if not success:
-                            error_msg = "所有API密钥均请求失败，请稍后重试"
-                            log('error', error_msg,
-                                extra={'key': 'ALL', 'request_type': 'fake-stream', 'model': chat_request.model})
-                            
-                            # 添加错误信息到队列
-                            error_json = {
-                                "id": "chatcmpl-error",
-                                "object": "chat.completion.chunk",
-                                "created": int(time.time()),
-                                "model": chat_request.model,
-                                "choices": [{"delta": {"content": f"\n\n[错误: {error_msg}]"}, "index": 0, "finish_reason": "error"}]
-                            }
-                            await queue.put(f"data: {json.dumps(error_json)}\n\n")
-                        
-                        # 添加完成标记到队列
-                        await queue.put("data: [DONE]\n\n")
-                        # 添加None表示队列结束
-                        await queue.put(None)
-                        
-                    except asyncio.CancelledError:
-                        log('info', "API请求任务被取消",
-                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
-                        # 添加None表示队列结束
-                        await queue.put(None)
-                        raise
-                    except Exception as e:
-                        log('error', f"API请求任务出错: {str(e)}",
-                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
-                        # 添加错误信息到队列
-                        error_json = {
-                            "id": "chatcmpl-error",
-                            "object": "chat.completion.chunk",
-                            "created": int(time.time()),
-                            "model": chat_request.model,
-                            "choices": [{"delta": {"content": f"\n\n[错误: {str(e)}]"}, "index": 0, "finish_reason": "error"}]
-                        }
-                        await queue.put(f"data: {json.dumps(error_json)}\n\n")
-                        await queue.put("data: [DONE]\n\n")
-                        # 添加None表示队列结束
-                        await queue.put(None)
-                        raise
-                
-                # 启动保持连接的任务
-                keep_alive_task = asyncio.create_task(keep_alive_sender())
-                # 启动API请求任务
-                api_request_task = asyncio.create_task(api_request_handler())
-                
-                # 从队列中获取数据并发送给客户端
-                while True:
-                    chunk = await queue.get()
-                    if chunk is None:  # None表示队列结束
-                        break
-                    yield chunk
-                    
-                    # 如果API请求任务已完成，取消保持连接任务
-                    if api_request_task.done() and not keep_alive_task.done():
-                        keep_alive_task.cancel()
-                
-            except asyncio.CancelledError:
-                log('info', "流式响应生成器被取消",
-                    extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
-                # 取消所有任务
-                if keep_alive_task and not keep_alive_task.done():
-                    keep_alive_task.cancel()
-                if api_request_task and not api_request_task.done():
-                    api_request_task.cancel()
-            except Exception as e:
-                log('error', f"流式响应生成器出错: {str(e)}",
-                    extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
-                # 取消所有任务
-                if keep_alive_task and not keep_alive_task.done():
-                    keep_alive_task.cancel()
-                if api_request_task and not api_request_task.done():
-                    api_request_task.cancel()
-                # 发送错误信息给客户端
-                error_json = {
-                    "id": "chatcmpl-error",
-                    "object": "chat.completion.chunk",
-                    "created": int(time.time()),
-                    "model": chat_request.model,
-                    "choices": [{"delta": {"content": f"\n\n[错误: {str(e)}]"}, "index": 0, "finish_reason": "error"}]
-                }
-                yield f"data: {json.dumps(error_json)}\n\n"
-                yield "data: [DONE]\n\n"
-            finally:
-                # 确保所有任务都被取消
-                if keep_alive_task and not keep_alive_task.done():
-                    keep_alive_task.cancel()
-                if api_request_task and not api_request_task.done():
-                    api_request_task.cancel()
-        else:
-            # 原始流��请求处理逻辑
-            gemini_client = GeminiClient(current_api_key)
-            success = False
-            
-            try:
-                # 直接迭代生成器并发送响应块
-                async for chunk in gemini_client.stream_chat(
-                    chat_request,
-                    contents,
-                    safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
-                    system_instruction
-                ):
-                    # 空字符串跳过
-                    if not chunk:
-                        continue
-                        
-                    formatted_chunk = {
-                        "id": "chatcmpl-someid",
-                        "object": "chat.completion.chunk",
-                        "created": int(time.time()),
-                        "model": chat_request.model,
-                        "choices": [{"delta": {"role": "assistant", "content": chunk}, "index": 0, "finish_reason": None}]
-                    }
-                    success = True  # 只要有一个chunk成功，就标记为成功
-                    yield f"data: {json.dumps(formatted_chunk)}\n\n"
-                
-                # 如果成功获取到响应，更新API调用统计
-                if success:
-                    update_api_call_stats()
-                    
-                yield "data: [DONE]\n\n"
-                
-            except asyncio.CancelledError:
-                extra_log_cancel = {'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model, 'error_message': '客户端已断开连接'}
-                log('info', "客户端连接已中断", extra=extra_log_cancel)
-            except Exception as e:
-                error_detail = handle_gemini_error(e, current_api_key, key_manager)
-                log('error', f"流式请求失败: {error_detail}",
-                    extra={'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
-                # 发送错误信息给客户端
-                error_json = {
-                    "id": "chatcmpl-error",
-                    "object": "chat.completion.chunk",
-                    "created": int(time.time()),
-                    "model": chat_request.model,
-                    "choices": [{"delta": {"content": f"\n\n[错误: {error_detail}]"}, "index": 0, "finish_reason": "error"}]
-                }
-                yield f"data: {json.dumps(error_json)}\n\n"
-                yield "data: [DONE]\n\n"
-                # 重新抛出异常，这样process_request可以捕获它
-                raise e
-    
-    return StreamingResponse(stream_response_generator(), media_type="text/event-stream")
-
-async def run_gemini_completion(
-    gemini_client, 
-    chat_request: ChatCompletionRequest, 
-    contents,
-    system_instruction,
-    request_type: str,
-    current_api_key: str
-):
-    """运行Gemini非流式请求"""
-    # 记录函数调用状态
-    run_fn = run_gemini_completion
-    
-    try:
-        # 创建一个不会被客户端断开影响的任务
-        response_future = asyncio.create_task(
-            asyncio.to_thread(
-                gemini_client.complete_chat, 
-                chat_request, 
-                contents, 
-                safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings, 
-                system_instruction
-            )
-        )
-        
-        # 使用shield防止任务被外部取消
-        response_content = await asyncio.shield(response_future)
-        
-        # 只在第一次调用时记录完成日志
-        if not hasattr(run_fn, 'logged_complete'):
-            log('info', "非流式请求成功完成", extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
-            run_fn.logged_complete = True
-        return response_content
-    except asyncio.CancelledError:
-        # 即使任务被取消，我们也确保正在进行的API请求能够完成
-        if 'response_future' in locals() and not response_future.done():
-            try:
-                # 使用shield确保任务不被取消，并等待它完成
-                response_content = await asyncio.shield(response_future)
-                log('info', "API请求在客户端断开后完成", extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
-                return response_content
-            except Exception as e:
-                extra_log_gemini_cancel = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': f'API请求在客户端断开后失败: {str(e)}'}
-                log('info', "API调用因客户端断开而失败", extra=extra_log_gemini_cancel)
-                raise
-        
-        # 如果任务尚未开始或已经失败，记录日志
-        extra_log_gemini_cancel = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': '���户端断开导致API调用取消'}
-        log('info', "API调用因客户端断开而取消", extra=extra_log_gemini_cancel)
-        raise
-
-async def check_client_disconnect(http_request: Request, current_api_key: str, request_type: str, model: str):
-    """检查客户端是否断开连接"""
-    while True:
-        if await http_request.is_disconnected():
-            extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': model, 'error_message': '检测到客户端断开连接'}
-            log('info', "客户端连接已中断，等待API请求完成", extra=extra_log)
-            return True
-        await asyncio.sleep(0.5)
-
-async def handle_client_disconnect(
-    gemini_task: asyncio.Task, 
-    chat_request: ChatCompletionRequest, 
-    request_type: str, 
-    current_api_key: str,
-    cache_key: str = None,
-    client_ip: str = None
-):
-
-    try:
-        # 等待API任务完成，使用shield防止它被取消
-        response_content = await asyncio.shield(gemini_task)
-        
-        # 检查响应文本是否为空
-        if response_content is None or response_content.text == "":
-            if response_content is None:
-                log('info', "客户端断开后API任务返回None", 
-                    extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
-            else:
-                extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'status_code': 204}
-                log('info', "客户端断开后Gemini API 返回空响应", extra=extra_log)
-            
-            # 删除任何现有缓存，因为响应为空
-            if cache_key and cache_key in response_cache_manager.cache:
-                log('info', f"因空响应，删除缓存: {cache_key[:8]}...", 
-                    extra={'cache_operation': 'remove-on-empty', 'request_type': request_type})
-                del response_cache_manager.cache[cache_key]
-                
-            # 返回错误响应而不是None
-            return create_error_response(chat_request.model, "AI未返回任何内容，请重试")
-        
-        # 首先检查是否有现有缓存
-        cached_response, cache_hit = response_cache_manager.get(cache_key)
-        if cache_hit:
-            log('info', f"客户端断开但找到已存在缓存，将删除: {cache_key[:8]}...", 
-                extra={'cache_operation': 'disconnect-found-cache', 'request_type': request_type})
-            
-            # 安全删除缓存
-            if cache_key in response_cache_manager.cache:
-                del response_cache_manager.cache[cache_key]
-            
-            # 不返回缓存，而是创建新响应并缓存
-        
-        # 创建新响应
-        # log('info', f"客户端断开后创建新缓存: {cache_key[:8] if cache_key else 'none'}...", 
-        #     extra={'cache_operation': 'create-after-disconnect', 'request_type': request_type})
-        response = create_response(chat_request, response_content)
-        
-        # 客户端已断开，此响应不会实际发送，可以考虑将其缓存以供后续使用
-        # 如果确实需要缓存，则可以取消下面的注释
-        # cache_response(response, cache_key, client_ip)
-        
-        return response
-    except asyncio.CancelledError:
-        # 对于取消异常，仍然尝试继续完成任务
-        log('info', "客户端断开后任务被取消，但我们仍会尝试完成", 
-            extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
-        
-        # 检查任务是否已经完成
-        if gemini_task.done() and not gemini_task.cancelled():
-            try:
-                response_content = gemini_task.result()
-                
-                # 首先检查是否有现有缓存
-                cached_response, cache_hit = response_cache_manager.get(cache_key)
-                if cache_hit:
-                    log('info', f"任务被取消但找到已存在缓存，将删除: {cache_key[:8]}...", 
-                        extra={'cache_operation': 'cancel-found-cache', 'request_type': request_type})
-                    
-                    # 安全删除缓存
-                    if cache_key in response_cache_manager.cache:
-                        del response_cache_manager.cache[cache_key]
-                
-                # 创建但不缓存响应
-                response = create_response(chat_request, response_content)
-                return response
-            except Exception as inner_e:
-                log('error', f"客户端断开后从已完成任务获取结果失败: {str(inner_e)}", 
-                    extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
-                
-                # 删除缓存，因为出现错误
-                if cache_key and cache_key in response_cache_manager.cache:
-                    log('info', f"因任务获取结果失败，删除缓存: {cache_key[:8]}...", 
-                        extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
-                    del response_cache_manager.cache[cache_key]
-        
-        # 创建错误响应而不是返回None
-        return create_error_response(chat_request.model, "请求处理过程中发生错误，请重试")
-    except Exception as e:
-        # 处理API任务异常
-        error_msg = str(e)
-        extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': error_msg}
-        log('error', f"客户端断开后处理API响应时出错: {error_msg}", extra=extra_log)
-        
-        # 删除缓存，因为出现错误
-        if cache_key and cache_key in response_cache_manager.cache:
-            log('info', f"因API响应错误，删除缓存: {cache_key[:8]}...", 
-                extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
-            del response_cache_manager.cache[cache_key]
-            
-        # 创建错误响应而不是返回None
-        return create_error_response(chat_request.model, f"请求处理错误: {error_msg}")
-
-async def process_nonstream_request(
-    chat_request: ChatCompletionRequest, 
-    http_request: Request, 
-    request_type: str,
-    contents,
-    system_instruction,
-    current_api_key: str,
-    cache_key: str = None,
-    client_ip: str = None
-):
-    """处理非流式API请求"""
-    gemini_client = GeminiClient(current_api_key)
-    
-    # 创建任务
-    gemini_task = asyncio.create_task(
-        run_gemini_completion(
-            gemini_client,
-            chat_request,
-            contents,
-            system_instruction,
-            request_type,
-            current_api_key
-        )
-    )
-    
-    disconnect_task = asyncio.create_task(
-        check_client_disconnect(
-            http_request,
-            current_api_key,
-            request_type,
-            chat_request.model
-        )
-    )
-
-    try:
-        # 先等待看是否API任务先完成，或者客户端先断开连接
-        done, pending = await asyncio.wait(
-            [gemini_task, disconnect_task],
-            return_when=asyncio.FIRST_COMPLETED
-        )
-
-        if disconnect_task in done:
-            # 客户端已断开连接，但我们仍继续完成API请求以便缓存结果
-            return await handle_client_disconnect(
-                gemini_task,
-                chat_request,
-                request_type,
-                current_api_key,
-                cache_key,
-                client_ip
-            )
-        else:
-            # API任务先完成，取消断开检测任务
-            disconnect_task.cancel()
-            
-            # 获取响应内容
-            response_content = await gemini_task
-            
-            # 检查缓存是否已经存在，如果存在则不再创建新缓存
-            cached_response, cache_hit = response_cache_manager.get(cache_key)
-            if cache_hit:
-                log('info', f"缓存已存在，直接返回: {cache_key[:8]}...", 
-                    extra={'cache_operation': 'use-existing', 'request_type': request_type})
-                
-                # 安全删除缓存
-                if cache_key in response_cache_manager.cache:
-                    del response_cache_manager.cache[cache_key]
-                    log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
-                        extra={'cache_operation': 'used-and-removed', 'request_type': request_type})
-                
-                return cached_response
-            
-            # 创建响应
-            response = create_response(chat_request, response_content)
-            
-            # 缓存响应
-            cache_response(response, cache_key, client_ip)
-            
-            # 立即删除缓存，确保只能使用一次
-            if cache_key and cache_key in response_cache_manager.cache:
-                del response_cache_manager.cache[cache_key]
-                log('info', f"缓存创建后立即删除: {cache_key[:8]}...", 
-                    extra={'cache_operation': 'store-and-remove', 'request_type': request_type})
-            
-            # 返回响应
-            return response
-
-    except asyncio.CancelledError:
-        extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message':"请求被取消"}
-        log('info', "请求取消", extra=extra_log)
-        
-        # 在请求被取消时先检查缓存中是否已有结果
-        cached_response, cache_hit = response_cache_manager.get(cache_key)
-        if cache_hit:
-            log('info', f"请求取消但找到有效缓存，使用缓存响应: {cache_key[:8]}...", 
-                extra={'cache_operation': 'use-cache-on-cancel', 'request_type': request_type})
-            
-            # 安全删除缓存
-            if cache_key in response_cache_manager.cache:
-                del response_cache_manager.cache[cache_key]
-                log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
-                    extra={'cache_operation': 'used-and-removed', 'request_type': request_type})
-            
-            return cached_response
-            
-        # 尝试完成正在进行的API请求
-        if not gemini_task.done():
-            log('info', "请求取消但API请求尚未完成，继续等待...", 
-                extra={'key': current_api_key[:8], 'request_type': request_type})
-            
-            # 使用shield确保任务不会被取消
-            response_content = await asyncio.shield(gemini_task)
-            
-            # 创建响应
-            response = create_response(chat_request, response_content)
-            
-            # 不缓存这个响应，直接返回
-            return response
-        else:
-            # 任务已完成，获取结果
-            response_content = gemini_task.result()
-            
-            # 创建响应
-            response = create_response(chat_request, response_content)
-            
-            # 不缓存这个响应，直接返回
-            return response
-
-    except HTTPException as e:
-        if e.status_code == status.HTTP_408_REQUEST_TIMEOUT:
-            extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 
-                        'status_code': 408, 'error_message': '客户端连接中断'}
-            log('error', "客户端连接中断，终止后续重试", extra=extra_log)
-            raise  
-        else:
-            raise
-
-# 添加通用响应处理函数
-def create_response(
-    chat_request, response_content
-):
-    """创建标准响应对象但不缓存"""
-    # 创建响应对象
-    return create_chat_response(
-        model=chat_request.model,
-        choices=[{
-            "index": 0, 
-            "message": {
-                "role": "assistant", 
-                "content": response_content.text
-            }, 
-            "finish_reason": "stop"
-        }]
-    )
-
-def cache_response(response, cache_key, client_ip):
-    """将响应存入缓存"""
-    if not cache_key:
-        return
-        
-    # 先检查缓存是否已存在
-    existing_cache = cache_key in response_cache_manager.cache
-    
-    if existing_cache:
-        log('info', f"缓存已存在，跳过存储: {cache_key[:8]}...", 
-            extra={'cache_operation': 'skip-existing', 'request_type': 'non-stream'})
-    else:
-        response_cache_manager.store(cache_key, response, client_ip)
-        log('info', f"API响应已缓存: {cache_key[:8]}...", 
-            extra={'cache_operation': 'store-new', 'request_type': 'non-stream'})
-    
-    # 更新API调用统计
-    update_api_call_stats()
-
-# 统一的API错误处理函数
-async def handle_api_error(e, api_key, key_manager, request_type, model, retry_count=0):
-    """统一处理API错误，对500和503错误实现自动重试机制"""
-    error_detail = handle_gemini_error(e, api_key, key_manager)
-    
-    # 处理500和503服务器错误
-    if isinstance(e, requests.exceptions.HTTPError) and ('500' in str(e) or '503' in str(e)):
-        status_code = '500' if '500' in str(e) else '503'
-        
-        # 最多重试3次
-        if retry_count < 3:
-            wait_time = min(RETRY_DELAY * (2 ** retry_count), MAX_RETRY_DELAY)
-            log('warning', f"Gemini服务器错误({status_code})，等待{wait_time}秒后重试 ({retry_count+1}/3)", 
-                key=api_key[:8], request_type=request_type, model=model, status_code=int(status_code))
-            
-            # 等待后返回重试信号
-            await asyncio.sleep(wait_time)
-            return {'should_retry': True, 'error': error_detail, 'remove_cache': False}
-        
-        # 重试次数用尽，直接返回错误状态码
-        log('error', f"服务器错误({status_code})重试{retry_count}次后仍然失败", 
-            key=api_key[:8], request_type=request_type, model=model, status_code=int(status_code))
-        
-        # 不建议切换密钥，直接抛出HTTP异常
-        raise HTTPException(status_code=int(status_code), 
-                          detail=f"Gemini API 服务器错误({status_code})，请稍后重试")
-    
-    # 对于其他错误，返回切换密钥的信号
-    log('error', f"API错误: {error_detail}", 
-        key=api_key[:8], request_type=request_type, model=model, error_message=error_detail)
-    return {'should_retry': False, 'should_switch_key': True, 'error': error_detail, 'remove_cache': True}
+    return templates.TemplateResponse("index.html", {"request": request, **context})

app/models/__init__.py

@@ -0,0 +1,19 @@
+from app.models.schemas import (
+    Message,
+    ChatCompletionRequest,
+    Choice,
+    Usage,
+    ChatCompletionResponse,
+    ErrorResponse,
+    ModelList
+)
+
+__all__ = [
+    'Message',
+    'ChatCompletionRequest',
+    'Choice',
+    'Usage',
+    'ChatCompletionResponse',
+    'ErrorResponse',
+    'ModelList'
+]

app/models/schemas.py

@@ -0,0 +1,46 @@
+from typing import List, Dict, Optional, Union, Literal
+from pydantic import BaseModel, Field
+
+class Message(BaseModel):
+    role: str
+    content: Union[str, List[Dict[str, str]]]
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    temperature: float = 0.7
+    top_p: Optional[float] = 1.0
+    n: int = 1
+    stream: bool = False
+    stop: Optional[Union[str, List[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = 0.0
+    frequency_penalty: Optional[float] = 0.0
+
+class Choice(BaseModel):
+    index: int
+    message: Message
+    finish_reason: Optional[str] = None
+
+class Usage(BaseModel):
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: Literal["chat.completion"]
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: Usage = Field(default_factory=Usage)
+
+class ErrorResponse(BaseModel):
+    message: str
+    type: str
+    param: Optional[str] = None
+    code: Optional[str] = None
+
+class ModelList(BaseModel):
+    object: str = "list"
+    data: List[Dict]

app/services/__init__.py

@@ -0,0 +1,7 @@
+from app.services.gemini import GeminiClient, ResponseWrapper, GeneratedText
+
+__all__ = [
+    'GeminiClient',
+    'ResponseWrapper',
+    'GeneratedText'
+]

app/services/gemini.py

@@ -0,0 +1,346 @@
+import requests
+import json
+import os
+import asyncio
+import time
+from app.models import ChatCompletionRequest, Message
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List
+import httpx
+import logging
+from app.utils import format_log_message
+
+logger = logging.getLogger('my_logger')
+
+# 是否启用假流式请求 默认启用
+FAKE_STREAMING = os.environ.get("FAKE_STREAMING", "true").lower() in ["true", "1", "yes"]
+# 假流式请求的空内容返回间隔（秒）
+FAKE_STREAMING_INTERVAL = float(os.environ.get("FAKE_STREAMING_INTERVAL", "1"))
+
+@dataclass
+class GeneratedText:
+    text: str
+    finish_reason: Optional[str] = None
+
+
+class ResponseWrapper:
+    def __init__(self, data: Dict[Any, Any]):  # 正确的初始化方法名
+        self._data = data
+        self._text = self._extract_text()
+        self._finish_reason = self._extract_finish_reason()
+        self._prompt_token_count = self._extract_prompt_token_count()
+        self._candidates_token_count = self._extract_candidates_token_count()
+        self._total_token_count = self._extract_total_token_count()
+        self._thoughts = self._extract_thoughts()
+        self._json_dumps = json.dumps(self._data, indent=4, ensure_ascii=False)
+
+    def _extract_thoughts(self) -> Optional[str]:
+        try:
+            for part in self._data['candidates'][0]['content']['parts']:
+                if 'thought' in part:
+                    return part['text']
+            return ""
+        except (KeyError, IndexError):
+            return ""
+
+    def _extract_text(self) -> str:
+        try:
+            for part in self._data['candidates'][0]['content']['parts']:
+                if 'thought' not in part:
+                    return part['text']
+            return ""
+        except (KeyError, IndexError):
+            return ""
+
+    def _extract_finish_reason(self) -> Optional[str]:
+        try:
+            return self._data['candidates'][0].get('finishReason')
+        except (KeyError, IndexError):
+            return None
+
+    def _extract_prompt_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('promptTokenCount')
+        except (KeyError):
+            return None
+
+    def _extract_candidates_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('candidatesTokenCount')
+        except (KeyError):
+            return None
+
+    def _extract_total_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('totalTokenCount')
+        except (KeyError):
+            return None
+
+    @property
+    def text(self) -> str:
+        return self._text
+
+    @property
+    def finish_reason(self) -> Optional[str]:
+        return self._finish_reason
+
+    @property
+    def prompt_token_count(self) -> Optional[int]:
+        return self._prompt_token_count
+
+    @property
+    def candidates_token_count(self) -> Optional[int]:
+        return self._candidates_token_count
+
+    @property
+    def total_token_count(self) -> Optional[int]:
+        return self._total_token_count
+
+    @property
+    def thoughts(self) -> Optional[str]:
+        return self._thoughts
+
+    @property
+    def json_dumps(self) -> str:
+        return self._json_dumps
+
+
+class GeminiClient:
+
+    AVAILABLE_MODELS = []
+    EXTRA_MODELS = os.environ.get("EXTRA_MODELS", "").split(",")
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    async def stream_chat(self, request: ChatCompletionRequest, contents, safety_settings, system_instruction):
+        extra_log = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model, 'status_code': 'N/A'}
+        log_msg = format_log_message('INFO', "流式请求开始", extra=extra_log)
+        logger.info(log_msg)
+        
+        # 检查是否启用假流式请求
+        if FAKE_STREAMING:
+            log_msg = format_log_message('INFO', "使用假流式请求模式（发送换行符保持连接）", extra=extra_log)
+            logger.info(log_msg)
+            
+            try:
+                # 这个方法不再直接使用self.api_key，而是由main.py提供API密钥列表和管理
+                # 在这里，我们只负责持续发送换行符，直到main.py那边获取到响应
+                
+                # 持续发送换行符，直到外部取消此生成器
+                start_time = time.time()
+                while True:
+                    # 发送换行符作为保活消息
+                    yield "\n"
+                    # 等待一段时间
+                    await asyncio.sleep(FAKE_STREAMING_INTERVAL)
+                    
+                    # 如果等待时间过长（超过300秒），防止无限等待
+                    if time.time() - start_time > 300:
+                        log_msg = format_log_message('WARNING', "假流式请求等待时间过长，强制结束", extra=extra_log)
+                        logger.warning(log_msg)
+                        # 抛出超时异常，让外部处理
+                        error_msg = "假流式请求等待时间过长，所有API密钥均已尝试"
+                        extra_log_timeout = {'key': self.api_key[:8], 'request_type': 'fake-stream', 'model': request.model, 'status_code': 'TIMEOUT', 'error_message': error_msg}
+                        log_msg = format_log_message('ERROR', error_msg, extra=extra_log_timeout)
+                        logger.error(log_msg)
+                        raise TimeoutError(error_msg)
+                
+            except Exception as e:
+                if not isinstance(e, asyncio.CancelledError):  # 忽略取消异常的日志记录
+                    error_msg = f"假流式处理期间发生错误: {str(e)}"
+                    extra_log_error = {'key': self.api_key[:8], 'request_type': 'fake-stream', 'model': request.model, 'status_code': 'ERROR', 'error_message': error_msg}
+                    log_msg = format_log_message('ERROR', error_msg, extra=extra_log_error)
+                    logger.error(log_msg)
+                raise e
+            finally:
+                log_msg = format_log_message('INFO', "假流式请求结束", extra=extra_log)
+                logger.info(log_msg)
+        else:
+            # 原始流式请求处理逻辑
+            api_version = "v1alpha" if "think" in request.model else "v1beta"
+            url = f"https://generativelanguage.googleapis.com/{api_version}/models/{request.model}:streamGenerateContent?key={self.api_key}&alt=sse"
+            headers = {
+                "Content-Type": "application/json",
+            }
+            data = {
+                "contents": contents,
+                "generationConfig": {
+                    "temperature": request.temperature,
+                    "maxOutputTokens": request.max_tokens,
+                },
+                "safetySettings": safety_settings,
+            }
+            if system_instruction:
+                data["system_instruction"] = system_instruction
+            
+            async with httpx.AsyncClient() as client:
+                async with client.stream("POST", url, headers=headers, json=data, timeout=600) as response:
+                    buffer = b""
+                    try:
+                        async for line in response.aiter_lines():
+                            if not line.strip():
+                                continue
+                            if line.startswith("data: "):
+                                line = line[len("data: "):]
+                            buffer += line.encode('utf-8')
+                            try:
+                                data = json.loads(buffer.decode('utf-8'))
+                                buffer = b""
+                                if 'candidates' in data and data['candidates']:
+                                    candidate = data['candidates'][0]
+                                    if 'content' in candidate:
+                                        content = candidate['content']
+                                        if 'parts' in content and content['parts']:
+                                            parts = content['parts']
+                                            text = ""
+                                            for part in parts:
+                                                if 'text' in part:
+                                                    text += part['text']
+                                            if text:
+                                                yield text
+                                            
+                                    if candidate.get("finishReason") and candidate.get("finishReason") != "STOP":
+                                        error_msg = f"模型的响应被截断: {candidate.get('finishReason')}"
+                                        extra_log_error = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model, 'status_code': 'ERROR', 'error_message': error_msg}
+                                        log_msg = format_log_message('WARNING', error_msg, extra=extra_log_error)
+                                        logger.warning(log_msg)
+                                        raise ValueError(error_msg)
+                                    
+                                    if 'safetyRatings' in candidate:
+                                        for rating in candidate['safetyRatings']:
+                                            if rating['probability'] == 'HIGH':
+                                                error_msg = f"模型的响应被截断: {rating['category']}"
+                                                extra_log_safety = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model, 'status_code': 'ERROR', 'error_message': error_msg}
+                                                log_msg = format_log_message('WARNING', error_msg, extra=extra_log_safety)
+                                                logger.warning(log_msg)
+                                                raise ValueError(error_msg)
+                            except json.JSONDecodeError:
+                                continue
+                            except Exception as e:
+                                error_msg = f"流式处理期间发生错误: {str(e)}"
+                                extra_log_stream_error = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model, 'status_code': 'ERROR', 'error_message': error_msg}
+                                log_msg = format_log_message('ERROR', error_msg, extra=extra_log_stream_error)
+                                logger.error(log_msg)
+                                raise e
+                    except Exception as e:
+                        raise e
+                    finally:
+                        log_msg = format_log_message('INFO', "流式请求结束", extra=extra_log)
+                        logger.info(log_msg)
+
+    def complete_chat(self, request: ChatCompletionRequest, contents, safety_settings, system_instruction):
+        extra_log = {'key': self.api_key[:8], 'request_type': 'non-stream', 'model': request.model, 'status_code': 'N/A'}
+        log_msg = format_log_message('INFO', "非流式请求开始", extra=extra_log)
+        logger.info(log_msg)
+        
+        api_version = "v1alpha" if "think" in request.model else "v1beta"
+        url = f"https://generativelanguage.googleapis.com/{api_version}/models/{request.model}:generateContent?key={self.api_key}"
+        headers = {
+            "Content-Type": "application/json",
+        }
+        data = {
+            "contents": contents,
+            "generationConfig": {
+                "temperature": request.temperature,
+                "maxOutputTokens": request.max_tokens,
+            },
+            "safetySettings": safety_settings,
+        }
+        if system_instruction:
+            data["system_instruction"] = system_instruction
+            
+        try:
+            response = requests.post(url, headers=headers, json=data)
+            response.raise_for_status()
+            
+            log_msg = format_log_message('INFO', "非流式请求成功完成", extra=extra_log)
+            logger.info(log_msg)
+            
+            return ResponseWrapper(response.json())
+        except Exception as e:
+            raise
+
+    def convert_messages(self, messages, use_system_prompt=False):
+        gemini_history = []
+        errors = []
+        system_instruction_text = ""
+        is_system_phase = use_system_prompt
+        for i, message in enumerate(messages):
+            role = message.role
+            content = message.content
+
+            if isinstance(content, str):
+                if is_system_phase and role == 'system':
+                    if system_instruction_text:
+                        system_instruction_text += "\n" + content
+                    else:
+                        system_instruction_text = content
+                else:
+                    is_system_phase = False
+
+                    if role in ['user', 'system']:
+                        role_to_use = 'user'
+                    elif role == 'assistant':
+                        role_to_use = 'model'
+                    else:
+                        errors.append(f"Invalid role: {role}")
+                        continue
+
+                    if gemini_history and gemini_history[-1]['role'] == role_to_use:
+                        gemini_history[-1]['parts'].append({"text": content})
+                    else:
+                        gemini_history.append(
+                            {"role": role_to_use, "parts": [{"text": content}]})
+            elif isinstance(content, list):
+                parts = []
+                for item in content:
+                    if item.get('type') == 'text':
+                        parts.append({"text": item.get('text')})
+                    elif item.get('type') == 'image_url':
+                        image_data = item.get('image_url', {}).get('url', '')
+                        if image_data.startswith('data:image/'):
+                            try:
+                                mime_type, base64_data = image_data.split(';')[0].split(':')[1], image_data.split(',')[1]
+                                parts.append({
+                                    "inline_data": {
+                                        "mime_type": mime_type,
+                                        "data": base64_data
+                                    }
+                                })
+                            except (IndexError, ValueError):
+                                errors.append(
+                                    f"Invalid data URI for image: {image_data}")
+                        else:
+                            errors.append(
+                                f"Invalid image URL format for item: {item}")
+
+                if parts:
+                    if role in ['user', 'system']:
+                        role_to_use = 'user'
+                    elif role == 'assistant':
+                        role_to_use = 'model'
+                    else:
+                        errors.append(f"Invalid role: {role}")
+                        continue
+                    if gemini_history and gemini_history[-1]['role'] == role_to_use:
+                        gemini_history[-1]['parts'].extend(parts)
+                    else:
+                        gemini_history.append(
+                            {"role": role_to_use, "parts": parts})
+        if errors:
+            return errors
+        else:
+            return gemini_history, {"parts": [{"text": system_instruction_text}]}
+
+    @staticmethod
+    async def list_available_models(api_key) -> list:
+        url = "https://generativelanguage.googleapis.com/v1beta/models?key={}".format(
+            api_key)
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            data = response.json()
+            models = [model["name"] for model in data.get("models", [])]
+            models.extend(GeminiClient.EXTRA_MODELS)
+            return models

app/templates/__init__.py

@@ -0,0 +1 @@
+# Templates package initialization

app/templates/index.html

@@ -0,0 +1,576 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Gemini API 代理服务</title>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+            line-height: 1.6;
+            background-color: #f8f9fa;
+        }
+        h1, h2, h3 {
+            color: #333;
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        .info-box {
+            background-color: #fff;
+            border: 1px solid #dee2e6;
+            border-radius: 8px;
+            padding: 20px;
+            margin-bottom: 20px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        }
+        .status {
+            color: #28a745;
+            font-weight: bold;
+            font-size: 18px;
+            margin-bottom: 20px;
+            text-align: center;
+        }
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(3, 1fr);
+            gap: 15px;
+            margin-top: 15px;
+            margin-bottom: 20px;
+        }
+        .stat-card {
+            background-color: #e9ecef;
+            padding: 15px;
+            border-radius: 8px;
+            text-align: center;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+            transition: transform 0.2s;
+        }
+        .stat-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        }
+        .stat-value {
+            font-size: 24px;
+            font-weight: bold;
+            color: #007bff;
+        }
+        .stat-label {
+            font-size: 14px;
+            color: #6c757d;
+            margin-top: 5px;
+        }
+        .section-title {
+            color: #495057;
+            border-bottom: 1px solid #dee2e6;
+            padding-bottom: 10px;
+            margin-bottom: 20px;
+        }
+        .log-container {
+            background-color: #f5f5f5;
+            border: 1px solid #ddd;
+            border-radius: 8px;
+            padding: 15px;
+            margin-top: 20px;
+            max-height: 500px;
+            overflow-y: auto;
+            font-family: monospace;
+            font-size: 14px;
+            line-height: 1.5;
+        }
+        .log-entry {
+            margin-bottom: 8px;
+            padding: 8px;
+            border-radius: 4px;
+        }
+        .log-entry.INFO {
+            background-color: #e8f4f8;
+            border-left: 4px solid #17a2b8;
+        }
+        .log-entry.WARNING {
+            background-color: #fff3cd;
+            border-left: 4px solid #ffc107;
+        }
+        .log-entry.ERROR {
+            background-color: #f8d7da;
+            border-left: 4px solid #dc3545;
+        }
+        .log-entry.DEBUG {
+            background-color: #d1ecf1;
+            border-left: 4px solid #17a2b8;
+        }
+        .log-timestamp {
+            color: #6c757d;
+            font-size: 12px;
+            margin-right: 10px;
+        }
+        .log-level {
+            font-weight: bold;
+            margin-right: 10px;
+        }
+        .log-level.INFO {
+            color: #17a2b8;
+        }
+        .log-level.WARNING {
+            color: #ffc107;
+        }
+        .log-level.ERROR {
+            color: #dc3545;
+        }
+        .log-level.DEBUG {
+            color: #17a2b8;
+        }
+        .log-message {
+            color: #212529;
+        }
+        .refresh-button {
+            display: block;
+            margin: 20px auto;
+            padding: 10px 20px;
+            background-color: #007bff;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            font-size: 16px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+        .refresh-button:hover {
+            background-color: #0069d9;
+        }
+        .log-filter {
+            display: flex;
+            justify-content: center;
+            margin-bottom: 15px;
+            gap: 10px;
+        }
+        .log-filter button {
+            padding: 5px 10px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            background-color: #f8f9fa;
+            cursor: pointer;
+        }
+        .log-filter button.active {
+            background-color: #007bff;
+            color: white;
+            border-color: #007bff;
+        }
+        
+        /* API密钥统计样式 */
+        .api-key-stats-container {
+            margin-top: 20px;
+        }
+        
+        .api-key-stats-list {
+            display: grid;
+            grid-template-columns: repeat(3, 1fr); /* 电脑上显示为三列 */
+            gap: 15px;
+            margin-top: 15px;
+        }
+        
+        /* 在中等屏幕上显示为两列 */
+        @media (max-width: 992px) {
+            .api-key-stats-list {
+                grid-template-columns: repeat(2, 1fr);
+            }
+        }
+        
+        /* 在小屏幕上显示为一列 */
+        @media (max-width: 576px) {
+            .api-key-stats-list {
+                grid-template-columns: 1fr;
+            }
+        }
+        
+        .api-key-item {
+            background-color: #f8f9fa;
+            border-radius: 8px;
+            padding: 15px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        }
+        
+        .api-key-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 10px;
+        }
+        
+        .api-key-name {
+            font-weight: bold;
+            color: #495057;
+        }
+        
+        .api-key-usage {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+        
+        .api-key-count {
+            font-weight: bold;
+            color: #007bff;
+        }
+        
+        .progress-container {
+            width: 100%;
+            height: 10px;
+            background-color: #e9ecef;
+            border-radius: 5px;
+            overflow: hidden;
+        }
+        
+        .progress-bar {
+            height: 100%;
+            border-radius: 5px;
+            transition: width 0.3s ease;
+        }
+        
+        .progress-bar.low {
+            background-color: #28a745; /* 绿色 - 低使用率 */
+        }
+        
+        .progress-bar.medium {
+            background-color: #ffc107; /* 黄色 - 中等使用率 */
+        }
+        
+        .progress-bar.high {
+            background-color: #dc3545; /* 红色 - 高使用率 */
+        }
+    </style>
+</head>
+<body>
+    <h1>🤖 Gemini API 代理服务</h1>
+    
+    <div class="info-box">
+        <h2 class="section-title">🟢 运行状态</h2>
+        <p class="status">服务运行中</p>
+        
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-value">{{ key_count }}</div>
+                <div class="stat-label">可用API密钥数量</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value">{{ model_count }}</div>
+                <div class="stat-label">可用模型数量</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value">{{ retry_count }}</div>
+                <div class="stat-label">最大重试次数</div>
+            </div>
+        </div>
+        
+        <h3 class="section-title">API调用统计</h3>
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-value" id="last-24h-calls">{{ last_24h_calls }}</div>
+                <div class="stat-label">24小时内调用次数</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="hourly-calls">{{ hourly_calls }}</div>
+                <div class="stat-label">一小时内调用次数</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="minute-calls">{{ minute_calls }}</div>
+                <div class="stat-label">一分钟内调用次数</div>
+            </div>
+        </div>
+        
+        <div class="api-key-stats-container">
+            <h3 class="section-title" style="cursor: pointer; user-select: none;" onclick="toggleApiKeyStats()">
+                API密钥使用统计 <span id="toggle-icon">▼</span>
+            </h3>
+            <div id="api-key-stats" style="display: block;">
+                <div class="api-key-stats-list" id="api-key-stats-list">
+                    <!-- API密钥统计将在这里动态生成 -->
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="info-box">
+        <h2 class="section-title">⚙️ 环境配置</h2>
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-value">{{ max_requests_per_minute }}</div>
+                <div class="stat-label">每分钟请求限制</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value">{{ max_requests_per_day_per_ip }}</div>
+                <div class="stat-label">每IP每日请求限制</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="current-time">{{ current_time }}</div>
+                <div class="stat-label">当前服务器时间</div>
+            </div>
+        </div>
+    </div>
+
+    <div class="info-box">
+        <h2 class="section-title">📦 版本信息</h2>
+        <div class="version-info" style="text-align: center; margin-bottom: 15px;">
+            <div style="font-size: 18px; margin-bottom: 10px;">
+                当前版本: <span style="font-weight: bold; color: #007bff;">{{ local_version }}</span>
+            </div>
+            {% if has_update %}
+            <div style="display: flex; align-items: center; justify-content: center; margin-top: 15px;">
+                <div style="background-color: #fef6e0; border: 1px solid #ffeeba; border-radius: 4px; padding: 10px 15px; display: inline-flex; align-items: center;">
+                    <span style="color: #ff9800; margin-right: 10px;">
+                        <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                            <circle cx="12" cy="12" r="10"></circle>
+                            <line x1="12" y1="8" x2="12" y2="12"></line>
+                            <line x1="12" y1="16" x2="12.01" y2="16"></line>
+                        </svg>
+                    </span>
+                    <span>
+                        <strong>发现新版本!</strong> 最新版本: <span style="font-weight: bold; color: #28a745;">{{ remote_version }}</span>
+                    </span>
+                </div>
+            </div>
+            {% endif %}
+        </div>
+    </div>
+
+    <div class="info-box">
+        <h2 class="section-title"> 系统日志</h2>
+        <div class="log-filter">
+            <button class="active" data-level="ALL">全部</button>
+            <button data-level="INFO">信息</button>
+            <button data-level="WARNING">警告</button>
+            <button data-level="ERROR">错误</button>
+        </div>
+        <div class="log-container" id="log-container">
+            {% for log in logs %}
+            <div class="log-entry {{ log.level }}" data-level="{{ log.level }}">
+                <span class="log-timestamp">{{ log.timestamp }}</span>
+                <span class="log-level {{ log.level }}">{{ log.level }}</span>
+                <span class="log-message">
+                    {% if log.key != 'N/A' %}[{{ log.key }}]{% endif %}
+                    {% if log.request_type != 'N/A' %}{{ log.request_type }}{% endif %}
+                    {% if log.model != 'N/A' %}[{{ log.model }}]{% endif %}
+                    {% if log.status_code != 'N/A' %}{{ log.status_code }}{% endif %}
+                    : {{ log.message }}
+                    {% if log.error_message %}
+                    - {{ log.error_message }}
+                    {% endif %}
+                </span>
+            </div>
+            {% endfor %}
+        </div>
+        <button class="refresh-button" id="refresh-button">刷新数据</button>
+    </div>
+
+    <script>
+        // 日志过滤功能
+        document.querySelectorAll('.log-filter button').forEach(button => {
+            button.addEventListener('click', function() {
+                // 移除所有按钮的active类
+                document.querySelectorAll('.log-filter button').forEach(btn => {
+                    btn.classList.remove('active');
+                });
+                
+                // 为当前按钮添加active类
+                this.classList.add('active');
+                
+                const level = this.getAttribute('data-level');
+                
+                // 显示或隐藏日志条目
+                document.querySelectorAll('.log-entry').forEach(entry => {
+                    if (level === 'ALL' || entry.getAttribute('data-level') === level) {
+                        entry.style.display = 'block';
+                    } else {
+                        entry.style.display = 'none';
+                    }
+                });
+            });
+        });
+        
+        // 动态刷新功能
+        let refreshInterval;
+        const refreshRate = 1000; // 1秒刷新一次
+        let isRefreshing = false;
+        
+        // 开始自动刷新
+        function startAutoRefresh() {
+            if (!refreshInterval) {
+                refreshInterval = setInterval(fetchDashboardData, refreshRate);
+                console.log('自动刷新已启动');
+            }
+        }
+        
+        // 停止自动刷新
+        function stopAutoRefresh() {
+            if (refreshInterval) {
+                clearInterval(refreshInterval);
+                refreshInterval = null;
+                console.log('自动刷新已停止');
+            }
+        }
+        
+        // 获取仪表盘数据
+        async function fetchDashboardData() {
+            if (isRefreshing) return; // 防止重复请求
+            
+            isRefreshing = true;
+            try {
+                const response = await fetch('/api/dashboard-data');
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                const data = await response.json();
+                updateDashboard(data);
+            } catch (error) {
+                console.error('获取数据失败:', error);
+            } finally {
+                isRefreshing = false;
+            }
+        }
+        
+        // 更新仪表盘数据
+        function updateDashboard(data) {
+            // 更新时间
+            document.getElementById('current-time').textContent = data.current_time;
+            
+            // 更新调用统计
+            document.getElementById('last-24h-calls').textContent = data.last_24h_calls;
+            document.getElementById('hourly-calls').textContent = data.hourly_calls;
+            document.getElementById('minute-calls').textContent = data.minute_calls;
+            
+            // 更新API密钥统计
+            if (data.api_key_stats) {
+                updateApiKeyStats(data.api_key_stats);
+            }
+            
+            // 更新日志
+            updateLogs(data.logs);
+        }
+        
+        // 更新API密钥统计
+        function updateApiKeyStats(apiKeyStats) {
+            const container = document.getElementById('api-key-stats-list');
+            container.innerHTML = '';
+            
+            if (!apiKeyStats || apiKeyStats.length === 0) {
+                container.innerHTML = '<div class="api-key-item">没有API密钥使用数据</div>';
+                return;
+            }
+            
+            apiKeyStats.forEach(stat => {
+                const item = document.createElement('div');
+                item.className = 'api-key-item';
+                
+                // 确定进度条颜色
+                let barClass = 'low';
+                if (stat.usage_percent > 75) {
+                    barClass = 'high';
+                } else if (stat.usage_percent > 50) {
+                    barClass = 'medium';
+                }
+                
+                item.innerHTML = `
+                    <div class="api-key-header">
+                        <div class="api-key-name">API密钥: ${stat.api_key}</div>
+                        <div class="api-key-usage">
+                            <span class="api-key-count">${stat.calls_24h}</span> /
+                            <span class="api-key-limit">${stat.limit}</span>
+                            <span class="api-key-percent">(${stat.usage_percent}%)</span>
+                        </div>
+                    </div>
+                    <div class="progress-container">
+                        <div class="progress-bar ${barClass}" style="width: ${Math.min(stat.usage_percent, 100)}%"></div>
+                    </div>
+                `;
+                
+                container.appendChild(item);
+            });
+        }
+        
+        // 切换API密钥统计显示/隐藏
+        function toggleApiKeyStats() {
+            const statsDiv = document.getElementById('api-key-stats');
+            const toggleIcon = document.getElementById('toggle-icon');
+            
+            if (statsDiv.style.display === 'none') {
+                statsDiv.style.display = 'block';
+                toggleIcon.textContent = '▼';
+            } else {
+                statsDiv.style.display = 'none';
+                toggleIcon.textContent = '▶';
+            }
+        }
+        
+        // 更新日志
+        function updateLogs(logs) {
+            const logContainer = document.getElementById('log-container');
+            const currentFilter = document.querySelector('.log-filter button.active').getAttribute('data-level');
+            
+            // 保存当前滚动位置
+            const wasScrolledToBottom = logContainer.scrollHeight - logContainer.clientHeight <= logContainer.scrollTop + 5;
+            
+            // 清空现有日志
+            logContainer.innerHTML = '';
+            
+            // 添加新日志
+            logs.forEach(log => {
+                const logEntry = document.createElement('div');
+                logEntry.className = `log-entry ${log.level}`;
+                logEntry.setAttribute('data-level', log.level);
+                
+                // 根据当前过滤器设置显示状态
+                if (currentFilter !== 'ALL' && log.level !== currentFilter) {
+                    logEntry.style.display = 'none';
+                }
+                
+                const timestampSpan = document.createElement('span');
+                timestampSpan.className = 'log-timestamp';
+                timestampSpan.textContent = log.timestamp;
+                
+                const levelSpan = document.createElement('span');
+                levelSpan.className = `log-level ${log.level}`;
+                levelSpan.textContent = log.level;
+                
+                const messageSpan = document.createElement('span');
+                messageSpan.className = 'log-message';
+                
+                // 构建消息内容
+                let messageContent = '';
+                if (log.key !== 'N/A') messageContent += `[${log.key}] `;
+                if (log.request_type !== 'N/A') messageContent += log.request_type + ' ';
+                if (log.model !== 'N/A') messageContent += `[${log.model}] `;
+                if (log.status_code !== 'N/A') messageContent += log.status_code + ' ';
+                messageContent += ': ' + log.message;
+                if (log.error_message) messageContent += ' - ' + log.error_message;
+                
+                messageSpan.textContent = messageContent;
+                
+                logEntry.appendChild(timestampSpan);
+                logEntry.appendChild(levelSpan);
+                logEntry.appendChild(messageSpan);
+                
+                logContainer.appendChild(logEntry);
+            });
+            
+            // 如果之前是滚动到底部的，则保持滚动到底部
+            if (wasScrolledToBottom) {
+                logContainer.scrollTop = logContainer.scrollHeight;
+            }
+        }
+        
+        // 页面加载时自动滚动到日志底部并启动自动刷新
+        window.onload = function() {
+            const logContainer = document.getElementById('log-container');
+            logContainer.scrollTop = logContainer.scrollHeight;
+            
+            // 启动自动刷新
+            startAutoRefresh();
+        };
+        
+        // 手动刷新按钮
+        document.getElementById('refresh-button').addEventListener('click', fetchDashboardData);
+    </script>
+</body>
+</html>

app/utils/__init__.py

@@ -0,0 +1,12 @@
+# Utils package initialization
+
+from app.utils.logging import logger, log_manager, format_log_message,log
+from app.utils.api_key import APIKeyManager, test_api_key
+from app.utils.error_handling import handle_gemini_error, translate_error, handle_api_error
+from app.utils.rate_limiting import protect_from_abuse
+from app.utils.cache import ResponseCacheManager, generate_cache_key, cache_response
+from app.utils.request import ActiveRequestsManager, check_client_disconnect
+from app.utils.stats import clean_expired_stats, update_api_call_stats
+from app.utils.response import create_chat_response, create_error_response, create_response, handle_exception
+from app.utils.version import check_version
+from app.utils.maintenance import handle_exception, schedule_cache_cleanup

app/utils/api_key.py

@@ -0,0 +1,87 @@
+import random
+import re
+import os
+import logging
+from datetime import datetime, timedelta
+from apscheduler.schedulers.background import BackgroundScheduler
+from app.utils.logging import format_log_message
+
+logger = logging.getLogger("my_logger")
+
+class APIKeyManager:
+    def __init__(self):
+        self.api_keys = re.findall(
+            r"AIzaSy[a-zA-Z0-9_-]{33}", os.environ.get('GEMINI_API_KEYS', ""))
+        self.key_stack = [] # 初始化密钥栈
+        self._reset_key_stack() # 初始化时创建随机密钥栈
+        # self.api_key_blacklist = set()
+        # self.api_key_blacklist_duration = 60
+        self.scheduler = BackgroundScheduler()
+        self.scheduler.start()
+        self.tried_keys_for_request = set()  # 用于跟踪当前请求尝试中已试过的 key
+
+    def _reset_key_stack(self):
+        """创建并随机化密钥栈"""
+        shuffled_keys = self.api_keys[:]  # 创建 api_keys 的副本以避免直接修改原列表
+        random.shuffle(shuffled_keys)
+        self.key_stack = shuffled_keys
+
+
+    def get_available_key(self):
+        """从栈顶获取密钥，栈空时重新生成 (修改后)"""
+        while self.key_stack:
+            key = self.key_stack.pop()
+            # if key not in self.api_key_blacklist and key not in self.tried_keys_for_request:
+            if key not in self.tried_keys_for_request:
+                self.tried_keys_for_request.add(key)
+                return key
+
+        if not self.api_keys:
+            log_msg = format_log_message('ERROR', "没有配置任何 API 密钥！")
+            logger.error(log_msg)
+            return None
+
+        self._reset_key_stack() # 重新生成密钥栈
+
+        # 再次尝试从新栈中获取密钥 (迭代一次)
+        while self.key_stack:
+            key = self.key_stack.pop()
+            # if key not in self.api_key_blacklist and key not in self.tried_keys_for_request:
+            if key not in self.tried_keys_for_request:
+                self.tried_keys_for_request.add(key)
+                return key
+
+        return None
+
+
+    def show_all_keys(self):
+        log_msg = format_log_message('INFO', f"当前可用API key个数: {len(self.api_keys)} ")
+        logger.info(log_msg)
+        for i, api_key in enumerate(self.api_keys):
+            log_msg = format_log_message('INFO', f"API Key{i}: {api_key[:8]}...{api_key[-3:]}")
+            logger.info(log_msg)
+
+    # def blacklist_key(self, key):
+    #     log_msg = format_log_message('WARNING', f"{key[:8]} → 暂时禁用 {self.api_key_blacklist_duration} 秒")
+    #     logger.warning(log_msg)
+    #     self.api_key_blacklist.add(key)
+    #     self.scheduler.add_job(lambda: self.api_key_blacklist.discard(key), 'date',
+    #                            run_date=datetime.now() + timedelta(seconds=self.api_key_blacklist_duration))
+
+    def reset_tried_keys_for_request(self):
+        """在新的请求尝试时重置已尝试的 key 集合"""
+        self.tried_keys_for_request = set()
+
+async def test_api_key(api_key: str) -> bool:
+    """
+    测试 API 密钥是否有效。
+    """
+    try:
+        import httpx
+        url = "https://generativelanguage.googleapis.com/v1beta/models?key={}".format(api_key)
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return True
+    except Exception:
+        return False

app/utils/cache.py

@@ -0,0 +1,137 @@
+import time
+import hashlib
+import json
+from typing import Dict, Any, Optional
+import logging
+from app.utils.logging import log
+from app.config.settings import (
+    api_call_stats
+)
+logger = logging.getLogger("my_logger")
+
+class ResponseCacheManager:
+    """管理API响应缓存的类"""
+    
+    def __init__(self, expiry_time: int, max_entries: int, remove_after_use: bool = True, 
+                cache_dict: Dict[str, Dict[str, Any]] = None):
+        self.cache = cache_dict if cache_dict is not None else {}  # 使用传入的缓存字典或创建新字典
+        self.expiry_time = expiry_time
+        self.max_entries = max_entries
+        self.remove_after_use = remove_after_use
+    
+    def get(self, cache_key: str):
+        """获取缓存项，如果存在且未过期"""
+        now = time.time()
+        if cache_key in self.cache and now < self.cache[cache_key].get('expiry_time', 0):
+            cached_item = self.cache[cache_key]
+            
+            # 获取响应但先不删除
+            response = cached_item['response']
+            
+            # 返回响应
+            return response, True
+        
+        return None, False
+    
+    def store(self, cache_key: str, response, client_ip: str = None):
+        """存储响应到缓存"""
+        now = time.time()
+        self.cache[cache_key] = {
+            'response': response,
+            'expiry_time': now + self.expiry_time,
+            'created_at': now,
+            'client_ip': client_ip
+        }
+        
+        log('info', f"响应已缓存: {cache_key[:8]}...", 
+            extra={'cache_operation': 'store', 'request_type': 'non-stream'})
+        
+        # 如果缓存超过限制，清理最旧的
+        self.clean_if_needed()
+    
+    def clean_expired(self):
+        """清理所有过期的缓存项"""
+        now = time.time()
+        expired_keys = [k for k, v in self.cache.items() if now > v.get('expiry_time', 0)]
+        
+        for key in expired_keys:
+            del self.cache[key]
+            log('info', f"清理过期缓存: {key[:8]}...", extra={'cache_operation': 'clean'})
+    
+    def clean_if_needed(self):
+        """如果缓存数量超过限制，清理最旧的项目"""
+        if len(self.cache) <= self.max_entries:
+            return
+        
+        # 按创建时间排序
+        sorted_keys = sorted(self.cache.keys(),
+                           key=lambda k: self.cache[k].get('created_at', 0))
+        
+        # 计算需要删除的数量
+        to_remove = len(self.cache) - self.max_entries
+        
+        # 删除最旧的项
+        for key in sorted_keys[:to_remove]:
+            del self.cache[key]
+            log('info', f"缓存容量限制，删除旧缓存: {key[:8]}...", extra={'cache_operation': 'limit'})
+
+def generate_cache_key(chat_request) -> str:
+    """生成请求的唯一缓存键"""
+    # 创建包含请求关键信息的字典
+    request_data = {
+        'model': chat_request.model, 
+        'messages': []
+    }
+    
+    # 添加消息内容
+    for msg in chat_request.messages:
+        if isinstance(msg.content, str):
+            message_data = {'role': msg.role, 'content': msg.content}
+            request_data['messages'].append(message_data)
+        elif isinstance(msg.content, list):
+            content_list = []
+            for item in msg.content:
+                if item.get('type') == 'text':
+                    content_list.append({'type': 'text', 'text': item.get('text')})
+                # 对于图像数据，我们只使用标识符而不是全部数据
+                elif item.get('type') == 'image_url':
+                    image_data = item.get('image_url', {}).get('url', '')
+                    if image_data.startswith('data:image/'):
+                        # 对于base64图像，使用前32字符作为标识符
+                        content_list.append({'type': 'image_url', 'hash': hashlib.md5(image_data[:32].encode()).hexdigest()})
+                    else:
+                        content_list.append({'type': 'image_url', 'url': image_data})
+            request_data['messages'].append({'role': msg.role, 'content': content_list})
+    
+    # 将字典转换为JSON字符串并计算哈希值
+    json_data = json.dumps(request_data, sort_keys=True)
+    return hashlib.md5(json_data.encode()).hexdigest()
+
+def cache_response(response, cache_key, client_ip, response_cache_manager, update_api_call_stats, api_key=None):
+    """
+    将响应存入缓存
+    
+    参数:
+    - response: 响应对象
+    - cache_key: 缓存键
+    - client_ip: 客户端IP
+    - response_cache_manager: 缓存管理器
+    - update_api_call_stats: 更新统计的函数
+    - api_key: API密钥，用于更新API密钥使用统计
+    """
+    if not cache_key:
+        return
+        
+    # 先检查缓存是否已存在
+    existing_cache = cache_key in response_cache_manager.cache
+    
+    if existing_cache:
+        log('info', f"缓存已存在，跳过存储: {cache_key[:8]}...",
+            extra={'cache_operation': 'skip-existing', 'request_type': 'non-stream'})
+    else:
+        response_cache_manager.store(cache_key, response, client_ip)
+        log('info', f"API响应已缓存: {cache_key[:8]}...",
+            extra={'cache_operation': 'store-new', 'request_type': 'non-stream'})
+    
+    # 更新API调用统计
+    update_api_call_stats(api_call_stats, api_key)

app/utils/error_handling.py

@@ -0,0 +1,137 @@
+import requests
+import logging
+import asyncio
+from fastapi import HTTPException, status
+from app.utils.logging import format_log_message
+
+logger = logging.getLogger("my_logger")
+
+def handle_gemini_error(error, current_api_key, key_manager) -> str:
+    if isinstance(error, requests.exceptions.HTTPError):
+        status_code = error.response.status_code
+        if status_code == 400:
+            try:
+                error_data = error.response.json()
+                if 'error' in error_data:
+                    if error_data['error'].get('code') == "invalid_argument":
+                        error_message = "无效的 API 密钥"
+                        extra_log_invalid_key = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+                        log_msg = format_log_message('ERROR', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 无效，可能已过期或被删除", extra=extra_log_invalid_key)
+                        logger.error(log_msg)
+                        # key_manager.blacklist_key(current_api_key)
+                        
+                        return error_message
+                    error_message = error_data['error'].get(
+                        'message', 'Bad Request')
+                    extra_log_400 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+                    log_msg = format_log_message('WARNING', f"400 错误请求: {error_message}", extra=extra_log_400)
+                    logger.warning(log_msg)
+                    return f"400 错误请求: {error_message}"
+            except ValueError:
+                error_message = "400 错误请求：响应不是有效的JSON格式"
+                extra_log_400_json = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+                log_msg = format_log_message('WARNING', error_message, extra=extra_log_400_json)
+                logger.warning(log_msg)
+                return error_message
+
+        elif status_code == 429:
+            error_message = "API 密钥配额已用尽或其他原因"
+            extra_log_429 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 429 官方资源耗尽或其他原因", extra=extra_log_429)
+            logger.warning(log_msg)
+            # key_manager.blacklist_key(current_api_key)
+             
+            return error_message
+
+        elif status_code == 403:
+            error_message = "权限被拒绝"
+            extra_log_403 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+            log_msg = format_log_message('ERROR', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 403 权限被拒绝", extra=extra_log_403)
+            logger.error(log_msg)
+            # key_manager.blacklist_key(current_api_key)
+            
+            return error_message
+        elif status_code == 500:
+            error_message = "服务器内部错误"
+            extra_log_500 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 500 服务器内部错误", extra=extra_log_500)
+            logger.warning(log_msg)
+            
+            return "Gemini API 内部错误"
+
+        elif status_code == 503:
+            error_message = "服务不可用"
+            extra_log_503 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 503 服务不可用", extra=extra_log_503)
+            logger.warning(log_msg)
+            
+            return "Gemini API 服务不可用"
+        else:
+            error_message = f"未知错误: {status_code}"
+            extra_log_other = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → {status_code} 未知错误", extra=extra_log_other)
+            logger.warning(log_msg)
+            
+            return f"未知错误/模型不可用: {status_code}"
+
+    elif isinstance(error, requests.exceptions.ConnectionError):
+        error_message = "连接错误"
+        log_msg = format_log_message('WARNING', error_message, extra={'error_message': error_message})
+        logger.warning(log_msg)
+        return error_message
+
+    elif isinstance(error, requests.exceptions.Timeout):
+        error_message = "请求超时"
+        log_msg = format_log_message('WARNING', error_message, extra={'error_message': error_message})
+        logger.warning(log_msg)
+        return error_message
+    else:
+        error_message = f"发生未知错误: {error}"
+        log_msg = format_log_message('ERROR', error_message, extra={'error_message': error_message})
+        logger.error(log_msg)
+        return error_message
+
+def translate_error(message: str) -> str:
+    if "quota exceeded" in message.lower():
+        return "API 密钥配额已用尽"
+    if "invalid argument" in message.lower():
+        return "无效参数"
+    if "internal server error" in message.lower():
+        return "服务器内部错误"
+    if "service unavailable" in message.lower():
+        return "服务不可用"
+    return message
+
+async def handle_api_error(e, api_key, key_manager, request_type, model, retry_count=0):
+    """统一处理API错误，对500和503错误实现自动重试机制"""
+    error_detail = handle_gemini_error(e, api_key, key_manager)
+    
+    # 处理500和503服务器错误
+    if isinstance(e, requests.exceptions.HTTPError) and ('500' in str(e) or '503' in str(e)):
+        status_code = '500' if '500' in str(e) else '503'
+        
+        # 最多重试3次
+        if retry_count < 3:
+            wait_time = min(1 * (2 ** retry_count), 16)  # RETRY_DELAY=1, MAX_RETRY_DELAY=16
+            log_msg = format_log_message('WARNING', f"Gemini服务器错误({status_code})，等待{wait_time}秒后重试 ({retry_count+1}/3)",
+                extra={'key': api_key[:8], 'request_type': request_type, 'model': model, 'status_code': int(status_code)})
+            logger.warning(log_msg)
+            
+            # 等待后返回重试信号
+            await asyncio.sleep(wait_time)
+            return {'should_retry': True, 'error': error_detail, 'remove_cache': False}
+        
+        # 重试次数用尽，直接返回错误状态码
+        log_msg = format_log_message('ERROR', f"服务器错误({status_code})重试{retry_count}次后仍然失败",
+            extra={'key': api_key[:8], 'request_type': request_type, 'model': model, 'status_code': int(status_code)})
+        logger.error(log_msg)
+        
+        # 不建议切换密钥，直接抛出HTTP异常
+        raise HTTPException(status_code=int(status_code),
+                          detail=f"Gemini API 服务器错误({status_code})，请稍后重试")
+    
+    # 对于其他错误，返回切换密钥的信号
+    log_msg = format_log_message('ERROR', f"API错误: {error_detail}",
+        extra={'key': api_key[:8], 'request_type': request_type, 'model': model, 'error_message': error_detail})
+    logger.error(log_msg)
+    return {'should_retry': False, 'should_switch_key': True, 'error': error_detail, 'remove_cache': True}

app/utils/logging.py

@@ -0,0 +1,72 @@
+import logging
+from datetime import datetime
+from collections import deque
+from threading import Lock
+
+DEBUG = False  # 可以从环境变量中获取
+
+LOG_FORMAT_DEBUG = '%(asctime)s - %(levelname)s - [%(key)s]-%(request_type)s-[%(model)s]-%(status_code)s: %(message)s - %(error_message)s'
+LOG_FORMAT_NORMAL = '[%(asctime)s] [%(levelname)s] [%(key)s]-%(request_type)s-[%(model)s]-%(status_code)s: %(message)s'
+
+# 配置 logger
+logger = logging.getLogger("my_logger")
+logger.setLevel(logging.DEBUG)
+
+# 控制台处理器
+console_handler = logging.StreamHandler()
+console_formatter = logging.Formatter('%(message)s')
+console_handler.setFormatter(console_formatter)
+logger.addHandler(console_handler)
+
+# 日志缓存，用于在网页上显示最近的日志
+class LogManager:
+    def __init__(self, max_logs=100):
+        self.logs = deque(maxlen=max_logs)  # 使用双端队列存储最近的日志
+        self.lock = Lock()
+    
+    def add_log(self, log_entry):
+        with self.lock:
+            self.logs.append(log_entry)
+    
+    def get_recent_logs(self, count=50):
+        with self.lock:
+            return list(self.logs)[-count:]
+
+# 创建日志管理器实例
+log_manager = LogManager()
+
+def format_log_message(level, message, extra=None):
+    extra = extra or {}
+    log_values = {
+        'asctime': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'levelname': level,
+        'key': extra.get('key', 'N/A'),
+        'request_type': extra.get('request_type', 'N/A'),
+        'model': extra.get('model', 'N/A'),
+        'status_code': extra.get('status_code', 'N/A'),
+        'error_message': extra.get('error_message', ''),
+        'message': message
+    }
+    log_format = LOG_FORMAT_DEBUG if DEBUG else LOG_FORMAT_NORMAL
+    formatted_log = log_format % log_values
+    
+    # 将格式化后的日志添加到日志管理器
+    log_entry = {
+        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'level': level,
+        'key': extra.get('key', 'N/A'),
+        'request_type': extra.get('request_type', 'N/A'),
+        'model': extra.get('model', 'N/A'),
+        'status_code': extra.get('status_code', 'N/A'),
+        'message': message,
+        'error_message': extra.get('error_message', ''),
+        'formatted': formatted_log
+    }
+    log_manager.add_log(log_entry)
+    
+    return formatted_log
+
+def log(level: str, message: str, **extra):
+    """简化日志记录的统一函数"""
+    msg = format_log_message(level.upper(), message, extra=extra)
+    getattr(logger, level.lower())(msg)

app/utils/maintenance.py

@@ -0,0 +1,36 @@
+import sys
+from apscheduler.schedulers.background import BackgroundScheduler
+from app.utils.logging import log
+from app.utils.stats import clean_expired_stats
+from app.config import api_call_stats
+from app.utils import check_version
+def handle_exception(exc_type, exc_value, exc_traceback):
+    """
+    全局异常处理函数
+    
+    处理未捕获的异常，并记录到日志中
+    """
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.excepthook(exc_type, exc_value, exc_traceback)
+        return
+    from app.utils.error_handling import translate_error
+    error_message = translate_error(str(exc_value))
+    log('error', f"未捕获的异常: {error_message}", status_code=500, error_message=error_message)
+
+def schedule_cache_cleanup(response_cache_manager, active_requests_manager):
+    """
+    设置定期清理缓存和活跃请求的定时任务
+    顺便定时检查更新
+    Args:
+        response_cache_manager: 响应缓存管理器实例
+        active_requests_manager: 活跃请求管理器实例
+    """
+    scheduler = BackgroundScheduler()
+    scheduler.add_job(response_cache_manager.clean_expired, 'interval', minutes=1)  # 每分钟清理过期缓存
+    scheduler.add_job(active_requests_manager.clean_completed, 'interval', seconds=30)  # 每30秒清理已完成的活跃请求
+    scheduler.add_job(active_requests_manager.clean_long_running, 'interval', minutes=5, args=[300])  # 每5分钟清理运行超过5分钟的任务
+    scheduler.add_job(clean_expired_stats, 'interval', minutes=5,args=[api_call_stats])  # 每5分钟清理过期的统计数据
+    scheduler.add_job(check_version, 'interval', minutes=240)  # 每4小时检查更新
+    scheduler.start()
+    
+    return scheduler

app/utils/rate_limiting.py

@@ -0,0 +1,36 @@
+import time
+from threading import Lock
+from fastapi import HTTPException, Request
+
+rate_limit_data = {}
+rate_limit_lock = Lock()
+
+def protect_from_abuse(request: Request, max_requests_per_minute: int = 30, max_requests_per_day_per_ip: int = 600):
+    now = int(time.time())
+    minute = now // 60
+    day = now // (60 * 60 * 24)
+
+    minute_key = f"{request.url.path}:{minute}"
+    day_key = f"{request.client.host}:{day}"
+
+    with rate_limit_lock:
+        minute_count, minute_timestamp = rate_limit_data.get(
+            minute_key, (0, now))
+        if now - minute_timestamp >= 60:
+            minute_count = 0
+            minute_timestamp = now
+        minute_count += 1
+        rate_limit_data[minute_key] = (minute_count, minute_timestamp)
+
+        day_count, day_timestamp = rate_limit_data.get(day_key, (0, now))
+        if now - day_timestamp >= 86400:
+            day_count = 0
+            day_timestamp = now
+        day_count += 1
+        rate_limit_data[day_key] = (day_count, day_timestamp)
+
+    if minute_count > max_requests_per_minute:
+        raise HTTPException(status_code=429, detail={
+            "message": "Too many requests per minute", "limit": max_requests_per_minute})
+    if day_count > max_requests_per_day_per_ip:
+        raise HTTPException(status_code=429, detail={"message": "Too many requests per day from this IP", "limit": max_requests_per_day_per_ip})

app/utils/request.py

@@ -0,0 +1,72 @@
+import asyncio
+import time
+from typing import Dict, Any
+from app.utils.logging import log
+
+class ActiveRequestsManager:
+    """管理活跃API请求的类"""
+    
+    def __init__(self, requests_pool: Dict[str, asyncio.Task] = None):
+        self.active_requests = requests_pool if requests_pool is not None else {}  # 存储活跃请求
+    
+    def add(self, key: str, task: asyncio.Task):
+        """添加新的活跃请求任务"""
+        task.creation_time = time.time()  # 添加创建时间属性
+        self.active_requests[key] = task
+    
+    def get(self, key: str):
+        """获取活跃请求任务"""
+        return self.active_requests.get(key)
+    
+    def remove(self, key: str):
+        """移除活跃请求任务"""
+        if key in self.active_requests:
+            del self.active_requests[key]
+            return True
+        return False
+    
+    def remove_by_prefix(self, prefix: str):
+        """移除所有以特定前缀开头的活跃请求任务"""
+        keys_to_remove = [k for k in self.active_requests.keys() if k.startswith(prefix)]
+        for key in keys_to_remove:
+            self.remove(key)
+        return len(keys_to_remove)
+    
+    def clean_completed(self):
+        """清理所有已完成或已取消的任务"""
+        keys_to_remove = []
+        
+        for key, task in self.active_requests.items():
+            if task.done() or task.cancelled():
+                keys_to_remove.append(key)
+        
+        for key in keys_to_remove:
+            self.remove(key)
+        
+        # if keys_to_remove:
+        #    log('info', f"清理已完成请求任务: {len(keys_to_remove)}个", cleanup='active_requests')
+    
+    def clean_long_running(self, max_age_seconds: int = 300):
+        """清理长时间运行的任务"""
+        now = time.time()
+        long_running_keys = []
+        
+        for key, task in list(self.active_requests.items()):
+            if (hasattr(task, 'creation_time') and
+                task.creation_time < now - max_age_seconds and
+                not task.done() and not task.cancelled()):
+                
+                long_running_keys.append(key)
+                task.cancel()  # 取消长时间运行的任务
+        
+        if long_running_keys:
+            log('warning', f"取消长时间运行的任务: {len(long_running_keys)}个", cleanup='long_running_tasks')
+
+async def check_client_disconnect(http_request, current_api_key: str, request_type: str, model: str):
+    """检查客户端是否断开连接"""
+    while True:
+        if await http_request.is_disconnected():
+            extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': model, 'error_message': '检测到客户端断开连接'}
+            log('info', "客户端连接已中断，等待API请求完成", extra=extra_log)
+            return True
+        await asyncio.sleep(0.5)

app/utils/response.py

@@ -0,0 +1,59 @@
+import time
+from fastapi import status
+from fastapi.responses import JSONResponse
+
+def create_chat_response(model: str, choices: list, id: str = None):
+    """创建标准响应对象的工厂函数"""
+    return {
+        "id": id or f"chatcmpl-{int(time.time()*1000)}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+        "usage": {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0
+        }
+    }
+
+def create_error_response(model: str, error_message: str):
+    """创建错误响应对象的工厂函数"""
+    return create_chat_response(
+        model=model,
+        choices=[{
+            "index": 0,
+            "message": {
+                "role": "assistant",
+                "content": error_message
+            },
+            "finish_reason": "error"
+        }]
+    )
+
+def create_response(chat_request, response_content):
+    """创建标准响应对象但不缓存"""
+    # 创建响应对象
+    return create_chat_response(
+        model=chat_request.model,
+        choices=[{
+            "index": 0, 
+            "message": {
+                "role": "assistant", 
+                "content": response_content.text
+            }, 
+            "finish_reason": "stop"
+        }]
+    )
+
+def handle_exception(exc_type, exc_value, exc_traceback, translate_error, log):
+    """处理全局异常的函数"""
+    if issubclass(exc_type, KeyboardInterrupt):
+        # 对于KeyboardInterrupt，使用默认处理
+        import sys
+        sys.excepthook(exc_type, exc_value, exc_traceback)
+        return
+    
+    # 对于其他异常，记录日志
+    error_message = translate_error(str(exc_value))
+    log('error', f"未捕获的异常: {error_message}", status_code=500, error_message=error_message)

app/utils/stats.py

@@ -0,0 +1,158 @@
+from datetime import datetime, timedelta
+from app.utils.logging import log
+
+def clean_expired_stats(api_call_stats):
+    """清理过期统计数据的函数"""
+    now = datetime.now()
+    
+    # 清理24小时前的数据
+    # 清理总调用次数
+    for hour_key in list(api_call_stats['last_24h']['total'].keys()):
+        try:
+            hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+            if (now - hour_time).total_seconds() > 24 * 3600:  # 超过24小时
+                del api_call_stats['last_24h']['total'][hour_key]
+        except ValueError:
+            # 如果键格式不正确，直接删除
+            del api_call_stats['last_24h']['total'][hour_key]
+    
+    # 清理按端点分类的数据
+    for endpoint in list(api_call_stats['last_24h']['by_endpoint'].keys()):
+        if not isinstance(api_call_stats['last_24h']['by_endpoint'][endpoint], dict):
+            del api_call_stats['last_24h']['by_endpoint'][endpoint]
+            continue
+            
+        for hour_key in list(api_call_stats['last_24h']['by_endpoint'][endpoint].keys()):
+            try:
+                hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+                if (now - hour_time).total_seconds() > 24 * 3600:  # 超过24小时
+                    del api_call_stats['last_24h']['by_endpoint'][endpoint][hour_key]
+            except ValueError:
+                # 如果键格式不正确，直接删除
+                del api_call_stats['last_24h']['by_endpoint'][endpoint][hour_key]
+    
+    # 清理一小时前的小时统计数据
+    one_hour_ago = now - timedelta(hours=1)
+    # 清理总调用次数
+    for hour_key in list(api_call_stats['hourly']['total'].keys()):
+        try:
+            hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+            if hour_time < one_hour_ago:
+                del api_call_stats['hourly']['total'][hour_key]
+        except ValueError:
+            # 如果键格式不正确，直接删除
+            del api_call_stats['hourly']['total'][hour_key]
+    
+    # 清理按端点分类的数据
+    for endpoint in list(api_call_stats['hourly']['by_endpoint'].keys()):
+        if not isinstance(api_call_stats['hourly']['by_endpoint'][endpoint], dict):
+            del api_call_stats['hourly']['by_endpoint'][endpoint]
+            continue
+            
+        for hour_key in list(api_call_stats['hourly']['by_endpoint'][endpoint].keys()):
+            try:
+                hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+                if hour_time < one_hour_ago:
+                    del api_call_stats['hourly']['by_endpoint'][endpoint][hour_key]
+            except ValueError:
+                # 如果键格式不正确，直接删除
+                del api_call_stats['hourly']['by_endpoint'][endpoint][hour_key]
+    
+    # 清理一分钟前的分钟统计数据
+    one_minute_ago = now - timedelta(minutes=1)
+    # 清理总调用次数
+    for minute_key in list(api_call_stats['minute']['total'].keys()):
+        try:
+            minute_time = datetime.strptime(minute_key, '%Y-%m-%d %H:%M')
+            if minute_time < one_minute_ago:
+                del api_call_stats['minute']['total'][minute_key]
+        except ValueError:
+            # 如果键格式不正确，直接删除
+            del api_call_stats['minute']['total'][minute_key]
+    
+    # 清理按端点分类的数据
+    for endpoint in list(api_call_stats['minute']['by_endpoint'].keys()):
+        if not isinstance(api_call_stats['minute']['by_endpoint'][endpoint], dict):
+            del api_call_stats['minute']['by_endpoint'][endpoint]
+            continue
+            
+        for minute_key in list(api_call_stats['minute']['by_endpoint'][endpoint].keys()):
+            try:
+                minute_time = datetime.strptime(minute_key, '%Y-%m-%d %H:%M')
+                if minute_time < one_minute_ago:
+                    del api_call_stats['minute']['by_endpoint'][endpoint][minute_key]
+            except ValueError:
+                # 如果键格式不正确，直接删除
+                del api_call_stats['minute']['by_endpoint'][endpoint][minute_key]
+
+def update_api_call_stats(api_call_stats, endpoint=None):
+    """
+    更新API调用统计的函数
+    
+    参数:
+    - api_call_stats: 统计数据字典
+    - endpoint: APIkey,为None则只更新总调用次数
+    """
+    now = datetime.now()
+    hour_key = now.strftime('%Y-%m-%d %H:00')
+    minute_key = now.strftime('%Y-%m-%d %H:%M')
+    
+    # 检查并清理过期统计
+    clean_expired_stats(api_call_stats)
+    
+    # 初始化总调用次数键（如果不存在）
+    if hour_key not in api_call_stats['last_24h']['total']:
+        api_call_stats['last_24h']['total'][hour_key] = 0
+    if hour_key not in api_call_stats['hourly']['total']:
+        api_call_stats['hourly']['total'][hour_key] = 0
+    if minute_key not in api_call_stats['minute']['total']:
+        api_call_stats['minute']['total'][minute_key] = 0
+    
+    # 更新总调用次数统计
+    api_call_stats['last_24h']['total'][hour_key] += 1
+    api_call_stats['hourly']['total'][hour_key] += 1
+    api_call_stats['minute']['total'][minute_key] += 1
+    
+    # 如果提供了端点，更新按端点分类的统计
+    if endpoint:
+        # 确保端点字典存在
+        if endpoint not in api_call_stats['last_24h']['by_endpoint']:
+            api_call_stats['last_24h']['by_endpoint'][endpoint] = {}
+        if endpoint not in api_call_stats['hourly']['by_endpoint']:
+            api_call_stats['hourly']['by_endpoint'][endpoint] = {}
+        if endpoint not in api_call_stats['minute']['by_endpoint']:
+            api_call_stats['minute']['by_endpoint'][endpoint] = {}
+        
+        # 初始化端点特定的键（如果不存在）
+        if hour_key not in api_call_stats['last_24h']['by_endpoint'][endpoint]:
+            api_call_stats['last_24h']['by_endpoint'][endpoint][hour_key] = 0
+        if hour_key not in api_call_stats['hourly']['by_endpoint'][endpoint]:
+            api_call_stats['hourly']['by_endpoint'][endpoint][hour_key] = 0
+        if minute_key not in api_call_stats['minute']['by_endpoint'][endpoint]:
+            api_call_stats['minute']['by_endpoint'][endpoint][minute_key] = 0
+        
+        # 更新端点特定的统计
+        api_call_stats['last_24h']['by_endpoint'][endpoint][hour_key] += 1
+        api_call_stats['hourly']['by_endpoint'][endpoint][hour_key] += 1
+        api_call_stats['minute']['by_endpoint'][endpoint][minute_key] += 1
+    
+    # 计算总调用次数
+    total_24h = sum(api_call_stats['last_24h']['total'].values())
+    total_hourly = sum(api_call_stats['hourly']['total'].values())
+    total_minute = sum(api_call_stats['minute']['total'].values())
+    
+    log_message = "API调用统计已更新: 24小时=%s, 1小时=%s, 1分钟=%s" % (
+        total_24h, total_hourly, total_minute
+    )
+    
+    # 如果提供了端点，添加端点特定的统计信息
+    if endpoint:
+        endpoint_24h = sum(api_call_stats['last_24h']['by_endpoint'][endpoint].values())
+        endpoint_hourly = sum(api_call_stats['hourly']['by_endpoint'][endpoint].values())
+        endpoint_minute = sum(api_call_stats['minute']['by_endpoint'][endpoint].values())
+        
+        log_message += " | 端点 '%s': 24小时=%s, 1小时=%s, 1分钟=%s" % (
+            endpoint[:8], endpoint_24h, endpoint_hourly, endpoint_minute
+        )
+    
+    log('info', log_message)

app/utils/version.py

@@ -0,0 +1,50 @@
+import requests
+import logging
+from app.utils.logging import log
+import app.config.settings as settings
+async def check_version():
+    """
+    检查应用程序版本更新
+    
+    从本地和远程获取版本信息，并比较版本号以确定是否有更新
+    """
+    # 导入全局变量
+    try:
+        # 读取本地版本
+        with open("./version.txt", "r") as f:
+            version_line = f.read().strip()
+            settings.local_version = version_line.split("=")[1] if "=" in version_line else "0.0.0"
+        
+        # 获取远程版本
+        github_url = "https://raw.githubusercontent.com/wyeeeee/hajimi/refs/heads/main/version.txt"
+        response = requests.get(github_url, timeout=5)
+        if response.status_code == 200:
+            version_line = response.text.strip()
+            settings.remote_version = version_line.split("=")[1] if "=" in version_line else "0.0.0"
+            
+            # 比较版本号
+            local_parts = [int(x) for x in settings.local_version.split(".")]
+            remote_parts = [int(x) for x in settings.remote_version.split(".")]
+            
+            # 确保两个列表长度相同
+            while len(local_parts) < len(remote_parts):
+                local_parts.append(0)
+            while len(remote_parts) < len(local_parts):
+                remote_parts.append(0)
+                
+            # 比较版本号
+            settings.has_update = False
+            for i in range(len(local_parts)):
+                if remote_parts[i] > local_parts[i]:
+                    settings.has_update = True
+                    break
+                elif remote_parts[i] < local_parts[i]:
+                    break
+            
+            log('info', f"版本检查: 本地版本 {settings.local_version}, 远程版本 {settings.remote_version}, 有更新: {settings.has_update}")
+        else:
+            log('warning', f"无法获取远程版本信息，HTTP状态码: {response.status_code}")
+    except Exception as e:
+        log('error', f"版本检查失败: {str(e)}")
+        
+    return settings.local_version, settings.remote_version, settings.has_update

version.txt

@@ -1 +1 @@
-version=0.0.3
+version=0.0.4