Initial commit

src/api/admin/providers/__init__.py

@@ -0,0 +1,20 @@
+"""Provider admin routes export."""
+
+from fastapi import APIRouter
+
+from .models import router as models_router
+from .routes import router as routes_router
+from .summary import router as summary_router
+
+router = APIRouter(prefix="/api/admin/providers", tags=["Admin - Providers"])
+
+# Provider CRUD
+router.include_router(routes_router)
+
+# Provider summary & health monitor
+router.include_router(summary_router)
+
+# Provider models management
+router.include_router(models_router)
+
+__all__ = ["router"]

src/api/admin/providers/models.py

@@ -0,0 +1,443 @@
+"""
+Provider 模型管理 API
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, Depends, Request
+from sqlalchemy import or_
+from sqlalchemy.orm import Session, joinedload
+
+from src.api.base.admin_adapter import AdminApiAdapter
+from src.api.base.pipeline import ApiRequestPipeline
+from src.core.exceptions import InvalidRequestException, NotFoundException
+from src.core.logger import logger
+from src.database import get_db
+from src.models.api import (
+    ModelCreate,
+    ModelResponse,
+    ModelUpdate,
+)
+from src.models.pydantic_models import (
+    BatchAssignModelsToProviderRequest,
+    BatchAssignModelsToProviderResponse,
+)
+from src.models.database import (
+    GlobalModel,
+    Model,
+    ModelMapping,
+    Provider,
+)
+from src.models.pydantic_models import (
+    ProviderAvailableSourceModel,
+    ProviderAvailableSourceModelsResponse,
+)
+from src.services.model.service import ModelService
+
+router = APIRouter(tags=["Model Management"])
+pipeline = ApiRequestPipeline()
+
+
+@router.get("/{provider_id}/models", response_model=List[ModelResponse])
+async def list_provider_models(
+    provider_id: str,
+    request: Request,
+    is_active: Optional[bool] = None,
+    skip: int = 0,
+    limit: int = 100,
+    db: Session = Depends(get_db),
+) -> List[ModelResponse]:
+    """获取提供商的所有模型（管理员）"""
+    adapter = AdminListProviderModelsAdapter(
+        provider_id=provider_id,
+        is_active=is_active,
+        skip=skip,
+        limit=limit,
+    )
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.post("/{provider_id}/models", response_model=ModelResponse)
+async def create_provider_model(
+    provider_id: str,
+    model_data: ModelCreate,
+    request: Request,
+    db: Session = Depends(get_db),
+) -> ModelResponse:
+    """创建模型（管理员）"""
+    adapter = AdminCreateProviderModelAdapter(provider_id=provider_id, model_data=model_data)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.get("/{provider_id}/models/{model_id}", response_model=ModelResponse)
+async def get_provider_model(
+    provider_id: str,
+    model_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+) -> ModelResponse:
+    """获取模型详情（管理员）"""
+    adapter = AdminGetProviderModelAdapter(provider_id=provider_id, model_id=model_id)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.patch("/{provider_id}/models/{model_id}", response_model=ModelResponse)
+async def update_provider_model(
+    provider_id: str,
+    model_id: str,
+    model_data: ModelUpdate,
+    request: Request,
+    db: Session = Depends(get_db),
+) -> ModelResponse:
+    """更新模型（管理员）"""
+    adapter = AdminUpdateProviderModelAdapter(
+        provider_id=provider_id,
+        model_id=model_id,
+        model_data=model_data,
+    )
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.delete("/{provider_id}/models/{model_id}")
+async def delete_provider_model(
+    provider_id: str,
+    model_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """删除模型（管理员）"""
+    adapter = AdminDeleteProviderModelAdapter(provider_id=provider_id, model_id=model_id)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.post("/{provider_id}/models/batch", response_model=List[ModelResponse])
+async def batch_create_provider_models(
+    provider_id: str,
+    models_data: List[ModelCreate],
+    request: Request,
+    db: Session = Depends(get_db),
+) -> List[ModelResponse]:
+    """批量创建模型（管理员）"""
+    adapter = AdminBatchCreateModelsAdapter(provider_id=provider_id, models_data=models_data)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.get(
+    "/{provider_id}/available-source-models",
+    response_model=ProviderAvailableSourceModelsResponse,
+)
+async def get_provider_available_source_models(
+    provider_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    获取该 Provider 支持的所有统一模型名（source_model）
+
+    包括：
+    1. 通过 ModelMapping 映射的模型
+    2. 直连模型（Model.provider_model_name 直接作为统一模型名）
+    """
+    adapter = AdminGetProviderAvailableSourceModelsAdapter(provider_id=provider_id)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.post(
+    "/{provider_id}/assign-global-models",
+    response_model=BatchAssignModelsToProviderResponse,
+)
+async def batch_assign_global_models_to_provider(
+    provider_id: str,
+    payload: BatchAssignModelsToProviderRequest,
+    request: Request,
+    db: Session = Depends(get_db),
+) -> BatchAssignModelsToProviderResponse:
+    """批量为 Provider 关联 GlobalModels（自动继承价格和能力配置）"""
+    adapter = AdminBatchAssignModelsToProviderAdapter(
+        provider_id=provider_id, payload=payload
+    )
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+# -------- Adapters --------
+
+
+@dataclass
+class AdminListProviderModelsAdapter(AdminApiAdapter):
+    provider_id: str
+    is_active: Optional[bool]
+    skip: int
+    limit: int
+
+    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("Provider not found", "provider")
+
+        models = ModelService.get_models_by_provider(
+            db, self.provider_id, self.skip, self.limit, self.is_active
+        )
+        return [ModelService.convert_to_response(model) for model in models]
+
+
+@dataclass
+class AdminCreateProviderModelAdapter(AdminApiAdapter):
+    provider_id: str
+    model_data: ModelCreate
+
+    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("Provider not found", "provider")
+
+        try:
+            model = ModelService.create_model(db, self.provider_id, self.model_data)
+            logger.info(f"Model created: {model.provider_model_name} for provider {provider.name} by {context.user.username}")
+            return ModelService.convert_to_response(model)
+        except Exception as exc:
+            raise InvalidRequestException(str(exc))
+
+
+@dataclass
+class AdminGetProviderModelAdapter(AdminApiAdapter):
+    provider_id: str
+    model_id: str
+
+    async def handle(self, context):  # type: ignore[override]
+        db = context.db
+        model = (
+            db.query(Model)
+            .filter(Model.id == self.model_id, Model.provider_id == self.provider_id)
+            .first()
+        )
+        if not model:
+            raise NotFoundException("Model not found", "model")
+
+        return ModelService.convert_to_response(model)
+
+
+@dataclass
+class AdminUpdateProviderModelAdapter(AdminApiAdapter):
+    provider_id: str
+    model_id: str
+    model_data: ModelUpdate
+
+    async def handle(self, context):  # type: ignore[override]
+        db = context.db
+        model = (
+            db.query(Model)
+            .filter(Model.id == self.model_id, Model.provider_id == self.provider_id)
+            .first()
+        )
+        if not model:
+            raise NotFoundException("Model not found", "model")
+
+        try:
+            updated_model = ModelService.update_model(db, self.model_id, self.model_data)
+            logger.info(f"Model updated: {updated_model.provider_model_name} by {context.user.username}")
+            return ModelService.convert_to_response(updated_model)
+        except Exception as exc:
+            raise InvalidRequestException(str(exc))
+
+
+@dataclass
+class AdminDeleteProviderModelAdapter(AdminApiAdapter):
+    provider_id: str
+    model_id: str
+
+    async def handle(self, context):  # type: ignore[override]
+        db = context.db
+        model = (
+            db.query(Model)
+            .filter(Model.id == self.model_id, Model.provider_id == self.provider_id)
+            .first()
+        )
+        if not model:
+            raise NotFoundException("Model not found", "model")
+
+        model_name = model.provider_model_name
+        try:
+            ModelService.delete_model(db, self.model_id)
+            logger.info(f"Model deleted: {model_name} by {context.user.username}")
+            return {"message": f"Model '{model_name}' deleted successfully"}
+        except Exception as exc:
+            raise InvalidRequestException(str(exc))
+
+
+@dataclass
+class AdminBatchCreateModelsAdapter(AdminApiAdapter):
+    provider_id: str
+    models_data: List[ModelCreate]
+
+    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("Provider not found", "provider")
+
+        try:
+            models = ModelService.batch_create_models(db, self.provider_id, self.models_data)
+            logger.info(f"Batch created {len(models)} models for provider {provider.name} by {context.user.username}")
+            return [ModelService.convert_to_response(model) for model in models]
+        except Exception as exc:
+            raise InvalidRequestException(str(exc))
+
+
+@dataclass
+class AdminGetProviderAvailableSourceModelsAdapter(AdminApiAdapter):
+    provider_id: str
+
+    async def handle(self, context):  # type: ignore[override]
+        """
+        返回 Provider 支持的所有 GlobalModel
+
+        方案 A 逻辑：
+        1. 查询该 Provider 的所有 Model
+        2. 通过 Model.global_model_id 获取 GlobalModel
+        3. 查询所有指向该 GlobalModel 的别名（ModelMapping.alias）
+        """
+        db = context.db
+        provider = db.query(Provider).filter(Provider.id == self.provider_id).first()
+        if not provider:
+            raise NotFoundException("Provider not found", "provider")
+
+        # 1. 查询该 Provider 的所有活跃 Model（预加载 GlobalModel）
+        models = (
+            db.query(Model)
+            .options(joinedload(Model.global_model))
+            .filter(Model.provider_id == self.provider_id, Model.is_active == True)
+            .all()
+        )
+
+        # 2. 构建以 GlobalModel 为主键的字典
+        global_models_dict: Dict[str, Dict[str, Any]] = {}
+
+        for model in models:
+            global_model = model.global_model
+            if not global_model or not global_model.is_active:
+                continue
+
+            global_model_name = global_model.name
+
+            # 如果该 GlobalModel 还未处理，初始化
+            if global_model_name not in global_models_dict:
+                # 查询指向该 GlobalModel 的所有别名/映射
+                alias_rows = (
+                    db.query(ModelMapping.source_model)
+                    .filter(
+                        ModelMapping.target_global_model_id == global_model.id,
+                        ModelMapping.is_active == True,
+                        or_(
+                            ModelMapping.provider_id == self.provider_id,
+                            ModelMapping.provider_id.is_(None),
+                        ),
+                    )
+                    .all()
+                )
+                alias_list = [alias[0] for alias in alias_rows]
+
+                global_models_dict[global_model_name] = {
+                    "global_model_name": global_model_name,
+                    "display_name": global_model.display_name,
+                    "provider_model_name": model.provider_model_name,
+                    "has_alias": len(alias_list) > 0,
+                    "aliases": alias_list,
+                    "model_id": model.id,
+                    "price": {
+                        "input_price_per_1m": model.get_effective_input_price(),
+                        "output_price_per_1m": model.get_effective_output_price(),
+                        "cache_creation_price_per_1m": model.get_effective_cache_creation_price(),
+                        "cache_read_price_per_1m": model.get_effective_cache_read_price(),
+                        "price_per_request": model.get_effective_price_per_request(),
+                    },
+                    "capabilities": {
+                        "supports_vision": bool(model.supports_vision),
+                        "supports_function_calling": bool(model.supports_function_calling),
+                        "supports_streaming": bool(model.supports_streaming),
+                    },
+                    "is_active": bool(model.is_active),
+                }
+
+        models_list = [
+            ProviderAvailableSourceModel(**global_models_dict[name])
+            for name in sorted(global_models_dict.keys())
+        ]
+
+        return ProviderAvailableSourceModelsResponse(models=models_list, total=len(models_list))
+
+
+@dataclass
+class AdminBatchAssignModelsToProviderAdapter(AdminApiAdapter):
+    """批量为 Provider 关联 GlobalModels"""
+
+    provider_id: str
+    payload: BatchAssignModelsToProviderRequest
+
+    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("Provider not found", "provider")
+
+        success = []
+        errors = []
+
+        for global_model_id in self.payload.global_model_ids:
+            try:
+                global_model = (
+                    db.query(GlobalModel).filter(GlobalModel.id == global_model_id).first()
+                )
+                if not global_model:
+                    errors.append(
+                        {"global_model_id": global_model_id, "error": "GlobalModel not found"}
+                    )
+                    continue
+
+                # 检查是否已存在关联
+                existing = (
+                    db.query(Model)
+                    .filter(
+                        Model.provider_id == self.provider_id,
+                        Model.global_model_id == global_model_id,
+                    )
+                    .first()
+                )
+                if existing:
+                    errors.append(
+                        {
+                            "global_model_id": global_model_id,
+                            "global_model_name": global_model.name,
+                            "error": "Already associated",
+                        }
+                    )
+                    continue
+
+                # 创建新的 Model 记录，继承 GlobalModel 的配置
+                new_model = Model(
+                    provider_id=self.provider_id,
+                    global_model_id=global_model_id,
+                    provider_model_name=global_model.name,
+                    is_active=True,
+                )
+                db.add(new_model)
+                db.flush()
+
+                success.append(
+                    {
+                        "global_model_id": global_model_id,
+                        "global_model_name": global_model.name,
+                        "model_id": new_model.id,
+                    }
+                )
+            except Exception as e:
+                errors.append({"global_model_id": global_model_id, "error": str(e)})
+
+        db.commit()
+        logger.info(
+            f"Batch assigned {len(success)} GlobalModels to provider {provider.name} by {context.user.username}"
+        )
+
+        return BatchAssignModelsToProviderResponse(success=success, errors=errors)

src/api/admin/providers/routes.py

@@ -0,0 +1,249 @@
+"""管理员 Provider 管理路由。"""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+from fastapi import APIRouter, Depends, Query, Request
+from pydantic import ValidationError
+from sqlalchemy.orm import Session
+
+from src.api.base.admin_adapter import AdminApiAdapter
+from src.api.base.pipeline import ApiRequestPipeline
+from src.core.enums import ProviderBillingType
+from src.core.exceptions import InvalidRequestException, NotFoundException
+from src.database import get_db
+from src.models.admin_requests import CreateProviderRequest, UpdateProviderRequest
+from src.models.database import Provider
+
+router = APIRouter(tags=["Provider CRUD"])
+pipeline = ApiRequestPipeline()
+
+
+@router.get("/")
+async def list_providers(
+    request: Request,
+    skip: int = Query(0, ge=0),
+    limit: int = Query(100, ge=1, le=500),
+    is_active: Optional[bool] = None,
+    db: Session = Depends(get_db),
+):
+    adapter = AdminListProvidersAdapter(skip=skip, limit=limit, is_active=is_active)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.post("/")
+async def create_provider(request: Request, db: Session = Depends(get_db)):
+    adapter = AdminCreateProviderAdapter()
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.put("/{provider_id}")
+async def update_provider(provider_id: str, request: Request, db: Session = Depends(get_db)):
+    adapter = AdminUpdateProviderAdapter(provider_id=provider_id)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.delete("/{provider_id}")
+async def delete_provider(provider_id: str, request: Request, db: Session = Depends(get_db)):
+    adapter = AdminDeleteProviderAdapter(provider_id=provider_id)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+class AdminListProvidersAdapter(AdminApiAdapter):
+    def __init__(self, skip: int, limit: int, is_active: Optional[bool]):
+        self.skip = skip
+        self.limit = limit
+        self.is_active = is_active
+
+    async def handle(self, context):  # type: ignore[override]
+        db = context.db
+        query = db.query(Provider)
+        if self.is_active is not None:
+            query = query.filter(Provider.is_active == self.is_active)
+        providers = query.offset(self.skip).limit(self.limit).all()
+
+        data = []
+        for provider in providers:
+            api_format = getattr(provider, "api_format", None)
+            base_url = getattr(provider, "base_url", None)
+            api_key = getattr(provider, "api_key", None)
+            priority = getattr(provider, "priority", provider.provider_priority)
+
+            data.append(
+                {
+                    "id": provider.id,
+                    "name": provider.name,
+                    "display_name": provider.display_name,
+                    "api_format": api_format.value if api_format else None,
+                    "base_url": base_url,
+                    "api_key": "***" if api_key else None,
+                    "priority": priority,
+                    "is_active": provider.is_active,
+                    "created_at": provider.created_at.isoformat(),
+                    "updated_at": provider.updated_at.isoformat() if provider.updated_at else None,
+                }
+            )
+        context.add_audit_metadata(
+            action="list_providers",
+            filter_is_active=self.is_active,
+            limit=self.limit,
+            skip=self.skip,
+            result_count=len(data),
+        )
+        return data
+
+
+class AdminCreateProviderAdapter(AdminApiAdapter):
+    async def handle(self, context):  # type: ignore[override]
+        db = context.db
+        payload = context.ensure_json_body()
+
+        try:
+            # 使用 Pydantic 模型进行验证（自动进行 SQL 注入、XSS、SSRF 检测）
+            validated_data = CreateProviderRequest.model_validate(payload)
+        except ValidationError as exc:
+            # 将 Pydantic 验证错误转换为友好的错误信息
+            errors = []
+            for error in exc.errors():
+                field = " -> ".join(str(x) for x in error["loc"])
+                errors.append(f"{field}: {error['msg']}")
+            raise InvalidRequestException("输入验证失败: " + "; ".join(errors))
+
+        try:
+            # 检查名称是否已存在
+            existing = db.query(Provider).filter(Provider.name == validated_data.name).first()
+            if existing:
+                raise InvalidRequestException(f"提供商名称 '{validated_data.name}' 已存在")
+
+            # 将验证后的数据转换为枚举类型
+            billing_type = (
+                ProviderBillingType(validated_data.billing_type)
+                if validated_data.billing_type
+                else ProviderBillingType.PAY_AS_YOU_GO
+            )
+
+            # 创建 Provider 对象
+            provider = Provider(
+                name=validated_data.name,
+                display_name=validated_data.display_name,
+                description=validated_data.description,
+                website=validated_data.website,
+                billing_type=billing_type,
+                monthly_quota_usd=validated_data.monthly_quota_usd,
+                quota_reset_day=validated_data.quota_reset_day,
+                quota_last_reset_at=validated_data.quota_last_reset_at,
+                quota_expires_at=validated_data.quota_expires_at,
+                rpm_limit=validated_data.rpm_limit,
+                provider_priority=validated_data.provider_priority,
+                is_active=validated_data.is_active,
+                rate_limit=validated_data.rate_limit,
+                concurrent_limit=validated_data.concurrent_limit,
+                config=validated_data.config,
+            )
+
+            db.add(provider)
+            db.commit()
+            db.refresh(provider)
+
+            context.add_audit_metadata(
+                action="create_provider",
+                provider_id=provider.id,
+                provider_name=provider.name,
+                billing_type=provider.billing_type.value if provider.billing_type else None,
+                is_active=provider.is_active,
+                provider_priority=provider.provider_priority,
+            )
+
+            return {
+                "id": provider.id,
+                "name": provider.name,
+                "display_name": provider.display_name,
+                "message": "提供商创建成功",
+            }
+        except InvalidRequestException:
+            db.rollback()
+            raise
+        except Exception:
+            db.rollback()
+            raise
+
+
+class AdminUpdateProviderAdapter(AdminApiAdapter):
+    def __init__(self, provider_id: str):
+        self.provider_id = provider_id
+
+    async def handle(self, context):  # type: ignore[override]
+        db = context.db
+        payload = context.ensure_json_body()
+
+        # 查找 Provider
+        provider = db.query(Provider).filter(Provider.id == self.provider_id).first()
+        if not provider:
+            raise NotFoundException("提供商不存在", "provider")
+
+        try:
+            # 使用 Pydantic 模型进行验证（自动进行 SQL 注入、XSS、SSRF 检测）
+            validated_data = UpdateProviderRequest.model_validate(payload)
+        except ValidationError as exc:
+            # 将 Pydantic 验证错误转换为友好的错误信息
+            errors = []
+            for error in exc.errors():
+                field = " -> ".join(str(x) for x in error["loc"])
+                errors.append(f"{field}: {error['msg']}")
+            raise InvalidRequestException("输入验证失败: " + "; ".join(errors))
+
+        try:
+            # 更新字段（只更新非 None 的字段）
+            update_data = validated_data.model_dump(exclude_unset=True)
+
+            for field, value in update_data.items():
+                if field == "billing_type" and value is not None:
+                    # billing_type 需要转换为枚举
+                    setattr(provider, field, ProviderBillingType(value))
+                else:
+                    setattr(provider, field, value)
+
+            provider.updated_at = datetime.now(timezone.utc)
+            db.commit()
+            db.refresh(provider)
+
+            context.add_audit_metadata(
+                action="update_provider",
+                provider_id=provider.id,
+                changed_fields=list(update_data.keys()),
+                is_active=provider.is_active,
+                provider_priority=provider.provider_priority,
+            )
+
+            return {
+                "id": provider.id,
+                "name": provider.name,
+                "is_active": provider.is_active,
+                "message": "提供商更新成功",
+            }
+        except InvalidRequestException:
+            db.rollback()
+            raise
+        except Exception:
+            db.rollback()
+            raise
+
+
+class AdminDeleteProviderAdapter(AdminApiAdapter):
+    def __init__(self, provider_id: str):
+        self.provider_id = provider_id
+
+    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("提供商不存在", "provider")
+
+        context.add_audit_metadata(
+            action="delete_provider",
+            provider_id=provider.id,
+            provider_name=provider.name,
+        )
+        db.delete(provider)
+        db.commit()
+        return {"message": "提供商已删除"}

src/api/admin/providers/summary.py

@@ -0,0 +1,348 @@
+"""
+Provider 摘要与健康监控 API
+"""
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Dict, List
+
+from fastapi import APIRouter, Depends, Query, Request
+from sqlalchemy import case, func
+from sqlalchemy.orm import Session
+
+from src.api.base.admin_adapter import AdminApiAdapter
+from src.api.base.pipeline import ApiRequestPipeline
+from src.core.enums import ProviderBillingType
+from src.core.exceptions import NotFoundException
+from src.core.logger import logger
+from src.database import get_db
+from src.models.database import (
+    Model,
+    Provider,
+    ProviderAPIKey,
+    ProviderEndpoint,
+    RequestCandidate,
+)
+from src.models.endpoint_models import (
+    EndpointHealthEvent,
+    EndpointHealthMonitor,
+    ProviderEndpointHealthMonitorResponse,
+    ProviderUpdateRequest,
+    ProviderWithEndpointsSummary,
+)
+
+router = APIRouter(tags=["Provider Summary"])
+pipeline = ApiRequestPipeline()
+
+
+@router.get("/summary", response_model=List[ProviderWithEndpointsSummary])
+async def get_providers_summary(
+    request: Request,
+    db: Session = Depends(get_db),
+) -> List[ProviderWithEndpointsSummary]:
+    """获取所有 Providers 的摘要信息(包含 Endpoints 和 Keys 统计)"""
+    adapter = AdminProviderSummaryAdapter()
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.get("/{provider_id}/summary", response_model=ProviderWithEndpointsSummary)
+async def get_provider_summary(
+    provider_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+) -> ProviderWithEndpointsSummary:
+    """获取单个 Provider 的摘要信息(包含 Endpoints 和 Keys 统计)"""
+    provider = db.query(Provider).filter(Provider.id == provider_id).first()
+    if not provider:
+        raise NotFoundException(f"Provider {provider_id} not found")
+
+    return _build_provider_summary(db, provider)
+
+
+@router.get("/{provider_id}/health-monitor", response_model=ProviderEndpointHealthMonitorResponse)
+async def get_provider_health_monitor(
+    provider_id: str,
+    request: Request,
+    lookback_hours: int = Query(6, ge=1, le=72, description="回溯的小时数"),
+    per_endpoint_limit: int = Query(48, ge=10, le=200, description="每个端点的事件数量"),
+    db: Session = Depends(get_db),
+) -> ProviderEndpointHealthMonitorResponse:
+    """获取 Provider 下所有端点的健康监控时间线"""
+
+    adapter = AdminProviderHealthMonitorAdapter(
+        provider_id=provider_id,
+        lookback_hours=lookback_hours,
+        per_endpoint_limit=per_endpoint_limit,
+    )
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+@router.patch("/{provider_id}", response_model=ProviderWithEndpointsSummary)
+async def update_provider_settings(
+    provider_id: str,
+    update_data: ProviderUpdateRequest,
+    request: Request,
+    db: Session = Depends(get_db),
+) -> ProviderWithEndpointsSummary:
+    """更新 Provider 基础配置（display_name, description, priority, weight 等）"""
+
+    adapter = AdminUpdateProviderSettingsAdapter(provider_id=provider_id, update_data=update_data)
+    return await pipeline.run(adapter=adapter, http_request=request, db=db, mode=adapter.mode)
+
+
+def _build_provider_summary(db: Session, provider: Provider) -> ProviderWithEndpointsSummary:
+    endpoints = db.query(ProviderEndpoint).filter(ProviderEndpoint.provider_id == provider.id).all()
+
+    total_endpoints = len(endpoints)
+    active_endpoints = sum(1 for e in endpoints if e.is_active)
+    endpoint_ids = [e.id for e in endpoints]
+
+    # Key 统计（合并为单个查询）
+    total_keys = 0
+    active_keys = 0
+    if endpoint_ids:
+        key_stats = db.query(
+            func.count(ProviderAPIKey.id).label("total"),
+            func.sum(case((ProviderAPIKey.is_active == True, 1), else_=0)).label("active"),
+        ).filter(ProviderAPIKey.endpoint_id.in_(endpoint_ids)).first()
+        total_keys = key_stats.total or 0
+        active_keys = int(key_stats.active or 0)
+
+    # Model 统计（合并为单个查询）
+    model_stats = db.query(
+        func.count(Model.id).label("total"),
+        func.sum(case((Model.is_active == True, 1), else_=0)).label("active"),
+    ).filter(Model.provider_id == provider.id).first()
+    total_models = model_stats.total or 0
+    active_models = int(model_stats.active or 0)
+
+    api_formats = [e.api_format for e in endpoints]
+
+    # 优化: 一次性加载所有 endpoint 的 keys，避免 N+1 查询
+    all_keys = []
+    if endpoint_ids:
+        all_keys = (
+            db.query(ProviderAPIKey).filter(ProviderAPIKey.endpoint_id.in_(endpoint_ids)).all()
+        )
+
+    # 按 endpoint_id 分组 keys
+    keys_by_endpoint: dict[str, list[ProviderAPIKey]] = {}
+    for key in all_keys:
+        if key.endpoint_id not in keys_by_endpoint:
+            keys_by_endpoint[key.endpoint_id] = []
+        keys_by_endpoint[key.endpoint_id].append(key)
+
+    endpoint_health_map: dict[str, float] = {}
+    for endpoint in endpoints:
+        keys = keys_by_endpoint.get(endpoint.id, [])
+        if keys:
+            health_scores = [k.health_score for k in keys if k.health_score is not None]
+            avg_health = sum(health_scores) / len(health_scores) if health_scores else 1.0
+            endpoint_health_map[endpoint.id] = avg_health
+        else:
+            endpoint_health_map[endpoint.id] = 1.0
+
+    all_health_scores = list(endpoint_health_map.values())
+    avg_health_score = sum(all_health_scores) / len(all_health_scores) if all_health_scores else 1.0
+    unhealthy_endpoints = sum(1 for score in all_health_scores if score < 0.5)
+
+    # 计算每个端点的活跃密钥数量
+    active_keys_by_endpoint: dict[str, int] = {}
+    for endpoint_id, keys in keys_by_endpoint.items():
+        active_keys_by_endpoint[endpoint_id] = sum(1 for k in keys if k.is_active)
+
+    endpoint_health_details = [
+        {
+            "api_format": e.api_format,
+            "health_score": endpoint_health_map.get(e.id, 1.0),
+            "is_active": e.is_active,
+            "active_keys": active_keys_by_endpoint.get(e.id, 0),
+        }
+        for e in endpoints
+    ]
+
+    return ProviderWithEndpointsSummary(
+        id=provider.id,
+        name=provider.name,
+        display_name=provider.display_name,
+        description=provider.description,
+        website=provider.website,
+        provider_priority=provider.provider_priority,
+        is_active=provider.is_active,
+        billing_type=provider.billing_type.value if provider.billing_type else None,
+        monthly_quota_usd=provider.monthly_quota_usd,
+        monthly_used_usd=provider.monthly_used_usd,
+        quota_reset_day=provider.quota_reset_day,
+        quota_last_reset_at=provider.quota_last_reset_at,
+        quota_expires_at=provider.quota_expires_at,
+        rpm_limit=provider.rpm_limit,
+        rpm_used=provider.rpm_used,
+        rpm_reset_at=provider.rpm_reset_at,
+        total_endpoints=total_endpoints,
+        active_endpoints=active_endpoints,
+        total_keys=total_keys,
+        active_keys=active_keys,
+        total_models=total_models,
+        active_models=active_models,
+        avg_health_score=avg_health_score,
+        unhealthy_endpoints=unhealthy_endpoints,
+        api_formats=api_formats,
+        endpoint_health_details=endpoint_health_details,
+        created_at=provider.created_at,
+        updated_at=provider.updated_at,
+    )
+
+
+# -------- Adapters --------
+
+
+@dataclass
+class AdminProviderHealthMonitorAdapter(AdminApiAdapter):
+    provider_id: str
+    lookback_hours: int
+    per_endpoint_limit: int
+
+    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} 不存在")
+
+        endpoints = (
+            db.query(ProviderEndpoint)
+            .filter(ProviderEndpoint.provider_id == self.provider_id)
+            .all()
+        )
+
+        now = datetime.now(timezone.utc)
+        since = now - timedelta(hours=self.lookback_hours)
+
+        endpoint_ids = [endpoint.id for endpoint in endpoints]
+        if not endpoint_ids:
+            response = ProviderEndpointHealthMonitorResponse(
+                provider_id=provider.id,
+                provider_name=provider.display_name or provider.name,
+                generated_at=now,
+                endpoints=[],
+            )
+            context.add_audit_metadata(
+                action="provider_health_monitor",
+                provider_id=self.provider_id,
+                endpoint_count=0,
+                lookback_hours=self.lookback_hours,
+            )
+            return response
+
+        limit_rows = max(200, self.per_endpoint_limit * max(1, len(endpoint_ids)) * 2)
+        attempts_query = (
+            db.query(RequestCandidate)
+            .filter(
+                RequestCandidate.endpoint_id.in_(endpoint_ids),
+                RequestCandidate.created_at >= since,
+            )
+            .order_by(RequestCandidate.created_at.desc())
+        )
+        attempts = attempts_query.limit(limit_rows).all()
+
+        buffered_attempts: Dict[str, List[RequestCandidate]] = {eid: [] for eid in endpoint_ids}
+        counters: Dict[str, int] = {eid: 0 for eid in endpoint_ids}
+
+        for attempt in attempts:
+            if not attempt.endpoint_id or attempt.endpoint_id not in buffered_attempts:
+                continue
+            if counters[attempt.endpoint_id] >= self.per_endpoint_limit:
+                continue
+            buffered_attempts[attempt.endpoint_id].append(attempt)
+            counters[attempt.endpoint_id] += 1
+
+        endpoint_monitors: List[EndpointHealthMonitor] = []
+        for endpoint in endpoints:
+            attempt_list = list(reversed(buffered_attempts.get(endpoint.id, [])))
+            events: List[EndpointHealthEvent] = []
+            for attempt in attempt_list:
+                event_timestamp = attempt.finished_at or attempt.started_at or attempt.created_at
+                events.append(
+                    EndpointHealthEvent(
+                        timestamp=event_timestamp,
+                        status=attempt.status,
+                        status_code=attempt.status_code,
+                        latency_ms=attempt.latency_ms,
+                        error_type=attempt.error_type,
+                        error_message=attempt.error_message,
+                    )
+                )
+
+            success_count = sum(1 for event in events if event.status == "success")
+            failed_count = sum(1 for event in events if event.status == "failed")
+            skipped_count = sum(1 for event in events if event.status == "skipped")
+            total_attempts = len(events)
+            success_rate = success_count / total_attempts if total_attempts else 1.0
+            last_event_at = events[-1].timestamp if events else None
+
+            endpoint_monitors.append(
+                EndpointHealthMonitor(
+                    endpoint_id=endpoint.id,
+                    api_format=endpoint.api_format,
+                    is_active=endpoint.is_active,
+                    total_attempts=total_attempts,
+                    success_count=success_count,
+                    failed_count=failed_count,
+                    skipped_count=skipped_count,
+                    success_rate=success_rate,
+                    last_event_at=last_event_at,
+                    events=events,
+                )
+            )
+
+        response = ProviderEndpointHealthMonitorResponse(
+            provider_id=provider.id,
+            provider_name=provider.display_name or provider.name,
+            generated_at=now,
+            endpoints=endpoint_monitors,
+        )
+        context.add_audit_metadata(
+            action="provider_health_monitor",
+            provider_id=self.provider_id,
+            endpoint_count=len(endpoint_monitors),
+            lookback_hours=self.lookback_hours,
+            per_endpoint_limit=self.per_endpoint_limit,
+        )
+        return response
+
+
+class AdminProviderSummaryAdapter(AdminApiAdapter):
+    async def handle(self, context):  # type: ignore[override]
+        db = context.db
+        providers = (
+            db.query(Provider)
+            .order_by(Provider.provider_priority.asc(), Provider.created_at.asc())
+            .all()
+        )
+        return [_build_provider_summary(db, provider) for provider in providers]
+
+
+@dataclass
+class AdminUpdateProviderSettingsAdapter(AdminApiAdapter):
+    provider_id: str
+    update_data: ProviderUpdateRequest
+
+    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("Provider not found", "provider")
+
+        update_dict = self.update_data.model_dump(exclude_unset=True)
+        if "billing_type" in update_dict and update_dict["billing_type"] is not None:
+            update_dict["billing_type"] = ProviderBillingType(update_dict["billing_type"])
+
+        for key, value in update_dict.items():
+            setattr(provider, key, value)
+
+        db.commit()
+        db.refresh(provider)
+
+        admin_name = context.user.username if context.user else "admin"
+        logger.info(f"Provider {provider.name} updated by {admin_name}: {update_dict}")
+
+        return _build_provider_summary(db, provider)