Upload 48 files

Dockerfile

@@ -1,20 +1,20 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# 安装 unzip 工具
-RUN apt-get update && apt-get install -y unzip && rm -rf /var/lib/apt/lists/*
-
-COPY app.zip .
-COPY requirements.txt .
-COPY version.txt .
-RUN mkdir -p app
-# 解压 app.zip 文件
-RUN unzip app.zip -d app && rm app.zip
-
-RUN pip install --no-cache-dir -r requirements.txt
-
-# 环境变量 (在 Hugging Face Spaces 中设置)
-# ENV GEMINI_API_KEYS=your_key_1,your_key_2,your_key_3
-
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# 安装 unzip 工具
+RUN apt-get update && apt-get install -y unzip && rm -rf /var/lib/apt/lists/*
+
+COPY app.zip .
+COPY requirements.txt .
+COPY version.txt .
+RUN mkdir -p app
+# 解压 app.zip 文件
+RUN unzip app.zip -d app && rm app.zip
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 环境变量 (在 Hugging Face Spaces 中设置)
+# ENV GEMINI_API_KEYS=your_key_1,your_key_2,your_key_3
+
 CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

Dockerfile_git

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY ./app /app/app
+COPY requirements.txt .
+COPY version.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 环境变量 (在 Hugging Face Spaces 中设置)
+# ENV GEMINI_API_KEYS=your_key_1,your_key_2,your_key_3
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/api/auth.py

@@ -0,0 +1,14 @@
+from fastapi import HTTPException, Request
+
+# 密码验证依赖
+async def verify_password(request: Request, PASSWORD: str = None):
+    """验证请求中的Bearer令牌是否与配置的密码匹配"""
+    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/api/client_disconnect.py

@@ -0,0 +1,120 @@
+import asyncio
+import time
+from fastapi import Request
+from app.models import ChatCompletionRequest
+from app.utils import create_error_response
+from .logging_utils import log
+
+# 客户端断开检测函数
+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,
+    response_cache_manager,
+    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}")

app/api/dashboard.py

@@ -95,7 +95,7 @@ async def get_dashboard_data():
     api_key_stats.sort(key=lambda x: x['usage_percent'], reverse=True)
     
     # 获取最近的日志
-    recent_logs = log_manager.get_recent_logs(50)  # 获取最近50条日志
+    recent_logs = log_manager.get_recent_logs(500)  # 获取最近50条日志
     
     # 返回JSON格式的数据
     return {

app/api/gemini_handlers.py

@@ -0,0 +1,57 @@
+import asyncio
+from app.models import ChatCompletionRequest
+from app.services import GeminiClient
+from .logging_utils import log
+
+# Gemini完成请求函数
+async def run_gemini_completion(
+    gemini_client, 
+    chat_request: ChatCompletionRequest, 
+    contents,
+    system_instruction,
+    request_type: str,
+    current_api_key: str,
+    safety_settings,
+    safety_settings_g2
+):
+    """运行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

app/api/logging_utils.py

@@ -0,0 +1,11 @@
+import logging
+from app.utils import format_log_message
+
+# 获取logger
+logger = logging.getLogger("my_logger")
+
+# 日志记录函数
+def log(level: str, message: str, **extra):
+    """简化日志记录的统一函数"""
+    msg = format_log_message(level.upper(), message, extra=extra)
+    getattr(logger, level.lower())(msg)

app/api/nonstream_handlers.py

@@ -0,0 +1,157 @@
+import asyncio
+from fastapi import HTTPException, status, Request
+from app.models import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils import cache_response, update_api_call_stats
+from .logging_utils import log
+from .client_disconnect import check_client_disconnect, handle_client_disconnect
+from .gemini_handlers import run_gemini_completion
+
+# 非流式请求处理函数
+async def process_nonstream_request(
+    chat_request: ChatCompletionRequest, 
+    http_request: Request, 
+    request_type: str,
+    contents,
+    system_instruction,
+    current_api_key: str,
+    response_cache_manager,
+    active_requests_manager,
+    safety_settings,
+    safety_settings_g2,
+    api_call_stats,
+    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,
+            safety_settings,
+            safety_settings_g2
+        )
+    )
+    
+    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,
+                response_cache_manager,
+                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/api/request_handlers.py

@@ -0,0 +1,165 @@
+import asyncio
+import json
+from typing import Literal
+from fastapi import HTTPException, Request, status
+from fastapi.responses import StreamingResponse
+from app.models import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils import protect_from_abuse, handle_gemini_error, handle_api_error
+from .logging_utils import log
+from .stream_handlers import process_stream_request
+from .nonstream_handlers import process_nonstream_request
+
+# 请求处理函数
+async def process_request(
+    chat_request: ChatCompletionRequest, 
+    http_request: Request, 
+    request_type: Literal['stream', 'non-stream'], 
+    key_manager,
+    response_cache_manager,
+    active_requests_manager,
+    safety_settings,
+    safety_settings_g2,
+    api_call_stats,
+    FAKE_STREAMING,
+    FAKE_STREAMING_INTERVAL,
+    MAX_REQUESTS_PER_MINUTE,
+    MAX_REQUESTS_PER_DAY_PER_IP,
+    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,
+                            key_manager,
+                            safety_settings,
+                            safety_settings_g2,
+                            api_call_stats,
+                            FAKE_STREAMING,
+                            FAKE_STREAMING_INTERVAL
+                        )
+                    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,
+                        response_cache_manager,
+                        active_requests_manager,
+                        safety_settings,
+                        safety_settings_g2,
+                        api_call_stats,
+                        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)

app/api/routes.py

@@ -1,33 +1,25 @@
 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.services import GeminiClient
 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
+    create_error_response
 )
-import json
-import asyncio
-import time
-import logging
-import random
-from typing import Literal
 from app.config.settings import (
     api_call_stats,
     BLOCKED_MODELS
 )
-# 获取logger
-logger = logging.getLogger("my_logger")
+import asyncio
+import time
+import logging
+
+# 导入拆分后的模块
+from .auth import verify_password
+from .logging_utils import log
+from .request_handlers import process_request
 
 # 创建路由器
 router = APIRouter()
@@ -76,23 +68,9 @@ def init_router(
     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")
+# 自定义密码验证依赖
+async def custom_verify_password(request: Request):
+    await verify_password(request, PASSWORD)
 
 # API路由
 @router.get("/v1/models", response_model=ModelList)
@@ -102,13 +80,27 @@ def list_models():
     return ModelList(data=[{"id": model, "object": "model", "created": 1678888888, "owned_by": "organization-owner"} for model in filtered_models])
 
 @router.post("/v1/chat/completions", response_model=ChatCompletionResponse)
-async def chat_completions(request: ChatCompletionRequest, http_request: Request, _: None = Depends(verify_password)):
+async def chat_completions(request: ChatCompletionRequest, http_request: Request, _: None = Depends(custom_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")
+        return await process_request(
+            request, 
+            http_request, 
+            "stream",
+            key_manager,
+            response_cache_manager,
+            active_requests_manager,
+            safety_settings,
+            safety_settings_g2,
+            api_call_stats,
+            FAKE_STREAMING,
+            FAKE_STREAMING_INTERVAL,
+            MAX_REQUESTS_PER_MINUTE,
+            MAX_REQUESTS_PER_DAY_PER_IP
+        )
     
     # 生成完整缓存键 - 用于精确匹配
     cache_key = generate_cache_key(request)
@@ -191,7 +183,23 @@ async def chat_completions(request: ChatCompletionRequest, http_request: Request
      
     # 创建请求处理任务
     process_task = asyncio.create_task(
-        process_request(request, http_request, "non-stream", cache_key=cache_key, client_ip=client_ip)
+        process_request(
+            request, 
+            http_request, 
+            "non-stream",
+            key_manager,
+            response_cache_manager,
+            active_requests_manager,
+            safety_settings,
+            safety_settings_g2,
+            api_call_stats,
+            FAKE_STREAMING,
+            FAKE_STREAMING_INTERVAL,
+            MAX_REQUESTS_PER_MINUTE,
+            MAX_REQUESTS_PER_DAY_PER_IP,
+            cache_key,
+            client_ip
+        )
     )
     
     # 将任务添加到活跃请求池
@@ -213,706 +221,4 @@ async def chat_completions(request: ChatCompletionRequest, http_request: Request
             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
+        raise

app/api/stream_handlers.py

@@ -0,0 +1,284 @@
+import asyncio
+import json
+import time
+import random
+from fastapi import Request
+from fastapi.responses import StreamingResponse
+from app.models import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils import handle_gemini_error, update_api_call_stats
+from .logging_utils import log
+
+# 流式请求处理函数
+async def process_stream_request(
+    chat_request: ChatCompletionRequest,
+    http_request: Request,
+    contents,
+    system_instruction,
+    current_api_key: str,
+    key_manager,
+    safety_settings,
+    safety_settings_g2,
+    api_call_stats,
+    FAKE_STREAMING,
+    FAKE_STREAMING_INTERVAL
+) -> 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(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:
+                    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")

app/config/settings.py

@@ -11,6 +11,11 @@ FAKE_STREAMING = os.environ.get("FAKE_STREAMING", "true").lower() in ["true", "1
 # 假流式请求的空内容返回间隔（秒）
 FAKE_STREAMING_INTERVAL = float(os.environ.get("FAKE_STREAMING_INTERVAL", "1"))
 
+#随机字符串
+RANDOM_STRING = os.environ.get("RANDOM_STRING", "true").lower() in ["true", "1", "yes"]
+RANDOM_STRING_LENGTH = int(os.environ.get("RANDOM_STRING_LENGTH", "20"))
+
+
 # 日志配置
 logging.getLogger("uvicorn").disabled = True
 logging.getLogger("uvicorn.access").disabled = True
@@ -35,10 +40,12 @@ REMOVE_CACHE_AFTER_USE = os.environ.get("REMOVE_CACHE_AFTER_USE", "true").lower(
 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
+
+version={
+    "local_version":"0.0.0",
+    "remote_version":"0.0.0",
+    "has_update":False
+}
 
 # API调用统计
 api_call_stats = {

app/main.py

@@ -22,6 +22,8 @@ from app.api import router, init_router, dashboard_router, init_dashboard_router
 from app.config.settings import (
     FAKE_STREAMING,
     FAKE_STREAMING_INTERVAL,
+    RANDOM_STRING,
+    RANDOM_STRING_LENGTH,
     PASSWORD,
     MAX_REQUESTS_PER_MINUTE,
     MAX_REQUESTS_PER_DAY_PER_IP,
@@ -34,9 +36,7 @@ from app.config.settings import (
     ENABLE_RECONNECT_DETECTION,
     api_call_stats,
     client_request_history,
-    local_version,
-    remote_version,
-    has_update,
+    version,
     API_KEY_DAILY_LIMIT
 )
 from app.config.safety import SAFETY_SETTINGS, SAFETY_SETTINGS_G2
@@ -115,7 +115,6 @@ async def startup_event():
     
     # 检查版本
     await check_version()
-    
     available_keys = await check_keys()
     if available_keys:
         key_manager.api_keys = available_keys
@@ -202,7 +201,7 @@ async def root(request: Request):
             continue
     
     # 获取最近的日志
-    recent_logs = log_manager.get_recent_logs(50)  # 获取最近50条日志
+    recent_logs = log_manager.get_recent_logs(500)  # 获取最近50条日志
     
     # 获取缓存统计
     total_cache = len(response_cache_manager.cache)
@@ -267,9 +266,15 @@ async def root(request: Request):
         "current_time": datetime.now().strftime('%H:%M:%S'),
         "logs": recent_logs,
         # 添加版本信息
-        "local_version": local_version,
-        "remote_version": remote_version,
-        "has_update": has_update,
+        "local_version": version["local_version"],
+        "remote_version": version["remote_version"],
+        "has_update": version["has_update"],
+        # 添加流式响应配置
+        "fake_streaming": FAKE_STREAMING,
+        "fake_streaming_interval": FAKE_STREAMING_INTERVAL,
+        # 添加随机字符串配置
+        "random_string": RANDOM_STRING,
+        "random_string_length": RANDOM_STRING_LENGTH,
         # 添加缓存信息
         "cache_entries": total_cache,
         "valid_cache": valid_cache,

app/services/gemini.py

@@ -8,7 +8,18 @@ from dataclasses import dataclass
 from typing import Optional, Dict, Any, List
 import httpx
 import logging
+import secrets
+import string
 from app.utils import format_log_message
+from app.config.settings import (    
+    RANDOM_STRING,
+    RANDOM_STRING_LENGTH
+)
+
+def generate_secure_random_string(length):
+    all_characters = string.ascii_letters + string.digits
+    secure_random_string = ''.join(secrets.choice(all_characters) for _ in range(length))
+    return secure_random_string
 
 logger = logging.getLogger('my_logger')
 
@@ -269,7 +280,6 @@ class GeminiClient:
         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:
@@ -331,6 +341,11 @@ class GeminiClient:
         if errors:
             return errors
         else:
+            if RANDOM_STRING:
+                gemini_history.insert(1,{'role': 'user', 'parts': [{'text': generate_secure_random_string(RANDOM_STRING_LENGTH)}]})
+                gemini_history.insert(len(gemini_history)-1,{'role': 'user', 'parts': [{'text': generate_secure_random_string(RANDOM_STRING_LENGTH)}]})
+                log_msg = format_log_message('INFO', "伪装消息成功")
+                logger.info(log_msg)
             return gemini_history, {"parts": [{"text": system_instruction_text}]}
 
     @staticmethod

app/templates/index.html

@@ -240,6 +240,15 @@
         .progress-bar.high {
             background-color: #dc3545; /* 红色 - 高使用率 */
         }
+        
+        /* 版本更新状态样式 */
+        .update-needed {
+            color: #dc3545; /* 红色 - 需要更新 */
+        }
+        
+        .up-to-date {
+            color: #28a745; /* 绿色 - 已是最新 */
+        }
     </style>
 </head>
 <body>
@@ -294,6 +303,9 @@
 
     <div class="info-box">
         <h2 class="section-title">⚙️ 环境配置</h2>
+        
+        <!-- 基本配置 -->
+        <h3 class="section-title">基本配置</h3>
         <div class="stats-grid">
             <div class="stat-card">
                 <div class="stat-value">{{ max_requests_per_minute }}</div>
@@ -308,30 +320,41 @@
                 <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>
+        
+        <!-- 功能配置 -->
+        <h3 class="section-title">功能配置</h3>
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-value">{{ "启用" if fake_streaming else "禁用" }}</div>
+                <div class="stat-label">假流式响应</div>
             </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 class="stat-card">
+                <div class="stat-value">{{ fake_streaming_interval }}秒</div>
+                <div class="stat-label">假流式间隔</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value">{{ "启用" if random_string else "禁用" }}</div>
+                <div class="stat-label">伪装信息</div>
+            </div>
+        </div>
+        
+        <!-- 版本信息 -->
+        <h3 class="section-title">版本信息</h3>
+        <div class="stats-grid">
+            <div class="stat-card">
+                <div class="stat-value">{{ local_version }}</div>
+                <div class="stat-label">当前版本</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value">{{ remote_version }}</div>
+                <div class="stat-label">最新版本</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value {% if has_update %}update-needed{% else %}up-to-date{% endif %}">
+                    {{ "需要更新" if has_update else "已是最新" }}
                 </div>
+                <div class="stat-label">更新状态</div>
             </div>
-            {% endif %}
         </div>
     </div>
 

app/utils/maintenance.py

@@ -1,9 +1,12 @@
-import sys
-from apscheduler.schedulers.background import BackgroundScheduler
+import sys,asyncio
+#from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.schedulers.asyncio import AsyncIOScheduler  # 替换为异步调度器
 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
+from zoneinfo import ZoneInfo
+from app.config import settings
 def handle_exception(exc_type, exc_value, exc_traceback):
     """
     全局异常处理函数
@@ -16,7 +19,7 @@ def handle_exception(exc_type, exc_value, exc_traceback):
     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):
     """
     设置定期清理缓存和活跃请求的定时任务
@@ -30,7 +33,45 @@ def schedule_cache_cleanup(response_cache_manager, active_requests_manager):
     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.add_job(check_version, 'interval', minutes=1)  # 每4小时检查更新
     scheduler.start()
     
-    return scheduler
+    return scheduler
+
+'''
+def schedule_cache_cleanup(response_cache_manager, active_requests_manager):
+    """
+    设置定期清理缓存和活跃请求的定时任务
+    顺便定时检查更新
+    Args:
+        response_cache_manager: 响应缓存管理器实例
+        active_requests_manager: 活跃请求管理器实例
+    """
+    beijing_tz = ZoneInfo("Asia/Shanghai")
+    scheduler = AsyncIOScheduler(timezone=beijing_tz)  # 使用 AsyncIOScheduler 替代 BackgroundScheduler
+    
+    # 添加任务时直接传递异步函数（无需额外包装）
+    scheduler.add_job(response_cache_manager.clean_expired, 'interval', minutes=1)
+    scheduler.add_job(active_requests_manager.clean_completed, 'interval', seconds=30)
+    scheduler.add_job(active_requests_manager.clean_long_running, 'interval', minutes=5, args=[300])
+    scheduler.add_job(clean_expired_stats, 'interval', minutes=5, args=[api_call_stats])
+    scheduler.add_job(check_version, 'interval', hours=4)
+    scheduler.add_job(api_call_stats_clean, 'cron', hour=16,minute=0)
+    scheduler.start()
+    return scheduler
+
+def api_call_stats_clean():
+    settings.api_call_stats = {
+    'last_24h': {
+        'total': {},  
+        'by_endpoint': {}  
+    },
+    'hourly': {
+        'total': {}, 
+        'by_endpoint': {}  
+    },
+    'minute': {
+        'total': {},  
+        'by_endpoint': {}  
+    }
+}

app/utils/version.py

@@ -13,18 +13,17 @@ async def check_version():
         # 读取本地版本
         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"
+            settings.version['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"
-            
+            settings.version['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(".")]
+            local_parts = [int(x) for x in settings.version['local_version'].split(".")]
+            remote_parts = [int(x) for x in settings.version['remote_version'].split(".")]
             
             # 确保两个列表长度相同
             while len(local_parts) < len(remote_parts):
@@ -33,18 +32,18 @@ async def check_version():
                 remote_parts.append(0)
                 
             # 比较版本号
-            settings.has_update = False
+            settings.version['has_update'] = False
             for i in range(len(local_parts)):
                 if remote_parts[i] > local_parts[i]:
-                    settings.has_update = True
+                    settings.version['has_update'] = True
                     break
                 elif remote_parts[i] < local_parts[i]:
                     break
             
-            log('info', f"版本检查: 本地版本 {settings.local_version}, 远程版本 {settings.remote_version}, 有更新: {settings.has_update}")
+            log('info', f"版本检查: 本地版本 {settings.version['local_version']}, 远程版本 {settings.version['remote_version']}, 有更新: {settings.version['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
+    return settings.version['has_update']

readme.md

@@ -4,13 +4,22 @@
 
 这是一个基于 FastAPI 构建的 Gemini API 代理，旨在提供一个简单、安全且可配置的方式来访问 Google 的 Gemini 模型。适用于在 Hugging Face Spaces 上部署，并支持openai api格式的工具集成。
 ###  使用文档
-- [使用文档](https://github.com/wyeeeee/hajimi/blob/main/wiki/wiki.md)
+- [使用文档](./wiki/wiki.md)
 ###  更新日志
+*   v0.0.5beta
+    * 新增“**伪装信息**功能，默认开启，可在转发消息中添加随机字符串伪装消息，防止被检测
+    * 修复若干bug
+    * 为前端界面新增**功能配置**栏目，可检查功能是否开启
+    * 北京时间16点自动重置统计数据
+    * 在环境变量中新增`RANDOM_STRING`，是否启用伪装信息，默认值为true
+    * 在环境变量中新增`RANDOM_STRING_LENGTH`，伪装信息长度，默认为20
+    * 为git用户提供单独的`Dockerfile_git`
 *   v0.0.4
     * 修改版本更新逻辑，现在为每四小时检查一次版本更新
     * 前端界面所有数据数据实现动态更新
-    * 新增“单api使用次数统计”，在原API调用统计下方新增可折叠的单api使用次数统计，同时提供进度条查看剩余使用次数
+    * 新增**单api使用次数统计**，在原API调用统计下方新增可折叠的单api使用次数统计，同时提供进度条查看剩余使用次数
     * 在环境变量中新增`API_KEY_DAILY_LIMIT`，为单api 24小时最大使用次数，默认值为25
+    * 在环境变量中新增`BLOCKED_MODELS`，为需要屏蔽的模型名称，多个模型用英文逗号分隔
 
 *   v0.0.3beta
     * 完善了客户端断开连接的处理逻辑（感谢[@warming-afternoon](https://github.com/warming-afternoon)）

requirements.txt

@@ -1,7 +1,7 @@
-fastapi
-uvicorn
-httpx
-python-dotenv
-requests
-apscheduler
+fastapi
+uvicorn
+httpx
+python-dotenv
+requests
+apscheduler
 jinja2

version.txt

@@ -1 +1 @@
-version=0.0.5
+version=0.0.5

wiki/Termux.md

@@ -0,0 +1,84 @@
+# Termux 安装与配置 Hajimi 项目教程 由[@天命不又](https://github.com/tmby)编写
+
+## 一、切换 Termux 清华源（有“魔法”的可跳过）
+
+```bash
+sed -i 's@^\(deb.*stable main\)$@#\1\ndeb https://mirrors.tuna.tsinghua.edu.cn/termux/apt/termux-main stable main@' $PREFIX/etc/apt/sources.list
+```
+
+## 二、安装必要依赖
+
+```bash
+apt update && apt --yes upgrade && apt --yes install git python rust
+```
+
+## 三、配置 pip 使用清华源（有“魔法”的可跳过）
+
+```bash
+pip config set global.index-url https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
+```
+
+## 四、配置 Rust 使用清华源（有“魔法”的可跳过）
+
+```bash
+export CARGO_REGISTRIES_CRATES_IO_INDEX="https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"
+```
+
+## 五、克隆项目源码（有“魔法”的可去除加速链接）
+
+```bash
+git clone https://github.boki.moe/https://github.com/wyeeeee/hajimi
+```
+
+## 六、进入项目目录
+
+```bash
+cd hajimi
+```
+
+## 七、安装 Python 依赖
+
+```bash
+pip install tzdata -r requirements.txt
+```
+
+> **提示**：安装和构建过程会比较慢，请耐心等待。
+
+---
+
+## 八、配置 Termux Widget 启动脚本
+
+### 1. 安装 Termux Widget 插件  
+项目地址：[termux-widget](https://github.com/termux/termux-widget)
+
+### 2. 使用 MT 管理器：
+- 打开 Termux 的根目录
+- 新建 `.shortcuts` 文件夹
+- 在其中创建一个空白脚本文件（例如 `哈基米启动`），内容如下：
+
+```bash
+#!/data/data/com.termux/files/usr/bin/bash
+
+HAJIMI_PATH=/data/data/com.termux/files/home/hajimi
+export GEMINI_API_KEYS="key1,key2,key3"
+
+termux-wake-lock
+cd $HAJIMI_PATH
+uvicorn app.main:app --reload --host 127.0.0.1 --port 7860
+```
+
+### 3. 添加桌面小部件
+- 在桌面添加 Termux Widget 快捷方式
+- 点击刚才创建的脚本，即可一键启动 Hajimi 服务
+
+---
+
+## 九、访问前端页面
+
+启动服务后，在浏览器中访问以下地址查看前端界面：
+
+```
+http://127.0.0.1:7860
+```
+
+> **注意**：此地址只能在当前设备本地访问，如需远程访问请进行端口转发或内网穿透设置。

wiki/docker.md

@@ -0,0 +1,91 @@
+# 使用 Docker 部署 Gemini 轮询魔改版教程 由 **北极星星** 编写
+
+## 一、准备工作
+
+### 1.1 下载项目
+
+从 releases 下载最新版本，并解压到任意目录。
+
+### 1.2 配置环境变量
+
+在项目根目录下创建 `.env` 文件，配置必要环境变量，示例如下：
+
+```
+GEMINI_API_KEYS=key1,key2,key3
+PASSWORD=your_password
+TZ=Asia/Shanghai
+```
+
+按需修改上述值，注意⚠️key必须使用英文逗号间隔。
+
+## 二、构建并运行 Docker 容器
+
+### 2.1 构建镜像
+
+在项目根目录打开终端，执行命令构建 Docker 镜像：
+
+```bash
+cd 项目文件夹完整路径（例如：cd /volume3/docker/hagemi）
+docker build -t hajimi-app .
+```
+
+此过程可能需一些时间，取决于网络和系统性能。
+
+### 2.2 运行容器
+
+镜像构建完成后，执行命令启动 Docker 容器，如端口被占用需修改左侧端口号：
+
+```bash
+docker run -d -p 7860:7860 --env-file .env hajimi-app
+```
+
+## 三、验证部署
+
+### 3.1 检查容器状态
+
+打开 docker 查看 hajimi-app 容器运行状态，确认正常启动。
+
+### 3.2 访问应用
+
+打开浏览器，访问 http://localhost:7860，若看到应用界面，则部署成功。
+
+API 地址：http://localhost:7860/v1  
+key：PASSWORD=your_password
+
+## 四、容器更新
+
+### 4.1 更新脚本
+
+将下面 gemini_docker_update.sh 脚本按需修改保存为一个 .sh 文件：
+
+```bash
+# 停止容器
+docker stop hajimi-app
+# 删除容器
+docker rm hajimi-app
+# 进入项目所在目录
+cd /volume3/docker/hagemi
+# 使用以下命令拉取最新代码
+git pull origin main
+# 构建新的 Docker 镜像
+docker build -t hajimi-app .
+# 运行新容器
+docker run -d -p 7860:7860 --env-file .env hajimi-app
+# 查看容器状态
+docker ps -a | grep hajimi-app    
+```
+
+### 4.2 脚本存放位置
+
+把 gemini_docker_update.sh 脚本存放在项目根目录，例如项目文件路径是 /volume3/docker/hagemi，便将脚本存放在 /volume3/docker/hagemi。
+
+### 4.3 执行更新
+
+进入终端输入命令，执行更新脚本：
+
+```bash
+cd /volume3/docker/hagemi
+./gemini_docker_update.sh
+```
+
+通过以上步骤，即可使用 Docker 成功部署 Gemini 轮询魔改版应用。

wiki/wiki.md

@@ -7,16 +7,16 @@
 
 ### 1.2 使用huggingface space部署项目
 - 在[huggingface](https://huggingface.co)注册账号。
-- 注册完成后，进入[spaces](https://huggingface.co/spaces)如图所示，点击new spaces。<br>![spaces](https://github.com/wyeeeee/hajimi/blob/main/wiki/img/spaces.png)
-- 如图所示，填入创建选项，注意space name不要使用符号，填写完成后，点击create space<br>![create_space](https://github.com/wyeeeee/hajimi/blob/main/wiki/img/create_space.png)
-- 如图所示，选择upload files<br>![files](https://github.com/wyeeeee/hajimi/blob/main/wiki/img/files.png)
-- 如图所示，将1.1下载并解压的文件全部拖入，上传完成后点击Commit changes to main<br>![upload_files](https://github.com/wyeeeee/hajimi/blob/main/wiki/img/upload_files.png)
+- 注册完成后，进入[spaces](https://huggingface.co/spaces)如图所示，点击new spaces。<br>![spaces](./img/spaces.png)
+- 如图所示，填入创建选项，注意space name不要使用符号，填写完成后，点击create space<br>![create_space](./img/create_space.png)
+- 如图所示，选择upload files<br>![files](./img/files.png)
+- 如图所示，将1.1下载并解压的文件全部拖入，上传完成后点击Commit changes to main<br>![upload_files](./img/upload_files.png)
 
 ### 1.2 配置环境变量
-- 如图所示，进入settings界面<br>![settings](https://github.com/wyeeeee/hajimi/blob/main/wiki/img/settings.png)
-- 如图所示，在settings界面中找到Variables and secrets，点击new secrets<br>![secrets](https://github.com/wyeeeee/hajimi/blob/main/wiki/img/secrets.png)
-- 添加环境变量，如图所示为添加GEMINI_API_KEYS环境变量，在value中填入具体apikey<br>![KEYS](https://github.com/wyeeeee/hajimi/blob/main/wiki/img/KEYS.png)
-- 等待项目部署完成，app界面显示如图界面，即完成<br>![app](https://github.com/wyeeeee/hajimi/blob/main/wiki/img/app.png)
+- 如图所示，进入settings界面<br>![settings](./img/settings.png)
+- 如图所示，在settings界面中找到Variables and secrets，点击new secrets<br>![secrets](./img/secrets.png)
+- 添加环境变量，如图所示为添加GEMINI_API_KEYS环境变量，在value中填入具体apikey<br>![KEYS](./img/KEYS.png)
+- 等待项目部署完成，app界面显示如图界面，即完成<br>![app](./img/app.png)
 
 ### 1.3 环境变量说明
 #### 重要环境变量
@@ -28,7 +28,8 @@
 -   `FAKE_STREAMING`：（可选）是否启用假流式传输，默认为true。
 -   `API_KEY_DAILY_LIMIT`: 单api 24小时最大使用次数，默认值为25
 -   `BLOCKED_MODELS`，（可选）需要屏蔽的模型名称，多个模型用英文逗号分隔
-
+-   `RANDOM_STRING`，是否启用伪装信息，默认值为true
+-   `RANDOM_STRING_LENGTH`，伪装信息长度，默认为20
 ### 1.4 在酒馆中使用
 在酒馆api连接配置中，选择兼容openai格式，URL格式为`https://(huggingface用户名)-(huggingface项目名).hf.space/v1`（注意为https）。自定义 API 密钥为1.3中配置的`PASSWORD`。
 
@@ -47,7 +48,15 @@
 2.  设置环境变量（如上所述）。
 3.  运行：`uvicorn app.main:app --reload --host 0.0.0.0 --port 7860`
 
-### 🔌 接入其他服务
+### 1.8 💻 手机本地运行（可选,安装耗时长）：
+
+[Termux 安装与配置 Hajimi 项目教程 由**天命不又**编写](./Termux.md)
+
+### 1.9 💻 docker部署运行：
+
+[docker 安装与配置 Hajimi 项目教程 由 **北极星星** 编写](./docker.md)
+
+### 1.10 🔌 接入其他服务
 
 1.  在连接中选择OpenAI
 2.  在API Base URL中填入`https://(huggingface用户名)-(huggingface项目名).hf.space/v1`