chore: 更新版本号至2.2.5

- 统一 add_error_log 的 request_time：优先使用 request_datetime，
  否则使用 datetime.now()，去除 timezone.utc，避免与请求日志时区不一致
- 在 Gemini/OpenAI/Vertex/Embedding 等服务的异常处理处补充传入
  request_datetime，使错误日志与请求日志可一一对应
- stats: 移除失败记录的错误日志时间窗匹配与 error_log_id 附带，降低查询开销
  与误关联风险；建议通过统一时间戳（key + request_time）或独立错误日志
  查询接口完成关联
- 调整部分导入顺序与长行换行等代码风格，无功能改动

BREAKING CHANGE: 统计详情接口不再返回 error_log_id 字段。需要关联错误日志的
客户端请改为基于 key 与 request_time 在错误日志接口中检索。

VERSION

@@ -1 +1 @@
-2.2.2
+2.2.5

app/database/services.py

@@ -1,12 +1,15 @@
 """
 数据库服务模块
 """
-from typing import List, Optional, Dict, Any, Union
-from datetime import datetime, timezone
-from sqlalchemy import func, desc, asc, select, insert, update, delete
+
 import json
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List, Optional, Union
+
+from sqlalchemy import asc, delete, desc, func, insert, select, update
+
 from app.database.connection import database
-from app.database.models import Settings, ErrorLog, RequestLog, FileRecord, FileState
+from app.database.models import ErrorLog, FileRecord, FileState, RequestLog, Settings
 from app.log.logger import get_database_logger
 from app.utils.helpers import redact_key_for_logging
 
@@ -16,7 +19,7 @@ logger = get_database_logger()
 async def get_all_settings() -> List[Dict[str, Any]]:
     """
     获取所有设置
-    
+
     Returns:
         List[Dict[str, Any]]: 设置列表
     """
@@ -32,10 +35,10 @@ async def get_all_settings() -> List[Dict[str, Any]]:
 async def get_setting(key: str) -> Optional[Dict[str, Any]]:
     """
     获取指定键的设置
-    
+
     Args:
         key: 设置键名
-    
+
     Returns:
         Optional[Dict[str, Any]]: 设置信息，如果不存在则返回None
     """
@@ -48,22 +51,24 @@ async def get_setting(key: str) -> Optional[Dict[str, Any]]:
         raise
 
 
-async def update_setting(key: str, value: str, description: Optional[str] = None) -> bool:
+async def update_setting(
+    key: str, value: str, description: Optional[str] = None
+) -> bool:
     """
     更新设置
-    
+
     Args:
         key: 设置键名
         value: 设置值
         description: 设置描述
-    
+
     Returns:
         bool: 是否更新成功
     """
     try:
         # 检查设置是否存在
         setting = await get_setting(key)
-        
+
         if setting:
             # 更新设置
             query = (
@@ -72,7 +77,7 @@ async def update_setting(key: str, value: str, description: Optional[str] = None
                 .values(
                     value=value,
                     description=description if description else setting["description"],
-                    updated_at=datetime.now()
+                    updated_at=datetime.now(),
                 )
             )
             await database.execute(query)
@@ -80,15 +85,12 @@ async def update_setting(key: str, value: str, description: Optional[str] = None
             return True
         else:
             # 插入设置
-            query = (
-                insert(Settings)
-                .values(
-                    key=key,
-                    value=value,
-                    description=description,
-                    created_at=datetime.now(),
-                    updated_at=datetime.now()
-                )
+            query = insert(Settings).values(
+                key=key,
+                value=value,
+                description=description,
+                created_at=datetime.now(),
+                updated_at=datetime.now(),
             )
             await database.execute(query)
             logger.info(f"Inserted setting: {key}")
@@ -104,17 +106,18 @@ async def add_error_log(
     error_type: Optional[str] = None,
     error_log: Optional[str] = None,
     error_code: Optional[int] = None,
-    request_msg: Optional[Union[Dict[str, Any], str]] = None
+    request_msg: Optional[Union[Dict[str, Any], str]] = None,
+    request_datetime: Optional[datetime] = None,
 ) -> bool:
     """
     添加错误日志
-    
+
     Args:
         gemini_key: Gemini API密钥
         error_log: 错误日志
         error_code: 错误代码 (例如 HTTP 状态码)
         request_msg: 请求消息
-    
+
     Returns:
         bool: 是否添加成功
     """
@@ -129,19 +132,16 @@ async def add_error_log(
                 request_msg_json = {"message": request_msg}
         else:
             request_msg_json = None
-        
+
         # 插入错误日志
-        query = (
-            insert(ErrorLog)
-            .values(
-                gemini_key=gemini_key,
-                error_type=error_type,
-                error_log=error_log,
-                model_name=model_name,
-                error_code=error_code,
-                request_msg=request_msg_json,
-                request_time=datetime.now()
-            )
+        query = insert(ErrorLog).values(
+            gemini_key=gemini_key,
+            error_type=error_type,
+            error_log=error_log,
+            model_name=model_name,
+            error_code=error_code,
+            request_msg=request_msg_json,
+            request_time=(request_datetime if request_datetime else datetime.now()),
         )
         await database.execute(query)
         logger.info(f"Added error log for key: {redact_key_for_logging(gemini_key)}")
@@ -159,8 +159,8 @@ async def get_error_logs(
     error_code_search: Optional[str] = None,
     start_date: Optional[datetime] = None,
     end_date: Optional[datetime] = None,
-    sort_by: str = 'id',
-    sort_order: str = 'desc'
+    sort_by: str = "id",
+    sort_order: str = "desc",
 ) -> List[Dict[str, Any]]:
     """
     获取错误日志，支持搜索、日期过滤和排序
@@ -187,15 +187,15 @@ async def get_error_logs(
             ErrorLog.error_type,
             ErrorLog.error_log,
             ErrorLog.error_code,
-            ErrorLog.request_time
+            ErrorLog.request_time,
         )
-        
+
         if key_search:
             query = query.where(ErrorLog.gemini_key.ilike(f"%{key_search}%"))
         if error_search:
             query = query.where(
-                (ErrorLog.error_type.ilike(f"%{error_search}%")) |
-                (ErrorLog.error_log.ilike(f"%{error_search}%"))
+                (ErrorLog.error_type.ilike(f"%{error_search}%"))
+                | (ErrorLog.error_log.ilike(f"%{error_search}%"))
             )
         if start_date:
             query = query.where(ErrorLog.request_time >= start_date)
@@ -206,10 +206,12 @@ async def get_error_logs(
                 error_code_int = int(error_code_search)
                 query = query.where(ErrorLog.error_code == error_code_int)
             except ValueError:
-                logger.warning(f"Invalid format for error_code_search: '{error_code_search}'. Expected an integer. Skipping error code filter.")
+                logger.warning(
+                    f"Invalid format for error_code_search: '{error_code_search}'. Expected an integer. Skipping error code filter."
+                )
 
         sort_column = getattr(ErrorLog, sort_by, ErrorLog.id)
-        if sort_order.lower() == 'asc':
+        if sort_order.lower() == "asc":
             query = query.order_by(asc(sort_column))
         else:
             query = query.order_by(desc(sort_column))
@@ -228,7 +230,7 @@ async def get_error_logs_count(
     error_search: Optional[str] = None,
     error_code_search: Optional[str] = None,
     start_date: Optional[datetime] = None,
-    end_date: Optional[datetime] = None
+    end_date: Optional[datetime] = None,
 ) -> int:
     """
     获取符合条件的错误日志总数
@@ -250,8 +252,8 @@ async def get_error_logs_count(
             query = query.where(ErrorLog.gemini_key.ilike(f"%{key_search}%"))
         if error_search:
             query = query.where(
-                (ErrorLog.error_type.ilike(f"%{error_search}%")) |
-                (ErrorLog.error_log.ilike(f"%{error_search}%"))
+                (ErrorLog.error_type.ilike(f"%{error_search}%"))
+                | (ErrorLog.error_log.ilike(f"%{error_search}%"))
             )
         if start_date:
             query = query.where(ErrorLog.request_time >= start_date)
@@ -262,8 +264,9 @@ async def get_error_logs_count(
                 error_code_int = int(error_code_search)
                 query = query.where(ErrorLog.error_code == error_code_int)
             except ValueError:
-                logger.warning(f"Invalid format for error_code_search in count: '{error_code_search}'. Expected an integer. Skipping error code filter.")
-
+                logger.warning(
+                    f"Invalid format for error_code_search in count: '{error_code_search}'. Expected an integer. Skipping error code filter."
+                )
 
         count_result = await database.fetch_one(query)
         return count_result[0] if count_result else 0
@@ -289,12 +292,14 @@ async def get_error_log_details(log_id: int) -> Optional[Dict[str, Any]]:
         if result:
             # 将 request_msg (JSONB) 转换为字符串以便在 API 中返回
             log_dict = dict(result)
-            if 'request_msg' in log_dict and log_dict['request_msg'] is not None:
+            if "request_msg" in log_dict and log_dict["request_msg"] is not None:
                 # 确保即使是 None 或非 JSON 数据也能处理
                 try:
-                    log_dict['request_msg'] = json.dumps(log_dict['request_msg'], ensure_ascii=False, indent=2)
+                    log_dict["request_msg"] = json.dumps(
+                        log_dict["request_msg"], ensure_ascii=False, indent=2
+                    )
                 except TypeError:
-                    log_dict['request_msg'] = str(log_dict['request_msg'])
+                    log_dict["request_msg"] = str(log_dict["request_msg"])
             return log_dict
         else:
             return None
@@ -303,6 +308,78 @@ async def get_error_log_details(log_id: int) -> Optional[Dict[str, Any]]:
         raise
 
 
+# 新增函数：通过 gemini_key / error_code / 时间窗口 查找最接近的错误日志
+async def find_error_log_by_info(
+    gemini_key: str,
+    timestamp: datetime,
+    status_code: Optional[int] = None,
+    window_seconds: int = 1,
+) -> Optional[Dict[str, Any]]:
+    """
+    在给定时间窗口内，根据 gemini_key（精确匹配）及可选的 status_code 查找最接近 timestamp 的错误日志。
+
+    假设错误日志的 error_code 存储的是 HTTP 状态码或等价错误码。
+
+    Args:
+        gemini_key: 完整的 Gemini key 字符串。
+        timestamp: 目标时间（UTC 或本地，与存储一致）。
+        status_code: 可选的错误码，若提供则优先匹配该错误码。
+        window_seconds: 允许的时间偏差窗口，单位秒，默认为 1 秒。
+
+    Returns:
+        Optional[Dict[str, Any]]: 最匹配的一条错误日志的完整详情（字段与 get_error_log_details 一致），若未找到则返回 None。
+    """
+    try:
+        start_time = timestamp - timedelta(seconds=window_seconds)
+        end_time = timestamp + timedelta(seconds=window_seconds)
+
+        base_query = select(ErrorLog).where(
+            ErrorLog.gemini_key == gemini_key,
+            ErrorLog.request_time >= start_time,
+            ErrorLog.request_time <= end_time,
+        )
+
+        # 若提供了状态码，先尝试按状态码过滤
+        if status_code is not None:
+            query = base_query.where(ErrorLog.error_code == status_code).order_by(
+                ErrorLog.request_time.desc()
+            )
+            candidates = await database.fetch_all(query)
+            if not candidates:
+                # 回退：不按状态码，仅按时间窗口
+                query2 = base_query.order_by(ErrorLog.request_time.desc())
+                candidates = await database.fetch_all(query2)
+        else:
+            query = base_query.order_by(ErrorLog.request_time.desc())
+            candidates = await database.fetch_all(query)
+
+        if not candidates:
+            return None
+
+        # 在 Python 中选择与 timestamp 最接近的一条
+        def _to_dict(row: Any) -> Dict[str, Any]:
+            d = dict(row)
+            if "request_msg" in d and d["request_msg"] is not None:
+                try:
+                    d["request_msg"] = json.dumps(
+                        d["request_msg"], ensure_ascii=False, indent=2
+                    )
+                except TypeError:
+                    d["request_msg"] = str(d["request_msg"])
+            return d
+
+        best = min(
+            candidates,
+            key=lambda r: abs((r["request_time"] - timestamp).total_seconds()),
+        )
+        return _to_dict(best)
+    except Exception as e:
+        logger.exception(
+            f"Failed to find error log by info (key=***{gemini_key[-4:] if gemini_key else ''}, code={status_code}, ts={timestamp}, window={window_seconds}s): {str(e)}"
+        )
+        raise
+
+
 async def delete_error_logs_by_ids(log_ids: List[int]) -> int:
     """
     根据提供的 ID 列表批量删除错误日志 (异步)。
@@ -327,12 +404,15 @@ async def delete_error_logs_by_ids(log_ids: List[int]) -> int:
         # 注意：databases 的 execute 不返回 rowcount，所以我们不能直接返回删除的数量
         # 返回 log_ids 的长度作为尝试删除的数量，或者返回 0/1 表示操作尝试
         logger.info(f"Attempted bulk deletion for error logs with IDs: {log_ids}")
-        return len(log_ids) # 返回尝试删除的数量
+        return len(log_ids)  # 返回尝试删除的数量
     except Exception as e:
         # 数据库连接或执行错误
-        logger.error(f"Error during bulk deletion of error logs {log_ids}: {e}", exc_info=True)
+        logger.error(
+            f"Error during bulk deletion of error logs {log_ids}: {e}", exc_info=True
+        )
         raise
 
+
 async def delete_error_log_by_id(log_id: int) -> bool:
     """
     根据 ID 删除单个错误日志 (异步)。
@@ -349,7 +429,9 @@ async def delete_error_log_by_id(log_id: int) -> bool:
         exists = await database.fetch_one(check_query)
 
         if not exists:
-            logger.warning(f"Attempted to delete non-existent error log with ID: {log_id}")
+            logger.warning(
+                f"Attempted to delete non-existent error log with ID: {log_id}"
+            )
             return False
 
         # 执行删除
@@ -360,35 +442,31 @@ async def delete_error_log_by_id(log_id: int) -> bool:
     except Exception as e:
         logger.error(f"Error deleting error log with ID {log_id}: {e}", exc_info=True)
         raise
- 
- 
+
+
 async def delete_all_error_logs() -> int:
     """
     删除所有错误日志条目。
- 
+
     Returns:
-        int: 被删除的错误日志数量。
+        int: 被删除的错误日志数量。如果使用的数据库驱动不支持返回受影响行数，则返回 -1 表示操作成功。
     """
     try:
-        # 1. 获取删除前的总数
-        count_query = select(func.count()).select_from(ErrorLog)
-        total_to_delete = await database.fetch_val(count_query)
- 
-        if total_to_delete == 0:
-            logger.info("No error logs found to delete.")
-            return 0
- 
-        # 2. 执行删除操作
+        # 直接执行删除操作，避免不必要的查询
         delete_query = delete(ErrorLog)
         await database.execute(delete_query)
-        
-        logger.info(f"Successfully deleted all {total_to_delete} error logs.")
-        return total_to_delete
+
+        logger.info("Successfully deleted all error logs.")
+
+        # 由于 databases 库的 execute 方法不返回受影响的行数，
+        # 返回 -1 表示删除操作成功执行，但具体删除数量未知
+        # 这比先查询再删除的方式更高效
+        return -1
     except Exception as e:
         logger.error(f"Failed to delete all error logs: {str(e)}", exc_info=True)
         raise
- 
- 
+
+
 # 新增函数：添加请求日志
 async def add_request_log(
     model_name: Optional[str],
@@ -396,7 +474,7 @@ async def add_request_log(
     is_success: bool,
     status_code: Optional[int] = None,
     latency_ms: Optional[int] = None,
-    request_time: Optional[datetime] = None
+    request_time: Optional[datetime] = None,
 ) -> bool:
     """
     添加 API 请求日志
@@ -421,7 +499,7 @@ async def add_request_log(
             api_key=api_key,
             is_success=is_success,
             status_code=status_code,
-            latency_ms=latency_ms
+            latency_ms=latency_ms,
         )
         await database.execute(query)
         return True
@@ -432,6 +510,7 @@ async def add_request_log(
 
 # ==================== 文件记录相关函数 ====================
 
+
 async def create_file_record(
     name: str,
     mime_type: str,
@@ -445,11 +524,11 @@ async def create_file_record(
     display_name: Optional[str] = None,
     sha256_hash: Optional[str] = None,
     upload_url: Optional[str] = None,
-    user_token: Optional[str] = None
+    user_token: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
     创建文件记录
-    
+
     Args:
         name: 文件名称（格式: files/{file_id}）
         mime_type: MIME 类型
@@ -463,7 +542,7 @@ async def create_file_record(
         sha256_hash: SHA256 哈希值
         upload_url: 临时上传 URL
         user_token: 上传用户的 token
-    
+
     Returns:
         Dict[str, Any]: 创建的文件记录
     """
@@ -481,10 +560,10 @@ async def create_file_record(
             uri=uri,
             api_key=api_key,
             upload_url=upload_url,
-            user_token=user_token
+            user_token=user_token,
         )
         await database.execute(query)
-        
+
         # 返回创建的记录
         return await get_file_record_by_name(name)
     except Exception as e:
@@ -495,10 +574,10 @@ async def create_file_record(
 async def get_file_record_by_name(name: str) -> Optional[Dict[str, Any]]:
     """
     根据文件名获取文件记录
-    
+
     Args:
         name: 文件名称（格式: files/{file_id}）
-    
+
     Returns:
         Optional[Dict[str, Any]]: 文件记录，如果不存在则返回 None
     """
@@ -511,24 +590,23 @@ async def get_file_record_by_name(name: str) -> Optional[Dict[str, Any]]:
         raise
 
 
-
 async def update_file_record_state(
     file_name: str,
     state: FileState,
     update_time: Optional[datetime] = None,
     upload_completed: Optional[datetime] = None,
-    sha256_hash: Optional[str] = None
+    sha256_hash: Optional[str] = None,
 ) -> bool:
     """
     更新文件记录状态
-    
+
     Args:
         file_name: 文件名
         state: 新状态
         update_time: 更新时间
         upload_completed: 上传完成时间
         sha256_hash: SHA256 哈希值
-    
+
     Returns:
         bool: 是否更新成功
     """
@@ -540,14 +618,14 @@ async def update_file_record_state(
             values["upload_completed"] = upload_completed
         if sha256_hash:
             values["sha256_hash"] = sha256_hash
-            
+
         query = update(FileRecord).where(FileRecord.name == file_name).values(**values)
         result = await database.execute(query)
-        
+
         if result:
             logger.info(f"Updated file record state for {file_name} to {state}")
             return True
-        
+
         logger.warning(f"File record not found for update: {file_name}")
         return False
     except Exception as e:
@@ -559,31 +637,33 @@ async def list_file_records(
     user_token: Optional[str] = None,
     api_key: Optional[str] = None,
     page_size: int = 10,
-    page_token: Optional[str] = None
+    page_token: Optional[str] = None,
 ) -> tuple[List[Dict[str, Any]], Optional[str]]:
     """
     列出文件记录
-    
+
     Args:
         user_token: 用户 token（如果提供，只返回该用户的文件）
         api_key: API Key（如果提供，只返回使用该 key 的文件）
         page_size: 每页大小
         page_token: 分页标记（偏移量）
-    
+
     Returns:
         tuple[List[Dict[str, Any]], Optional[str]]: (文件列表, 下一页标记)
     """
     try:
-        logger.debug(f"list_file_records called with page_size={page_size}, page_token={page_token}")
+        logger.debug(
+            f"list_file_records called with page_size={page_size}, page_token={page_token}"
+        )
         query = select(FileRecord).where(
             FileRecord.expiration_time > datetime.now(timezone.utc)
         )
-        
+
         if user_token:
             query = query.where(FileRecord.user_token == user_token)
         if api_key:
             query = query.where(FileRecord.api_key == api_key)
-            
+
         # 使用偏移量进行分页
         offset = 0
         if page_token:
@@ -592,16 +672,18 @@ async def list_file_records(
             except ValueError:
                 logger.warning(f"Invalid page token: {page_token}")
                 offset = 0
-                
+
         # 按ID升序排列，使用 OFFSET 和 LIMIT
         query = query.order_by(FileRecord.id).offset(offset).limit(page_size + 1)
-        
+
         results = await database.fetch_all(query)
-        
+
         logger.debug(f"Query returned {len(results)} records")
         if results:
-            logger.debug(f"First record ID: {results[0]['id']}, Last record ID: {results[-1]['id']}")
-        
+            logger.debug(
+                f"First record ID: {results[0]['id']}, Last record ID: {results[-1]['id']}"
+            )
+
         # 处理分页
         has_next = len(results) > page_size
         if has_next:
@@ -609,11 +691,13 @@ async def list_file_records(
             # 下一页的偏移量是当前偏移量加上本页返回的记录数
             next_offset = offset + page_size
             next_page_token = str(next_offset)
-            logger.debug(f"Has next page, offset={offset}, page_size={page_size}, next_page_token={next_page_token}")
+            logger.debug(
+                f"Has next page, offset={offset}, page_size={page_size}, next_page_token={next_page_token}"
+            )
         else:
             next_page_token = None
             logger.debug(f"No next page, returning {len(results)} results")
-            
+
         return [dict(row) for row in results], next_page_token
     except Exception as e:
         logger.error(f"Failed to list file records: {str(e)}")
@@ -623,10 +707,10 @@ async def list_file_records(
 async def delete_file_record(name: str) -> bool:
     """
     删除文件记录
-    
+
     Args:
         name: 文件名称
-    
+
     Returns:
         bool: 是否删除成功
     """
@@ -642,7 +726,7 @@ async def delete_file_record(name: str) -> bool:
 async def delete_expired_file_records() -> List[Dict[str, Any]]:
     """
     删除已过期的文件记录
-    
+
     Returns:
         List[Dict[str, Any]]: 删除的记录列表
     """
@@ -652,16 +736,16 @@ async def delete_expired_file_records() -> List[Dict[str, Any]]:
             FileRecord.expiration_time <= datetime.now(timezone.utc)
         )
         expired_records = await database.fetch_all(query)
-        
+
         if not expired_records:
             return []
-            
+
         # 执行删除
         delete_query = delete(FileRecord).where(
             FileRecord.expiration_time <= datetime.now(timezone.utc)
         )
         await database.execute(delete_query)
-        
+
         logger.info(f"Deleted {len(expired_records)} expired file records")
         return [dict(record) for record in expired_records]
     except Exception as e:
@@ -672,17 +756,17 @@ async def delete_expired_file_records() -> List[Dict[str, Any]]:
 async def get_file_api_key(name: str) -> Optional[str]:
     """
     获取文件对应的 API Key
-    
+
     Args:
         name: 文件名称
-    
+
     Returns:
         Optional[str]: API Key，如果文件不存在或已过期则返回 None
     """
     try:
         query = select(FileRecord.api_key).where(
-            (FileRecord.name == name) &
-            (FileRecord.expiration_time > datetime.now(timezone.utc))
+            (FileRecord.name == name)
+            & (FileRecord.expiration_time > datetime.now(timezone.utc))
         )
         result = await database.fetch_one(query)
         return result["api_key"] if result else None

app/domain/gemini_models.py

@@ -80,3 +80,36 @@ class ResetSelectedKeysRequest(BaseModel):
 
 class VerifySelectedKeysRequest(BaseModel):
     keys: List[str]
+
+
+class GeminiEmbedContent(BaseModel):
+    """嵌入内容模型"""
+
+    parts: List[Dict[str, str]]
+
+
+class GeminiEmbedRequest(BaseModel):
+    """单一嵌入请求模型"""
+
+    content: GeminiEmbedContent
+    taskType: Optional[
+        Literal[
+            "TASK_TYPE_UNSPECIFIED",
+            "RETRIEVAL_QUERY",
+            "RETRIEVAL_DOCUMENT",
+            "SEMANTIC_SIMILARITY",
+            "CLASSIFICATION",
+            "CLUSTERING",
+            "QUESTION_ANSWERING",
+            "FACT_VERIFICATION",
+            "CODE_RETRIEVAL_QUERY",
+        ]
+    ] = None
+    title: Optional[str] = None
+    outputDimensionality: Optional[int] = None
+
+
+class GeminiBatchEmbedRequest(BaseModel):
+    """批量嵌入请求模型"""
+
+    requests: List[GeminiEmbedRequest]

app/domain/openai_models.py

@@ -12,6 +12,7 @@ class ChatRequest(BaseModel):
     max_tokens: Optional[int] = None
     top_p: Optional[float] = DEFAULT_TOP_P
     top_k: Optional[int] = DEFAULT_TOP_K
+    n: Optional[int] = 1
     stop: Optional[Union[List[str],str]] = None
     reasoning_effort: Optional[str] = None
     tools: Optional[Union[List[Dict[str, Any]], Dict[str, Any]]] = []

app/handler/response_handler.py

@@ -42,21 +42,35 @@ class GeminiResponseHandler(ResponseHandler):
 def _handle_openai_stream_response(
     response: Dict[str, Any], model: str, finish_reason: str, usage_metadata: Optional[Dict[str, Any]]
 ) -> Dict[str, Any]:
-    text, reasoning_content, tool_calls, _ = _extract_result(
-        response, model, stream=True, gemini_format=False
-    )
-    if not text and not tool_calls and not reasoning_content:
-        delta = {}
-    else:
-        delta = {"content": text, "reasoning_content": reasoning_content, "role": "assistant"}
-        if tool_calls:
-            delta["tool_calls"] = tool_calls
+    choices = []
+    candidates = response.get("candidates", [])
+
+    for candidate in candidates:
+        index = candidate.get("index", 0)
+        text, reasoning_content, tool_calls, _ = _extract_result(
+            {"candidates": [candidate]}, model, stream=True, gemini_format=False
+        )
+
+        if not text and not tool_calls and not reasoning_content:
+            delta = {}
+        else:
+            delta = {"content": text, "reasoning_content": reasoning_content, "role": "assistant"}
+            if tool_calls:
+                delta["tool_calls"] = tool_calls
+        
+        choice = {
+            "index": index,
+            "delta": delta,
+            "finish_reason": finish_reason
+        }
+        choices.append(choice)
+
     template_chunk = {
         "id": f"chatcmpl-{uuid.uuid4()}",
         "object": "chat.completion.chunk",
         "created": int(time.time()),
         "model": model,
-        "choices": [{"index": 0, "delta": delta, "finish_reason": finish_reason}],
+        "choices": choices,
     }
     if usage_metadata:
         template_chunk["usage"] = {"prompt_tokens": usage_metadata.get("promptTokenCount", 0), "completion_tokens": usage_metadata.get("candidatesTokenCount",0), "total_tokens": usage_metadata.get("totalTokenCount", 0)}
@@ -66,26 +80,31 @@ def _handle_openai_stream_response(
 def _handle_openai_normal_response(
     response: Dict[str, Any], model: str, finish_reason: str, usage_metadata: Optional[Dict[str, Any]]
 ) -> Dict[str, Any]:
-    text, reasoning_content, tool_calls, _ = _extract_result(
-        response, model, stream=False, gemini_format=False
-    )
+    choices = []
+    candidates = response.get("candidates", [])
+    
+    for i, candidate in enumerate(candidates):
+        text, reasoning_content, tool_calls, _ = _extract_result(
+            {"candidates": [candidate]}, model, stream=False, gemini_format=False
+        )
+        choice = {
+            "index": i,
+            "message": {
+                "role": "assistant",
+                "content": text,
+                "reasoning_content": reasoning_content,
+                "tool_calls": tool_calls,
+            },
+            "finish_reason": finish_reason,
+        }
+        choices.append(choice)
+
     return {
         "id": f"chatcmpl-{uuid.uuid4()}",
         "object": "chat.completion",
         "created": int(time.time()),
         "model": model,
-        "choices": [
-            {
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": text,
-                    "reasoning_content": reasoning_content,
-                    "tool_calls": tool_calls,
-                },
-                "finish_reason": finish_reason,
-            }
-        ],
+        "choices": choices,
         "usage": {"prompt_tokens": usage_metadata.get("promptTokenCount", 0), "completion_tokens": usage_metadata.get("candidatesTokenCount",0), "total_tokens": usage_metadata.get("totalTokenCount", 0)},
     }
 

app/log/logger.py

@@ -284,6 +284,10 @@ def get_vertex_express_logger():
     return Logger.setup_logger("vertex_express")
 
 
+def get_gemini_embedding_logger():
+    return Logger.setup_logger("gemini_embedding")
+
+
 def setup_access_logging():
     """
     Configure uvicorn access logging with API key redaction

app/router/error_log_routes.py

@@ -120,6 +120,7 @@ class ErrorLogDetailResponse(BaseModel):
     request_msg: Optional[str] = None
     model_name: Optional[str] = None
     request_time: Optional[datetime] = None
+    error_code: Optional[int] = None
 
 
 @router.get("/errors/{log_id}/details", response_model=ErrorLogDetailResponse)
@@ -151,6 +152,43 @@ async def get_error_log_detail_api(request: Request, log_id: int = Path(..., ge=
         )
 
 
+@router.get("/errors/lookup", response_model=ErrorLogDetailResponse)
+async def lookup_error_log_by_info(
+    request: Request,
+    gemini_key: str = Query(..., description="完整的 Gemini key"),
+    timestamp: datetime = Query(..., description="请求时间 (ISO8601)"),
+    status_code: Optional[int] = Query(None, description="错误码 (可选)"),
+    window_seconds: int = Query(
+        100, ge=1, le=300, description="时间窗口(秒), 默认100秒"
+    ),
+):
+    """
+    通过 key / 错误码 / 时间窗口 查找最匹配的一条错误日志详情。
+    """
+    auth_token = request.cookies.get("auth_token")
+    if not auth_token or not verify_auth_token(auth_token):
+        logger.warning("Unauthorized access attempt to lookup error log by info")
+        raise HTTPException(status_code=401, detail="Not authenticated")
+
+    try:
+        detail = await error_log_service.process_find_error_log_by_info(
+            gemini_key=gemini_key,
+            timestamp=timestamp,
+            status_code=status_code,
+            window_seconds=window_seconds,
+        )
+        if not detail:
+            raise HTTPException(status_code=404, detail="No matching error log found")
+        return ErrorLogDetailResponse(**detail)
+    except HTTPException as http_exc:
+        raise http_exc
+    except Exception as e:
+        logger.exception(
+            f"Failed to lookup error log by info for key=***{gemini_key[-4:] if gemini_key else ''}: {str(e)}"
+        )
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
 @router.delete("/errors", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_error_logs_bulk_api(
     request: Request, payload: Dict[str, List[int]] = Body(...)
@@ -192,10 +230,10 @@ async def delete_all_error_logs_api(request: Request):
     if not auth_token or not verify_auth_token(auth_token):
         logger.warning("Unauthorized access attempt to delete all error logs")
         raise HTTPException(status_code=401, detail="Not authenticated")
- 
+
     try:
-        deleted_count = await error_log_service.process_delete_all_error_logs()
-        logger.info(f"Successfully deleted all {deleted_count} error logs.")
+        await error_log_service.process_delete_all_error_logs()
+        logger.info("Successfully deleted all error logs.")
         # No body needed for 204 response
         return Response(status_code=status.HTTP_204_NO_CONTENT)
     except Exception as e:
@@ -203,8 +241,8 @@ async def delete_all_error_logs_api(request: Request):
         raise HTTPException(
             status_code=500, detail="Internal server error during deletion of all logs"
         )
- 
- 
+
+
 @router.delete("/errors/{log_id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_error_log_api(request: Request, log_id: int = Path(..., ge=1)):
     """
@@ -214,7 +252,7 @@ async def delete_error_log_api(request: Request, log_id: int = Path(..., ge=1)):
     if not auth_token or not verify_auth_token(auth_token):
         logger.warning(f"Unauthorized access attempt to delete error log ID: {log_id}")
         raise HTTPException(status_code=401, detail="Not authenticated")
- 
+
     try:
         success = await error_log_service.process_delete_error_log_by_id(log_id)
         if not success:

app/router/gemini_routes.py

@@ -5,8 +5,9 @@ import asyncio
 from app.config.config import settings
 from app.log.logger import get_gemini_logger
 from app.core.security import SecurityService
-from app.domain.gemini_models import GeminiContent, GeminiRequest, ResetSelectedKeysRequest, VerifySelectedKeysRequest
+from app.domain.gemini_models import GeminiContent, GeminiRequest, ResetSelectedKeysRequest, VerifySelectedKeysRequest, GeminiEmbedRequest, GeminiBatchEmbedRequest
 from app.service.chat.gemini_chat_service import GeminiChatService
+from app.service.embedding.gemini_embedding_service import GeminiEmbeddingService
 from app.service.key.key_manager import KeyManager, get_key_manager_instance
 from app.service.tts.native.tts_routes import get_tts_chat_service
 from app.service.model.model_service import ModelService
@@ -38,6 +39,11 @@ async def get_chat_service(key_manager: KeyManager = Depends(get_key_manager)):
     return GeminiChatService(settings.BASE_URL, key_manager)
 
 
+async def get_embedding_service(key_manager: KeyManager = Depends(get_key_manager)):
+    """获取Gemini嵌入服务实例"""
+    return GeminiEmbeddingService(settings.BASE_URL, key_manager)
+
+
 @router.get("/models")
 @router_v1beta.get("/models")
 async def list_models(
@@ -210,6 +216,63 @@ async def count_tokens(
             api_key=api_key
         )
         return response
+    
+@router.post("/models/{model_name}:embedContent")
+@router_v1beta.post("/models/{model_name}:embedContent")
+@RetryHandler(key_arg="api_key")
+async def embed_content(
+    model_name: str,
+    request: GeminiEmbedRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    embedding_service: GeminiEmbeddingService = Depends(get_embedding_service)
+):
+    """处理 Gemini 单一嵌入请求"""
+    operation_name = "gemini_embed_content"
+    async with handle_route_errors(logger, operation_name, failure_message="Embedding content generation failed"):
+        logger.info(f"Handling Gemini embedding request for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        response = await embedding_service.embed_content(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return response
+
+
+@router.post("/models/{model_name}:batchEmbedContents")
+@router_v1beta.post("/models/{model_name}:batchEmbedContents")
+@RetryHandler(key_arg="api_key")
+async def batch_embed_contents(
+    model_name: str,
+    request: GeminiBatchEmbedRequest,
+    _=Depends(security_service.verify_key_or_goog_api_key),
+    api_key: str = Depends(get_next_working_key),
+    key_manager: KeyManager = Depends(get_key_manager),
+    embedding_service: GeminiEmbeddingService = Depends(get_embedding_service)
+):
+    """处理 Gemini 批量嵌入请求"""
+    operation_name = "gemini_batch_embed_contents"
+    async with handle_route_errors(logger, operation_name, failure_message="Batch embedding content generation failed"):
+        logger.info(f"Handling Gemini batch embedding request for model: {model_name}")
+        logger.debug(f"Request: \n{request.model_dump_json(indent=2)}")
+        logger.info(f"Using API key: {redact_key_for_logging(api_key)}")
+
+        if not await model_service.check_model_support(model_name):
+            raise HTTPException(status_code=400, detail=f"Model {model_name} is not supported")
+
+        response = await embedding_service.batch_embed_contents(
+            model=model_name,
+            request=request,
+            api_key=api_key
+        )
+        return response
 
 
 @router.post("/reset-all-fail-counts")

app/router/routes.py

@@ -6,10 +6,22 @@ from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, RedirectResponse
 from fastapi.templating import Jinja2Templates
 
-from app.core.security import verify_auth_token
 from app.config.config import settings
+from app.core.security import verify_auth_token
 from app.log.logger import get_routes_logger
-from app.router import error_log_routes, gemini_routes, openai_routes, config_routes, scheduler_routes, stats_routes, version_routes, openai_compatiable_routes, vertex_express_routes, files_routes, key_routes
+from app.router import (
+    config_routes,
+    error_log_routes,
+    files_routes,
+    gemini_routes,
+    key_routes,
+    openai_compatiable_routes,
+    openai_routes,
+    scheduler_routes,
+    stats_routes,
+    version_routes,
+    vertex_express_routes,
+)
 from app.service.key.key_manager import get_key_manager_instance
 from app.service.stats.stats_service import StatsService
 
@@ -69,9 +81,12 @@ def setup_page_routes(app: FastAPI) -> None:
 
             if verify_auth_token(auth_token):
                 logger.info("Successful authentication")
-                response = RedirectResponse(url="/config", status_code=302)
+                response = RedirectResponse(url="/keys", status_code=302)
                 response.set_cookie(
-                    key="auth_token", value=auth_token, httponly=True, max_age=settings.ADMIN_SESSION_EXPIRE
+                    key="auth_token",
+                    value=auth_token,
+                    httponly=True,
+                    max_age=settings.ADMIN_SESSION_EXPIRE,
                 )
                 return response
             logger.warning("Failed authentication attempt with invalid token")
@@ -91,7 +106,9 @@ def setup_page_routes(app: FastAPI) -> None:
 
             key_manager = await get_key_manager_instance()
             keys_status = await key_manager.get_keys_by_status()
-            total_keys = len(keys_status["valid_keys"]) + len(keys_status["invalid_keys"])
+            total_keys = len(keys_status["valid_keys"]) + len(
+                keys_status["invalid_keys"]
+            )
             valid_key_count = len(keys_status["valid_keys"])
             invalid_key_count = len(keys_status["invalid_keys"])
 
@@ -133,7 +150,7 @@ def setup_page_routes(app: FastAPI) -> None:
                     },
                 },
             )
-            
+
     @app.get("/config", response_class=HTMLResponse)
     async def config_page(request: Request):
         """配置编辑页面"""
@@ -142,13 +159,15 @@ def setup_page_routes(app: FastAPI) -> None:
             if not auth_token or not verify_auth_token(auth_token):
                 logger.warning("Unauthorized access attempt to config page")
                 return RedirectResponse(url="/", status_code=302)
-                
+
             logger.info("Config page accessed successfully")
-            return templates.TemplateResponse("config_editor.html", {"request": request})
+            return templates.TemplateResponse(
+                "config_editor.html", {"request": request}
+            )
         except Exception as e:
             logger.error(f"Error accessing config page: {str(e)}")
             raise
-            
+
     @app.get("/logs", response_class=HTMLResponse)
     async def logs_page(request: Request):
         """错误日志页面"""
@@ -157,7 +176,7 @@ def setup_page_routes(app: FastAPI) -> None:
             if not auth_token or not verify_auth_token(auth_token):
                 logger.warning("Unauthorized access attempt to logs page")
                 return RedirectResponse(url="/", status_code=302)
-                
+
             logger.info("Logs page accessed successfully")
             return templates.TemplateResponse("error_logs.html", {"request": request})
         except Exception as e:
@@ -187,6 +206,7 @@ def setup_api_stats_routes(app: FastAPI) -> None:
     Args:
         app: FastAPI应用程序实例
     """
+
     @app.get("/api/stats/details")
     async def api_stats_details(request: Request, period: str):
         """获取指定时间段内的 API 调用详情"""
@@ -201,8 +221,67 @@ def setup_api_stats_routes(app: FastAPI) -> None:
             details = await stats_service.get_api_call_details(period)
             return details
         except ValueError as e:
-            logger.warning(f"Invalid period requested for API stats details: {period} - {str(e)}")
+            logger.warning(
+                f"Invalid period requested for API stats details: {period} - {str(e)}"
+            )
             return {"error": str(e)}, 400
         except Exception as e:
-            logger.error(f"Error fetching API stats details for period {period}: {str(e)}")
+            logger.error(
+                f"Error fetching API stats details for period {period}: {str(e)}"
+            )
+            return {"error": "Internal server error"}, 500
+
+    @app.get("/api/stats/attention-keys")
+    async def api_stats_attention_keys(
+        request: Request, limit: int = 20, status_code: int = 429
+    ):
+        """返回最近24小时指定错误码次数最多的Key（仅包含内存Key列表中的）。默认错误码429。"""
+        try:
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning("Unauthorized access attempt to attention-keys")
+                return {"error": "Unauthorized"}, 401
+
+            # 支持所有标准HTTP状态码范围
+            # if not isinstance(status_code, int) or status_code < 100 or status_code > 599:
+            #     return {"error": f"Unsupported status_code: {status_code}"}, 400
+
+            key_manager = await get_key_manager_instance()
+            keys_status = await key_manager.get_keys_by_status()
+            in_memory_keys = set(keys_status.get("valid_keys", [])) | set(
+                keys_status.get("invalid_keys", [])
+            )
+            stats_service = StatsService()
+            data = await stats_service.get_attention_keys_last_24h(
+                in_memory_keys, limit, status_code
+            )
+            return data
+        except Exception as e:
+            logger.error(f"Error fetching attention keys: {e}")
+            return {"error": "Internal server error"}, 500
+
+    @app.get("/api/stats/key-details")
+    async def api_stats_key_details(request: Request, key: str, period: str):
+        """获取指定密钥在指定时间段内的调用详情"""
+        try:
+            auth_token = request.cookies.get("auth_token")
+            if not auth_token or not verify_auth_token(auth_token):
+                logger.warning("Unauthorized access attempt to API key stats details")
+                return {"error": "Unauthorized"}, 401
+
+            logger.info(
+                f"Fetching key call details for key=...{key[-4:] if key else ''}, period: {period}"
+            )
+            stats_service = StatsService()
+            details = await stats_service.get_key_call_details(key, period)
+            return details
+        except ValueError as e:
+            logger.warning(
+                f"Invalid period requested for key stats details: {period} - {str(e)}"
+            )
+            return {"error": str(e)}, 400
+        except Exception as e:
+            logger.error(
+                f"Error fetching key stats details for period {period}: {str(e)}"
+            )
             return {"error": "Internal server error"}, 500

app/service/chat/gemini_chat_service.py

@@ -1,19 +1,20 @@
 # app/services/chat_service.py
 
+import datetime
 import json
 import re
-import datetime
 import time
 from typing import Any, AsyncGenerator, Dict, List
+
 from app.config.config import settings
 from app.core.constants import GEMINI_2_FLASH_EXP_SAFETY_SETTINGS
+from app.database.services import add_error_log, add_request_log, get_file_api_key
 from app.domain.gemini_models import GeminiRequest
 from app.handler.response_handler import GeminiResponseHandler
 from app.handler.stream_optimizer import gemini_optimizer
 from app.log.logger import get_gemini_logger
 from app.service.client.api_client import GeminiApiClient
 from app.service.key.key_manager import KeyManager
-from app.database.services import add_error_log, add_request_log, get_file_api_key
 from app.utils.helpers import redact_key_for_logging
 
 logger = get_gemini_logger()
@@ -28,6 +29,7 @@ def _has_image_parts(contents: List[Dict[str, Any]]) -> bool:
                     return True
     return False
 
+
 def _extract_file_references(contents: List[Dict[str, Any]]) -> List[str]:
     """從內容中提取文件引用"""
     file_names = []
@@ -42,7 +44,9 @@ def _extract_file_references(contents: List[Dict[str, Any]]) -> List[str]:
                 file_uri = file_data["fileUri"]
                 # 從 URI 中提取文件名
                 # 1. https://generativelanguage.googleapis.com/v1beta/files/{file_id}
-                match = re.match(rf"{re.escape(settings.BASE_URL)}/(files/.*)", file_uri)
+                match = re.match(
+                    rf"{re.escape(settings.BASE_URL)}/(files/.*)", file_uri
+                )
                 if not match:
                     logger.warning(f"Invalid file URI: {file_uri}")
                     continue
@@ -51,19 +55,36 @@ def _extract_file_references(contents: List[Dict[str, Any]]) -> List[str]:
                 logger.info(f"Found file reference: {file_id}")
     return file_names
 
+
 def _clean_json_schema_properties(obj: Any) -> Any:
     """清理JSON Schema中Gemini API不支持的字段"""
     if not isinstance(obj, dict):
         return obj
-    
+
     # Gemini API不支持的JSON Schema字段
     unsupported_fields = {
-        "exclusiveMaximum", "exclusiveMinimum", "const", "examples", 
-        "contentEncoding", "contentMediaType", "if", "then", "else",
-        "allOf", "anyOf", "oneOf", "not", "definitions", "$schema",
-        "$id", "$ref", "$comment", "readOnly", "writeOnly"
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "const",
+        "examples",
+        "contentEncoding",
+        "contentMediaType",
+        "if",
+        "then",
+        "else",
+        "allOf",
+        "anyOf",
+        "oneOf",
+        "not",
+        "definitions",
+        "$schema",
+        "$id",
+        "$ref",
+        "$comment",
+        "readOnly",
+        "writeOnly",
     }
-    
+
     cleaned = {}
     for key, value in obj.items():
         if key in unsupported_fields:
@@ -74,13 +95,13 @@ def _clean_json_schema_properties(obj: Any) -> Any:
             cleaned[key] = [_clean_json_schema_properties(item) for item in value]
         else:
             cleaned[key] = value
-    
+
     return cleaned
 
 
 def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
     """构建工具"""
-    
+
     def _has_function_call(contents: List[Dict[str, Any]]) -> bool:
         """检查内容中是否包含 functionCall"""
         if not contents or not isinstance(contents, list):
@@ -95,7 +116,7 @@ def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
                 if isinstance(part, dict) and "functionCall" in part:
                     return True
         return False
-    
+
     def _merge_tools(tools: List[Dict[str, Any]]) -> Dict[str, Any]:
         record = dict()
         for item in tools:
@@ -119,6 +140,14 @@ def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
                     record[k] = v
         return record
 
+    def _is_structured_output_request(payload: Dict[str, Any]) -> bool:
+        """检查请求是否要求结构化JSON输出"""
+        try:
+            generation_config = payload.get("generationConfig", {})
+            return generation_config.get("responseMimeType") == "application/json"
+        except (AttributeError, TypeError):
+            return False
+
     tool = dict()
     if payload and isinstance(payload, dict) and "tools" in payload:
         if payload.get("tools") and isinstance(payload.get("tools"), dict):
@@ -127,21 +156,29 @@ def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
         if items and isinstance(items, list):
             tool.update(_merge_tools(items))
 
-    if (
-        settings.TOOLS_CODE_EXECUTION_ENABLED
-        and not (model.endswith("-search") or "-thinking" in model)
-        and not _has_image_parts(payload.get("contents", []))
-    ):
-        tool["codeExecution"] = {}
-    if model.endswith("-search"):
-        tool["googleSearch"] = {}
-    
-    real_model = _get_real_model(model)
-    if real_model in settings.URL_CONTEXT_MODELS and settings.URL_CONTEXT_ENABLED:
-        tool["urlContext"] = {}
-        
+    # "Tool use with a response mime type: 'application/json' is unsupported"
+    # Gemini API限制：不支持同时使用tools和结构化输出(response_mime_type='application/json')
+    # 当请求指定了JSON响应格式时，跳过所有工具的添加以避免API错误
+    has_structured_output = _is_structured_output_request(payload)
+    if not has_structured_output:
+        if (
+            settings.TOOLS_CODE_EXECUTION_ENABLED
+            and not (model.endswith("-search") or "-thinking" in model)
+            and not _has_image_parts(payload.get("contents", []))
+        ):
+            tool["codeExecution"] = {}
+
+        if model.endswith("-search"):
+            tool["googleSearch"] = {}
+
+        real_model = _get_real_model(model)
+        if real_model in settings.URL_CONTEXT_MODELS and settings.URL_CONTEXT_ENABLED:
+            tool["urlContext"] = {}
+
     # 解决 "Tool use with function calling is unsupported" 问题
-    if tool.get("functionDeclarations") or _has_function_call(payload.get("contents", [])):
+    if tool.get("functionDeclarations") or _has_function_call(
+        payload.get("contents", [])
+    ):
         tool.pop("googleSearch", None)
         tool.pop("codeExecution", None)
         tool.pop("urlContext", None)
@@ -175,10 +212,16 @@ def _filter_empty_parts(contents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
 
     filtered_contents = []
     for content in contents:
-        if not content or "parts" not in content or not isinstance(content.get("parts"), list):
+        if (
+            not content
+            or "parts" not in content
+            or not isinstance(content.get("parts"), list)
+        ):
             continue
 
-        valid_parts = [part for part in content["parts"] if isinstance(part, dict) and part]
+        valid_parts = [
+            part for part in content["parts"] if isinstance(part, dict) and part
+        ]
 
         if valid_parts:
             new_content = content.copy()
@@ -227,30 +270,32 @@ def _build_payload(model: str, request: GeminiRequest) -> Dict[str, Any]:
     if model.endswith("-image") or model.endswith("-image-generation"):
         payload.pop("systemInstruction")
         payload["generationConfig"]["responseModalities"] = ["Text", "Image"]
-    
+
     # 处理思考配置：优先使用客户端提供的配置，否则使用默认配置
     client_thinking_config = None
     if request.generationConfig and request.generationConfig.thinkingConfig:
         client_thinking_config = request.generationConfig.thinkingConfig
-    
+
     if client_thinking_config is not None:
         # 客户端提供了思考配置，直接使用
         payload["generationConfig"]["thinkingConfig"] = client_thinking_config
     else:
-        # 客户端没有提供思考配置，使用默认配置    
+        # 客户端没有提供思考配置，使用默认配置
         if model.endswith("-non-thinking"):
             if "gemini-2.5-pro" in model:
                 payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 128}
             else:
-                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0} 
+                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
         elif _get_real_model(model) in settings.THINKING_BUDGET_MAP:
             if settings.SHOW_THINKING_PROCESS:
                 payload["generationConfig"]["thinkingConfig"] = {
-                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model,1000),
-                    "includeThoughts": True
+                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model, 1000),
+                    "includeThoughts": True,
                 }
             else:
-                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": settings.THINKING_BUDGET_MAP.get(model,1000)}
+                payload["generationConfig"]["thinkingConfig"] = {
+                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model, 1000)
+                }
 
     return payload
 
@@ -297,11 +342,15 @@ class GeminiChatService:
             logger.info(f"Request contains file references: {file_names}")
             file_api_key = await get_file_api_key(file_names[0])
             if file_api_key:
-                logger.info(f"Found API key for file {file_names[0]}: {redact_key_for_logging(file_api_key)}")
+                logger.info(
+                    f"Found API key for file {file_names[0]}: {redact_key_for_logging(file_api_key)}"
+                )
                 api_key = file_api_key  # 使用文件的 API key
             else:
-                logger.warning(f"No API key found for file {file_names[0]}, using default key: {redact_key_for_logging(api_key)}")
-        
+                logger.warning(
+                    f"No API key found for file {file_names[0]}, using default key: {redact_key_for_logging(api_key)}"
+                )
+
         payload = _build_payload(model, request)
         start_time = time.perf_counter()
         request_datetime = datetime.datetime.now()
@@ -330,7 +379,8 @@ class GeminiChatService:
                 error_type="gemini-chat-non-stream",
                 error_log=error_log_msg,
                 error_code=status_code,
-                request_msg=payload
+                request_msg=payload,
+                request_datetime=request_datetime,
             )
             raise e
         finally:
@@ -342,7 +392,7 @@ class GeminiChatService:
                 is_success=is_success,
                 status_code=status_code,
                 latency_ms=latency_ms,
-                request_time=request_datetime
+                request_time=request_datetime,
             )
 
     async def count_tokens(
@@ -350,7 +400,9 @@ class GeminiChatService:
     ) -> Dict[str, Any]:
         """计算token数量"""
         # countTokens API只需要contents
-        payload = {"contents": _filter_empty_parts(request.model_dump().get("contents", []))}
+        payload = {
+            "contents": _filter_empty_parts(request.model_dump().get("contents", []))
+        }
         start_time = time.perf_counter()
         request_datetime = datetime.datetime.now()
         is_success = False
@@ -378,7 +430,7 @@ class GeminiChatService:
                 error_type="gemini-count-tokens",
                 error_log=error_log_msg,
                 error_code=status_code,
-                request_msg=payload
+                request_msg=payload,
             )
             raise e
         finally:
@@ -390,7 +442,7 @@ class GeminiChatService:
                 is_success=is_success,
                 status_code=status_code,
                 latency_ms=latency_ms,
-                request_time=request_datetime
+                request_time=request_datetime,
             )
 
     async def stream_generate_content(
@@ -403,11 +455,15 @@ class GeminiChatService:
             logger.info(f"Request contains file references: {file_names}")
             file_api_key = await get_file_api_key(file_names[0])
             if file_api_key:
-                logger.info(f"Found API key for file {file_names[0]}: {redact_key_for_logging(file_api_key)}")
+                logger.info(
+                    f"Found API key for file {file_names[0]}: {redact_key_for_logging(file_api_key)}"
+                )
                 api_key = file_api_key  # 使用文件的 API key
             else:
-                logger.warning(f"No API key found for file {file_names[0]}, using default key: {redact_key_for_logging(api_key)}")
-                
+                logger.warning(
+                    f"No API key found for file {file_names[0]}, using default key: {redact_key_for_logging(api_key)}"
+                )
+
         retries = 0
         max_retries = settings.MAX_RETRIES
         payload = _build_payload(model, request)
@@ -468,20 +524,23 @@ class GeminiChatService:
                     error_type="gemini-chat-stream",
                     error_log=error_log_msg,
                     error_code=status_code,
-                    request_msg=payload
+                    request_msg=payload,
+                    request_datetime=request_datetime,
                 )
 
-                api_key = await self.key_manager.handle_api_failure(current_attempt_key, retries)
+                api_key = await self.key_manager.handle_api_failure(
+                    current_attempt_key, retries
+                )
                 if api_key:
-                    logger.info(f"Switched to new API key: {redact_key_for_logging(api_key)}")
+                    logger.info(
+                        f"Switched to new API key: {redact_key_for_logging(api_key)}"
+                    )
                 else:
                     logger.error(f"No valid API key available after {retries} retries.")
                     break
 
                 if retries >= max_retries:
-                    logger.error(
-                        f"Max retries ({max_retries}) reached for streaming."
-                    )
+                    logger.error(f"Max retries ({max_retries}) reached for streaming.")
                     break
             finally:
                 end_time = time.perf_counter()
@@ -492,5 +551,5 @@ class GeminiChatService:
                     is_success=is_success,
                     status_code=status_code,
                     latency_ms=latency_ms,
-                    request_time=request_datetime
+                    request_time=request_datetime,
                 )

app/service/chat/openai_chat_service.py

@@ -40,15 +40,31 @@ def _clean_json_schema_properties(obj: Any) -> Any:
     """清理JSON Schema中Gemini API不支持的字段"""
     if not isinstance(obj, dict):
         return obj
-    
+
     # Gemini API不支持的JSON Schema字段
     unsupported_fields = {
-        "exclusiveMaximum", "exclusiveMinimum", "const", "examples", 
-        "contentEncoding", "contentMediaType", "if", "then", "else",
-        "allOf", "anyOf", "oneOf", "not", "definitions", "$schema",
-        "$id", "$ref", "$comment", "readOnly", "writeOnly"
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "const",
+        "examples",
+        "contentEncoding",
+        "contentMediaType",
+        "if",
+        "then",
+        "else",
+        "allOf",
+        "anyOf",
+        "oneOf",
+        "not",
+        "definitions",
+        "$schema",
+        "$id",
+        "$ref",
+        "$comment",
+        "readOnly",
+        "writeOnly",
     }
-    
+
     cleaned = {}
     for key, value in obj.items():
         if key in unsupported_fields:
@@ -59,7 +75,7 @@ def _clean_json_schema_properties(obj: Any) -> Any:
             cleaned[key] = [_clean_json_schema_properties(item) for item in value]
         else:
             cleaned[key] = value
-    
+
     return cleaned
 
 
@@ -87,7 +103,7 @@ def _build_tools(
 
     if model.endswith("-search"):
         tool["googleSearch"] = {}
-        
+
     real_model = _get_real_model(model)
     if real_model in settings.URL_CONTEXT_MODELS and settings.URL_CONTEXT_ENABLED:
         tool["urlContext"] = {}
@@ -116,7 +132,7 @@ def _build_tools(
             names, functions = set(), []
             for fc in function_declarations:
                 if fc.get("name") not in names:
-                    if fc.get("name")=="googleSearch":
+                    if fc.get("name") == "googleSearch":
                         # cherry开启内置搜索时，添加googleSearch工具
                         tool["googleSearch"] = {}
                     else:
@@ -130,7 +146,7 @@ def _build_tools(
     if tool.get("functionDeclarations"):
         tool.pop("googleSearch", None)
         tool.pop("codeExecution", None)
-        tool.pop("urlContext",None)
+        tool.pop("urlContext", None)
 
     return [tool] if tool else []
 
@@ -160,17 +176,17 @@ def _get_safety_settings(model: str) -> List[Dict[str, str]]:
 
 
 def _validate_and_set_max_tokens(
-    payload: Dict[str, Any], 
-    max_tokens: Optional[int], 
-    logger_instance
+    payload: Dict[str, Any], max_tokens: Optional[int], logger_instance
 ) -> None:
     """验证并设置 max_tokens 参数"""
     if max_tokens is None:
         return
-    
+
     # 参数验证和处理
     if max_tokens <= 0:
-        logger_instance.warning(f"Invalid max_tokens value: {max_tokens}, will not set maxOutputTokens")
+        logger_instance.warning(
+            f"Invalid max_tokens value: {max_tokens}, will not set maxOutputTokens"
+        )
         # 不设置 maxOutputTokens，让 Gemini API 使用默认值
     else:
         payload["generationConfig"]["maxOutputTokens"] = max_tokens
@@ -193,27 +209,33 @@ def _build_payload(
         "tools": _build_tools(request, messages),
         "safetySettings": _get_safety_settings(request.model),
     }
-    
+
     # 处理 max_tokens 参数
     _validate_and_set_max_tokens(payload, request.max_tokens, logger)
-    
+
+    # 处理 n 参数
+    if request.n is not None and request.n > 0:
+        payload["generationConfig"]["candidateCount"] = request.n
+
     if request.model.endswith("-image") or request.model.endswith("-image-generation"):
         payload["generationConfig"]["responseModalities"] = ["Text", "Image"]
-    
+
     if request.model.endswith("-non-thinking"):
         if "gemini-2.5-pro" in request.model:
             payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 128}
         else:
-            payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0} 
-    
+            payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
+
     elif _get_real_model(request.model) in settings.THINKING_BUDGET_MAP:
         if settings.SHOW_THINKING_PROCESS:
             payload["generationConfig"]["thinkingConfig"] = {
                 "thinkingBudget": settings.THINKING_BUDGET_MAP.get(request.model, 1000),
-                "includeThoughts": True
+                "includeThoughts": True,
             }
         else:
-            payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": settings.THINKING_BUDGET_MAP.get(request.model, 1000)}
+            payload["generationConfig"]["thinkingConfig"] = {
+                "thinkingBudget": settings.THINKING_BUDGET_MAP.get(request.model, 1000)
+            }
 
     if (
         instruction
@@ -280,13 +302,13 @@ class OpenAIChatService:
         is_success = False
         status_code = None
         response = None
-        
+
         try:
             response = await self.api_client.generate_content(payload, model, api_key)
             usage_metadata = response.get("usageMetadata", {})
             is_success = True
             status_code = 200
-            
+
             # 尝试处理响应，捕获可能的响应处理异常
             try:
                 result = self.response_handler.handle_response(
@@ -298,8 +320,10 @@ class OpenAIChatService:
                 )
                 return result
             except Exception as response_error:
-                logger.error(f"Response processing failed for model {model}: {str(response_error)}")
-                
+                logger.error(
+                    f"Response processing failed for model {model}: {str(response_error)}"
+                )
+
                 # 记录详细的错误信息
                 if "parts" in str(response_error):
                     logger.error("Response structure issue - missing or invalid parts")
@@ -307,24 +331,26 @@ class OpenAIChatService:
                         candidate = response["candidates"][0]
                         content = candidate.get("content", {})
                         logger.error(f"Content structure: {content}")
-                
+
                 # 重新抛出异常
                 raise response_error
-                
+
         except Exception as e:
             is_success = False
             error_log_msg = str(e)
             logger.error(f"API call failed for model {model}: {error_log_msg}")
-            
+
             # 特别记录 max_tokens 相关的错误
-            gen_config = payload.get('generationConfig', {})
+            gen_config = payload.get("generationConfig", {})
             if "maxOutputTokens" in gen_config:
-                logger.error(f"Request had maxOutputTokens: {gen_config['maxOutputTokens']}")
-            
+                logger.error(
+                    f"Request had maxOutputTokens: {gen_config['maxOutputTokens']}"
+                )
+
             # 如果是响应处理错误，记录更多信息
             if "parts" in error_log_msg:
                 logger.error("This is likely a response processing error")
-            
+
             match = re.search(r"status code (\d+)", error_log_msg)
             status_code = int(match.group(1)) if match else 500
 
@@ -335,13 +361,16 @@ class OpenAIChatService:
                 error_log=error_log_msg,
                 error_code=status_code,
                 request_msg=payload,
+                request_datetime=request_datetime,
             )
             raise e
         finally:
             end_time = time.perf_counter()
             latency_ms = int((end_time - start_time) * 1000)
-            logger.info(f"Normal completion finished - Success: {is_success}, Latency: {latency_ms}ms")
-            
+            logger.info(
+                f"Normal completion finished - Success: {is_success}, Latency: {latency_ms}ms"
+            )
+
             await add_request_log(
                 model_name=model,
                 api_key=api_key,
@@ -358,49 +387,44 @@ class OpenAIChatService:
         logger.info(
             f"Fake streaming enabled for model: {model}. Calling non-streaming endpoint."
         )
-        keep_sending_empty_data = True
 
-        async def send_empty_data_locally() -> AsyncGenerator[str, None]:
-            """定期发送空数据以保持连接"""
-            while keep_sending_empty_data:
-                await asyncio.sleep(settings.FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS)
-                if keep_sending_empty_data:
-                    empty_chunk = self.response_handler.handle_response({}, model, stream=True, finish_reason='stop', usage_metadata=None)
-                    yield f"data: {json.dumps(empty_chunk)}\n\n"
-                    logger.debug("Sent empty data chunk for fake stream heartbeat.")
-
-        empty_data_generator = send_empty_data_locally()
         api_response_task = asyncio.create_task(
             self.api_client.generate_content(payload, model, api_key)
         )
 
+        i = 0
         try:
             while not api_response_task.done():
-                try:
-                    next_empty_chunk = await asyncio.wait_for(
-                        empty_data_generator.__anext__(), timeout=0.1
+                i = i + 1
+                """定期发送空数据以保持连接"""
+                if i >= settings.FAKE_STREAM_EMPTY_DATA_INTERVAL_SECONDS:
+                    i = 0
+                    empty_chunk = self.response_handler.handle_response(
+                        {},
+                        model,
+                        stream=True,
+                        finish_reason="stop",
+                        usage_metadata=None,
                     )
-                    yield next_empty_chunk
-                except asyncio.TimeoutError:
-                    pass
-                except (
-                    StopAsyncIteration
-                ):
-                    break
-
-            response = await api_response_task
+                    yield f"data: {json.dumps(empty_chunk)}\n\n"
+                    logger.debug("Sent empty data chunk for fake stream heartbeat.")
+                await asyncio.sleep(1)
         finally:
-            keep_sending_empty_data = False
+            response = await api_response_task
 
         if response and response.get("candidates"):
-            response = self.response_handler.handle_response(response, model, stream=True, finish_reason='stop', usage_metadata=response.get("usageMetadata", {}))
+            response = self.response_handler.handle_response(
+                response,
+                model,
+                stream=True,
+                finish_reason="stop",
+                usage_metadata=response.get("usageMetadata", {}),
+            )
             yield f"data: {json.dumps(response)}\n\n"
             logger.info(f"Sent full response content for fake stream: {model}")
         else:
             error_message = "Failed to get response from model"
-            if (
-                response and isinstance(response, dict) and response.get("error")
-            ):
+            if response and isinstance(response, dict) and response.get("error"):
                 error_details = response.get("error")
                 if isinstance(error_details, dict):
                     error_message = error_details.get("message", error_message)
@@ -408,7 +432,9 @@ class OpenAIChatService:
             logger.error(
                 f"No candidates or error in response for fake stream model {model}: {response}"
             )
-            error_chunk = self.response_handler.handle_response({}, model, stream=True, finish_reason='stop', usage_metadata=None)
+            error_chunk = self.response_handler.handle_response(
+                {}, model, stream=True, finish_reason="stop", usage_metadata=None
+            )
             yield f"data: {json.dumps(error_chunk)}\n\n"
 
     async def _real_stream_logic_impl(
@@ -436,7 +462,11 @@ class OpenAIChatService:
                     )
                     continue
                 openai_chunk = self.response_handler.handle_response(
-                    chunk, model, stream=True, finish_reason=None, usage_metadata=usage_metadata
+                    chunk,
+                    model,
+                    stream=True,
+                    finish_reason=None,
+                    usage_metadata=usage_metadata,
                 )
                 if openai_chunk:
                     text = self._extract_text_from_openai_chunk(openai_chunk)
@@ -450,7 +480,9 @@ class OpenAIChatService:
                         ):
                             yield optimized_chunk_data
                     else:
-                        if openai_chunk.get("choices") and openai_chunk["choices"][0].get("delta", {}).get("tool_calls"):
+                        if openai_chunk.get("choices") and openai_chunk["choices"][
+                            0
+                        ].get("delta", {}).get("tool_calls"):
                             tool_call_flag = True
 
                         yield f"data: {json.dumps(openai_chunk)}\n\n"
@@ -527,6 +559,7 @@ class OpenAIChatService:
                     error_log=error_log_msg,
                     error_code=status_code,
                     request_msg=payload,
+                    request_datetime=request_datetime,
                 )
 
                 if self.key_manager:
@@ -640,6 +673,7 @@ class OpenAIChatService:
                 error_log=error_log_msg,
                 error_code=status_code,
                 request_msg={"image_data_truncated": image_data[:1000]},
+                request_datetime=request_datetime,
             )
             yield f"data: {json.dumps({'error': error_log_msg})}\n\n"
             yield "data: [DONE]\n\n"
@@ -690,6 +724,7 @@ class OpenAIChatService:
                 error_log=error_log_msg,
                 error_code=status_code,
                 request_msg={"image_data_truncated": image_data[:1000]},
+                request_datetime=request_datetime,
             )
             raise e
         finally:

app/service/chat/vertex_express_chat_service.py

@@ -1,19 +1,20 @@
 # app/services/chat_service.py
 
+import datetime
 import json
 import re
-import datetime
 import time
 from typing import Any, AsyncGenerator, Dict, List
+
 from app.config.config import settings
 from app.core.constants import GEMINI_2_FLASH_EXP_SAFETY_SETTINGS
+from app.database.services import add_error_log, add_request_log
 from app.domain.gemini_models import GeminiRequest
 from app.handler.response_handler import GeminiResponseHandler
 from app.handler.stream_optimizer import gemini_optimizer
 from app.log.logger import get_gemini_logger
 from app.service.client.api_client import GeminiApiClient
 from app.service.key.key_manager import KeyManager
-from app.database.services import add_error_log, add_request_log
 from app.utils.helpers import redact_key_for_logging
 
 logger = get_gemini_logger()
@@ -33,15 +34,31 @@ def _clean_json_schema_properties(obj: Any) -> Any:
     """清理JSON Schema中Gemini API不支持的字段"""
     if not isinstance(obj, dict):
         return obj
-    
+
     # Gemini API不支持的JSON Schema字段
     unsupported_fields = {
-        "exclusiveMaximum", "exclusiveMinimum", "const", "examples", 
-        "contentEncoding", "contentMediaType", "if", "then", "else",
-        "allOf", "anyOf", "oneOf", "not", "definitions", "$schema",
-        "$id", "$ref", "$comment", "readOnly", "writeOnly"
+        "exclusiveMaximum",
+        "exclusiveMinimum",
+        "const",
+        "examples",
+        "contentEncoding",
+        "contentMediaType",
+        "if",
+        "then",
+        "else",
+        "allOf",
+        "anyOf",
+        "oneOf",
+        "not",
+        "definitions",
+        "$schema",
+        "$id",
+        "$ref",
+        "$comment",
+        "readOnly",
+        "writeOnly",
     }
-    
+
     cleaned = {}
     for key, value in obj.items():
         if key in unsupported_fields:
@@ -52,13 +69,13 @@ def _clean_json_schema_properties(obj: Any) -> Any:
             cleaned[key] = [_clean_json_schema_properties(item) for item in value]
         else:
             cleaned[key] = value
-    
+
     return cleaned
 
 
 def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
     """构建工具"""
-    
+
     def _has_function_call(contents: List[Dict[str, Any]]) -> bool:
         """检查内容中是否包含 functionCall"""
         if not contents or not isinstance(contents, list):
@@ -73,7 +90,7 @@ def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
                 if isinstance(part, dict) and "functionCall" in part:
                     return True
         return False
-    
+
     def _merge_tools(tools: List[Dict[str, Any]]) -> Dict[str, Any]:
         record = dict()
         for item in tools:
@@ -97,6 +114,14 @@ def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
                     record[k] = v
         return record
 
+    def _is_structured_output_request(payload: Dict[str, Any]) -> bool:
+        """检查请求是否要求结构化JSON输出"""
+        try:
+            generation_config = payload.get("generationConfig", {})
+            return generation_config.get("responseMimeType") == "application/json"
+        except (AttributeError, TypeError):
+            return False
+
     tool = dict()
     if payload and isinstance(payload, dict) and "tools" in payload:
         if payload.get("tools") and isinstance(payload.get("tools"), dict):
@@ -105,21 +130,29 @@ def _build_tools(model: str, payload: Dict[str, Any]) -> List[Dict[str, Any]]:
         if items and isinstance(items, list):
             tool.update(_merge_tools(items))
 
-    if (
-        settings.TOOLS_CODE_EXECUTION_ENABLED
-        and not (model.endswith("-search") or "-thinking" in model)
-        and not _has_image_parts(payload.get("contents", []))
-    ):
-        tool["codeExecution"] = {}
-    if model.endswith("-search"):
-        tool["googleSearch"] = {}
-        
-    real_model = _get_real_model(model)
-    if real_model in settings.URL_CONTEXT_MODELS and settings.URL_CONTEXT_ENABLED:
-        tool["urlContext"] = {}
+    # "Tool use with a response mime type: 'application/json' is unsupported"
+    # Gemini API限制：不支持同时使用tools和结构化输出(response_mime_type='application/json')
+    # 当请求指定了JSON响应格式时，跳过所有工具的添加以避免API错误
+    has_structured_output = _is_structured_output_request(payload)
+    if not has_structured_output:
+        if (
+            settings.TOOLS_CODE_EXECUTION_ENABLED
+            and not (model.endswith("-search") or "-thinking" in model)
+            and not _has_image_parts(payload.get("contents", []))
+        ):
+            tool["codeExecution"] = {}
+
+        if model.endswith("-search"):
+            tool["googleSearch"] = {}
+
+        real_model = _get_real_model(model)
+        if real_model in settings.URL_CONTEXT_MODELS and settings.URL_CONTEXT_ENABLED:
+            tool["urlContext"] = {}
 
     # 解决 "Tool use with function calling is unsupported" 问题
-    if tool.get("functionDeclarations") or _has_function_call(payload.get("contents", [])):
+    if tool.get("functionDeclarations") or _has_function_call(
+        payload.get("contents", [])
+    ):
         tool.pop("googleSearch", None)
         tool.pop("codeExecution", None)
         tool.pop("urlContext", None)
@@ -153,7 +186,7 @@ def _build_payload(model: str, request: GeminiRequest) -> Dict[str, Any]:
         if request.generationConfig.maxOutputTokens is None:
             # 如果未指定最大输出长度，则不传递该字段，解决截断的问题
             request_dict["generationConfig"].pop("maxOutputTokens")
-    
+
     payload = {
         "contents": request_dict.get("contents", []),
         "tools": _build_tools(model, request_dict),
@@ -165,30 +198,32 @@ def _build_payload(model: str, request: GeminiRequest) -> Dict[str, Any]:
     if model.endswith("-image") or model.endswith("-image-generation"):
         payload.pop("systemInstruction")
         payload["generationConfig"]["responseModalities"] = ["Text", "Image"]
-        
+
     # 处理思考配置：优先使用客户端提供的配置，否则使用默认配置
     client_thinking_config = None
     if request.generationConfig and request.generationConfig.thinkingConfig:
         client_thinking_config = request.generationConfig.thinkingConfig
-    
+
     if client_thinking_config is not None:
         # 客户端提供了思考配置，直接使用
         payload["generationConfig"]["thinkingConfig"] = client_thinking_config
     else:
-        # 客户端没有提供思考配置，使用默认配置    
+        # 客户端没有提供思考配置，使用默认配置
         if model.endswith("-non-thinking"):
             if "gemini-2.5-pro" in model:
                 payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 128}
             else:
-                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0} 
+                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": 0}
         elif _get_real_model(model) in settings.THINKING_BUDGET_MAP:
             if settings.SHOW_THINKING_PROCESS:
                 payload["generationConfig"]["thinkingConfig"] = {
-                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model,1000),
-                    "includeThoughts": True
+                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model, 1000),
+                    "includeThoughts": True,
                 }
             else:
-                payload["generationConfig"]["thinkingConfig"] = {"thinkingBudget": settings.THINKING_BUDGET_MAP.get(model,1000)}
+                payload["generationConfig"]["thinkingConfig"] = {
+                    "thinkingBudget": settings.THINKING_BUDGET_MAP.get(model, 1000)
+                }
 
     return payload
 
@@ -257,7 +292,8 @@ class GeminiChatService:
                 error_type="gemini-chat-non-stream",
                 error_log=error_log_msg,
                 error_code=status_code,
-                request_msg=payload
+                request_msg=payload,
+                request_datetime=request_datetime,
             )
             raise e
         finally:
@@ -269,7 +305,7 @@ class GeminiChatService:
                 is_success=is_success,
                 status_code=status_code,
                 latency_ms=latency_ms,
-                request_time=request_datetime
+                request_time=request_datetime,
             )
 
     async def stream_generate_content(
@@ -287,7 +323,7 @@ class GeminiChatService:
             request_datetime = datetime.datetime.now()
             start_time = time.perf_counter()
             current_attempt_key = api_key
-            final_api_key = current_attempt_key # Update final key used
+            final_api_key = current_attempt_key  # Update final key used
             try:
                 async for line in self.api_client.stream_generate_content(
                     payload, model, current_attempt_key
@@ -336,20 +372,23 @@ class GeminiChatService:
                     error_type="gemini-chat-stream",
                     error_log=error_log_msg,
                     error_code=status_code,
-                    request_msg=payload
+                    request_msg=payload,
+                    request_datetime=request_datetime,
                 )
 
-                api_key = await self.key_manager.handle_api_failure(current_attempt_key, retries)
+                api_key = await self.key_manager.handle_api_failure(
+                    current_attempt_key, retries
+                )
                 if api_key:
-                    logger.info(f"Switched to new API key: {redact_key_for_logging(api_key)}")
+                    logger.info(
+                        f"Switched to new API key: {redact_key_for_logging(api_key)}"
+                    )
                 else:
                     logger.error(f"No valid API key available after {retries} retries.")
                     break
 
                 if retries >= max_retries:
-                    logger.error(
-                        f"Max retries ({max_retries}) reached for streaming."
-                    )
+                    logger.error(f"Max retries ({max_retries}) reached for streaming.")
                     break
             finally:
                 end_time = time.perf_counter()
@@ -360,5 +399,5 @@ class GeminiChatService:
                     is_success=is_success,
                     status_code=status_code,
                     latency_ms=latency_ms,
-                    request_time=request_datetime
+                    request_time=request_datetime,
                 )

app/service/client/api_client.py

@@ -161,6 +161,80 @@ class GeminiApiClient(ApiClient):
                 raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
             return response.json()
 
+    async def embed_content(self, payload: Dict[str, Any], model: str, api_key: str) -> Dict[str, Any]:
+        """单一嵌入内容生成"""
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        model = self._get_real_model(model)
+        
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for embedding: {proxy_to_use}")
+
+        headers = self._prepare_headers()
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/models/{model}:embedContent?key={api_key}"
+            
+            try:
+                response = await client.post(url, json=payload, headers=headers)
+                
+                if response.status_code != 200:
+                    error_content = response.text
+                    logger.error(f"Embedding API call failed - Status: {response.status_code}, Content: {error_content}")
+                    raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+                
+                return response.json()
+                
+            except httpx.TimeoutException as e:
+                logger.error(f"Embedding request timeout: {e}")
+                raise Exception(f"Request timeout: {e}")
+            except httpx.RequestError as e:
+                logger.error(f"Embedding request error: {e}")
+                raise Exception(f"Request error: {e}")
+            except Exception as e:
+                logger.error(f"Unexpected embedding error: {e}")
+                raise
+
+    async def batch_embed_contents(self, payload: Dict[str, Any], model: str, api_key: str) -> Dict[str, Any]:
+        """批量嵌入内容生成"""
+        timeout = httpx.Timeout(self.timeout, read=self.timeout)
+        model = self._get_real_model(model)
+        
+        proxy_to_use = None
+        if settings.PROXIES:
+            if settings.PROXIES_USE_CONSISTENCY_HASH_BY_API_KEY:
+                proxy_to_use = settings.PROXIES[hash(api_key) % len(settings.PROXIES)]
+            else:
+                proxy_to_use = random.choice(settings.PROXIES)
+            logger.info(f"Using proxy for batch embedding: {proxy_to_use}")
+
+        headers = self._prepare_headers()
+        async with httpx.AsyncClient(timeout=timeout, proxy=proxy_to_use) as client:
+            url = f"{self.base_url}/models/{model}:batchEmbedContents?key={api_key}"
+            
+            try:
+                response = await client.post(url, json=payload, headers=headers)
+                
+                if response.status_code != 200:
+                    error_content = response.text
+                    logger.error(f"Batch embedding API call failed - Status: {response.status_code}, Content: {error_content}")
+                    raise Exception(f"API call failed with status code {response.status_code}, {error_content}")
+                
+                return response.json()
+                
+            except httpx.TimeoutException as e:
+                logger.error(f"Batch embedding request timeout: {e}")
+                raise Exception(f"Request timeout: {e}")
+            except httpx.RequestError as e:
+                logger.error(f"Batch embedding request error: {e}")
+                raise Exception(f"Request error: {e}")
+            except Exception as e:
+                logger.error(f"Unexpected batch embedding error: {e}")
+                raise
+
 
 class OpenaiApiClient(ApiClient):
     """OpenAI API客户端"""

app/service/embedding/embedding_service.py

@@ -1,6 +1,6 @@
 import datetime
-import time
 import re
+import time
 from typing import List, Union
 
 import openai
@@ -8,8 +8,8 @@ from openai import APIStatusError
 from openai.types import CreateEmbeddingResponse
 
 from app.config.config import settings
-from app.log.logger import get_embeddings_logger
 from app.database.services import add_error_log, add_request_log
+from app.log.logger import get_embeddings_logger
 
 logger = get_embeddings_logger()
 
@@ -27,12 +27,20 @@ class EmbeddingService:
         response = None
         error_log_msg = ""
         if isinstance(input_text, list):
-            request_msg_log = {"input_truncated": [str(item)[:100] + "..." if len(str(item)) > 100 else str(item) for item in input_text[:5]]}
+            request_msg_log = {
+                "input_truncated": [
+                    str(item)[:100] + "..." if len(str(item)) > 100 else str(item)
+                    for item in input_text[:5]
+                ]
+            }
             if len(input_text) > 5:
-                 request_msg_log["input_truncated"].append("...")
+                request_msg_log["input_truncated"].append("...")
         else:
-            request_msg_log = {"input_truncated": input_text[:1000] + "..." if len(input_text) > 1000 else input_text}
-
+            request_msg_log = {
+                "input_truncated": (
+                    input_text[:1000] + "..." if len(input_text) > 1000 else input_text
+                )
+            }
 
         try:
             client = openai.OpenAI(api_key=api_key, base_url=settings.BASE_URL)
@@ -66,13 +74,14 @@ class EmbeddingService:
                     error_type="openai-embedding",
                     error_log=error_log_msg,
                     error_code=status_code,
-                    request_msg=request_msg_log
-                 )
+                    request_msg=request_msg_log,
+                    request_datetime=request_datetime,
+                )
             await add_request_log(
                 model_name=model,
                 api_key=api_key,
                 is_success=is_success,
                 status_code=status_code,
                 latency_ms=latency_ms,
-                request_time=request_datetime
+                request_time=request_datetime,
             )

app/service/embedding/gemini_embedding_service.py

@@ -0,0 +1,150 @@
+# app/service/embedding/gemini_embedding_service.py
+
+import datetime
+import re
+import time
+from typing import Any, Dict
+
+from app.config.config import settings
+from app.database.services import add_error_log, add_request_log
+from app.domain.gemini_models import GeminiBatchEmbedRequest, GeminiEmbedRequest
+from app.log.logger import get_gemini_embedding_logger
+from app.service.client.api_client import GeminiApiClient
+from app.service.key.key_manager import KeyManager
+
+logger = get_gemini_embedding_logger()
+
+
+def _build_embed_payload(request: GeminiEmbedRequest) -> Dict[str, Any]:
+    """构建嵌入请求payload"""
+    payload = {"content": request.content.model_dump()}
+
+    if request.taskType:
+        payload["taskType"] = request.taskType
+    if request.title:
+        payload["title"] = request.title
+    if request.outputDimensionality:
+        payload["outputDimensionality"] = request.outputDimensionality
+
+    return payload
+
+
+def _build_batch_embed_payload(
+    request: GeminiBatchEmbedRequest, model: str
+) -> Dict[str, Any]:
+    """构建批量嵌入请求payload"""
+    requests = []
+    for embed_request in request.requests:
+        embed_payload = _build_embed_payload(embed_request)
+        embed_payload["model"] = (
+            f"models/{model}"  # Gemini API要求每个请求包含model字段
+        )
+        requests.append(embed_payload)
+
+    return {"requests": requests}
+
+
+class GeminiEmbeddingService:
+    """Gemini嵌入服务"""
+
+    def __init__(self, base_url: str, key_manager: KeyManager):
+        self.api_client = GeminiApiClient(base_url, settings.TIME_OUT)
+        self.key_manager = key_manager
+
+    async def embed_content(
+        self, model: str, request: GeminiEmbedRequest, api_key: str
+    ) -> Dict[str, Any]:
+        """生成单一嵌入内容"""
+        payload = _build_embed_payload(request)
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+
+        try:
+            response = await self.api_client.embed_content(payload, model, api_key)
+            is_success = True
+            status_code = 200
+            return response
+        except Exception as e:
+            is_success = False
+            error_log_msg = str(e)
+            logger.error(f"Single embedding API call failed: {error_log_msg}")
+            match = re.search(r"status code (\d+)", error_log_msg)
+            if match:
+                status_code = int(match.group(1))
+            else:
+                status_code = 500
+
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="gemini-embed-single",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg=payload,
+                request_datetime=request_datetime,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )
+
+    async def batch_embed_contents(
+        self, model: str, request: GeminiBatchEmbedRequest, api_key: str
+    ) -> Dict[str, Any]:
+        """生成批量嵌入内容"""
+        payload = _build_batch_embed_payload(request, model)
+        start_time = time.perf_counter()
+        request_datetime = datetime.datetime.now()
+        is_success = False
+        status_code = None
+        response = None
+
+        try:
+            response = await self.api_client.batch_embed_contents(
+                payload, model, api_key
+            )
+            is_success = True
+            status_code = 200
+            return response
+        except Exception as e:
+            is_success = False
+            error_log_msg = str(e)
+            logger.error(f"Batch embedding API call failed: {error_log_msg}")
+            match = re.search(r"status code (\d+)", error_log_msg)
+            if match:
+                status_code = int(match.group(1))
+            else:
+                status_code = 500
+
+            await add_error_log(
+                gemini_key=api_key,
+                model_name=model,
+                error_type="gemini-embed-batch",
+                error_log=error_log_msg,
+                error_code=status_code,
+                request_msg=payload,
+                request_datetime=request_datetime,
+            )
+            raise e
+        finally:
+            end_time = time.perf_counter()
+            latency_ms = int((end_time - start_time) * 1000)
+            await add_request_log(
+                model_name=model,
+                api_key=api_key,
+                is_success=is_success,
+                status_code=status_code,
+                latency_ms=latency_ms,
+                request_time=request_datetime,
+            )

app/service/error_log/error_log_service.py

@@ -121,6 +121,30 @@ async def process_get_error_log_details(log_id: int) -> Optional[Dict[str, Any]]
         raise
 
 
+async def process_find_error_log_by_info(
+    gemini_key: str,
+    timestamp: datetime,
+    status_code: Optional[int] = None,
+    window_seconds: int = 100,
+) -> Optional[Dict[str, Any]]:
+    """
+    根据 key/状态码/时间窗口 查询最匹配的一条错误日志，未找到则返回 None。
+    """
+    try:
+        return await db_services.find_error_log_by_info(
+            gemini_key=gemini_key,
+            timestamp=timestamp,
+            status_code=status_code,
+            window_seconds=window_seconds,
+        )
+    except Exception as e:
+        logger.error(
+            f"Service error in process_find_error_log_by_info: {e}",
+            exc_info=True,
+        )
+        raise
+
+
 async def process_delete_error_logs_by_ids(log_ids: List[int]) -> int:
     """
     按 ID 批量删除错误日志。

app/service/openai_compatiable/openai_compatiable_service.py

@@ -1,4 +1,3 @@
-
 import datetime
 import json
 import re
@@ -11,20 +10,21 @@ from app.database.services import (
     add_request_log,
 )
 from app.domain.openai_models import ChatRequest, ImageGenerationRequest
+from app.log.logger import get_openai_compatible_logger
 from app.service.client.api_client import OpenaiApiClient
 from app.service.key.key_manager import KeyManager
 from app.utils.helpers import redact_key_for_logging
-from app.log.logger import get_openai_compatible_logger
 
 logger = get_openai_compatible_logger()
 
+
 class OpenAICompatiableService:
 
     def __init__(self, base_url: str, key_manager: KeyManager = None):
         self.key_manager = key_manager
         self.base_url = base_url
         self.api_client = OpenaiApiClient(base_url, settings.TIME_OUT)
-        
+
     async def get_models(self, api_key: str) -> Dict[str, Any]:
         return await self.api_client.get_models(api_key)
 
@@ -37,10 +37,12 @@ class OpenAICompatiableService:
         request_dict = request.model_dump()
         # 移除值为null的
         request_dict = {k: v for k, v in request_dict.items() if v is not None}
-        del request_dict["top_k"] # 删除top_k参数，目前不支持该参数
+        del request_dict["top_k"]  # 删除top_k参数，目前不支持该参数
         if request.stream:
             return self._handle_stream_completion(request.model, request_dict, api_key)
-        return await self._handle_normal_completion(request.model, request_dict, api_key)
+        return await self._handle_normal_completion(
+            request.model, request_dict, api_key
+        )
 
     async def generate_images(
         self,
@@ -153,6 +155,7 @@ class OpenAICompatiableService:
                     error_log=error_log_msg,
                     error_code=status_code,
                     request_msg=payload,
+                    request_datetime=request_datetime,
                 )
 
                 if self.key_manager:
@@ -160,15 +163,17 @@ class OpenAICompatiableService:
                         current_attempt_key, retries
                     )
                     if api_key:
-                        logger.info(f"Switched to new API key: {redact_key_for_logging(api_key)}")
+                        logger.info(
+                            f"Switched to new API key: {redact_key_for_logging(api_key)}"
+                        )
                     else:
                         logger.error(
                             f"No valid API key available after {retries} retries."
                         )
-                        break 
+                        break
                 else:
                     logger.error("KeyManager not available for retry logic.")
-                    break 
+                    break
 
                 if retries >= max_retries:
                     logger.error(f"Max retries ({max_retries}) reached for streaming.")
@@ -187,5 +192,3 @@ class OpenAICompatiableService:
                 if not is_success and retries >= max_retries:
                     yield f"data: {json.dumps({'error': 'Streaming failed after retries'})}\n\n"
                     yield "data: [DONE]\n\n"
-                    
-    

app/service/stats/stats_service.py

@@ -146,7 +146,7 @@ class StatsService:
             period: 时间段标识 ('1m', '1h', '24h')
 
         Returns:
-            包含调用详情的字典列表，每个字典包含 timestamp, key, model, status
+            包含调用详情的字典列表，每个字典包含 timestamp, key, model, status, status_code, latency_ms, error_log_id(可选)
 
         Raises:
             ValueError: 如果 period 无效
@@ -156,6 +156,8 @@ class StatsService:
             start_time = now - datetime.timedelta(minutes=1)
         elif period == "1h":
             start_time = now - datetime.timedelta(hours=1)
+        elif period == "8h":
+            start_time = now - datetime.timedelta(hours=8)
         elif period == "24h":
             start_time = now - datetime.timedelta(hours=24)
         else:
@@ -167,7 +169,8 @@ class StatsService:
                     RequestLog.request_time.label("timestamp"),
                     RequestLog.api_key.label("key"),
                     RequestLog.model_name.label("model"),
-                    RequestLog.status_code,
+                    RequestLog.status_code.label("status_code"),
+                    RequestLog.latency_ms.label("latency_ms"),
                 )
                 .where(RequestLog.request_time >= start_time)
                 .order_by(RequestLog.request_time.desc())
@@ -175,31 +178,127 @@ class StatsService:
 
             results = await database.fetch_all(query)
 
-            details = []
+            details: list[dict] = []
             for row in results:
                 status = "failure"
                 if row["status_code"] is not None:
                     status = "success" if 200 <= row["status_code"] < 300 else "failure"
-                details.append(
-                    {
-                        "timestamp": row[
-                            "timestamp"
-                        ].isoformat(),
-                        "key": row["key"],
-                        "model": row["model"],
-                        "status": status,
-                    }
-                )
+
+                record = {
+                    "timestamp": row["timestamp"].isoformat(),
+                    "key": row["key"],
+                    "model": row["model"],
+                    "status": status,
+                    "status_code": row["status_code"],
+                    "latency_ms": row["latency_ms"],
+                }
+
+                details.append(record)
+
             logger.info(
                 f"Retrieved {len(details)} API call details for period '{period}'"
             )
             return details
 
         except Exception as e:
-            logger.error(
-                f"Failed to get API call details for period '{period}': {e}")
+            logger.error(f"Failed to get API call details for period '{period}': {e}")
             raise
 
+    async def get_key_call_details(self, key: str, period: str) -> list[dict]:
+        """获取指定密钥在指定时间段内的调用详情 (与 get_api_call_details 结构一致)"""
+        now = datetime.datetime.now()
+        if period == "1m":
+            start_time = now - datetime.timedelta(minutes=1)
+        elif period == "1h":
+            start_time = now - datetime.timedelta(hours=1)
+        elif period == "8h":
+            start_time = now - datetime.timedelta(hours=8)
+        elif period == "24h":
+            start_time = now - datetime.timedelta(hours=24)
+        else:
+            raise ValueError(f"无效的时间段标识: {period}")
+
+        try:
+            query = (
+                select(
+                    RequestLog.request_time.label("timestamp"),
+                    RequestLog.api_key.label("key"),
+                    RequestLog.model_name.label("model"),
+                    RequestLog.status_code.label("status_code"),
+                    RequestLog.latency_ms.label("latency_ms"),
+                )
+                .where(RequestLog.request_time >= start_time, RequestLog.api_key == key)
+                .order_by(RequestLog.request_time.desc())
+            )
+
+            results = await database.fetch_all(query)
+
+            details: list[dict] = []
+            for row in results:
+                status = "failure"
+                if row["status_code"] is not None:
+                    status = "success" if 200 <= row["status_code"] < 300 else "failure"
+
+                record = {
+                    "timestamp": row["timestamp"].isoformat(),
+                    "key": row["key"],
+                    "model": row["model"],
+                    "status": status,
+                    "status_code": row["status_code"],
+                    "latency_ms": row["latency_ms"],
+                }
+
+                details.append(record)
+
+            logger.info(
+                f"Retrieved {len(details)} key call details for key=...{key[-4:] if key else ''} period '{period}'"
+            )
+            return details
+        except Exception as e:
+            logger.error(
+                f"Failed to get key call details for key=...{key[-4:] if key else ''} period '{period}': {e}"
+            )
+            raise
+
+    async def get_attention_keys_last_24h(
+        self, include_keys: set[str], limit: int = 20, status_code: int = 429
+    ) -> list[dict]:
+        """返回最近24小时内指定状态码(默认429)最多的Key列表，仅包含include_keys中的Key。
+
+        Returns: [{"key": str, "count": int, "status_code": int}, ...] 按次数降序
+        """
+        try:
+            now = datetime.datetime.now()
+            start_time = now - datetime.timedelta(hours=24)
+            if not include_keys:
+                return []
+            query = (
+                select(
+                    RequestLog.api_key.label("key"),
+                    func.count(RequestLog.id).label("count"),
+                )
+                .where(
+                    RequestLog.request_time >= start_time,
+                    RequestLog.status_code == status_code,
+                    RequestLog.api_key.isnot(None),
+                    RequestLog.api_key.in_(list(include_keys)),
+                )
+                .group_by(RequestLog.api_key)
+                .order_by(func.count(RequestLog.id).desc())
+                .limit(limit)
+            )
+            rows = await database.fetch_all(query)
+            return [
+                {"key": row["key"], "count": row["count"], "status_code": status_code}
+                for row in rows
+                if row["key"]
+            ]
+        except Exception as e:
+            logger.error(
+                f"Failed to get attention keys ({status_code}) in last 24h: {e}"
+            )
+            return []
+
     async def get_key_usage_details_last_24h(self, key: str) -> Union[dict, None]:
         """
         获取指定 API 密钥在过去 24 小时内按模型统计的调用次数。
@@ -220,8 +319,7 @@ class StatsService:
         try:
             query = (
                 select(
-                    RequestLog.model_name, func.count(
-                        RequestLog.id).label("call_count")
+                    RequestLog.model_name, func.count(RequestLog.id).label("call_count")
                 )
                 .where(
                     RequestLog.api_key == key,
@@ -240,8 +338,7 @@ class StatsService:
                 )
                 return {}
 
-            usage_details = {row["model_name"]: row["call_count"]
-                             for row in results}
+            usage_details = {row["model_name"]: row["call_count"] for row in results}
             logger.info(
                 f"Successfully fetched usage details for key ending in ...{key[-4:]}: {usage_details}"
             )

app/static/css/fonts.css

@@ -0,0 +1,315 @@
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7SUc.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7SUc.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7SUc.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7SUc.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7SUc.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7SUc.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7SUc.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7SUc.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7SUc.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7SUc.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7SUc.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7SUc.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7SUc.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7SUc.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7SUc.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7SUc.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7SUc.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7SUc.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7SUc.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7SUc.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7SUc.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7SUc.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7SUc.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7SUc.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7SUc.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7SUc.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7SUc.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7SUc.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7SUc.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7SUc.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v19/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}

app/static/js/config_editor.js

@@ -16,6 +16,13 @@ const PROXY_REGEX =
 const VERTEX_API_KEY_REGEX = /AQ\.[a-zA-Z0-9_\-]{50}/g; // 新增 Vertex Express API Key 正则
 const MASKED_VALUE = "••••••••";
 
+// API Keys Pagination Constants
+const API_KEYS_PER_PAGE = 20; // 每页显示的API密钥数量
+let currentApiKeyPage = 1;
+let totalApiKeyPages = 1;
+let allApiKeys = []; // 存储所有API密钥数据
+let filteredApiKeys = []; // 存储过滤后的API密钥数据
+
 // DOM Elements - Global Scope for frequently accessed elements
 const safetySettingsContainer = document.getElementById(
   "SAFETY_SETTINGS_container"
@@ -147,6 +154,17 @@ document.addEventListener("DOMContentLoaded", function () {
   if (apiKeySearchInput)
     apiKeySearchInput.addEventListener("input", handleApiKeySearch);
 
+  // API Key Pagination Event Listeners
+  const apiKeyPrevBtn = document.getElementById("apiKeyPrevBtn");
+  const apiKeyNextBtn = document.getElementById("apiKeyNextBtn");
+  
+  if (apiKeyPrevBtn) {
+    apiKeyPrevBtn.addEventListener("click", prevApiKeyPage);
+  }
+  if (apiKeyNextBtn) {
+    apiKeyNextBtn.addEventListener("click", nextApiKeyPage);
+  }
+
   // Bulk Delete API Key Modal Elements and Events
   const bulkDeleteApiKeyBtn = document.getElementById("bulkDeleteApiKeyBtn");
   const closeBulkDeleteModalBtn = document.getElementById(
@@ -924,9 +942,9 @@ function populateForm(config) {
       '<div class="text-gray-500 text-sm italic">添加自定义请求头，例如 X-Api-Key: your-key</div>';
   }
 
-  // 4. Populate other array fields (excluding THINKING_MODELS)
+  // 4. Populate other array fields (excluding THINKING_MODELS and API_KEYS)
   for (const [key, value] of Object.entries(config)) {
-    if (Array.isArray(value) && key !== "THINKING_MODELS") {
+    if (Array.isArray(value) && key !== "THINKING_MODELS" && key !== "API_KEYS") {
       const container = document.getElementById(`${key}_container`);
       if (container) {
         value.forEach((itemValue) => {
@@ -940,6 +958,17 @@ function populateForm(config) {
     }
   }
 
+  // 4.1. 特殊处理API_KEYS - 使用分页
+  if (Array.isArray(config.API_KEYS)) {
+    allApiKeys = config.API_KEYS.filter(key =>
+      typeof key === "string" && key.trim() !== ""
+    );
+    filteredApiKeys = [...allApiKeys];
+    currentApiKeyPage = 1;
+    renderApiKeyPage();
+    updateApiKeyPagination();
+  }
+
   // 5. Populate non-array/non-budget fields
   for (const [key, value] of Object.entries(config)) {
     if (
@@ -1062,44 +1091,31 @@ function populateForm(config) {
  * Handles the bulk addition of API keys from the modal input.
  */
 function handleBulkAddApiKeys() {
-  const apiKeyContainer = document.getElementById("API_KEYS_container");
-  if (!apiKeyBulkInput || !apiKeyContainer || !apiKeyModal) return;
+  if (!apiKeyBulkInput || !apiKeyModal) return;
 
   const bulkText = apiKeyBulkInput.value;
   const extractedKeys = bulkText.match(API_KEY_REGEX) || [];
 
-  const currentKeyInputs = apiKeyContainer.querySelectorAll(
-    `.${ARRAY_INPUT_CLASS}.${SENSITIVE_INPUT_CLASS}`
-  );
-  let currentKeys = Array.from(currentKeyInputs)
-    .map((input) => {
-      return input.hasAttribute("data-real-value")
-        ? input.getAttribute("data-real-value")
-        : input.value;
-    })
-    .filter((key) => key && key.trim() !== "" && key !== MASKED_VALUE);
-
-  const combinedKeys = new Set([...currentKeys, ...extractedKeys]);
+  // 合并现有密钥和新密钥，去重
+  const combinedKeys = new Set([...allApiKeys, ...extractedKeys]);
   const uniqueKeys = Array.from(combinedKeys);
 
-  apiKeyContainer.innerHTML = ""; // Clear existing items more directly
+  // 更新全局密钥数组
+  allApiKeys = uniqueKeys;
+  
+  // 更新过滤后的数组
+  const searchTerm = apiKeySearchInput ? apiKeySearchInput.value.toLowerCase() : "";
+  if (!searchTerm) {
+    filteredApiKeys = [...allApiKeys];
+  } else {
+    filteredApiKeys = allApiKeys.filter(key =>
+      key.toLowerCase().includes(searchTerm)
+    );
+  }
 
-  uniqueKeys.forEach((key) => {
-    addArrayItemWithValue("API_KEYS", key);
-  });
-
-  const newKeyInputs = apiKeyContainer.querySelectorAll(
-    `.${ARRAY_INPUT_CLASS}.${SENSITIVE_INPUT_CLASS}`
-  );
-  newKeyInputs.forEach((input) => {
-    if (configForm && typeof initializeSensitiveFields === "function") {
-      const focusoutEvent = new Event("focusout", {
-        bubbles: true,
-        cancelable: true,
-      });
-      input.dispatchEvent(focusoutEvent);
-    }
-  });
+  // 重新渲染当前页
+  renderApiKeyPage();
+  updateApiKeyPagination();
 
   closeModal(apiKeyModal);
   showNotification(`添加/更新了 ${uniqueKeys.length} 个唯一密钥`, "success");
@@ -1109,32 +1125,139 @@ function handleBulkAddApiKeys() {
  * Handles searching/filtering of API keys in the list.
  */
 function handleApiKeySearch() {
-  const apiKeyContainer = document.getElementById("API_KEYS_container");
-  if (!apiKeySearchInput || !apiKeyContainer) return;
+  if (!apiKeySearchInput) return;
 
   const searchTerm = apiKeySearchInput.value.toLowerCase();
-  const keyItems = apiKeyContainer.querySelectorAll(`.${ARRAY_ITEM_CLASS}`);
-
-  keyItems.forEach((item) => {
-    const input = item.querySelector(
-      `.${ARRAY_INPUT_CLASS}.${SENSITIVE_INPUT_CLASS}`
+  
+  // 过滤API密钥
+  if (!searchTerm) {
+    filteredApiKeys = [...allApiKeys];
+  } else {
+    filteredApiKeys = allApiKeys.filter(key =>
+      key.toLowerCase().includes(searchTerm)
     );
-    if (input) {
-      const realValue = input.hasAttribute("data-real-value")
-        ? input.getAttribute("data-real-value").toLowerCase()
-        : input.value.toLowerCase();
-      item.style.display = realValue.includes(searchTerm) ? "flex" : "none";
-    }
+  }
+
+  // 重置到第一页
+  currentApiKeyPage = 1;
+  
+  // 重新渲染当前页
+  renderApiKeyPage();
+  updateApiKeyPagination();
+}
+
+/**
+ * 渲染当前页的API密钥
+ */
+function renderApiKeyPage() {
+  const apiKeyContainer = document.getElementById("API_KEYS_container");
+  if (!apiKeyContainer) return;
+
+  // 清空容器
+  apiKeyContainer.innerHTML = "";
+
+  // 计算当前页的数据范围
+  const startIndex = (currentApiKeyPage - 1) * API_KEYS_PER_PAGE;
+  const endIndex = Math.min(startIndex + API_KEYS_PER_PAGE, filteredApiKeys.length);
+  const pageKeys = filteredApiKeys.slice(startIndex, endIndex);
+
+  // 渲染当前页的密钥
+  pageKeys.forEach((key) => {
+    addArrayItemWithValue("API_KEYS", key);
   });
+
+  // 如果没有密钥，显示提示信息
+  if (pageKeys.length === 0) {
+    const emptyMessage = document.createElement("div");
+    emptyMessage.className = "text-gray-500 text-sm italic text-center py-4";
+    emptyMessage.textContent = filteredApiKeys.length === 0 ?
+      (allApiKeys.length === 0 ? "暂无API密钥" : "未找到匹配的密钥") :
+      "当前页无数据";
+    apiKeyContainer.appendChild(emptyMessage);
+  }
+}
+
+/**
+ * 更新分页控件
+ */
+function updateApiKeyPagination() {
+  totalApiKeyPages = Math.max(1, Math.ceil(filteredApiKeys.length / API_KEYS_PER_PAGE));
+  
+  // 确保当前页在有效范围内
+  if (currentApiKeyPage > totalApiKeyPages) {
+    currentApiKeyPage = totalApiKeyPages;
+  }
+
+  const paginationContainer = document.getElementById("apiKeyPagination");
+  if (!paginationContainer) return;
+
+  // 如果只有一页或没有数据，隐藏分页控件
+  if (totalApiKeyPages <= 1) {
+    paginationContainer.style.display = "none";
+    return;
+  }
+
+  paginationContainer.style.display = "flex";
+
+  // 更新页码信息
+  const pageInfo = document.getElementById("apiKeyPageInfo");
+  if (pageInfo) {
+    pageInfo.textContent = `第 ${currentApiKeyPage} 页，共 ${totalApiKeyPages} 页 (${filteredApiKeys.length} 个密钥)`;
+  }
+
+  // 更新按钮状态
+  const prevBtn = document.getElementById("apiKeyPrevBtn");
+  const nextBtn = document.getElementById("apiKeyNextBtn");
+  
+  if (prevBtn) {
+    prevBtn.disabled = currentApiKeyPage <= 1;
+    prevBtn.className = currentApiKeyPage <= 1 ?
+      "px-3 py-1 rounded bg-gray-300 text-gray-500 cursor-not-allowed" :
+      "px-3 py-1 rounded bg-blue-500 text-white hover:bg-blue-600 cursor-pointer";
+  }
+  
+  if (nextBtn) {
+    nextBtn.disabled = currentApiKeyPage >= totalApiKeyPages;
+    nextBtn.className = currentApiKeyPage >= totalApiKeyPages ?
+      "px-3 py-1 rounded bg-gray-300 text-gray-500 cursor-not-allowed" :
+      "px-3 py-1 rounded bg-blue-500 text-white hover:bg-blue-600 cursor-pointer";
+  }
+}
+
+/**
+ * 跳转到指定页
+ */
+function goToApiKeyPage(page) {
+  if (page < 1 || page > totalApiKeyPages) return;
+  
+  currentApiKeyPage = page;
+  renderApiKeyPage();
+  updateApiKeyPagination();
+}
+
+/**
+ * 上一页
+ */
+function prevApiKeyPage() {
+  if (currentApiKeyPage > 1) {
+    goToApiKeyPage(currentApiKeyPage - 1);
+  }
+}
+
+/**
+ * 下一页
+ */
+function nextApiKeyPage() {
+  if (currentApiKeyPage < totalApiKeyPages) {
+    goToApiKeyPage(currentApiKeyPage + 1);
+  }
 }
 
 /**
  * Handles the bulk deletion of API keys based on input from the modal.
  */
 function handleBulkDeleteApiKeys() {
-  const apiKeyContainer = document.getElementById("API_KEYS_container");
-  if (!bulkDeleteApiKeyInput || !apiKeyContainer || !bulkDeleteApiKeyModal)
-    return;
+  if (!bulkDeleteApiKeyInput || !bulkDeleteApiKeyModal) return;
 
   const bulkText = bulkDeleteApiKeyInput.value;
   if (!bulkText.trim()) {
@@ -1149,24 +1272,30 @@ function handleBulkDeleteApiKeys() {
     return;
   }
 
-  const keyItems = apiKeyContainer.querySelectorAll(`.${ARRAY_ITEM_CLASS}`);
+  // 从allApiKeys数组中删除匹配的密钥
   let deleteCount = 0;
-
-  keyItems.forEach((item) => {
-    const input = item.querySelector(
-      `.${ARRAY_INPUT_CLASS}.${SENSITIVE_INPUT_CLASS}`
-    );
-    const realValue =
-      input &&
-      (input.hasAttribute("data-real-value")
-        ? input.getAttribute("data-real-value")
-        : input.value);
-    if (realValue && keysToDelete.has(realValue)) {
-      item.remove();
+  allApiKeys = allApiKeys.filter(key => {
+    if (keysToDelete.has(key)) {
       deleteCount++;
+      return false;
     }
+    return true;
   });
 
+  // 更新过滤后的数组
+  const searchTerm = apiKeySearchInput ? apiKeySearchInput.value.toLowerCase() : "";
+  if (!searchTerm) {
+    filteredApiKeys = [...allApiKeys];
+  } else {
+    filteredApiKeys = allApiKeys.filter(key =>
+      key.toLowerCase().includes(searchTerm)
+    );
+  }
+
+  // 重新渲染当前页
+  renderApiKeyPage();
+  updateApiKeyPagination();
+
   closeModal(bulkDeleteApiKeyModal);
 
   if (deleteCount > 0) {
@@ -1782,6 +1911,15 @@ function collectFormData() {
   const arrayContainers = document.querySelectorAll(".array-container");
   arrayContainers.forEach((container) => {
     const key = container.id.replace("_container", "");
+    
+    // 特殊处理API_KEYS - 使用全局数组而不是DOM元素
+    if (key === "API_KEYS") {
+      formData[key] = allApiKeys.filter(
+        (value) => value && value.trim() !== "" && value !== MASKED_VALUE
+      );
+      return;
+    }
+    
     const arrayInputs = container.querySelectorAll(`.${ARRAY_INPUT_CLASS}`);
     formData[key] = Array.from(arrayInputs)
       .map((input) => {

app/static/js/keys_status.js

@@ -108,8 +108,14 @@ function initStatItemAnimations() {
 
 // 获取指定类型区域内选中的密钥
 function getSelectedKeys(type) {
+  let selectorRoot;
+  if (type === 'attention') {
+    selectorRoot = '#attentionKeysList';
+  } else {
+    selectorRoot = `#${type}Keys`;
+  }
   const checkboxes = document.querySelectorAll(
-    `#${type}Keys .key-checkbox:checked`
+    `${selectorRoot} .key-checkbox:checked`
   );
   return Array.from(checkboxes).map((cb) => cb.value);
 }
@@ -119,27 +125,27 @@ function updateBatchActions(type) {
   const selectedKeys = getSelectedKeys(type);
   const count = selectedKeys.length;
   const batchActionsDiv = document.getElementById(`${type}BatchActions`);
+  if (!batchActionsDiv) return;
   const selectedCountSpan = document.getElementById(`${type}SelectedCount`);
   const buttons = batchActionsDiv.querySelectorAll("button");
 
   if (count > 0) {
     batchActionsDiv.classList.remove("hidden");
-    selectedCountSpan.textContent = count;
+    if (selectedCountSpan) selectedCountSpan.textContent = count;
     buttons.forEach((button) => (button.disabled = false));
   } else {
     batchActionsDiv.classList.add("hidden");
-    selectedCountSpan.textContent = "0";
+    if (selectedCountSpan) selectedCountSpan.textContent = "0";
     buttons.forEach((button) => (button.disabled = true));
   }
 
   // 更新全选复选框状态
-  const selectAllCheckbox = document.getElementById(
-    `selectAll${type.charAt(0).toUpperCase() + type.slice(1)}`
-  );
-  const allCheckboxes = document.querySelectorAll(`#${type}Keys .key-checkbox`);
+  const selectAllId = `selectAll${type.charAt(0).toUpperCase() + type.slice(1)}`;
+  const selectAllCheckbox = document.getElementById(selectAllId);
+  const rootId = type === 'attention' ? 'attentionKeysList' : `${type}Keys`;
   // 只有在有可见的 key 时才考虑全选状态
   const visibleCheckboxes = document.querySelectorAll(
-    `#${type}Keys li:not([style*="display: none"]) .key-checkbox`
+    `#${rootId} li:not([style*="display: none"]) .key-checkbox`
   );
   if (selectAllCheckbox && visibleCheckboxes.length > 0) {
     selectAllCheckbox.checked = count === visibleCheckboxes.length;
@@ -153,29 +159,28 @@ function updateBatchActions(type) {
 
 // 全选/取消全选指定类型的密钥
 function toggleSelectAll(type, isChecked) {
-  const listElement = document.getElementById(`${type}Keys`);
-  // Select checkboxes within LI elements that are NOT styled with display:none
-  // This targets currently visible items based on filtering.
+  const rootId = type === 'attention' ? 'attentionKeysList' : `${type}Keys`;
+  const listElement = document.getElementById(rootId);
+  if (!listElement) return;
   const visibleCheckboxes = listElement.querySelectorAll(
     `li:not([style*="display: none"]) .key-checkbox`
   );
 
   visibleCheckboxes.forEach((checkbox) => {
     checkbox.checked = isChecked;
-    const listItem = checkbox.closest("li[data-key]"); // Get the LI from the current DOM
+    const listItem = checkbox.closest("li[data-key]");
     if (listItem) {
       listItem.classList.toggle("selected", isChecked);
-
-      // Sync with master array
-      const key = listItem.dataset.key;
-      const masterList = type === "valid" ? allValidKeys : allInvalidKeys;
-      if (masterList) {
-        // Ensure masterList is defined
-        const masterListItem = masterList.find((li) => li.dataset.key === key);
-        if (masterListItem) {
-          const masterCheckbox = masterListItem.querySelector(".key-checkbox");
-          if (masterCheckbox) {
-            masterCheckbox.checked = isChecked;
+      if (type !== 'attention') {
+        const key = listItem.dataset.key;
+        const masterList = type === "valid" ? allValidKeys : allInvalidKeys;
+        if (masterList) {
+          const masterListItem = masterList.find((li) => li.dataset.key === key);
+          if (masterListItem) {
+            const masterCheckbox = masterListItem.querySelector(".key-checkbox");
+            if (masterCheckbox) {
+              masterCheckbox.checked = isChecked;
+            }
           }
         }
       }
@@ -346,7 +351,8 @@ function showResetModal(type) {
   // 设置确认按钮事件
   confirmButton.onclick = () => executeResetAll(type);
 
-  // 显示模态框
+  // 显示模态框，确保位于最上层
+  modalElement.style.zIndex = '1001';
   modalElement.classList.remove("hidden");
 }
 
@@ -1161,20 +1167,21 @@ function initializeKeySelectionListeners() {
         if (listItem) {
           listItem.classList.toggle("selected", checkbox.checked);
 
-          // Sync with master array
-          const key = listItem.dataset.key;
-          const masterList =
-            keyType === "valid" ? allValidKeys : allInvalidKeys;
-          if (masterList) {
-            // Ensure masterList is defined
-            const masterListItem = masterList.find(
-              (li) => li.dataset.key === key
-            );
-            if (masterListItem) {
-              const masterCheckbox =
-                masterListItem.querySelector(".key-checkbox");
-              if (masterCheckbox) {
-                masterCheckbox.checked = checkbox.checked;
+          // Sync with master array (only for valid/invalid lists)
+          if (keyType !== 'attention') {
+            const key = listItem.dataset.key;
+            const masterList =
+              keyType === "valid" ? allValidKeys : allInvalidKeys;
+            if (masterList) {
+              const masterListItem = masterList.find(
+                (li) => li.dataset.key === key
+              );
+              if (masterListItem) {
+                const masterCheckbox =
+                  masterListItem.querySelector(".key-checkbox");
+                if (masterCheckbox) {
+                  masterCheckbox.checked = checkbox.checked;
+                }
               }
             }
           }
@@ -1186,50 +1193,9 @@ function initializeKeySelectionListeners() {
 
   setupEventListenersForList("validKeys", "valid");
   setupEventListenersForList("invalidKeys", "invalid");
+  setupEventListenersForList("attentionKeysList", "attention");
 }
 
-function initializeAutoRefreshControls() {
-  const autoRefreshToggle = document.getElementById("autoRefreshToggle");
-  const autoRefreshIntervalTime = 60000; // 60秒
-  let autoRefreshTimer = null;
-
-  function startAutoRefresh() {
-    if (autoRefreshTimer) return;
-    console.log("启动自动刷新...");
-    showNotification("自动刷新已启动", "info", 2000);
-    autoRefreshTimer = setInterval(() => {
-      console.log("自动刷新 keys_status 页面...");
-      location.reload();
-    }, autoRefreshIntervalTime);
-  }
-
-  function stopAutoRefresh() {
-    if (autoRefreshTimer) {
-      console.log("停止自动刷新...");
-      showNotification("自动刷新已停止", "info", 2000);
-      clearInterval(autoRefreshTimer);
-      autoRefreshTimer = null;
-    }
-  }
-
-  if (autoRefreshToggle) {
-    const isAutoRefreshEnabled =
-      localStorage.getItem("autoRefreshEnabled") === "true";
-    autoRefreshToggle.checked = isAutoRefreshEnabled;
-    if (isAutoRefreshEnabled) {
-      startAutoRefresh();
-    }
-    autoRefreshToggle.addEventListener("change", () => {
-      if (autoRefreshToggle.checked) {
-        localStorage.setItem("autoRefreshEnabled", "true");
-        startAutoRefresh();
-      } else {
-        localStorage.setItem("autoRefreshEnabled", "false");
-        stopAutoRefresh();
-      }
-    });
-  }
-}
 
 // Debounce function
 function debounce(func, delay) {
@@ -1478,6 +1444,261 @@ function initializeDropdownMenu() {
   }
 }
 
+// --- Chart: API success/failure over time ---
+let apiStatsChart = null;
+
+function buildChartConfig(labels, successData, failureData) {
+  return {
+    type: 'line',
+    data: {
+      labels,
+      datasets: [
+        {
+          label: '成功',
+          data: successData,
+          borderColor: 'rgba(16,185,129,1)', // emerald-500
+          backgroundColor: 'rgba(16,185,129,0.15)',
+          tension: 0.3,
+          fill: true,
+          pointRadius: 2,
+        },
+        {
+          label: '失败',
+          data: failureData,
+          borderColor: 'rgba(239,68,68,1)', // red-500
+          backgroundColor: 'rgba(239,68,68,0.15)',
+          tension: 0.3,
+          fill: true,
+          pointRadius: 2,
+        },
+      ],
+    },
+    options: {
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: {
+        legend: { position: 'top' },
+        tooltip: { mode: 'index', intersect: false },
+      },
+      interaction: { mode: 'nearest', axis: 'x', intersect: false },
+      scales: {
+        x: { title: { display: true, text: '时间' } },
+        y: { title: { display: true, text: '调用次数' }, beginAtZero: true, ticks: { precision: 0 } },
+      },
+    },
+  };
+}
+
+async function fetchPeriodDetails(period) {
+  // Uses backend endpoint /api/stats/details?period={period}
+  return await fetchAPI(`/api/stats/details?period=${period}`);
+}
+
+function bucketizeDetails(period, details) {
+  // details is expected to be an array of call records with fields: timestamp, status
+  // Build buckets depending on period
+  const buckets = new Map();
+  const addToBucket = (key, isSuccess) => {
+    if (!buckets.has(key)) buckets.set(key, { success: 0, failure: 0 });
+    const obj = buckets.get(key);
+    if (isSuccess) obj.success += 1; else obj.failure += 1;
+  };
+
+  const toKey = (ts) => {
+    const d = new Date(ts);
+    if (period === '1m') {
+      // bucket by second within last minute
+      const mm = String(d.getMinutes()).padStart(2,'0');
+      const ss = String(d.getSeconds()).padStart(2,'0');
+      return `${mm}:${ss}`;
+    } else if (period === '1h') {
+      // bucket by minute
+      const HH = String(d.getHours()).padStart(2,'0');
+      const mm = String(d.getMinutes()).padStart(2,'0');
+      return `${HH}:${mm}`;
+    } else if (period === '8h') {
+      // bucket by hour for 8h window (same as 24h)
+      const MM = String(d.getMonth()+1).padStart(2,'0');
+      const DD = String(d.getDate()).padStart(2,'0');
+      const HH = String(d.getHours()).padStart(2,'0');
+      return `${MM}-${DD} ${HH}:00`;
+    } else {
+      // 24h: bucket by hour
+      const MM = String(d.getMonth()+1).padStart(2,'0');
+      const DD = String(d.getDate()).padStart(2,'0');
+      const HH = String(d.getHours()).padStart(2,'0');
+      return `${MM}-${DD} ${HH}:00`;
+    }
+  };
+
+  (details || []).forEach((call) => {
+    const key = toKey(call.timestamp);
+    const isSuccess = call.status === 'success';
+    addToBucket(key, isSuccess);
+  });
+
+  // sort labels chronologically by parsing back to date when possible
+  const labels = Array.from(buckets.keys()).sort((a,b)=>{
+    // Try to create date objects relative to today for ordering; fallback to string compare
+    const da = Date.parse(a) || 0;
+    const db = Date.parse(b) || 0;
+    if (da && db) return da - db;
+    return a.localeCompare(b);
+  });
+  const successData = labels.map(l => buckets.get(l).success);
+  const failureData = labels.map(l => buckets.get(l).failure);
+  return { labels, successData, failureData };
+}
+
+async function renderApiChart(period) {
+  const canvas = document.getElementById('apiStatsChart');
+  if (!canvas || typeof Chart === 'undefined') return;
+  try {
+    const details = await fetchPeriodDetails(period);
+    const { labels, successData, failureData } = bucketizeDetails(period, details || []);
+    const cfg = buildChartConfig(labels, successData, failureData);
+    if (apiStatsChart) {
+      apiStatsChart.destroy();
+    }
+    apiStatsChart = new Chart(canvas.getContext('2d'), cfg);
+  } catch (e) {
+    console.error('Failed to render chart:', e);
+  }
+}
+
+// --- Helpers for Attention Keys panel ---
+// track current active status code tab
+let currentStatus = 429;
+
+function getLimit() {
+  const el = document.getElementById('attentionLimitInput');
+  const v = parseInt(el && el.value, 10);
+  if (isNaN(v)) return 10;
+  // clamp between 1 and 1000 to match input limits
+  return Math.min(1000, Math.max(1, v));
+}
+
+async function fetchAndRenderAttentionKeys(statusCode = 429, limit = 10) {
+  const listEl = document.getElementById('attentionKeysList');
+  if (!listEl) return;
+  try {
+    const data = await fetchAPI(`/api/stats/attention-keys?status_code=${statusCode}&limit=${limit}`);
+    listEl.innerHTML = '';
+    if (!data || (Array.isArray(data) && data.length === 0) || data.error) {
+      listEl.innerHTML = '<li class="text-center text-gray-500 py-2">暂无需要注意的Key</li>';
+      updateBatchActions('attention');
+      return;
+    }
+    data.forEach(item => {
+      const li = document.createElement('li');
+      li.className = 'flex items-center justify-between bg-white rounded border px-3 py-2';
+      li.dataset.key = item.key || '';
+      const masked = item.key ? `${item.key.substring(0,4)}...${item.key.substring(item.key.length-4)}` : 'N/A';
+      const code = item.status_code ?? statusCode;
+      li.innerHTML = `
+        <div class="flex items-center gap-3">
+          <input type="checkbox" class="form-checkbox h-4 w-4 text-primary-600 border-gray-300 rounded key-checkbox" value="${item.key || ''}">
+          <span class="font-mono text-sm">${masked}</span>
+          <span class="text-xs bg-red-100 text-red-700 px-2 py-0.5 rounded">${code}: ${item.count}</span>
+        </div>
+        <div class="flex items-center gap-2">
+          <button class="px-2 py-1 text-xs rounded bg-success-600 hover:bg-success-700 text-white" title="验证此Key">验证</button>
+          <button class="px-2 py-1 text-xs rounded bg-blue-600 hover:bg-blue-700 text-white" title="查看24小时详情">详情</button>
+          <button class="px-2 py-1 text-xs rounded bg-blue-500 hover:bg-blue-600 text-white" title="复制Key">复制</button>
+          <button class="px-2 py-1 text-xs rounded bg-red-800 hover:bg-red-900 text-white" title="删除此Key">删除</button>
+        </div>`;
+      const [verifyBtn, detailBtn, copyBtn, deleteBtn] = li.querySelectorAll('button');
+      verifyBtn.addEventListener('click', (e) => { e.stopPropagation(); verifyKey(item.key, e.currentTarget); });
+      detailBtn.addEventListener('click', (e) => { e.stopPropagation(); window.showKeyUsageDetails(item.key); });
+      copyBtn.addEventListener('click', (e) => { e.stopPropagation(); copyKey(item.key); });
+      deleteBtn.addEventListener('click', (e) => { e.stopPropagation(); showSingleKeyDeleteConfirmModal(item.key, e.currentTarget); });
+      // Checkbox change updates batch actions
+      const checkbox = li.querySelector('.key-checkbox');
+      if (checkbox) {
+        checkbox.addEventListener('change', () => updateBatchActions('attention'));
+      }
+      listEl.appendChild(li);
+    });
+    updateBatchActions('attention');
+  } catch (e) {
+    listEl.innerHTML = `<li class="text-center text-red-500 py-2">加载失败: ${e.message}</li>`;
+    updateBatchActions('attention');
+  }
+}
+
+function initChartControls() {
+  const btn1h = document.getElementById('chartBtn1h');
+  const btn8h = document.getElementById('chartBtn8h');
+  const btn24h = document.getElementById('chartBtn24h');
+  const setActive = (activeBtn) => {
+    [btn1h, btn8h, btn24h].forEach(btn => {
+      if (!btn) return;
+      if (btn === activeBtn) {
+        btn.classList.remove('bg-gray-200');
+        btn.classList.add('bg-primary-600','text-white');
+      } else {
+        btn.classList.add('bg-gray-200');
+        btn.classList.remove('bg-primary-600','text-white');
+      }
+    });
+  };
+
+  if (btn1h) btn1h.addEventListener('click', async () => { setActive(btn1h); await renderApiChart('1h'); });
+  if (btn8h) btn8h.addEventListener('click', async () => { setActive(btn8h); await renderApiChart('8h'); });
+  if (btn24h) btn24h.addEventListener('click', async () => { setActive(btn24h); await renderApiChart('24h'); });
+
+  // default period
+  if (btn1h) setActive(btn1h);
+  renderApiChart('1h');
+}
+
+function initAttentionKeysControls() {
+  const btn429 = document.getElementById('attentionErr429');
+  const btn403 = document.getElementById('attentionErr403');
+  const btn400 = document.getElementById('attentionErr400');
+  // 修复：补充获取数量输入框，避免未声明变量导致初始化报错
+  const limitInput = document.getElementById('attentionLimitInput');
+  const setActive = (activeBtn) => {
+    [btn429, btn403, btn400].forEach(btn => {
+      if (!btn) return;
+      if (btn === activeBtn) {
+        btn.classList.remove('bg-gray-200');
+        btn.classList.add('bg-primary-600','text-white');
+      } else {
+        btn.classList.add('bg-gray-200');
+        btn.classList.remove('bg-primary-600','text-white');
+      }
+    });
+  };
+  if (btn429) btn429.addEventListener('click', () => { setActive(btn429); currentStatus = 429; fetchAndRenderAttentionKeys(429, getLimit()); });
+  if (btn403) btn403.addEventListener('click', () => { setActive(btn403); currentStatus = 403; fetchAndRenderAttentionKeys(403, getLimit()); });
+  if (btn400) btn400.addEventListener('click', () => { setActive(btn400); currentStatus = 400; fetchAndRenderAttentionKeys(400, getLimit()); });
+  // 自定义查询
+  const input = document.getElementById('attentionErrCustom');
+  const go = document.getElementById('attentionErrGo');
+  const trigger = () => {
+    if (!input) return;
+    const val = parseInt(input.value, 10);
+    if (!isNaN(val) && val >= 100 && val <= 599) {
+      setActive(null);
+      [btn429, btn403, btn400].forEach(btn=>{ if(btn){ btn.classList.add('bg-gray-200'); btn.classList.remove('bg-primary-600','text-white'); }});
+      currentStatus = val;
+      fetchAndRenderAttentionKeys(val, getLimit());
+    } else {
+      showNotification('请输入100-599之间的HTTP状态码', 'warning');
+    }
+  };
+  if (go) go.addEventListener('click', trigger);
+  if (input) input.addEventListener('keydown', (e)=>{ if(e.key==='Enter'){ trigger(); }});
+
+  // limit变化实时刷新当前状态码
+  if (limitInput) limitInput.addEventListener('change', () => {
+    fetchAndRenderAttentionKeys(currentStatus, getLimit());
+  });
+
+  if (btn429) setActive(btn429); // default active
+}
+
 // 初始化
 document.addEventListener("DOMContentLoaded", () => {
   initializePageAnimationsAndEffects();
@@ -1485,10 +1706,12 @@ document.addEventListener("DOMContentLoaded", () => {
   initializeKeyFilterControls();
   initializeGlobalBatchVerificationHandlers();
   initializeKeySelectionListeners();
-  initializeAutoRefreshControls();
   initializeKeyPaginationAndSearch(); // This will also handle initial display
   registerServiceWorker();
   initializeDropdownMenu(); // 初始化下拉菜单
+  initChartControls(); // 初始化图表与时间区间切换
+  initAttentionKeysControls(); // 初始化值得注意的Key错误码切换
+  fetchAndRenderAttentionKeys(429, 10); // 默认渲染429，数量10
 
   // Initial batch actions update might be needed if not covered by displayPage
   // updateBatchActions('valid');
@@ -1744,6 +1967,82 @@ async function showApiCallDetails(
   }
 }
 
+// 获取并显示错误日志详情（通过日志ID）
+async function fetchAndShowErrorDetail(logId) {
+  try {
+    const detail = await fetchAPI(`/api/logs/errors/${logId}/details`);
+    if (!detail) {
+      showResultModal(false, `未找到日志 ${logId}`, false);
+      return;
+    }
+    const container = document.createElement('div');
+    container.className = 'space-y-3 text-sm';
+    const basic = document.createElement('div');
+    basic.innerHTML = `
+      <div><span class="font-semibold">Key:</span> ${detail.gemini_key ? detail.gemini_key.substring(0,4)+'...'+detail.gemini_key.slice(-4) : 'N/A'}</div>
+      <div><span class="font-semibold">模型:</span> ${detail.model_name || 'N/A'}</div>
+      <div><span class="font-semibold">时间:</span> ${detail.request_time ? new Date(detail.request_time).toLocaleString() : 'N/A'}</div>
+      <div><span class="font-semibold">错误类型:</span> ${detail.error_type || 'N/A'}</div>
+    `;
+    const codeBlock = document.createElement('pre');
+    codeBlock.className = 'bg-red-50 border border-red-200 rounded p-3 whitespace-pre-wrap break-words text-red-700';
+    codeBlock.textContent = detail.error_log || '无错误日志内容';
+    const reqBlock = document.createElement('pre');
+    reqBlock.className = 'bg-gray-50 border border-gray-200 rounded p-3 whitespace-pre-wrap break-words';
+    reqBlock.textContent = detail.request_msg || '';
+    container.appendChild(basic);
+    container.appendChild(codeBlock);
+    if (detail.request_msg) container.appendChild(reqBlock);
+    showResultModal(false, container, false);
+  } catch (e) {
+    showResultModal(false, `加载日志详情失败: ${e.message}`, false);
+  }
+}
+
+// 新增：根据 key / 状态码 / 时间窗口(±100秒) 查询并显示错误日志详情
+async function fetchAndShowErrorDetailByInfo(geminiKey, statusCode, timestampISO) {
+  try {
+    if (!geminiKey || !timestampISO) {
+      showResultModal(false, '缺少必要参数，无法查询错误详情', false);
+      return;
+    }
+    const params = new URLSearchParams();
+    params.set('gemini_key', geminiKey);
+    params.set('timestamp', timestampISO);
+    if (statusCode !== null && statusCode !== undefined) {
+      params.set('status_code', String(statusCode));
+    }
+    params.set('window_seconds', '100');
+    const detail = await fetchAPI(`/api/logs/errors/lookup?${params.toString()}`);
+    if (!detail) {
+      showResultModal(false, '未找到匹配的错误日志', false);
+      return;
+    }
+    const container = document.createElement('div');
+    container.className = 'space-y-3 text-sm';
+    const basic = document.createElement('div');
+    basic.innerHTML = `
+      <div><span class="font-semibold">Key:</span> ${detail.gemini_key ? detail.gemini_key.substring(0,4)+'...'+detail.gemini_key.slice(-4) : 'N/A'}</div>
+      <div><span class="font-semibold">模型:</span> ${detail.model_name || 'N/A'}</div>
+      <div><span class="font-semibold">时间:</span> ${detail.request_time ? new Date(detail.request_time).toLocaleString() : 'N/A'}</div>
+      <div><span class="font-semibold">错误码:</span> ${detail.error_code ?? 'N/A'}</div>
+      <div><span class="font-semibold">错误类型:</span> ${detail.error_type || 'N/A'}</div>
+    `;
+    const codeBlock = document.createElement('pre');
+    codeBlock.className = 'bg-red-50 border border-red-200 rounded p-3 whitespace-pre-wrap break-words text-red-700';
+    codeBlock.textContent = detail.error_log || '无错误日志内容';
+    const reqBlock = document.createElement('pre');
+    reqBlock.className = 'bg-gray-50 border border-gray-200 rounded p-3 whitespace-pre-wrap break-words';
+    reqBlock.textContent = detail.request_msg || '';
+    container.appendChild(basic);
+    container.appendChild(codeBlock);
+    if (detail.request_msg) container.appendChild(reqBlock);
+    showResultModal(false, container, false);
+  } catch (e) {
+    showResultModal(false, `加载日志详情失败: ${e.message}`, false);
+  }
+}
+
 // 关闭 API 调用详情模态框
 function closeApiCallDetailsModal() {
   const modal = document.getElementById("apiCallDetailsModal");
@@ -1767,23 +2066,33 @@ function renderApiCallDetails(
     successCalls !== undefined &&
     failureCalls !== undefined
   ) {
+    const total = Number(totalCalls) || 0;
+    const succ = Number(successCalls) || 0;
+    const fail = Number(failureCalls) || 0;
+    const denom = total > 0 ? total : succ + fail;
+    const succRate = denom > 0 ? ((succ / denom) * 100).toFixed(1) : '0.0';
+    const failRate = denom > 0 ? ((fail / denom) * 100).toFixed(1) : '0.0';
+
     summaryHtml = `
-        <div class="mb-4 p-3 bg-white dark:bg-gray-700 rounded-lg"> 
-            <h4 class="font-semibold text-gray-700 dark:text-gray-200 mb-2 text-md border-b pb-1.5 dark:border-gray-600">期间调用概览:</h4>
-            <div class="grid grid-cols-3 gap-2 text-center">
-                <div>
-                    <p class="text-sm text-gray-500 dark:text-gray-400">总计</p>
-                    <p class="text-lg font-bold text-primary-600 dark:text-primary-400">${totalCalls}</p>
-                </div>
-                <div>
-                    <p class="text-sm text-gray-500 dark:text-gray-400">成功</p>
-                    <p class="text-lg font-bold text-success-600 dark:text-success-400">${successCalls}</p>
-                </div>
-                <div>
-                    <p class="text-sm text-gray-500 dark:text-gray-400">失败</p>
-                    <p class="text-lg font-bold text-danger-600 dark:text-danger-400">${failureCalls}</p>
-                </div>
-            </div>
+        <div class="mb-4">
+          <table class="min-w-full divide-y divide-gray-200 dark:divide-gray-700 rounded-lg overflow-hidden">
+            <thead class="bg-gray-50 dark:bg-gray-700/50">
+              <tr>
+                <th class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">总计</th>
+                <th class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">成功</th>
+                <th class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">失败</th>
+                <th class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">成功率</th>
+              </tr>
+            </thead>
+            <tbody class="bg-white dark:bg-gray-800">
+              <tr>
+                <td class="px-4 py-2 whitespace-nowrap text-sm font-bold text-primary-600 dark:text-primary-400">${totalCalls}</td>
+                <td class="px-4 py-2 whitespace-nowrap text-sm font-bold text-success-600 dark:text-success-400">${successCalls}</td>
+                <td class="px-4 py-2 whitespace-nowrap text-sm font-bold text-danger-600 dark:text-danger-400">${failureCalls}</td>
+                <td class="px-4 py-2 whitespace-nowrap text-sm font-bold text-success-600 dark:text-success-400">${succRate}%</td>
+              </tr>
+            </tbody>
+          </table>
         </div>
     `;
   }
@@ -1807,7 +2116,10 @@ function renderApiCallDetails(
                     <th scope="col" class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">时间</th>
                     <th scope="col" class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">密钥 (部分)</th>
                     <th scope="col" class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">模型</th>
+                    <th scope="col" class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">状态码</th>
+                    <th scope="col" class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">耗时(ms)</th>
                     <th scope="col" class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">状态</th>
+                    <th scope="col" class="px-4 py-2 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">详情</th>
                 </tr>
             </thead>
             <tbody class="bg-white dark:bg-gray-800 divide-y divide-gray-200 dark:divide-gray-700">
@@ -1828,17 +2140,25 @@ function renderApiCallDetails(
     const statusIcon =
       call.status === "success" ? "fa-check-circle" : "fa-times-circle";
 
+const detailsBtn =
+      call.status === "failure"
+        ? `<button class="px-2 py-1 rounded bg-red-100 hover:bg-red-200 text-red-700 text-xs" onclick="fetchAndShowErrorDetailByInfo('${call.key}', ${call.status_code ?? 'null'}, '${call.timestamp}')">
+             <i class="fas fa-info-circle mr-1"></i>详情
+           </button>`
+        : "-";
+
     tableHtml += `
             <tr class="hover:bg-gray-50 dark:hover:bg-gray-700/30">
                 <td class="px-4 py-2 whitespace-nowrap text-sm text-gray-700 dark:text-gray-300">${timestamp}</td>
                 <td class="px-4 py-2 whitespace-nowrap text-sm text-gray-500 dark:text-gray-400 font-mono">${keyDisplay}</td>
-                <td class="px-4 py-2 whitespace-nowrap text-sm text-gray-500 dark:text-gray-400">${
-                  call.model || "N/A"
-                }</td>
+                <td class="px-4 py-2 whitespace-nowrap text-sm text-gray-500 dark:text-gray-400">${call.model || "N/A"}</td>
+                <td class="px-4 py-2 whitespace-nowrap text-sm text-gray-500 dark:text-gray-400">${call.status_code ?? "-"}</td>
+                <td class="px-4 py-2 whitespace-nowrap text-sm text-gray-500 dark:text-gray-400">${call.latency_ms ?? "-"}</td>
                 <td class="px-4 py-2 whitespace-nowrap text-sm ${statusClass}">
                     <i class="fas ${statusIcon} mr-1"></i>
                     ${call.status}
                 </td>
+                <td class="px-4 py-2 whitespace-nowrap text-sm">${detailsBtn}</td>
             </tr>
         `;
   });
@@ -1867,67 +2187,122 @@ window.showKeyUsageDetails = async function (key) {
     return;
   }
 
-  // renderKeyUsageDetails 变为 showKeyUsageDetails 的局部函数
-  function renderKeyUsageDetails(data, container) {
-    if (!data || Object.keys(data).length === 0) {
+  // 构建内容框架（时间范围按钮 + 图表 + 表格容器）
+  const controlsHtml = `
+    <div class="flex items-center gap-2 mb-3 text-xs">
+      <button id="keyBtn1h" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700">1小时</button>
+      <button id="keyBtn8h" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700">8小时</button>
+      <button id="keyBtn24h" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700">24小时</button>
+    </div>
+    <div class="h-48 mb-4">
+      <canvas id="keyUsageChart"></canvas>
+    </div>
+    <div id="keyUsageTable"></div>`;
+  contentArea.innerHTML = controlsHtml;
+
+  // 设置标题
+  titleElement.textContent = `密钥 ${keyDisplay} - 请求详情`;
+
+  // 显示模态框
+  modal.classList.remove("hidden");
+
+  let keyUsageChart = null;
+  function buildKeyChartConfig(labels, successData, failureData) {
+    return buildChartConfig(labels, successData, failureData);
+  }
+  function bucketizeKeyDetails(period, details) {
+    return bucketizeDetails(period, details);
+  }
+  function renderKeyUsageTable(data) {
+    const container = document.getElementById('keyUsageTable');
+    if (!container) return;
+    if (!data || data.length === 0) {
       container.innerHTML = `
                 <div class="text-center py-10 text-gray-500">
                     <i class="fas fa-info-circle text-3xl"></i>
-                    <p class="mt-2">该密钥在最近24小时内没有调用记录。</p>
+                    <p class="mt-2">该时间段内没有 API 调用记录。</p>
                 </div>`;
       return;
     }
     let tableHtml = `
             <table class="min-w-full divide-y divide-gray-200">
                 <thead class="bg-gray-50">
-                    <tr>
-                        <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">模型名称</th>
-                        <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">调用次数 (24h)</th>
-                    </tr>
+                  <tr>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">时间</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">模型</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">状态码</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">耗时(ms)</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">状态</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">详情</th>
+                  </tr>
                 </thead>
                 <tbody class="bg-white divide-y divide-gray-200">`;
-    const sortedModels = Object.entries(data).sort(
-      ([, countA], [, countB]) => countB - countA
-    );
-    sortedModels.forEach(([model, count]) => {
+    data.forEach((row) => {
+      const timestamp = new Date(row.timestamp).toLocaleString();
+      const statusClass = row.status === 'success' ? 'text-success-600' : 'text-danger-600';
+      const statusIcon = row.status === 'success' ? 'fa-check-circle' : 'fa-times-circle';
+      const detailsBtn = row.status === 'failure'
+        ? `<button class="px-2 py-1 rounded bg-red-100 hover:bg-red-200 text-red-700 text-xs" onclick="fetchAndShowErrorDetailByInfo('${row.key}', ${row.status_code ?? 'null'}, '${row.timestamp}')">
+             <i class="fas fa-info-circle mr-1"></i>详情
+           </button>`
+        : '-';
       tableHtml += `
-                <tr>
-                    <td class="px-6 py-4 whitespace-nowrap text-sm font-medium text-gray-900">${model}</td>
-                    <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${count}</td>
-                </tr>`;
+        <tr>
+          <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-900">${timestamp}</td>
+          <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${row.model || 'N/A'}</td>
+          <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${row.status_code ?? '-'}</td>
+          <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${row.latency_ms ?? '-'}</td>
+          <td class="px-6 py-4 whitespace-nowrap text-sm ${statusClass}"><i class="fas ${statusIcon} mr-1"></i>${row.status}</td>
+          <td class="px-6 py-4 whitespace-nowrap text-sm">${detailsBtn}</td>
+        </tr>`;
     });
-    tableHtml += `
-                </tbody>
-            </table>`;
+    tableHtml += `</tbody></table>`;
     container.innerHTML = tableHtml;
   }
-
-  // 设置标题
-  titleElement.textContent = `密钥 ${keyDisplay} - 最近24小时请求详情`;
-
-  // 显示模态框并设置加载状态
-  modal.classList.remove("hidden");
-  contentArea.innerHTML = `
-        <div class="text-center py-10">
-             <i class="fas fa-spinner fa-spin text-primary-600 text-3xl"></i>
-             <p class="text-gray-500 mt-2">加载中...</p>
-        </div>`;
-
-  try {
-    const data = await fetchAPI(`/api/key-usage-details/${key}`);
-    if (data) {
-      renderKeyUsageDetails(data, contentArea);
-    } else {
-      renderKeyUsageDetails({}, contentArea); // Show empty state if no data
-    }
-  } catch (apiError) {
-    console.error("获取密钥使用详情失败:", apiError);
-    contentArea.innerHTML = `
-            <div class="text-center py-10 text-danger-500">
+  async function renderForPeriod(period) {
+    try {
+      const details = await fetchAPI(`/api/stats/key-details?key=${encodeURIComponent(key)}&period=${period}`);
+      const { labels, successData, failureData } = bucketizeKeyDetails(period, details || []);
+      const canvas = document.getElementById('keyUsageChart');
+      if (canvas && typeof Chart !== 'undefined') {
+        const cfg = buildKeyChartConfig(labels, successData, failureData);
+        if (keyUsageChart) keyUsageChart.destroy();
+        keyUsageChart = new Chart(canvas.getContext('2d'), cfg);
+      }
+      renderKeyUsageTable(details || []);
+    } catch (e) {
+      console.error('加载密钥期内详情失败:', e);
+      const tableContainer = document.getElementById('keyUsageTable');
+      if (tableContainer) {
+        tableContainer.innerHTML = `<div class="text-center py-10 text-danger-500">
                 <i class="fas fa-exclamation-triangle text-3xl"></i>
-                <p class="mt-2">加载失败: ${apiError.message}</p>
+                <p class="mt-2">加载失败: ${e.message}</p>
             </div>`;
+      }
+    }
   }
+
+  // 绑定按钮事件与默认加载
+  const btn1h = document.getElementById('keyBtn1h');
+  const btn8h = document.getElementById('keyBtn8h');
+  const btn24h = document.getElementById('keyBtn24h');
+  const setActive = (activeBtn) => {
+    [btn1h, btn8h, btn24h].forEach((btn) => {
+      if (!btn) return;
+      if (btn === activeBtn) {
+        btn.classList.remove('bg-gray-200');
+        btn.classList.add('bg-primary-600','text-white');
+      } else {
+        btn.classList.add('bg-gray-200');
+        btn.classList.remove('bg-primary-600','text-white');
+      }
+    });
+  };
+  if (btn1h) btn1h.addEventListener('click', () => { setActive(btn1h); renderForPeriod('1h'); });
+  if (btn8h) btn8h.addEventListener('click', () => { setActive(btn8h); renderForPeriod('8h'); });
+  if (btn24h) btn24h.addEventListener('click', () => { setActive(btn24h); renderForPeriod('24h'); });
+  if (btn1h) setActive(btn1h);
+  renderForPeriod('1h');
 };
 
 // 关闭密钥使用详情模态框

app/templates/base.html

@@ -11,14 +11,14 @@
     <meta name="apple-mobile-web-app-title" content="GBalance" />
     <link rel="icon" href="/static/icons/icon-192x192.png" />
     <link
-      href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap"
+      href="/static/css/fonts.css"
       rel="stylesheet"
     />
     <link
       rel="stylesheet"
       href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"
     />
-    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="/static/js/tailwindcss.js"></script>
     <script>
       tailwind.config = {
         theme: {

app/templates/config_editor.html

@@ -961,6 +961,29 @@ endblock %} {% block head_extra_styles %}
           <div class="array-container" id="API_KEYS_container">
             <!-- 数组项将在这里动态添加 -->
           </div>
+          <!-- API密钥分页控件 -->
+          <div id="apiKeyPagination" class="flex items-center justify-between mt-2 mb-2" style="display: none;">
+            <div class="flex items-center gap-2">
+              <button
+                type="button"
+                id="apiKeyPrevBtn"
+                class="px-3 py-1 rounded bg-blue-500 text-white hover:bg-blue-600 cursor-pointer"
+              >
+                <i class="fas fa-chevron-left"></i> 上一页
+              </button>
+              <span id="apiKeyPageInfo" class="text-sm text-gray-600">第 1 页，共 1 页</span>
+              <button
+                type="button"
+                id="apiKeyNextBtn"
+                class="px-3 py-1 rounded bg-blue-500 text-white hover:bg-blue-600 cursor-pointer"
+              >
+                下一页 <i class="fas fa-chevron-right"></i>
+              </button>
+            </div>
+            <div class="text-xs text-gray-500">
+              每页显示 20 个密钥
+            </div>
+          </div>
           <div class="flex justify-end gap-2">
             <button
               type="button"

app/templates/keys_status.html

@@ -38,6 +38,18 @@ endblock %} {% block head_extra_styles %}
     }
   }
 
+  /* 让图表卡片在网格中占满整行 */
+  .stats-card.chart-wide {
+    grid-column: 1 / -1;
+  }
+  /* 图表容器固定高度，配合 Chart.js maintainAspectRatio:false */
+  .chart-container {
+    height: 300px;
+  }
+  @media (max-width: 640px) {
+    .chart-container { height: 220px; }
+  }
+
   /* 统计卡片样式 */
   .stats-card {
     background-color: rgba(255, 255, 255, 0.95);
@@ -310,12 +322,13 @@ endblock %} {% block head_extra_styles %}
     border-color: rgba(59, 130, 246, 0.3);
   }
 
-  /* 隐藏原生复选框 */
-  .key-checkbox {
+  /* 隐藏原生复选框（仅隐藏有效/无效列表中的复选框，保留值得注意的Key列表中的复选框可见） */
+  #validKeys .key-checkbox,
+  #invalidKeys .key-checkbox {
     display: none;
   }
 
-  /* 自定义复选框样式 */
+  /* 自定义复选框样式（仅针对有效/无效列表） */
   #validKeys li::before,
   #invalidKeys li::before {
     content: "";
@@ -351,6 +364,31 @@ endblock %} {% block head_extra_styles %}
     font-size: 0.8rem;
   }
 
+  /* 值得注意的Key列表样式与选中态（保留原生复选框可见） */
+  #attentionKeysList li {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    background-color: rgba(255, 255, 255, 0.9);
+    border: 1px solid rgba(0, 0, 0, 0.08);
+    border-radius: 0.5rem;
+    padding: 0.5rem 0.75rem;
+    transition: all 0.2s ease;
+    cursor: pointer;
+  }
+  #attentionKeysList li:hover {
+    border-color: rgba(0, 0, 0, 0.12);
+    box-shadow: 0 4px 12px rgba(0,0,0,0.08);
+    background-color: rgba(249, 250, 251, 0.95);
+  }
+  #attentionKeysList li.selected {
+    background-color: rgba(239, 246, 255, 0.95); /* light blue */
+    border-color: rgba(59, 130, 246, 0.35);
+  }
+  #attentionKeysList .key-checkbox {
+    margin-right: 0.25rem;
+  }
+
   .key-text {
     color: #374151 !important; /* gray-700 for light theme */
     text-shadow: none;
@@ -1096,31 +1134,15 @@ endblock %} {% block head_extra_styles %}
   }
 </style>
 {% endblock %} {% block head_extra_scripts %}
-<!-- keys_status.js needs to be loaded in head because it might be used by inline scripts -->
-<script src="/static/js/keys_status.js"></script>
+<!-- Chart.js for time-series chart -->
+<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js" defer></script>
+<!-- Load page script with defer to guarantee DOM is ready and keep execution order -->
+<script src="/static/js/keys_status.js" defer></script>
 {% endblock %} {% block content %}
 <div class="container max-w-6xl mx-auto px-4">
   <!-- Increased max-width -->
   <div class="glass-card rounded-2xl shadow-xl p-6 md:p-8">
     <div class="absolute top-6 right-6 flex items-center gap-3">
-      <!-- 自动刷新开关 -->
-      <div class="flex items-center text-sm select-none font-semibold" style="color: #1f2937 !important;">
-        <span class="mr-2">自动刷新</span>
-        <div
-          class="relative inline-block w-10 mr-2 align-middle select-none transition duration-200 ease-in"
-        >
-          <input
-            type="checkbox"
-            name="autoRefreshToggle"
-            id="autoRefreshToggle"
-            class="toggle-checkbox absolute block w-6 h-6 rounded-full bg-white border-4 appearance-none cursor-pointer"
-          />
-          <label
-            for="autoRefreshToggle"
-            class="toggle-label block overflow-hidden h-6 rounded-full bg-gray-300 cursor-pointer"
-          ></label>
-        </div>
-      </div>
       <!-- 手动刷新按钮 -->
       <button
         class="bg-white bg-opacity-20 hover:bg-opacity-30 rounded-full w-8 h-8 flex items-center justify-center text-primary-600 transition-all duration-300"
@@ -1263,7 +1285,94 @@ endblock %} {% block head_extra_styles %}
           </div>
         </div>
       </div>
+
+      <!-- 可切换时间区间的成功/失败图表卡片 -->
+      <div class="stats-card chart-wide">
+        <div class="stats-card-header">
+          <h3 class="stats-card-title">
+            <i class="fas fa-chart-bar"></i>
+            <span>调用趋势图</span>
+          </h3>
+          <div class="flex items-center gap-2 text-xs">
+            <button id="chartBtn1h" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700">1小时</button>
+            <button id="chartBtn8h" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700">8小时</button>
+            <button id="chartBtn24h" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700">24小时</button>
+          </div>
+        </div>
+        <div class="p-4 chart-container">
+          <canvas id="apiStatsChart"></canvas>
+        </div>
+      </div>
+
+      <!-- 值得注意的 Key 卡片（错误码统计，可切换） -->
+      <div class="stats-card chart-wide">
+        <div class="stats-card-header">
+          <h3 class="stats-card-title">
+            <i class="fas fa-exclamation-circle"></i>
+            <span>值得注意的Key（24h内错误码最多）</span>
+          </h3>
+          <div class="flex items-center gap-2 text-xs">
+            <button id="attentionErr429" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700" title="429 Too Many Requests">429</button>
+            <button id="attentionErr403" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700" title="403 Forbidden">403</button>
+            <button id="attentionErr400" class="px-2 py-1 rounded bg-gray-200 hover:bg-gray-300 text-gray-700" title="400 Bad Request">400</button>
+            <div class="flex items-center gap-1 ml-2">
+              <input id="attentionErrCustom" type="number" min="100" max="599" placeholder="自定义" class="form-input h-7 w-20 px-2 py-1 text-xs border rounded focus:ring-primary-500 focus:border-primary-500" />
+              <button id="attentionErrGo" class="px-2 py-1 rounded bg-blue-500 hover:bg-blue-600 text-white" title="查询">查询</button>
+            </div>
+            <div class="flex items-center gap-2 ml-3">
+              <label for="attentionLimitInput" class="text-xs text-gray-600">数量</label>
+              <input id="attentionLimitInput" type="number" min="1" max="1000" value="10" class="form-input h-7 w-20 px-2 py-1 text-xs border rounded focus:ring-primary-500 focus:border-primary-500" />
+              <!-- 全选移动到数量输入框右侧 -->
+              <div class="flex items-center gap-1">
+                <input
+                  type="checkbox"
+                  id="selectAllAttention"
+                  class="form-checkbox h-4 w-4 text-primary-600 border-gray-300 rounded focus:ring-primary-500"
+                  onchange="toggleSelectAll('attention', this.checked)"
+                />
+                <label for="selectAllAttention" class="text-xs select-none whitespace-nowrap font-semibold" style="color: #1f2937 !important;">全选</label>
+              </div>
+            </div>
+          </div>
+        </div>
+      <div class="p-4">
+        <!-- 批量操作按钮组 (仅在选中时显示) -->
+        <div
+          id="attentionBatchActions"
+          class="p-3 border mb-3 hidden flex items-center flex-wrap gap-3"
+          style="background-color: rgba(249, 250, 251, 0.95); border-color: rgba(0, 0, 0, 0.08);"
+        >
+          <span class="text-sm font-semibold whitespace-nowrap" style="color: #1f2937 !important;">
+            已选择 <span id="attentionSelectedCount">0</span> 项
+          </span>
+          <button
+            class="flex items-center gap-1 bg-success-600 hover:bg-success-700 text-white px-2.5 py-1 rounded-lg text-xs font-medium transition-all duration-200 disabled:cursor-not-allowed"
+            onclick="event.stopPropagation(); showVerifyModal('attention', event)"
+            disabled
+          >
+            <i class="fas fa-check-double"></i> 批量验证
+          </button>
+          <button
+            class="flex items-center gap-1 bg-blue-500 hover:bg-blue-600 text-white px-2.5 py-1 rounded-lg text-xs font-medium transition-all duration-200 disabled:cursor-not-allowed"
+            onclick="event.stopPropagation(); copySelectedKeys('attention')"
+            disabled
+          >
+            <i class="fas fa-copy"></i> 批量复制
+          </button>
+          <button
+            class="flex items-center gap-1 bg-red-800 hover:bg-red-900 text-white px-2.5 py-1 rounded-lg text-xs font-medium transition-all duration-200 disabled:cursor-not-allowed"
+            onclick="event.stopPropagation(); showDeleteConfirmationModal('attention', event)"
+            disabled
+          >
+            <i class="fas fa-trash-alt"></i> 批量删除
+          </button>
+        </div>
+        <ul id="attentionKeysList" class="space-y-2">
+          <li class="text-center text-gray-500 py-2">加载中...</li>
+        </ul>
+      </div>
     </div>
+  </div>
 
     <!-- 有效密钥区域 -->
     <div class="stats-card mb-6 animate-fade-in" style="animation-delay: 0.2s">
@@ -1873,7 +1982,8 @@ endblock %} {% block head_extra_styles %}
 <!-- 操作结果模态框 -->
 <div
   id="resultModal"
-  class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 hidden"
+  class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center hidden"
+  style="z-index: 1001;"
 >
   <div
     class="bg-white rounded-2xl p-0 shadow-2xl max-w-lg w-full animate-fade-in border border-gray-200"