refactor: 重构限流系统和健康监控，支持按 API 格式区分

- 将 adaptive_concurrency 重命名为 adaptive_rpm，从并发控制改为 RPM 控制
- 健康监控器支持按 API 格式独立管理健康度和熔断器状态
- 新增 model_permissions 模块，支持按格式配置允许的模型
- 重构前端提供商相关表单组件，新增 Collapsible UI 组件
- 新增数据库迁移脚本支持新的数据结构

src/api/admin/endpoints/keys.py

@@ -1,5 +1,5 @@
 """
-Endpoint API Keys 管理
+Provider API Keys 管理
 """
 
 import uuid
@@ -12,6 +12,7 @@ from sqlalchemy.orm import Session
 
 from src.api.base.admin_adapter import AdminApiAdapter
 from src.api.base.pipeline import ApiRequestPipeline
+from src.config.constants import RPMDefaults
 from src.core.crypto import crypto_service
 from src.core.exceptions import InvalidRequestException, NotFoundException
 from src.core.key_capabilities import get_capability
@@ -20,96 +21,14 @@ from src.database import get_db
 from src.models.database import Provider, ProviderAPIKey, ProviderEndpoint
 from src.services.cache.provider_cache import ProviderCacheService
 from src.models.endpoint_models import (
-    BatchUpdateKeyPriorityRequest,
     EndpointAPIKeyCreate,
     EndpointAPIKeyResponse,
     EndpointAPIKeyUpdate,
 )
 
-router = APIRouter(tags=["Endpoint Keys"])
+router = APIRouter(tags=["Provider Keys"])
 pipeline = ApiRequestPipeline()
 
-
-@router.get("/{endpoint_id}/keys", response_model=List[EndpointAPIKeyResponse])
-async def list_endpoint_keys(
-    endpoint_id: str,
-    request: Request,
-    skip: int = Query(0, ge=0, description="跳过的记录数"),
-    limit: int = Query(100, ge=1, le=1000, description="返回的最大记录数"),
-    db: Session = Depends(get_db),
-) -> List[EndpointAPIKeyResponse]:
-    """
-    获取 Endpoint 的所有 Keys
-
-    获取指定 Endpoint 下的所有 API Key 列表，包括 Key 的配置、统计信息等。
-    结果按优先级和创建时间排序。
-
-    **路径参数**:
-    - `endpoint_id`: Endpoint ID
-
-    **查询参数**:
-    - `skip`: 跳过的记录数，用于分页（默认 0）
-    - `limit`: 返回的最大记录数（1-1000，默认 100）
-
-    **返回字段**:
-    - `id`: Key ID
-    - `name`: Key 名称
-    - `api_key_masked`: 脱敏后的 API Key
-    - `internal_priority`: 内部优先级
-    - `global_priority`: 全局优先级
-    - `rate_multiplier`: 速率倍数
-    - `max_concurrent`: 最大并发数（null 表示自适应模式）
-    - `is_adaptive`: 是否为自适应并发模式
-    - `effective_limit`: 有效并发限制
-    - `success_rate`: 成功率
-    - `avg_response_time_ms`: 平均响应时间（毫秒）
-    - 其他配置和统计字段
-    """
-    adapter = AdminListEndpointKeysAdapter(
-        endpoint_id=endpoint_id,
-        skip=skip,
-        limit=limit,
-    )
-    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
-
-
-@router.post("/{endpoint_id}/keys", response_model=EndpointAPIKeyResponse)
-async def add_endpoint_key(
-    endpoint_id: str,
-    key_data: EndpointAPIKeyCreate,
-    request: Request,
-    db: Session = Depends(get_db),
-) -> EndpointAPIKeyResponse:
-    """
-    为 Endpoint 添加 Key
-
-    为指定 Endpoint 添加新的 API Key，支持配置并发限制、速率倍数、
-    优先级、配额限制、能力限制等。
-
-    **路径参数**:
-    - `endpoint_id`: Endpoint ID
-
-    **请求体字段**:
-    - `endpoint_id`: Endpoint ID（必须与路径参数一致）
-    - `api_key`: API Key 原文（将被加密存储）
-    - `name`: Key 名称
-    - `note`: 备注（可选）
-    - `rate_multiplier`: 速率倍数（默认 1.0）
-    - `internal_priority`: 内部优先级（默认 100）
-    - `max_concurrent`: 最大并发数（null 表示自适应模式）
-    - `rate_limit`: 每分钟请求限制（可选）
-    - `daily_limit`: 每日请求限制（可选）
-    - `monthly_limit`: 每月请求限制（可选）
-    - `allowed_models`: 允许的模型列表（可选）
-    - `capabilities`: 能力配置（可选）
-
-    **返回字段**:
-    - 包含完整的 Key 信息，其中 `api_key_plain` 为原文（仅在创建时返回）
-    """
-    adapter = AdminCreateEndpointKeyAdapter(endpoint_id=endpoint_id, key_data=key_data)
-    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
-
-
 @router.put("/keys/{key_id}", response_model=EndpointAPIKeyResponse)
 async def update_endpoint_key(
     key_id: str,
@@ -118,7 +37,7 @@ async def update_endpoint_key(
     db: Session = Depends(get_db),
 ) -> EndpointAPIKeyResponse:
     """
-    更新 Endpoint Key
+    更新 Provider Key
 
     更新指定 Key 的配置，支持修改并发限制、速率倍数、优先级、
     配额限制、能力限制等。支持部分更新。
@@ -132,10 +51,7 @@ async def update_endpoint_key(
     - `note`: 备注
     - `rate_multiplier`: 速率倍数
     - `internal_priority`: 内部优先级
-    - `max_concurrent`: 最大并发数（设置为 null 可切换到自适应模式）
-    - `rate_limit`: 每分钟请求限制
-    - `daily_limit`: 每日请求限制
-    - `monthly_limit`: 每月请求限制
+    - `rpm_limit`: RPM 限制（设置为 null 可切换到自适应模式）
     - `allowed_models`: 允许的模型列表
     - `capabilities`: 能力配置
     - `is_active`: 是否活跃
@@ -210,7 +126,7 @@ async def delete_endpoint_key(
     db: Session = Depends(get_db),
 ) -> dict:
     """
-    删除 Endpoint Key
+    删除 Provider Key
 
     删除指定的 API Key。此操作不可逆，请谨慎使用。
 
@@ -224,163 +140,66 @@ async def delete_endpoint_key(
     return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
 
 
-@router.put("/{endpoint_id}/keys/batch-priority")
-async def batch_update_key_priority(
-    endpoint_id: str,
-    request: Request,
-    priority_data: BatchUpdateKeyPriorityRequest,
-    db: Session = Depends(get_db),
-) -> dict:
-    """
-    批量更新 Endpoint 下 Keys 的优先级
+# ========== Provider Keys API ==========
 
-    批量更新指定 Endpoint 下多个 Key 的内部优先级，用于拖动排序。
-    所有 Key 必须属于指定的 Endpoint。
+
+@router.get("/providers/{provider_id}/keys", response_model=List[EndpointAPIKeyResponse])
+async def list_provider_keys(
+    provider_id: str,
+    request: Request,
+    skip: int = Query(0, ge=0, description="跳过的记录数"),
+    limit: int = Query(100, ge=1, le=1000, description="返回的最大记录数"),
+    db: Session = Depends(get_db),
+) -> List[EndpointAPIKeyResponse]:
+    """
+    获取 Provider 的所有 Keys
+
+    获取指定 Provider 下的所有 API Key 列表，支持多 API 格式。
+    结果按优先级和创建时间排序。
 
     **路径参数**:
-    - `endpoint_id`: Endpoint ID
+    - `provider_id`: Provider ID
+
+    **查询参数**:
+    - `skip`: 跳过的记录数，用于分页（默认 0）
+    - `limit`: 返回的最大记录数（1-1000，默认 100）
+    """
+    adapter = AdminListProviderKeysAdapter(
+        provider_id=provider_id,
+        skip=skip,
+        limit=limit,
+    )
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.post("/providers/{provider_id}/keys", response_model=EndpointAPIKeyResponse)
+async def add_provider_key(
+    provider_id: str,
+    key_data: EndpointAPIKeyCreate,
+    request: Request,
+    db: Session = Depends(get_db),
+) -> EndpointAPIKeyResponse:
+    """
+    为 Provider 添加 Key
+
+    为指定 Provider 添加新的 API Key，支持配置多个 API 格式。
+
+    **路径参数**:
+    - `provider_id`: Provider ID
 
     **请求体字段**:
-    - `priorities`: 优先级列表
-      - `key_id`: Key ID
-      - `internal_priority`: 新的内部优先级
-
-    **返回字段**:
-    - `message`: 操作结果消息
-    - `updated_count`: 实际更新的 Key 数量
+    - `api_formats`: 支持的 API 格式列表（必填）
+    - `api_key`: API Key 原文（将被加密存储）
+    - `name`: Key 名称
+    - 其他配置字段同 Key
     """
-    adapter = AdminBatchUpdateKeyPriorityAdapter(endpoint_id=endpoint_id, priority_data=priority_data)
+    adapter = AdminCreateProviderKeyAdapter(provider_id=provider_id, key_data=key_data)
     return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
 
 
 # -------- Adapters --------
 
 
-@dataclass
-class AdminListEndpointKeysAdapter(AdminApiAdapter):
-    endpoint_id: str
-    skip: int
-    limit: int
-
-    async def handle(self, context):  # type: ignore[override]
-        db = context.db
-        endpoint = (
-            db.query(ProviderEndpoint).filter(ProviderEndpoint.id == self.endpoint_id).first()
-        )
-        if not endpoint:
-            raise NotFoundException(f"Endpoint {self.endpoint_id} 不存在")
-
-        keys = (
-            db.query(ProviderAPIKey)
-            .filter(ProviderAPIKey.endpoint_id == self.endpoint_id)
-            .order_by(ProviderAPIKey.internal_priority.asc(), ProviderAPIKey.created_at.asc())
-            .offset(self.skip)
-            .limit(self.limit)
-            .all()
-        )
-
-        result: List[EndpointAPIKeyResponse] = []
-        for key in keys:
-            try:
-                decrypted_key = crypto_service.decrypt(key.api_key)
-                masked_key = f"{decrypted_key[:8]}***{decrypted_key[-4:]}"
-            except Exception:
-                masked_key = "***ERROR***"
-
-            success_rate = key.success_count / key.request_count if key.request_count > 0 else 0.0
-            avg_response_time_ms = (
-                key.total_response_time_ms / key.success_count if key.success_count > 0 else 0.0
-            )
-
-            is_adaptive = key.max_concurrent is None
-            key_dict = key.__dict__.copy()
-            key_dict.pop("_sa_instance_state", None)
-            key_dict.update(
-                {
-                    "api_key_masked": masked_key,
-                    "api_key_plain": None,
-                    "success_rate": success_rate,
-                    "avg_response_time_ms": round(avg_response_time_ms, 2),
-                    "is_adaptive": is_adaptive,
-                    "effective_limit": (
-                        key.learned_max_concurrent if is_adaptive else key.max_concurrent
-                    ),
-                }
-            )
-            result.append(EndpointAPIKeyResponse(**key_dict))
-
-        return result
-
-
-@dataclass
-class AdminCreateEndpointKeyAdapter(AdminApiAdapter):
-    endpoint_id: str
-    key_data: EndpointAPIKeyCreate
-
-    async def handle(self, context):  # type: ignore[override]
-        db = context.db
-        endpoint = (
-            db.query(ProviderEndpoint).filter(ProviderEndpoint.id == self.endpoint_id).first()
-        )
-        if not endpoint:
-            raise NotFoundException(f"Endpoint {self.endpoint_id} 不存在")
-
-        if self.key_data.endpoint_id != self.endpoint_id:
-            raise InvalidRequestException("endpoint_id 不匹配")
-
-        encrypted_key = crypto_service.encrypt(self.key_data.api_key)
-        now = datetime.now(timezone.utc)
-        # max_concurrent=NULL 表示自适应模式，数字表示固定限制
-        new_key = ProviderAPIKey(
-            id=str(uuid.uuid4()),
-            endpoint_id=self.endpoint_id,
-            api_key=encrypted_key,
-            name=self.key_data.name,
-            note=self.key_data.note,
-            rate_multiplier=self.key_data.rate_multiplier,
-            internal_priority=self.key_data.internal_priority,
-            max_concurrent=self.key_data.max_concurrent,  # NULL=自适应模式
-            rate_limit=self.key_data.rate_limit,
-            daily_limit=self.key_data.daily_limit,
-            monthly_limit=self.key_data.monthly_limit,
-            allowed_models=self.key_data.allowed_models if self.key_data.allowed_models else None,
-            capabilities=self.key_data.capabilities if self.key_data.capabilities else None,
-            request_count=0,
-            success_count=0,
-            error_count=0,
-            total_response_time_ms=0,
-            is_active=True,
-            last_used_at=None,
-            created_at=now,
-            updated_at=now,
-        )
-
-        db.add(new_key)
-        db.commit()
-        db.refresh(new_key)
-
-        logger.info(f"[OK] 添加 Key: Endpoint={self.endpoint_id}, Key=***{self.key_data.api_key[-4:]}, ID={new_key.id}")
-
-        masked_key = f"{self.key_data.api_key[:8]}***{self.key_data.api_key[-4:]}"
-        is_adaptive = new_key.max_concurrent is None
-        response_dict = new_key.__dict__.copy()
-        response_dict.pop("_sa_instance_state", None)
-        response_dict.update(
-            {
-                "api_key_masked": masked_key,
-                "api_key_plain": self.key_data.api_key,
-                "success_rate": 0.0,
-                "avg_response_time_ms": 0.0,
-                "is_adaptive": is_adaptive,
-                "effective_limit": (
-                    new_key.learned_max_concurrent if is_adaptive else new_key.max_concurrent
-                ),
-            }
-        )
-
-        return EndpointAPIKeyResponse(**response_dict)
-
-
 @dataclass
 class AdminUpdateEndpointKeyAdapter(AdminApiAdapter):
     key_id: str
@@ -396,14 +215,21 @@ class AdminUpdateEndpointKeyAdapter(AdminApiAdapter):
         if "api_key" in update_data:
             update_data["api_key"] = crypto_service.encrypt(update_data["api_key"])
 
-        # 特殊处理 max_concurrent：需要区分"未提供"和"显式设置为 null"
-        # 当 max_concurrent 被显式设置时（在 model_fields_set 中），即使值为 None 也应该更新
-        if "max_concurrent" in self.key_data.model_fields_set:
-            update_data["max_concurrent"] = self.key_data.max_concurrent
-            # 切换到自适应模式时，清空学习到的并发限制，让系统重新学习
-            if self.key_data.max_concurrent is None:
-                update_data["learned_max_concurrent"] = None
-                logger.info("Key %s 切换为自适应并发模式", self.key_id)
+        # 特殊处理 rpm_limit：需要区分"未提供"和"显式设置为 null"
+        if "rpm_limit" in self.key_data.model_fields_set:
+            update_data["rpm_limit"] = self.key_data.rpm_limit
+            if self.key_data.rpm_limit is None:
+                update_data["learned_rpm_limit"] = None
+                logger.info("Key %s 切换为自适应 RPM 模式", self.key_id)
+
+        # 统一处理 allowed_models：空列表/空字典 -> None（表示不限制）
+        if "allowed_models" in update_data:
+            am = update_data["allowed_models"]
+            if am is not None and (
+                (isinstance(am, list) and len(am) == 0)
+                or (isinstance(am, dict) and len(am) == 0)
+            ):
+                update_data["allowed_models"] = None
 
         for field, value in update_data.items():
             setattr(key, field, value)
@@ -412,39 +238,13 @@ class AdminUpdateEndpointKeyAdapter(AdminApiAdapter):
         db.commit()
         db.refresh(key)
 
-        # 如果更新了 rate_multiplier，清除缓存
-        if "rate_multiplier" in update_data:
-            await ProviderCacheService.invalidate_provider_api_key_cache(self.key_id)
+        # 任何字段更新都清除缓存，确保缓存一致性
+        # 包括 is_active、allowed_models、capabilities 等影响权限和行为的字段
+        await ProviderCacheService.invalidate_provider_api_key_cache(self.key_id)
 
         logger.info("[OK] 更新 Key: ID=%s, Updates=%s", self.key_id, list(update_data.keys()))
 
-        try:
-            decrypted_key = crypto_service.decrypt(key.api_key)
-            masked_key = f"{decrypted_key[:8]}***{decrypted_key[-4:]}"
-        except Exception:
-            masked_key = "***ERROR***"
-
-        success_rate = key.success_count / key.request_count if key.request_count > 0 else 0.0
-        avg_response_time_ms = (
-            key.total_response_time_ms / key.success_count if key.success_count > 0 else 0.0
-        )
-
-        is_adaptive = key.max_concurrent is None
-        response_dict = key.__dict__.copy()
-        response_dict.pop("_sa_instance_state", None)
-        response_dict.update(
-            {
-                "api_key_masked": masked_key,
-                "api_key_plain": None,
-                "success_rate": success_rate,
-                "avg_response_time_ms": round(avg_response_time_ms, 2),
-                "is_adaptive": is_adaptive,
-                "effective_limit": (
-                    key.learned_max_concurrent if is_adaptive else key.max_concurrent
-                ),
-            }
-        )
-        return EndpointAPIKeyResponse(**response_dict)
+        return _build_key_response(key)
 
 
 @dataclass
@@ -481,7 +281,7 @@ class AdminDeleteEndpointKeyAdapter(AdminApiAdapter):
         if not key:
             raise NotFoundException(f"Key {self.key_id} 不存在")
 
-        endpoint_id = key.endpoint_id
+        provider_id = key.provider_id
         try:
             db.delete(key)
             db.commit()
@@ -490,7 +290,7 @@ class AdminDeleteEndpointKeyAdapter(AdminApiAdapter):
             logger.error(f"删除 Key 失败: ID={self.key_id}, Error={exc}")
             raise
 
-        logger.warning(f"[DELETE] 删除 Key: ID={self.key_id}, Endpoint={endpoint_id}")
+        logger.warning(f"[DELETE] 删除 Key: ID={self.key_id}, Provider={provider_id}")
         return {"message": f"Key {self.key_id} 已删除"}
 
 
@@ -498,31 +298,51 @@ class AdminGetKeysGroupedByFormatAdapter(AdminApiAdapter):
     async def handle(self, context):  # type: ignore[override]
         db = context.db
 
+        # Key 属于 Provider：按 key.api_formats 分组展示
         keys = (
-            db.query(ProviderAPIKey, ProviderEndpoint, Provider)
-            .join(ProviderEndpoint, ProviderAPIKey.endpoint_id == ProviderEndpoint.id)
-            .join(Provider, ProviderEndpoint.provider_id == Provider.id)
+            db.query(ProviderAPIKey, Provider)
+            .join(Provider, ProviderAPIKey.provider_id == Provider.id)
             .filter(
                 ProviderAPIKey.is_active.is_(True),
-                ProviderEndpoint.is_active.is_(True),
                 Provider.is_active.is_(True),
             )
             .order_by(
-                ProviderAPIKey.global_priority.asc().nullslast(), ProviderAPIKey.internal_priority.asc()
+                ProviderAPIKey.global_priority.asc().nullslast(),
+                ProviderAPIKey.internal_priority.asc(),
             )
             .all()
         )
 
+        provider_ids = {str(provider.id) for _key, provider in keys}
+        endpoints = (
+            db.query(
+                ProviderEndpoint.provider_id,
+                ProviderEndpoint.api_format,
+                ProviderEndpoint.base_url,
+            )
+            .filter(
+                ProviderEndpoint.provider_id.in_(provider_ids),
+                ProviderEndpoint.is_active.is_(True),
+            )
+            .all()
+        )
+        endpoint_base_url_map: Dict[tuple[str, str], str] = {}
+        for provider_id, api_format, base_url in endpoints:
+            fmt = api_format.value if hasattr(api_format, "value") else str(api_format)
+            endpoint_base_url_map[(str(provider_id), fmt)] = base_url
+
         grouped: Dict[str, List[dict]] = {}
-        for key, endpoint, provider in keys:
-            api_format = endpoint.api_format
-            if api_format not in grouped:
-                grouped[api_format] = []
+        for key, provider in keys:
+            api_formats = key.api_formats or []
+
+            if not api_formats:
+                continue  # 跳过没有 API 格式的 Key
 
             try:
                 decrypted_key = crypto_service.decrypt(key.api_key)
                 masked_key = f"{decrypted_key[:8]}***{decrypted_key[-4:]}"
-            except Exception:
+            except Exception as e:
+                logger.error(f"解密 Key 失败: key_id={key.id}, error={e}")
                 masked_key = "***ERROR***"
 
             # 计算健康度指标
@@ -541,73 +361,209 @@ class AdminGetKeysGroupedByFormatAdapter(AdminApiAdapter):
                         cap_def = get_capability(cap_name)
                         caps_list.append(cap_def.short_name if cap_def else cap_name)
 
-            grouped[api_format].append(
-                {
-                    "id": key.id,
-                    "name": key.name,
-                    "api_key_masked": masked_key,
-                    "internal_priority": key.internal_priority,
-                    "global_priority": key.global_priority,
-                    "rate_multiplier": key.rate_multiplier,
-                    "is_active": key.is_active,
-                    "circuit_breaker_open": key.circuit_breaker_open,
-                    "provider_name": provider.display_name or provider.name,
-                    "endpoint_base_url": endpoint.base_url,
-                    "api_format": api_format,
-                    "capabilities": caps_list,
-                    "health_score": key.health_score,
-                    "success_rate": success_rate,
-                    "avg_response_time_ms": avg_response_time_ms,
-                    "request_count": key.request_count,
-                }
-            )
+            # 构建 Key 信息（基础数据）
+            key_info = {
+                "id": key.id,
+                "name": key.name,
+                "api_key_masked": masked_key,
+                "internal_priority": key.internal_priority,
+                "global_priority": key.global_priority,
+                "rate_multiplier": key.rate_multiplier,
+                "is_active": key.is_active,
+                "provider_name": provider.name,
+                "api_formats": api_formats,
+                "capabilities": caps_list,
+                "success_rate": success_rate,
+                "avg_response_time_ms": avg_response_time_ms,
+                "request_count": key.request_count,
+            }
+
+            # 将 Key 添加到每个支持的格式分组中，并附加格式特定的健康度数据
+            health_by_format = key.health_by_format or {}
+            circuit_by_format = key.circuit_breaker_by_format or {}
+            provider_id = str(provider.id)
+            for api_format in api_formats:
+                if api_format not in grouped:
+                    grouped[api_format] = []
+                # 为每个格式创建副本，设置当前格式
+                format_key_info = key_info.copy()
+                format_key_info["api_format"] = api_format
+                format_key_info["endpoint_base_url"] = endpoint_base_url_map.get(
+                    (provider_id, api_format)
+                )
+                # 添加格式特定的健康度数据
+                format_health = health_by_format.get(api_format, {})
+                format_circuit = circuit_by_format.get(api_format, {})
+                format_key_info["health_score"] = float(format_health.get("health_score") or 1.0)
+                format_key_info["circuit_breaker_open"] = bool(format_circuit.get("open", False))
+                grouped[api_format].append(format_key_info)
 
         # 直接返回分组对象，供前端使用
         return grouped
 
 
+# ========== Adapters ==========
+
+
+def _build_key_response(
+    key: ProviderAPIKey, api_key_plain: str | None = None
+) -> EndpointAPIKeyResponse:
+    """构建 Key 响应对象的辅助函数"""
+    try:
+        decrypted_key = crypto_service.decrypt(key.api_key)
+        masked_key = f"{decrypted_key[:8]}***{decrypted_key[-4:]}"
+    except Exception:
+        masked_key = "***ERROR***"
+
+    success_rate = key.success_count / key.request_count if key.request_count > 0 else 0.0
+    avg_response_time_ms = (
+        key.total_response_time_ms / key.success_count if key.success_count > 0 else 0.0
+    )
+
+    is_adaptive = key.rpm_limit is None
+    key_dict = key.__dict__.copy()
+    key_dict.pop("_sa_instance_state", None)
+
+    # 从 health_by_format 计算汇总字段（便于列表展示）
+    health_by_format = key.health_by_format or {}
+    circuit_by_format = key.circuit_breaker_by_format or {}
+
+    # 计算整体健康度（取所有格式中的最低值）
+    if health_by_format:
+        health_scores = [
+            float(h.get("health_score") or 1.0) for h in health_by_format.values()
+        ]
+        min_health_score = min(health_scores) if health_scores else 1.0
+        # 取最大的连续失败次数
+        max_consecutive = max(
+            (int(h.get("consecutive_failures") or 0) for h in health_by_format.values()),
+            default=0,
+        )
+        # 取最近的失败时间
+        failure_times = [
+            h.get("last_failure_at")
+            for h in health_by_format.values()
+            if h.get("last_failure_at")
+        ]
+        last_failure = max(failure_times) if failure_times else None
+    else:
+        min_health_score = 1.0
+        max_consecutive = 0
+        last_failure = None
+
+    # 检查是否有任何格式的熔断器打开
+    any_circuit_open = any(c.get("open", False) for c in circuit_by_format.values())
+
+    key_dict.update(
+        {
+            "api_key_masked": masked_key,
+            "api_key_plain": api_key_plain,
+            "success_rate": success_rate,
+            "avg_response_time_ms": round(avg_response_time_ms, 2),
+            "is_adaptive": is_adaptive,
+            "effective_limit": (
+                (key.learned_rpm_limit if key.learned_rpm_limit is not None else RPMDefaults.INITIAL_LIMIT)
+                if is_adaptive
+                else key.rpm_limit
+            ),
+            # 汇总字段
+            "health_score": min_health_score,
+            "consecutive_failures": max_consecutive,
+            "last_failure_at": last_failure,
+            "circuit_breaker_open": any_circuit_open,
+        }
+    )
+
+    # 防御性：确保 api_formats 存在（历史数据可能为空/缺失）
+    if "api_formats" not in key_dict or key_dict["api_formats"] is None:
+        key_dict["api_formats"] = []
+
+    return EndpointAPIKeyResponse(**key_dict)
+
+
 @dataclass
-class AdminBatchUpdateKeyPriorityAdapter(AdminApiAdapter):
-    endpoint_id: str
-    priority_data: BatchUpdateKeyPriorityRequest
+class AdminListProviderKeysAdapter(AdminApiAdapter):
+    """获取 Provider 的所有 Keys"""
+
+    provider_id: str
+    skip: int
+    limit: int
 
     async def handle(self, context):  # type: ignore[override]
         db = context.db
-        endpoint = (
-            db.query(ProviderEndpoint).filter(ProviderEndpoint.id == self.endpoint_id).first()
-        )
-        if not endpoint:
-            raise NotFoundException(f"Endpoint {self.endpoint_id} 不存在")
+        provider = db.query(Provider).filter(Provider.id == self.provider_id).first()
+        if not provider:
+            raise NotFoundException(f"Provider {self.provider_id} 不存在")
 
-        # 获取所有需要更新的 Key ID
-        key_ids = [item.key_id for item in self.priority_data.priorities]
-
-        # 验证所有 Key 都属于该 Endpoint
         keys = (
             db.query(ProviderAPIKey)
-            .filter(
-                ProviderAPIKey.id.in_(key_ids),
-                ProviderAPIKey.endpoint_id == self.endpoint_id,
-            )
+            .filter(ProviderAPIKey.provider_id == self.provider_id)
+            .order_by(ProviderAPIKey.internal_priority.asc(), ProviderAPIKey.created_at.asc())
+            .offset(self.skip)
+            .limit(self.limit)
             .all()
         )
 
-        if len(keys) != len(key_ids):
-            found_ids = {k.id for k in keys}
-            missing_ids = set(key_ids) - found_ids
-            raise InvalidRequestException(f"Keys 不属于该 Endpoint 或不存在: {missing_ids}")
+        return [_build_key_response(key) for key in keys]
 
-        # 批量更新优先级
-        key_map = {k.id: k for k in keys}
-        updated_count = 0
-        for item in self.priority_data.priorities:
-            key = key_map.get(item.key_id)
-            if key and key.internal_priority != item.internal_priority:
-                key.internal_priority = item.internal_priority
-                key.updated_at = datetime.now(timezone.utc)
-                updated_count += 1
 
+@dataclass
+class AdminCreateProviderKeyAdapter(AdminApiAdapter):
+    """为 Provider 添加 Key"""
+
+    provider_id: str
+    key_data: EndpointAPIKeyCreate
+
+    async def handle(self, context):  # type: ignore[override]
+        db = context.db
+        provider = db.query(Provider).filter(Provider.id == self.provider_id).first()
+        if not provider:
+            raise NotFoundException(f"Provider {self.provider_id} 不存在")
+
+        # 验证 api_formats 必填
+        if not self.key_data.api_formats:
+            raise InvalidRequestException("api_formats 为必填字段")
+
+        # 允许同一个 API Key 在同一 Provider 下添加多次
+        # 用户可以为不同的 API 格式创建独立的配置记录，便于分开管理
+
+        encrypted_key = crypto_service.encrypt(self.key_data.api_key)
+        now = datetime.now(timezone.utc)
+
+        new_key = ProviderAPIKey(
+            id=str(uuid.uuid4()),
+            provider_id=self.provider_id,
+            api_formats=self.key_data.api_formats,
+            api_key=encrypted_key,
+            name=self.key_data.name,
+            note=self.key_data.note,
+            rate_multiplier=self.key_data.rate_multiplier,
+            rate_multipliers=self.key_data.rate_multipliers,  # 按 API 格式的成本倍率
+            internal_priority=self.key_data.internal_priority,
+            rpm_limit=self.key_data.rpm_limit,
+            allowed_models=self.key_data.allowed_models if self.key_data.allowed_models else None,
+            capabilities=self.key_data.capabilities if self.key_data.capabilities else None,
+            cache_ttl_minutes=self.key_data.cache_ttl_minutes,
+            max_probe_interval_minutes=self.key_data.max_probe_interval_minutes,
+            request_count=0,
+            success_count=0,
+            error_count=0,
+            total_response_time_ms=0,
+            health_by_format={},  # 按格式存储健康度
+            circuit_breaker_by_format={},  # 按格式存储熔断器状态
+            is_active=True,
+            last_used_at=None,
+            created_at=now,
+            updated_at=now,
+        )
+
+        db.add(new_key)
         db.commit()
+        db.refresh(new_key)
 
-        logger.info(f"[OK] 批量更新 Key 优先级: Endpoint={self.endpoint_id}, Updated={updated_count}/{len(key_ids)}")
-        return {"message": f"已更新 {updated_count} 个 Key 的优先级", "updated_count": updated_count}
+        logger.info(
+            f"[OK] 添加 Key: Provider={self.provider_id}, "
+            f"Formats={self.key_data.api_formats}, Key=***{self.key_data.api_key[-4:]}, ID={new_key.id}"
+        )
+
+        return _build_key_response(new_key, api_key_plain=self.key_data.api_key)