Delete hajimi.v0.0.3

hajimi.v0.0.3/Dockerfile

@@ -1,14 +0,0 @@
-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"]

hajimi.v0.0.3/app/gemini.py

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

hajimi.v0.0.3/app/index.html

@@ -1,306 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Gemini API 代理服务</title>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <style>
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
-            max-width: 1200px;
-            margin: 0 auto;
-            padding: 20px;
-            line-height: 1.6;
-            background-color: #f8f9fa;
-        }
-        h1, h2, h3 {
-            color: #333;
-            text-align: center;
-            margin-bottom: 20px;
-        }
-        .info-box {
-            background-color: #fff;
-            border: 1px solid #dee2e6;
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 20px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
-        }
-        .status {
-            color: #28a745;
-            font-weight: bold;
-            font-size: 18px;
-            margin-bottom: 20px;
-            text-align: center;
-        }
-        .stats-grid {
-            display: grid;
-            grid-template-columns: repeat(3, 1fr);
-            gap: 15px;
-            margin-top: 15px;
-            margin-bottom: 20px;
-        }
-        .stat-card {
-            background-color: #e9ecef;
-            padding: 15px;
-            border-radius: 8px;
-            text-align: center;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
-            transition: transform 0.2s;
-        }
-        .stat-card:hover {
-            transform: translateY(-2px);
-            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
-        }
-        .stat-value {
-            font-size: 24px;
-            font-weight: bold;
-            color: #007bff;
-        }
-        .stat-label {
-            font-size: 14px;
-            color: #6c757d;
-            margin-top: 5px;
-        }
-        .section-title {
-            color: #495057;
-            border-bottom: 1px solid #dee2e6;
-            padding-bottom: 10px;
-            margin-bottom: 20px;
-        }
-        .log-container {
-            background-color: #f5f5f5;
-            border: 1px solid #ddd;
-            border-radius: 8px;
-            padding: 15px;
-            margin-top: 20px;
-            max-height: 500px;
-            overflow-y: auto;
-            font-family: monospace;
-            font-size: 14px;
-            line-height: 1.5;
-        }
-        .log-entry {
-            margin-bottom: 8px;
-            padding: 8px;
-            border-radius: 4px;
-        }
-        .log-entry.INFO {
-            background-color: #e8f4f8;
-            border-left: 4px solid #17a2b8;
-        }
-        .log-entry.WARNING {
-            background-color: #fff3cd;
-            border-left: 4px solid #ffc107;
-        }
-        .log-entry.ERROR {
-            background-color: #f8d7da;
-            border-left: 4px solid #dc3545;
-        }
-        .log-entry.DEBUG {
-            background-color: #d1ecf1;
-            border-left: 4px solid #17a2b8;
-        }
-        .log-timestamp {
-            color: #6c757d;
-            font-size: 12px;
-            margin-right: 10px;
-        }
-        .log-level {
-            font-weight: bold;
-            margin-right: 10px;
-        }
-        .log-level.INFO {
-            color: #17a2b8;
-        }
-        .log-level.WARNING {
-            color: #ffc107;
-        }
-        .log-level.ERROR {
-            color: #dc3545;
-        }
-        .log-level.DEBUG {
-            color: #17a2b8;
-        }
-        .log-message {
-            color: #212529;
-        }
-        .refresh-button {
-            display: block;
-            margin: 20px auto;
-            padding: 10px 20px;
-            background-color: #007bff;
-            color: white;
-            border: none;
-            border-radius: 4px;
-            font-size: 16px;
-            cursor: pointer;
-            transition: background-color 0.2s;
-        }
-        .refresh-button:hover {
-            background-color: #0069d9;
-        }
-        .log-filter {
-            display: flex;
-            justify-content: center;
-            margin-bottom: 15px;
-            gap: 10px;
-        }
-        .log-filter button {
-            padding: 5px 10px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-            background-color: #f8f9fa;
-            cursor: pointer;
-        }
-        .log-filter button.active {
-            background-color: #007bff;
-            color: white;
-            border-color: #007bff;
-        }
-    </style>
-</head>
-<body>
-    <h1>🤖 Gemini API 代理服务</h1>
-    
-    <div class="info-box">
-        <h2 class="section-title">🟢 运行状态</h2>
-        <p class="status">服务运行中</p>
-        
-        <div class="stats-grid">
-            <div class="stat-card">
-                <div class="stat-value">{{ key_count }}</div>
-                <div class="stat-label">可用API密钥数量</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-value">{{ model_count }}</div>
-                <div class="stat-label">可用模型数量</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-value">{{ retry_count }}</div>
-                <div class="stat-label">最大重试次数</div>
-            </div>
-        </div>
-        
-        <h3 class="section-title">API调用统计</h3>
-        <div class="stats-grid">
-            <div class="stat-card">
-                <div class="stat-value">{{ last_24h_calls }}</div>
-                <div class="stat-label">24小时内调用次数</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-value">{{ hourly_calls }}</div>
-                <div class="stat-label">一小时内调用次数</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-value">{{ minute_calls }}</div>
-                <div class="stat-label">一分钟内调用次数</div>
-            </div>
-        </div>
-    </div>
-
-    <div class="info-box">
-        <h2 class="section-title">⚙️ 环境配置</h2>
-        <div class="stats-grid">
-            <div class="stat-card">
-                <div class="stat-value">{{ max_requests_per_minute }}</div>
-                <div class="stat-label">每分钟请求限制</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-value">{{ max_requests_per_day_per_ip }}</div>
-                <div class="stat-label">每IP每日请求限制</div>
-            </div>
-            <div class="stat-card">
-                <div class="stat-value">{{ current_time }}</div>
-                <div class="stat-label">当前服务器时间</div>
-            </div>
-        </div>
-    </div>
-
-    <div class="info-box">
-        <h2 class="section-title">📦 版本信息</h2>
-        <div class="version-info" style="text-align: center; margin-bottom: 15px;">
-            <div style="font-size: 18px; margin-bottom: 10px;">
-                当前版本: <span style="font-weight: bold; color: #007bff;">{{ local_version }}</span>
-            </div>
-            {% if has_update %}
-            <div style="display: flex; align-items: center; justify-content: center; margin-top: 15px;">
-                <div style="background-color: #fef6e0; border: 1px solid #ffeeba; border-radius: 4px; padding: 10px 15px; display: inline-flex; align-items: center;">
-                    <span style="color: #ff9800; margin-right: 10px;">
-                        <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                            <circle cx="12" cy="12" r="10"></circle>
-                            <line x1="12" y1="8" x2="12" y2="12"></line>
-                            <line x1="12" y1="16" x2="12.01" y2="16"></line>
-                        </svg>
-                    </span>
-                    <span>
-                        <strong>发现新版本!</strong> 最新版本: <span style="font-weight: bold; color: #28a745;">{{ remote_version }}</span>
-                    </span>
-                </div>
-            </div>
-            {% endif %}
-        </div>
-    </div>
-
-    <div class="info-box">
-        <h2 class="section-title"> 系统日志</h2>
-        <div class="log-filter">
-            <button class="active" data-level="ALL">全部</button>
-            <button data-level="INFO">信息</button>
-            <button data-level="WARNING">警告</button>
-            <button data-level="ERROR">错误</button>
-        </div>
-        <div class="log-container">
-            {% for log in logs %}
-            <div class="log-entry {{ log.level }}" data-level="{{ log.level }}">
-                <span class="log-timestamp">{{ log.timestamp }}</span>
-                <span class="log-level {{ log.level }}">{{ log.level }}</span>
-                <span class="log-message">
-                    {% if log.key != 'N/A' %}[{{ log.key }}]{% endif %}
-                    {% if log.request_type != 'N/A' %}{{ log.request_type }}{% endif %}
-                    {% if log.model != 'N/A' %}[{{ log.model }}]{% endif %}
-                    {% if log.status_code != 'N/A' %}{{ log.status_code }}{% endif %}
-                    : {{ log.message }}
-                    {% if log.error_message %}
-                    - {{ log.error_message }}
-                    {% endif %}
-                </span>
-            </div>
-            {% endfor %}
-        </div>
-        <button class="refresh-button" onclick="window.location.reload()">刷新日志</button>
-    </div>
-
-    <script>
-        // 日志过滤功能
-        document.querySelectorAll('.log-filter button').forEach(button => {
-            button.addEventListener('click', function() {
-                // 移除所有按钮的active类
-                document.querySelectorAll('.log-filter button').forEach(btn => {
-                    btn.classList.remove('active');
-                });
-                
-                // 为当前按钮添加active类
-                this.classList.add('active');
-                
-                const level = this.getAttribute('data-level');
-                
-                // 显示或隐藏日志条目
-                document.querySelectorAll('.log-entry').forEach(entry => {
-                    if (level === 'ALL' || entry.getAttribute('data-level') === level) {
-                        entry.style.display = 'block';
-                    } else {
-                        entry.style.display = 'none';
-                    }
-                });
-            });
-        });
-        
-        // 页面加载时自动滚动到日志底部
-        window.onload = function() {
-            const logContainer = document.querySelector('.log-container');
-            logContainer.scrollTop = logContainer.scrollHeight;
-        };
-    </script>
-</body>
-</html>

hajimi.v0.0.3/app/main.py

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

hajimi.v0.0.3/app/models.py

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

hajimi.v0.0.3/app/utils.py

@@ -1,275 +0,0 @@
-import random
-from fastapi import HTTPException, Request
-import time
-import re
-from datetime import datetime, timedelta
-from apscheduler.schedulers.background import BackgroundScheduler
-import os
-import requests
-import httpx
-from threading import Lock
-import logging
-import sys
-from collections import deque
-
-DEBUG = os.environ.get("DEBUG", "false").lower() == "true"
-LOG_FORMAT_DEBUG = '%(asctime)s - %(levelname)s - [%(key)s]-%(request_type)s-[%(model)s]-%(status_code)s: %(message)s - %(error_message)s'
-LOG_FORMAT_NORMAL = '[%(asctime)s] [%(levelname)s] [%(key)s]-%(request_type)s-[%(model)s]-%(status_code)s: %(message)s'
-
-# 配置 logger
-logger = logging.getLogger("my_logger")
-logger.setLevel(logging.DEBUG)
-
-# 控制台处理器
-console_handler = logging.StreamHandler()
-console_formatter = logging.Formatter('%(message)s')
-console_handler.setFormatter(console_formatter)
-logger.addHandler(console_handler)
-
-# 日志缓存，用于在网页上显示最近的日志
-class LogManager:
-    def __init__(self, max_logs=100):
-        self.logs = deque(maxlen=max_logs)  # 使用双端队列存储最近的日志
-        self.lock = Lock()
-    
-    def add_log(self, log_entry):
-        with self.lock:
-            self.logs.append(log_entry)
-    
-    def get_recent_logs(self, count=50):
-        with self.lock:
-            return list(self.logs)[-count:]
-
-# 创建日志管理器实例
-log_manager = LogManager()
-
-def format_log_message(level, message, extra=None):
-    extra = extra or {}
-    log_values = {
-        'asctime': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        'levelname': level,
-        'key': extra.get('key', 'N/A'),
-        'request_type': extra.get('request_type', 'N/A'),
-        'model': extra.get('model', 'N/A'),
-        'status_code': extra.get('status_code', 'N/A'),
-        'error_message': extra.get('error_message', ''),
-        'message': message
-    }
-    log_format = LOG_FORMAT_DEBUG if DEBUG else LOG_FORMAT_NORMAL
-    formatted_log = log_format % log_values
-    
-    # 将格式化后的日志添加到日志管理器
-    log_entry = {
-        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        'level': level,
-        'key': extra.get('key', 'N/A'),
-        'request_type': extra.get('request_type', 'N/A'),
-        'model': extra.get('model', 'N/A'),
-        'status_code': extra.get('status_code', 'N/A'),
-        'message': message,
-        'error_message': extra.get('error_message', ''),
-        'formatted': formatted_log
-    }
-    log_manager.add_log(log_entry)
-    
-    return formatted_log
-
-
-class APIKeyManager:
-    def __init__(self):
-        self.api_keys = re.findall(
-            r"AIzaSy[a-zA-Z0-9_-]{33}", os.environ.get('GEMINI_API_KEYS', ""))
-        self.key_stack = [] # 初始化密钥栈
-        self._reset_key_stack() # 初始化时创建随机密钥栈
-        # self.api_key_blacklist = set()
-        # self.api_key_blacklist_duration = 60
-        self.scheduler = BackgroundScheduler()
-        self.scheduler.start()
-        self.tried_keys_for_request = set()  # 用于跟踪当前请求尝试中已试过的 key
-
-    def _reset_key_stack(self):
-        """创建并随机化密钥栈"""
-        shuffled_keys = self.api_keys[:]  # 创建 api_keys 的副本以避免直接修改原列表
-        random.shuffle(shuffled_keys)
-        self.key_stack = shuffled_keys
-
-
-    def get_available_key(self):
-        """从栈顶获取密钥，栈空时重新生成 (修改后)"""
-        while self.key_stack:
-            key = self.key_stack.pop()
-            # if key not in self.api_key_blacklist and key not in self.tried_keys_for_request:
-            if key not in self.tried_keys_for_request:
-                self.tried_keys_for_request.add(key)
-                return key
-
-        if not self.api_keys:
-            log_msg = format_log_message('ERROR', "没有配置任何 API 密钥！")
-            logger.error(log_msg)
-            return None
-
-        self._reset_key_stack() # 重新生成密钥栈
-
-        # 再次尝试从新栈中获取密钥 (迭代一次)
-        while self.key_stack:
-            key = self.key_stack.pop()
-            # if key not in self.api_key_blacklist and key not in self.tried_keys_for_request:
-            if key not in self.tried_keys_for_request:
-                self.tried_keys_for_request.add(key)
-                return key
-
-        return None
-
-
-    def show_all_keys(self):
-        log_msg = format_log_message('INFO', f"当前可用API key个数: {len(self.api_keys)} ")
-        logger.info(log_msg)
-        for i, api_key in enumerate(self.api_keys):
-            log_msg = format_log_message('INFO', f"API Key{i}: {api_key[:8]}...{api_key[-3:]}")
-            logger.info(log_msg)
-
-    # def blacklist_key(self, key):
-    #     log_msg = format_log_message('WARNING', f"{key[:8]} → 暂时禁用 {self.api_key_blacklist_duration} 秒")
-    #     logger.warning(log_msg)
-    #     self.api_key_blacklist.add(key)
-    #     self.scheduler.add_job(lambda: self.api_key_blacklist.discard(key), 'date',
-    #                            run_date=datetime.now() + timedelta(seconds=self.api_key_blacklist_duration))
-
-    def reset_tried_keys_for_request(self):
-        """在新的请求尝试时重置已尝试的 key 集合"""
-        self.tried_keys_for_request = set()
-
-
-def handle_gemini_error(error, current_api_key, key_manager) -> str:
-    if isinstance(error, requests.exceptions.HTTPError):
-        status_code = error.response.status_code
-        if status_code == 400:
-            try:
-                error_data = error.response.json()
-                if 'error' in error_data:
-                    if error_data['error'].get('code') == "invalid_argument":
-                        error_message = "无效的 API 密钥"
-                        extra_log_invalid_key = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
-                        log_msg = format_log_message('ERROR', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 无效，可能已过期或被删除", extra=extra_log_invalid_key)
-                        logger.error(log_msg)
-                        # key_manager.blacklist_key(current_api_key)
-                        
-                        return error_message
-                    error_message = error_data['error'].get(
-                        'message', 'Bad Request')
-                    extra_log_400 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
-                    log_msg = format_log_message('WARNING', f"400 错误请求: {error_message}", extra=extra_log_400)
-                    logger.warning(log_msg)
-                    return f"400 错误请求: {error_message}"
-            except ValueError:
-                error_message = "400 错误请求：响应不是有效的JSON格式"
-                extra_log_400_json = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
-                log_msg = format_log_message('WARNING', error_message, extra=extra_log_400_json)
-                logger.warning(log_msg)
-                return error_message
-
-        elif status_code == 429:
-            error_message = "API 密钥配额已用尽或其他原因"
-            extra_log_429 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
-            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 429 官方资源耗尽或其他原因", extra=extra_log_429)
-            logger.warning(log_msg)
-            # key_manager.blacklist_key(current_api_key)
-             
-            return error_message
-
-        elif status_code == 403:
-            error_message = "权限被拒绝"
-            extra_log_403 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
-            log_msg = format_log_message('ERROR', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 403 权限被拒绝", extra=extra_log_403)
-            logger.error(log_msg)
-            # key_manager.blacklist_key(current_api_key)
-            
-            return error_message
-        elif status_code == 500:
-            error_message = "服务器内部错误"
-            extra_log_500 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
-            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 500 服务器内部错误", extra=extra_log_500)
-            logger.warning(log_msg)
-            
-            return "Gemini API 内部错误"
-
-        elif status_code == 503:
-            error_message = "服务不可用"
-            extra_log_503 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
-            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 503 服务不可用", extra=extra_log_503)
-            logger.warning(log_msg)
-            
-            return "Gemini API 服务不可用"
-        else:
-            error_message = f"未知错误: {status_code}"
-            extra_log_other = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
-            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → {status_code} 未知错误", extra=extra_log_other)
-            logger.warning(log_msg)
-            
-            return f"未知错误/模型不可用: {status_code}"
-
-    elif isinstance(error, requests.exceptions.ConnectionError):
-        error_message = "连接错误"
-        log_msg = format_log_message('WARNING', error_message, extra={'error_message': error_message})
-        logger.warning(log_msg)
-        return error_message
-
-    elif isinstance(error, requests.exceptions.Timeout):
-        error_message = "请求超时"
-        log_msg = format_log_message('WARNING', error_message, extra={'error_message': error_message})
-        logger.warning(log_msg)
-        return error_message
-    else:
-        error_message = f"发生未知错误: {error}"
-        log_msg = format_log_message('ERROR', error_message, extra={'error_message': error_message})
-        logger.error(log_msg)
-        return error_message
-
-
-async def test_api_key(api_key: str) -> bool:
-    """
-    测试 API 密钥是否有效。
-    """
-    try:
-        url = "https://generativelanguage.googleapis.com/v1beta/models?key={}".format(api_key)
-        async with httpx.AsyncClient() as client:
-            response = await client.get(url)
-            response.raise_for_status()
-            return True
-    except Exception:
-        return False
-
-
-rate_limit_data = {}
-rate_limit_lock = Lock()
-
-
-def protect_from_abuse(request: Request, max_requests_per_minute: int = 30, max_requests_per_day_per_ip: int = 600):
-    now = int(time.time())
-    minute = now // 60
-    day = now // (60 * 60 * 24)
-
-    minute_key = f"{request.url.path}:{minute}"
-    day_key = f"{request.client.host}:{day}"
-
-    with rate_limit_lock:
-        minute_count, minute_timestamp = rate_limit_data.get(
-            minute_key, (0, now))
-        if now - minute_timestamp >= 60:
-            minute_count = 0
-            minute_timestamp = now
-        minute_count += 1
-        rate_limit_data[minute_key] = (minute_count, minute_timestamp)
-
-        day_count, day_timestamp = rate_limit_data.get(day_key, (0, now))
-        if now - day_timestamp >= 86400:
-            day_count = 0
-            day_timestamp = now
-        day_count += 1
-        rate_limit_data[day_key] = (day_count, day_timestamp)
-
-    if minute_count > max_requests_per_minute:
-        raise HTTPException(status_code=429, detail={
-            "message": "Too many requests per minute", "limit": max_requests_per_minute})
-    if day_count > max_requests_per_day_per_ip:
-        raise HTTPException(status_code=429, detail={"message": "Too many requests per day from this IP", "limit": max_requests_per_day_per_ip})

hajimi.v0.0.3/requirements.txt

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

hajimi.v0.0.3/version.txt

@@ -1 +0,0 @@
-version=0.0.3