Upload 22 files

src/anti_truncation.py

@@ -0,0 +1,589 @@
+"""
+Anti-Truncation Module - Ensures complete streaming output
+保持一个流式请求内完整输出的反截断模块
+"""
+import json
+import re
+from typing import Dict, Any, AsyncGenerator, List, Tuple
+
+from fastapi.responses import StreamingResponse
+
+from log import log
+
+# 反截断配置
+DONE_MARKER = "[done]"
+MAX_CONTINUATION_ATTEMPTS = 3
+CONTINUATION_PROMPT = f"""请从刚才被截断的地方继续输出剩余的所有内容。
+
+重要提醒：
+1. 不要重复前面已经输出的内容
+2. 直接继续输出，无需任何前言或解释
+3. 当你完整完成所有内容输出后，必须在最后一行单独输出：{DONE_MARKER}
+4. {DONE_MARKER} 标记表示你的回答已经完全结束，这是必需的结束标记
+
+现在请继续输出："""
+
+# 正则替换配置
+REGEX_REPLACEMENTS: List[Tuple[str, str, str]] = [
+    (
+        "age_pattern",  # 替换规则名称
+        r"(?:[1-9]|1[0-8])岁(?:的)?|(?:十一|十二|十三|十四|十五|十六|十七|十八|十|一|二|三|四|五|六|七|八|九)岁(?:的)?",  # 正则模式
+        ""  # 替换文本
+    ),
+    # 可在此处添加更多替换规则
+    # ("rule_name", r"pattern", "replacement"),
+]
+
+def apply_regex_replacements(text: str) -> str:
+    """
+    对文本应用正则替换规则
+    
+    Args:
+        text: 要处理的文本
+        
+    Returns:
+        处理后的文本
+    """
+    if not text:
+        return text
+    
+    processed_text = text
+    replacement_count = 0
+    
+    for rule_name, pattern, replacement in REGEX_REPLACEMENTS:
+        try:
+            # 编译正则表达式，使用IGNORECASE标志
+            regex = re.compile(pattern, re.IGNORECASE)
+            
+            # 执行替换
+            new_text, count = regex.subn(replacement, processed_text)
+            
+            if count > 0:
+                log.debug(f"Regex replacement '{rule_name}': {count} matches replaced")
+                processed_text = new_text
+                replacement_count += count
+                
+        except re.error as e:
+            log.error(f"Invalid regex pattern in rule '{rule_name}': {e}")
+            continue
+    
+    if replacement_count > 0:
+        log.info(f"Applied {replacement_count} regex replacements to text")
+    
+    return processed_text
+
+def apply_regex_replacements_to_payload(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    对请求payload中的文本内容应用正则替换
+    
+    Args:
+        payload: 请求payload
+        
+    Returns:
+        应用替换后的payload
+    """
+    if not REGEX_REPLACEMENTS:
+        return payload
+    
+    modified_payload = payload.copy()
+    request_data = modified_payload.get("request", {})
+    
+    # 处理contents中的文本
+    contents = request_data.get("contents", [])
+    if contents:
+        new_contents = []
+        for content in contents:
+            if isinstance(content, dict):
+                new_content = content.copy()
+                parts = new_content.get("parts", [])
+                if parts:
+                    new_parts = []
+                    for part in parts:
+                        if isinstance(part, dict) and "text" in part:
+                            new_part = part.copy()
+                            new_part["text"] = apply_regex_replacements(part["text"])
+                            new_parts.append(new_part)
+                        else:
+                            new_parts.append(part)
+                    new_content["parts"] = new_parts
+                new_contents.append(new_content)
+            else:
+                new_contents.append(content)
+        
+        request_data["contents"] = new_contents
+        modified_payload["request"] = request_data
+        log.debug("Applied regex replacements to request contents")
+    
+    return modified_payload
+
+def apply_anti_truncation(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    对请求payload应用反截断处理和正则替换
+    在systemInstruction中添加提醒，要求模型在结束时输出DONE_MARKER标记
+    
+    Args:
+        payload: 原始请求payload
+        
+    Returns:
+        添加了反截断指令并应用了正则替换的payload
+    """
+    # 首先应用正则替换
+    modified_payload = apply_regex_replacements_to_payload(payload)
+    request_data = modified_payload.get("request", {})
+    
+    # 获取或创建systemInstruction
+    system_instruction = request_data.get("systemInstruction", {})
+    if not system_instruction:
+        system_instruction = {"parts": []}
+    elif "parts" not in system_instruction:
+        system_instruction["parts"] = []
+    
+    # 添加反截断指令
+    anti_truncation_instruction = {
+        "text": f"""严格执行以下输出结束规则：
+
+1. 当你完成完整回答时，必须在输出的最后单独一行输出：{DONE_MARKER}
+2. {DONE_MARKER} 标记表示你的回答已经完全结束，这是必需的结束标记
+3. 只有输出了 {DONE_MARKER} 标记，系统才认为你的回答是完整的
+4. 如果你的回答被截断，系统会要求你继续输出剩余内容
+5. 无论回答长短，都必须以 {DONE_MARKER} 标记结束
+
+示例格式：
+```
+你的回答内容...
+更多回答内容...
+{DONE_MARKER}
+```
+
+注意：{DONE_MARKER} 必须单独占一行，前面不要有任何其他字符。
+
+这个规则对于确保输出完整性极其重要，请严格遵守。"""
+    }
+    
+    # 检查是否已经包含反截断指令
+    has_done_instruction = any(
+        part.get("text", "").find(DONE_MARKER) != -1 
+        for part in system_instruction["parts"] 
+        if isinstance(part, dict)
+    )
+    
+    if not has_done_instruction:
+        system_instruction["parts"].append(anti_truncation_instruction)
+        request_data["systemInstruction"] = system_instruction
+        modified_payload["request"] = request_data
+        
+        log.debug("Applied anti-truncation instruction to request")
+    
+    return modified_payload
+
+class AntiTruncationStreamProcessor:
+    """反截断流式处理器"""
+    
+    def __init__(self, 
+                 original_request_func,
+                 payload: Dict[str, Any],
+                 max_attempts: int = MAX_CONTINUATION_ATTEMPTS):
+        self.original_request_func = original_request_func
+        self.base_payload = payload.copy()
+        self.max_attempts = max_attempts
+        self.collected_content = []  # 使用列表避免字符串重复拼接
+        self.current_attempt = 0
+        
+    async def process_stream(self) -> AsyncGenerator[bytes, None]:
+        """处理流式响应，检测并处理截断"""
+        
+        while self.current_attempt < self.max_attempts:
+            self.current_attempt += 1
+            
+            # 构建当前请求payload
+            current_payload = self._build_current_payload()
+            
+            log.debug(f"Anti-truncation attempt {self.current_attempt}/{self.max_attempts}")
+            
+            # 发送请求
+            try:
+                response = await self.original_request_func(current_payload)
+                
+                if not isinstance(response, StreamingResponse):
+                    # 非流式响应，直接处理
+                    yield await self._handle_non_streaming_response(response)
+                    return
+                
+                # 处理流式响应
+                chunk_content = ""
+                found_done_marker = False
+                
+                async for chunk in response.body_iterator:
+                    if not chunk:
+                        yield chunk
+                        continue
+                    
+                    # 处理不同数据类型的startswith问题
+                    if isinstance(chunk, bytes):
+                        if not chunk.startswith(b'data: '):
+                            yield chunk
+                            continue
+                        payload_data = chunk[len(b'data: '):]
+                    else:
+                        chunk_str = str(chunk)
+                        if not chunk_str.startswith('data: '):
+                            yield chunk
+                            continue
+                        payload_data = chunk_str[len('data: '):].encode()
+                    
+                    # 解析chunk内容
+                    
+                    if payload_data.strip() == b'[DONE]':
+                        # 检查是否找到了done标记
+                        if found_done_marker:
+                            log.info("Anti-truncation: Found [done] marker, output complete")
+                            yield chunk
+                            return
+                        else:
+                            log.warning("Anti-truncation: Stream ended without [done] marker")
+                            # 不发送[DONE]，准备继续
+                            break
+                    
+                    try:
+                        data = json.loads(payload_data.decode())
+                        content = self._extract_content_from_chunk(data)
+                        
+                        if content:
+                            chunk_content += content
+                            
+                            # 检查是否包含done标记
+                            if self._check_done_marker_in_chunk_content(content):
+                                found_done_marker = True
+                                log.info("Anti-truncation: Found [done] marker in chunk")
+                        
+                        # 清理chunk中的[done]标记后再发送
+                        cleaned_chunk = self._remove_done_marker_from_chunk(chunk, data)
+                        yield cleaned_chunk
+                        
+                    except (json.JSONDecodeError, UnicodeDecodeError):
+                        yield chunk
+                        continue
+                
+                # 更新收集的内容 - 使用列表避免字符串重复拼接
+                if chunk_content:
+                    self.collected_content.append(chunk_content)
+                
+                # 如果找到了done标记，结束
+                if found_done_marker:
+                    # 立即清理内容释放内存
+                    self.collected_content.clear()
+                    yield b'data: [DONE]\n\n'
+                    return
+                
+                # 只有在单个chunk中没有找到done标记时，才检查累积内容（防止done标记跨chunk出现）
+                if not found_done_marker:
+                    accumulated_text = ''.join(self.collected_content) if self.collected_content else ""
+                    if self._check_done_marker_in_text(accumulated_text):
+                        log.info("Anti-truncation: Found [done] marker in accumulated content")
+                        # 立即清理内容释放内存
+                        self.collected_content.clear()
+                        yield b'data: [DONE]\n\n'
+                        return
+                
+                # 如果没找到done标记且不是最后一次尝试，准备续传
+                if self.current_attempt < self.max_attempts:
+                    total_length = sum(len(chunk) for chunk in self.collected_content) if self.collected_content else 0
+                    log.info(f"Anti-truncation: No [done] marker found in output (length: {total_length}), preparing continuation (attempt {self.current_attempt + 1})")
+                    if self.collected_content and total_length > 100:
+                        last_chunk = self.collected_content[-1] if self.collected_content else ""
+                        log.debug(f"Anti-truncation: Current collected content ends with: {'...' + last_chunk[-100:]}")
+                    # 在下一次循环中会继续
+                    continue
+                else:
+                    # 最后一次尝试，直接结束
+                    log.warning("Anti-truncation: Max attempts reached, ending stream")
+                    # 立即清理内容释放内存
+                    self.collected_content.clear()
+                    yield b'data: [DONE]\n\n'
+                    return
+                
+            except Exception as e:
+                log.error(f"Anti-truncation error in attempt {self.current_attempt}: {str(e)}")
+                if self.current_attempt >= self.max_attempts:
+                    # 发送错误chunk
+                    error_chunk = {
+                        "error": {
+                            "message": f"Anti-truncation failed: {str(e)}",
+                            "type": "api_error",
+                            "code": 500
+                        }
+                    }
+                    yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+                    yield b'data: [DONE]\n\n'
+                    return
+                # 否则继续下一次尝试
+                
+        # 如果所有尝试都失败了
+        log.error("Anti-truncation: All attempts failed")
+        # 确保清理内容释放内存
+        self.collected_content.clear()
+        yield b'data: [DONE]\n\n'
+    
+    def _build_current_payload(self) -> Dict[str, Any]:
+        """构建当前请求的payload"""
+        if self.current_attempt == 1:
+            # 第一次请求，使用原始payload（已经包含反截断指令）
+            return self.base_payload
+        
+        # 后续请求，添加续传指令
+        continuation_payload = self.base_payload.copy()
+        request_data = continuation_payload.get("request", {})
+        
+        # 获取原始对话内容
+        contents = request_data.get("contents", [])
+        new_contents = contents.copy()
+        
+        # 如果有收集到的内容，添加到对话中
+        if self.collected_content:
+            # 拼接收集的内容并添加模型的回复
+            accumulated_text = ''.join(self.collected_content)
+            new_contents.append({
+                "role": "model",
+                "parts": [{"text": accumulated_text}]
+            })
+        
+        # 构建具体的续写指令，包含前面的内容摘要
+        content_summary = ""
+        if self.collected_content:
+            accumulated_text = ''.join(self.collected_content)
+            if len(accumulated_text) > 200:
+                content_summary = f"\n\n前面你已经输出了约 {len(accumulated_text)} 个字符的内容，结尾是：\n\"...{accumulated_text[-100:]}\""
+            else:
+                content_summary = f"\n\n前面你已经输出的内容是：\n\"{accumulated_text}\""
+        
+        detailed_continuation_prompt = f"""{CONTINUATION_PROMPT}{content_summary}"""
+        
+        # 添加继续指令
+        continuation_message = {
+            "role": "user", 
+            "parts": [{"text": detailed_continuation_prompt}]
+        }
+        new_contents.append(continuation_message)
+        
+        request_data["contents"] = new_contents
+        continuation_payload["request"] = request_data
+        
+        return continuation_payload
+    
+    def _extract_content_from_chunk(self, data: Dict[str, Any]) -> str:
+        """从chunk数据中提取文本内容"""
+        content = ""
+        
+        # 处理Gemini格式
+        if "candidates" in data:
+            for candidate in data["candidates"]:
+                if "content" in candidate:
+                    parts = candidate["content"].get("parts", [])
+                    for part in parts:
+                        if "text" in part:
+                            content += part["text"]
+        
+        # 处理OpenAI格式
+        elif "choices" in data:
+            for choice in data["choices"]:
+                if "delta" in choice and "content" in choice["delta"]:
+                    content += choice["delta"]["content"]
+                elif "message" in choice and "content" in choice["message"]:
+                    content += choice["message"]["content"]
+        
+        return content
+    
+    async def _handle_non_streaming_response(self, response) -> bytes:
+        """处理非流式响应"""
+        try:
+            if hasattr(response, 'body'):
+                content = response.body.decode() if isinstance(response.body, bytes) else response.body
+            elif hasattr(response, 'content'):
+                content = response.content.decode() if isinstance(response.content, bytes) else response.content
+            else:
+                content = str(response)
+            
+            response_data = json.loads(content)
+            
+            # 检查是否包含done标记
+            text_content = self._extract_content_from_response(response_data)
+            has_done_marker = self._check_done_marker_in_text(text_content)
+            
+            if not has_done_marker and self.current_attempt < self.max_attempts:
+                log.info("Anti-truncation: Non-streaming response needs continuation")
+                if text_content:
+                    self.collected_content.append(text_content)
+                # 递归处理续传
+                return await self._handle_non_streaming_response(
+                    await self.original_request_func(self._build_current_payload())
+                )
+            
+            return content.encode()
+            
+        except Exception as e:
+            log.error(f"Anti-truncation non-streaming error: {str(e)}")
+            return json.dumps({
+                "error": {
+                    "message": f"Anti-truncation failed: {str(e)}",
+                    "type": "api_error",
+                    "code": 500
+                }
+            }).encode()
+    
+    def _check_done_marker_in_text(self, text: str) -> bool:
+        """检测文本中是否包含DONE_MARKER（只检测指定标记）"""
+        if not text:
+            return False
+
+        # 只要文本中出现DONE_MARKER即可
+        return DONE_MARKER in text
+    
+    def _check_done_marker_in_chunk_content(self, content: str) -> bool:
+        """检查单个chunk内容中是否包含done标记"""
+        return self._check_done_marker_in_text(content)
+    
+    def _extract_content_from_response(self, data: Dict[str, Any]) -> str:
+        """从响应数据中提取文本内容"""
+        content = ""
+        
+        # 处理Gemini格式
+        if "candidates" in data:
+            for candidate in data["candidates"]:
+                if "content" in candidate:
+                    parts = candidate["content"].get("parts", [])
+                    for part in parts:
+                        if "text" in part:
+                            content += part["text"]
+        
+        # 处理OpenAI格式
+        elif "choices" in data:
+            for choice in data["choices"]:
+                if "message" in choice and "content" in choice["message"]:
+                    content += choice["message"]["content"]
+        
+        return content
+    
+    def _remove_done_marker_from_chunk(self, chunk: bytes, data: Dict[str, Any]) -> bytes:
+        """使用正则表达式从chunk中移除[done]标记"""
+        try:
+            # 首先检查是否真的包含[done]标记，如果没有则直接返回原始chunk
+            chunk_text = chunk.decode('utf-8', errors='ignore') if isinstance(chunk, bytes) else str(chunk)
+            if '[done]' not in chunk_text.lower():
+                return chunk  # 没有[done]标记，直接返回原始chunk
+            
+            # 编译正则表达式，匹配[done]标记（忽略大小写，包括可能的空白字符）
+            done_pattern = re.compile(r'\s*\[done\]\s*', re.IGNORECASE)
+            
+            # 处理Gemini格式
+            if "candidates" in data:
+                modified_data = data.copy()
+                modified_data["candidates"] = []
+                
+                for i, candidate in enumerate(data["candidates"]):
+                    modified_candidate = candidate.copy()
+                    # 只在最后一个candidate中清理[done]标记
+                    is_last_candidate = (i == len(data["candidates"]) - 1)
+                    
+                    if "content" in candidate:
+                        modified_content = candidate["content"].copy()
+                        if "parts" in modified_content:
+                            modified_parts = []
+                            for part in modified_content["parts"]:
+                                if "text" in part and isinstance(part["text"], str):
+                                    modified_part = part.copy()
+                                    # 只在最后一个candidate中清理[done]标记
+                                    if is_last_candidate:
+                                        modified_part["text"] = done_pattern.sub('', part["text"])
+                                    modified_parts.append(modified_part)
+                                else:
+                                    modified_parts.append(part)
+                            modified_content["parts"] = modified_parts
+                        modified_candidate["content"] = modified_content
+                    modified_data["candidates"].append(modified_candidate)
+                
+                # 重新编码为chunk格式，保持原始的换行符
+                if isinstance(chunk, bytes):
+                    prefix = b'data: '
+                    suffix = b'\n\n'  # 确保有正确的换行符
+                    json_data = json.dumps(modified_data, separators=(',',':'), ensure_ascii=False).encode('utf-8')
+                    return prefix + json_data + suffix
+                else:
+                    return f"data: {json.dumps(modified_data, separators=(',',':'), ensure_ascii=False)}\n\n"
+            
+            # 处理OpenAI格式
+            elif "choices" in data:
+                modified_data = data.copy()
+                modified_data["choices"] = []
+                
+                for choice in data["choices"]:
+                    modified_choice = choice.copy()
+                    if "delta" in choice and "content" in choice["delta"]:
+                        modified_delta = choice["delta"].copy()
+                        modified_delta["content"] = done_pattern.sub('', choice["delta"]["content"])
+                        modified_choice["delta"] = modified_delta
+                    elif "message" in choice and "content" in choice["message"]:
+                        modified_message = choice["message"].copy()
+                        modified_message["content"] = done_pattern.sub('', choice["message"]["content"])
+                        modified_choice["message"] = modified_message
+                    modified_data["choices"].append(modified_choice)
+                
+                # 重新编码为chunk格式，保持原始的换行符
+                if isinstance(chunk, bytes):
+                    prefix = b'data: '
+                    suffix = b'\n\n'  # 确保有正确的换行符
+                    json_data = json.dumps(modified_data, separators=(',',':'), ensure_ascii=False).encode('utf-8')
+                    return prefix + json_data + suffix
+                else:
+                    return f"data: {json.dumps(modified_data, separators=(',',':'), ensure_ascii=False)}\n\n"
+            
+            # 如果没有找到支持的格式，返回原始chunk
+            return chunk
+            
+        except Exception as e:
+            log.warning(f"Failed to remove [done] marker from chunk: {str(e)}")
+            return chunk
+
+async def apply_anti_truncation_to_stream(
+    request_func,
+    payload: Dict[str, Any],
+    max_attempts: int = MAX_CONTINUATION_ATTEMPTS
+) -> StreamingResponse:
+    """
+    对流式请求应用反截断处理
+    
+    Args:
+        request_func: 原始请求函数
+        payload: 请求payload
+        max_attempts: 最大续传尝试次数
+        
+    Returns:
+        处理后的StreamingResponse
+    """
+    
+    # 首先对payload应用反截断指令
+    anti_truncation_payload = apply_anti_truncation(payload)
+    
+    # 创建反截断处理器
+    processor = AntiTruncationStreamProcessor(
+        lambda p: request_func(p),
+        anti_truncation_payload,
+        max_attempts
+    )
+    
+    # 返回包装后的流式响应
+    return StreamingResponse(
+        processor.process_stream(),
+        media_type="text/event-stream"
+    )
+
+def is_anti_truncation_enabled(request_data: Dict[str, Any]) -> bool:
+    """
+    检查请求是否启用了反截断功能
+    
+    Args:
+        request_data: 请求数据
+        
+    Returns:
+        是否启用反截断
+    """
+    return request_data.get("enable_anti_truncation", False)

src/auth.py

@@ -0,0 +1,1530 @@
+"""
+认证API模块 - 使用统一存储中间层，完全摆脱文件操作
+"""
+import asyncio
+import json
+import secrets
+import socket
+import threading
+import time
+import uuid
+from datetime import timezone
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Optional, Dict, Any, List
+from urllib.parse import urlparse, parse_qs
+
+from .google_oauth_api import Credentials, Flow, enable_required_apis, get_user_projects, select_default_project
+from .storage_adapter import get_storage_adapter
+from config import get_config_value
+from log import log
+
+# OAuth Configuration
+CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com"
+CLIENT_SECRET = "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"
+SCOPES = [
+    "https://www.googleapis.com/auth/cloud-platform",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile",
+]
+
+# 回调服务器配置
+CALLBACK_HOST = 'localhost'
+
+async def get_callback_port():
+    """获取OAuth回调端口"""
+    return int(await get_config_value('oauth_callback_port', '8080', 'OAUTH_CALLBACK_PORT'))
+
+# 全局状态管理 - 严格限制大小
+auth_flows = {}  # 存储进行中的认证流程
+MAX_AUTH_FLOWS = 20  # 严格限制最大认证流程数
+
+def cleanup_auth_flows_for_memory():
+    """清理认证流程以释放内存"""
+    global auth_flows
+    cleaned = cleanup_expired_flows()
+    # 如果还是太多，强制清理一些旧的流程
+    if len(auth_flows) > 10:
+        # 按创建时间排序，保留最新的10个
+        sorted_flows = sorted(auth_flows.items(), key=lambda x: x[1].get('created_at', 0), reverse=True)
+        new_auth_flows = dict(sorted_flows[:10])
+        
+        # 清理被移除的流程
+        for state, flow_data in auth_flows.items():
+            if state not in new_auth_flows:
+                try:
+                    if flow_data.get('server'):
+                        server = flow_data['server']
+                        port = flow_data.get('callback_port')
+                        async_shutdown_server(server, port)
+                except Exception:
+                    pass
+                flow_data.clear()
+        
+        auth_flows = new_auth_flows
+        log.info(f"强制清理认证流程，保留 {len(auth_flows)} 个最新流程")
+    
+    return len(auth_flows)
+
+
+async def find_available_port(start_port: int = None) -> int:
+    """动态查找可用端口"""
+    if start_port is None:
+        start_port = await get_callback_port()
+    
+    # 首先尝试默认端口
+    for port in range(start_port, start_port + 100):  # 尝试100个端口
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                s.bind(('0.0.0.0', port))
+                log.info(f"找到可用端口: {port}")
+                return port
+        except OSError:
+            continue
+    
+    # 如果都不可用，让系统自动分配端口
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(('0.0.0.0', 0))
+            port = s.getsockname()[1]
+            log.info(f"系统分配可用端口: {port}")
+            return port
+    except OSError as e:
+        log.error(f"无法找到可用端口: {e}")
+        raise RuntimeError("无法找到可用端口")
+
+def create_callback_server(port: int) -> HTTPServer:
+    """创建指定端口的回调服务器，优化快速关闭"""
+    try:
+        # 服务器监听0.0.0.0
+        server = HTTPServer(("0.0.0.0", port), AuthCallbackHandler)
+        
+        # 设置socket选项以支持快速关闭
+        server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        # 设置较短的超时时间
+        server.timeout = 1.0
+        
+        log.info(f"创建OAuth回调服务器，监听端口: {port}")
+        return server
+    except OSError as e:
+        log.error(f"创建端口{port}的服务器失败: {e}")
+        raise
+
+class AuthCallbackHandler(BaseHTTPRequestHandler):
+    """OAuth回调处理器"""
+    def do_GET(self):
+        query_components = parse_qs(urlparse(self.path).query)
+        code = query_components.get("code", [None])[0]
+        state = query_components.get("state", [None])[0]
+        
+        log.info(f"收到OAuth回调: code={'已获取' if code else '未获取'}, state={state}")
+        
+        if code and state and state in auth_flows:
+            # 更新流程状态
+            auth_flows[state]['code'] = code
+            auth_flows[state]['completed'] = True
+            
+            log.info(f"OAuth回调成功处理: state={state}")
+            
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            # 成功页面
+            self.wfile.write(b"<h1>OAuth authentication successful!</h1><p>You can close this window. Please return to the original page and click 'Get Credentials' button.</p>")
+        else:
+            self.send_response(400)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(b"<h1>Authentication failed.</h1><p>Please try again.</p>")
+    
+    def log_message(self, format, *args):
+        # 减少日志噪音
+        pass
+
+
+async def create_auth_url(project_id: Optional[str] = None, user_session: str = None, get_all_projects: bool = False) -> Dict[str, Any]:
+    """创建认证URL，支持动态端口分配"""
+    try:
+        # 动态分配端口
+        callback_port = await find_available_port()
+        callback_url = f"http://{CALLBACK_HOST}:{callback_port}"
+        
+        # 立即启动回调服务器
+        try:
+            callback_server = create_callback_server(callback_port)
+            # 在后台线程中运行服务器
+            server_thread = threading.Thread(
+                target=callback_server.serve_forever, 
+                daemon=True,
+                name=f"OAuth-Server-{callback_port}"
+            )
+            server_thread.start()
+            log.info(f"OAuth回调服务器已启动，端口: {callback_port}")
+        except Exception as e:
+            log.error(f"启动回调服务器失败: {e}")
+            return {
+                'success': False,
+                'error': f'无法启动OAuth回调服务器，端口{callback_port}: {str(e)}'
+            }
+        
+        # 创建OAuth流程
+        client_config = {
+            "installed": {
+                "client_id": CLIENT_ID,
+                "client_secret": CLIENT_SECRET,
+                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+                "token_uri": "https://oauth2.googleapis.com/token",
+            }
+        }
+        
+        flow = Flow(
+            client_id=CLIENT_ID,
+            client_secret=CLIENT_SECRET,
+            scopes=SCOPES,
+            redirect_uri=callback_url
+        )
+        
+        # 生成状态标识符，包含用户会话信息
+        if user_session:
+            state = f"{user_session}_{str(uuid.uuid4())}"
+        else:
+            state = str(uuid.uuid4())
+        
+        # 生成认证URL
+        auth_url = flow.get_auth_url(state=state)
+        
+        # 严格控制认证流程数量 - 超过限制时立即清理最旧的
+        if len(auth_flows) >= MAX_AUTH_FLOWS:
+            # 清理最旧的认证流程
+            oldest_state = min(auth_flows.keys(), 
+                             key=lambda k: auth_flows[k].get('created_at', 0))
+            try:
+                # 清理服务器资源
+                old_flow = auth_flows[oldest_state]
+                if old_flow.get('server'):
+                    server = old_flow['server']
+                    port = old_flow.get('callback_port')
+                    async_shutdown_server(server, port)
+            except Exception as e:
+                log.warning(f"Failed to cleanup old auth flow {oldest_state}: {e}")
+            
+            del auth_flows[oldest_state]
+            log.debug(f"Removed oldest auth flow: {oldest_state}")
+        
+        # 保存流程状态
+        auth_flows[state] = {
+            'flow': flow,
+            'project_id': project_id,  # 可能为None，稍后在回调时确定
+            'user_session': user_session,
+            'callback_port': callback_port,  # 存储分配的端口
+            'callback_url': callback_url,   # 存储完整回调URL
+            'server': callback_server,  # 存储服务器实例
+            'server_thread': server_thread,  # 存储服务器线程
+            'code': None,
+            'completed': False,
+            'created_at': time.time(),
+            'auto_project_detection': project_id is None,  # 标记是否需要自动检测项目ID
+            'get_all_projects': get_all_projects  # 是否为所有项目获取凭证
+        }
+        
+        # 清理过期的流程（30分钟）
+        cleanup_expired_flows()
+        
+        log.info(f"OAuth流程已创建: state={state}, project_id={project_id}")
+        log.info(f"用户需要访问认证URL，然后OAuth会回调到 {callback_url}")
+        log.info(f"为此认证流程分配的端口: {callback_port}")
+        
+        return {
+            'auth_url': auth_url,
+            'state': state,
+            'callback_port': callback_port,
+            'success': True,
+            'auto_project_detection': project_id is None,
+            'detected_project_id': project_id
+        }
+        
+    except Exception as e:
+        log.error(f"创建认证URL失败: {e}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def wait_for_callback_sync(state: str, timeout: int = 300) -> Optional[str]:
+    """同步等待OAuth回调完成，使用对应流程的专用服务器"""
+    if state not in auth_flows:
+        log.error(f"未找到状态为 {state} 的认证流程")
+        return None
+    
+    flow_data = auth_flows[state]
+    callback_port = flow_data['callback_port']
+    
+    # 服务器已经在create_auth_url时启动了，这里只需要等待
+    log.info(f"等待OAuth回调完成，端口: {callback_port}")
+    
+    # 等待回调完成
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        if flow_data.get('code'):
+            log.info(f"OAuth回调成功完成")
+            return flow_data['code']
+        time.sleep(0.5)  # 每0.5秒检查一次
+        
+        # 刷新flow_data引用
+        if state in auth_flows:
+            flow_data = auth_flows[state]
+    
+    log.warning(f"等待OAuth回调超时 ({timeout}秒)")
+    return None
+
+
+async def complete_auth_flow(project_id: Optional[str] = None, user_session: str = None) -> Dict[str, Any]:
+    """完成认证流程并保存凭证，支持自动检测项目ID"""
+    try:
+        # 查找对应的认证流程
+        state = None
+        flow_data = None
+        
+        # 如果指定了project_id，先尝试匹配指定的项目
+        if project_id:
+            for s, data in auth_flows.items():
+                if data['project_id'] == project_id:
+                    # 如果指定了用户会话，优先匹配相同会话的流程
+                    if user_session and data.get('user_session') == user_session:
+                        state = s
+                        flow_data = data
+                        break
+                    # 如果没有指定会话，或没找到匹配会话的流程，使用第一个匹配项目ID的
+                    elif not state:
+                        state = s
+                        flow_data = data
+        
+        # 如果没有指定项目ID或没找到匹配的，查找需要自动检测项目ID的流程
+        if not state:
+            for s, data in auth_flows.items():
+                if data.get('auto_project_detection', False):
+                    # 如果指定了用户会话，优先匹配相同会话的流程
+                    if user_session and data.get('user_session') == user_session:
+                        state = s
+                        flow_data = data
+                        break
+                    # 使用第一个找到的需要自动检测的流程
+                    elif not state:
+                        state = s
+                        flow_data = data
+        
+        if not state or not flow_data:
+            return {
+                'success': False,
+                'error': '未找到对应的认证流程，请先点击获取认证链接'
+            }
+        
+        if not project_id:
+            project_id = flow_data.get('project_id')
+            if not project_id:
+                return {
+                    'success': False,
+                    'error': '缺少项目ID，请指定项目ID',
+                    'requires_manual_project_id': True
+                }
+        
+        flow = flow_data['flow']
+        
+        # 如果还没有授权码，需要等待回调
+        if not flow_data.get('code'):
+            log.info(f"等待用户完成OAuth授权 (state: {state})")
+            auth_code = wait_for_callback_sync(state)
+            
+            if not auth_code:
+                return {
+                    'success': False,
+                    'error': '未接收到授权回调，请确保完成了浏览器中的OAuth认证'
+                }
+            
+            # 更新流程数据
+            auth_flows[state]['code'] = auth_code
+            auth_flows[state]['completed'] = True
+        else:
+            auth_code = flow_data['code']
+        
+        # 使用认证代码获取凭证
+        import oauthlib.oauth2.rfc6749.parameters
+        original_validate = oauthlib.oauth2.rfc6749.parameters.validate_token_parameters
+        
+        def patched_validate(params):
+            try:
+                return original_validate(params)
+            except Warning:
+                pass
+        
+        oauthlib.oauth2.rfc6749.parameters.validate_token_parameters = patched_validate
+        
+        try:
+            credentials = await flow.exchange_code(auth_code)
+            # credentials 已经在 exchange_code 中获得
+            
+            # 如果需要自动检测项目ID且没有提供项目ID
+            if flow_data.get('auto_project_detection', False) and not project_id:
+                log.info("尝试通过API获取用户项目列表...")
+                log.info(f"使用的token: {credentials.access_token[:20]}...")
+                log.info(f"Token过期时间: {credentials.expires_at}")
+                user_projects = await get_user_projects(credentials)
+                
+                if user_projects:
+                    # 如果只有一个项目，自动使用
+                    if len(user_projects) == 1:
+                        project_id = user_projects[0].get('projectId')
+                        if project_id:
+                            flow_data['project_id'] = project_id
+                            log.info(f"自动选择唯一项目: {project_id}")
+                    # 如果有多个项目，尝试选择默认项目
+                    else:
+                        project_id = await select_default_project(user_projects)
+                        if project_id:
+                            flow_data['project_id'] = project_id
+                            log.info(f"自动选择默认项目: {project_id}")
+                        else:
+                            # 返回项目列表让用户选择
+                            return {
+                                'success': False,
+                                'error': '请从以下项目中选择一个',
+                                'requires_project_selection': True,
+                                'available_projects': [
+                                    {
+                                        'projectId': p.get('projectId'),
+                                        'name': p.get('displayName') or p.get('projectId'),
+                                        'projectNumber': p.get('projectNumber')
+                                    }
+                                    for p in user_projects
+                                ]
+                            }
+                else:
+                    # 如果无法获取项目列表，提示手动输入
+                    return {
+                        'success': False,
+                        'error': '无法获取您的项目列表，请手动指定项目ID',
+                        'requires_manual_project_id': True
+                    }
+            
+            # 如果仍然没有项目ID，返回错误
+            if not project_id:
+                return {
+                    'success': False,
+                    'error': '缺少项目ID，请指定项目ID',
+                    'requires_manual_project_id': True
+                }
+            
+            # 保存凭证
+            saved_filename = await save_credentials(credentials, project_id)
+            
+            # 准备返回的凭证数据
+            creds_data = {
+                "client_id": CLIENT_ID,
+                "client_secret": CLIENT_SECRET,
+                "token": credentials.access_token,
+                "refresh_token": credentials.refresh_token,
+                "scopes": SCOPES,
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "project_id": project_id
+            }
+            
+            if credentials.expires_at:
+                if credentials.expires_at.tzinfo is None:
+                    expiry_utc = credentials.expires_at.replace(tzinfo=timezone.utc)
+                else:
+                    expiry_utc = credentials.expires_at
+                creds_data["expiry"] = expiry_utc.isoformat()
+            
+            # 清理使用过的流程
+            if state in auth_flows:
+                flow_data_to_clean = auth_flows[state]
+                # 快速关闭服务器
+                try:
+                    if flow_data_to_clean.get('server'):
+                        server = flow_data_to_clean['server']
+                        port = flow_data_to_clean.get('callback_port')
+                        async_shutdown_server(server, port)
+                except Exception as e:
+                    log.debug(f"启动异步关闭服务器时出错: {e}")
+                
+                del auth_flows[state]
+            
+            log.info("OAuth认证成功，凭证已保存")
+            return {
+                'success': True,
+                'credentials': creds_data,
+                'file_path': saved_filename,
+                'auto_detected_project': flow_data.get('auto_project_detection', False)
+            }
+            
+        except Exception as e:
+            log.error(f"获取凭证失败: {e}")
+            return {
+                'success': False,
+                'error': f'获取凭证失败: {str(e)}'
+            }
+        finally:
+            oauthlib.oauth2.rfc6749.parameters.validate_token_parameters = original_validate
+            
+    except Exception as e:
+        log.error(f"完成认证流程失败: {e}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+async def asyncio_complete_auth_flow(project_id: Optional[str] = None, user_session: str = None, get_all_projects: bool = False) -> Dict[str, Any]:
+    """异步完成认证流程，支持自动检测项目ID"""
+    try:
+        log.info(f"asyncio_complete_auth_flow开始执行: project_id={project_id}, user_session={user_session}")
+        
+        # 查找对应的认证流程
+        state = None
+        flow_data = None
+        
+        log.debug(f"当前所有auth_flows: {list(auth_flows.keys())}")
+        
+        # 如果指定了project_id，先尝试匹配指定的项目
+        if project_id:
+            log.info(f"尝试匹配指定的项目ID: {project_id}")
+            for s, data in auth_flows.items():
+                if data['project_id'] == project_id:
+                    # 如果指定了用户会话，优先匹配相同会话的流程
+                    if user_session and data.get('user_session') == user_session:
+                        state = s
+                        flow_data = data
+                        log.info(f"找到匹配的用户会话: {s}")
+                        break
+                    # 如果没有指定会话，或没找到匹配会话的流程，使用第一个匹配项目ID的
+                    elif not state:
+                        state = s
+                        flow_data = data
+                        log.info(f"找到匹配的项目ID: {s}")
+        
+        # 如果没有指定项目ID或没找到匹配的，查找需要自动检测项目ID的流程
+        if not state:
+            log.info(f"没有找到指定项目的流程，查找自动检测流程")
+            for s, data in auth_flows.items():
+                log.debug(f"检查流程 {s}: auto_project_detection={data.get('auto_project_detection', False)}")
+                if data.get('auto_project_detection', False):
+                    # 如果指定了用户会话，优先匹配相同会话的流程
+                    if user_session and data.get('user_session') == user_session:
+                        state = s
+                        flow_data = data
+                        log.info(f"找到匹配用户会话的自动检测流程: {s}")
+                        break
+                    # 使用第一个找到的需要自动检测的流程
+                    elif not state:
+                        state = s
+                        flow_data = data
+                        log.info(f"找到自动检测流程: {s}")
+        
+        if not state or not flow_data:
+            log.error(f"未找到认证流程: state={state}, flow_data存在={bool(flow_data)}")
+            log.debug(f"当前所有flow_data: {list(auth_flows.keys())}")
+            return {
+                'success': False,
+                'error': '未找到对应的认证流程，请先点击获取认证链接'
+            }
+        
+        log.info(f"找到认证流程: state={state}")
+        log.info(f"flow_data内容: project_id={flow_data.get('project_id')}, auto_project_detection={flow_data.get('auto_project_detection')}")
+        log.info(f"传入的project_id参数: {project_id}")
+        
+        # 如果需要自动检测项目ID且没有提供项目ID
+        log.info(f"检查auto_project_detection条件: auto_project_detection={flow_data.get('auto_project_detection', False)}, not project_id={not project_id}")
+        if flow_data.get('auto_project_detection', False) and not project_id:
+            log.info("跳过自动检测项目ID，进入等待阶段")
+        elif not project_id:
+            log.info("进入project_id检查分支")
+            project_id = flow_data.get('project_id')
+            if not project_id:
+                log.error("缺少项目ID，返回错误")
+                return {
+                    'success': False,
+                    'error': '缺少项目ID，请指定项目ID',
+                    'requires_manual_project_id': True
+                }
+        else:
+            log.info(f"使用提供的项目ID: {project_id}")
+        
+        # 检查是否已经有授权码
+        log.info(f"开始检查OAuth授权码...")
+        max_wait_time = 60  # 最多等待60秒
+        wait_interval = 1   # 每秒检查一次
+        waited = 0
+        
+        while waited < max_wait_time:
+            log.debug(f"等待OAuth授权码... ({waited}/{max_wait_time}秒)")
+            if flow_data.get('code'):
+                log.info(f"检测到OAuth授权码，开始处理凭证 (等待时间: {waited}秒)")
+                break
+            
+            # 异步等待
+            await asyncio.sleep(wait_interval)
+            waited += wait_interval
+            
+            # 刷新flow_data引用，因为可能被回调更新了
+            if state in auth_flows:
+                flow_data = auth_flows[state]
+                log.debug(f"刷新flow_data: completed={flow_data.get('completed')}, code存在={bool(flow_data.get('code'))}")
+        
+        if not flow_data.get('code'):
+            log.error(f"等待OAuth回调超时，等待了{waited}秒")
+            return {
+                'success': False,
+                'error': '等待OAuth回调超时，请确保完成了浏览器中的认证并看到成功页面'
+            }
+        
+        flow = flow_data['flow']
+        auth_code = flow_data['code']
+        
+        log.info(f"开始使用授权码获取凭证: code={'***' + auth_code[-4:] if auth_code else 'None'}")
+        
+        # 使用认证代码获取凭证
+        import oauthlib.oauth2.rfc6749.parameters
+        original_validate = oauthlib.oauth2.rfc6749.parameters.validate_token_parameters
+        
+        def patched_validate(params):
+            try:
+                return original_validate(params)
+            except Warning:
+                pass
+        
+        oauthlib.oauth2.rfc6749.parameters.validate_token_parameters = patched_validate
+        
+        try:
+            log.info(f"调用flow.exchange_code...")
+            credentials = await flow.exchange_code(auth_code)
+            log.info(f"成功获取凭证，token前缀: {credentials.access_token[:20] if credentials.access_token else 'None'}...")
+            
+            log.info(f"检查是否需要项目检测: auto_project_detection={flow_data.get('auto_project_detection')}, project_id={project_id}")
+            
+            # 检查是否为批量获取所有项目模式
+            if flow_data.get('get_all_projects', False) or get_all_projects:
+                log.info("批量模式：为所有项目并发获取凭证...")
+                user_projects = await get_user_projects(credentials)
+                
+                if user_projects:
+                    async def process_single_project(project_info):
+                        """并发处理单个项目的凭证获取"""
+                        project_id_current = project_info.get('projectId')
+                        project_name = project_info.get('displayName') or project_id_current
+                        
+                        try:
+                            log.info(f"为项目 {project_name} ({project_id_current}) 启用API服务...")
+                            await enable_required_apis(credentials, project_id_current)
+                            
+                            # 保存凭证
+                            saved_filename = await save_credentials(credentials, project_id_current)
+                            
+                            log.info(f"成功为项目 {project_name} 保存凭证")
+                            return {
+                                'status': 'success',
+                                'project_id': project_id_current,
+                                'project_name': project_name,
+                                'file_path': saved_filename
+                            }
+                            
+                        except Exception as e:
+                            log.error(f"为项目 {project_name} ({project_id_current}) 处理凭证失败: {e}")
+                            return {
+                                'status': 'failed',
+                                'project_id': project_id_current,
+                                'project_name': project_name,
+                                'error': str(e)
+                            }
+                    
+                    # 并发处理所有项目
+                    log.info(f"开始并发处理 {len(user_projects)} 个项目...")
+                    tasks = [process_single_project(project_info) for project_info in user_projects]
+                    results = await asyncio.gather(*tasks, return_exceptions=True)
+                    
+                    # 整理结果
+                    multiple_results = {'success': [], 'failed': []}
+                    for result in results:
+                        if isinstance(result, Exception):
+                            log.error(f"并发处理项目时发生异常: {result}")
+                            multiple_results['failed'].append({
+                                'project_id': 'unknown',
+                                'project_name': 'unknown',
+                                'error': f'处理异常: {str(result)}'
+                            })
+                        elif result['status'] == 'success':
+                            multiple_results['success'].append({
+                                'project_id': result['project_id'],
+                                'project_name': result['project_name'],
+                                'file_path': result['file_path']
+                            })
+                        else:  # failed
+                            multiple_results['failed'].append({
+                                'project_id': result['project_id'],
+                                'project_name': result['project_name'],
+                                'error': result['error']
+                            })
+                    
+                    # 清理使用过的流程
+                    if state in auth_flows:
+                        flow_data_to_clean = auth_flows[state]
+                        try:
+                            if flow_data_to_clean.get('server'):
+                                server = flow_data_to_clean['server']
+                                port = flow_data_to_clean.get('callback_port')
+                                async_shutdown_server(server, port)
+                        except Exception as e:
+                            log.debug(f"启动异步关闭服务器时出错: {e}")
+                        del auth_flows[state]
+                    
+                    log.info(f"批量并发认证完成：成功 {len(multiple_results['success'])} 个，失败 {len(multiple_results['failed'])} 个")
+                    return {
+                        'success': True,
+                        'multiple_credentials': multiple_results
+                    }
+                else:
+                    return {
+                        'success': False,
+                        'error': '无法获取您的项目列表，批量认证失败'
+                    }
+                        
+            # 如果需要自动检测项目ID且没有提供项目ID（单项目模式）
+            elif flow_data.get('auto_project_detection', False) and not project_id:
+                log.info("尝试通过API获取用户项目列表...")
+                log.info(f"使用的token: {credentials.access_token[:20]}...")
+                log.info(f"Token过期时间: {credentials.expires_at}")
+                user_projects = await get_user_projects(credentials)
+                
+                if user_projects:
+                    # 如果只有一个项目，自动使用
+                    if len(user_projects) == 1:
+                        project_id = user_projects[0].get('projectId')
+                        if project_id:
+                            flow_data['project_id'] = project_id
+                            log.info(f"自动选择唯一项目: {project_id}")
+                            # 自动启用必需的API服务
+                            log.info("正在自动启用必需的API服务...")
+                            await enable_required_apis(credentials, project_id)
+                    # 如果有多个项目，尝试选择默认项目
+                    else:
+                        project_id = await select_default_project(user_projects)
+                        if project_id:
+                            flow_data['project_id'] = project_id
+                            log.info(f"自动选择默认项目: {project_id}")
+                            # 自动启用必需的API服务
+                            log.info("正在自动启用必需的API服务...")
+                            await enable_required_apis(credentials, project_id)
+                        else:
+                            # 返回项目列表让用户选择
+                            return {
+                                'success': False,
+                                'error': '请从以下项目中选择一个',
+                                'requires_project_selection': True,
+                                'available_projects': [
+                                    {
+                                        'projectId': p.get('projectId'),
+                                        'name': p.get('displayName') or p.get('projectId'),
+                                        'projectNumber': p.get('projectNumber')
+                                    }
+                                    for p in user_projects
+                                ]
+                            }
+                else:
+                    # 如果无法获取项目列表，提示手动输入
+                    return {
+                        'success': False,
+                        'error': '无法获取您的项目列表，请手动指定项目ID',
+                        'requires_manual_project_id': True
+                    }
+            elif project_id:
+                # 如果已经有项目ID（手动提供或环境检测），也尝试启用API服务
+                log.info("正在为已提供的项目ID自动启用必需的API服务...")
+                await enable_required_apis(credentials, project_id)
+            
+            # 如果仍然没有项目ID，返回错误
+            if not project_id:
+                return {
+                    'success': False,
+                    'error': '缺少项目ID，请指定项目ID',
+                    'requires_manual_project_id': True
+                }
+            
+            # 保存凭证
+            saved_filename = await save_credentials(credentials, project_id)
+            
+            # 准备返回的凭证数据
+            creds_data = {
+                "client_id": CLIENT_ID,
+                "client_secret": CLIENT_SECRET,
+                "token": credentials.access_token,
+                "refresh_token": credentials.refresh_token,
+                "scopes": SCOPES,
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "project_id": project_id
+            }
+            
+            if credentials.expires_at:
+                if credentials.expires_at.tzinfo is None:
+                    expiry_utc = credentials.expires_at.replace(tzinfo=timezone.utc)
+                else:
+                    expiry_utc = credentials.expires_at
+                creds_data["expiry"] = expiry_utc.isoformat()
+            
+            # 清理使用过的流程
+            if state in auth_flows:
+                flow_data_to_clean = auth_flows[state]
+                # 快速关闭服务器
+                try:
+                    if flow_data_to_clean.get('server'):
+                        server = flow_data_to_clean['server']
+                        port = flow_data_to_clean.get('callback_port')
+                        async_shutdown_server(server, port)
+                except Exception as e:
+                    log.debug(f"启动异步关闭服务器时出错: {e}")
+                
+                del auth_flows[state]
+            
+            log.info("OAuth认证成功，凭证已保存")
+            return {
+                'success': True,
+                'credentials': creds_data,
+                'file_path': saved_filename,
+                'auto_detected_project': flow_data.get('auto_project_detection', False)
+            }
+            
+        except Exception as e:
+            log.error(f"获取凭证失败: {e}")
+            return {
+                'success': False,
+                'error': f'获取凭证失败: {str(e)}'
+            }
+        finally:
+            oauthlib.oauth2.rfc6749.parameters.validate_token_parameters = original_validate
+            
+    except Exception as e:
+        log.error(f"异步完成认证流程失败: {e}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+async def complete_auth_flow_from_callback_url(callback_url: str, project_id: Optional[str] = None, get_all_projects: bool = False) -> Dict[str, Any]:
+    """从回调URL直接完成认证流程，无需启动本地服务器"""
+    try:
+        log.info(f"开始从回调URL完成认证: {callback_url}")
+        
+        # 解析回调URL
+        parsed_url = urlparse(callback_url)
+        query_params = parse_qs(parsed_url.query)
+        
+        # 验证必要参数
+        if 'state' not in query_params or 'code' not in query_params:
+            return {
+                'success': False,
+                'error': '回调URL缺少必要参数 (state 或 code)'
+            }
+        
+        state = query_params['state'][0]
+        code = query_params['code'][0]
+        
+        log.info(f"从URL解析到: state={state}, code=xxx...")
+        
+        # 检查是否有对应的认证流程
+        if state not in auth_flows:
+            return {
+                'success': False,
+                'error': f'未找到对应的认证流程，请先启动认证 (state: {state})'
+            }
+        
+        flow_data = auth_flows[state]
+        flow = flow_data['flow']
+        
+        # 构造回调URL（使用flow中存储的redirect_uri）
+        redirect_uri = flow.redirect_uri
+        log.info(f"使用redirect_uri: {redirect_uri}")
+        
+        try:
+            # 使用authorization code获取token
+            credentials = await flow.exchange_code(code)
+            log.info("成功获取访问令牌")
+            
+            # 检查是否为批量获取所有项目模式
+            if get_all_projects:
+                log.info("批量模式：从回调URL为所有项目并发获取凭证...")
+                try:
+                    projects = await get_user_projects(credentials)
+                    if projects:
+                        async def process_single_project(project_info):
+                            """并发处理单个项目的凭证获取"""
+                            project_id_current = project_info.get('projectId')
+                            project_name = project_info.get('displayName') or project_id_current
+                            
+                            try:
+                                log.info(f"为项目 {project_name} ({project_id_current}) 启用API服务...")
+                                await enable_required_apis(credentials, project_id_current)
+                                
+                                # 保存凭证
+                                saved_filename = await save_credentials(credentials, project_id_current)
+                                
+                                log.info(f"成功为项目 {project_name} 保存凭证")
+                                return {
+                                    'status': 'success',
+                                    'project_id': project_id_current,
+                                    'project_name': project_name,
+                                    'file_path': saved_filename
+                                }
+                                
+                            except Exception as e:
+                                log.error(f"为项目 {project_name} ({project_id_current}) 处理凭证失败: {e}")
+                                return {
+                                    'status': 'failed',
+                                    'project_id': project_id_current,
+                                    'project_name': project_name,
+                                    'error': str(e)
+                                }
+                        
+                        # 并发处理所有项目
+                        log.info(f"开始并发处理 {len(projects)} 个项目...")
+                        tasks = [process_single_project(project_info) for project_info in projects]
+                        results = await asyncio.gather(*tasks, return_exceptions=True)
+                        
+                        # 整理结果
+                        multiple_results = {'success': [], 'failed': []}
+                        for result in results:
+                            if isinstance(result, Exception):
+                                log.error(f"并发处理项目时发生异常: {result}")
+                                multiple_results['failed'].append({
+                                    'project_id': 'unknown',
+                                    'project_name': 'unknown',
+                                    'error': f'处理异常: {str(result)}'
+                                })
+                            elif result['status'] == 'success':
+                                multiple_results['success'].append({
+                                    'project_id': result['project_id'],
+                                    'project_name': result['project_name'],
+                                    'file_path': result['file_path']
+                                })
+                            else:  # failed
+                                multiple_results['failed'].append({
+                                    'project_id': result['project_id'],
+                                    'project_name': result['project_name'],
+                                    'error': result['error']
+                                })
+                        
+                        # 清理使用过的流程
+                        if state in auth_flows:
+                            flow_data_to_clean = auth_flows[state]
+                            try:
+                                if flow_data_to_clean.get('server'):
+                                    server = flow_data_to_clean['server']
+                                    port = flow_data_to_clean.get('callback_port')
+                                    async_shutdown_server(server, port)
+                            except Exception as e:
+                                log.debug(f"关闭服务器时出错: {e}")
+                            del auth_flows[state]
+                        
+                        log.info(f"从回调URL批量并发认证完成：成功 {len(multiple_results['success'])} 个，失败 {len(multiple_results['failed'])} 个")
+                        return {
+                            'success': True,
+                            'multiple_credentials': multiple_results
+                        }
+                    else:
+                        return {
+                            'success': False,
+                            'error': '无法获取您的项目列表，批量认证失败'
+                        }
+                except Exception as e:
+                    log.error(f"批量获取项目列表失败: {e}")
+                    return {
+                        'success': False,
+                        'error': f'批量获取项目列表失败: {str(e)}'
+                    }
+            
+            # 单项目模式的项目ID处理逻辑
+            detected_project_id = None
+            auto_detected = False
+            
+            if not project_id:
+                # 尝试自动检测项目ID
+                try:
+                    projects = await get_user_projects(credentials)
+                    if projects:
+                        if len(projects) == 1:
+                            # 只有一个项目，自动使用
+                            detected_project_id = projects[0]['projectId']
+                            auto_detected = True
+                            log.info(f"自动检测到唯一项目ID: {detected_project_id}")
+                        else:
+                            # 多个项目，自动选择第一个
+                            detected_project_id = projects[0]['projectId']
+                            auto_detected = True
+                            log.info(f"检测到{len(projects)}个项目，自动选择第一个: {detected_project_id}")
+                            log.debug(f"其他可用项目: {[p['projectId'] for p in projects[1:]]}")
+                    else:
+                        # 没有项目访问权限
+                        return {
+                            'success': False,
+                            'error': '未检测到可访问的项目，请检查权限或手动指定项目ID',
+                            'requires_manual_project_id': True
+                        }
+                except Exception as e:
+                    log.warning(f"自动检测项目ID失败: {e}")
+                    return {
+                        'success': False,
+                        'error': f'自动检测项目ID失败: {str(e)}，请手动指定项目ID',
+                        'requires_manual_project_id': True
+                    }
+            else:
+                detected_project_id = project_id
+            
+            # 启用必需的API服务
+            if detected_project_id:
+                try:
+                    log.info(f"正在为项目 {detected_project_id} 启用必需的API服务...")
+                    await enable_required_apis(credentials, detected_project_id)
+                except Exception as e:
+                    log.warning(f"启用API服务失败: {e}")
+            
+            # 保存凭证
+            saved_filename = await save_credentials(credentials, detected_project_id)
+            
+            # 准备返回的凭证数据
+            creds_data = {
+                "client_id": CLIENT_ID,
+                "client_secret": CLIENT_SECRET,
+                "token": credentials.access_token,
+                "refresh_token": credentials.refresh_token,
+                "scopes": SCOPES,
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "project_id": detected_project_id
+            }
+            
+            if credentials.expires_at:
+                if credentials.expires_at.tzinfo is None:
+                    expiry_utc = credentials.expires_at.replace(tzinfo=timezone.utc)
+                else:
+                    expiry_utc = credentials.expires_at
+                creds_data["expiry"] = expiry_utc.isoformat()
+            
+            # 清理使用过的流程
+            if state in auth_flows:
+                flow_data_to_clean = auth_flows[state]
+                # 快速关闭服务器（如果有）
+                try:
+                    if flow_data_to_clean.get('server'):
+                        server = flow_data_to_clean['server']
+                        port = flow_data_to_clean.get('callback_port')
+                        async_shutdown_server(server, port)
+                except Exception as e:
+                    log.debug(f"关闭服务器时出错: {e}")
+                
+                del auth_flows[state]
+            
+            log.info("从回调URL完成OAuth认证成功，凭证已保存")
+            return {
+                'success': True,
+                'credentials': creds_data,
+                'file_path': saved_filename,
+                'auto_detected_project': auto_detected
+            }
+            
+        except Exception as e:
+            log.error(f"从回调URL获取凭证失败: {e}")
+            return {
+                'success': False,
+                'error': f'获取凭证失败: {str(e)}'
+            }
+        
+    except Exception as e:
+        log.error(f"从回调URL完成认证流程失败: {e}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+async def save_credentials(creds: Credentials, project_id: str) -> str:
+    """通过统一存储系统保存凭证"""
+    # 生成文件名（使用project_id和时间戳）
+    timestamp = int(time.time())
+    filename = f"{project_id}-{timestamp}.json"
+    
+    # 准备凭证数据
+    creds_data = {
+        "client_id": CLIENT_ID,
+        "client_secret": CLIENT_SECRET,
+        "token": creds.access_token,
+        "refresh_token": creds.refresh_token,
+        "scopes": SCOPES,
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "project_id": project_id
+    }
+    
+    if creds.expires_at:
+        if creds.expires_at.tzinfo is None:
+            expiry_utc = creds.expires_at.replace(tzinfo=timezone.utc)
+        else:
+            expiry_utc = creds.expires_at
+        creds_data["expiry"] = expiry_utc.isoformat()
+    
+    # 通过存储适配器保存
+    storage_adapter = await get_storage_adapter()
+    success = await storage_adapter.store_credential(filename, creds_data)
+    
+    if success:
+        # 创建默认状态记录
+        try:
+            default_state = {
+                "error_codes": [],
+                "disabled": False,
+                "last_success": time.time(),
+                "user_email": None,
+                "gemini_2_5_pro_calls": 0,
+                "total_calls": 0,
+                "next_reset_time": None,
+                "daily_limit_gemini_2_5_pro": 100,
+                "daily_limit_total": 1000
+            }
+            await storage_adapter.update_credential_state(filename, default_state)
+            log.info(f"凭证和状态已保存到: {filename}")
+        except Exception as e:
+            log.warning(f"创建默认状态记录失败 {filename}: {e}")
+        
+        return filename
+    else:
+        raise Exception(f"保存凭证失败: {filename}")
+
+
+def async_shutdown_server(server, port):
+    """异步关闭OAuth回调服务器，避免阻塞主流程"""
+    def shutdown_server_async():
+        try:
+            # 设置一个标志来跟踪关闭状态
+            shutdown_completed = threading.Event()
+            
+            def do_shutdown():
+                try:
+                    server.shutdown()
+                    server.server_close()
+                    shutdown_completed.set()
+                    log.info(f"已关闭端口 {port} 的OAuth回调服务器")
+                except Exception as e:
+                    shutdown_completed.set()
+                    log.debug(f"关闭服务器时出错: {e}")
+            
+            # 在单独线程中执行关闭操作
+            shutdown_worker = threading.Thread(target=do_shutdown, daemon=True)
+            shutdown_worker.start()
+            
+            # 等待最多5秒，如果超时就放弃等待
+            if shutdown_completed.wait(timeout=5):
+                log.debug(f"端口 {port} 服务器关闭完成")
+            else:
+                log.warning(f"端口 {port} 服务器关闭超时，但不阻塞主流程")
+                
+        except Exception as e:
+            log.debug(f"异步关闭服务器时出错: {e}")
+    
+    # 在后台线程中关闭服务器，不阻塞主流程
+    shutdown_thread = threading.Thread(target=shutdown_server_async, daemon=True)
+    shutdown_thread.start()
+    log.debug(f"开始异步关闭端口 {port} 的OAuth回调服务器")
+
+def cleanup_expired_flows():
+    """清理过期的认证流程"""
+    current_time = time.time()
+    EXPIRY_TIME = 600  # 10分钟过期
+    
+    # 直接遍历删除，避免创建额外列表
+    states_to_remove = [
+        state for state, flow_data in auth_flows.items()
+        if current_time - flow_data['created_at'] > EXPIRY_TIME
+    ]
+    
+    # 批量清理，提高效率
+    cleaned_count = 0
+    for state in states_to_remove:
+        flow_data = auth_flows.get(state)
+        if flow_data:
+            # 快速关闭可能存在的服务器
+            try:
+                if flow_data.get('server'):
+                    server = flow_data['server']
+                    port = flow_data.get('callback_port')
+                    async_shutdown_server(server, port)
+            except Exception as e:
+                log.debug(f"清理过期流程时启动异步关闭服务器失败: {e}")
+            
+            # 显式清理流程数据，释放内存
+            flow_data.clear()
+            del auth_flows[state]
+            cleaned_count += 1
+    
+    if cleaned_count > 0:
+        log.info(f"清理了 {cleaned_count} 个过期的认证流程")
+    
+    # 更积极的垃圾回收触发条件
+    if len(auth_flows) > 20:  # 降低阈值
+        import gc
+        gc.collect()
+        log.debug(f"触发垃圾回收，当前活跃认证流程数: {len(auth_flows)}")
+
+
+def get_auth_status(project_id: str) -> Dict[str, Any]:
+    """获取认证状态"""
+    for state, flow_data in auth_flows.items():
+        if flow_data['project_id'] == project_id:
+            return {
+                'status': 'completed' if flow_data['completed'] else 'pending',
+                'state': state,
+                'created_at': flow_data['created_at']
+            }
+    
+    return {
+        'status': 'not_found'
+    }
+
+
+# 鉴权功能 - 使用更小的数据结构
+auth_tokens = {}  # 存储有效的认证令牌
+TOKEN_EXPIRY = 3600  # 1小时令牌过期时间
+
+
+async def verify_password(password: str) -> bool:
+    """验证密码（面板登录使用）"""
+    from config import get_panel_password
+    correct_password = await get_panel_password()
+    return password == correct_password
+
+
+def generate_auth_token() -> str:
+    """生成认证令牌"""
+    # 清理过期令牌
+    cleanup_expired_tokens()
+    
+    token = secrets.token_urlsafe(32)
+    # 只存储创建时间
+    auth_tokens[token] = time.time()
+    return token
+
+
+def verify_auth_token(token: str) -> bool:
+    """验证认证令牌"""
+    if not token or token not in auth_tokens:
+        return False
+    
+    created_at = auth_tokens[token]
+    
+    # 检查令牌是否过期 (使用更短的过期时间)
+    if time.time() - created_at > TOKEN_EXPIRY:
+        del auth_tokens[token]
+        return False
+    
+    return True
+
+
+def cleanup_expired_tokens():
+    """清理过期的认证令牌"""
+    current_time = time.time()
+    expired_tokens = [
+        token for token, created_at in auth_tokens.items()
+        if current_time - created_at > TOKEN_EXPIRY
+    ]
+    
+    for token in expired_tokens:
+        del auth_tokens[token]
+    
+    if expired_tokens:
+        log.debug(f"清理了 {len(expired_tokens)} 个过期的认证令牌")
+
+def invalidate_auth_token(token: str):
+    """使认证令牌失效"""
+    if token in auth_tokens:
+        del auth_tokens[token]
+
+
+# 文件验证和处理功能 - 使用统一存储系统
+def validate_credential_content(content: str) -> Dict[str, Any]:
+    """验证凭证内容格式"""
+    try:
+        creds_data = json.loads(content)
+        
+        # 检查必要字段
+        required_fields = ['client_id', 'client_secret', 'refresh_token', 'token_uri']
+        missing_fields = [field for field in required_fields if field not in creds_data]
+        
+        if missing_fields:
+            return {
+                'valid': False,
+                'error': f'缺少必要字段: {", ".join(missing_fields)}'
+            }
+        
+        # 检查project_id
+        if 'project_id' not in creds_data:
+            log.warning("��证文件缺少project_id字段")
+        
+        return {
+            'valid': True,
+            'data': creds_data
+        }
+        
+    except json.JSONDecodeError as e:
+        return {
+            'valid': False,
+            'error': f'JSON格式错误: {str(e)}'
+        }
+    except Exception as e:
+        return {
+            'valid': False,
+            'error': f'文件验证失败: {str(e)}'
+        }
+
+
+async def save_uploaded_credential(content: str, original_filename: str) -> Dict[str, Any]:
+    """通过统一存储系统保存上传的凭证"""
+    try:
+        # 验证内容格式
+        validation = validate_credential_content(content)
+        if not validation['valid']:
+            return {
+                'success': False,
+                'error': validation['error']
+            }
+        
+        creds_data = validation['data']
+        
+        # 生成文件名
+        project_id = creds_data.get('project_id', 'unknown')
+        timestamp = int(time.time())
+        
+        # 从原文件名中提取有用信息
+        import os
+        base_name = os.path.splitext(original_filename)[0]
+        filename = f"{base_name}-{timestamp}.json"
+        
+        # 通过存储适配器保存
+        storage_adapter = await get_storage_adapter()
+        success = await storage_adapter.store_credential(filename, creds_data)
+        
+        if success:
+            log.info(f"凭证文件已上传保存: {filename}")
+            return {
+                'success': True,
+                'file_path': filename,
+                'project_id': project_id
+            }
+        else:
+            return {
+                'success': False,
+                'error': '保存到存储系统失败'
+            }
+        
+    except Exception as e:
+        log.error(f"保存上传文件失败: {e}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+async def batch_upload_credentials(files_data: List[Dict[str, str]]) -> Dict[str, Any]:
+    """批量上传凭证文件到统一存储系统"""
+    results = []
+    success_count = 0
+    
+    for file_data in files_data:
+        filename = file_data.get('filename', 'unknown.json')
+        content = file_data.get('content', '')
+        
+        result = await save_uploaded_credential(content, filename)
+        result['filename'] = filename
+        results.append(result)
+        
+        if result['success']:
+            success_count += 1
+    
+    return {
+        'uploaded_count': success_count,
+        'total_count': len(files_data),
+        'results': results
+    }
+
+
+# 环境变量批量导入功能 - 使用统一存储系统
+async def load_credentials_from_env() -> Dict[str, Any]:
+    """
+    从环境变量加载多个凭证文件到统一存储系统
+    支持两种环境变量格式:
+    1. GCLI_CREDS_1, GCLI_CREDS_2, ... (编号格式)
+    2. GCLI_CREDS_projectname1, GCLI_CREDS_projectname2, ... (项目名格式)
+    """
+    import os
+    
+    results = []
+    success_count = 0
+    
+    log.info("开始从环境变量加载认证凭证...")
+    
+    # 获取所有以GCLI_CREDS_开头的环境变量
+    creds_env_vars = {key: value for key, value in os.environ.items() 
+                      if key.startswith('GCLI_CREDS_') and value.strip()}
+    
+    if not creds_env_vars:
+        log.info("未找到GCLI_CREDS_*环境变量")
+        return {
+            'loaded_count': 0,
+            'total_count': 0,
+            'results': [],
+            'message': '未找到GCLI_CREDS_*环境变量'
+        }
+    
+    log.info(f"找到 {len(creds_env_vars)} 个凭证环境变量")
+    
+    # 获取存储适配器
+    storage_adapter = await get_storage_adapter()
+    
+    for env_name, creds_content in creds_env_vars.items():
+        # 从环境变量名提取标识符
+        identifier = env_name.replace('GCLI_CREDS_', '')
+        
+        try:
+            # 验证JSON格式
+            validation = validate_credential_content(creds_content)
+            if not validation['valid']:
+                result = {
+                    'env_name': env_name,
+                    'identifier': identifier,
+                    'success': False,
+                    'error': validation['error']
+                }
+                results.append(result)
+                log.error(f"环境变量 {env_name} 验证失败: {validation['error']}")
+                continue
+            
+            creds_data = validation['data']
+            project_id = creds_data.get('project_id', 'unknown')
+            
+            # 生成文件名 (使用标识符和项目ID)
+            timestamp = int(time.time())
+            if identifier.isdigit():
+                # 如果标识符是数字，使用项目ID作为主要标识
+                filename = f"env-{project_id}-{identifier}-{timestamp}.json"
+            else:
+                # 如果标识符是项目名，直接使用
+                filename = f"env-{identifier}-{timestamp}.json"
+            
+            # 通过存储适配器保存
+            success = await storage_adapter.store_credential(filename, creds_data)
+            
+            if success:
+                result = {
+                    'env_name': env_name,
+                    'identifier': identifier,
+                    'success': True,
+                    'file_path': filename,
+                    'project_id': project_id,
+                    'filename': filename
+                }
+                results.append(result)
+                success_count += 1
+                
+                log.info(f"成功从环境变量 {env_name} 保存凭证到: {filename}")
+            else:
+                result = {
+                    'env_name': env_name,
+                    'identifier': identifier,
+                    'success': False,
+                    'error': '保存到存储系统失败'
+                }
+                results.append(result)
+                log.error(f"环境变量 {env_name} 保存失败")
+            
+        except Exception as e:
+            result = {
+                'env_name': env_name,
+                'identifier': identifier,
+                'success': False,
+                'error': str(e)
+            }
+            results.append(result)
+            log.error(f"处理环境变量 {env_name} 时发生错误: {e}")
+    
+    message = f"成功导入 {success_count}/{len(creds_env_vars)} 个凭证文件"
+    log.info(message)
+    
+    return {
+        'loaded_count': success_count,
+        'total_count': len(creds_env_vars),
+        'results': results,
+        'message': message
+    }
+
+
+async def auto_load_env_credentials_on_startup() -> None:
+    """
+    程序启动时自动从环境变量加载凭证到统一存储系统
+    如果设置了 AUTO_LOAD_ENV_CREDS=true，则会自动执行
+    """
+    from config import get_auto_load_env_creds
+    auto_load = await get_auto_load_env_creds()
+    
+    if not auto_load:
+        log.debug("AUTO_LOAD_ENV_CREDS未启用，跳过自动加载")
+        return
+    
+    log.info("AUTO_LOAD_ENV_CREDS已启用，开始自动加载环境变量中的凭证...")
+    
+    try:
+        result = await load_credentials_from_env()
+        if result['loaded_count'] > 0:
+            log.info(f"启动时成功自动导入 {result['loaded_count']} 个凭证文件")
+        else:
+            log.info("启动时未找到可导入的环境变量凭证")
+    except Exception as e:
+        log.error(f"启动时自动加载环境变量凭证失败: {e}")
+
+
+async def clear_env_credentials() -> Dict[str, Any]:
+    """
+    清除所有从环境变量导入的凭证文件
+    仅删除文件名包含'env-'前缀的文件
+    """
+    try:
+        storage_adapter = await get_storage_adapter()
+        
+        # 获取所有凭证
+        all_credentials = await storage_adapter.list_credentials()
+        
+        deleted_files = []
+        deleted_count = 0
+        
+        for credential_name in all_credentials:
+            if credential_name.startswith('env-') and credential_name.endswith('.json'):
+                try:
+                    success = await storage_adapter.delete_credential(credential_name)
+                    if success:
+                        deleted_files.append(credential_name)
+                        deleted_count += 1
+                        log.info(f"删除环境变量凭证文件: {credential_name}")
+                    else:
+                        log.error(f"删除文件 {credential_name} 失败")
+                except Exception as e:
+                    log.error(f"删除文件 {credential_name} 失败: {e}")
+        
+        message = f"成功删除 {deleted_count} 个环境变量凭证文件"
+        log.info(message)
+        
+        return {
+            'deleted_count': deleted_count,
+            'deleted_files': deleted_files,
+            'message': message
+        }
+        
+    except Exception as e:
+        error_message = f"清除环境变量凭证文件时发生错误: {e}"
+        log.error(error_message)
+        return {
+            'deleted_count': 0,
+            'error': error_message
+        }

src/credential_manager.py

@@ -0,0 +1,611 @@
+"""
+凭证管理器 - 完全基于统一存储中间层
+"""
+import asyncio
+import time
+from datetime import datetime, timezone
+from typing import Dict, Any, List, Optional, Tuple
+from contextlib import asynccontextmanager
+
+from config import get_calls_per_rotation, is_mongodb_mode
+from log import log
+from .storage_adapter import get_storage_adapter
+from .google_oauth_api import fetch_user_email_from_file, Credentials
+from .task_manager import task_manager
+
+
+class CredentialManager:
+    """
+    统一凭证管理器
+    所有存储操作通过storage_adapter进行
+    """
+    
+    def __init__(self):
+        # 核心状态
+        self._initialized = False
+        self._storage_adapter = None
+        
+        # 凭证轮换相关
+        self._credential_files: List[str] = []  # 存储凭证文件名列表
+        self._current_credential_index = 0
+        self._call_count = 0
+        self._last_scan_time = 0
+        
+        # 当前使用的凭证信息
+        self._current_credential_file: Optional[str] = None
+        self._current_credential_data: Optional[Dict[str, Any]] = None
+        self._current_credential_state: Dict[str, Any] = {}
+        
+        # 并发控制
+        self._state_lock = asyncio.Lock()
+        self._operation_lock = asyncio.Lock()
+        
+        # 工作线程控制
+        self._shutdown_event = asyncio.Event()
+        self._write_worker_running = False
+        self._write_worker_task = None
+        
+        # 原子操作计数器
+        self._atomic_counter = 0
+        self._atomic_lock = asyncio.Lock()
+        
+        # Onboarding state
+        self._onboarding_complete = False
+        self._onboarding_checked = False
+    
+    async def initialize(self):
+        """初始化凭证管理器"""
+        async with self._state_lock:
+            if self._initialized:
+                return
+            
+            # 初始化统一存储适配器
+            self._storage_adapter = await get_storage_adapter()
+            
+            # 启动后台工作线程
+            await self._start_background_workers()
+            
+            # 发现并加载凭证
+            await self._discover_credentials()
+            
+            self._initialized = True
+            storage_type = "MongoDB" if await is_mongodb_mode() else "File"
+            log.debug(f"Credential manager initialized with {storage_type} storage backend")
+    
+    async def close(self):
+        """清理资源"""
+        log.debug("Closing credential manager...")
+        
+        # 设置关闭标志
+        self._shutdown_event.set()
+        
+        # 等待后台任务结束
+        if self._write_worker_task:
+            try:
+                await asyncio.wait_for(self._write_worker_task, timeout=5.0)
+            except asyncio.TimeoutError:
+                log.warning("Write worker task did not finish within timeout")
+                if not self._write_worker_task.done():
+                    self._write_worker_task.cancel()
+        
+        self._initialized = False
+        log.debug("Credential manager closed")
+    
+    async def _start_background_workers(self):
+        """启动后台工作线程"""
+        if not self._write_worker_running:
+            self._write_worker_running = True
+            self._write_worker_task = task_manager.create_task(
+                self._background_worker(), 
+                name="credential_background_worker"
+            )
+    
+    async def _background_worker(self):
+        """后台工作线程，处理定期任务"""
+        while not self._shutdown_event.is_set():
+            try:
+                # 每60秒检查一次凭证更新
+                await asyncio.wait_for(self._shutdown_event.wait(), timeout=60.0)
+                if self._shutdown_event.is_set():
+                    break
+                
+                # 重新发现凭证（热更新）
+                await self._discover_credentials()
+                
+            except asyncio.TimeoutError:
+                # 超时是正常的，继续下一轮
+                continue
+            except Exception as e:
+                log.error(f"Background worker error: {e}")
+                await asyncio.sleep(5)  # 错误后等待5秒再继续
+    
+    async def _discover_credentials(self):
+        """发现和加载所有可用凭证"""
+        try:
+            # 从存储适配器获取所有凭证
+            all_credentials = await self._storage_adapter.list_credentials()
+            
+            # 过滤出可用的凭证（排除被禁用的）- 批量读取状态以提升性能
+            available_credentials = []
+            
+            # 批量获取所有凭证状态，避免多次读取状态文件
+            if all_credentials:
+                try:
+                    all_states = await self._storage_adapter.get_all_credential_states()
+                    
+                    for credential_name in all_credentials:
+                        normalized_name = credential_name
+                        # 标准化文件名以匹配状态数据中的键
+                        if hasattr(self._storage_adapter._backend, '_normalize_filename'):
+                            normalized_name = self._storage_adapter._backend._normalize_filename(credential_name)
+                        
+                        state = all_states.get(normalized_name, {})
+                        if not state.get("disabled", False):
+                            available_credentials.append(credential_name)
+                except Exception as e:
+                    log.warning(f"Failed to batch load credential states, falling back to individual checks: {e}")
+                    # 如果批量读取失败，回退到逐个检查
+                    for credential_name in all_credentials:
+                        try:
+                            state = await self._storage_adapter.get_credential_state(credential_name)
+                            if not state.get("disabled", False):
+                                available_credentials.append(credential_name)
+                        except Exception as e2:
+                            log.warning(f"Failed to check state for credential {credential_name}: {e2}")
+            
+            # 更新凭证列表
+            old_credentials = set(self._credential_files)
+            new_credentials = set(available_credentials)
+            
+            if old_credentials != new_credentials:
+                # 记录变化（只在非初始状态时记录）
+                is_initial_load = len(old_credentials) == 0
+                added = new_credentials - old_credentials
+                removed = old_credentials - new_credentials
+                
+                self._credential_files = available_credentials
+                
+                # 初始加载时只记录调试信息，运行时变化才记录INFO
+                if not is_initial_load:
+                    if added:
+                        log.info(f"发现新的可用凭证: {list(added)}")
+                    if removed:
+                        log.info(f"移除不可用凭证: {list(removed)}")
+                else:
+                    # 初始加载时只记录调试信息
+                    if available_credentials:
+                        log.debug(f"初始加载发现 {len(available_credentials)} 个可用凭证")
+                
+                # 重置当前索引如果需要
+                if self._current_credential_index >= len(self._credential_files):
+                    self._current_credential_index = 0
+            
+            if not self._credential_files:
+                log.warning("No available credential files found")
+            else:
+                log.debug(f"Available credentials: {len(self._credential_files)} files")
+                
+        except Exception as e:
+            log.error(f"Failed to discover credentials: {e}")
+    
+    async def _load_current_credential(self) -> Optional[Tuple[str, Dict[str, Any]]]:
+        """加载当前选中的凭证数据，包含token过期检测和自动刷新"""
+        if not self._credential_files:
+            return None
+        
+        try:
+            current_file = self._credential_files[self._current_credential_index]
+            
+            # 从存储适配器加载凭证数据
+            credential_data = await self._storage_adapter.get_credential(current_file)
+            if not credential_data:
+                log.error(f"Failed to load credential data for: {current_file}")
+                return None
+            
+            # 检查refresh_token
+            if "refresh_token" not in credential_data or not credential_data["refresh_token"]:
+                log.warning(f"No refresh token in {current_file}")
+                return None
+                
+            # Auto-add 'type' field if missing but has required OAuth fields
+            if 'type' not in credential_data and all(key in credential_data for key in ['client_id', 'refresh_token']):
+                credential_data['type'] = 'authorized_user'
+                log.debug(f"Auto-added 'type' field to credential from file {current_file}")
+            
+            # 兼容不同的token字段格式
+            if "access_token" in credential_data and "token" not in credential_data:
+                credential_data["token"] = credential_data["access_token"]
+            if "scope" in credential_data and "scopes" not in credential_data:
+                credential_data["scopes"] = credential_data["scope"].split()
+            
+            # token过期检测和刷新
+            should_refresh = await self._should_refresh_token(credential_data)
+            
+            if should_refresh:
+                log.debug(f"Token需要刷新 - 文件: {current_file}")
+                refreshed_data = await self._refresh_token(credential_data, current_file)
+                if refreshed_data:
+                    credential_data = refreshed_data
+                    log.debug(f"Token刷新成功: {current_file}")
+                else:
+                    log.error(f"Token刷新失败: {current_file}")
+                    return None
+            
+            # 加载状态信息
+            state_data = await self._storage_adapter.get_credential_state(current_file)
+            
+            # 缓存当前凭证信息
+            self._current_credential_file = current_file
+            self._current_credential_data = credential_data
+            self._current_credential_state = state_data
+            
+            return current_file, credential_data
+            
+        except Exception as e:
+            log.error(f"Error loading current credential: {e}")
+            return None
+    
+    async def get_valid_credential(self) -> Optional[Tuple[str, Dict[str, Any]]]:
+        """获取有效的凭证，自动处理轮换和失效凭证切换"""
+        async with self._operation_lock:
+            if not self._credential_files:
+                await self._discover_credentials()
+                if not self._credential_files:
+                    return None
+            
+            # 检查是否需要轮换
+            if await self._should_rotate():
+                await self._rotate_credential()
+            
+            # 尝试获取有效凭证，如果失败则自动切换
+            max_attempts = len(self._credential_files)  # 最多尝试所有凭证
+            
+            for attempt in range(max_attempts):
+                try:
+                    # 加载当前凭证
+                    result = await self._load_current_credential()
+                    if result:
+                        return result
+                    
+                    # 当前凭证加载失败，标记为失效并切换到下一个
+                    current_file = self._credential_files[self._current_credential_index] if self._credential_files else None
+                    if current_file:
+                        log.warning(f"凭证失效，自动禁用并切换: {current_file}")
+                        await self.set_cred_disabled(current_file, True)
+                        
+                        # 重新发现可用凭证（排除刚禁用的）
+                        await self._discover_credentials()
+                        if not self._credential_files:
+                            log.error("没有可用的凭证")
+                            return None
+                        
+                        # 重置索引到第一个可用凭证
+                        self._current_credential_index = 0
+                        log.info(f"切换到下一个可用凭证 (索引: {self._current_credential_index})")
+                    else:
+                        log.error("无法获取当前凭证文件名")
+                        break
+                        
+                except Exception as e:
+                    log.error(f"获取凭证时发生异常 (尝试 {attempt + 1}/{max_attempts}): {e}")
+                    if attempt < max_attempts - 1:
+                        # 切换到下一个凭证继续尝试
+                        await self._rotate_credential()
+                    continue
+            
+            log.error(f"所有 {max_attempts} 个凭证都尝试失败")
+            return None
+    
+    async def _should_rotate(self) -> bool:
+        """检查是否需要轮换凭证"""
+        if not self._credential_files or len(self._credential_files) <= 1:
+            return False
+        
+        current_calls_per_rotation = await get_calls_per_rotation()
+        return self._call_count >= current_calls_per_rotation
+    
+    async def _rotate_credential(self):
+        """轮换到下一个凭证"""
+        if len(self._credential_files) <= 1:
+            return
+        
+        self._current_credential_index = (self._current_credential_index + 1) % len(self._credential_files)
+        self._call_count = 0
+        
+        log.info(f"Rotated to credential index {self._current_credential_index}")
+    
+    async def force_rotate_credential(self):
+        """强制轮换到下一个凭证（用于429错误处理）"""
+        async with self._operation_lock:
+            if len(self._credential_files) <= 1:
+                log.warning("Only one credential available, cannot rotate")
+                return
+            
+            await self._rotate_credential()
+            log.info("Forced credential rotation due to rate limit")
+    
+    def increment_call_count(self):
+        """增加调用计数"""
+        self._call_count += 1
+    
+    async def update_credential_state(self, credential_name: str, state_updates: Dict[str, Any]):
+        """更新凭证状态"""
+        try:
+            # 直接通过存储适配器更新状态
+            success = await self._storage_adapter.update_credential_state(credential_name, state_updates)
+            
+            # 如果是当前使用的凭证，更新缓存
+            if credential_name == self._current_credential_file:
+                self._current_credential_state.update(state_updates)
+            
+            if success:
+                log.debug(f"Updated credential state: {credential_name}")
+            else:
+                log.warning(f"Failed to update credential state: {credential_name}")
+                
+            return success
+            
+        except Exception as e:
+            log.error(f"Error updating credential state {credential_name}: {e}")
+            return False
+    
+    async def set_cred_disabled(self, credential_name: str, disabled: bool):
+        """设置凭证的启用/禁用状态"""
+        try:
+            state_updates = {"disabled": disabled}
+            success = await self.update_credential_state(credential_name, state_updates)
+            
+            if success:
+                # 如果禁用了当前正在使用的凭证，需要重新发现可用凭证
+                if disabled and credential_name == self._current_credential_file:
+                    await self._discover_credentials()
+                    if self._credential_files:
+                        await self._rotate_credential()
+                
+                action = "disabled" if disabled else "enabled"
+                log.info(f"Credential {action}: {credential_name}")
+            
+            return success
+            
+        except Exception as e:
+            log.error(f"Error setting credential disabled state {credential_name}: {e}")
+            return False
+    
+    async def get_creds_status(self) -> Dict[str, Dict[str, Any]]:
+        """获取所有凭证的状态"""
+        try:
+            # 从存储适配器获取所有状态
+            all_states = await self._storage_adapter.get_all_credential_states()
+            return all_states
+            
+        except Exception as e:
+            log.error(f"Error getting credential statuses: {e}")
+            return {}
+    
+    async def get_or_fetch_user_email(self, credential_name: str) -> Optional[str]:
+        """获取或获取用户邮箱地址"""
+        try:
+            # 首先检查缓存的状态
+            state = await self._storage_adapter.get_credential_state(credential_name)
+            cached_email = state.get("user_email")
+            
+            if cached_email:
+                return cached_email
+            
+            # 如果没有缓存，从凭证数据获取
+            credential_data = await self._storage_adapter.get_credential(credential_name)
+            if not credential_data:
+                return None
+            
+            # 尝试获取邮箱
+            email = await fetch_user_email_from_file(credential_data)
+            
+            if email:
+                # 缓存邮箱地址
+                await self.update_credential_state(credential_name, {"user_email": email})
+                return email
+            
+            return None
+            
+        except Exception as e:
+            log.error(f"Error fetching user email for {credential_name}: {e}")
+            return None
+    
+    async def record_api_call_result(self, credential_name: str, success: bool, error_code: Optional[int] = None):
+        """记录API调用结果"""
+        try:
+            state_updates = {}
+            
+            if success:
+                state_updates["last_success"] = time.time()
+                # 清除错误码（如果之前有的话）
+                state_updates["error_codes"] = []
+            elif error_code:
+                # 记录错误码
+                current_state = await self._storage_adapter.get_credential_state(credential_name)
+                error_codes = current_state.get("error_codes", [])
+                
+                if error_code not in error_codes:
+                    error_codes.append(error_code)
+                    # 限制错误码列表长度
+                    if len(error_codes) > 10:
+                        error_codes = error_codes[-10:]
+                    
+                state_updates["error_codes"] = error_codes
+            
+            if state_updates:
+                await self.update_credential_state(credential_name, state_updates)
+                
+        except Exception as e:
+            log.error(f"Error recording API call result for {credential_name}: {e}")
+    
+    # 原子操作支持
+    @asynccontextmanager
+    async def _atomic_operation(self, operation_name: str):
+        """原子操作上下文管理器"""
+        async with self._atomic_lock:
+            self._atomic_counter += 1
+            operation_id = self._atomic_counter
+            log.debug(f"开始原子操作[{operation_id}]: {operation_name}")
+            
+            try:
+                yield operation_id
+                log.debug(f"完成原子操作[{operation_id}]: {operation_name}")
+            except Exception as e:
+                log.error(f"原子操作[{operation_id}]失败: {operation_name} - {e}")
+                raise
+    
+    async def _should_refresh_token(self, credential_data: Dict[str, Any]) -> bool:
+        """检查token是否需要刷新"""
+        try:
+            # 如果没有access_token或过期时间，需要刷新
+            if not credential_data.get("access_token") and not credential_data.get("token"):
+                log.debug("没有access_token，需要刷新")
+                return True
+                
+            expiry_str = credential_data.get("expiry")
+            if not expiry_str:
+                log.debug("没有过期时间，需要刷新")
+                return True
+                
+            # 解析过期时间
+            try:
+                if isinstance(expiry_str, str):
+                    if "+" in expiry_str:
+                        file_expiry = datetime.fromisoformat(expiry_str)
+                    elif expiry_str.endswith("Z"):
+                        file_expiry = datetime.fromisoformat(expiry_str.replace('Z', '+00:00'))
+                    else:
+                        file_expiry = datetime.fromisoformat(expiry_str)
+                else:
+                    log.debug("过期时间格式无效，需要刷新")
+                    return True
+                    
+                # 确保时区信息
+                if file_expiry.tzinfo is None:
+                    file_expiry = file_expiry.replace(tzinfo=timezone.utc)
+                    
+                # 检查是否还有至少5分钟有效期
+                now = datetime.now(timezone.utc)
+                time_left = (file_expiry - now).total_seconds()
+                
+                log.debug(f"Token剩余时间: {int(time_left/60)}分钟")
+                
+                if time_left > 300:  # 5分钟缓冲
+                    return False
+                else:
+                    log.debug(f"Token即将过期（剩余{int(time_left/60)}分钟），需要刷新")
+                    return True
+                    
+            except Exception as e:
+                log.warning(f"解析过期时间失败: {e}，需要刷新")
+                return True
+                
+        except Exception as e:
+            log.error(f"检查token过期时出错: {e}")
+            return True
+    
+    async def _refresh_token(self, credential_data: Dict[str, Any], filename: str) -> Optional[Dict[str, Any]]:
+        """刷新token并更新存储"""
+        try:
+            # 创建Credentials对象
+            creds = Credentials.from_dict(credential_data)
+            
+            # 检查是否可以刷新
+            if not creds.refresh_token:
+                log.error(f"没有refresh_token，无法刷新: {filename}")
+                return None
+                
+            # 刷新token
+            log.debug(f"正在刷新token: {filename}")
+            await creds.refresh()
+            
+            # 更新凭证数据
+            if creds.access_token:
+                credential_data["access_token"] = creds.access_token
+                # 保持兼容性
+                credential_data["token"] = creds.access_token
+                
+            if creds.expires_at:
+                credential_data["expiry"] = creds.expires_at.isoformat()
+                
+            # 保存到存储
+            await self._storage_adapter.store_credential(filename, credential_data)
+            log.info(f"Token刷新成功并已保存: {filename}")
+            
+            return credential_data
+            
+        except Exception as e:
+            error_msg = str(e)
+            log.error(f"Token刷新失败 {filename}: {error_msg}")
+            
+            # 检查是否是凭证永久失效的错误
+            is_permanent_failure = self._is_permanent_refresh_failure(error_msg)
+            
+            if is_permanent_failure:
+                log.warning(f"检测到凭证永久失效: {filename}")
+                # 记录失效状态，但不在这里禁用凭证，让上层调用者处理
+                await self.record_api_call_result(filename, False, 400)
+            
+            return None
+    
+    def _is_permanent_refresh_failure(self, error_msg: str) -> bool:
+        """判断是否是凭证永久失效的错误"""
+        # 常见的永久失效错误模式
+        permanent_error_patterns = [
+            "400 Bad Request",
+            "invalid_grant",
+            "refresh_token_expired", 
+            "invalid_refresh_token",
+            "unauthorized_client",
+            "access_denied"
+        ]
+        
+        error_msg_lower = error_msg.lower()
+        for pattern in permanent_error_patterns:
+            if pattern.lower() in error_msg_lower:
+                return True
+                
+        return False
+
+    # 兼容性方法 - 保持与现有代码的接口兼容
+    async def _update_token_in_file(self, file_path: str, new_token: str, expires_at=None):
+        """更新凭证令牌（兼容性方法）"""
+        try:
+            credential_data = await self._storage_adapter.get_credential(file_path)
+            if not credential_data:
+                log.error(f"Credential not found for token update: {file_path}")
+                return False
+            
+            # 更新令牌数据
+            credential_data["token"] = new_token
+            if expires_at:
+                credential_data["expiry"] = expires_at.isoformat() if hasattr(expires_at, 'isoformat') else expires_at
+            
+            # 保存更新后的凭证
+            success = await self._storage_adapter.store_credential(file_path, credential_data)
+            
+            if success:
+                log.debug(f"Token updated for credential: {file_path}")
+            else:
+                log.error(f"Failed to update token for credential: {file_path}")
+            
+            return success
+            
+        except Exception as e:
+            log.error(f"Error updating token for {file_path}: {e}")
+            return False
+
+
+# 全局实例管理（保持兼容性）
+_credential_manager: Optional[CredentialManager] = None
+
+async def get_credential_manager() -> CredentialManager:
+    """获取全局凭证管理器实例"""
+    global _credential_manager
+    
+    if _credential_manager is None:
+        _credential_manager = CredentialManager()
+        await _credential_manager.initialize()
+    
+    return _credential_manager

src/format_detector.py

@@ -0,0 +1,172 @@
+"""
+Format detection utilities for supporting both OpenAI and Gemini request formats
+"""
+from typing import Dict, Any
+
+from log import log
+
+def detect_request_format(data: Dict[str, Any]) -> str:
+    """
+    Detect whether the request is in OpenAI or Gemini format.
+    
+    Returns:
+        "openai" or "gemini"
+    """
+    # OpenAI format indicators:
+    # - Has "messages" field with array of {role, content} objects
+    # - Role values are "system", "user", "assistant"
+    if "messages" in data and isinstance(data["messages"], list):
+        if data["messages"] and isinstance(data["messages"][0], dict):
+            # Check for OpenAI role values
+            first_role = data["messages"][0].get("role", "")
+            if first_role in ["system", "user", "assistant"]:
+                return "openai"
+    
+    # Gemini format indicators:
+    # - Has "contents" field with array of {role, parts} objects
+    # - Role values are "user", "model"
+    # - May have "systemInstruction" field
+    if "contents" in data and isinstance(data["contents"], list):
+        if data["contents"] and isinstance(data["contents"][0], dict):
+            # Check for Gemini structure
+            if "parts" in data["contents"][0]:
+                return "gemini"
+    
+    # Additional Gemini indicators
+    if "systemInstruction" in data or "generationConfig" in data:
+        return "gemini"
+    
+    # Default to OpenAI if unclear (for backwards compatibility)
+    log.debug(f"Unable to definitively detect format, defaulting to OpenAI. Keys present: {list(data.keys())}")
+    return "openai"
+
+def gemini_request_to_openai(gemini_request: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Convert a Gemini format request to OpenAI format.
+    
+    Args:
+        gemini_request: Request in Gemini API format
+        
+    Returns:
+        Dictionary in OpenAI API format
+    """
+    openai_request = {
+        "model": gemini_request.get("model", "gemini-2.5-pro"),
+        "messages": []
+    }
+    
+    # Convert system instruction if present
+    if "systemInstruction" in gemini_request:
+        system_content = ""
+        if isinstance(gemini_request["systemInstruction"], dict):
+            parts = gemini_request["systemInstruction"].get("parts", [])
+            for part in parts:
+                if "text" in part:
+                    system_content += part["text"]
+        elif isinstance(gemini_request["systemInstruction"], str):
+            system_content = gemini_request["systemInstruction"]
+        
+        if system_content:
+            openai_request["messages"].append({
+                "role": "system",
+                "content": system_content
+            })
+    
+    # Convert contents to messages
+    contents = gemini_request.get("contents", [])
+    for content in contents:
+        role = content.get("role", "user")
+        # Map Gemini roles to OpenAI roles
+        if role == "model":
+            role = "assistant"
+        
+        # Convert parts to content
+        parts = content.get("parts", [])
+        if len(parts) == 1 and "text" in parts[0]:
+            # Simple text message
+            openai_request["messages"].append({
+                "role": role,
+                "content": parts[0]["text"]
+            })
+        elif len(parts) > 0:
+            # Multi-part message (could include images)
+            content_parts = []
+            for part in parts:
+                if "text" in part:
+                    content_parts.append({
+                        "type": "text",
+                        "text": part["text"]
+                    })
+                elif "inlineData" in part:
+                    # Convert Gemini inline data to OpenAI image format
+                    inline_data = part["inlineData"]
+                    mime_type = inline_data.get("mimeType", "image/jpeg")
+                    data = inline_data.get("data", "")
+                    content_parts.append({
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:{mime_type};base64,{data}"
+                        }
+                    })
+            
+            if content_parts:
+                # If only one text part, use simple string format
+                if len(content_parts) == 1 and content_parts[0]["type"] == "text":
+                    openai_request["messages"].append({
+                        "role": role,
+                        "content": content_parts[0]["text"]
+                    })
+                else:
+                    openai_request["messages"].append({
+                        "role": role,
+                        "content": content_parts
+                    })
+    
+    # Convert generation config if present
+    if "generationConfig" in gemini_request:
+        config = gemini_request["generationConfig"]
+        if "temperature" in config:
+            openai_request["temperature"] = config["temperature"]
+        if "topP" in config:
+            openai_request["top_p"] = config["topP"]
+        if "topK" in config:
+            openai_request["top_k"] = config["topK"]
+        if "maxOutputTokens" in config:
+            openai_request["max_tokens"] = config["maxOutputTokens"]
+        if "stopSequences" in config:
+            openai_request["stop"] = config["stopSequences"]
+        if "frequencyPenalty" in config:
+            openai_request["frequency_penalty"] = config["frequencyPenalty"]
+        if "presencePenalty" in config:
+            openai_request["presence_penalty"] = config["presencePenalty"]
+        if "candidateCount" in config:
+            openai_request["n"] = config["candidateCount"]
+        if "seed" in config:
+            openai_request["seed"] = config["seed"]
+    
+    # Preserve stream setting if present
+    if "stream" in gemini_request:
+        openai_request["stream"] = gemini_request["stream"]
+    
+    return openai_request
+
+def validate_and_normalize_request(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate and normalize the request to OpenAI format.
+    Automatically detects format and converts if necessary.
+    
+    Args:
+        data: Raw request data
+        
+    Returns:
+        Normalized request in OpenAI format
+    """
+    format_type = detect_request_format(data)
+    log.info(f"Detected request format: {format_type}")
+    
+    if format_type == "gemini":
+        # Convert Gemini format to OpenAI format
+        return gemini_request_to_openai(data)
+    else:
+        # Already in OpenAI format
+        return data

src/gemini_router.py

@@ -0,0 +1,583 @@
+"""
+Gemini Router - Handles native Gemini format API requests
+处理原生Gemini格式请求的路由模块
+"""
+import asyncio
+import json
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Depends, Request, Path, Query, status, Header
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+from config import get_available_models, is_fake_streaming_model, is_anti_truncation_model, get_base_model_from_feature_model, get_anti_truncation_max_attempts, get_base_model_name
+from log import log
+from .anti_truncation import apply_anti_truncation_to_stream
+from .credential_manager import CredentialManager
+from .google_chat_api import send_gemini_request, build_gemini_payload_from_native
+from .openai_transfer import _extract_content_and_reasoning
+from .task_manager import create_managed_task
+# 创建路由器
+router = APIRouter()
+security = HTTPBearer()
+
+# 全局凭证管理器实例
+credential_manager = None
+
+@asynccontextmanager
+async def get_credential_manager():
+    """获取全局凭证管理器实例"""
+    global credential_manager
+    if not credential_manager:
+        credential_manager = CredentialManager()
+        await credential_manager.initialize()
+    yield credential_manager
+
+async def authenticate(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
+    """验证用户密码（Bearer Token方式）"""
+    from config import get_api_password
+    password = await get_api_password()
+    token = credentials.credentials
+    if token != password:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="密码错误")
+    return token
+
+async def authenticate_gemini_flexible(
+    request: Request,
+    x_goog_api_key: Optional[str] = Header(None, alias="x-goog-api-key"),
+    key: Optional[str] = Query(None),
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(lambda: None)
+) -> str:
+    """灵活验证：支持x-goog-api-key头部、URL参数key或Authorization Bearer"""
+    from config import get_api_password
+    password = await get_api_password()
+    
+    # 尝试从URL参数key获取（Google官方标准方式）
+    if key:
+        log.debug(f"Using URL parameter key authentication")
+        if key == password:
+            return key
+    
+    # 尝试从Authorization头获取（兼容旧方式）
+    auth_header = request.headers.get("authorization")
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header[7:]  # 移除 "Bearer " 前缀
+        log.debug(f"Using Bearer token authentication")
+        if token == password:
+            return token
+    
+    # 尝试从x-goog-api-key头获取（新标准方式）
+    if x_goog_api_key:
+        log.debug(f"Using x-goog-api-key authentication")
+        if x_goog_api_key == password:
+            return x_goog_api_key
+    
+    log.error(f"Authentication failed. Headers: {dict(request.headers)}, Query params: key={key}")
+    raise HTTPException(
+        status_code=status.HTTP_400_BAD_REQUEST, 
+        detail="Missing or invalid authentication. Use 'key' URL parameter, 'x-goog-api-key' header, or 'Authorization: Bearer <token>'"
+    )
+
+@router.get("/v1/v1beta/models")
+@router.get("/v1/v1/models")
+@router.get("/v1beta/models")
+@router.get("/v1/models")
+async def list_gemini_models():
+    """返回Gemini格式的模型列表"""
+    models = get_available_models("gemini")
+    
+    # 构建符合Gemini API格式的模型列表
+    gemini_models = []
+    for model_name in models:
+        # 获取基础模型名
+        base_model = get_base_model_from_feature_model(model_name)
+        
+        model_info = {
+            "name": f"models/{model_name}",
+            "baseModelId": base_model,
+            "version": "001",
+            "displayName": model_name,
+            "description": f"Gemini {base_model} model",
+            "inputTokenLimit": 1000000,
+            "outputTokenLimit": 8192,
+            "supportedGenerationMethods": ["generateContent", "streamGenerateContent"],
+            "temperature": 1.0,
+            "maxTemperature": 2.0,
+            "topP": 0.95,
+            "topK": 64
+        }
+        gemini_models.append(model_info)
+    
+    return JSONResponse(content={
+        "models": gemini_models
+    })
+
+@router.post("/v1/v1beta/models/{model:path}:generateContent")
+@router.post("/v1/v1/models/{model:path}:generateContent")
+@router.post("/v1beta/models/{model:path}:generateContent")
+@router.post("/v1/models/{model:path}:generateContent")
+async def generate_content(
+    model: str = Path(..., description="Model name"),
+    request: Request = None,
+    api_key: str = Depends(authenticate_gemini_flexible)
+):
+    """处理Gemini格式的内容生成请求（非流式）"""
+    
+    
+    # 获取原始请求数据
+    try:
+        request_data = await request.json()
+    except Exception as e:
+        log.error(f"Failed to parse JSON request: {e}")
+        raise HTTPException(status_code=400, detail=f"Invalid JSON: {str(e)}")
+    
+    # 验证必要字段
+    if "contents" not in request_data or not request_data["contents"]:
+        raise HTTPException(status_code=400, detail="Missing required field: contents")
+    
+    # 请求预处理：限制参数
+    if "generationConfig" in request_data and request_data["generationConfig"]:
+        generation_config = request_data["generationConfig"]
+        
+        # 限制max_tokens (在Gemini中叫maxOutputTokens)
+        if "maxOutputTokens" in generation_config and generation_config["maxOutputTokens"] is not None:
+            if generation_config["maxOutputTokens"] > 65535:
+                generation_config["maxOutputTokens"] = 65535
+                
+        # 覆写 top_k 为 64 (在Gemini中叫topK)
+        generation_config["topK"] = 64
+    else:
+        # 如果没有generationConfig，创建一个并设置topK
+        request_data["generationConfig"] = {"topK": 64}
+    
+    # 处理模型名称和功能检测
+    use_anti_truncation = is_anti_truncation_model(model)
+    
+    # 获取基础模型名
+    real_model = get_base_model_from_feature_model(model)
+    
+    # 对于假流式模型，如果是流式端点才返回假流式响应
+    # 注意：这是generateContent端点，不应该触发假流式
+    
+    # 对于抗截断模型的非流式请求，给出警告
+    if use_anti_truncation:
+        log.warning("抗截断功能仅在流式传输时有效，非流式请求将忽略此设置")
+    
+    # 健康检查
+    if (len(request_data["contents"]) == 1 and 
+        request_data["contents"][0].get("role") == "user" and
+        request_data["contents"][0].get("parts", [{}])[0].get("text") == "Hi"):
+        return JSONResponse(content={
+            "candidates": [{
+                "content": {
+                    "parts": [{"text": "gcli2api工作中"}],
+                    "role": "model"
+                },
+                "finishReason": "STOP",
+                "index": 0
+            }]
+        })
+    
+    # 获取凭证管理器
+    from src.credential_manager import get_credential_manager
+    cred_mgr = await get_credential_manager()
+    
+    # 获取有效凭证
+    credential_result = await cred_mgr.get_valid_credential()
+    if not credential_result:
+        log.error("当前无可用凭证，请去控制台获取")
+        raise HTTPException(status_code=500, detail="当前无可用凭证，请去控制台获取")
+    
+    # 增加调用计数
+    cred_mgr.increment_call_count()
+    
+    # 构建Google API payload
+    try:
+        api_payload = build_gemini_payload_from_native(request_data, real_model)
+    except Exception as e:
+        log.error(f"Gemini payload build failed: {e}")
+        raise HTTPException(status_code=500, detail="Request processing failed")
+    
+    # 发送请求（429重试已在google_api_client中处理）
+    response = await send_gemini_request(api_payload, False, cred_mgr)
+    
+    # 处理响应
+    try:
+        if hasattr(response, 'body'):
+            response_data = json.loads(response.body.decode() if isinstance(response.body, bytes) else response.body)
+        elif hasattr(response, 'content'):
+            response_data = json.loads(response.content.decode() if isinstance(response.content, bytes) else response.content)
+        else:
+            response_data = json.loads(str(response))
+        
+        return JSONResponse(content=response_data)
+        
+    except Exception as e:
+        log.error(f"Response processing failed: {e}")
+        # 返回原始响应
+        if hasattr(response, 'content'):
+            return JSONResponse(content=json.loads(response.content))
+        else:
+            raise HTTPException(status_code=500, detail="Response processing failed")
+
+@router.post("/v1/v1beta/models/{model:path}:streamGenerateContent")
+@router.post("/v1/v1/models/{model:path}:streamGenerateContent")
+@router.post("/v1beta/models/{model:path}:streamGenerateContent")
+@router.post("/v1/models/{model:path}:streamGenerateContent")
+async def stream_generate_content(
+    model: str = Path(..., description="Model name"),
+    request: Request = None,
+    api_key: str = Depends(authenticate_gemini_flexible)
+):
+    """处理Gemini格式的流式内容生成请求"""
+    log.debug(f"Stream request received for model: {model}")
+    log.debug(f"Request headers: {dict(request.headers)}")
+    log.debug(f"API key received: {api_key[:10] if api_key else None}...")
+    try:
+        body = await request.body()
+        log.debug(f"request body: {body.decode() if isinstance(body, bytes) else body}")
+    except Exception as e:
+        log.error(f"Failed to read request body: {e}")
+
+
+    # 获取原始请求数据
+    try:
+        request_data = await request.json()
+    except Exception as e:
+        log.error(f"Failed to parse JSON request: {e}")
+        raise HTTPException(status_code=400, detail=f"Invalid JSON: {str(e)}")
+    
+    # 验���必要字段
+    if "contents" not in request_data or not request_data["contents"]:
+        raise HTTPException(status_code=400, detail="Missing required field: contents")
+    
+    # 请求预处理：限制参数
+    if "generationConfig" in request_data and request_data["generationConfig"]:
+        generation_config = request_data["generationConfig"]
+        
+        # 限制max_tokens (在Gemini中叫maxOutputTokens)
+        if "maxOutputTokens" in generation_config and generation_config["maxOutputTokens"] is not None:
+            if generation_config["maxOutputTokens"] > 65535:
+                generation_config["maxOutputTokens"] = 65535
+                
+        # 覆写 top_k 为 64 (在Gemini中叫topK)
+        generation_config["topK"] = 64
+    else:
+        # 如果没有generationConfig，创建一个并设置topK
+        request_data["generationConfig"] = {"topK": 64}
+    
+    # 处理模型名称和功能检测
+    use_fake_streaming = is_fake_streaming_model(model)
+    use_anti_truncation = is_anti_truncation_model(model)
+    
+    # 获取基础模型名
+    real_model = get_base_model_from_feature_model(model)
+    
+    # 对于假流式模型，返回假流式响应
+    if use_fake_streaming:
+        return await fake_stream_response_gemini(request_data, real_model)
+    
+    # 获取凭证管理器
+    from src.credential_manager import get_credential_manager
+    cred_mgr = await get_credential_manager()
+    
+    # 获取有效凭证
+    credential_result = await cred_mgr.get_valid_credential()
+    if not credential_result:
+        log.error("当前无可用凭证，请去控制台获取")
+        raise HTTPException(status_code=500, detail="当前无可用凭证，请去控制台获取")
+    
+    # 增加调用计数
+    cred_mgr.increment_call_count()
+    
+    # 构建Google API payload
+    try:
+        api_payload = build_gemini_payload_from_native(request_data, real_model)
+    except Exception as e:
+        log.error(f"Gemini payload build failed: {e}")
+        raise HTTPException(status_code=500, detail="Request processing failed")
+    
+    # 处理抗截断功能（仅流式传输时有效）
+    if use_anti_truncation:
+        log.info("启用流式抗截断功能")
+        # 使用流式抗截断处理器
+        max_attempts = await get_anti_truncation_max_attempts()
+        return await apply_anti_truncation_to_stream(
+            lambda payload: send_gemini_request(payload, True, cred_mgr),
+            api_payload,
+            max_attempts
+        )
+    
+    # 常规流式请求（429重试已在google_api_client中处理）
+    response = await send_gemini_request(api_payload, True, cred_mgr)
+    
+    # 直接返回流式响应
+    return response
+    
+@router.post("/v1/v1beta/models/{model:path}:countTokens")
+@router.post("/v1/v1/models/{model:path}:countTokens")
+@router.post("/v1beta/models/{model:path}:countTokens")
+@router.post("/v1/models/{model:path}:countTokens")
+async def count_tokens(
+    request: Request = None,
+    api_key: str = Depends(authenticate_gemini_flexible)
+):
+    """模拟Gemini格式的token计数"""
+    
+    try:
+        request_data = await request.json()
+    except Exception as e:
+        log.error(f"Failed to parse JSON request: {e}")
+        raise HTTPException(status_code=400, detail=f"Invalid JSON: {str(e)}")
+    
+    # 简单的token计数模拟 - 基于文本长度估算
+    total_tokens = 0
+    
+    # 如果有contents字段
+    if "contents" in request_data:
+        for content in request_data["contents"]:
+            if "parts" in content:
+                for part in content["parts"]:
+                    if "text" in part:
+                        # 简单估算：大约4字符=1token
+                        text_length = len(part["text"])
+                        total_tokens += max(1, text_length // 4)
+    
+    # 如果有generateContentRequest字段
+    elif "generateContentRequest" in request_data:
+        gen_request = request_data["generateContentRequest"]
+        if "contents" in gen_request:
+            for content in gen_request["contents"]:
+                if "parts" in content:
+                    for part in content["parts"]:
+                        if "text" in part:
+                            text_length = len(part["text"])
+                            total_tokens += max(1, text_length // 4)
+    
+    # 返回Gemini格式的响应
+    return JSONResponse(content={
+        "totalTokens": total_tokens
+    })
+
+@router.get("/v1/v1beta/models/{model:path}")
+@router.get("/v1/v1/models/{model:path}")
+@router.get("/v1beta/models/{model:path}")
+@router.get("/v1/models/{model:path}")
+async def get_model_info(
+    model: str = Path(..., description="Model name"),
+    api_key: str = Depends(authenticate_gemini_flexible)
+):
+    """获取特定模型的信息"""
+    
+    # 获取基础模型名称
+    base_model = get_base_model_name(model)
+    
+    # 模拟模型信息
+    model_info = {
+        "name": f"models/{base_model}",
+        "baseModelId": base_model,
+        "version": "001",
+        "displayName": base_model,
+        "description": f"Gemini {base_model} model",
+        "inputTokenLimit": 128000,
+        "outputTokenLimit": 8192,
+        "supportedGenerationMethods": [
+            "generateContent",
+            "streamGenerateContent"
+        ],
+        "temperature": 1.0,
+        "maxTemperature": 2.0,
+        "topP": 0.95,
+        "topK": 64
+    }
+    
+    return JSONResponse(content=model_info)
+
+async def fake_stream_response_gemini(request_data: dict, model: str):
+    """处理Gemini格式的假流式响应"""
+    
+    async def gemini_stream_generator():
+        try:
+            # 获取凭证管理器
+            from src.credential_manager import get_credential_manager
+            cred_mgr = await get_credential_manager()
+            
+            # 获取有效凭证
+            credential_result = await cred_mgr.get_valid_credential()
+            if not credential_result:
+                log.error("当前无可用凭证，请去控制台获取")
+                error_chunk = {
+                    "error": {
+                        "message": "当前无凭证，请去控制台获取",
+                        "type": "authentication_error",
+                        "code": 500
+                    }
+                }
+                yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+                yield "data: [DONE]\n\n".encode()
+                return
+            
+            # 增加调用计数
+            cred_mgr.increment_call_count()
+            
+            # 构建Google API payload
+            try:
+                api_payload = build_gemini_payload_from_native(request_data, model)
+            except Exception as e:
+                log.error(f"Gemini payload build failed: {e}")
+                error_chunk = {
+                    "error": {
+                        "message": f"Request processing failed: {str(e)}",
+                        "type": "api_error",
+                        "code": 500
+                    }
+                }
+                yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+                yield "data: [DONE]\n\n".encode()
+                return
+            
+            # 发送心跳
+            heartbeat = {
+                "candidates": [{
+                    "content": {
+                        "parts": [{"text": ""}],
+                        "role": "model"
+                    },
+                    "finishReason": None,
+                    "index": 0
+                }]
+            }
+            yield f"data: {json.dumps(heartbeat)}\n\n".encode()
+            
+            # 异步发送实际请求
+            async def get_response():
+                return await send_gemini_request(api_payload, False, cred_mgr)
+            
+            # 创建请求任务
+            response_task = create_managed_task(get_response(), name="gemini_fake_stream_request")
+            
+            try:
+                # 每3秒发送一次心跳，直到收到响应
+                while not response_task.done():
+                    await asyncio.sleep(3.0)
+                    if not response_task.done():
+                        yield f"data: {json.dumps(heartbeat)}\n\n".encode()
+                
+                # 获取响应结果
+                response = await response_task
+
+            except asyncio.CancelledError:
+                # 取消任务并传播取消
+                response_task.cancel()
+                try:
+                    await response_task
+                except asyncio.CancelledError:
+                    pass
+                raise
+            except Exception as e:
+                # 取消任务并处理其他异常
+                response_task.cancel()
+                try:
+                    await response_task
+                except asyncio.CancelledError:
+                    pass
+                log.error(f"Fake streaming request failed: {e}")
+                raise
+
+            # 发送实际请求
+            # response 已在上面获取
+
+            # 处理结果
+            try:
+                if hasattr(response, 'body'):
+                    response_data = json.loads(response.body.decode() if isinstance(response.body, bytes) else response.body)
+                elif hasattr(response, 'content'):
+                    response_data = json.loads(response.content.decode() if isinstance(response.content, bytes) else response.content)
+                else:
+                    response_data = json.loads(str(response))
+                
+                log.debug(f"Gemini fake stream response data: {response_data}")
+                
+                # 发送完整内容作为单个chunk，使用思维链分离
+                if "candidates" in response_data and response_data["candidates"]:
+                    candidate = response_data["candidates"][0]
+                    if "content" in candidate and "parts" in candidate["content"]:
+                        parts = candidate["content"]["parts"]
+                        content, reasoning_content = _extract_content_and_reasoning(parts)
+                        log.debug(f"Gemini extracted content: {content}")
+                        log.debug(f"Gemini extracted reasoning: {reasoning_content[:100] if reasoning_content else 'None'}...")
+                        
+                        # 如果没有正常内容但有思维内容
+                        if not content and reasoning_content:
+                            log.warning(f"Gemini fake stream contains only thinking content: {reasoning_content[:100]}...")
+                            content = "[模型正在思考中，请稍后再试或重新提问]"
+                        
+                        if content:
+                            # 构建包含分离内容的响应
+                            parts_response = [{"text": content}]
+                            if reasoning_content:
+                                parts_response.append({"text": reasoning_content, "thought": True})
+                            
+                            content_chunk = {
+                                "candidates": [{
+                                    "content": {
+                                        "parts": parts_response,
+                                        "role": "model"
+                                    },
+                                    "finishReason": candidate.get("finishReason", "STOP"),
+                                    "index": 0
+                                }]
+                            }
+                            yield f"data: {json.dumps(content_chunk)}\n\n".encode()
+                        else:
+                            log.warning(f"No content found in Gemini candidate: {candidate}")
+                            # 提供默认回复
+                            error_chunk = {
+                                "candidates": [{
+                                    "content": {
+                                        "parts": [{"text": "[响应为空，请重新尝试]"}],
+                                        "role": "model"
+                                    },
+                                    "finishReason": "STOP",
+                                    "index": 0
+                                }]
+                            }
+                            yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+                    else:
+                        log.warning(f"No content/parts found in Gemini candidate: {candidate}")
+                        # 返回原始响应
+                        yield f"data: {json.dumps(response_data)}\n\n".encode()
+                else:
+                    log.warning(f"No candidates found in Gemini response: {response_data}")
+                    yield f"data: {json.dumps(response_data)}\n\n".encode()
+                
+            except Exception as e:
+                log.error(f"Response parsing failed: {e}")
+                error_chunk = {
+                    "candidates": [{
+                        "content": {
+                            "parts": [{"text": f"Response parsing error: {str(e)}"}],
+                            "role": "model"
+                        },
+                        "finishReason": "ERROR",
+                        "index": 0
+                    }]
+                }
+                yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+            
+            yield "data: [DONE]\n\n".encode()
+                
+        except Exception as e:
+            log.error(f"Fake streaming error: {e}")
+            error_chunk = {
+                "error": {
+                    "message": f"Fake streaming error: {str(e)}",
+                    "type": "api_error", 
+                    "code": 500
+                }
+            }
+            yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+            yield "data: [DONE]\n\n".encode()
+
+    return StreamingResponse(gemini_stream_generator(), media_type="text/event-stream")

src/google_chat_api.py

@@ -0,0 +1,535 @@
+"""
+Google API Client - Handles all communication with Google's Gemini API.
+This module is used by both OpenAI compatibility layer and native Gemini endpoints.
+"""
+import asyncio
+import gc
+import json
+
+from fastapi import Response
+from fastapi.responses import StreamingResponse
+
+from config import (
+    get_code_assist_endpoint,
+    DEFAULT_SAFETY_SETTINGS,
+    get_base_model_name,
+    get_thinking_budget,
+    should_include_thoughts,
+    is_search_model,
+    get_auto_ban_enabled,
+    get_auto_ban_error_codes,
+    get_retry_429_max_retries,
+    get_retry_429_enabled,
+    get_retry_429_interval
+)
+from .httpx_client import http_client, create_streaming_client_with_kwargs
+from log import log
+from .credential_manager import CredentialManager
+from .usage_stats import record_successful_call
+from .utils import get_user_agent
+
+def _create_error_response(message: str, status_code: int = 500) -> Response:
+    """Create standardized error response."""
+    return Response(
+        content=json.dumps({
+            "error": {
+                "message": message,
+                "type": "api_error",
+                "code": status_code
+            }
+        }),
+        status_code=status_code,
+        media_type="application/json"
+    )
+
+async def _handle_api_error(credential_manager: CredentialManager, status_code: int, response_content: str = ""):
+    """Handle API errors by rotating credentials when needed. Error recording should be done before calling this function."""
+    if status_code == 429 and credential_manager:
+        if response_content:
+            log.error(f"Google API returned status 429 - quota exhausted. Response details: {response_content[:500]}")
+        else:
+            log.error("Google API returned status 429 - quota exhausted, switching credentials")
+        await credential_manager.force_rotate_credential()
+    
+    # 处理自动封禁的错误码
+    elif await get_auto_ban_enabled() and status_code in await get_auto_ban_error_codes() and credential_manager:
+        if response_content:
+            log.error(f"Google API returned status {status_code} - auto ban triggered. Response details: {response_content[:500]}")
+        else:
+            log.warning(f"Google API returned status {status_code} - auto ban triggered, rotating credentials")
+        await credential_manager.force_rotate_credential()
+
+async def _prepare_request_headers_and_payload(payload: dict, credential_data: dict):
+    """Prepare request headers and final payload from credential data."""
+    # 尝试获取token，支持多种字段名
+    token = credential_data.get('token') or credential_data.get('access_token', '')
+    
+    if not token:
+        raise Exception("凭证中没有找到有效的访问令牌（token或access_token字段）")
+    
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+        "User-Agent": get_user_agent(),
+    }
+
+    # 直接使用凭证数据中的项目ID
+    project_id = credential_data.get("project_id", "")
+    if not project_id:
+        raise Exception("项目ID不存在于凭证数据中")
+
+    final_payload = {
+        "model": payload.get("model"),
+        "project": project_id,
+        "request": payload.get("request", {})
+    }
+    
+    return headers, final_payload
+
+async def send_gemini_request(payload: dict, is_streaming: bool = False, credential_manager: CredentialManager = None) -> Response:
+    """
+    Send a request to Google's Gemini API.
+    
+    Args:
+        payload: The request payload in Gemini format
+        is_streaming: Whether this is a streaming request
+        credential_manager: CredentialManager instance
+        
+    Returns:
+        FastAPI Response object
+    """
+    # 获取429重试配置
+    max_retries = await get_retry_429_max_retries()
+    retry_429_enabled = await get_retry_429_enabled()
+    retry_interval = await get_retry_429_interval()
+    
+    # 确定API端点
+    action = "streamGenerateContent" if is_streaming else "generateContent"
+    target_url = f"{await get_code_assist_endpoint()}/v1internal:{action}"
+    if is_streaming:
+        target_url += "?alt=sse"
+
+    # 确保有credential_manager
+    if not credential_manager:
+        return _create_error_response("Credential manager not provided", 500)
+    
+    # 获取当前凭证
+    try:
+        credential_result = await credential_manager.get_valid_credential()
+        if not credential_result:
+            return _create_error_response("No valid credentials available", 500)
+        
+        current_file, credential_data = credential_result
+        headers, final_payload = await _prepare_request_headers_and_payload(payload, credential_data)
+    except Exception as e:
+        return _create_error_response(str(e), 500)
+
+    # 预序列化payload，避免重试时重复序列化
+    final_post_data = json.dumps(final_payload)
+    
+    # Debug日志：打印请求体结构
+    log.debug(f"Final request payload structure: {json.dumps(final_payload, ensure_ascii=False, indent=2)}")
+
+    for attempt in range(max_retries + 1):
+        try:
+            if is_streaming:
+                # 流式请求处理 - 使用httpx_client模块的统一配置
+                client = await create_streaming_client_with_kwargs()
+                
+                try:
+                    # 使用stream方法但不在async with块中消费数据
+                    stream_ctx = client.stream("POST", target_url, content=final_post_data, headers=headers)
+                    resp = await stream_ctx.__aenter__()
+                    
+                    if resp.status_code == 429:
+                        # 记录429错误并获取响应内容
+                        response_content = ""
+                        try:
+                            content_bytes = await resp.aread()
+                            if isinstance(content_bytes, bytes):
+                                response_content = content_bytes.decode('utf-8', errors='ignore')
+                        except Exception as e:
+                            log.debug(f"[STREAMING] Failed to read 429 response content: {e}")
+                        
+                        # 显示详细的429错误信息
+                        if response_content:
+                            log.error(f"Google API returned status 429 (STREAMING). Response details: {response_content[:500]}")
+                        else:
+                            log.error("Google API returned status 429 (STREAMING) - quota exhausted, no response details available")
+                        
+                        if credential_manager and current_file:
+                            await credential_manager.record_api_call_result(current_file, False, 429)
+                        
+                        # 清理资源
+                        try:
+                            await stream_ctx.__aexit__(None, None, None)
+                        except:
+                            pass
+                        await client.aclose()
+                        
+                        # 如果重试可用且未达到最大次数，进行重试
+                        if retry_429_enabled and attempt < max_retries:
+                            log.warning(f"[RETRY] 429 error encountered, retrying ({attempt + 1}/{max_retries})")
+                            if credential_manager:
+                                # 429错误时强制轮换凭证，不增加调用计数
+                                await credential_manager.force_rotate_credential()
+                                # 重新获取凭证和headers（凭证可能已轮换）
+                                new_credential_result = await credential_manager.get_valid_credential()
+                                if new_credential_result:
+                                    current_file, credential_data = new_credential_result
+                                    headers, updated_payload = await _prepare_request_headers_and_payload(payload, credential_data)
+                                    final_post_data = json.dumps(updated_payload)
+                            await asyncio.sleep(retry_interval)
+                            continue  # 跳出内层处理，继续外层循环重试
+                        else:
+                            # 返回429错误流
+                            async def error_stream():
+                                error_response = {
+                                    "error": {
+                                        "message": "429 rate limit exceeded, max retries reached",
+                                        "type": "api_error",
+                                        "code": 429
+                                    }
+                                }
+                                yield f"data: {json.dumps(error_response)}\n\n"
+                            return StreamingResponse(error_stream(), media_type="text/event-stream", status_code=429)
+                    elif resp.status_code != 200:
+                        # 处理其他非200状态码的错误
+                        response_content = ""
+                        try:
+                            content_bytes = await resp.aread()
+                            if isinstance(content_bytes, bytes):
+                                response_content = content_bytes.decode('utf-8', errors='ignore')
+                        except Exception as e:
+                            log.debug(f"[STREAMING] Failed to read error response content: {e}")
+                        
+                        # 显示详细的错误信息
+                        if response_content:
+                            log.error(f"Google API returned status {resp.status_code} (STREAMING). Response details: {response_content[:500]}")
+                        else:
+                            log.error(f"Google API returned status {resp.status_code} (STREAMING) - no response details available")
+                        
+                        # 记录API调用错误
+                        if credential_manager and current_file:
+                            await credential_manager.record_api_call_result(current_file, False, resp.status_code)
+                        
+                        # 清理资源
+                        try:
+                            await stream_ctx.__aexit__(None, None, None)
+                        except:
+                            pass
+                        await client.aclose()
+                        
+                        # 处理凭证轮换
+                        await _handle_api_error(credential_manager, resp.status_code, response_content)
+                        
+                        # 返回错误流
+                        async def error_stream():
+                            error_response = {
+                                "error": {
+                                    "message": f"API error: {resp.status_code}",
+                                    "type": "api_error", 
+                                    "code": resp.status_code
+                                }
+                            }
+                            yield f"data: {json.dumps(error_response)}\n\n"
+                        return StreamingResponse(error_stream(), media_type="text/event-stream", status_code=resp.status_code)
+                    else:
+                        # 成功响应，传递所有资源给流式处理函数管理
+                        return _handle_streaming_response_managed(resp, stream_ctx, client, credential_manager, payload.get("model", ""), current_file)
+                        
+                except Exception as e:
+                    # 清理资源
+                    try:
+                        await client.aclose()
+                    except:
+                        pass
+                    raise e
+
+            else:
+                # 非流式请求处理 - 使用httpx_client模块
+                async with http_client.get_client(timeout=None) as client:
+                    resp = await client.post(
+                        target_url, content=final_post_data, headers=headers
+                    )
+                    
+                    if resp.status_code == 429:
+                        # 记录429错误
+                        if credential_manager and current_file:
+                            await credential_manager.record_api_call_result(current_file, False, 429)
+                        
+                        # 如果重试可用且未达到最大次数，继续重试
+                        if retry_429_enabled and attempt < max_retries:
+                            log.warning(f"[RETRY] 429 error encountered, retrying ({attempt + 1}/{max_retries})")
+                            if credential_manager:
+                                # 429错误时强制轮换凭证，不增加调用计数
+                                await credential_manager.force_rotate_credential()
+                                # 重新获取凭证和headers（凭证可能已轮换）
+                                new_credential_result = await credential_manager.get_valid_credential()
+                                if new_credential_result:
+                                    current_file, credential_data = new_credential_result
+                                    headers, updated_payload = await _prepare_request_headers_and_payload(payload, credential_data)
+                                    final_post_data = json.dumps(updated_payload)
+                            await asyncio.sleep(retry_interval)
+                            continue
+                        else:
+                            log.error(f"[RETRY] Max retries exceeded for 429 error")
+                            return _create_error_response("429 rate limit exceeded, max retries reached", 429)
+                    else:
+                        # 非429错误或成功响应，正常处理
+                        return await _handle_non_streaming_response(resp, credential_manager, payload.get("model", ""), current_file)
+                    
+        except Exception as e:
+            if attempt < max_retries:
+                log.warning(f"[RETRY] Request failed with exception, retrying ({attempt + 1}/{max_retries}): {str(e)}")
+                await asyncio.sleep(retry_interval)
+                continue
+            else:
+                log.error(f"Request to Google API failed: {str(e)}")
+                return _create_error_response(f"Request failed: {str(e)}")
+    
+    # 如果循环结束仍未成功，返回错误
+    return _create_error_response("Max retries exceeded", 429)
+
+
+def _handle_streaming_response_managed(resp, stream_ctx, client, credential_manager: CredentialManager = None, model_name: str = "", current_file: str = None) -> StreamingResponse:
+    """Handle streaming response with complete resource lifecycle management."""
+    
+    # 检查HTTP错误
+    if resp.status_code != 200:
+        # 立即清理资源并返回错误
+        async def cleanup_and_error():
+            try:
+                await stream_ctx.__aexit__(None, None, None)
+            except:
+                pass
+            try:
+                await client.aclose()
+            except:
+                pass
+            
+            # 获取响应内容用于详细错误显示
+            response_content = ""
+            try:
+                content_bytes = await resp.aread()
+                if isinstance(content_bytes, bytes):
+                    response_content = content_bytes.decode('utf-8', errors='ignore')
+            except Exception as e:
+                log.debug(f"[STREAMING] Failed to read response content for error analysis: {e}")
+                response_content = ""
+            
+            # 显示详细错误信息
+            if resp.status_code == 429:
+                if response_content:
+                    log.error(f"Google API returned status 429 (STREAMING). Response details: {response_content[:500]}")
+                else:
+                    log.error(f"Google API returned status 429 (STREAMING)")
+            else:
+                if response_content:
+                    log.error(f"Google API returned status {resp.status_code} (STREAMING). Response details: {response_content[:500]}")
+                else:
+                    log.error(f"Google API returned status {resp.status_code} (STREAMING)")
+            
+            # 记录API调用错误
+            if credential_manager and current_file:
+                await credential_manager.record_api_call_result(current_file, False, resp.status_code)
+            
+            await _handle_api_error(credential_manager, resp.status_code, response_content)
+            
+            error_response = {
+                "error": {
+                    "message": f"API error: {resp.status_code}",
+                    "type": "api_error",
+                    "code": resp.status_code
+                }
+            }
+            yield f'data: {json.dumps(error_response)}\n\n'.encode('utf-8')
+        
+        return StreamingResponse(
+            cleanup_and_error(),
+            media_type="text/event-stream",
+            status_code=resp.status_code
+        )
+    
+    # 正常流式响应处理，确保资源在流结束时被清理
+    async def managed_stream_generator():
+        success_recorded = False
+        managed_stream_generator._chunk_count = 0  # 初始化chunk计数器
+        try:
+            async for chunk in resp.aiter_lines():
+                if not chunk or not chunk.startswith('data: '):
+                    continue
+                    
+                # 记录第一次成功响应
+                if not success_recorded:
+                    if current_file and credential_manager:
+                        await credential_manager.record_api_call_result(current_file, True)
+                        # 记录到使用统计
+                        try:
+                            await record_successful_call(current_file, model_name)
+                        except Exception as e:
+                            log.debug(f"Failed to record usage statistics: {e}")
+                    success_recorded = True
+                
+                payload = chunk[len('data: '):]
+                try:
+                    obj = json.loads(payload)
+                    if "response" in obj:
+                        data = obj["response"]
+                        yield f"data: {json.dumps(data, separators=(',',':'))}\n\n".encode()
+                        await asyncio.sleep(0)  # 让其他协程有机会运行
+                        
+                        # 定期释放内存（每100个chunk）
+                        if hasattr(managed_stream_generator, '_chunk_count'):
+                            managed_stream_generator._chunk_count += 1
+                            if managed_stream_generator._chunk_count % 100 == 0:
+                                gc.collect()
+                    else:
+                        yield f"data: {json.dumps(obj, separators=(',',':'))}\n\n".encode()
+                except json.JSONDecodeError:
+                    continue
+                    
+        except Exception as e:
+            log.error(f"Streaming error: {e}")
+            err = {"error": {"message": str(e), "type": "api_error", "code": 500}}
+            yield f"data: {json.dumps(err)}\n\n".encode()
+        finally:
+            # 确保清理所有资源
+            try:
+                await stream_ctx.__aexit__(None, None, None)
+            except Exception as e:
+                log.debug(f"Error closing stream context: {e}")
+            try:
+                await client.aclose()
+            except Exception as e:
+                log.debug(f"Error closing client: {e}")
+
+    return StreamingResponse(
+        managed_stream_generator(),
+        media_type="text/event-stream"
+    )
+
+async def _handle_non_streaming_response(resp, credential_manager: CredentialManager = None, model_name: str = "", current_file: str = None) -> Response:
+    """Handle non-streaming response from Google API."""
+    if resp.status_code == 200:
+        try:
+            # 记录成功响应
+            if current_file and credential_manager:
+                await credential_manager.record_api_call_result(current_file, True)
+                # 记录到使用统计
+                try:
+                    await record_successful_call(current_file, model_name)
+                except Exception as e:
+                    log.debug(f"Failed to record usage statistics: {e}")
+            
+            raw = await resp.aread()
+            google_api_response = raw.decode('utf-8')
+            if google_api_response.startswith('data: '):
+                google_api_response = google_api_response[len('data: '):]
+            google_api_response = json.loads(google_api_response)
+            log.debug(f"Google API原始响应: {json.dumps(google_api_response, ensure_ascii=False)[:500]}...")
+            standard_gemini_response = google_api_response.get("response")
+            log.debug(f"提取的response字段: {json.dumps(standard_gemini_response, ensure_ascii=False)[:500]}...")
+            return Response(
+                content=json.dumps(standard_gemini_response),
+                status_code=200,
+                media_type="application/json; charset=utf-8"
+            )
+        except Exception as e:
+            log.error(f"Failed to parse Google API response: {str(e)}")
+            return Response(
+                content=resp.content,
+                status_code=resp.status_code,
+                media_type=resp.headers.get("Content-Type")
+            )
+    else:
+        # 获取响应内容用于详细错误显示
+        response_content = ""
+        try:
+            if hasattr(resp, 'content'):
+                content = resp.content
+                if isinstance(content, bytes):
+                    response_content = content.decode('utf-8', errors='ignore')
+            else:
+                content_bytes = await resp.aread()
+                if isinstance(content_bytes, bytes):
+                    response_content = content_bytes.decode('utf-8', errors='ignore')
+        except Exception as e:
+            log.debug(f"[NON-STREAMING] Failed to read response content for error analysis: {e}")
+            response_content = ""
+        
+        # 显示详细错误信息
+        if resp.status_code == 429:
+            if response_content:
+                log.error(f"Google API returned status 429 (NON-STREAMING). Response details: {response_content[:500]}")
+            else:
+                log.error(f"Google API returned status 429 (NON-STREAMING)")
+        else:
+            if response_content:
+                log.error(f"Google API returned status {resp.status_code} (NON-STREAMING). Response details: {response_content[:500]}")
+            else:
+                log.error(f"Google API returned status {resp.status_code} (NON-STREAMING)")
+        
+        # 记录API调用错误
+        if credential_manager and current_file:
+            await credential_manager.record_api_call_result(current_file, False, resp.status_code)
+        
+        await _handle_api_error(credential_manager, resp.status_code, response_content)
+        
+        return _create_error_response(f"API error: {resp.status_code}", resp.status_code)
+
+def build_gemini_payload_from_native(native_request: dict, model_from_path: str) -> dict:
+    """
+    Build a Gemini API payload from a native Gemini request with full pass-through support.
+    """
+    # 创建请求副本以避免修改原始数据
+    request_data = native_request.copy()
+    
+    # 应用默认安全设置（如果未指定）
+    if "safetySettings" not in request_data:
+        request_data["safetySettings"] = DEFAULT_SAFETY_SETTINGS
+    
+    # 确保generationConfig存在
+    if "generationConfig" not in request_data:
+        request_data["generationConfig"] = {}
+    
+    generation_config = request_data["generationConfig"]
+    
+    # 配置thinking（如果未指定thinkingConfig）
+    if "thinkingConfig" not in generation_config:
+        generation_config["thinkingConfig"] = {}
+    
+    thinking_config = generation_config["thinkingConfig"]
+    
+    # 只有在未明确设置时才应用默认thinking配置
+    if "includeThoughts" not in thinking_config:
+        thinking_config["includeThoughts"] = should_include_thoughts(model_from_path)
+    if "thinkingBudget" not in thinking_config:
+        thinking_config["thinkingBudget"] = get_thinking_budget(model_from_path)
+    
+    # 为搜索模型添加Google Search工具（如果未指定且没有functionDeclarations）
+    if is_search_model(model_from_path):
+        if "tools" not in request_data:
+            request_data["tools"] = []
+        # 检查是否已有functionDeclarations或googleSearch工具
+        has_function_declarations = any(tool.get("functionDeclarations") for tool in request_data["tools"])
+        has_google_search = any(tool.get("googleSearch") for tool in request_data["tools"])
+        
+        # 只有在没有任何工具时才添加googleSearch，或者只有googleSearch工具时可以添加更多googleSearch
+        if not has_function_declarations and not has_google_search:
+            request_data["tools"].append({"googleSearch": {}})
+    
+    # 透传所有其他Gemini原生字段:
+    # - contents (必需)
+    # - systemInstruction (可选)
+    # - generationConfig (已处理)
+    # - safetySettings (已处理)  
+    # - tools (已处理)
+    # - toolConfig (透传)
+    # - cachedContent (透传)
+    # - 以及任何其他未知字段都会被透传
+    
+    return {
+        "model": get_base_model_name(model_from_path),
+        "request": request_data
+    }

src/google_oauth_api.py

@@ -0,0 +1,543 @@
+"""
+Google OAuth2 认证模块
+"""
+import time
+import jwt
+import asyncio
+from datetime import datetime, timezone, timedelta
+from typing import Optional, Dict, Any, List
+from urllib.parse import urlencode
+
+from config import get_oauth_proxy_url, get_googleapis_proxy_url, get_resource_manager_api_url, get_service_usage_api_url
+from log import log
+from .httpx_client import get_async, post_async
+
+
+class TokenError(Exception):
+    """Token相关错误"""
+    pass
+
+class Credentials:
+    """凭证类"""
+    
+    def __init__(self, access_token: str, refresh_token: str = None,
+                 client_id: str = None, client_secret: str = None,
+                 expires_at: datetime = None, project_id: str = None):
+        self.access_token = access_token
+        self.refresh_token = refresh_token
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.expires_at = expires_at
+        self.project_id = project_id
+        
+        # 反代配置将在使用时异步获取
+        self.oauth_base_url = None
+        self.token_endpoint = None
+    
+    def is_expired(self) -> bool:
+        """检查token是否过期"""
+        if not self.expires_at:
+            return True
+        
+        # 提前3分钟认为过期
+        buffer = timedelta(minutes=3)
+        return (self.expires_at - buffer) <= datetime.now(timezone.utc)
+    
+    async def refresh_if_needed(self) -> bool:
+        """如果需要则刷新token"""
+        if not self.is_expired():
+            return False
+        
+        if not self.refresh_token:
+            raise TokenError("需要刷新令牌但未提供")
+        
+        await self.refresh()
+        return True
+    
+    async def refresh(self, max_retries: int = 3, base_delay: float = 1.0):
+        """刷新访问令牌，支持重试机制"""
+        if not self.refresh_token:
+            raise TokenError("无刷新令牌")
+        
+        data = {
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'refresh_token': self.refresh_token,
+            'grant_type': 'refresh_token'
+        }
+        
+        last_exception = None
+        for attempt in range(max_retries + 1):
+            try:
+                oauth_base_url = await get_oauth_proxy_url()
+                token_url = f"{oauth_base_url.rstrip('/')}/token"
+                response = await post_async(
+                    token_url,
+                    data=data,
+                    headers={'Content-Type': 'application/x-www-form-urlencoded'}
+                )
+                response.raise_for_status()
+                
+                token_data = response.json()
+                self.access_token = token_data['access_token']
+                
+                if 'expires_in' in token_data:
+                    expires_in = int(token_data['expires_in'])
+                    self.expires_at = datetime.now(timezone.utc) + timedelta(seconds=expires_in)
+                
+                if 'refresh_token' in token_data:
+                    self.refresh_token = token_data['refresh_token']
+                
+                if attempt > 0:
+                    log.debug(f"Token刷新成功（第{attempt + 1}次尝试），过期时间: {self.expires_at}")
+                else:
+                    log.debug(f"Token刷新成功，过期时间: {self.expires_at}")
+                return
+                
+            except Exception as e:
+                last_exception = e
+                error_msg = str(e)
+                
+                # 检查是否是不可恢复的错误，如果是则不重试
+                if self._is_non_retryable_error(error_msg):
+                    log.error(f"Token刷新遇到不可恢复错误: {error_msg}")
+                    break
+                
+                if attempt < max_retries:
+                    # 计算退避延迟时间（指数退避）
+                    delay = base_delay * (2 ** attempt)
+                    log.warning(f"Token刷新失败（第{attempt + 1}次尝试）: {error_msg}，{delay}秒后重试...")
+                    await asyncio.sleep(delay)
+                else:
+                    break
+        
+        # 所有重试都失败了
+        error_msg = f"Token刷新失败（已重试{max_retries}次）: {str(last_exception)}"
+        log.error(error_msg)
+        raise TokenError(error_msg)
+    
+    def _is_non_retryable_error(self, error_msg: str) -> bool:
+        """判断是否是不需要重试的错误"""
+        non_retryable_patterns = [
+            "400 Bad Request",
+            "invalid_grant",
+            "refresh_token_expired",
+            "invalid_refresh_token", 
+            "unauthorized_client",
+            "access_denied",
+            "401 Unauthorized"
+        ]
+        
+        error_msg_lower = error_msg.lower()
+        for pattern in non_retryable_patterns:
+            if pattern.lower() in error_msg_lower:
+                return True
+                
+        return False
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'Credentials':
+        """从字典创建凭证"""
+        # 处理过期时间
+        expires_at = None
+        if 'expiry' in data and data['expiry']:
+            try:
+                expiry_str = data['expiry']
+                if isinstance(expiry_str, str):
+                    if expiry_str.endswith('Z'):
+                        expires_at = datetime.fromisoformat(expiry_str.replace('Z', '+00:00'))
+                    elif '+' in expiry_str:
+                        expires_at = datetime.fromisoformat(expiry_str)
+                    else:
+                        expires_at = datetime.fromisoformat(expiry_str).replace(tzinfo=timezone.utc)
+            except ValueError:
+                log.warning(f"无法解析过期时间: {expiry_str}")
+        
+        return cls(
+            access_token=data.get('token') or data.get('access_token', ''),
+            refresh_token=data.get('refresh_token'),
+            client_id=data.get('client_id'),
+            client_secret=data.get('client_secret'),
+            expires_at=expires_at,
+            project_id=data.get('project_id')
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """转为字典"""
+        result = {
+            'access_token': self.access_token,
+            'refresh_token': self.refresh_token,
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'project_id': self.project_id
+        }
+        
+        if self.expires_at:
+            result['expiry'] = self.expires_at.isoformat()
+        
+        return result
+
+
+class Flow:
+    """OAuth流程类"""
+    
+    def __init__(self, client_id: str, client_secret: str, scopes: List[str],
+                 redirect_uri: str = None):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.scopes = scopes
+        self.redirect_uri = redirect_uri
+        
+        # 反代配置将在使用时异步获取
+        self.oauth_base_url = None
+        self.token_endpoint = None
+        self.auth_endpoint = "https://accounts.google.com/o/oauth2/auth"
+        
+        self.credentials: Optional[Credentials] = None
+    
+    def get_auth_url(self, state: str = None, **kwargs) -> str:
+        """生成授权URL"""
+        params = {
+            'client_id': self.client_id,
+            'redirect_uri': self.redirect_uri,
+            'scope': ' '.join(self.scopes),
+            'response_type': 'code',
+            'access_type': 'offline',
+            'prompt': 'consent',
+            'include_granted_scopes': 'true'
+        }
+        
+        if state:
+            params['state'] = state
+        
+        params.update(kwargs)
+        return f"{self.auth_endpoint}?{urlencode(params)}"
+    
+    async def exchange_code(self, code: str) -> Credentials:
+        """用授权码换取token"""
+        data = {
+            'client_id': self.client_id,
+            'client_secret': self.client_secret,
+            'redirect_uri': self.redirect_uri,
+            'code': code,
+            'grant_type': 'authorization_code'
+        }
+        
+        try:
+            oauth_base_url = await get_oauth_proxy_url()
+            token_url = f"{oauth_base_url.rstrip('/')}/token"
+            response = await post_async(
+                token_url,
+                data=data,
+                headers={'Content-Type': 'application/x-www-form-urlencoded'}
+            )
+            response.raise_for_status()
+            
+            token_data = response.json()
+            
+            # 计算过期时间
+            expires_at = None
+            if 'expires_in' in token_data:
+                expires_in = int(token_data['expires_in'])
+                expires_at = datetime.now(timezone.utc) + timedelta(seconds=expires_in)
+            
+            # 创建凭证对象
+            self.credentials = Credentials(
+                access_token=token_data['access_token'],
+                refresh_token=token_data.get('refresh_token'),
+                client_id=self.client_id,
+                client_secret=self.client_secret,
+                expires_at=expires_at
+            )
+            
+            return self.credentials
+            
+        except Exception as e:
+            error_msg = f"获取token失败: {str(e)}"
+            log.error(error_msg)
+            raise TokenError(error_msg)
+
+
+class ServiceAccount:
+    """Service Account类"""
+    
+    def __init__(self, email: str, private_key: str, project_id: str = None,
+                 scopes: List[str] = None):
+        self.email = email
+        self.private_key = private_key
+        self.project_id = project_id
+        self.scopes = scopes or []
+        
+        # 反代配置将在使用时异步获取
+        self.oauth_base_url = None
+        self.token_endpoint = None
+        
+        self.access_token: Optional[str] = None
+        self.expires_at: Optional[datetime] = None
+    
+    def is_expired(self) -> bool:
+        """检查token是否过期"""
+        if not self.expires_at:
+            return True
+        
+        buffer = timedelta(minutes=3)
+        return (self.expires_at - buffer) <= datetime.now(timezone.utc)
+    
+    def create_jwt(self) -> str:
+        """创建JWT令牌"""
+        now = int(time.time())
+        
+        payload = {
+            'iss': self.email,
+            'scope': ' '.join(self.scopes) if self.scopes else '',
+            'aud': self.token_endpoint,
+            'exp': now + 3600,
+            'iat': now
+        }
+        
+        return jwt.encode(payload, self.private_key, algorithm='RS256')
+    
+    async def get_access_token(self) -> str:
+        """获取访问令牌"""
+        if not self.is_expired() and self.access_token:
+            return self.access_token
+        
+        assertion = self.create_jwt()
+        
+        data = {
+            'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+            'assertion': assertion
+        }
+        
+        try:
+            oauth_base_url = await get_oauth_proxy_url()
+            token_url = f"{oauth_base_url.rstrip('/')}/token"
+            response = await post_async(
+                token_url,
+                data=data,
+                headers={'Content-Type': 'application/x-www-form-urlencoded'}
+            )
+            response.raise_for_status()
+            
+            token_data = response.json()
+            self.access_token = token_data['access_token']
+            
+            if 'expires_in' in token_data:
+                expires_in = int(token_data['expires_in'])
+                self.expires_at = datetime.now(timezone.utc) + timedelta(seconds=expires_in)
+            
+            return self.access_token
+            
+        except Exception as e:
+            error_msg = f"Service Account获取token失败: {str(e)}"
+            log.error(error_msg)
+            raise TokenError(error_msg)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any], scopes: List[str] = None) -> 'ServiceAccount':
+        """从字典创建Service Account凭证"""
+        return cls(
+            email=data['client_email'],
+            private_key=data['private_key'],
+            project_id=data.get('project_id'),
+            scopes=scopes
+        )
+
+
+# 工具函数
+async def get_user_info(credentials: Credentials) -> Optional[Dict[str, Any]]:
+    """获取用户信息"""
+    await credentials.refresh_if_needed()
+    
+    try:
+        googleapis_base_url = await get_googleapis_proxy_url()
+        userinfo_url = f"{googleapis_base_url.rstrip('/')}/oauth2/v2/userinfo"
+        response = await get_async(
+            userinfo_url,
+            headers={'Authorization': f'Bearer {credentials.access_token}'}
+        )
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        log.error(f"获取用户信息失败: {e}")
+        return None
+
+
+async def get_user_email(credentials: Credentials) -> Optional[str]:
+    """获取用户邮箱地址"""
+    try:
+        # 确保凭证有效
+        await credentials.refresh_if_needed()
+        
+        # 调用Google userinfo API获取邮箱
+        user_info = await get_user_info(credentials)
+        if user_info:
+            email = user_info.get("email")
+            if email:
+                log.info(f"成功获取邮箱地址: {email}")
+                return email
+            else:
+                log.warning(f"userinfo响应中没有邮箱信息: {user_info}")
+                return None
+        else:
+            log.warning("获取用户信息失败")
+            return None
+                
+    except Exception as e:
+        log.error(f"获取用户邮箱失败: {e}")
+        return None
+
+
+async def fetch_user_email_from_file(cred_data: Dict[str, Any]) -> Optional[str]:
+    """从凭证数据获取用户邮箱地址（支持统一存储）"""
+    try:
+        # 直接从凭证数据创建凭证对象
+        credentials = Credentials.from_dict(cred_data)
+        if not credentials or not credentials.access_token:
+            log.warning(f"无法从凭证数据创建凭证对象或获取访问令牌")
+            return None
+        
+        # 获取邮箱
+        return await get_user_email(credentials)
+                
+    except Exception as e:
+        log.error(f"从凭证数据获取用户邮箱失败: {e}")
+        return None
+
+
+async def validate_token(token: str) -> Optional[Dict[str, Any]]:
+    """验证访问令牌"""
+    try:
+        oauth_base_url = await get_oauth_proxy_url()
+        tokeninfo_url = f"{oauth_base_url.rstrip('/')}/tokeninfo?access_token={token}"
+        
+        response = await get_async(tokeninfo_url)
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        log.error(f"验证令牌失败: {e}")
+        return None
+
+
+async def enable_required_apis(credentials: Credentials, project_id: str) -> bool:
+    """自动启用必需的API服务"""
+    try:
+        # 确保凭证有效
+        if credentials.is_expired() and credentials.refresh_token:
+            await credentials.refresh()
+        
+        headers = {
+            "Authorization": f"Bearer {credentials.access_token}",
+            "Content-Type": "application/json",
+            "User-Agent": "geminicli-oauth/1.0",
+        }
+        
+        # 需要启用的服务列表
+        required_services = [
+            "geminicloudassist.googleapis.com",  # Gemini Cloud Assist API
+            "cloudaicompanion.googleapis.com"    # Gemini for Google Cloud API
+        ]
+        
+        for service in required_services:
+            log.info(f"正在检查并启用服务: {service}")
+            
+            # 检查服务是否已启用
+            service_usage_base_url = await get_service_usage_api_url()
+            check_url = f"{service_usage_base_url.rstrip('/')}/v1/projects/{project_id}/services/{service}"
+            try:
+                check_response = await get_async(check_url, headers=headers)
+                if check_response.status_code == 200:
+                    service_data = check_response.json()
+                    if service_data.get("state") == "ENABLED":
+                        log.info(f"服务 {service} 已启用")
+                        continue
+            except Exception as e:
+                log.debug(f"检查服务状态失败，将尝试启用: {e}")
+            
+            # 启用服务
+            enable_url = f"{service_usage_base_url.rstrip('/')}/v1/projects/{project_id}/services/{service}:enable"
+            try:
+                enable_response = await post_async(enable_url, headers=headers, json={})
+                
+                if enable_response.status_code in [200, 201]:
+                    log.info(f"✅ 成功启用服务: {service}")
+                elif enable_response.status_code == 400:
+                    error_data = enable_response.json()
+                    if "already enabled" in error_data.get("error", {}).get("message", "").lower():
+                        log.info(f"✅ 服务 {service} 已经启用")
+                    else:
+                        log.warning(f"⚠️ 启用服务 {service} 时出现警告: {error_data}")
+                else:
+                    log.warning(f"⚠️ 启用服务 {service} 失败: {enable_response.status_code} - {enable_response.text}")
+                    
+            except Exception as e:
+                log.warning(f"⚠️ 启用服务 {service} 时发生异常: {e}")
+                
+        return True
+        
+    except Exception as e:
+        log.error(f"启用API服务时发生错误: {e}")
+        return False
+
+
+async def get_user_projects(credentials: Credentials) -> List[Dict[str, Any]]:
+    """获取用户可访问的Google Cloud项目列表"""
+    try:
+        # 确保凭证有效
+        if credentials.is_expired() and credentials.refresh_token:
+            await credentials.refresh()
+        
+        headers = {
+            "Authorization": f"Bearer {credentials.access_token}",
+            "User-Agent": "geminicli-oauth/1.0",
+        }
+        
+        # 使用Resource Manager API的正确域名和端点
+        resource_manager_base_url = await get_resource_manager_api_url()
+        url = f"{resource_manager_base_url.rstrip('/')}/v1/projects"
+        log.info(f"正在调用API: {url}")
+        response = await get_async(url, headers=headers)
+        
+        log.info(f"API响应状态码: {response.status_code}")
+        if response.status_code != 200:
+            log.error(f"API响应内容: {response.text}")
+        
+        if response.status_code == 200:
+            data = response.json()
+            projects = data.get('projects', [])
+            # 只返回活跃的项目
+            active_projects = [
+                project for project in projects 
+                if project.get('lifecycleState') == 'ACTIVE'
+            ]
+            log.info(f"获取到 {len(active_projects)} 个活跃项目")
+            return active_projects
+        else:
+            log.warning(f"获取项目列表失败: {response.status_code} - {response.text}")
+            return []
+            
+    except Exception as e:
+        log.error(f"获取用户项目列表失败: {e}")
+        return []
+
+
+
+
+async def select_default_project(projects: List[Dict[str, Any]]) -> Optional[str]:
+    """从项目列表中选择默认项目"""
+    if not projects:
+        return None
+    
+    # 策略1：查找显示名称或项目ID包含"default"的项目
+    for project in projects:
+        display_name = project.get('displayName', '').lower()
+        project_id = project.get('projectId', '')
+        if 'default' in display_name or 'default' in project_id.lower():
+            log.info(f"选择默认项目: {project_id} ({project.get('displayName', project_id)})")
+            return project_id
+    
+    # 策略2：选择第一个项目
+    first_project = projects[0]
+    project_id = first_project.get('projectId', '')
+    log.info(f"选择第一个项目作为默认: {project_id} ({first_project.get('displayName', project_id)})")
+    return project_id

src/httpx_client.py

@@ -0,0 +1,174 @@
+"""
+通用的HTTP客户端模块
+为所有需要使用httpx的模块提供统一的客户端配置和方法
+保持通用性，不与特定业务逻辑耦合
+"""
+import httpx
+from typing import Optional, Dict, Any, AsyncGenerator
+from contextlib import asynccontextmanager
+
+from config import get_proxy_config
+from log import log
+
+
+class HttpxClientManager:
+    """通用HTTP客户端管理器"""
+    
+    async def get_client_kwargs(self, timeout: float = 30.0, **kwargs) -> Dict[str, Any]:
+        """获取httpx客户端的通用配置参数"""
+        client_kwargs = {
+            "timeout": timeout,
+            **kwargs
+        }
+        
+        # 动态读取代理配置，支持热更新
+        current_proxy_config = await get_proxy_config()
+        if current_proxy_config:
+            client_kwargs["proxy"] = current_proxy_config
+        
+        return client_kwargs
+    
+    @asynccontextmanager
+    async def get_client(self, timeout: float = 30.0, **kwargs) -> AsyncGenerator[httpx.AsyncClient, None]:
+        """获取配置好的异步HTTP客户端"""
+        client_kwargs = await self.get_client_kwargs(timeout=timeout, **kwargs)
+        
+        async with httpx.AsyncClient(**client_kwargs) as client:
+            yield client
+    
+    @asynccontextmanager
+    async def get_streaming_client(self, timeout: float = None, **kwargs) -> AsyncGenerator[httpx.AsyncClient, None]:
+        """获取用于流式请求的HTTP客户端（无超时限制）"""
+        client_kwargs = await self.get_client_kwargs(timeout=timeout, **kwargs)
+        
+        # 创建独立的客户端实例用于流式处理
+        client = httpx.AsyncClient(**client_kwargs)
+        try:
+            yield client
+        finally:
+            await client.aclose()
+
+
+# 全局HTTP客户端管理器实例
+http_client = HttpxClientManager()
+
+
+# 通用的异步方法
+async def get_async(url: str, headers: Optional[Dict[str, str]] = None, 
+                   timeout: float = 30.0, **kwargs) -> httpx.Response:
+    """通用异步GET请求"""
+    async with http_client.get_client(timeout=timeout, **kwargs) as client:
+        return await client.get(url, headers=headers)
+
+
+async def post_async(url: str, data: Any = None, json: Any = None,
+                    headers: Optional[Dict[str, str]] = None,
+                    timeout: float = 30.0, **kwargs) -> httpx.Response:
+    """通用异步POST请求"""
+    async with http_client.get_client(timeout=timeout, **kwargs) as client:
+        return await client.post(url, data=data, json=json, headers=headers)
+
+
+async def put_async(url: str, data: Any = None, json: Any = None,
+                   headers: Optional[Dict[str, str]] = None,
+                   timeout: float = 30.0, **kwargs) -> httpx.Response:
+    """通用异步PUT请求"""
+    async with http_client.get_client(timeout=timeout, **kwargs) as client:
+        return await client.put(url, data=data, json=json, headers=headers)
+
+
+async def delete_async(url: str, headers: Optional[Dict[str, str]] = None,
+                      timeout: float = 30.0, **kwargs) -> httpx.Response:
+    """通用异步DELETE请求"""
+    async with http_client.get_client(timeout=timeout, **kwargs) as client:
+        return await client.delete(url, headers=headers)
+
+
+# 错误处理装饰器
+def handle_http_errors(func):
+    """HTTP错误处理装饰器"""
+    async def wrapper(*args, **kwargs):
+        try:
+            response = await func(*args, **kwargs)
+            response.raise_for_status()
+            return response
+        except httpx.HTTPStatusError as e:
+            log.error(f"HTTP错误: {e.response.status_code} - {e.response.text}")
+            raise
+        except httpx.RequestError as e:
+            log.error(f"请求错误: {e}")
+            raise
+        except Exception as e:
+            log.error(f"未知错误: {e}")
+            raise
+    return wrapper
+
+
+# 应用错误处理的安全方法
+@handle_http_errors
+async def safe_get_async(url: str, headers: Optional[Dict[str, str]] = None,
+                        timeout: float = 30.0, **kwargs) -> httpx.Response:
+    """安全的异步GET请求（自动错误处理）"""
+    return await get_async(url, headers=headers, timeout=timeout, **kwargs)
+
+
+@handle_http_errors
+async def safe_post_async(url: str, data: Any = None, json: Any = None,
+                         headers: Optional[Dict[str, str]] = None,
+                         timeout: float = 30.0, **kwargs) -> httpx.Response:
+    """安全的异步POST请求（自动错误处理）"""
+    return await post_async(url, data=data, json=json, headers=headers, timeout=timeout, **kwargs)
+
+
+@handle_http_errors
+async def safe_put_async(url: str, data: Any = None, json: Any = None,
+                        headers: Optional[Dict[str, str]] = None,
+                        timeout: float = 30.0, **kwargs) -> httpx.Response:
+    """安全的异步PUT请求（自动错误处理）"""
+    return await put_async(url, data=data, json=json, headers=headers, timeout=timeout, **kwargs)
+
+
+@handle_http_errors
+async def safe_delete_async(url: str, headers: Optional[Dict[str, str]] = None,
+                           timeout: float = 30.0, **kwargs) -> httpx.Response:
+    """安全的异步DELETE请求（自动错误处理）"""
+    return await delete_async(url, headers=headers, timeout=timeout, **kwargs)
+
+
+# 流式请求支持
+class StreamingContext:
+    """流式请求上下文管理器"""
+    
+    def __init__(self, client: httpx.AsyncClient, stream_context):
+        self.client = client
+        self.stream_context = stream_context
+        self.response = None
+    
+    async def __aenter__(self):
+        self.response = await self.stream_context.__aenter__()
+        return self.response
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        try:
+            if self.stream_context:
+                await self.stream_context.__aexit__(exc_type, exc_val, exc_tb)
+        finally:
+            if self.client:
+                await self.client.aclose()
+
+
+@asynccontextmanager
+async def get_streaming_post_context(url: str, data: Any = None, json: Any = None,
+                                   headers: Optional[Dict[str, str]] = None,
+                                   timeout: float = None, **kwargs) -> AsyncGenerator[StreamingContext, None]:
+    """获取流式POST请求的上下文管理器"""
+    async with http_client.get_streaming_client(timeout=timeout, **kwargs) as client:
+        stream_ctx = client.stream("POST", url, data=data, json=json, headers=headers)
+        streaming_context = StreamingContext(client, stream_ctx)
+        yield streaming_context
+
+
+async def create_streaming_client_with_kwargs(**kwargs) -> httpx.AsyncClient:
+    """创建用于流式处理的独立客户端实例（手动管理生命周期）"""
+    client_kwargs = await http_client.get_client_kwargs(timeout=None, **kwargs)
+    return httpx.AsyncClient(**client_kwargs)

src/models.py

@@ -0,0 +1,198 @@
+from typing import List, Optional, Union, Dict, Any
+
+from pydantic import BaseModel, Field
+
+# Common Models
+class Model(BaseModel):
+    id: str
+    object: str = "model"
+    created: Optional[int] = None
+    owned_by: Optional[str] = "google"
+
+class ModelList(BaseModel):
+    object: str = "list"
+    data: List[Model]
+
+# OpenAI Models
+class OpenAIChatMessage(BaseModel):
+    role: str
+    content: Union[str, List[Dict[str, Any]], None] = None
+    reasoning_content: Optional[str] = None
+    name: Optional[str] = None
+
+class OpenAIChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[OpenAIChatMessage]
+    stream: bool = False
+    temperature: Optional[float] = Field(None, ge=0.0, le=2.0)
+    top_p: Optional[float] = Field(None, ge=0.0, le=1.0)
+    max_tokens: Optional[int] = Field(None, ge=1)
+    stop: Optional[Union[str, List[str]]] = None
+    frequency_penalty: Optional[float] = Field(None, ge=-2.0, le=2.0)
+    presence_penalty: Optional[float] = Field(None, ge=-2.0, le=2.0)
+    n: Optional[int] = Field(1, ge=1, le=128)
+    seed: Optional[int] = None
+    response_format: Optional[Dict[str, Any]] = None
+    top_k: Optional[int] = Field(None, ge=1)
+    enable_anti_truncation: Optional[bool] = False
+    
+    class Config:
+        extra = "allow"  # Allow additional fields not explicitly defined
+
+# 通用的聊天完成请求模型（兼容OpenAI和其他格式）
+ChatCompletionRequest = OpenAIChatCompletionRequest
+
+class OpenAIChatCompletionChoice(BaseModel):
+    index: int
+    message: OpenAIChatMessage
+    finish_reason: Optional[str] = None
+    logprobs: Optional[Dict[str, Any]] = None
+
+class OpenAIChatCompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[OpenAIChatCompletionChoice]
+    usage: Optional[Dict[str, int]] = None
+    system_fingerprint: Optional[str] = None
+
+class OpenAIDelta(BaseModel):
+    role: Optional[str] = None
+    content: Optional[str] = None
+    reasoning_content: Optional[str] = None
+
+class OpenAIChatCompletionStreamChoice(BaseModel):
+    index: int
+    delta: OpenAIDelta
+    finish_reason: Optional[str] = None
+    logprobs: Optional[Dict[str, Any]] = None
+
+class OpenAIChatCompletionStreamResponse(BaseModel):
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: List[OpenAIChatCompletionStreamChoice]
+    system_fingerprint: Optional[str] = None
+
+# Gemini Models
+class GeminiPart(BaseModel):
+    text: Optional[str] = None
+    inlineData: Optional[Dict[str, Any]] = None
+    fileData: Optional[Dict[str, Any]] = None
+    thought: Optional[bool] = False
+
+class GeminiContent(BaseModel):
+    role: str
+    parts: List[GeminiPart]
+
+class GeminiSystemInstruction(BaseModel):
+    parts: List[GeminiPart]
+
+class GeminiGenerationConfig(BaseModel):
+    temperature: Optional[float] = Field(None, ge=0.0, le=2.0)
+    topP: Optional[float] = Field(None, ge=0.0, le=1.0)
+    topK: Optional[int] = Field(None, ge=1)
+    maxOutputTokens: Optional[int] = Field(None, ge=1)
+    stopSequences: Optional[List[str]] = None
+    responseMimeType: Optional[str] = None
+    responseSchema: Optional[Dict[str, Any]] = None
+    candidateCount: Optional[int] = Field(None, ge=1, le=8)
+    seed: Optional[int] = None
+    frequencyPenalty: Optional[float] = Field(None, ge=-2.0, le=2.0)
+    presencePenalty: Optional[float] = Field(None, ge=-2.0, le=2.0)
+    thinkingConfig: Optional[Dict[str, Any]] = None
+
+class GeminiSafetySetting(BaseModel):
+    category: str
+    threshold: str
+
+class GeminiRequest(BaseModel):
+    contents: List[GeminiContent]
+    systemInstruction: Optional[GeminiSystemInstruction] = None
+    generationConfig: Optional[GeminiGenerationConfig] = None
+    safetySettings: Optional[List[GeminiSafetySetting]] = None
+    tools: Optional[List[Dict[str, Any]]] = None
+    toolConfig: Optional[Dict[str, Any]] = None
+    cachedContent: Optional[str] = None
+    enable_anti_truncation: Optional[bool] = False
+    
+    class Config:
+        extra = "allow"  # 允许透传未定义的字段
+
+class GeminiCandidate(BaseModel):
+    content: GeminiContent
+    finishReason: Optional[str] = None
+    index: int = 0
+    safetyRatings: Optional[List[Dict[str, Any]]] = None
+    citationMetadata: Optional[Dict[str, Any]] = None
+    tokenCount: Optional[int] = None
+
+class GeminiUsageMetadata(BaseModel):
+    promptTokenCount: Optional[int] = None
+    candidatesTokenCount: Optional[int] = None
+    totalTokenCount: Optional[int] = None
+
+class GeminiResponse(BaseModel):
+    candidates: List[GeminiCandidate]
+    usageMetadata: Optional[GeminiUsageMetadata] = None
+    modelVersion: Optional[str] = None
+
+# Error Models
+class APIError(BaseModel):
+    message: str
+    type: str = "api_error"
+    code: Optional[int] = None
+
+class ErrorResponse(BaseModel):
+    error: APIError
+
+# Control Panel Models
+class SystemStatus(BaseModel):
+    status: str
+    timestamp: str
+    credentials: Dict[str, int]
+    config: Dict[str, Any]
+    current_credential: str
+
+class CredentialInfo(BaseModel):
+    filename: str
+    project_id: Optional[str] = None
+    status: Dict[str, Any]
+    size: Optional[int] = None
+    modified_time: Optional[str] = None
+    error: Optional[str] = None
+
+class LogEntry(BaseModel):
+    timestamp: str
+    level: str
+    message: str
+    module: Optional[str] = None
+
+class ConfigValue(BaseModel):
+    key: str
+    value: Any
+    env_locked: bool = False
+    description: Optional[str] = None
+
+# Authentication Models
+class AuthRequest(BaseModel):
+    project_id: Optional[str] = None
+    user_session: Optional[str] = None
+
+class AuthResponse(BaseModel):
+    success: bool
+    auth_url: Optional[str] = None
+    state: Optional[str] = None
+    error: Optional[str] = None
+    credentials: Optional[Dict[str, Any]] = None
+    file_path: Optional[str] = None
+    requires_manual_project_id: Optional[bool] = None
+    requires_project_selection: Optional[bool] = None
+    available_projects: Optional[List[Dict[str, str]]] = None
+
+class CredentialStatus(BaseModel):
+    disabled: bool = False
+    error_codes: List[int] = []
+    last_success: Optional[str] = None

src/openai_router.py

@@ -0,0 +1,395 @@
+"""
+OpenAI Router - Handles OpenAI format API requests
+处理OpenAI格式请求的路由模块
+"""
+import json
+import time
+import uuid
+import asyncio
+from contextlib import asynccontextmanager
+
+from fastapi import APIRouter, HTTPException, Depends, Request, status
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+from config import get_available_models, is_fake_streaming_model, is_anti_truncation_model, get_base_model_from_feature_model, get_anti_truncation_max_attempts
+from log import log
+from .anti_truncation import apply_anti_truncation_to_stream
+from .credential_manager import CredentialManager
+from .google_chat_api import send_gemini_request
+from .models import ChatCompletionRequest, ModelList, Model
+from .task_manager import create_managed_task
+from .openai_transfer import openai_request_to_gemini_payload, gemini_response_to_openai, gemini_stream_chunk_to_openai
+
+# 创建路由器
+router = APIRouter()
+security = HTTPBearer()
+
+# 全局凭证管理器实例
+credential_manager = None
+
+@asynccontextmanager
+async def get_credential_manager():
+    """获取全局凭证管理器实例"""
+    global credential_manager
+    if not credential_manager:
+        credential_manager = CredentialManager()
+        await credential_manager.initialize()
+    yield credential_manager
+
+async def authenticate(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
+    """验证用户密码"""
+    from config import get_api_password
+    password = await get_api_password()
+    token = credentials.credentials
+    if token != password:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="密码错误")
+    return token
+
+@router.get("/v1/models", response_model=ModelList)
+async def list_models():
+    """返回OpenAI格式的模型列表"""
+    models = get_available_models("openai")
+    return ModelList(data=[Model(id=m) for m in models])
+
+@router.post("/v1/chat/completions")
+async def chat_completions(
+    request: Request,
+    token: str = Depends(authenticate)
+):
+    """处理OpenAI格式的聊天完成请求"""
+    
+    # 获取原始请求数据
+    try:
+        raw_data = await request.json()
+    except Exception as e:
+        log.error(f"Failed to parse JSON request: {e}")
+        raise HTTPException(status_code=400, detail=f"Invalid JSON: {str(e)}")
+    
+    # 创建请求对象
+    try:
+        request_data = ChatCompletionRequest(**raw_data)
+    except Exception as e:
+        log.error(f"Request validation failed: {e}")
+        raise HTTPException(status_code=400, detail=f"Request validation error: {str(e)}")
+    
+    # 健康检查
+    if (len(request_data.messages) == 1 and 
+        getattr(request_data.messages[0], "role", None) == "user" and
+        getattr(request_data.messages[0], "content", None) == "Hi"):
+        return JSONResponse(content={
+            "choices": [{"message": {"role": "assistant", "content": "gcli2api正常工作中"}}]
+        })
+    
+    # 限制max_tokens
+    if getattr(request_data, "max_tokens", None) is not None and request_data.max_tokens > 65535:
+        request_data.max_tokens = 65535
+        
+    # 覆写 top_k 为 64
+    setattr(request_data, "top_k", 64)
+
+    # 过滤空消息
+    filtered_messages = []
+    for m in request_data.messages:
+        content = getattr(m, "content", None)
+        if content:
+            if isinstance(content, str) and content.strip():
+                filtered_messages.append(m)
+            elif isinstance(content, list) and len(content) > 0:
+                has_valid_content = False
+                for part in content:
+                    if isinstance(part, dict):
+                        if part.get("type") == "text" and part.get("text", "").strip():
+                            has_valid_content = True
+                            break
+                        elif part.get("type") == "image_url" and part.get("image_url", {}).get("url"):
+                            has_valid_content = True
+                            break
+                if has_valid_content:
+                    filtered_messages.append(m)
+    
+    request_data.messages = filtered_messages
+    
+    # 处理模型名称和功能检测
+    model = request_data.model
+    use_fake_streaming = is_fake_streaming_model(model)
+    use_anti_truncation = is_anti_truncation_model(model)
+    
+    # 获取基础模型名
+    real_model = get_base_model_from_feature_model(model)
+    request_data.model = real_model
+    
+    # 获取凭证管理器
+    from src.credential_manager import get_credential_manager
+    cred_mgr = await get_credential_manager()
+    
+    # 获取有效凭证
+    credential_result = await cred_mgr.get_valid_credential()
+    if not credential_result:
+        log.error("当前无可用凭证，请去控制台获取")
+        raise HTTPException(status_code=500, detail="当前无可用凭证，请去控制台获取")
+    
+    current_file = credential_result
+    log.debug(f"Using credential: {current_file}")
+    
+    # 增加调用计数
+    cred_mgr.increment_call_count()
+    
+    # 转换为Gemini API payload格式
+    try:
+        api_payload = await openai_request_to_gemini_payload(request_data)
+    except Exception as e:
+        log.error(f"OpenAI to Gemini conversion failed: {e}")
+        raise HTTPException(status_code=500, detail="Request conversion failed")
+    
+    # 处理假流式
+    if use_fake_streaming and getattr(request_data, "stream", False):
+        request_data.stream = False
+        return await fake_stream_response(api_payload, cred_mgr)
+    
+    # 处理抗截断 (仅流式传输时有效)
+    is_streaming = getattr(request_data, "stream", False)
+    if use_anti_truncation and is_streaming:
+        log.info("启用流式抗截断功能")
+        max_attempts = await get_anti_truncation_max_attempts()
+        
+        # 使用流式抗截断处理器
+        gemini_response = await apply_anti_truncation_to_stream(
+            lambda api_payload: send_gemini_request(api_payload, is_streaming, cred_mgr),
+            api_payload,
+            max_attempts
+        )
+        
+        return await convert_streaming_response(gemini_response, model)
+    elif use_anti_truncation and not is_streaming:
+        log.warning("抗截断功能仅在流式传输时有效，非流式请求将忽略此设置")
+    
+    # 发送请求（429重试已在google_api_client中处理）
+    is_streaming = getattr(request_data, "stream", False)
+    log.debug(f"Sending request: streaming={is_streaming}, model={real_model}")
+    response = await send_gemini_request(api_payload, is_streaming, cred_mgr)
+    
+    # 如果是流式响应，直接返回
+    if is_streaming:
+        return await convert_streaming_response(response, model)
+    
+    # 转换非流式响应
+    try:
+        log.debug(f"Processing response: type={type(response)}")
+        if hasattr(response, 'body'):
+            response_data = json.loads(response.body.decode() if isinstance(response.body, bytes) else response.body)
+        else:
+            response_data = json.loads(response.content.decode() if isinstance(response.content, bytes) else response.content)
+        
+        log.debug(f"Response data keys: {list(response_data.keys()) if isinstance(response_data, dict) else 'Not a dict'}")
+        openai_response = gemini_response_to_openai(response_data, model)
+        log.debug(f"Converted OpenAI response keys: {list(openai_response.keys()) if isinstance(openai_response, dict) else 'Not a dict'}")
+        return JSONResponse(content=openai_response)
+        
+    except Exception as e:
+        log.error(f"Response conversion failed: {e}")
+        log.error(f"Response object: {response}")
+        raise HTTPException(status_code=500, detail="Response conversion failed")
+
+async def fake_stream_response(api_payload: dict, cred_mgr: CredentialManager) -> StreamingResponse:
+    """处理假流式响应"""
+    async def stream_generator():
+        try:
+            # 发送心跳
+            heartbeat = {
+                "choices": [{
+                    "index": 0,
+                    "delta": {"role": "assistant", "content": ""},
+                    "finish_reason": None
+                }]
+            }
+            yield f"data: {json.dumps(heartbeat)}\n\n".encode()
+            
+            # 异步发送实际请求
+            async def get_response():
+                return await send_gemini_request(api_payload, False, cred_mgr)
+            
+            # 创建请求任务
+            response_task = create_managed_task(get_response(), name="openai_fake_stream_request")
+            
+            try:
+                # 每3秒发送一次心跳，直到收到响应
+                while not response_task.done():
+                    await asyncio.sleep(3.0)
+                    if not response_task.done():
+                        yield f"data: {json.dumps(heartbeat)}\n\n".encode()
+                
+                # 获取响应结果
+                response = await response_task
+                
+            except asyncio.CancelledError:
+                # 取消任务并传播取消
+                response_task.cancel()
+                try:
+                    await response_task
+                except asyncio.CancelledError:
+                    pass
+                raise
+            except Exception as e:
+                # 取消任务并处理其他异常
+                response_task.cancel()
+                try:
+                    await response_task
+                except asyncio.CancelledError:
+                    pass
+                log.error(f"Fake streaming request failed: {e}")
+                raise
+            
+            # 发送实际请求
+            # response 已在上面获取
+            
+            # 处理结果
+            if hasattr(response, 'body'):
+                body_str = response.body.decode() if isinstance(response.body, bytes) else str(response.body)
+            elif hasattr(response, 'content'):
+                body_str = response.content.decode() if isinstance(response.content, bytes) else str(response.content)
+            else:
+                body_str = str(response)
+            
+            try:
+                response_data = json.loads(body_str)
+                log.debug(f"Fake stream response data: {response_data}")
+                
+                # 从Gemini响应中提取内容，使用思维链分离逻辑
+                content = ""
+                reasoning_content = ""
+                if "candidates" in response_data and response_data["candidates"]:
+                    # Gemini格式响应 - 使用思维链分离
+                    from .openai_transfer import _extract_content_and_reasoning
+                    candidate = response_data["candidates"][0]
+                    if "content" in candidate and "parts" in candidate["content"]:
+                        parts = candidate["content"]["parts"]
+                        content, reasoning_content = _extract_content_and_reasoning(parts)
+                elif "choices" in response_data and response_data["choices"]:
+                    # OpenAI格式响应
+                    content = response_data["choices"][0].get("message", {}).get("content", "")
+                
+                log.debug(f"Extracted content: {content}")
+                log.debug(f"Extracted reasoning: {reasoning_content[:100] if reasoning_content else 'None'}...")
+                
+                # 如果没有正常内容但有思维内容，给出警告
+                if not content and reasoning_content:
+                    log.warning(f"Fake stream response contains only thinking content: {reasoning_content[:100]}...")
+                    content = "[模型正在思考中，请稍后再试或重新提问]"
+                
+                if content:
+                    # 构建响应块，包括思维内容（如果有）
+                    delta = {"role": "assistant", "content": content}
+                    if reasoning_content:
+                        delta["reasoning_content"] = reasoning_content
+                    
+                    content_chunk = {
+                        "choices": [{
+                            "index": 0,
+                            "delta": delta,
+                            "finish_reason": "stop"
+                        }]
+                    }
+                    yield f"data: {json.dumps(content_chunk)}\n\n".encode()
+                else:
+                    log.warning(f"No content found in response: {response_data}")
+                    # 如果完全没有内容，提供默认回复
+                    error_chunk = {
+                        "choices": [{
+                            "index": 0,
+                            "delta": {"role": "assistant", "content": "[响应为空，请重新尝试]"},
+                            "finish_reason": "stop"
+                        }]
+                    }
+                    yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+            except json.JSONDecodeError:
+                error_chunk = {
+                    "choices": [{
+                        "index": 0,
+                        "delta": {"role": "assistant", "content": body_str},
+                        "finish_reason": "stop"
+                    }]
+                }
+                yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+            
+            yield "data: [DONE]\n\n".encode()
+            
+        except Exception as e:
+            log.error(f"Fake streaming error: {e}")
+            error_chunk = {
+                "choices": [{
+                    "index": 0,
+                    "delta": {"role": "assistant", "content": f"Error: {str(e)}"},
+                    "finish_reason": "stop"
+                }]
+            }
+            yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+            yield "data: [DONE]\n\n".encode()
+
+    return StreamingResponse(stream_generator(), media_type="text/event-stream")
+
+async def convert_streaming_response(gemini_response, model: str) -> StreamingResponse:
+    """转换流式响应为OpenAI格式"""
+    response_id = str(uuid.uuid4())
+    
+    async def openai_stream_generator():
+        try:
+            # 处理不同类型的响应对象
+            if hasattr(gemini_response, 'body_iterator'):
+                # FastAPI StreamingResponse
+                async for chunk in gemini_response.body_iterator:
+                    if not chunk:
+                        continue
+                    
+                    # 处理不同数据类型的startswith问题
+                    if isinstance(chunk, bytes):
+                        if not chunk.startswith(b'data: '):
+                            continue
+                        payload = chunk[len(b'data: '):]
+                    else:
+                        chunk_str = str(chunk)
+                        if not chunk_str.startswith('data: '):
+                            continue
+                        payload = chunk_str[len('data: '):].encode()
+                    try:
+                        gemini_chunk = json.loads(payload.decode())
+                        openai_chunk = gemini_stream_chunk_to_openai(gemini_chunk, model, response_id)
+                        yield f"data: {json.dumps(openai_chunk, separators=(',',':'))}\n\n".encode()
+                    except json.JSONDecodeError:
+                        continue
+            else:
+                # 其他类型的响应，尝试直接处理
+                log.warning(f"Unexpected response type: {type(gemini_response)}")
+                error_chunk = {
+                    "id": response_id,
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {"role": "assistant", "content": "Response type error"},
+                        "finish_reason": "stop"
+                    }]
+                }
+                yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+            
+            # 发送结束标记
+            yield "data: [DONE]\n\n".encode()
+            
+        except Exception as e:
+            log.error(f"Stream conversion error: {e}")
+            error_chunk = {
+                "id": response_id,
+                "object": "chat.completion.chunk",
+                "created": int(time.time()),
+                "model": model,
+                "choices": [{
+                    "index": 0,
+                    "delta": {"role": "assistant", "content": f"Stream error: {str(e)}"},
+                    "finish_reason": "stop"
+                }]
+            }
+            yield f"data: {json.dumps(error_chunk)}\n\n".encode()
+            yield "data: [DONE]\n\n".encode()
+
+    return StreamingResponse(openai_stream_generator(), media_type="text/event-stream")

src/openai_transfer.py

@@ -0,0 +1,403 @@
+"""
+OpenAI Transfer Module - Handles conversion between OpenAI and Gemini API formats
+被openai-router调用，负责OpenAI格式与Gemini格式的双向转换
+"""
+import time
+import uuid
+from typing import Dict, Any
+
+from config import (
+    DEFAULT_SAFETY_SETTINGS,
+    get_base_model_name,
+    get_thinking_budget,
+    is_search_model,
+    should_include_thoughts,
+    get_compatibility_mode_enabled
+)
+from log import log
+from .models import ChatCompletionRequest
+
+async def openai_request_to_gemini_payload(openai_request: ChatCompletionRequest) -> Dict[str, Any]:
+    """
+    将OpenAI聊天完成请求直接转换为完整的Gemini API payload格式
+    
+    Args:
+        openai_request: OpenAI格式请求对象
+        
+    Returns:
+        完整的Gemini API payload，包含model和request字段
+    """
+    contents = []
+    system_instructions = []
+    
+    # 检查是否启用兼容性模式
+    compatibility_mode = await get_compatibility_mode_enabled()
+    
+    # 处理对话中的每条消息
+    # 第一阶段：收集连续的system消息到system_instruction中（除非在兼容性模式下）
+    collecting_system = True if not compatibility_mode else False
+    
+    for message in openai_request.messages:
+        role = message.role
+        
+        # 处理系统消息
+        if role == "system":
+            if compatibility_mode:
+                # 兼容性模式：所有system消息转换为user消息
+                role = "user"
+            elif collecting_system:
+                # 正常模式：仍在收集连续的system消息
+                if isinstance(message.content, str):
+                    system_instructions.append(message.content)
+                elif isinstance(message.content, list):
+                    # 处理列表格式的系统消息
+                    for part in message.content:
+                        if part.get("type") == "text" and part.get("text"):
+                            system_instructions.append(part["text"])
+                continue
+            else:
+                # 正常模式：后续的system消息转换为user消息
+                role = "user"
+        else:
+            # 遇到非system消息，停止收集system消息
+            collecting_system = False
+        
+        # 将OpenAI角色映射到Gemini角色
+        if role == "assistant":
+            role = "model"
+        
+        # 处理普通内容
+        if isinstance(message.content, list):
+            parts = []
+            for part in message.content:
+                if part.get("type") == "text":
+                    parts.append({"text": part.get("text", "")})
+                elif part.get("type") == "image_url":
+                    image_url = part.get("image_url", {}).get("url")
+                    if image_url:
+                        # 解析数据URI: "data:image/jpeg;base64,{base64_image}"
+                        try:
+                            mime_type, base64_data = image_url.split(";")
+                            _, mime_type = mime_type.split(":")
+                            _, base64_data = base64_data.split(",")
+                            parts.append({
+                                "inlineData": {
+                                    "mimeType": mime_type,
+                                    "data": base64_data
+                                }
+                            })
+                        except ValueError:
+                            continue
+            contents.append({"role": role, "parts": parts})
+            # log.debug(f"Added message to contents: role={role}, parts={parts}")
+        elif message.content:
+            # 简单文本内容
+            contents.append({"role": role, "parts": [{"text": message.content}]})
+            # log.debug(f"Added message to contents: role={role}, content={message.content}")
+
+    # 将OpenAI生成参数映射到Gemini格式
+    generation_config = {}
+    if openai_request.temperature is not None:
+        generation_config["temperature"] = openai_request.temperature
+    if openai_request.top_p is not None:
+        generation_config["topP"] = openai_request.top_p
+    if openai_request.max_tokens is not None:
+        generation_config["maxOutputTokens"] = openai_request.max_tokens
+    if openai_request.stop is not None:
+        # Gemini支持停止序列
+        if isinstance(openai_request.stop, str):
+            generation_config["stopSequences"] = [openai_request.stop]
+        elif isinstance(openai_request.stop, list):
+            generation_config["stopSequences"] = openai_request.stop
+    if openai_request.frequency_penalty is not None:
+        generation_config["frequencyPenalty"] = openai_request.frequency_penalty
+    if openai_request.presence_penalty is not None:
+        generation_config["presencePenalty"] = openai_request.presence_penalty
+    if openai_request.n is not None:
+        generation_config["candidateCount"] = openai_request.n
+    if openai_request.seed is not None:
+        generation_config["seed"] = openai_request.seed
+    if openai_request.response_format is not None:
+        # 处理JSON模式
+        if openai_request.response_format.get("type") == "json_object":
+            generation_config["responseMimeType"] = "application/json"
+
+    # 如果contents为空（只有系统消息的情况），添加一个默认的用户消息以满足Gemini API要求
+    if not contents:
+        contents.append({"role": "user", "parts": [{"text": "请根据系统指令回答。"}]})
+    
+    # 构建请求数据
+    request_data = {
+        "contents": contents,
+        "generationConfig": generation_config,
+        "safetySettings": DEFAULT_SAFETY_SETTINGS,
+    }
+    
+    # 如果有系统消息且未启用兼容性模式，添加systemInstruction
+    if system_instructions and not compatibility_mode:
+        combined_system_instruction = "\n\n".join(system_instructions)
+        request_data["systemInstruction"] = {"parts": [{"text": combined_system_instruction}]}
+    
+    log.debug(f"Final request payload contents count: {len(contents)}, system_instruction: {bool(system_instructions and not compatibility_mode)}, compatibility_mode: {compatibility_mode}")
+    
+    # 为thinking模型添加thinking配置
+    thinking_budget = get_thinking_budget(openai_request.model)
+    if thinking_budget is not None:
+        request_data["generationConfig"]["thinkingConfig"] = {
+            "thinkingBudget": thinking_budget,
+            "includeThoughts": should_include_thoughts(openai_request.model)
+        }
+    
+    # 为搜索模型添加Google Search工具
+    if is_search_model(openai_request.model):
+        request_data["tools"] = [{"googleSearch": {}}]
+
+    # 移除None值
+    request_data = {k: v for k, v in request_data.items() if v is not None}
+    
+    # 返回完整的Gemini API payload格式
+    return {
+        "model": get_base_model_name(openai_request.model),
+        "request": request_data
+    }
+
+def _extract_content_and_reasoning(parts: list) -> tuple:
+    """从Gemini响应部件中提取内容和推理内容"""
+    content = ""
+    reasoning_content = ""
+    
+    for part in parts:
+        # 处理文本内容
+        if part.get("text"):
+            # 检查这个部件是否包含thinking tokens
+            if part.get("thought", False):
+                reasoning_content += part.get("text", "")
+            else:
+                content += part.get("text", "")
+    
+    return content, reasoning_content
+
+def _build_message_with_reasoning(role: str, content: str, reasoning_content: str) -> dict:
+    """构建包含可选推理内容的消息对象"""
+    message = {
+        "role": role,
+        "content": content
+    }
+    
+    # 如果有thinking tokens，添加reasoning_content
+    if reasoning_content:
+        message["reasoning_content"] = reasoning_content
+    
+    return message
+
+def gemini_response_to_openai(gemini_response: Dict[str, Any], model: str) -> Dict[str, Any]:
+    """
+    将Gemini API响应转换为OpenAI聊天完成格式
+    
+    Args:
+        gemini_response: 来自Gemini API的响应
+        model: 要在响应中包含的模型名称
+        
+    Returns:
+        OpenAI聊天完成格式的字典
+    """
+    choices = []
+    
+    for candidate in gemini_response.get("candidates", []):
+        role = candidate.get("content", {}).get("role", "assistant")
+        
+        # 将Gemini角色映射回OpenAI角色
+        if role == "model":
+            role = "assistant"
+        
+        # 提取并分离thinking tokens和常规内容
+        parts = candidate.get("content", {}).get("parts", [])
+        content, reasoning_content = _extract_content_and_reasoning(parts)
+        
+        # 构建消息对象
+        message = _build_message_with_reasoning(role, content, reasoning_content)
+        
+        choices.append({
+            "index": candidate.get("index", 0),
+            "message": message,
+            "finish_reason": _map_finish_reason(candidate.get("finishReason")),
+        })
+    
+    return {
+        "id": str(uuid.uuid4()),
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+    }
+
+def gemini_stream_chunk_to_openai(gemini_chunk: Dict[str, Any], model: str, response_id: str) -> Dict[str, Any]:
+    """
+    将Gemini流式响应块转换为OpenAI流式格式
+    
+    Args:
+        gemini_chunk: 来自Gemini流式响应的单个块
+        model: 要在响应中包含的模型名称
+        response_id: 此流式响应的一致ID
+        
+    Returns:
+        OpenAI流式格式的字典
+    """
+    choices = []
+    
+    for candidate in gemini_chunk.get("candidates", []):
+        role = candidate.get("content", {}).get("role", "assistant")
+        
+        # 将Gemini角色映射回OpenAI角色
+        if role == "model":
+            role = "assistant"
+        
+        # 提取并分离thinking tokens和常规内容
+        parts = candidate.get("content", {}).get("parts", [])
+        content, reasoning_content = _extract_content_and_reasoning(parts)
+        
+        # 构建delta对象
+        delta = {}
+        if content:
+            delta["content"] = content
+        if reasoning_content:
+            delta["reasoning_content"] = reasoning_content
+        
+        choices.append({
+            "index": candidate.get("index", 0),
+            "delta": delta,
+            "finish_reason": _map_finish_reason(candidate.get("finishReason")),
+        })
+    
+    return {
+        "id": response_id,
+        "object": "chat.completion.chunk",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+    }
+
+def _map_finish_reason(gemini_reason: str) -> str:
+    """
+    将Gemini结束原因映射到OpenAI结束原因
+    
+    Args:
+        gemini_reason: 来自Gemini API的结束原因
+        
+    Returns:
+        OpenAI兼容的结束原因
+    """
+    if gemini_reason == "STOP":
+        return "stop"
+    elif gemini_reason == "MAX_TOKENS":
+        return "length"
+    elif gemini_reason in ["SAFETY", "RECITATION"]:
+        return "content_filter"
+    else:
+        return None
+
+def validate_openai_request(request_data: Dict[str, Any]) -> ChatCompletionRequest:
+    """
+    验证并标准化OpenAI请求数据
+    
+    Args:
+        request_data: 原始请求数据字典
+        
+    Returns:
+        验证后的ChatCompletionRequest对象
+        
+    Raises:
+        ValueError: 当请求数据无效时
+    """
+    try:
+        return ChatCompletionRequest(**request_data)
+    except Exception as e:
+        raise ValueError(f"Invalid OpenAI request format: {str(e)}")
+
+def normalize_openai_request(request_data: ChatCompletionRequest) -> ChatCompletionRequest:
+    """
+    标准化OpenAI请求数据，应用默认值和限制
+    
+    Args:
+        request_data: 原始请求对象
+        
+    Returns:
+        标准化后的请求对象
+    """
+    # 限制max_tokens
+    if getattr(request_data, "max_tokens", None) is not None and request_data.max_tokens > 65535:
+        request_data.max_tokens = 65535
+        
+    # 覆写 top_k 为 64
+    setattr(request_data, "top_k", 64)
+
+    # 过滤空消息
+    filtered_messages = []
+    for m in request_data.messages:
+        content = getattr(m, "content", None)
+        if content:
+            if isinstance(content, str) and content.strip():
+                filtered_messages.append(m)
+            elif isinstance(content, list) and len(content) > 0:
+                has_valid_content = False
+                for part in content:
+                    if isinstance(part, dict):
+                        if part.get("type") == "text" and part.get("text", "").strip():
+                            has_valid_content = True
+                            break
+                        elif part.get("type") == "image_url" and part.get("image_url", {}).get("url"):
+                            has_valid_content = True
+                            break
+                if has_valid_content:
+                    filtered_messages.append(m)
+    
+    request_data.messages = filtered_messages
+    
+    return request_data
+
+def is_health_check_request(request_data: ChatCompletionRequest) -> bool:
+    """
+    检查是否为健康检查请求
+    
+    Args:
+        request_data: 请求对象
+        
+    Returns:
+        是否为健康检查请求
+    """
+    return (len(request_data.messages) == 1 and 
+            getattr(request_data.messages[0], "role", None) == "user" and
+            getattr(request_data.messages[0], "content", None) == "Hi")
+
+def create_health_check_response() -> Dict[str, Any]:
+    """
+    创建健康检查响应
+    
+    Returns:
+        健康检查响应字典
+    """
+    return {
+        "choices": [{
+            "message": {
+                "role": "assistant", 
+                "content": "gcli2api正常工作中"
+            }
+        }]
+    }
+
+def extract_model_settings(model: str) -> Dict[str, Any]:
+    """
+    从模型名称中提取设置信息
+    
+    Args:
+        model: 模型名称
+        
+    Returns:
+        包含模型设置的字典
+    """
+    return {
+        "base_model": get_base_model_name(model),
+        "use_fake_streaming": model.endswith("-假流式"),
+        "thinking_budget": get_thinking_budget(model),
+        "include_thoughts": should_include_thoughts(model)
+    }

src/state_manager.py

@@ -0,0 +1,166 @@
+"""
+统一状态管理器
+"""
+import asyncio
+import os
+from typing import Dict, Any
+from contextlib import asynccontextmanager
+
+from config import is_mongodb_mode
+from log import log
+from .storage_adapter import get_storage_adapter
+
+
+class StateManager:
+    """
+    统一状态管理器
+    """
+    
+    def __init__(self, state_file_path: str):
+        self.state_file_path = state_file_path
+        self._lock = asyncio.Lock()
+        self._storage_adapter = None
+        self._initialized = False
+        
+        # 从文件路径推断存储用途
+        self._storage_purpose = self._infer_storage_purpose(state_file_path)
+    
+    def _infer_storage_purpose(self, file_path: str) -> str:
+        """根据文件路径推断存储用途"""
+        filename = os.path.basename(file_path)
+        
+        if "creds_state" in filename:
+            return "credential_state"
+        elif "config" in filename:
+            return "config"
+        elif "usage" in filename or "stats" in filename:
+            return "usage_stats"
+        else:
+            return "general"
+    
+    async def _ensure_initialized(self):
+        """确保状态管理器已初始化"""
+        if not self._initialized:
+            self._storage_adapter = await get_storage_adapter()
+            self._initialized = True
+            
+            if await is_mongodb_mode():
+                log.debug(f"Unified state manager initialized with MongoDB backend for: {self._storage_purpose}")
+            else:
+                log.debug(f"Unified state manager initialized with file backend for: {self._storage_purpose}")
+    
+    async def _load_state(self) -> Dict[str, Any]:
+        """加载状态数据"""
+        await self._ensure_initialized()
+        
+        if self._storage_purpose == "credential_state":
+            return await self._storage_adapter.get_all_credential_states()
+        elif self._storage_purpose == "config":
+            return await self._storage_adapter.get_all_config()
+        elif self._storage_purpose == "usage_stats":
+            return await self._storage_adapter.get_all_usage_stats()
+        else:
+            # 对于通用存储，尝试获取配置数据
+            return await self._storage_adapter.get_all_config()
+    
+    async def _save_state(self, state: Dict[str, Any]):
+        """保存状态数据"""
+        await self._ensure_initialized()
+        
+        # 根据存储用途批量更新数据
+        if self._storage_purpose == "credential_state":
+            # 批量更新凭证状态
+            for filename, file_state in state.items():
+                await self._storage_adapter.update_credential_state(filename, file_state)
+        elif self._storage_purpose == "config":
+            # 批量更新配置
+            for key, value in state.items():
+                await self._storage_adapter.set_config(key, value)
+        elif self._storage_purpose == "usage_stats":
+            # 批量更新使用统计
+            for filename, stats in state.items():
+                await self._storage_adapter.update_usage_stats(filename, stats)
+        else:
+            # 通用存储，作为配置处理
+            for key, value in state.items():
+                await self._storage_adapter.set_config(key, value)
+    
+    @asynccontextmanager
+    async def transaction(self):
+        """
+        事务上下文管理器，兼容原有接口。
+        Usage:
+            async with state_manager.transaction() as state:
+                state['key'] = 'value'
+                # State is automatically saved on exit
+        """
+        async with self._lock:
+            state = await self._load_state()
+            try:
+                yield state
+                await self._save_state(state)
+            except Exception:
+                # Don't save if there was an error
+                raise
+    
+    async def read_file_state(self, filename: str) -> Dict[str, Any]:
+        """读取特定文件的状态，兼容原有接口"""
+        await self._ensure_initialized()
+        
+        if self._storage_purpose == "credential_state":
+            return await self._storage_adapter.get_credential_state(filename)
+        elif self._storage_purpose == "usage_stats":
+            return await self._storage_adapter.get_usage_stats(filename)
+        else:
+            # 对于配置和通用存储，filename作为配置键
+            value = await self._storage_adapter.get_config(filename)
+            return value if isinstance(value, dict) else {}
+    
+    async def update_file_state(self, filename: str, updates: Dict[str, Any]):
+        """更新特定文件的状态，兼容原有接口"""
+        await self._ensure_initialized()
+        
+        if self._storage_purpose == "credential_state":
+            await self._storage_adapter.update_credential_state(filename, updates)
+        elif self._storage_purpose == "usage_stats":
+            await self._storage_adapter.update_usage_stats(filename, updates)
+        else:
+            # 对于配置存储，如果updates是字典则作为嵌套配置处理
+            if isinstance(updates, dict) and len(updates) == 1:
+                # 如果只有一个键值对，可能是设置单个配置
+                for key, value in updates.items():
+                    await self._storage_adapter.set_config(f"{filename}.{key}", value)
+            else:
+                # 否则将整个updates作为配置值
+                await self._storage_adapter.set_config(filename, updates)
+    
+    async def batch_update(self, updates: Dict[str, Dict[str, Any]]):
+        """批量更新多个文件，兼容原有接口"""
+        await self._ensure_initialized()
+        
+        for filename, file_updates in updates.items():
+            await self.update_file_state(filename, file_updates)
+
+
+# 全局状态管理器实例缓存
+_state_managers: Dict[str, StateManager] = {}
+
+
+def get_state_manager(state_file_path: str) -> StateManager:
+    """获取或创建状态管理器实例，兼容原有接口"""
+    if state_file_path not in _state_managers:
+        _state_managers[state_file_path] = StateManager(state_file_path)
+    return _state_managers[state_file_path]
+
+
+async def close_all_state_managers():
+    """关闭所有状态管理器（用于优雅关闭）"""
+    global _state_managers
+    
+    # 关闭存储适配器（这会自动处理所有状态管理器）
+    from .storage_adapter import close_storage_adapter
+    await close_storage_adapter()
+    
+    # 清空缓存
+    _state_managers.clear()
+    log.debug("All state managers closed")

src/storage/cache_manager.py

@@ -0,0 +1,312 @@
+"""
+统一内存缓存管理器
+为所有存储后端提供一致的内存缓存机制，确保读写一致性和高性能。
+"""
+import asyncio
+import time
+from typing import Dict, Any, Optional
+from collections import deque
+from abc import ABC, abstractmethod
+
+from log import log
+
+
+class CacheBackend(ABC):
+    """缓存后端接口，定义底层存储的读写操作"""
+    
+    @abstractmethod
+    async def load_data(self) -> Dict[str, Any]:
+        """从底层存储加载数据"""
+        pass
+    
+    @abstractmethod
+    async def write_data(self, data: Dict[str, Any]) -> bool:
+        """将数据写入底层存储"""
+        pass
+
+
+class UnifiedCacheManager:
+    """统一缓存管理器"""
+    
+    def __init__(
+        self,
+        cache_backend: CacheBackend,
+        cache_ttl: float = 300.0,
+        write_delay: float = 1.0,
+        name: str = "cache"
+    ):
+        """
+        初始化缓存管理器
+        
+        Args:
+            cache_backend: 缓存后端实现
+            cache_ttl: 缓存TTL（秒）
+            write_delay: 写入延迟（秒）
+            name: 缓存名称（用于日志）
+        """
+        self._backend = cache_backend
+        self._cache_ttl = cache_ttl
+        self._write_delay = write_delay
+        self._name = name
+        
+        # 缓存数据
+        self._cache: Dict[str, Any] = {}
+        self._cache_dirty = False
+        self._last_cache_time = 0
+        
+        # 并发控制
+        self._cache_lock = asyncio.Lock()
+        
+        # 异步写回任务
+        self._write_task: Optional[asyncio.Task] = None
+        self._shutdown_event = asyncio.Event()
+        
+        # 性能监控
+        self._operation_count = 0
+        self._operation_times = deque(maxlen=1000)
+    
+    async def start(self):
+        """启动缓存管理器"""
+        if self._write_task and not self._write_task.done():
+            return
+        
+        self._shutdown_event.clear()
+        self._write_task = asyncio.create_task(self._write_loop())
+        log.debug(f"{self._name} cache manager started")
+    
+    async def stop(self):
+        """停止缓存管理器并刷新数据"""
+        self._shutdown_event.set()
+        
+        if self._write_task and not self._write_task.done():
+            try:
+                await asyncio.wait_for(self._write_task, timeout=5.0)
+            except asyncio.TimeoutError:
+                self._write_task.cancel()
+                log.warning(f"{self._name} cache writer forcibly cancelled")
+        
+        # 刷新缓存
+        await self._flush_cache()
+        log.debug(f"{self._name} cache manager stopped")
+    
+    async def get(self, key: str, default: Any = None) -> Any:
+        """获取缓存项"""
+        async with self._cache_lock:
+            start_time = time.time()
+            
+            try:
+                # 确保缓存已加载
+                await self._ensure_cache_loaded()
+                
+                # 性能监控
+                self._operation_count += 1
+                operation_time = time.time() - start_time
+                self._operation_times.append(operation_time)
+                
+                result = self._cache.get(key, default)
+                log.debug(f"{self._name} cache get: {key} in {operation_time:.3f}s")
+                return result
+                
+            except Exception as e:
+                operation_time = time.time() - start_time
+                log.error(f"Error getting {self._name} cache key {key} in {operation_time:.3f}s: {e}")
+                return default
+    
+    async def set(self, key: str, value: Any) -> bool:
+        """设置缓存项"""
+        async with self._cache_lock:
+            start_time = time.time()
+            
+            try:
+                # 确保缓存已加载
+                await self._ensure_cache_loaded()
+                
+                # 更新缓存
+                self._cache[key] = value
+                self._cache_dirty = True
+                
+                # 性能监控
+                self._operation_count += 1
+                operation_time = time.time() - start_time
+                self._operation_times.append(operation_time)
+                
+                log.debug(f"{self._name} cache set: {key} in {operation_time:.3f}s")
+                return True
+                
+            except Exception as e:
+                operation_time = time.time() - start_time
+                log.error(f"Error setting {self._name} cache key {key} in {operation_time:.3f}s: {e}")
+                return False
+    
+    async def delete(self, key: str) -> bool:
+        """删除缓存项"""
+        async with self._cache_lock:
+            start_time = time.time()
+            
+            try:
+                # 确保缓存已加载
+                await self._ensure_cache_loaded()
+                
+                if key in self._cache:
+                    del self._cache[key]
+                    self._cache_dirty = True
+                    
+                    # 性能监控
+                    self._operation_count += 1
+                    operation_time = time.time() - start_time
+                    self._operation_times.append(operation_time)
+                    
+                    log.debug(f"{self._name} cache delete: {key} in {operation_time:.3f}s")
+                    return True
+                else:
+                    log.warning(f"{self._name} cache key not found for deletion: {key}")
+                    return False
+                    
+            except Exception as e:
+                operation_time = time.time() - start_time
+                log.error(f"Error deleting {self._name} cache key {key} in {operation_time:.3f}s: {e}")
+                return False
+    
+    async def get_all(self) -> Dict[str, Any]:
+        """获取所有缓存数据"""
+        async with self._cache_lock:
+            start_time = time.time()
+            
+            try:
+                # 确保缓存已加载
+                await self._ensure_cache_loaded()
+                
+                # 性能监控
+                self._operation_count += 1
+                operation_time = time.time() - start_time
+                self._operation_times.append(operation_time)
+                
+                log.debug(f"{self._name} cache get_all ({len(self._cache)}) in {operation_time:.3f}s")
+                return self._cache.copy()
+                
+            except Exception as e:
+                operation_time = time.time() - start_time
+                log.error(f"Error getting all {self._name} cache in {operation_time:.3f}s: {e}")
+                return {}
+    
+    async def update_multi(self, updates: Dict[str, Any]) -> bool:
+        """批量更新缓存项"""
+        async with self._cache_lock:
+            start_time = time.time()
+            
+            try:
+                # 确保缓存已加载
+                await self._ensure_cache_loaded()
+                
+                # 批量更新
+                self._cache.update(updates)
+                self._cache_dirty = True
+                
+                # 性能监控
+                self._operation_count += 1
+                operation_time = time.time() - start_time
+                self._operation_times.append(operation_time)
+                
+                log.debug(f"{self._name} cache update_multi ({len(updates)}) in {operation_time:.3f}s")
+                return True
+                
+            except Exception as e:
+                operation_time = time.time() - start_time
+                log.error(f"Error updating {self._name} cache multi in {operation_time:.3f}s: {e}")
+                return False
+    
+    async def _ensure_cache_loaded(self):
+        """确保缓存已从底层存储加载"""
+        current_time = time.time()
+        
+        # 检查缓存是否需要加载（首次加载或过期）
+        # 如果缓存脏了（有未写入的数据），不要重新加载以避免数据丢失
+        if (self._last_cache_time == 0 or 
+            (current_time - self._last_cache_time > self._cache_ttl and not self._cache_dirty)):
+            
+            await self._load_cache()
+            self._last_cache_time = current_time
+    
+    async def _load_cache(self):
+        """从底层存储加载缓存"""
+        try:
+            start_time = time.time()
+            
+            # 从后端加载数据
+            data = await self._backend.load_data()
+            
+            if data:
+                self._cache = data
+                log.debug(f"{self._name} cache loaded ({len(self._cache)}) from backend")
+            else:
+                # 如果后端没有数据，初始化空缓存
+                self._cache = {}
+                log.debug(f"{self._name} cache initialized empty")
+            
+            operation_time = time.time() - start_time
+            log.debug(f"{self._name} cache loaded in {operation_time:.3f}s")
+            
+        except Exception as e:
+            log.error(f"Error loading {self._name} cache from backend: {e}")
+            self._cache = {}
+    
+    async def _write_loop(self):
+        """异步写回循环"""
+        while not self._shutdown_event.is_set():
+            try:
+                # 等待写入延迟或关闭信号
+                try:
+                    await asyncio.wait_for(self._shutdown_event.wait(), timeout=self._write_delay)
+                    break  # 收到关闭信号
+                except asyncio.TimeoutError:
+                    pass  # 超时，检查是否需要写回
+                
+                # 如果缓存脏了，写回底层存储
+                async with self._cache_lock:
+                    if self._cache_dirty:
+                        await self._write_cache()
+                
+            except Exception as e:
+                log.error(f"Error in {self._name} cache writer loop: {e}")
+                await asyncio.sleep(1)
+    
+    async def _write_cache(self):
+        """将缓存写回底层存储"""
+        if not self._cache_dirty:
+            return
+        
+        try:
+            start_time = time.time()
+            
+            # 写入后端
+            success = await self._backend.write_data(self._cache.copy())
+            
+            if success:
+                self._cache_dirty = False
+                operation_time = time.time() - start_time
+                log.debug(f"{self._name} cache written to backend in {operation_time:.3f}s ({len(self._cache)} items)")
+            else:
+                log.error(f"Failed to write {self._name} cache to backend")
+            
+        except Exception as e:
+            log.error(f"Error writing {self._name} cache to backend: {e}")
+    
+    async def _flush_cache(self):
+        """立即刷新缓存到底层存储"""
+        async with self._cache_lock:
+            if self._cache_dirty:
+                await self._write_cache()
+                log.debug(f"{self._name} cache flushed to backend")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """获取缓存统计信息"""
+        avg_time = sum(self._operation_times) / len(self._operation_times) if self._operation_times else 0
+        
+        return {
+            "cache_name": self._name,
+            "cache_size": len(self._cache),
+            "cache_dirty": self._cache_dirty,
+            "operation_count": self._operation_count,
+            "avg_operation_time": avg_time,
+            "last_cache_time": self._last_cache_time,
+        }

src/storage/file_storage_manager.py

@@ -0,0 +1,606 @@
+"""
+本地文件存储管理器，使用统一缓存支持队列写入优化。
+所有凭证和状态数据存储在creds.toml中，配置数据存储在config.toml中。
+"""
+import asyncio
+import os
+import json
+import time
+from typing import Dict, Any, List, Optional
+
+import aiofiles
+import toml
+
+from log import log
+from .cache_manager import UnifiedCacheManager, CacheBackend
+
+
+class FileCacheBackend(CacheBackend):
+    """文件缓存后端实现"""
+    
+    def __init__(self, file_path: str):
+        self._file_path = file_path
+    
+    async def load_data(self) -> Dict[str, Any]:
+        """从TOML文件加载数据"""
+        try:
+            if not os.path.exists(self._file_path):
+                return {}
+            
+            async with aiofiles.open(self._file_path, "r", encoding="utf-8") as f:
+                content = await f.read()
+            
+            if not content.strip():
+                return {}
+            
+            return toml.loads(content)
+            
+        except Exception as e:
+            log.error(f"Error loading data from file {self._file_path}: {e}")
+            return {}
+    
+    async def write_data(self, data: Dict[str, Any]) -> bool:
+        """将数据写入TOML文件"""
+        try:
+            # 确保目录存在
+            os.makedirs(os.path.dirname(self._file_path), exist_ok=True)
+            
+            # 写入TOML文件
+            toml_content = toml.dumps(data)
+            async with aiofiles.open(self._file_path, "w", encoding="utf-8") as f:
+                await f.write(toml_content)
+            
+            return True
+            
+        except Exception as e:
+            log.error(f"Error writing data to file {self._file_path}: {e}")
+            return False
+
+
+class FileStorageManager:
+    """基于本地文件的存储管理器（使用统一缓存）"""
+    
+    # 状态字段常量
+    STATE_FIELDS = {
+        "error_codes", "disabled", "last_success", "user_email",
+        "gemini_2_5_pro_calls", "total_calls", "next_reset_time",
+        "daily_limit_gemini_2_5_pro", "daily_limit_total"
+    }
+    
+    # 默认状态数据模板（不包含动态值）
+    _DEFAULT_STATE_TEMPLATE = {
+        "error_codes": [],
+        "disabled": False,
+        "user_email": None,
+        "gemini_2_5_pro_calls": 0,
+        "total_calls": 0,
+        "next_reset_time": None,
+        "daily_limit_gemini_2_5_pro": 100,
+        "daily_limit_total": 1000
+    }
+    
+    @classmethod
+    def get_default_state(cls) -> Dict[str, Any]:
+        """获取默认状态数据（包含当前时间戳）"""
+        state = cls._DEFAULT_STATE_TEMPLATE.copy()
+        state["last_success"] = time.time()
+        return state
+    
+    def __init__(self):
+        self._credentials_dir = None  # 将通过异步初始化设置
+        self._state_file = None
+        self._config_file = None
+        self._lock = asyncio.Lock()
+        self._initialized = False
+        
+        # 统一缓存管理器
+        self._credentials_cache_manager: Optional[UnifiedCacheManager] = None
+        self._config_cache_manager: Optional[UnifiedCacheManager] = None
+        
+        # 配置参数
+        self._write_delay = 0.5  # 写入延迟（秒）
+        self._cache_ttl = 300  # 缓存TTL（秒）
+    
+    async def initialize(self) -> None:
+        """初始化文件存储"""
+        if self._initialized:
+            return
+        
+        # 获取凭证目录配置（初始化时直接使用环境变量，避免循环依赖）
+        self._credentials_dir = os.getenv("CREDENTIALS_DIR", "./creds")
+        self._state_file = os.path.join(self._credentials_dir, "creds.toml")
+        self._config_file = os.path.join(self._credentials_dir, "config.toml")
+        
+        # 确保目录存在
+        os.makedirs(self._credentials_dir, exist_ok=True)
+        
+        # 执行JSON到TOML的迁移
+        await self._migrate_json_to_toml()
+        
+        # 创建缓存管理器
+        credentials_backend = FileCacheBackend(self._state_file)
+        config_backend = FileCacheBackend(self._config_file)
+        
+        self._credentials_cache_manager = UnifiedCacheManager(
+            credentials_backend,
+            cache_ttl=self._cache_ttl,
+            write_delay=self._write_delay,
+            name="credentials"
+        )
+        
+        self._config_cache_manager = UnifiedCacheManager(
+            config_backend,
+            cache_ttl=self._cache_ttl,
+            write_delay=self._write_delay,
+            name="config"
+        )
+        
+        # 启动缓存管理器
+        await self._credentials_cache_manager.start()
+        await self._config_cache_manager.start()
+        
+        self._initialized = True
+        log.debug("File storage manager initialized with unified cache")
+    
+    async def close(self) -> None:
+        """关闭文件存储"""
+        # 停止缓存管理器
+        if self._credentials_cache_manager:
+            await self._credentials_cache_manager.stop()
+        if self._config_cache_manager:
+            await self._config_cache_manager.stop()
+        
+        self._initialized = False
+        log.debug("File storage manager closed with unified cache flushed")
+    
+    def _normalize_filename(self, filename: str) -> str:
+        """标准化文件名"""
+        return os.path.basename(filename)
+    
+    def _ensure_initialized(self):
+        """确保已初始化"""
+        if not self._initialized:
+            raise RuntimeError("File storage manager not initialized")
+    
+    async def _migrate_json_to_toml(self) -> None:
+        """将现有的JSON凭证文件和旧的creds_state.toml迁移到新的creds.toml文件中"""
+        try:
+            # 扫描JSON凭证文件
+            json_files = []
+            if os.path.exists(self._credentials_dir):
+                for filename in os.listdir(self._credentials_dir):
+                    if filename.endswith(".json"):
+                        json_files.append(filename)
+            
+            # 检查旧的creds_state.toml文件
+            old_state_file = os.path.join(self._credentials_dir, "creds_state.toml")
+            has_old_state = os.path.exists(old_state_file)
+            
+            if not json_files and not has_old_state:
+                log.debug("No JSON credential files or old state file found for migration")
+                return
+            
+            # 加载现有TOML数据（如果存在）
+            toml_data = {}
+            if os.path.exists(self._state_file):
+                try:
+                    async with aiofiles.open(self._state_file, "r", encoding="utf-8") as f:
+                        content = await f.read()
+                    if content.strip():
+                        toml_data = toml.loads(content)
+                except Exception as e:
+                    log.error(f"Failed to load existing TOML file: {e}")
+            
+            # 加载旧的creds_state.toml文件（稍后处理）
+            old_state_data = {}
+            if has_old_state:
+                try:
+                    async with aiofiles.open(old_state_file, "r", encoding="utf-8") as f:
+                        content = await f.read()
+                    old_state_data = toml.loads(content)
+                    log.debug("Loaded old state file for potential migration")
+                except Exception as e:
+                    log.error(f"Failed to load old state file: {e}")
+                    old_state_data = {}
+            
+            if json_files:
+                log.info(f"Migrating {len(json_files)} JSON credential files to TOML")
+            
+            # 处理每个JSON文件
+            migrated_count = 0
+            for filename in json_files:
+                try:
+                    filepath = os.path.join(self._credentials_dir, filename)
+                    
+                    # 读取JSON凭证数据
+                    async with aiofiles.open(filepath, "r", encoding="utf-8") as f:
+                        json_content = await f.read()
+                    credential_data = json.loads(json_content)
+                    
+                    # 创建新的section：凭证数据 + 状态数据
+                    section_data = credential_data.copy()
+                    
+                    # 首先添加默认状态数据
+                    section_data.update(self.get_default_state())
+                    
+                    # 如果旧状态文件中有该凭证的状态数据，则使用旧状态数据覆盖默认值
+                    if filename in old_state_data and isinstance(old_state_data[filename], dict):
+                        log.debug(f"Using old state data for: {filename}")
+                        section_data.update(old_state_data[filename])
+                    
+                    # 如果当前TOML中已存在该凭证，保留其状态数据
+                    if filename in toml_data and isinstance(toml_data[filename], dict):
+                        log.debug(f"Merging with existing TOML state for: {filename}")
+                        existing_state = toml_data[filename]
+                        section_data.update(existing_state)
+                    
+                    # 最后确保凭证数据是最新的（覆盖任何冲突的字段）
+                    section_data.update(credential_data)
+                    
+                    toml_data[filename] = section_data
+                    
+                    migrated_count += 1
+                    log.debug(f"Migrated credential: {filename}")
+                    
+                except Exception as e:
+                    log.error(f"Failed to migrate {filename}: {e}")
+                    continue
+            
+            # 保存TOML文件（如果有新的迁移）
+            if migrated_count > 0:
+                try:
+                    toml_content = toml.dumps(toml_data)
+                    async with aiofiles.open(self._state_file, "w", encoding="utf-8") as f:
+                        await f.write(toml_content)
+                    
+                    # 删除已迁移的JSON文件
+                    for filename in json_files:
+                        try:
+                            if filename in toml_data:  # 确保文件确实被迁移了
+                                filepath = os.path.join(self._credentials_dir, filename)
+                                os.remove(filepath)
+                                log.debug(f"Removed migrated JSON file: {filename}")
+                        except Exception as e:
+                            log.warning(f"Failed to remove {filename}: {e}")
+                    
+                    # 删除旧的状态文件（如果存在）
+                    if has_old_state:
+                        try:
+                            os.remove(old_state_file)
+                            log.debug("Removed old state file: creds_state.toml")
+                        except Exception as e:
+                            log.warning(f"Failed to remove old state file: {e}")
+                    
+                    log.info(f"Migration completed: {migrated_count} files migrated to TOML format")
+                
+                except Exception as e:
+                    log.error(f"Failed to save migrated TOML file: {e}")
+            
+        except Exception as e:
+            log.error(f"Error during JSON to TOML migration: {e}")
+    
+    # ============ 凭证管理 ============
+    
+    async def store_credential(self, filename: str, credential_data: Dict[str, Any]) -> bool:
+        """存储凭证数据到统一缓存"""
+        self._ensure_initialized()
+        
+        try:
+            filename = self._normalize_filename(filename)
+            
+            # 获取现有数据或创建新数据
+            all_data = await self._credentials_cache_manager.get_all()
+            existing_state = all_data.get(filename, {})
+            
+            # 创建新的section数据：凭证数据 + 状态数据
+            final_data = self.get_default_state()
+            final_data.update(existing_state)
+            final_data.update(credential_data)  # 凭证数据覆盖状态数据中的同名字段
+            
+            # 更新整个数据集
+            all_data[filename] = final_data
+            
+            success = await self._credentials_cache_manager.update_multi({filename: final_data})
+            log.debug(f"Stored credential to unified cache: {filename}")
+            return success
+            
+        except Exception as e:
+            log.error(f"Error storing credential {filename}: {e}")
+            return False
+    
+    async def get_credential(self, filename: str) -> Optional[Dict[str, Any]]:
+        """从统一缓存获取凭证数据"""
+        self._ensure_initialized()
+        
+        try:
+            filename = self._normalize_filename(filename)
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            if filename not in all_data:
+                return None
+            
+            section_data = all_data[filename]
+            
+            # 提取凭证数据（排除状态字段）
+            credential_data = {k: v for k, v in section_data.items() if k not in self.STATE_FIELDS}
+            return credential_data
+            
+        except Exception as e:
+            log.error(f"Error getting credential {filename}: {e}")
+            return None
+    
+    async def list_credentials(self) -> List[str]:
+        """从统一缓存列出所有凭证文件名"""
+        self._ensure_initialized()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            return list(all_data.keys())
+            
+        except Exception as e:
+            log.error(f"Error listing credentials: {e}")
+            return []
+    
+    async def delete_credential(self, filename: str) -> bool:
+        """从统一缓存删除凭证"""
+        self._ensure_initialized()
+        
+        try:
+            filename = self._normalize_filename(filename)
+            success = await self._credentials_cache_manager.delete(filename)
+            log.debug(f"Deleted credential from unified cache: {filename}")
+            return success
+            
+        except Exception as e:
+            log.error(f"Error deleting credential {filename}: {e}")
+            return False
+    
+    # ============ 状态管理 ============
+    
+    async def update_credential_state(self, filename: str, state_updates: Dict[str, Any]) -> bool:
+        """更新凭证状态"""
+        self._ensure_initialized()
+        
+        try:
+            filename = self._normalize_filename(filename)
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            if filename not in all_data:
+                all_data[filename] = self.get_default_state()
+            
+            # 更新状态
+            all_data[filename].update(state_updates)
+            
+            success = await self._credentials_cache_manager.update_multi({filename: all_data[filename]})
+            log.debug(f"Updated credential state in unified cache: {filename}")
+            return success
+            
+        except Exception as e:
+            log.error(f"Error updating credential state {filename}: {e}")
+            return False
+    
+    async def get_credential_state(self, filename: str) -> Dict[str, Any]:
+        """从统一缓存获取凭证状态"""
+        self._ensure_initialized()
+        
+        try:
+            filename = self._normalize_filename(filename)
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            if filename not in all_data:
+                # 返回基本的状态字段
+                default_state = self.get_default_state()
+                return {k: v for k, v in default_state.items() if k in {"error_codes", "disabled", "last_success", "user_email"}}
+            
+            section_data = all_data[filename]
+            
+            # 提取状态字段
+            state_data = {k: v for k, v in section_data.items() if k in self.STATE_FIELDS}
+            
+            # 确保必要字段存在
+            basic_fields = {"error_codes", "disabled", "last_success", "user_email"}
+            default_state = self.get_default_state()
+            
+            for field in basic_fields:
+                if field not in state_data:
+                    state_data[field] = default_state[field]
+            
+            return state_data
+            
+        except Exception as e:
+            log.error(f"Error getting credential state {filename}: {e}")
+            return self.get_default_state()
+    
+    async def get_all_credential_states(self) -> Dict[str, Dict[str, Any]]:
+        """从统一缓存获取所有凭证状态"""
+        self._ensure_initialized()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            states = {}
+            for filename, section_data in all_data.items():
+                # 提取状态字段
+                state_data = {k: v for k, v in section_data.items() if k in self.STATE_FIELDS}
+                
+                # 确保必要字段存在
+                basic_fields = {"error_codes", "disabled", "last_success", "user_email"}
+                default_state = self.get_default_state()
+                
+                for field in basic_fields:
+                    if field not in state_data:
+                        state_data[field] = default_state[field]
+                
+                states[filename] = state_data
+            
+            return states
+            
+        except Exception as e:
+            log.error(f"Error getting all credential states: {e}")
+            return {}
+    
+    # ============ 配置管理 ============
+    
+    async def set_config(self, key: str, value: Any) -> bool:
+        """设置配置到统一缓存"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.set(key, value)
+    
+    async def get_config(self, key: str, default: Any = None) -> Any:
+        """从统一缓存获取配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.get(key, default)
+    
+    async def get_all_config(self) -> Dict[str, Any]:
+        """从统一缓存获取所有配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.get_all()
+    
+    async def delete_config(self, key: str) -> bool:
+        """从统一缓存删除配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.delete(key)
+    
+    # ============ 使用统计管理 ============
+    
+    async def update_usage_stats(self, filename: str, stats_updates: Dict[str, Any]) -> bool:
+        """更新使用统计"""
+        self._ensure_initialized()
+        
+        try:
+            filename = self._normalize_filename(filename)
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            if filename not in all_data:
+                all_data[filename] = self.get_default_state()
+            
+            # 更新统计数据
+            all_data[filename].update(stats_updates)
+            
+            success = await self._credentials_cache_manager.update_multi({filename: all_data[filename]})
+            log.debug(f"Updated usage stats in unified cache: {filename}")
+            return success
+            
+        except Exception as e:
+            log.error(f"Error updating usage stats {filename}: {e}")
+            return False
+    
+    async def get_usage_stats(self, filename: str) -> Dict[str, Any]:
+        """从统一缓存获取使用统计"""
+        self._ensure_initialized()
+        
+        try:
+            filename = self._normalize_filename(filename)
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            if filename not in all_data:
+                # 返回基本的统计��段
+                default_state = self.get_default_state()
+                return {k: v for k, v in default_state.items() if k in {"gemini_2_5_pro_calls", "total_calls", "next_reset_time", "daily_limit_gemini_2_5_pro", "daily_limit_total"}}
+            
+            section_data = all_data[filename]
+            
+            # 提取统计字段
+            stats_fields = {"gemini_2_5_pro_calls", "total_calls", "next_reset_time", "daily_limit_gemini_2_5_pro", "daily_limit_total"}
+            stats_data = {k: v for k, v in section_data.items() if k in stats_fields}
+            
+            # 确保必要字段存在
+            default_state = self.get_default_state()
+            for field in stats_fields:
+                if field not in stats_data:
+                    stats_data[field] = default_state[field]
+            
+            return stats_data
+            
+        except Exception as e:
+            log.error(f"Error getting usage stats {filename}: {e}")
+            return self.get_default_state()
+    
+    async def get_all_usage_stats(self) -> Dict[str, Dict[str, Any]]:
+        """从统一缓存获取所有使用统计"""
+        self._ensure_initialized()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            stats = {}
+            stats_fields = {"gemini_2_5_pro_calls", "total_calls", "next_reset_time", "daily_limit_gemini_2_5_pro", "daily_limit_total"}
+            
+            for filename, section_data in all_data.items():
+                # 提取统计字段
+                stats_data = {k: v for k, v in section_data.items() if k in stats_fields}
+                
+                # 确保必要字段存在
+                default_state = self.get_default_state()
+                for field in stats_fields:
+                    if field not in stats_data:
+                        stats_data[field] = default_state[field]
+                
+                stats[filename] = stats_data
+            
+            return stats
+            
+        except Exception as e:
+            log.error(f"Error getting all usage stats: {e}")
+            return {}
+    
+    # ============ 工具方法 ============
+    
+    async def export_credential_to_json(self, filename: str, output_path: str = None) -> bool:
+        """将TOML中的凭证导出为JSON文件（用于兼容性和备份）"""
+        self._ensure_initialized()
+        
+        try:
+            filename = self._normalize_filename(filename)
+            credential_data = await self.get_credential(filename)
+            
+            if credential_data is None:
+                log.warning(f"Credential not found for export: {filename}")
+                return False
+            
+            if output_path is None:
+                output_path = os.path.join(self._credentials_dir, f"{filename}.json")
+            
+            # 写入JSON文件
+            json_content = json.dumps(credential_data, indent=2, ensure_ascii=False)
+            async with aiofiles.open(output_path, "w", encoding="utf-8") as f:
+                await f.write(json_content)
+            
+            log.info(f"Credential exported to JSON: {output_path}")
+            return True
+            
+        except Exception as e:
+            log.error(f"Error exporting credential {filename} to JSON: {e}")
+            return False
+    
+    async def import_credential_from_json(self, json_path: str, filename: str = None) -> bool:
+        """从JSON文件导入凭证到TOML"""
+        self._ensure_initialized()
+        
+        try:
+            if not os.path.exists(json_path):
+                log.error(f"JSON file not found: {json_path}")
+                return False
+            
+            # 读取JSON文件
+            async with aiofiles.open(json_path, "r", encoding="utf-8") as f:
+                json_content = await f.read()
+            
+            credential_data = json.loads(json_content)
+            
+            if filename is None:
+                filename = os.path.basename(json_path)
+            
+            filename = self._normalize_filename(filename)
+            
+            # 存储凭证
+            success = await self.store_credential(filename, credential_data)
+            
+            if success:
+                log.info(f"Credential imported from JSON: {json_path} -> {filename}")
+            
+            return success
+            
+        except Exception as e:
+            log.error(f"Error importing credential from JSON {json_path}: {e}")
+            return False

src/storage/mongodb_manager.py

@@ -0,0 +1,494 @@
+"""
+MongoDB数据库管理器，使用单文档设计和统一缓存。
+所有凭证数据存储在一个文档中，配置数据存储在另一个文档中，类似TOML文件结构。
+"""
+import asyncio
+import os
+import time
+from datetime import datetime, timezone
+from typing import Dict, Any, List, Optional
+from collections import deque
+
+import motor.motor_asyncio
+from log import log
+from .cache_manager import UnifiedCacheManager, CacheBackend
+
+
+class MongoDBCacheBackend(CacheBackend):
+    """MongoDB缓存后端实现"""
+    
+    def __init__(self, db, collection_name: str, doc_key: str):
+        self._db = db
+        self._collection_name = collection_name
+        self._doc_key = doc_key
+    
+    async def load_data(self) -> Dict[str, Any]:
+        """从MongoDB文档加载数据"""
+        try:
+            collection = self._db[self._collection_name]
+            doc = await collection.find_one({"key": self._doc_key})
+            
+            if doc and "data" in doc:
+                return doc["data"]
+            return {}
+            
+        except Exception as e:
+            log.error(f"Error loading data from MongoDB document {self._doc_key}: {e}")
+            return {}
+    
+    async def write_data(self, data: Dict[str, Any]) -> bool:
+        """将数据写入MongoDB文档"""
+        try:
+            collection = self._db[self._collection_name]
+            
+            doc = {
+                "key": self._doc_key,
+                "data": data,
+                "updated_at": datetime.now(timezone.utc)
+            }
+            
+            await collection.replace_one(
+                {"key": self._doc_key},
+                doc,
+                upsert=True
+            )
+            return True
+            
+        except Exception as e:
+            log.error(f"Error writing data to MongoDB document {self._doc_key}: {e}")
+            return False
+
+
+class MongoDBManager:
+    """MongoDB数据库管理器"""
+    
+    def __init__(self):
+        self._client: Optional[motor.motor_asyncio.AsyncIOMotorClient] = None
+        self._db: Optional[motor.motor_asyncio.AsyncIOMotorDatabase] = None
+        self._initialized = False
+        self._lock = asyncio.Lock()
+        
+        # 配置
+        self._connection_uri = None
+        self._database_name = None
+        
+        # 单文档设计 - 所有凭证存在一个文档中（类似TOML文件）
+        self._collection_name = "credentials_data"
+        
+        # 性能监控
+        self._operation_count = 0
+        self._operation_times = deque(maxlen=5000)
+        
+        # 统一缓存管理器
+        self._credentials_cache_manager: Optional[UnifiedCacheManager] = None
+        self._config_cache_manager: Optional[UnifiedCacheManager] = None
+        
+        # 文档key定义
+        self._credentials_doc_key = "all_credentials"
+        self._config_doc_key = "config_data"
+        
+        # 写入配置参数
+        self._write_delay = 1.0  # 写入延迟（秒）
+        self._cache_ttl = 300  # 缓存TTL（秒）
+    
+    async def initialize(self):
+        """初始化MongoDB连接"""
+        async with self._lock:
+            if self._initialized:
+                return
+                
+            try:
+                # 获取连接配置
+                self._connection_uri = os.getenv("MONGODB_URI")
+                self._database_name = os.getenv("MONGODB_DATABASE", "gcli2api")
+                
+                if not self._connection_uri:
+                    raise ValueError("MONGODB_URI environment variable is required")
+                
+                # 建立连接
+                self._client = motor.motor_asyncio.AsyncIOMotorClient(
+                    self._connection_uri,
+                    serverSelectionTimeoutMS=5000,
+                    maxPoolSize=100,
+                    minPoolSize=10,
+                    maxIdleTimeMS=45000,
+                    waitQueueTimeoutMS=10000,
+                )
+                
+                # 验证连接
+                await self._client.admin.command('ping')
+                
+                # 获取数据库
+                self._db = self._client[self._database_name]
+                
+                # 创建索引
+                await self._create_indexes()
+                
+                # 创建缓存管理器
+                credentials_backend = MongoDBCacheBackend(self._db, self._collection_name, self._credentials_doc_key)
+                config_backend = MongoDBCacheBackend(self._db, self._collection_name, self._config_doc_key)
+                
+                self._credentials_cache_manager = UnifiedCacheManager(
+                    credentials_backend,
+                    cache_ttl=self._cache_ttl,
+                    write_delay=self._write_delay,
+                    name="credentials"
+                )
+                
+                self._config_cache_manager = UnifiedCacheManager(
+                    config_backend,
+                    cache_ttl=self._cache_ttl,
+                    write_delay=self._write_delay,
+                    name="config"
+                )
+                
+                # 启动缓存管理器
+                await self._credentials_cache_manager.start()
+                await self._config_cache_manager.start()
+                
+                self._initialized = True
+                log.info(f"MongoDB connection established to {self._database_name} with unified cache")
+                
+            except Exception as e:
+                log.error(f"Error initializing MongoDB: {e}")
+                raise
+    
+    async def _create_indexes(self):
+        """创建简单索引（单文档设计）"""
+        try:
+            # 单文档设计只需要主键索引
+            await self._db[self._collection_name].create_index("key", unique=True)
+            await self._db[self._collection_name].create_index("updated_at")
+            
+            log.info("MongoDB indexes created for single-document design")
+            
+        except Exception as e:
+            log.error(f"Error creating MongoDB indexes: {e}")
+    
+    async def close(self):
+        """关闭MongoDB连接"""
+        # 停止缓存管理器
+        if self._credentials_cache_manager:
+            await self._credentials_cache_manager.stop()
+        if self._config_cache_manager:
+            await self._config_cache_manager.stop()
+        
+        if self._client:
+            self._client.close()
+            self._initialized = False
+            log.info("MongoDB connection closed with unified cache flushed")
+    
+    def _ensure_initialized(self):
+        """确保已初始化"""
+        if not self._initialized:
+            raise RuntimeError("MongoDB manager not initialized")
+    
+    def _get_default_state(self) -> Dict[str, Any]:
+        """获取默认状态数据"""
+        return {
+            "error_codes": [],
+            "disabled": False,
+            "last_success": time.time(),
+            "user_email": None,
+        }
+    
+    def _get_default_stats(self) -> Dict[str, Any]:
+        """获取默认统计数据"""
+        return {
+            "gemini_2_5_pro_calls": 0,
+            "total_calls": 0,
+            "next_reset_time": None,
+            "daily_limit_gemini_2_5_pro": 100,
+            "daily_limit_total": 1000
+        }
+    
+    # ============ 凭证管理 ============
+    
+    async def store_credential(self, filename: str, credential_data: Dict[str, Any]) -> bool:
+        """存储凭证数据到统一缓存"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            # 获取现有数据或创建新数据
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            
+            credential_entry = {
+                "credential": credential_data,
+                "state": existing_data.get("state", self._get_default_state()),
+                "stats": existing_data.get("stats", self._get_default_stats())
+            }
+            
+            success = await self._credentials_cache_manager.set(filename, credential_entry)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Stored credential to unified cache: {filename} in {operation_time:.3f}s")
+            return success
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error storing credential {filename} in {operation_time:.3f}s: {e}")
+            return False
+    
+    async def get_credential(self, filename: str) -> Optional[Dict[str, Any]]:
+        """从统一缓存获取凭证数据"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            if credential_entry and "credential" in credential_entry:
+                return credential_entry["credential"]
+            return None
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error retrieving credential {filename} in {operation_time:.3f}s: {e}")
+            return None
+    
+    async def list_credentials(self) -> List[str]:
+        """从统一缓存列出所有凭证文件名"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            filenames = list(all_data.keys())
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Listed {len(filenames)} credentials from unified cache in {operation_time:.3f}s")
+            return filenames
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error listing credentials in {operation_time:.3f}s: {e}")
+            return []
+    
+    async def delete_credential(self, filename: str) -> bool:
+        """从统一缓存删除凭证及所有相关数据"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            success = await self._credentials_cache_manager.delete(filename)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Deleted credential from unified cache: {filename} in {operation_time:.3f}s")
+            return success
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error deleting credential {filename} in {operation_time:.3f}s: {e}")
+            return False
+    
+    # ============ 状态管理 ============
+    
+    async def update_credential_state(self, filename: str, state_updates: Dict[str, Any]) -> bool:
+        """更新凭证状态（使用统一缓存）"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            # 获取现有数据或创建新数据
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            
+            if not existing_data:
+                existing_data = {
+                    "credential": {},
+                    "state": self._get_default_state(),
+                    "stats": self._get_default_stats()
+                }
+            
+            # 更新状态数据
+            existing_data["state"].update(state_updates)
+            
+            success = await self._credentials_cache_manager.set(filename, existing_data)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Updated credential state in unified cache: {filename} in {operation_time:.3f}s")
+            return success
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error updating credential state {filename} in {operation_time:.3f}s: {e}")
+            return False
+    
+    async def get_credential_state(self, filename: str) -> Dict[str, Any]:
+        """从统一缓存获取凭证状态"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            if credential_entry and "state" in credential_entry:
+                log.debug(f"Retrieved credential state from unified cache: {filename} in {operation_time:.3f}s")
+                return credential_entry["state"]
+            else:
+                # 返回默认状态
+                return self._get_default_state()
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error getting credential state {filename} in {operation_time:.3f}s: {e}")
+            return self._get_default_state()
+    
+    async def get_all_credential_states(self) -> Dict[str, Dict[str, Any]]:
+        """从统一缓存获取所有凭证状态"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            states = {}
+            for filename, cred_data in all_data.items():
+                states[filename] = cred_data.get("state", self._get_default_state())
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Retrieved all credential states from unified cache ({len(states)}) in {operation_time:.3f}s")
+            return states
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error getting all credential states in {operation_time:.3f}s: {e}")
+            return {}
+    
+    # ============ 配置管理 ============
+    
+    async def set_config(self, key: str, value: Any) -> bool:
+        """设置配置到统一缓存"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.set(key, value)
+    
+    async def get_config(self, key: str, default: Any = None) -> Any:
+        """从统一缓存获取配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.get(key, default)
+    
+    async def get_all_config(self) -> Dict[str, Any]:
+        """从统一缓存获取所有配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.get_all()
+    
+    async def delete_config(self, key: str) -> bool:
+        """从统一缓存删除配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.delete(key)
+    
+    # ============ 使用统计管理 ============
+    
+    async def update_usage_stats(self, filename: str, stats_updates: Dict[str, Any]) -> bool:
+        """更新使用统计（使用统一缓存）"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            # 获取现有数据或创建新数据
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            
+            if not existing_data:
+                existing_data = {
+                    "credential": {},
+                    "state": self._get_default_state(),
+                    "stats": self._get_default_stats()
+                }
+            
+            # 更新统计数据
+            existing_data["stats"].update(stats_updates)
+            
+            success = await self._credentials_cache_manager.set(filename, existing_data)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Updated usage stats in unified cache: {filename} in {operation_time:.3f}s")
+            return success
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error updating usage stats {filename} in {operation_time:.3f}s: {e}")
+            return False
+    
+    async def get_usage_stats(self, filename: str) -> Dict[str, Any]:
+        """从统一缓存获取使用统计"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            if credential_entry and "stats" in credential_entry:
+                log.debug(f"Retrieved usage stats from unified cache: {filename} in {operation_time:.3f}s")
+                return credential_entry["stats"]
+            else:
+                return self._get_default_stats()
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error getting usage stats {filename} in {operation_time:.3f}s: {e}")
+            return self._get_default_stats()
+    
+    async def get_all_usage_stats(self) -> Dict[str, Dict[str, Any]]:
+        """从统一缓存获取所有使用统计"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            stats = {}
+            for filename, cred_data in all_data.items():
+                if "stats" in cred_data:
+                    stats[filename] = cred_data["stats"]
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Retrieved all usage stats from unified cache ({len(stats)}) in {operation_time:.3f}s")
+            return stats
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error getting all usage stats in {operation_time:.3f}s: {e}")
+            return {}

src/storage/postgres_manager.py

@@ -0,0 +1,296 @@
+"""
+Postgres数据库管理器，采用单行设计并兼容 UnifiedCacheManager。
+实现与 mongodb_manager.py 风格一致的接口（异步）。
+需要环境变量: POSTGRES_DSN (例如: postgresql://user:pass@host:port/dbname)
+"""
+import asyncio
+import os
+import time
+import json
+from datetime import datetime, timezone
+from typing import Dict, Any, List, Optional
+from collections import deque
+
+import asyncpg
+from log import log
+from .cache_manager import UnifiedCacheManager, CacheBackend
+
+
+class PostgresCacheBackend(CacheBackend):
+    """Postgres缓存后端，数据存储为key, data(JSONB), updated_at
+    单行/单表设计：表名由管理器指定，每行以key区分。
+    """
+
+    def __init__(self, conn_pool, table_name: str, row_key: str):
+        self._pool = conn_pool
+        self._table_name = table_name
+        self._row_key = row_key
+
+    async def load_data(self) -> Dict[str, Any]:
+        try:
+            async with self._pool.acquire() as conn:
+                row = await conn.fetchrow(
+                    f"SELECT data FROM {self._table_name} WHERE key = $1",
+                    self._row_key
+                )
+                if row and row.get('data') is not None:
+                    data = row['data']
+                    # JSONB字段返回JSON字符串，需要解析为字典
+                    if isinstance(data, str):
+                        return json.loads(data)
+                    elif isinstance(data, dict):
+                        return data
+                    else:
+                        log.warning(f"Unexpected data type from JSONB field: {type(data)}")
+                        return {}
+                return {}
+        except Exception as e:
+            log.error(f"Error loading data from Postgres row {self._row_key}: {e}")
+            return {}
+
+    async def write_data(self, data: Dict[str, Any]) -> bool:
+        try:
+            async with self._pool.acquire() as conn:
+                await conn.execute(
+                    f"INSERT INTO {self._table_name}(key, data, updated_at) VALUES($1, $2::jsonb, $3)"
+                    " ON CONFLICT (key) DO UPDATE SET data = EXCLUDED.data, updated_at = EXCLUDED.updated_at",
+                    self._row_key, json.dumps(data, default=str), datetime.now(timezone.utc)
+                )
+                return True
+        except Exception as e:
+            log.error(f"Error writing data to Postgres row {self._row_key}: {e}")
+            return False
+
+
+class PostgresManager:
+    """Postgres管理器。
+    使用单表单行设计存储凭证和配置数据。
+    """
+
+    def __init__(self):
+        self._pool: Optional[asyncpg.pool.Pool] = None
+        self._initialized = False
+        self._lock = asyncio.Lock()
+
+        self._dsn = None
+        self._table_name = 'unified_storage'
+
+        self._operation_count = 0
+
+        self._operation_times = deque(maxlen=5000)
+
+        self._credentials_cache_manager: Optional[UnifiedCacheManager] = None
+        self._config_cache_manager: Optional[UnifiedCacheManager] = None
+
+        self._credentials_row_key = 'all_credentials'
+        self._config_row_key = 'config_data'
+
+        self._write_delay = 1.0
+        self._cache_ttl = 300
+
+    async def initialize(self):
+        async with self._lock:
+            if self._initialized:
+                return
+            try:
+                self._dsn = os.getenv('POSTGRES_DSN')
+                if not self._dsn:
+                    raise ValueError('POSTGRES_DSN environment variable is required')
+
+                self._pool = await asyncpg.create_pool(dsn=self._dsn, max_size=20, min_size=1)
+
+                # 确保表存在
+                await self._ensure_table()
+
+                # 创建缓存管理器后端
+                credentials_backend = PostgresCacheBackend(self._pool, self._table_name, self._credentials_row_key)
+                config_backend = PostgresCacheBackend(self._pool, self._table_name, self._config_row_key)
+
+                self._credentials_cache_manager = UnifiedCacheManager(
+                    credentials_backend, cache_ttl=self._cache_ttl, write_delay=self._write_delay, name='credentials'
+                )
+                self._config_cache_manager = UnifiedCacheManager(
+                    config_backend, cache_ttl=self._cache_ttl, write_delay=self._write_delay, name='config'
+                )
+
+                await self._credentials_cache_manager.start()
+                await self._config_cache_manager.start()
+
+                self._initialized = True
+                log.info('Postgres connection established with unified cache')
+            except Exception as e:
+                log.error(f'Error initializing Postgres: {e}')
+                raise
+
+    async def _ensure_table(self):
+        try:
+            async with self._pool.acquire() as conn:
+                await conn.execute(
+                    f"CREATE TABLE IF NOT EXISTS {self._table_name}(\n                        key TEXT PRIMARY KEY,\n                        data JSONB,\n                        updated_at TIMESTAMPTZ\n                    )"
+                )
+        except Exception as e:
+            log.error(f'Error ensuring Postgres table: {e}')
+            raise
+
+    async def close(self):
+        if self._credentials_cache_manager:
+            await self._credentials_cache_manager.stop()
+        if self._config_cache_manager:
+            await self._config_cache_manager.stop()
+        if self._pool:
+            await self._pool.close()
+            self._initialized = False
+            log.info('Postgres connection closed with unified cache flushed')
+
+    def _ensure_initialized(self):
+        if not self._initialized:
+            raise RuntimeError('Postgres manager not initialized')
+
+    def _get_default_state(self) -> Dict[str, Any]:
+        return {
+            'error_codes': [],
+            'disabled': False,
+            'last_success': time.time(),
+            'user_email': None,
+        }
+
+    def _get_default_stats(self) -> Dict[str, Any]:
+        return {
+            'gemini_2_5_pro_calls': 0,
+            'total_calls': 0,
+            'next_reset_time': None,
+            'daily_limit_gemini_2_5_pro': 100,
+            'daily_limit_total': 1000
+        }
+
+    # 以下方法委托给 UnifiedCacheManager
+    async def store_credential(self, filename: str, credential_data: Dict[str, Any]) -> bool:
+        self._ensure_initialized()
+        start_time = time.time()
+        try:
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            credential_entry = {
+                'credential': credential_data,
+                'state': existing_data.get('state', self._get_default_state()),
+                'stats': existing_data.get('stats', self._get_default_stats())
+            }
+            success = await self._credentials_cache_manager.set(filename, credential_entry)
+            self._operation_count += 1
+            self._operation_times.append(time.time() - start_time)
+            log.debug(f'Stored credential to unified cache (postgres): {filename}')
+            return success
+        except Exception as e:
+            log.error(f'Error storing credential {filename} in Postgres: {e}')
+            return False
+
+    async def get_credential(self, filename: str) -> Optional[Dict[str, Any]]:
+        self._ensure_initialized()
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            self._operation_count += 1
+            if credential_entry and 'credential' in credential_entry:
+                return credential_entry['credential']
+            return None
+        except Exception as e:
+            log.error(f'Error retrieving credential {filename} from Postgres: {e}')
+            return None
+
+    async def list_credentials(self) -> List[str]:
+        self._ensure_initialized()
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            return list(all_data.keys())
+        except Exception as e:
+            log.error(f'Error listing credentials from Postgres: {e}')
+            return []
+
+    async def delete_credential(self, filename: str) -> bool:
+        self._ensure_initialized()
+        try:
+            return await self._credentials_cache_manager.delete(filename)
+        except Exception as e:
+            log.error(f'Error deleting credential {filename} from Postgres: {e}')
+            return False
+
+    async def update_credential_state(self, filename: str, state_updates: Dict[str, Any]) -> bool:
+        self._ensure_initialized()
+        try:
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            if not existing_data:
+                existing_data = {'credential': {}, 'state': self._get_default_state(), 'stats': self._get_default_stats()}
+            existing_data['state'].update(state_updates)
+            return await self._credentials_cache_manager.set(filename, existing_data)
+        except Exception as e:
+            log.error(f'Error updating credential state {filename} in Postgres: {e}')
+            return False
+
+    async def get_credential_state(self, filename: str) -> Dict[str, Any]:
+        self._ensure_initialized()
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            if credential_entry and 'state' in credential_entry:
+                return credential_entry['state']
+            return self._get_default_state()
+        except Exception as e:
+            log.error(f'Error getting credential state {filename} from Postgres: {e}')
+            return self._get_default_state()
+
+    async def get_all_credential_states(self) -> Dict[str, Dict[str, Any]]:
+        self._ensure_initialized()
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            states = {fn: data.get('state', self._get_default_state()) for fn, data in all_data.items()}
+            return states
+        except Exception as e:
+            log.error(f'Error getting all credential states from Postgres: {e}')
+            return {}
+
+    async def set_config(self, key: str, value: Any) -> bool:
+        self._ensure_initialized()
+        return await self._config_cache_manager.set(key, value)
+
+    async def get_config(self, key: str, default: Any = None) -> Any:
+        self._ensure_initialized()
+        return await self._config_cache_manager.get(key, default)
+
+    async def get_all_config(self) -> Dict[str, Any]:
+        self._ensure_initialized()
+        return await self._config_cache_manager.get_all()
+
+    async def delete_config(self, key: str) -> bool:
+        self._ensure_initialized()
+        return await self._config_cache_manager.delete(key)
+
+    async def update_usage_stats(self, filename: str, stats_updates: Dict[str, Any]) -> bool:
+        self._ensure_initialized()
+        try:
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            if not existing_data:
+                existing_data = {'credential': {}, 'state': self._get_default_state(), 'stats': self._get_default_stats()}
+            existing_data['stats'].update(stats_updates)
+            return await self._credentials_cache_manager.set(filename, existing_data)
+        except Exception as e:
+            log.error(f'Error updating usage stats for {filename} in Postgres: {e}')
+            return False
+
+    async def get_usage_stats(self, filename: str) -> Dict[str, Any]:
+        self._ensure_initialized()
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            if credential_entry and 'stats' in credential_entry:
+                return credential_entry['stats']
+            return self._get_default_stats()
+        except Exception as e:
+            log.error(f'Error getting usage stats for {filename} from Postgres: {e}')
+            return self._get_default_stats()
+
+    async def get_all_usage_stats(self) -> Dict[str, Dict[str, Any]]:
+        self._ensure_initialized()
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            stats = {fn: data.get('stats', self._get_default_stats()) for fn, data in all_data.items()}
+            return stats
+        except Exception as e:
+            log.error(f'Error getting all usage stats from Postgres: {e}')
+            return {}
+

src/storage/redis_manager.py

@@ -0,0 +1,504 @@
+"""
+Redis数据库管理器，使用哈希表设计和统一缓存。
+所有凭证数据存储在一个哈希表中，配置数据存储在另一个哈希表中。
+"""
+import asyncio
+import json
+import os
+import time
+from typing import Dict, Any, List, Optional
+from collections import deque
+
+import redis.asyncio as redis
+from log import log
+from .cache_manager import UnifiedCacheManager, CacheBackend
+
+
+class RedisCacheBackend(CacheBackend):
+    """Redis缓存后端实现"""
+    
+    def __init__(self, redis_client: redis.Redis, hash_name: str):
+        self._client = redis_client
+        self._hash_name = hash_name
+    
+    async def load_data(self) -> Dict[str, Any]:
+        """从Redis哈希表加载数据"""
+        try:
+            hash_data = await self._client.hgetall(self._hash_name)
+            if not hash_data:
+                return {}
+            
+            result = {}
+            for key, value_str in hash_data.items():
+                try:
+                    result[key] = json.loads(value_str)
+                except json.JSONDecodeError as e:
+                    log.error(f"Error deserializing Redis data for key {key}: {e}")
+                    continue
+            return result
+        except Exception as e:
+            log.error(f"Error loading data from Redis hash {self._hash_name}: {e}")
+            return {}
+    
+    async def write_data(self, data: Dict[str, Any]) -> bool:
+        """将数据写入Redis哈希表"""
+        try:
+            if not data:
+                await self._client.delete(self._hash_name)
+                return True
+            
+            hash_data = {}
+            for key, value in data.items():
+                try:
+                    hash_data[key] = json.dumps(value, ensure_ascii=False)
+                except (TypeError, ValueError) as e:
+                    log.error(f"Error serializing data for key {key}: {e}")
+                    continue
+            
+            if not hash_data:
+                return True
+            
+            pipe = self._client.pipeline()
+            pipe.delete(self._hash_name)
+            pipe.hset(self._hash_name, mapping=hash_data)
+            await pipe.execute()
+            return True
+        except Exception as e:
+            log.error(f"Error writing data to Redis hash {self._hash_name}: {e}")
+            return False
+
+
+class RedisManager:
+    """Redis数据库管理器"""
+    
+    def __init__(self):
+        self._client: Optional[redis.Redis] = None
+        self._initialized = False
+        self._lock = asyncio.Lock()
+        
+        # 配置
+        self._connection_uri = None
+        self._database_index = 0
+        
+        # 哈希表设计 - 所有凭证存在一个哈希表中
+        self._credentials_hash_name = "gcli2api:credentials"
+        self._config_hash_name = "gcli2api:config"
+        
+        # 性能监控
+        self._operation_count = 0
+        self._operation_times = deque(maxlen=5000)
+        
+        # 统一缓存管理器
+        self._credentials_cache_manager: Optional[UnifiedCacheManager] = None
+        self._config_cache_manager: Optional[UnifiedCacheManager] = None
+        
+        # 写入配置参数
+        self._write_delay = 1.0  # 写入延迟（秒）
+        self._cache_ttl = 300  # 缓存TTL（秒）
+    
+    async def initialize(self):
+        """初始化Redis连接"""
+        async with self._lock:
+            if self._initialized:
+                return
+                
+            try:
+                # 获取连接配置
+                self._connection_uri = os.getenv("REDIS_URI", "redis://localhost:6379")
+                self._database_index = int(os.getenv("REDIS_DATABASE", "0"))
+                
+                # 建立连接 - 使用最简配置确保兼容性
+                # 检查是否需要 SSL
+                if self._connection_uri.startswith("rediss://"):
+                    # SSL 连接
+                    self._client = redis.from_url(
+                        self._connection_uri,
+                        db=self._database_index,
+                        decode_responses=True,
+                        ssl_cert_reqs=None,
+                        ssl_check_hostname=False,
+                        ssl_ca_certs=None
+                    )
+                else:
+                    # 普通连接
+                    self._client = redis.from_url(
+                        self._connection_uri,
+                        db=self._database_index,
+                        decode_responses=True
+                    )
+                
+                # 验证连接
+                await self._client.ping()
+                
+                # 创建缓存管理器
+                credentials_backend = RedisCacheBackend(self._client, self._credentials_hash_name)
+                config_backend = RedisCacheBackend(self._client, self._config_hash_name)
+                
+                self._credentials_cache_manager = UnifiedCacheManager(
+                    credentials_backend, 
+                    cache_ttl=self._cache_ttl, 
+                    write_delay=self._write_delay,
+                    name="credentials"
+                )
+                
+                self._config_cache_manager = UnifiedCacheManager(
+                    config_backend,
+                    cache_ttl=self._cache_ttl,
+                    write_delay=self._write_delay,
+                    name="config"
+                )
+                
+                # 启动缓存管理器
+                await self._credentials_cache_manager.start()
+                await self._config_cache_manager.start()
+                
+                self._initialized = True
+                log.info(f"Redis connection established to database {self._database_index} with unified cache")
+                
+            except Exception as e:
+                log.error(f"Error initializing Redis: {e}")
+                raise
+    
+    async def close(self):
+        """关闭Redis连接"""
+        # 停止缓存管理器
+        if self._credentials_cache_manager:
+            await self._credentials_cache_manager.stop()
+        if self._config_cache_manager:
+            await self._config_cache_manager.stop()
+        
+        if self._client:
+            await self._client.close()
+            self._initialized = False
+            log.info("Redis connection closed with unified cache flushed")
+    
+    def _ensure_initialized(self):
+        """确保已初始化"""
+        if not self._initialized:
+            raise RuntimeError("Redis manager not initialized")
+    
+    def _get_default_state(self) -> Dict[str, Any]:
+        """获取默认状态数据"""
+        return {
+            "error_codes": [],
+            "disabled": False,
+            "last_success": time.time(),
+            "user_email": None,
+        }
+    
+    def _get_default_stats(self) -> Dict[str, Any]:
+        """获取默认统计数据"""
+        return {
+            "gemini_2_5_pro_calls": 0,
+            "total_calls": 0,
+            "next_reset_time": None,
+            "daily_limit_gemini_2_5_pro": 100,
+            "daily_limit_total": 1000
+        }
+    
+    # ============ 凭证管理 ============
+    
+    async def store_credential(self, filename: str, credential_data: Dict[str, Any]) -> bool:
+        """存储凭证数据到统一缓存"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            # 获取现有数据或创建新数据
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            
+            credential_entry = {
+                "credential": credential_data,
+                "state": existing_data.get("state", self._get_default_state()),
+                "stats": existing_data.get("stats", self._get_default_stats())
+            }
+            
+            success = await self._credentials_cache_manager.set(filename, credential_entry)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Stored credential to unified cache: {filename} in {operation_time:.3f}s")
+            return success
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error storing credential {filename} in {operation_time:.3f}s: {e}")
+            return False
+    
+    async def get_credential(self, filename: str) -> Optional[Dict[str, Any]]:
+        """从统一缓存获取凭证数据"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            if credential_entry and "credential" in credential_entry:
+                return credential_entry["credential"]
+            return None
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error retrieving credential {filename} in {operation_time:.3f}s: {e}")
+            return None
+    
+    async def list_credentials(self) -> List[str]:
+        """从统一缓存列出所有凭证文件名"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            filenames = list(all_data.keys())
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Listed {len(filenames)} credentials from unified cache in {operation_time:.3f}s")
+            return filenames
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error listing credentials in {operation_time:.3f}s: {e}")
+            return []
+    
+    async def delete_credential(self, filename: str) -> bool:
+        """从统一缓存删除凭证及所有相关数据"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            success = await self._credentials_cache_manager.delete(filename)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Deleted credential from unified cache: {filename} in {operation_time:.3f}s")
+            return success
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error deleting credential {filename} in {operation_time:.3f}s: {e}")
+            return False
+    
+    # ============ 状态管理 ============
+    
+    async def update_credential_state(self, filename: str, state_updates: Dict[str, Any]) -> bool:
+        """更新凭证状态（使用统一缓存）"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            # 获取现有数据或创建新数据
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            
+            if not existing_data:
+                existing_data = {
+                    "credential": {},
+                    "state": self._get_default_state(),
+                    "stats": self._get_default_stats()
+                }
+            
+            # 更新状态数据
+            existing_data["state"].update(state_updates)
+            
+            success = await self._credentials_cache_manager.set(filename, existing_data)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Updated credential state in unified cache: {filename} in {operation_time:.3f}s")
+            return success
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error updating credential state {filename} in {operation_time:.3f}s: {e}")
+            return False
+    
+    async def get_credential_state(self, filename: str) -> Dict[str, Any]:
+        """从统一缓存获取凭证状态"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            if credential_entry and "state" in credential_entry:
+                log.debug(f"Retrieved credential state from unified cache: {filename} in {operation_time:.3f}s")
+                return credential_entry["state"]
+            else:
+                # 返回默认状态
+                return self._get_default_state()
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error getting credential state {filename} in {operation_time:.3f}s: {e}")
+            return self._get_default_state()
+    
+    async def get_all_credential_states(self) -> Dict[str, Dict[str, Any]]:
+        """从统一缓存获取所有凭证状态"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            states = {}
+            for filename, cred_data in all_data.items():
+                states[filename] = cred_data.get("state", self._get_default_state())
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Retrieved all credential states from unified cache ({len(states)}) in {operation_time:.3f}s")
+            return states
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error getting all credential states in {operation_time:.3f}s: {e}")
+            return {}
+    
+    # ============ 配置管理 ============
+    
+    async def set_config(self, key: str, value: Any) -> bool:
+        """设置配置到统一缓存"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            success = await self._config_cache_manager.set(key, value)
+            
+            # ���能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Set config to unified cache: {key} in {operation_time:.3f}s")
+            return success
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error setting config {key} in {operation_time:.3f}s: {e}")
+            return False
+    
+    async def get_config(self, key: str, default: Any = None) -> Any:
+        """从统一缓存获取配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.get(key, default)
+    
+    async def get_all_config(self) -> Dict[str, Any]:
+        """从统一缓存获取所有配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.get_all()
+    
+    async def delete_config(self, key: str) -> bool:
+        """从统一缓存删除配置"""
+        self._ensure_initialized()
+        return await self._config_cache_manager.delete(key)
+    
+    # ============ 使用统计管理 ============
+    
+    async def update_usage_stats(self, filename: str, stats_updates: Dict[str, Any]) -> bool:
+        """更新使用统计（使用统一缓存）"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            # 获取现有数据或创建新数据
+            existing_data = await self._credentials_cache_manager.get(filename, {})
+            
+            if not existing_data:
+                existing_data = {
+                    "credential": {},
+                    "state": self._get_default_state(),
+                    "stats": self._get_default_stats()
+                }
+            
+            # 更新统计数据
+            existing_data["stats"].update(stats_updates)
+            
+            success = await self._credentials_cache_manager.set(filename, existing_data)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Updated usage stats in unified cache: {filename} in {operation_time:.3f}s")
+            return success
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error updating usage stats {filename} in {operation_time:.3f}s: {e}")
+            return False
+    
+    async def get_usage_stats(self, filename: str) -> Dict[str, Any]:
+        """从统一缓存获取使用统计"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            credential_entry = await self._credentials_cache_manager.get(filename)
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            if credential_entry and "stats" in credential_entry:
+                log.debug(f"Retrieved usage stats from unified cache: {filename} in {operation_time:.3f}s")
+                return credential_entry["stats"]
+            else:
+                return self._get_default_stats()
+                
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error getting usage stats {filename} in {operation_time:.3f}s: {e}")
+            return self._get_default_stats()
+    
+    async def get_all_usage_stats(self) -> Dict[str, Dict[str, Any]]:
+        """从统一缓存获取所有使用统计"""
+        self._ensure_initialized()
+        start_time = time.time()
+        
+        try:
+            all_data = await self._credentials_cache_manager.get_all()
+            
+            stats = {}
+            for filename, cred_data in all_data.items():
+                if "stats" in cred_data:
+                    stats[filename] = cred_data["stats"]
+            
+            # 性能监控
+            self._operation_count += 1
+            operation_time = time.time() - start_time
+            self._operation_times.append(operation_time)
+            
+            log.debug(f"Retrieved all usage stats from unified cache ({len(stats)}) in {operation_time:.3f}s")
+            return stats
+            
+        except Exception as e:
+            operation_time = time.time() - start_time
+            log.error(f"Error getting all usage stats in {operation_time:.3f}s: {e}")
+            return {}

src/storage_adapter.py

@@ -0,0 +1,361 @@
+"""
+存储适配器，提供统一的接口来处理Redis、MongoDB和本地文件存储。
+根据配置自动选择存储后端，优先级：Redis > MongoDB > 本地文件。
+"""
+import asyncio
+import os
+import json
+from typing import Dict, Any, List, Optional, Protocol
+
+from log import log
+
+
+class StorageBackend(Protocol):
+    """存储后端协议"""
+    
+    async def initialize(self) -> None:
+        """初始化存储后端"""
+        ...
+    
+    async def close(self) -> None:
+        """关闭存储后端"""
+        ...
+    
+    # 凭证管理
+    async def store_credential(self, filename: str, credential_data: Dict[str, Any]) -> bool:
+        """存储凭证数据"""
+        ...
+    
+    async def get_credential(self, filename: str) -> Optional[Dict[str, Any]]:
+        """获取凭证数据"""
+        ...
+    
+    async def list_credentials(self) -> List[str]:
+        """列出所有凭证文件名"""
+        ...
+    
+    async def delete_credential(self, filename: str) -> bool:
+        """删除凭证"""
+        ...
+    
+    # 状态管理
+    async def update_credential_state(self, filename: str, state_updates: Dict[str, Any]) -> bool:
+        """更新凭证状态"""
+        ...
+    
+    async def get_credential_state(self, filename: str) -> Dict[str, Any]:
+        """获取凭证状态"""
+        ...
+    
+    async def get_all_credential_states(self) -> Dict[str, Dict[str, Any]]:
+        """获取所有凭证状态"""
+        ...
+    
+    # 配置管理
+    async def set_config(self, key: str, value: Any) -> bool:
+        """设置配置项"""
+        ...
+    
+    async def get_config(self, key: str, default: Any = None) -> Any:
+        """获取配置项"""
+        ...
+    
+    async def get_all_config(self) -> Dict[str, Any]:
+        """获取所有配置"""
+        ...
+    
+    async def delete_config(self, key: str) -> bool:
+        """删除配置项"""
+        ...
+    
+    # 使用统计管理
+    async def update_usage_stats(self, filename: str, stats_updates: Dict[str, Any]) -> bool:
+        """更新使用统计"""
+        ...
+    
+    async def get_usage_stats(self, filename: str) -> Dict[str, Any]:
+        """获取使用统计"""
+        ...
+    
+    async def get_all_usage_stats(self) -> Dict[str, Dict[str, Any]]:
+        """获取所有使用统计"""
+        ...
+
+
+
+
+class StorageAdapter:
+    """存储适配器，根据配置选择存储后端"""
+    
+    def __init__(self):
+        self._backend: Optional["StorageBackend"] = None
+        self._initialized = False
+        self._lock = asyncio.Lock()
+    
+    async def initialize(self) -> None:
+        """初始化存储适配器"""
+        async with self._lock:
+            if self._initialized:
+                return
+            
+            # 按优先级检查存储后端：Redis > MongoDB > 本地文件
+            redis_uri = os.getenv("REDIS_URI", "")
+            mongodb_uri = os.getenv("MONGODB_URI", "")
+            
+            # 优先尝试Redis存储
+            if redis_uri:
+                try:
+                    from .storage.redis_manager import RedisManager
+                    self._backend = RedisManager()
+                    await self._backend.initialize()
+                    log.info("Using Redis storage backend")
+                except ImportError as e:
+                    log.error(f"Failed to import Redis backend: {e}")
+                    log.info("Falling back to next available storage backend")
+                except Exception as e:
+                    log.error(f"Failed to initialize Redis backend: {e}")
+                    log.info("Falling back to next available storage backend")
+            
+            # 如果Redis不可用或未配置，接下来尝试Postgres（优先级低于Redis）
+            postgres_dsn = os.getenv("POSTGRES_DSN", "")
+            if not self._backend and postgres_dsn:
+                try:
+                    from .storage.postgres_manager import PostgresManager
+                    self._backend = PostgresManager()
+                    await self._backend.initialize()
+                    log.info("Using Postgres storage backend")
+                except ImportError as e:
+                    log.error(f"Failed to import Postgres backend: {e}")
+                    log.info("Falling back to next available storage backend")
+                except Exception as e:
+                    log.error(f"Failed to initialize Postgres backend: {e}")
+                    log.info("Falling back to next available storage backend")
+
+            # 如果Redis和Postgres不可用，尝试MongoDB存储
+            if not self._backend and mongodb_uri:
+                try:
+                    from .storage.mongodb_manager import MongoDBManager
+                    self._backend = MongoDBManager()
+                    await self._backend.initialize()
+                    log.info("Using MongoDB storage backend")
+                except ImportError as e:
+                    log.error(f"Failed to import MongoDB backend: {e}")
+                    log.info("Falling back to file storage backend")
+                except Exception as e:
+                    log.error(f"Failed to initialize MongoDB backend: {e}")
+                    log.info("Falling back to file storage backend")
+            
+            # 如果Redis和MongoDB都不可用，使用文件存储
+            if not self._backend:
+                from .storage.file_storage_manager import FileStorageManager
+                self._backend = FileStorageManager()
+                await self._backend.initialize()
+                log.info("Using file storage backend")
+            
+            self._initialized = True
+    
+    async def close(self) -> None:
+        """关闭存储适配器"""
+        if self._backend:
+            await self._backend.close()
+            self._backend = None
+            self._initialized = False
+    
+    def _ensure_initialized(self):
+        """确保存储适配器已初始化"""
+        if not self._initialized or not self._backend:
+            raise RuntimeError("Storage adapter not initialized")
+    
+    # ============ 凭证管理 ============
+    
+    async def store_credential(self, filename: str, credential_data: Dict[str, Any]) -> bool:
+        """存储凭证数据"""
+        self._ensure_initialized()
+        return await self._backend.store_credential(filename, credential_data)
+    
+    async def get_credential(self, filename: str) -> Optional[Dict[str, Any]]:
+        """获取凭证数据"""
+        self._ensure_initialized()
+        return await self._backend.get_credential(filename)
+    
+    async def list_credentials(self) -> List[str]:
+        """列出所有凭证文件名"""
+        self._ensure_initialized()
+        return await self._backend.list_credentials()
+    
+    async def delete_credential(self, filename: str) -> bool:
+        """删除凭证"""
+        self._ensure_initialized()
+        return await self._backend.delete_credential(filename)
+    
+    # ============ 状态管理 ============
+    
+    async def update_credential_state(self, filename: str, state_updates: Dict[str, Any]) -> bool:
+        """更新凭证状态"""
+        self._ensure_initialized()
+        return await self._backend.update_credential_state(filename, state_updates)
+    
+    async def get_credential_state(self, filename: str) -> Dict[str, Any]:
+        """获取凭证状态"""
+        self._ensure_initialized()
+        return await self._backend.get_credential_state(filename)
+    
+    async def get_all_credential_states(self) -> Dict[str, Dict[str, Any]]:
+        """获取所有凭证状态"""
+        self._ensure_initialized()
+        return await self._backend.get_all_credential_states()
+    
+    # ============ 配置管理 ============
+    
+    async def set_config(self, key: str, value: Any) -> bool:
+        """设置配置项"""
+        self._ensure_initialized()
+        return await self._backend.set_config(key, value)
+    
+    async def get_config(self, key: str, default: Any = None) -> Any:
+        """获取配置项"""
+        self._ensure_initialized()
+        return await self._backend.get_config(key, default)
+    
+    async def get_all_config(self) -> Dict[str, Any]:
+        """获取所有配置"""
+        self._ensure_initialized()
+        return await self._backend.get_all_config()
+    
+    async def delete_config(self, key: str) -> bool:
+        """删除配置项"""
+        self._ensure_initialized()
+        return await self._backend.delete_config(key)
+    
+    # ============ 使用统计管理 ============
+    
+    async def update_usage_stats(self, filename: str, stats_updates: Dict[str, Any]) -> bool:
+        """更新使用统计"""
+        self._ensure_initialized()
+        return await self._backend.update_usage_stats(filename, stats_updates)
+    
+    async def get_usage_stats(self, filename: str) -> Dict[str, Any]:
+        """获取使用统计"""
+        self._ensure_initialized()
+        return await self._backend.get_usage_stats(filename)
+    
+    async def get_all_usage_stats(self) -> Dict[str, Dict[str, Any]]:
+        """获取所有使用统计"""
+        self._ensure_initialized()
+        return await self._backend.get_all_usage_stats()
+    
+    # ============ 工具方法 ============
+    
+    async def export_credential_to_json(self, filename: str, output_path: str = None) -> bool:
+        """将凭证导出为JSON文件"""
+        self._ensure_initialized()
+        if hasattr(self._backend, 'export_credential_to_json'):
+            return await self._backend.export_credential_to_json(filename, output_path)
+        # MongoDB后端的fallback实现
+        credential_data = await self.get_credential(filename)
+        if credential_data is None:
+            return False
+        
+        if output_path is None:
+            output_path = f"{filename}.json"
+        
+        import aiofiles
+        try:
+            async with aiofiles.open(output_path, "w", encoding="utf-8") as f:
+                await f.write(json.dumps(credential_data, indent=2, ensure_ascii=False))
+            return True
+        except Exception:
+            return False
+    
+    async def import_credential_from_json(self, json_path: str, filename: str = None) -> bool:
+        """从JSON文件导入凭证"""
+        self._ensure_initialized()
+        if hasattr(self._backend, 'import_credential_from_json'):
+            return await self._backend.import_credential_from_json(json_path, filename)
+        # MongoDB后端的fallback实现
+        try:
+            import aiofiles
+            async with aiofiles.open(json_path, "r", encoding="utf-8") as f:
+                content = await f.read()
+            
+            credential_data = json.loads(content)
+            
+            if filename is None:
+                filename = os.path.basename(json_path)
+            
+            return await self.store_credential(filename, credential_data)
+        except Exception:
+            return False
+    
+    def get_backend_type(self) -> str:
+        """获取当前存储后端类型"""
+        if not self._backend:
+            return "none"
+        
+        # 检查后端类型
+        backend_class_name = self._backend.__class__.__name__
+        if "File" in backend_class_name or "file" in backend_class_name.lower():
+            return "file"
+        elif "MongoDB" in backend_class_name or "mongo" in backend_class_name.lower():
+            return "mongodb"
+        elif "Redis" in backend_class_name or "redis" in backend_class_name.lower():
+            return "redis"
+        else:
+            return "unknown"
+    
+    async def get_backend_info(self) -> Dict[str, Any]:
+        """获取存储后端信息"""
+        self._ensure_initialized()
+        
+        backend_type = self.get_backend_type()
+        info = {
+            "backend_type": backend_type,
+            "initialized": self._initialized
+        }
+        
+        # 获取底层存储信息
+        if hasattr(self._backend, 'get_database_info'):
+            try:
+                db_info = await self._backend.get_database_info()
+                info.update(db_info)
+            except Exception as e:
+                info["database_error"] = str(e)
+        else:
+            backend_type = self.get_backend_type()
+            if backend_type == "file":
+                info.update({
+                    "credentials_dir": getattr(self._backend, '_credentials_dir', None),
+                    "state_file": getattr(self._backend, '_state_file', None),
+                    "config_file": getattr(self._backend, '_config_file', None)
+                })
+            elif backend_type == "redis":
+                info.update({
+                    "redis_url": getattr(self._backend, '_redis_url', None),
+                    "connection_pool_size": getattr(self._backend, '_pool_size', None)
+                })
+        
+        return info
+
+
+# 全局存储适配器实例
+_storage_adapter: Optional[StorageAdapter] = None
+
+
+async def get_storage_adapter() -> StorageAdapter:
+    """获取全局存储适配器实例"""
+    global _storage_adapter
+    
+    if _storage_adapter is None:
+        _storage_adapter = StorageAdapter()
+        await _storage_adapter.initialize()
+    
+    return _storage_adapter
+
+
+async def close_storage_adapter():
+    """关闭全局存储适配器"""
+    global _storage_adapter
+    
+    if _storage_adapter:
+        await _storage_adapter.close()
+        _storage_adapter = None

src/task_manager.py

@@ -0,0 +1,137 @@
+"""
+Global task lifecycle management module
+管理应用程序中所有异步任务的生命周期，确保正确清理
+"""
+import asyncio
+import weakref
+from typing import Set, Dict, Any
+from log import log
+
+
+class TaskManager:
+    """全局异步任务管理器 - 单例模式"""
+    
+    _instance = None
+    _lock = asyncio.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+    
+    def __init__(self):
+        if self._initialized:
+            return
+        
+        self._tasks: Set[asyncio.Task] = set()
+        self._resources: Set[Any] = set()  # 需要关闭的资源
+        self._shutdown_event = asyncio.Event()
+        self._initialized = True
+        log.debug("TaskManager initialized")
+    
+    def register_task(self, task: asyncio.Task, description: str = None) -> asyncio.Task:
+        """注册一个任务供生命周期管理"""
+        self._tasks.add(task)
+        task.add_done_callback(lambda t: self._tasks.discard(t))
+        
+        if description:
+            task.set_name(description)
+        
+        log.debug(f"Registered task: {task.get_name() or 'unnamed'}")
+        return task
+    
+    def create_task(self, coro, *, name: str = None) -> asyncio.Task:
+        """创建并注册一个任务"""
+        task = asyncio.create_task(coro, name=name)
+        return self.register_task(task, name)
+    
+    def register_resource(self, resource: Any) -> Any:
+        """注册一个需要清理的资源（如HTTP客户端、文件句柄等）"""
+        # 使用弱引用避免循环引用
+        self._resources.add(weakref.ref(resource))
+        log.debug(f"Registered resource: {type(resource).__name__}")
+        return resource
+    
+    async def shutdown(self, timeout: float = 30.0):
+        """关闭所有任务和资源"""
+        log.info("TaskManager shutdown initiated")
+        
+        # 设置关闭标志
+        self._shutdown_event.set()
+        
+        # 取消所有未完成的任务
+        cancelled_count = 0
+        for task in list(self._tasks):
+            if not task.done():
+                task.cancel()
+                cancelled_count += 1
+        
+        if cancelled_count > 0:
+            log.info(f"Cancelled {cancelled_count} pending tasks")
+        
+        # 等待所有任务完成（包括取消）
+        if self._tasks:
+            try:
+                await asyncio.wait_for(
+                    asyncio.gather(*self._tasks, return_exceptions=True),
+                    timeout=timeout
+                )
+            except asyncio.TimeoutError:
+                log.warning(f"Some tasks did not complete within {timeout}s timeout")
+        
+        # 清理资源
+        cleaned_resources = 0
+        for resource_ref in list(self._resources):
+            resource = resource_ref()
+            if resource is not None:
+                try:
+                    if hasattr(resource, 'close'):
+                        if asyncio.iscoroutinefunction(resource.close):
+                            await resource.close()
+                        else:
+                            resource.close()
+                    elif hasattr(resource, 'aclose'):
+                        await resource.aclose()
+                    cleaned_resources += 1
+                except Exception as e:
+                    log.warning(f"Failed to close resource {type(resource).__name__}: {e}")
+        
+        if cleaned_resources > 0:
+            log.info(f"Cleaned up {cleaned_resources} resources")
+        
+        self._tasks.clear()
+        self._resources.clear()
+        log.info("TaskManager shutdown completed")
+    
+    @property
+    def is_shutdown(self) -> bool:
+        """检查是否已经开始关闭"""
+        return self._shutdown_event.is_set()
+    
+    def get_stats(self) -> Dict[str, int]:
+        """获取任务管理统计信息"""
+        return {
+            'active_tasks': len(self._tasks),
+            'registered_resources': len(self._resources),
+            'is_shutdown': self.is_shutdown
+        }
+
+
+# 全局任务管理器实例
+task_manager = TaskManager()
+
+
+def create_managed_task(coro, *, name: str = None) -> asyncio.Task:
+    """创建一个被管理的异步任务的便捷函数"""
+    return task_manager.create_task(coro, name=name)
+
+
+def register_resource(resource: Any) -> Any:
+    """注册资源的便捷函数"""
+    return task_manager.register_resource(resource)
+
+
+async def shutdown_all_tasks(timeout: float = 30.0):
+    """关闭所有任务的便捷函数"""
+    await task_manager.shutdown(timeout)

src/usage_stats.py

@@ -0,0 +1,444 @@
+"""
+Usage statistics module for tracking API calls per credential file.
+Uses the simpler logic: compare current time with next_reset_time.
+"""
+import os
+import time
+from datetime import datetime, timezone, timedelta
+from threading import Lock
+from typing import Dict, Any, Optional
+
+from config import get_credentials_dir, is_mongodb_mode
+from log import log
+from .state_manager import get_state_manager
+from .storage_adapter import get_storage_adapter
+
+
+def _get_next_utc_7am() -> datetime:
+    """
+    Calculate the next UTC 07:00 time for quota reset.
+    """
+    now = datetime.now(timezone.utc)
+    today_7am = now.replace(hour=7, minute=0, second=0, microsecond=0)
+    
+    if now < today_7am:
+        return today_7am
+    else:
+        return today_7am + timedelta(days=1)
+
+
+class UsageStats:
+    """
+    Simplified usage statistics manager with clear reset logic.
+    """
+    
+    def __init__(self):
+        self._lock = Lock()
+        # 状态文件路径将在初始化时异步设置
+        self._state_file = None
+        self._state_manager = None
+        self._storage_adapter = None
+        self._stats_cache: Dict[str, Dict[str, Any]] = {}
+        self._initialized = False
+        self._cache_dirty = False  # 缓存脏标记，减少不必要的写入
+        self._last_save_time = 0
+        self._save_interval = 60  # 最多每分钟保存一次，减少I/O
+        self._max_cache_size = 100  # 严格限制缓存大小
+    
+    async def initialize(self):
+        """Initialize the usage stats module."""
+        if self._initialized:
+            return
+        
+        # 初始化存储适配器
+        self._storage_adapter = await get_storage_adapter()
+        
+        # 只在文件模式下创建本地状态文件
+        if not await is_mongodb_mode():
+            credentials_dir = await get_credentials_dir()
+            self._state_file = os.path.join(credentials_dir, "creds_state.toml")
+            self._state_manager = get_state_manager(self._state_file)
+        
+        await self._load_stats()
+        self._initialized = True
+        storage_type = "MongoDB" if await is_mongodb_mode() else "File"
+        log.debug(f"Usage statistics module initialized with {storage_type} storage backend")
+        
+    
+    def _normalize_filename(self, filename: str) -> str:
+        """Normalize filename to relative path for consistent storage."""
+        if not filename:
+            return ""
+            
+        if os.path.sep not in filename and "/" not in filename:
+            return filename
+            
+        return os.path.basename(filename)
+    
+    def _is_gemini_2_5_pro(self, model_name: str) -> bool:
+        """
+        Check if model is gemini-2.5-pro variant (including prefixes and suffixes).
+        """
+        if not model_name:
+            return False
+        
+        try:
+            from config import get_base_model_name, get_base_model_from_feature_model
+            
+            # Remove feature prefixes (流式抗截断/, 假流式/)
+            base_with_suffix = get_base_model_from_feature_model(model_name)
+            
+            # Remove thinking/search suffixes (-maxthinking, -nothinking, -search)
+            pure_base_model = get_base_model_name(base_with_suffix)
+            
+            # Check if the pure base model is exactly "gemini-2.5-pro"
+            return pure_base_model == "gemini-2.5-pro"
+            
+        except ImportError:
+            # Fallback logic if config import fails
+            clean_model = model_name
+            for prefix in ["流式抗截断/", "假流式/"]:
+                if clean_model.startswith(prefix):
+                    clean_model = clean_model[len(prefix):]
+                    break
+            
+            for suffix in ["-maxthinking", "-nothinking", "-search"]:
+                if clean_model.endswith(suffix):
+                    clean_model = clean_model[:-len(suffix)]
+                    break
+            
+            return clean_model == "gemini-2.5-pro"
+    
+    async def _load_stats(self):
+        """Load statistics from unified storage"""
+        try:
+            # 从统一存储获取所有使用统计，添加超时机制防止卡死
+            import asyncio
+            
+            async def load_stats_with_timeout():
+                all_usage_stats = await self._storage_adapter.get_all_usage_stats()
+                
+                log.debug(f"Processing {len(all_usage_stats)} usage statistics items...")
+                
+                # 直接处理统计数据
+                stats_cache = {}
+                processed_count = 0
+                
+                for filename, stats_data in all_usage_stats.items():
+                    if isinstance(stats_data, dict):
+                        normalized_filename = self._normalize_filename(filename)
+                        
+                        # 提取使用统计字段
+                        usage_data = {
+                            "gemini_2_5_pro_calls": stats_data.get("gemini_2_5_pro_calls", 0),
+                            "total_calls": stats_data.get("total_calls", 0),
+                            "next_reset_time": stats_data.get("next_reset_time"),
+                            "daily_limit_gemini_2_5_pro": stats_data.get("daily_limit_gemini_2_5_pro", 100),
+                            "daily_limit_total": stats_data.get("daily_limit_total", 1000)
+                        }
+                        
+                        # 只加载有实际使用数据的统计，或者有reset时间的
+                        if (usage_data.get("gemini_2_5_pro_calls", 0) > 0 or 
+                            usage_data.get("total_calls", 0) > 0 or 
+                            usage_data.get("next_reset_time")):
+                            stats_cache[normalized_filename] = usage_data
+                            processed_count += 1
+                
+                return stats_cache, processed_count
+            
+            # 设置15秒超时防止卡死
+            try:
+                self._stats_cache, processed_count = await asyncio.wait_for(
+                    load_stats_with_timeout(), timeout=15.0
+                )
+                log.debug(f"Loaded usage statistics for {processed_count} credential files")
+            except asyncio.TimeoutError:
+                log.error("Loading usage statistics timed out after 30 seconds, using empty cache")
+                self._stats_cache = {}
+                return
+            
+        except Exception as e:
+            log.error(f"Failed to load usage statistics: {e}")
+            self._stats_cache = {}
+    
+    async def _save_stats(self):
+        """Save statistics to unified storage."""
+        current_time = time.time()
+        
+        # 使用脏标记和时间间隔控制，减少不必要的写入
+        if not self._cache_dirty or (current_time - self._last_save_time < self._save_interval):
+            return
+            
+        try:
+            # 批量更新使用统计到存储适配器
+            log.debug(f"Saving {len(self._stats_cache)} usage statistics items...")
+            
+            saved_count = 0
+            for filename, stats in self._stats_cache.items():
+                try:
+                    stats_data = {
+                        "gemini_2_5_pro_calls": stats.get("gemini_2_5_pro_calls", 0),
+                        "total_calls": stats.get("total_calls", 0),
+                        "next_reset_time": stats.get("next_reset_time"),
+                        "daily_limit_gemini_2_5_pro": stats.get("daily_limit_gemini_2_5_pro", 100),
+                        "daily_limit_total": stats.get("daily_limit_total", 1000)
+                    }
+                    
+                    success = await self._storage_adapter.update_usage_stats(filename, stats_data)
+                    if success:
+                        saved_count += 1
+                except Exception as e:
+                    log.error(f"Failed to save stats for {filename}: {e}")
+                    continue
+                
+            self._cache_dirty = False  # 清除脏标记
+            self._last_save_time = current_time
+            log.debug(f"Successfully saved {saved_count}/{len(self._stats_cache)} usage statistics to unified storage")
+        except Exception as e:
+            log.error(f"Failed to save usage statistics: {e}")
+    
+    def _get_or_create_stats(self, filename: str) -> Dict[str, Any]:
+        """Get or create statistics entry for a credential file."""
+        normalized_filename = self._normalize_filename(filename)
+        
+        if normalized_filename not in self._stats_cache:
+            # 严格控制缓存大小 - 超过限制时删除最旧的条目
+            if len(self._stats_cache) >= self._max_cache_size:
+                # 删除最旧的统计数据（基于next_reset_time或没有该字段的）
+                oldest_key = min(self._stats_cache.keys(),
+                               key=lambda k: self._stats_cache[k].get('next_reset_time', ''))
+                del self._stats_cache[oldest_key]
+                self._cache_dirty = True
+                log.debug(f"Removed oldest usage stats cache entry: {oldest_key}")
+            
+            next_reset = _get_next_utc_7am()
+            self._stats_cache[normalized_filename] = {
+                "gemini_2_5_pro_calls": 0,
+                "total_calls": 0,
+                "next_reset_time": next_reset.isoformat(),
+                "daily_limit_gemini_2_5_pro": 100,
+                "daily_limit_total": 1000
+            }
+            self._cache_dirty = True  # 标记缓存已修改
+        
+        return self._stats_cache[normalized_filename]
+    
+    def _check_and_reset_daily_quota(self, stats: Dict[str, Any]) -> bool:
+        """
+        Simple reset logic: if current time >= next_reset_time, then reset.
+        """
+        try:
+            next_reset_str = stats.get("next_reset_time")
+            if not next_reset_str:
+                # No next reset time recorded, set it up
+                next_reset = _get_next_utc_7am()
+                stats["next_reset_time"] = next_reset.isoformat()
+                return False
+            
+            next_reset = datetime.fromisoformat(next_reset_str)
+            now = datetime.now(timezone.utc)
+            
+            # Simple comparison: if current time >= next reset time, then reset
+            if now >= next_reset:
+                old_gemini_calls = stats.get("gemini_2_5_pro_calls", 0)
+                old_total_calls = stats.get("total_calls", 0)
+                
+                # Reset counters and set new next reset time
+                new_next_reset = _get_next_utc_7am()
+                stats.update({
+                    "gemini_2_5_pro_calls": 0,
+                    "total_calls": 0,
+                    "next_reset_time": new_next_reset.isoformat()
+                })
+                
+                self._cache_dirty = True  # 标记缓存已修改
+                log.info(f"Daily quota reset performed. Previous stats - Gemini 2.5 Pro: {old_gemini_calls}, Total: {old_total_calls}")
+                return True
+            
+            return False
+        except Exception as e:
+            log.error(f"Error in daily quota reset check: {e}")
+            return False
+    
+    async def record_successful_call(self, filename: str, model_name: str):
+        """Record a successful API call for statistics."""
+        if not self._initialized:
+            await self.initialize()
+        
+        with self._lock:
+            try:
+                normalized_filename = self._normalize_filename(filename)
+                stats = self._get_or_create_stats(normalized_filename)
+                
+                # Check and perform daily reset if needed
+                reset_performed = self._check_and_reset_daily_quota(stats)
+                
+                # Increment counters
+                is_gemini_2_5_pro = self._is_gemini_2_5_pro(model_name)
+                
+                stats["total_calls"] += 1
+                if is_gemini_2_5_pro:
+                    stats["gemini_2_5_pro_calls"] += 1
+                
+                self._cache_dirty = True  # 标记缓存已修改
+                
+                log.debug(f"Usage recorded - File: {normalized_filename}, Model: {model_name}, "
+                         f"Gemini 2.5 Pro: {stats['gemini_2_5_pro_calls']}/{stats.get('daily_limit_gemini_2_5_pro', 100)}, "
+                         f"Total: {stats['total_calls']}/{stats.get('daily_limit_total', 1000)}")
+                
+                if reset_performed:
+                    log.info(f"Daily quota was reset for {normalized_filename}")
+                
+            except Exception as e:
+                log.error(f"Failed to record usage statistics: {e}")
+        
+        # Save stats asynchronously
+        try:
+            await self._save_stats()
+        except Exception as e:
+            log.error(f"Failed to save usage statistics after recording: {e}")
+    
+    async def get_usage_stats(self, filename: str = None) -> Dict[str, Any]:
+        """Get usage statistics."""
+        if not self._initialized:
+            await self.initialize()
+        
+        with self._lock:
+            if filename:
+                normalized_filename = self._normalize_filename(filename)
+                stats = self._get_or_create_stats(normalized_filename)
+                # Check for daily reset before returning stats
+                self._check_and_reset_daily_quota(stats)
+                return {
+                    "filename": normalized_filename,
+                    "gemini_2_5_pro_calls": stats.get("gemini_2_5_pro_calls", 0),
+                    "total_calls": stats.get("total_calls", 0),
+                    "daily_limit_gemini_2_5_pro": stats.get("daily_limit_gemini_2_5_pro", 100),
+                    "daily_limit_total": stats.get("daily_limit_total", 1000),
+                    "next_reset_time": stats.get("next_reset_time")
+                }
+            else:
+                # Return all statistics
+                all_stats = {}
+                for filename, stats in self._stats_cache.items():
+                    # Check for daily reset for each file
+                    self._check_and_reset_daily_quota(stats)
+                    all_stats[filename] = {
+                        "gemini_2_5_pro_calls": stats.get("gemini_2_5_pro_calls", 0),
+                        "total_calls": stats.get("total_calls", 0),
+                        "daily_limit_gemini_2_5_pro": stats.get("daily_limit_gemini_2_5_pro", 100),
+                        "daily_limit_total": stats.get("daily_limit_total", 1000),
+                        "next_reset_time": stats.get("next_reset_time")
+                    }
+                
+                return all_stats
+    
+    async def get_aggregated_stats(self) -> Dict[str, Any]:
+        """Get aggregated statistics across all credential files."""
+        if not self._initialized:
+            await self.initialize()
+        
+        all_stats = await self.get_usage_stats()
+        
+        total_gemini_2_5_pro = 0
+        total_all_models = 0
+        total_files = len(all_stats)
+        
+        for stats in all_stats.values():
+            total_gemini_2_5_pro += stats["gemini_2_5_pro_calls"]
+            total_all_models += stats["total_calls"]
+        
+        return {
+            "total_files": total_files,
+            "total_gemini_2_5_pro_calls": total_gemini_2_5_pro,
+            "total_all_model_calls": total_all_models,
+            "avg_gemini_2_5_pro_per_file": total_gemini_2_5_pro / max(total_files, 1),
+            "avg_total_per_file": total_all_models / max(total_files, 1),
+            "next_reset_time": _get_next_utc_7am().isoformat()
+        }
+    
+    async def update_daily_limits(self, filename: str, gemini_2_5_pro_limit: int = None, 
+                                total_limit: int = None):
+        """Update daily limits for a specific credential file."""
+        if not self._initialized:
+            await self.initialize()
+        
+        with self._lock:
+            try:
+                normalized_filename = self._normalize_filename(filename)
+                stats = self._get_or_create_stats(normalized_filename)
+                
+                if gemini_2_5_pro_limit is not None:
+                    stats["daily_limit_gemini_2_5_pro"] = gemini_2_5_pro_limit
+                
+                if total_limit is not None:
+                    stats["daily_limit_total"] = total_limit
+                
+                log.info(f"Updated daily limits for {normalized_filename}: "
+                        f"Gemini 2.5 Pro = {stats.get('daily_limit_gemini_2_5_pro', 100)}, "
+                        f"Total = {stats.get('daily_limit_total', 1000)}")
+                
+            except Exception as e:
+                log.error(f"Failed to update daily limits: {e}")
+                raise
+        
+        await self._save_stats()
+    
+    async def reset_stats(self, filename: str = None):
+        """Reset usage statistics."""
+        if not self._initialized:
+            await self.initialize()
+        
+        with self._lock:
+            if filename:
+                normalized_filename = self._normalize_filename(filename)
+                if normalized_filename in self._stats_cache:
+                    # Manual reset: reset counters and set new next reset time
+                    next_reset = _get_next_utc_7am()
+                    self._stats_cache[normalized_filename].update({
+                        "gemini_2_5_pro_calls": 0,
+                        "total_calls": 0,
+                        "next_reset_time": next_reset.isoformat()
+                    })
+                    log.info(f"Reset usage statistics for {normalized_filename}")
+            else:
+                # Reset all statistics
+                next_reset = _get_next_utc_7am()
+                for filename, stats in self._stats_cache.items():
+                    stats.update({
+                        "gemini_2_5_pro_calls": 0,
+                        "total_calls": 0,
+                        "next_reset_time": next_reset.isoformat()
+                    })
+                log.info("Reset usage statistics for all credential files")
+        
+        await self._save_stats()
+
+# Global instance
+_usage_stats_instance: Optional[UsageStats] = None
+
+async def get_usage_stats_instance() -> UsageStats:
+    """Get the global usage statistics instance."""
+    global _usage_stats_instance
+    if _usage_stats_instance is None:
+        _usage_stats_instance = UsageStats()
+        await _usage_stats_instance.initialize()
+    return _usage_stats_instance
+
+
+async def record_successful_call(filename: str, model_name: str):
+    """Convenience function to record a successful API call."""
+    stats = await get_usage_stats_instance()
+    await stats.record_successful_call(filename, model_name)
+
+
+async def get_usage_stats(filename: str = None) -> Dict[str, Any]:
+    """Convenience function to get usage statistics."""
+    stats = await get_usage_stats_instance()
+    return await stats.get_usage_stats(filename)
+
+
+async def get_aggregated_stats() -> Dict[str, Any]:
+    """Convenience function to get aggregated statistics."""
+    stats = await get_usage_stats_instance()
+    return await stats.get_aggregated_stats()

src/utils.py

@@ -0,0 +1,10 @@
+import platform
+
+CLI_VERSION = "0.1.5"  # Match current gemini-cli version
+
+def get_user_agent():
+    """Generate User-Agent string matching gemini-cli format."""
+    version = CLI_VERSION
+    system = platform.system()
+    arch = platform.machine()
+    return f"GeminiCLI/{version} ({system}; {arch})"

src/web_routes.py

@@ -0,0 +1,1738 @@
+"""
+Web路由模块 - 处理认证相关的HTTP请求和控制面板功能
+用于与上级web.py集成
+"""
+import asyncio
+import datetime
+import io
+import json
+import os
+import time
+import zipfile
+from collections import deque
+from typing import List, Optional, Dict, Any
+from urllib.parse import urlparse
+
+from fastapi import APIRouter, HTTPException, Depends, File, UploadFile, WebSocket, WebSocketDisconnect, Request
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse, Response
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel
+from starlette.websockets import WebSocketState
+import toml
+import zipfile
+import httpx
+
+import config
+from log import log
+from .auth import (
+    create_auth_url, get_auth_status,
+    verify_password, generate_auth_token, verify_auth_token,
+    asyncio_complete_auth_flow, complete_auth_flow_from_callback_url,
+    load_credentials_from_env, clear_env_credentials
+)
+from .credential_manager import CredentialManager
+from .usage_stats import get_usage_stats, get_aggregated_stats, get_usage_stats_instance
+from .storage_adapter import get_storage_adapter
+
+# 创建路由器
+router = APIRouter()
+security = HTTPBearer()
+
+# 创建credential manager实例
+credential_manager = CredentialManager()
+
+# WebSocket连接管理
+
+class ConnectionManager:
+    def __init__(self, max_connections: int = 3):  # 进一步降低最大连接数
+        # 使用双端队列严格限制内存使用
+        self.active_connections: deque = deque(maxlen=max_connections)
+        self.max_connections = max_connections
+        self._last_cleanup = 0
+        self._cleanup_interval = 120  # 120秒清理一次死连接
+
+    async def connect(self, websocket: WebSocket):
+        # 自动清理死连接
+        self._auto_cleanup()
+        
+        # 限制最大连接数，防止内存无限增长
+        if len(self.active_connections) >= self.max_connections:
+            await websocket.close(code=1008, reason="Too many connections")
+            return False
+        
+        await websocket.accept()
+        self.active_connections.append(websocket)
+        log.debug(f"WebSocket连接建立，当前连接数: {len(self.active_connections)}")
+        return True
+
+    def disconnect(self, websocket: WebSocket):
+        # 使用更高效的方式移除连接
+        try:
+            self.active_connections.remove(websocket)
+        except ValueError:
+            pass  # 连接已不存在
+        log.debug(f"WebSocket连接断开，当前连接数: {len(self.active_connections)}")
+
+    async def send_personal_message(self, message: str, websocket: WebSocket):
+        try:
+            await websocket.send_text(message)
+        except Exception:
+            self.disconnect(websocket)
+
+    async def broadcast(self, message: str):
+        # 使用更高效的方式处理广播，避免索引操作
+        dead_connections = []
+        for conn in self.active_connections:
+            try:
+                await conn.send_text(message)
+            except Exception:
+                dead_connections.append(conn)
+        
+        # 批量移除死连接
+        for dead_conn in dead_connections:
+            self.disconnect(dead_conn)
+                
+    def _auto_cleanup(self):
+        """自动清理死连接"""
+        current_time = time.time()
+        if current_time - self._last_cleanup > self._cleanup_interval:
+            self.cleanup_dead_connections()
+            self._last_cleanup = current_time
+    
+    def cleanup_dead_connections(self):
+        """清理已断开的连接"""
+        original_count = len(self.active_connections)
+        # 使用列表推导式过滤活跃连接，更高效
+        alive_connections = deque([
+            conn for conn in self.active_connections 
+            if hasattr(conn, 'client_state') and conn.client_state != WebSocketState.DISCONNECTED
+        ], maxlen=self.max_connections)
+        
+        self.active_connections = alive_connections
+        cleaned = original_count - len(self.active_connections)
+        if cleaned > 0:
+            log.debug(f"清理了 {cleaned} 个死连接，剩余连接数: {len(self.active_connections)}")
+
+manager = ConnectionManager()
+
+
+async def ensure_credential_manager_initialized():
+    """确保credential manager已初始化"""
+    if not credential_manager._initialized:
+        await credential_manager.initialize()
+
+async def get_credential_manager():
+    """获取全局凭证管理器实例"""
+    global credential_manager
+    if not credential_manager:
+        credential_manager = CredentialManager()
+        await credential_manager.initialize()
+    return credential_manager
+
+async def authenticate(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
+    """验证用户密码（控制面板使用）"""
+    from config import get_panel_password
+    password = await get_panel_password()
+    token = credentials.credentials
+    if token != password:
+        raise HTTPException(status_code=403, detail="密码错误")
+    return token
+
+class LoginRequest(BaseModel):
+    password: str
+
+class AuthStartRequest(BaseModel):
+    project_id: Optional[str] = None  # 现在是可选的
+    get_all_projects: Optional[bool] = False  # 是否为所有项目获取凭证
+
+class AuthCallbackRequest(BaseModel):
+    project_id: Optional[str] = None  # 现在是可选的
+    get_all_projects: Optional[bool] = False  # 是否为所有项目获取凭证
+
+class AuthCallbackUrlRequest(BaseModel):
+    callback_url: str  # OAuth回调完整URL
+    project_id: Optional[str] = None  # 可选的项目ID
+    get_all_projects: Optional[bool] = False  # 是否为所有项目获取凭证
+
+class CredFileActionRequest(BaseModel):
+    filename: str
+    action: str  # enable, disable, delete
+
+class CredFileBatchActionRequest(BaseModel):
+    action: str  # "enable", "disable", "delete"
+    filenames: List[str]  # 批量操作的文件名列表
+
+class ConfigSaveRequest(BaseModel):
+    config: dict
+
+
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """验证认证令牌"""
+    if not verify_auth_token(credentials.credentials):
+        raise HTTPException(status_code=401, detail="无效的认证令牌")
+    return credentials.credentials
+
+def is_mobile_user_agent(user_agent: str) -> bool:
+    """检测是否为移动设备用户代理"""
+    if not user_agent:
+        return False
+    
+    user_agent_lower = user_agent.lower()
+    mobile_keywords = [
+        'mobile', 'android', 'iphone', 'ipad', 'ipod', 
+        'blackberry', 'windows phone', 'samsung', 'htc',
+        'motorola', 'nokia', 'palm', 'webos', 'opera mini',
+        'opera mobi', 'fennec', 'minimo', 'symbian', 'psp',
+        'nintendo', 'tablet'
+    ]
+    
+    return any(keyword in user_agent_lower for keyword in mobile_keywords)
+
+@router.get("/", response_class=HTMLResponse)
+@router.get("/v1", response_class=HTMLResponse)
+@router.get("/auth", response_class=HTMLResponse)
+async def serve_control_panel(request: Request):
+    """提供统一控制面板（包含认证、文件管理、配置等功能）"""
+    try:
+        # 获取用户代理并判断是否为移动设备
+        user_agent = request.headers.get("user-agent", "")
+        is_mobile = is_mobile_user_agent(user_agent)
+        
+        # 根据设备类型选择相应的HTML文件
+        if is_mobile:
+            html_file_path = "front/control_panel_mobile.html"
+            log.info(f"Serving mobile control panel to user-agent: {user_agent}")
+        else:
+            html_file_path = "front/control_panel.html"
+            log.info(f"Serving desktop control panel to user-agent: {user_agent}")
+        
+        with open(html_file_path, "r", encoding="utf-8") as f:
+            html_content = f.read()
+        return HTMLResponse(content=html_content)
+    except FileNotFoundError:
+        log.error(f"控制面板页面文件不存在: {html_file_path}")
+        # 如果移动端文件不存在，回退到桌面版
+        if is_mobile:
+            try:
+                with open("front/control_panel.html", "r", encoding="utf-8") as f:
+                    html_content = f.read()
+                return HTMLResponse(content=html_content)
+            except FileNotFoundError:
+                raise HTTPException(status_code=404, detail="控制面板页面不存在")
+        else:
+            raise HTTPException(status_code=404, detail="控制面板页面不存在")
+    except Exception as e:
+        log.error(f"加载控制面板页面失败: {e}")
+        raise HTTPException(status_code=500, detail="服务器内部错误")
+
+
+@router.post("/auth/login")
+async def login(request: LoginRequest):
+    """用户登录"""
+    try:
+        if await verify_password(request.password):
+            token = generate_auth_token()
+            return JSONResponse(content={"token": token, "message": "登录成功"})
+        else:
+            raise HTTPException(status_code=401, detail="密码错误")
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"登录失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/auth/start")
+async def start_auth(request: AuthStartRequest, token: str = Depends(verify_token)):
+    """开始认证流程，支持自动检测项目ID和批量获取所有项目"""
+    try:
+        # 检查是否为批量项目模式
+        if request.get_all_projects:
+            log.info("用户请求批量获取所有项目的凭证...")
+            project_id = None  # 批量模式下不指定单个项目ID
+        else:
+            # 如果没有提供项目ID，尝试自动检测
+            project_id = request.project_id
+            if not project_id:
+                log.info("用户未提供项目ID，后续将使用自动检测...")
+        
+        # 使用认证令牌作为用户会话标识
+        user_session = token if token else None
+        result = await create_auth_url(project_id, user_session, get_all_projects=request.get_all_projects)
+        
+        if result['success']:
+            return JSONResponse(content={
+                "auth_url": result['auth_url'],
+                "state": result['state'],
+                "auto_project_detection": result.get('auto_project_detection', False),
+                "detected_project_id": result.get('detected_project_id'),
+                "get_all_projects": request.get_all_projects
+            })
+        else:
+            raise HTTPException(status_code=500, detail=result['error'])
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"开始认证流程失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/auth/callback")
+async def auth_callback(request: AuthCallbackRequest, token: str = Depends(verify_token)):
+    """处理认证回调，支持自动检测项目ID和批量获取所有项目"""
+    try:
+        # 项目ID现在是可选的，在回调处理中进行自动检测
+        project_id = request.project_id
+        get_all_projects = request.get_all_projects
+        
+        # 使用认证令牌作为用户会话标识
+        user_session = token if token else None
+        # 异步等待OAuth回调完成
+        result = await asyncio_complete_auth_flow(project_id, user_session, get_all_projects=get_all_projects)
+        
+        if result['success']:
+            if get_all_projects and result.get('multiple_credentials'):
+                # 批量认证成功，返回多个凭证信息
+                return JSONResponse(content={
+                    "multiple_credentials": result['multiple_credentials'],
+                    "message": "批量认证成功，已为多个项目保存凭证"
+                })
+            else:
+                # 单项目认证成功
+                return JSONResponse(content={
+                    "credentials": result['credentials'],
+                    "file_path": result['file_path'],
+                    "message": "认证成功，凭证已保存",
+                    "auto_detected_project": result.get('auto_detected_project', False)
+                })
+        else:
+            # 如果需要手动项目ID或项目选择，在响应中标明
+            if result.get('requires_manual_project_id'):
+                # 使用JSON响应
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "error": result['error'],
+                        "requires_manual_project_id": True
+                    }
+                )
+            elif result.get('requires_project_selection'):
+                # 返回项目列表供用户选择
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "error": result['error'],
+                        "requires_project_selection": True,
+                        "available_projects": result['available_projects']
+                    }
+                )
+            else:
+                raise HTTPException(status_code=400, detail=result['error'])
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"处理认证回调失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/auth/callback-url")
+async def auth_callback_url(request: AuthCallbackUrlRequest, token: str = Depends(verify_token)):
+    """从回调URL直接完成认证，支持批量获取所有项目"""
+    try:
+        # 验证URL格式
+        if not request.callback_url or not request.callback_url.startswith(('http://', 'https://')):
+            raise HTTPException(status_code=400, detail="请提供有效的回调URL")
+        
+        # 从回调URL完成认证
+        result = await complete_auth_flow_from_callback_url(
+            request.callback_url, 
+            request.project_id, 
+            get_all_projects=request.get_all_projects
+        )
+        
+        if result['success']:
+            if request.get_all_projects and result.get('multiple_credentials'):
+                # 批量认证成功，返回多个凭证信息
+                return JSONResponse(content={
+                    "multiple_credentials": result['multiple_credentials'],
+                    "message": "从回调URL批量认证成功，已为多个项目保存凭证"
+                })
+            else:
+                # 单项目认证成功
+                return JSONResponse(content={
+                    "credentials": result['credentials'],
+                    "file_path": result['file_path'],
+                    "message": "从回调URL认证成功，凭证已保存",
+                    "auto_detected_project": result.get('auto_detected_project', False)
+                })
+        else:
+            # 处理各种错误情况
+            if result.get('requires_manual_project_id'):
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "error": result['error'],
+                        "requires_manual_project_id": True
+                    }
+                )
+            elif result.get('requires_project_selection'):
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "error": result['error'],
+                        "requires_project_selection": True,
+                        "available_projects": result['available_projects']
+                    }
+                )
+            else:
+                raise HTTPException(status_code=400, detail=result['error'])
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"从回调URL处理认证失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/auth/status/{project_id}")
+async def check_auth_status(project_id: str, token: str = Depends(verify_token)):
+    """检查认证状态"""
+    try:
+        if not project_id:
+            raise HTTPException(status_code=400, detail="Project ID 不能为空")
+        
+        status = get_auth_status(project_id)
+        return JSONResponse(content=status)
+        
+    except Exception as e:
+        log.error(f"检查认证状态失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def extract_json_files_from_zip(zip_file: UploadFile) -> List[dict]:
+    """从ZIP文件中提取JSON文件"""
+    try:
+        # 读取ZIP文件内容
+        zip_content = await zip_file.read()
+        
+        # 不限制ZIP文件大小，只在处理时控制文件数量
+        
+        files_data = []
+        
+        with zipfile.ZipFile(io.BytesIO(zip_content), 'r') as zip_ref:
+            # 获取ZIP中的所有文件
+            file_list = zip_ref.namelist()
+            json_files = [f for f in file_list if f.endswith('.json') and not f.startswith('__MACOSX/')]
+            
+            if not json_files:
+                raise HTTPException(status_code=400, detail="ZIP文件中没有找到JSON文件")
+
+            log.info(f"从ZIP文件 {zip_file.filename} 中找到 {len(json_files)} 个JSON文件")
+            
+            for json_filename in json_files:
+                try:
+                    # 读取JSON文件内容
+                    with zip_ref.open(json_filename) as json_file:
+                        content = json_file.read()
+                        
+                        try:
+                            content_str = content.decode('utf-8')
+                        except UnicodeDecodeError:
+                            log.warning(f"跳过编码错误的文件: {json_filename}")
+                            continue
+                        
+                        # 使用原始文件名（去掉路径）
+                        filename = os.path.basename(json_filename)
+                        files_data.append({
+                            'filename': filename,
+                            'content': content_str
+                        })
+                        
+                except Exception as e:
+                    log.warning(f"处理ZIP中的文件 {json_filename} 时出错: {e}")
+                    continue
+        
+        log.info(f"成功从ZIP文件中提取 {len(files_data)} 个有效的JSON文件")
+        return files_data
+        
+    except zipfile.BadZipFile:
+        raise HTTPException(status_code=400, detail="无效的ZIP文件格式")
+    except Exception as e:
+        log.error(f"处理ZIP文件失败: {e}")
+        raise HTTPException(status_code=500, detail=f"处理ZIP文件失败: {str(e)}")
+
+
+@router.post("/auth/upload")
+async def upload_credentials(files: List[UploadFile] = File(...), token: str = Depends(verify_token)):
+    """批量上传认证文件"""
+    try:
+        if not files:
+            raise HTTPException(status_code=400, detail="请选择要上传的文件")
+        
+        # 检查文件数量限制
+        if len(files) > 100:
+            raise HTTPException(status_code=400, detail=f"文件数量过多，最多支持100个文件，当前：{len(files)}个")
+        
+        files_data = []
+        for file in files:
+            # 检查文件类型：支持JSON和ZIP
+            if file.filename.endswith('.zip'):
+                # 处理ZIP文件
+                zip_files_data = await extract_json_files_from_zip(file)
+                files_data.extend(zip_files_data)
+                log.info(f"从ZIP文件 {file.filename} 中提取了 {len(zip_files_data)} 个JSON文件")
+                
+            elif file.filename.endswith('.json'):
+                # 处理单个JSON文件
+                # 流式读取文件内容
+                content_chunks = []
+                while True:
+                    chunk = await file.read(8192)  # 8KB chunks
+                    if not chunk:
+                        break
+                    content_chunks.append(chunk)
+                
+                content = b''.join(content_chunks)
+                try:
+                    content_str = content.decode('utf-8')
+                except UnicodeDecodeError:
+                    raise HTTPException(status_code=400, detail=f"文件 {file.filename} 编码格式不支持")
+                
+                files_data.append({
+                    'filename': file.filename,
+                    'content': content_str
+                })
+            else:
+                raise HTTPException(status_code=400, detail=f"文件 {file.filename} 格式不支持，只支持JSON和ZIP文件")
+        
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+        
+        # 分批处理大量文件以提高稳定性
+        batch_size = 1000  # 每批处理1000个文件
+        all_results = []
+        total_success = 0
+        
+        for i in range(0, len(files_data), batch_size):
+            batch_files = files_data[i:i + batch_size]
+            
+            # 使用并发处理提升文件上传性能
+            async def process_single_file(file_data):
+                """处理单个文件的并发函数"""
+                try:
+                    filename = file_data['filename']
+                    content_str = file_data['content']
+                    
+                    # 解析JSON内容
+                    credential_data = json.loads(content_str)
+                    
+                    # 存储到统一存储系统
+                    success = await storage_adapter.store_credential(filename, credential_data)
+                    if success:
+                        # 创建默认状态记录（如果不存在）
+                        try:
+                            import time
+                            default_state = {
+                                "error_codes": [],
+                                "disabled": False,
+                                "last_success": time.time(),
+                                "user_email": None,
+                                "gemini_2_5_pro_calls": 0,
+                                "total_calls": 0,
+                                "next_reset_time": None,
+                                "daily_limit_gemini_2_5_pro": 100,
+                                "daily_limit_total": 1000
+                            }
+                            # 只在状态不存在时创建，避免覆盖现有状态
+                            # 检查数据库中是否真正存在状态记录
+                            all_states = await storage_adapter.get_all_credential_states()
+                            if filename not in all_states:
+                                await storage_adapter.update_credential_state(filename, default_state)
+                                log.debug(f"Created default state for new credential: {filename}")
+                        except Exception as e:
+                            log.warning(f"Failed to create default state for {filename}: {e}")
+                        
+                        log.debug(f"成功上传凭证文件: {filename}")
+                        return {
+                            "filename": filename,
+                            "status": "success",
+                            "message": "上传成功"
+                        }
+                    else:
+                        return {
+                            "filename": filename,
+                            "status": "error",
+                            "message": "存储失败"
+                        }
+                        
+                except json.JSONDecodeError as e:
+                    return {
+                        "filename": file_data['filename'],
+                        "status": "error",
+                        "message": f"JSON格式错误: {str(e)}"
+                    }
+                except Exception as e:
+                    return {
+                        "filename": file_data['filename'],
+                        "status": "error",
+                        "message": f"处理失败: {str(e)}"
+                    }
+            
+            # 并发处理这一批文件
+            log.info(f"开始并发处理 {len(batch_files)} 个文件...")
+            concurrent_tasks = [process_single_file(file_data) for file_data in batch_files]
+            batch_results = await asyncio.gather(*concurrent_tasks, return_exceptions=True)
+            
+            # 处理异常结果
+            processed_results = []
+            batch_uploaded_count = 0
+            for result in batch_results:
+                if isinstance(result, Exception):
+                    processed_results.append({
+                        "filename": "unknown",
+                        "status": "error", 
+                        "message": f"处理异常: {str(result)}"
+                    })
+                else:
+                    processed_results.append(result)
+                    if result["status"] == "success":
+                        batch_uploaded_count += 1
+            
+            batch_results = processed_results
+            
+            all_results.extend(batch_results)
+            total_success += batch_uploaded_count
+            
+            # 记录批次进度
+            batch_num = (i // batch_size) + 1
+            total_batches = (len(files_data) + batch_size - 1) // batch_size
+            log.info(f"批次 {batch_num}/{total_batches} 完成: 成功 {batch_uploaded_count}/{len(batch_files)} 个文件")
+        
+        if total_success > 0:
+            return JSONResponse(content={
+                "uploaded_count": total_success,
+                "total_count": len(files_data),
+                "results": all_results,
+                "message": f"批量上传完成: 成功 {total_success}/{len(files_data)} 个文件"
+            })
+        else:
+            raise HTTPException(status_code=400, detail="没有文件上传成功")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"批量上传失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/creds/status")
+async def get_creds_status(token: str = Depends(verify_token)):
+    """获取所有凭证文件的状态"""
+    try:
+        await ensure_credential_manager_initialized()
+        
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+        
+        # 获取所有凭证和状态
+        all_credentials = await storage_adapter.list_credentials()
+        all_states = await credential_manager.get_creds_status()
+        
+        # 获取后端信息（一次性获取，避免重复查询）
+        backend_info = await storage_adapter.get_backend_info()
+        backend_type = backend_info.get("backend_type", "unknown")
+        
+        # 并发处理所有凭证的数据获取（状态已获取，无需重复处理）
+        async def process_credential_data(filename):
+            """并发处理单个凭证的数据获取"""
+            file_status = all_states.get(filename)
+            
+            # 如果没有状态记录，创建默认状态
+            if not file_status:
+                try:
+                    import time
+                    default_state = {
+                        "error_codes": [],
+                        "disabled": False,
+                        "last_success": time.time(),
+                        "user_email": None,
+                        "gemini_2_5_pro_calls": 0,
+                        "total_calls": 0,
+                        "next_reset_time": None,
+                        "daily_limit_gemini_2_5_pro": 100,
+                        "daily_limit_total": 1000
+                    }
+                    await storage_adapter.update_credential_state(filename, default_state)
+                    file_status = default_state
+                    log.debug(f"为凭证 {filename} 创建了默认状态记录")
+                except Exception as e:
+                    log.warning(f"无法为凭证 {filename} 创建状态记录: {e}")
+                    # 创建临时状态用于显示
+                    file_status = {
+                        "error_codes": [],
+                        "disabled": False,
+                        "last_success": time.time(),
+                        "user_email": None,
+                        "gemini_2_5_pro_calls": 0,
+                        "total_calls": 0,
+                        "next_reset_time": None,
+                        "daily_limit_gemini_2_5_pro": 100,
+                        "daily_limit_total": 1000
+                    }
+            
+            try:
+                # 从存储获取凭证数据
+                credential_data = await storage_adapter.get_credential(filename)
+                if credential_data:
+                    result = {
+                        "status": file_status,
+                        "content": credential_data,
+                        "filename": os.path.basename(filename),
+                        "backend_type": backend_type,  # 复用backend信息
+                        "user_email": file_status.get("user_email")
+                    }
+                    
+                    # 如果是文件模式，添加文件元数据
+                    if backend_type == "file" and os.path.exists(filename):
+                        result.update({
+                            "size": os.path.getsize(filename),
+                            "modified_time": os.path.getmtime(filename)
+                        })
+                    
+                    return filename, result
+                else:
+                    return filename, {
+                        "status": file_status,
+                        "content": None,
+                        "filename": os.path.basename(filename),
+                        "error": "凭证数据不存在"
+                    }
+                    
+            except Exception as e:
+                log.error(f"读取凭证��件失败 {filename}: {e}")
+                return filename, {
+                    "status": file_status,
+                    "content": None,
+                    "filename": os.path.basename(filename),
+                    "error": str(e)
+                }
+        
+        # 并发处理所有凭证数据获取
+        log.debug(f"开始并发获取 {len(all_credentials)} 个凭证数据...")
+        concurrent_tasks = [process_credential_data(filename) for filename in all_credentials]
+        results = await asyncio.gather(*concurrent_tasks, return_exceptions=True)
+        
+        # 组装结果
+        creds_info = {}
+        for result in results:
+            if isinstance(result, Exception):
+                log.error(f"处理凭证状态异常: {result}")
+            else:
+                filename, credential_info = result
+                creds_info[filename] = credential_info
+        
+        return JSONResponse(content={"creds": creds_info})
+        
+    except Exception as e:
+        log.error(f"获取凭证状态失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/creds/action")
+async def creds_action(request: CredFileActionRequest, token: str = Depends(verify_token)):
+    """对凭证文件执行操作（启用/禁用/删除）"""
+    try:
+        await ensure_credential_manager_initialized()
+        
+        log.info(f"Received request: {request}")
+        
+        filename = request.filename
+        action = request.action
+        
+        log.info(f"Performing action '{action}' on file: {filename}")
+        
+        # 验证文件名
+        if not filename.endswith('.json'):
+            log.error(f"Invalid filename: {filename} (not a .json file)")
+            raise HTTPException(status_code=400, detail=f"无效的文件名: {filename}")
+        
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+        
+        # 检查凭证是否存在
+        credential_data = await storage_adapter.get_credential(filename)
+        if not credential_data:
+            log.error(f"Credential not found: {filename}")
+            raise HTTPException(status_code=404, detail="凭证文件不存在")
+        
+        if action == "enable":
+            log.info(f"Web request: ENABLING file {filename}")
+            await credential_manager.set_cred_disabled(filename, False)
+            log.info(f"Web request: ENABLED file {filename} successfully")
+            return JSONResponse(content={"message": f"已启用凭证文件 {os.path.basename(filename)}"})
+        
+        elif action == "disable":
+            log.info(f"Web request: DISABLING file {filename}")
+            await credential_manager.set_cred_disabled(filename, True)
+            log.info(f"Web request: DISABLED file {filename} successfully")
+            return JSONResponse(content={"message": f"已禁用凭证文件 {os.path.basename(filename)}"})
+        
+        elif action == "delete":
+            try:
+                # 使用存储适配器删除凭证
+                success = await storage_adapter.delete_credential(filename)
+                if success:
+                    log.info(f"Successfully deleted credential: {filename}")
+                    return JSONResponse(content={"message": f"已删除凭证文件 {os.path.basename(filename)}"})
+                else:
+                    raise HTTPException(status_code=500, detail="删除凭证失败")
+            except Exception as e:
+                log.error(f"Error deleting credential {filename}: {e}")
+                raise HTTPException(status_code=500, detail=f"删除文件失败: {str(e)}")
+        
+        else:
+            raise HTTPException(status_code=400, detail="无效的操作类型")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"凭证文件操作失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/creds/batch-action")
+async def creds_batch_action(request: CredFileBatchActionRequest, token: str = Depends(verify_token)):
+    """批量对凭证文件执行操作（启用/禁用/删除）"""
+    try:
+        await ensure_credential_manager_initialized()
+        
+        action = request.action
+        filenames = request.filenames
+        
+        if not filenames:
+            raise HTTPException(status_code=400, detail="文件名列表不能为空")
+        
+        log.info(f"Performing batch action '{action}' on {len(filenames)} files")
+        
+        success_count = 0
+        errors = []
+        
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+        
+        for filename in filenames:
+            try:
+                # 验证文件名安全性
+                if not filename.endswith('.json'):
+                    errors.append(f"{filename}: 无效的文件类型")
+                    continue
+                
+                # 检查凭证是否存在
+                credential_data = await storage_adapter.get_credential(filename)
+                if not credential_data:
+                    errors.append(f"{filename}: 凭证不存在")
+                    continue
+                
+                # 执行相应操作
+                if action == "enable":
+                    await credential_manager.set_cred_disabled(filename, False)
+                    success_count += 1
+                    
+                elif action == "disable":
+                    await credential_manager.set_cred_disabled(filename, True)
+                    success_count += 1
+                    
+                elif action == "delete":
+                    try:
+                        # 使用存储适配器删除凭证
+                        delete_success = await storage_adapter.delete_credential(filename)
+                        if delete_success:
+                            success_count += 1
+                            log.info(f"Successfully deleted credential in batch: {filename}")
+                        else:
+                            errors.append(f"{filename}: 删除失败")
+                            continue
+                    except Exception as e:
+                        errors.append(f"{filename}: 删除文件失败 - {str(e)}")
+                        continue
+                else:
+                    errors.append(f"{filename}: 无效的操作类型")
+                    continue
+                    
+            except Exception as e:
+                log.error(f"Processing {filename} failed: {e}")
+                errors.append(f"{filename}: 处理失败 - {str(e)}")
+                continue
+        
+        # 构建返回消息
+        result_message = f"批量操作完成：成功处理 {success_count}/{len(filenames)} 个文件"
+        if errors:
+            result_message += f"\n错误详情：\n" + "\n".join(errors)
+            
+        response_data = {
+            "success_count": success_count,
+            "total_count": len(filenames),
+            "errors": errors,
+            "message": result_message
+        }
+        
+        return JSONResponse(content=response_data)
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"批量凭证文件操作失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/creds/download/{filename}")
+async def download_cred_file(filename: str, token: str = Depends(verify_token)):
+    """下载单个凭证文件"""
+    try:
+        # 验证文件名安全性
+        if not filename.endswith('.json'):
+            raise HTTPException(status_code=404, detail="无效的文件名")
+        
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+        
+        # 从存储系统获取凭证数据
+        credential_data = await storage_adapter.get_credential(filename)
+        if not credential_data:
+            raise HTTPException(status_code=404, detail="文件不存在")
+        
+        # 转换为JSON字符串
+        content = json.dumps(credential_data, ensure_ascii=False, indent=2)
+        
+        from fastapi.responses import Response
+        return Response(
+            content=content,
+            media_type="application/json",
+            headers={"Content-Disposition": f"attachment; filename={filename}"}
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"下载凭证文件失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/creds/fetch-email/{filename}")
+async def fetch_user_email(filename: str, token: str = Depends(verify_token)):
+    """获取指定凭证文件的用户邮箱地址"""
+    try:
+        await ensure_credential_manager_initialized()
+        
+        # 标准化文件名（只保留文件名部分）
+        import os
+        filename_only = os.path.basename(filename)
+        if not filename_only.endswith('.json'):
+            raise HTTPException(status_code=404, detail="无效的文件名")
+        
+        # 检查凭证是否存在于存储系统中
+        storage_adapter = await get_storage_adapter()
+        credential_data = await storage_adapter.get_credential(filename_only)
+        if not credential_data:
+            raise HTTPException(status_code=404, detail="凭证文件不存在")
+        
+        # 获取用户邮箱（使用凭证名称而不是文件路径）
+        email = await credential_manager.get_or_fetch_user_email(filename_only)
+        
+        if email:
+            return JSONResponse(content={
+                "filename": filename_only,
+                "user_email": email,
+                "message": "成功获取用户邮箱"
+            })
+        else:
+            return JSONResponse(content={
+                "filename": filename_only,
+                "user_email": None,
+                "message": "无法获取用户邮箱，可能凭证已过期或权限不足"
+            }, status_code=400)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"获取用户邮箱失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/creds/refresh-all-emails")
+async def refresh_all_user_emails(token: str = Depends(verify_token)):
+    """刷新所有凭证文件的用户邮箱地址"""
+    try:
+        await ensure_credential_manager_initialized()
+        
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+        
+        # 获取所有凭证文件
+        credential_filenames = await storage_adapter.list_credentials()
+        
+        results = []
+        success_count = 0
+        
+        for filename in credential_filenames:
+            try:
+                email = await credential_manager.get_or_fetch_user_email(filename)
+                if email:
+                    success_count += 1
+                    results.append({
+                        "filename": os.path.basename(filename),
+                        "user_email": email,
+                        "success": True
+                    })
+                else:
+                    results.append({
+                        "filename": os.path.basename(filename),
+                        "user_email": None,
+                        "success": False,
+                        "error": "无法获取邮箱"
+                    })
+            except Exception as e:
+                results.append({
+                    "filename": os.path.basename(filename),
+                    "user_email": None,
+                    "success": False,
+                    "error": str(e)
+                })
+        
+        return JSONResponse(content={
+            "success_count": success_count,
+            "total_count": len(credential_filenames),
+            "results": results,
+            "message": f"成功获取 {success_count}/{len(credential_filenames)} 个邮箱地址"
+        })
+        
+    except Exception as e:
+        log.error(f"批量获取用户邮箱失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/creds/download-all")
+async def download_all_creds(token: str = Depends(verify_token)):
+    """打包下载所有凭证文件"""
+    try:
+        # 获取存储适配器
+        storage_adapter = await get_storage_adapter()
+        
+        # 获取所有凭证文件列表
+        credential_filenames = await storage_adapter.list_credentials()
+        
+        if not credential_filenames:
+            raise HTTPException(status_code=404, detail="没有找到凭证文件")
+        
+        # 创建内存中的ZIP文件
+        zip_buffer = io.BytesIO()
+        
+        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            # 遍历所有凭证文件
+            for filename in credential_filenames:
+                try:
+                    credential_data = await storage_adapter.get_credential(filename)
+                    if credential_data:
+                        # 转换为JSON字符串
+                        content = json.dumps(credential_data, ensure_ascii=False, indent=2)
+                        
+                        # 添加到ZIP文件中
+                        zip_file.writestr(os.path.basename(filename), content)
+                        log.debug(f"已添加到ZIP: {filename}")
+                except Exception as e:
+                    log.warning(f"处理凭证文件 {filename} 时出错: {e}")
+                    continue
+        
+        zip_buffer.seek(0)
+        return Response(
+            content=zip_buffer.getvalue(),
+            media_type="application/zip",
+            headers={"Content-Disposition": "attachment; filename=credentials.zip"}
+        )
+        
+    except Exception as e:
+        log.error(f"打包下载失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/config/get")
+async def get_config(token: str = Depends(verify_token)):
+    """获取当前配置"""
+    try:
+        await ensure_credential_manager_initialized()
+        
+        # 导入配置相关模块
+        
+        # 读取当前配置（包括环境变量和TOML文件中的配置）
+        current_config = {}
+        env_locked = []
+        
+        # 基础配置
+        current_config["code_assist_endpoint"] = await config.get_code_assist_endpoint()
+        current_config["credentials_dir"] = await config.get_credentials_dir()
+        current_config["proxy"] = await config.get_proxy_config() or ""
+        
+        # 代理端点配置
+        current_config["oauth_proxy_url"] = await config.get_oauth_proxy_url()
+        current_config["googleapis_proxy_url"] = await config.get_googleapis_proxy_url()
+        current_config["resource_manager_api_url"] = await config.get_resource_manager_api_url()
+        current_config["service_usage_api_url"] = await config.get_service_usage_api_url()
+        
+        # 检查环境变量锁定状态
+        if os.getenv("CODE_ASSIST_ENDPOINT"):
+            env_locked.append("code_assist_endpoint")
+        if os.getenv("CREDENTIALS_DIR"):
+            env_locked.append("credentials_dir")
+        if os.getenv("PROXY"):
+            env_locked.append("proxy")
+        if os.getenv("OAUTH_PROXY_URL"):
+            env_locked.append("oauth_proxy_url")
+        if os.getenv("GOOGLEAPIS_PROXY_URL"):
+            env_locked.append("googleapis_proxy_url")
+        if os.getenv("RESOURCE_MANAGER_API_URL"):
+            env_locked.append("resource_manager_api_url")
+        if os.getenv("SERVICE_USAGE_API_URL"):
+            env_locked.append("service_usage_api_url")
+        
+        # 自动封禁配置
+        current_config["auto_ban_enabled"] = await config.get_auto_ban_enabled()
+        current_config["auto_ban_error_codes"] = await config.get_auto_ban_error_codes()
+        
+        # 检查环境变量锁定状态
+        if os.getenv("AUTO_BAN"):
+            env_locked.append("auto_ban_enabled")
+        
+        # 从存储系统读取配置
+        storage_adapter = await get_storage_adapter()
+        storage_config = await storage_adapter.get_all_config()
+        
+        # 合并存储系统配置（不覆盖环境变量）
+        for key, value in storage_config.items():
+            if key not in env_locked:
+                current_config[key] = value
+        
+        # 性能配置
+        current_config["calls_per_rotation"] = await config.get_calls_per_rotation()
+        
+        # 429重试配置
+        current_config["retry_429_max_retries"] = await config.get_retry_429_max_retries()
+        current_config["retry_429_enabled"] = await config.get_retry_429_enabled()
+        current_config["retry_429_interval"] = await config.get_retry_429_interval()
+        
+        
+        # 抗截断配置
+        current_config["anti_truncation_max_attempts"] = await config.get_anti_truncation_max_attempts()
+        
+        # 兼容性配置
+        current_config["compatibility_mode_enabled"] = await config.get_compatibility_mode_enabled()
+        
+        # 服务器配置
+        current_config["host"] = await config.get_server_host()
+        current_config["port"] = await config.get_server_port()
+        current_config["api_password"] = await config.get_api_password()
+        current_config["panel_password"] = await config.get_panel_password()
+        current_config["password"] = await config.get_server_password()
+        
+        # 检查其他环境变量锁定状态
+        if os.getenv("RETRY_429_MAX_RETRIES"):
+            env_locked.append("retry_429_max_retries")
+        if os.getenv("RETRY_429_ENABLED"):
+            env_locked.append("retry_429_enabled")
+        if os.getenv("RETRY_429_INTERVAL"):
+            env_locked.append("retry_429_interval")
+        if os.getenv("ANTI_TRUNCATION_MAX_ATTEMPTS"):
+            env_locked.append("anti_truncation_max_attempts")
+        if os.getenv("COMPATIBILITY_MODE"):
+            env_locked.append("compatibility_mode_enabled")
+        if os.getenv("HOST"):
+            env_locked.append("host")
+        if os.getenv("PORT"):
+            env_locked.append("port")
+        if os.getenv("API_PASSWORD"):
+            env_locked.append("api_password")
+        if os.getenv("PANEL_PASSWORD"):
+            env_locked.append("panel_password")
+        if os.getenv("PASSWORD"):
+            env_locked.append("password")
+        
+        return JSONResponse(content={
+            "config": current_config,
+            "env_locked": env_locked
+        })
+        
+    except Exception as e:
+        log.error(f"获取配置失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/config/save")
+async def save_config(request: ConfigSaveRequest, token: str = Depends(verify_token)):
+    """保存配置到TOML文件"""
+    try:
+        await ensure_credential_manager_initialized()
+        new_config = request.config
+        
+        log.debug(f"收到的配置数据: {list(new_config.keys())}")
+        log.debug(f"收到的password值: {new_config.get('password', 'NOT_FOUND')}")
+
+        # 验证配置项
+        if "calls_per_rotation" in new_config:
+            if not isinstance(new_config["calls_per_rotation"], int) or new_config["calls_per_rotation"] < 1:
+                raise HTTPException(status_code=400, detail="凭证轮换调用次数必须是大于0的整数")
+        
+        
+        if "retry_429_max_retries" in new_config:
+            if not isinstance(new_config["retry_429_max_retries"], int) or new_config["retry_429_max_retries"] < 0:
+                raise HTTPException(status_code=400, detail="最大429重试次数必须是大于等于0的整数")
+        
+        if "retry_429_enabled" in new_config:
+            if not isinstance(new_config["retry_429_enabled"], bool):
+                raise HTTPException(status_code=400, detail="429重试开关必须是布尔值")
+        
+        # 验证新的配置项
+        if "retry_429_interval" in new_config:
+            try:
+                interval = float(new_config["retry_429_interval"])
+                if interval < 0.01 or interval > 10:
+                    raise HTTPException(status_code=400, detail="429重试间隔必须在0.01-10秒之间")
+            except (ValueError, TypeError):
+                raise HTTPException(status_code=400, detail="429重试间隔必须是有效的数字")
+        
+        
+        if "anti_truncation_max_attempts" in new_config:
+            if not isinstance(new_config["anti_truncation_max_attempts"], int) or new_config["anti_truncation_max_attempts"] < 1 or new_config["anti_truncation_max_attempts"] > 10:
+                raise HTTPException(status_code=400, detail="抗截断最大重试次数必须是1-10之间的整数")
+        
+        if "compatibility_mode_enabled" in new_config:
+            if not isinstance(new_config["compatibility_mode_enabled"], bool):
+                raise HTTPException(status_code=400, detail="兼容性模式开关必须是布尔值")
+        
+        # 验证服务器配置
+        if "host" in new_config:
+            if not isinstance(new_config["host"], str) or not new_config["host"].strip():
+                raise HTTPException(status_code=400, detail="服务器主机地址不能为空")
+        
+        if "port" in new_config:
+            if not isinstance(new_config["port"], int) or new_config["port"] < 1 or new_config["port"] > 65535:
+                raise HTTPException(status_code=400, detail="端口号必须是1-65535之间的整数")
+        
+        if "api_password" in new_config:
+            if not isinstance(new_config["api_password"], str):
+                raise HTTPException(status_code=400, detail="API访问密码必须是字符串")
+        
+        if "panel_password" in new_config:
+            if not isinstance(new_config["panel_password"], str):
+                raise HTTPException(status_code=400, detail="控制面板密码必须是字符串")
+        
+        if "password" in new_config:
+            if not isinstance(new_config["password"], str):
+                raise HTTPException(status_code=400, detail="访问密码必须是字符串")
+        
+        # 读取现有的配置文件
+        credentials_dir = await config.get_credentials_dir()
+        config_file = os.path.join(credentials_dir, "config.toml")
+        existing_config = {}
+        
+        try:
+            if os.path.exists(config_file):
+                with open(config_file, "r", encoding="utf-8") as f:
+                    existing_config = toml.load(f)
+        except Exception as e:
+            log.warning(f"读取现有配置文件失败: {e}")
+        
+        # 只更新不被环境变量锁定的配置项
+        env_locked_keys = set()
+        if os.getenv("CODE_ASSIST_ENDPOINT"):
+            env_locked_keys.add("code_assist_endpoint")
+        if os.getenv("CREDENTIALS_DIR"):
+            env_locked_keys.add("credentials_dir")
+        if os.getenv("PROXY"):
+            env_locked_keys.add("proxy")
+        if os.getenv("OAUTH_PROXY_URL"):
+            env_locked_keys.add("oauth_proxy_url")
+        if os.getenv("GOOGLEAPIS_PROXY_URL"):
+            env_locked_keys.add("googleapis_proxy_url")
+        if os.getenv("AUTO_BAN"):
+            env_locked_keys.add("auto_ban_enabled")
+        if os.getenv("RETRY_429_MAX_RETRIES"):
+            env_locked_keys.add("retry_429_max_retries")
+        if os.getenv("RETRY_429_ENABLED"):
+            env_locked_keys.add("retry_429_enabled")
+        if os.getenv("RETRY_429_INTERVAL"):
+            env_locked_keys.add("retry_429_interval")
+        if os.getenv("ANTI_TRUNCATION_MAX_ATTEMPTS"):
+            env_locked_keys.add("anti_truncation_max_attempts")
+        if os.getenv("COMPATIBILITY_MODE"):
+            env_locked_keys.add("compatibility_mode_enabled")
+        if os.getenv("HOST"):
+            env_locked_keys.add("host")
+        if os.getenv("PORT"):
+            env_locked_keys.add("port")
+        if os.getenv("API_PASSWORD"):
+            env_locked_keys.add("api_password")
+        if os.getenv("PANEL_PASSWORD"):
+            env_locked_keys.add("panel_password")
+        if os.getenv("PASSWORD"):
+            env_locked_keys.add("password")
+        
+        for key, value in new_config.items():
+            if key not in env_locked_keys:
+                existing_config[key] = value
+                if key == 'password':
+                    log.debug(f"设置password字段为: {value}")
+                elif key == 'api_password':
+                    log.debug(f"设置api_password字段为: {value}")
+                elif key == 'panel_password':
+                    log.debug(f"设置panel_password字段为: {value}")
+        log.debug(f"最终保存的existing_config中password = {existing_config.get('password', 'NOT_FOUND')}")
+
+        # 直接使用存储适配器保存配置
+        storage_adapter = await get_storage_adapter()
+        for key, value in existing_config.items():
+            await storage_adapter.set_config(key, value)
+        
+        # 验证保存后的结果
+        test_api_password = await config.get_api_password()
+        test_panel_password = await config.get_panel_password()
+        test_password = await config.get_server_password()
+        log.debug(f"保存后立即读取的API密码: {test_api_password}")
+        log.debug(f"保存后立即读取的面板密码: {test_panel_password}")
+        log.debug(f"保存后立即读取的通用密码: {test_password}")
+        
+        # 热更新配置到内存中的模块（如果可能）
+        hot_updated = []  # 记录成功热更新的配置项
+        restart_required = []  # 记录需要重启的配置项
+        
+        # 支持热更新的配置项：
+        # - calls_per_rotation: 凭证轮换调用次数
+        # - proxy: 网络配置
+        # - log_level: 日志级别
+        # - auto_ban_enabled, auto_ban_error_codes: 自动封禁配置
+        # - retry_429_enabled, retry_429_max_retries, retry_429_interval: 429重试配置
+        # - anti_truncation_max_attempts: 抗截断配置
+        # - compatibility_mode_enabled: 兼容性模式
+        # - api_password, panel_password, password: 访问密码
+        #
+        # 需要重启的配置项：
+        # - host, port: 服务器地址和端口
+        # - log_file: 日志文件路径
+        
+        try:
+            # save_config_to_toml已经更新了缓存，不需要reload
+            
+            # 1. credential_manager配置通过config模块动态获取，无需手动更新
+            if "calls_per_rotation" in new_config and "calls_per_rotation" not in env_locked_keys:
+                # 新的credential_manager会通过get_calls_per_rotation()动态获取最新配置
+                hot_updated.append("calls_per_rotation")
+
+            # 2. 代理配置（部分热更新）
+            if "proxy" in new_config and "proxy" not in env_locked_keys:
+                hot_updated.append("proxy")
+            
+            # 代理端点配置（可热更新）
+            proxy_endpoint_configs = ["oauth_proxy_url", "googleapis_proxy_url"]
+            for config_key in proxy_endpoint_configs:
+                if config_key in new_config and config_key not in env_locked_keys:
+                    hot_updated.append(config_key)
+
+
+            # 4. 其他可热更新的配置项
+            hot_updatable_configs = [
+                "auto_ban_enabled", "auto_ban_error_codes",
+                "retry_429_enabled", "retry_429_max_retries", "retry_429_interval",
+                "anti_truncation_max_attempts", "compatibility_mode_enabled"
+            ]
+            
+            for config_key in hot_updatable_configs:
+                if config_key in new_config and config_key not in env_locked_keys:
+                    hot_updated.append(config_key)
+            
+            # 4. 需要重启的配置项
+            restart_required_configs = ["host", "port"]
+            for config_key in restart_required_configs:
+                if config_key in new_config and config_key not in env_locked_keys:
+                    restart_required.append(config_key)
+            
+            # 5. 密码配置（立即生效）
+            password_configs = ["api_password", "panel_password", "password"]
+            for config_key in password_configs:
+                if config_key in new_config and config_key not in env_locked_keys:
+                    hot_updated.append(config_key)
+            
+        except Exception as e:
+            log.warning(f"热更新配置失败: {e}")
+        
+        # 构建响应消息
+        response_data = {
+            "message": "配置保存成功",
+            "saved_config": {k: v for k, v in new_config.items() if k not in env_locked_keys}
+        }
+        
+        # 添加热更新状态信息
+        if hot_updated:
+            response_data["hot_updated"] = hot_updated
+        
+        if restart_required:
+            response_data["restart_required"] = restart_required
+            response_data["restart_notice"] = f"以下配置项需要重启服务器才能生效: {', '.join(restart_required)}"
+        
+        return JSONResponse(content=response_data)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"保存配置失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/auth/load-env-creds")
+async def load_env_credentials(token: str = Depends(verify_token)):
+    """从环境变量加载凭证文件"""
+    try:
+        result = await load_credentials_from_env()
+        
+        if result['loaded_count'] > 0:
+            return JSONResponse(content={
+                "loaded_count": result['loaded_count'],
+                "total_count": result['total_count'],
+                "results": result['results'],
+                "message": result['message']
+            })
+        else:
+            return JSONResponse(content={
+                "loaded_count": 0,
+                "total_count": result['total_count'],
+                "message": result['message'],
+                "results": result['results']
+            })
+            
+    except Exception as e:
+        log.error(f"从环境变量加载凭证失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/auth/env-creds")
+async def clear_env_creds(token: str = Depends(verify_token)):
+    """清除所有从环境变量导入的凭证文件"""
+    try:
+        result = await clear_env_credentials()
+        
+        if 'error' in result:
+            raise HTTPException(status_code=500, detail=result['error'])
+        
+        return JSONResponse(content={
+            "deleted_count": result['deleted_count'],
+            "deleted_files": result.get('deleted_files', []),
+            "message": result['message']
+        })
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"清除环境变量凭证失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/auth/env-creds-status")
+async def get_env_creds_status(token: str = Depends(verify_token)):
+    """获取环境变量凭证状态"""
+    try:
+        # 检查有哪些环境变量可用
+        available_env_vars = {key: "***已设置***" for key, value in os.environ.items() 
+                              if key.startswith('GCLI_CREDS_') and value.strip()}
+        
+        # 检查自动加载设置
+        auto_load_enabled = await config.get_auto_load_env_creds()
+        
+        # 统计已存在的环境变量凭证文件
+        storage_adapter = await get_storage_adapter()
+        all_credentials = await storage_adapter.list_credentials()
+        existing_env_files = [
+            filename for filename in all_credentials 
+            if filename.startswith('env-') and filename.endswith('.json')
+        ]
+        
+        return JSONResponse(content={
+            "available_env_vars": available_env_vars,
+            "auto_load_enabled": auto_load_enabled,
+            "existing_env_files_count": len(existing_env_files),
+            "existing_env_files": existing_env_files
+        })
+        
+    except Exception as e:
+        log.error(f"获取环境变量凭证状态失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# =============================================================================
+# 实时日志WebSocket (Real-time Logs WebSocket)  
+# =============================================================================
+
+@router.post("/auth/logs/clear")
+async def clear_logs(token: str = Depends(verify_token)):
+    """清空日志文件"""
+    try:
+        # 直接使用环境变量获取日志文件路径
+        log_file_path = os.getenv('LOG_FILE', 'log.txt')
+        
+        # 检查日志文件是否存在
+        if os.path.exists(log_file_path):
+            try:
+                # 清空文件内容（保留文件），确保以UTF-8编码写入
+                with open(log_file_path, 'w', encoding='utf-8', newline='') as f:
+                    f.write('')
+                    f.flush()  # 强制刷新到磁盘
+                log.info(f"日志文件已清空: {log_file_path}")
+                
+                # 通知所有WebSocket连接日志已清空
+                await manager.broadcast("--- 日志文件已清空 ---")
+                
+                return JSONResponse(content={"message": f"日志文件已清空: {os.path.basename(log_file_path)}"})
+            except Exception as e:
+                log.error(f"清空日志文件失败: {e}")
+                raise HTTPException(status_code=500, detail=f"清空日志文件失败: {str(e)}")
+        else:
+            return JSONResponse(content={"message": "日志文件不存在"})
+            
+    except Exception as e:
+        log.error(f"清空日志文件失败: {e}")
+        raise HTTPException(status_code=500, detail=f"清空日志文件失败: {str(e)}")
+
+@router.get("/auth/logs/download")
+async def download_logs(token: str = Depends(verify_token)):
+    """下载日志文件"""
+    try:
+        # 直接使用环境变量获取日志文件路径
+        log_file_path = os.getenv('LOG_FILE', 'log.txt')
+        
+        # 检查日志文件是否存在
+        if not os.path.exists(log_file_path):
+            raise HTTPException(status_code=404, detail="日志文件不存在")
+        
+        # 检查文件是否为空
+        file_size = os.path.getsize(log_file_path)
+        if file_size == 0:
+            raise HTTPException(status_code=404, detail="日志文件为空")
+        
+        # 生成文件名（包含时间戳）
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"gcli2api_logs_{timestamp}.txt"
+        
+        log.info(f"下载日志文件: {log_file_path}")
+        
+        return FileResponse(
+            path=log_file_path,
+            filename=filename,
+            media_type='text/plain',
+            headers={"Content-Disposition": f"attachment; filename={filename}"}
+        )
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(f"下载日志文件失败: {e}")
+        raise HTTPException(status_code=500, detail=f"下载日志文件失败: {str(e)}")
+
+@router.websocket("/auth/logs/stream")
+async def websocket_logs(websocket: WebSocket):
+    """WebSocket端点，用于实时日志流"""
+    # 检查连接数限制
+    if not await manager.connect(websocket):
+        return
+    
+    try:
+        # 直接使用环境变量获取日志文件路径
+        log_file_path = os.getenv('LOG_FILE', 'log.txt')
+        
+        # 发送初始日志（限制为最后50行，减少内存占用）
+        if os.path.exists(log_file_path):
+            try:
+                with open(log_file_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()
+                    # 只发送最后50行，减少初始内存消耗
+                    for line in lines[-50:]:
+                        if line.strip():
+                            await websocket.send_text(line.strip())
+            except Exception as e:
+                await websocket.send_text(f"Error reading log file: {e}")
+        
+        # 监控日志文件变化
+        last_size = os.path.getsize(log_file_path) if os.path.exists(log_file_path) else 0
+        max_read_size = 8192  # 限制单次读取大小为8KB，防止大量日志造成内存激增
+        check_interval = 2    # 增加检查间隔，减少CPU和I/O开销
+        
+        while websocket.client_state == WebSocketState.CONNECTED:
+            await asyncio.sleep(check_interval)
+            
+            if os.path.exists(log_file_path):
+                current_size = os.path.getsize(log_file_path)
+                if current_size > last_size:
+                    # 限制读取大小，防止单次读取过多内容
+                    read_size = min(current_size - last_size, max_read_size)
+                    
+                    try:
+                        with open(log_file_path, "r", encoding="utf-8", errors="replace") as f:
+                            f.seek(last_size)
+                            new_content = f.read(read_size)
+                            
+                            # 处理编码错误的情况
+                            if not new_content:
+                                last_size = current_size
+                                continue
+                            
+                            # 分行发送，避免发送不完整的行
+                            lines = new_content.splitlines(keepends=True)
+                            if lines:
+                                # 如果最后一行没有换行符，保留到下次处理
+                                if not lines[-1].endswith('\n') and len(lines) > 1:
+                                    # 除了最后一行，其他都发送
+                                    for line in lines[:-1]:
+                                        if line.strip():
+                                            await websocket.send_text(line.rstrip())
+                                    # 更新位置，但要退回最后一行的字节数
+                                    last_size += len(new_content.encode('utf-8')) - len(lines[-1].encode('utf-8'))
+                                else:
+                                    # 所有行都发送
+                                    for line in lines:
+                                        if line.strip():
+                                            await websocket.send_text(line.rstrip())
+                                    last_size += len(new_content.encode('utf-8'))
+                    except UnicodeDecodeError as e:
+                        # 遇到编码错误时，跳过这部分内容
+                        log.warning(f"WebSocket日志读取编码错误: {e}, 跳过部分内容")
+                        last_size = current_size
+                    except Exception as e:
+                        await websocket.send_text(f"Error reading new content: {e}")
+                        # 发生其他错误时，重置文件位置
+                        last_size = current_size
+                        
+                # 如果文件被截断（如清空日志），重置位置
+                elif current_size < last_size:
+                    last_size = 0
+                    await websocket.send_text("--- 日志已清空 ---")
+                    
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        log.error(f"WebSocket logs error: {e}")
+    finally:
+        manager.disconnect(websocket)
+
+
+# =============================================================================
+# Usage Statistics API (使用统计API)
+# =============================================================================
+
+@router.get("/usage/stats")
+async def get_usage_statistics(filename: Optional[str] = None, token: str = Depends(verify_token)):
+    """
+    获取使用统计信息
+    
+    Args:
+        filename: 可选，指定凭证文��名。如果不提供则返回所有文件的统计
+    
+    Returns:
+        usage statistics for the specified file or all files
+    """
+    try:
+        stats = await get_usage_stats(filename)
+        return JSONResponse(content={
+            "success": True,
+            "data": stats
+        })
+    except Exception as e:
+        log.error(f"获取使用统计失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/usage/aggregated")
+async def get_aggregated_usage_statistics(token: str = Depends(verify_token)):
+    """
+    获取聚合使用统计信息
+    
+    Returns:
+        Aggregated statistics across all credential files
+    """
+    try:
+        stats = await get_aggregated_stats()
+        return JSONResponse(content={
+            "success": True,
+            "data": stats
+        })
+    except Exception as e:
+        log.error(f"获取聚合统计失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
+class UsageLimitsUpdateRequest(BaseModel):
+    filename: str
+    gemini_2_5_pro_limit: Optional[int] = None
+    total_limit: Optional[int] = None
+
+
+@router.post("/usage/update-limits")
+async def update_usage_limits(request: UsageLimitsUpdateRequest, token: str = Depends(verify_token)):
+    """
+    更新指定凭证文件的每日使用限制
+    
+    Args:
+        request: 包含文件名和新限制值的请求
+    
+    Returns:
+        Success message
+    """
+    try:
+        stats_instance = await get_usage_stats_instance()
+        
+        await stats_instance.update_daily_limits(
+            filename=request.filename,
+            gemini_2_5_pro_limit=request.gemini_2_5_pro_limit,
+            total_limit=request.total_limit
+        )
+        
+        return JSONResponse(content={
+            "success": True,
+            "message": f"已更新 {request.filename} 的使用限制"
+        })
+        
+    except Exception as e:
+        log.error(f"更新使用限制失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+class UsageResetRequest(BaseModel):
+    filename: Optional[str] = None
+
+
+@router.post("/usage/reset")
+async def reset_usage_statistics(request: UsageResetRequest, token: str = Depends(verify_token)):
+    """
+    重置使用统计
+    
+    Args:
+        request: 包含可选文件名的请求。如果不提供文件名则重置所有统计
+    
+    Returns:
+        Success message
+    """
+    try:
+        stats_instance = await get_usage_stats_instance()
+        
+        await stats_instance.reset_stats(filename=request.filename)
+        
+        if request.filename:
+            message = f"已重置 {request.filename} 的使用统计"
+        else:
+            message = "已重置所有文件的使用统计"
+        
+        return JSONResponse(content={
+            "success": True,
+            "message": message
+        })
+        
+    except Exception as e:
+        log.error(f"重置使用统计失败: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+