hyf-backend/th_agenter/api/endpoints/llm_configs.py

"""LLM configuration management API endpoints."""

from typing import List, Optional
from fastapi import APIRouter, Depends, HTTPException, status, Query
from langchain_openai import ChatOpenAI
from langchain_core.messages import AIMessage
from sqlalchemy.orm import Session
from sqlalchemy import or_, select, delete, update

from loguru import logger

from th_agenter.llm.embed.embed_llm import BGEEmbedLLM, EmbedLLM
from th_agenter.llm.online.online_llm import OnlineLLM
from ...db.database import get_session
from ...models.user import User
from ...models.llm_config import LLMConfig
from th_agenter.llm.base_llm import LLMConfig_DataClass
from ...core.simple_permissions import require_super_admin, require_authenticated_user
from ...schemas.llm_config import (
    LLMConfigCreate, LLMConfigUpdate, LLMConfigResponse,
    LLMConfigTest
)
from th_agenter.services.document_processor import get_document_processor
from utils.util_exceptions import HxfResponse

router = APIRouter(prefix="/llm-configs", tags=["llm-configs"])

@router.get("/", response_model=List[LLMConfigResponse], summary="获取大模型配置列表")
async def get_llm_configs(
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=1000),
    search: Optional[str] = Query(None),
    provider: Optional[str] = Query(None),
    is_active: Optional[bool] = Query(None),
    is_embedding: Optional[bool] = Query(None),
    session: Session = Depends(get_session),
    current_user: User = Depends(require_authenticated_user)
):
    """获取大模型配置列表."""
    session.title = "获取大模型配置列表"
    session.desc = f"START: 获取大模型配置列表, skip={skip}, limit={limit}, search={search}, provider={provider}, is_active={is_active}, is_embedding={is_embedding}"
    stmt = select(LLMConfig)
    
    # 搜索
    if search:
        stmt = stmt.where(
            or_(
                LLMConfig.name.ilike(f"%{search}%"),
                LLMConfig.model_name.ilike(f"%{search}%"),
                LLMConfig.description.ilike(f"%{search}%")
            )
        )
    
    # 服务商筛选
    if provider:
        stmt = stmt.where(LLMConfig.provider == provider)
    
    # 状态筛选
    if is_active is not None:
        stmt = stmt.where(LLMConfig.is_active == is_active)
    
    # 模型类型筛选
    if is_embedding is not None:
        stmt = stmt.where(LLMConfig.is_embedding == is_embedding)
    
    # 排序
    stmt = stmt.order_by(LLMConfig.name)
    
    # 分页
    stmt = stmt.offset(skip).limit(limit)
    configs = (await session.execute(stmt)).scalars().all()
    session.desc = f"SUCCESS: 获取 {len(configs)} 个大模型配置 ..."
    return HxfResponse([config.to_dict(include_sensitive=True) for config in configs])


@router.get("/providers", summary="获取支持的大模型服务商列表")
async def get_llm_providers(
    session: Session = Depends(get_session),
    current_user: User = Depends(require_authenticated_user)
):
    """获取支持的大模型服务商列表."""
    session.desc = "START: 获取支持的大模型服务商列表"
    stmt = select(LLMConfig.provider).distinct()
    providers = (await session.execute(stmt)).scalars().all()
    session.desc = f"SUCCESS: 获取 {len(providers)} 个大模型服务商"
    return HxfResponse([provider for provider in providers if provider])



@router.get("/active", response_model=List[LLMConfigResponse], summary="获取所有激活的大模型配置")
async def get_active_llm_configs(
    is_embedding: Optional[bool] = Query(None),
    session: Session = Depends(get_session),
    current_user: User = Depends(require_authenticated_user)
):
    """获取所有激活的大模型配置."""
    session.desc = f"START: 获取所有激活的大模型配置, is_embedding={is_embedding}"
    stmt = select(LLMConfig).where(LLMConfig.is_active == True)
    
    if is_embedding is not None:
        stmt = stmt.where(LLMConfig.is_embedding == is_embedding)
    
    stmt = stmt.order_by(LLMConfig.created_at)
    configs = (await session.execute(stmt)).scalars().all()
    session.desc = f"SUCCESS: 获取 {len(configs)} 个激活的大模型配置"    
    return HxfResponse([config.to_dict(include_sensitive=True) for config in configs])

@router.get("/default", response_model=LLMConfigResponse, summary="获取默认大模型配置")
async def get_default_llm_config(
    is_embedding: bool = Query(False, description="是否获取嵌入模型默认配置"),
    session: Session = Depends(get_session),
    current_user: User = Depends(require_authenticated_user)
):
    """获取默认大模型配置."""
    session.desc = f"START: 获取默认大模型配置, is_embedding={is_embedding}"
    stmt = select(LLMConfig).where(
        LLMConfig.is_default == True,
        LLMConfig.is_embedding == is_embedding,
        LLMConfig.is_active == True
    )
    config = (await session.execute(stmt)).scalar_one_or_none()
    
    if not config:
        model_type = "嵌入模型" if is_embedding else "对话模型"
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail=f"未找到默认{model_type}配置"
        )
    
    session.desc = f"SUCCESS: 获取默认大模型配置, is_embedding={is_embedding}"
    return HxfResponse(config.to_dict(include_sensitive=True))

@router.get("/{config_id}", response_model=LLMConfigResponse, summary="获取大模型配置详情")
async def get_llm_config(
    config_id: int,
    session: Session = Depends(get_session),
    current_user: User = Depends(require_authenticated_user)
):
    """获取大模型配置详情."""
    stmt = select(LLMConfig).where(LLMConfig.id == config_id)
    config = (await session.execute(stmt)).scalar_one_or_none()
    if not config:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="大模型配置不存在"
        )
        
    return HxfResponse(config.to_dict(include_sensitive=True))


@router.post("/", response_model=LLMConfigResponse, status_code=status.HTTP_201_CREATED, summary="创建大模型配置")
async def create_llm_config(
    config_data: LLMConfigCreate,
    session: Session = Depends(get_session),
    current_user: User = Depends(require_super_admin)
):
    """创建大模型配置."""
    # 检查配置名称是否已存在
    # 先保存当前用户名，避免在refresh后访问可能导致MissingGreenlet错误
    username = current_user.username
    session.desc = f"START: 创建大模型配置, name={config_data.name}"
    stmt = select(LLMConfig).where(LLMConfig.name == config_data.name)
    existing_config = (await session.execute(stmt)).scalar_one_or_none()
    if existing_config:
        session.desc = f"ERROR: 配置名称已存在, name={config_data.name}"
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="配置名称已存在"
        )
    
    # 创建配置对象
    config = LLMConfig_DataClass(
        name=config_data.name,
        provider=config_data.provider,
        model_name=config_data.model_name,
        api_key=config_data.api_key,
        base_url=config_data.base_url,
        max_tokens=config_data.max_tokens,
        temperature=config_data.temperature,
        top_p=config_data.top_p,
        frequency_penalty=config_data.frequency_penalty,
        presence_penalty=config_data.presence_penalty,
        description=config_data.description,
        is_active=config_data.is_active,
        is_default=config_data.is_default,
        is_embedding=config_data.is_embedding,
        extra_config=config_data.extra_config or {}
    )
    
    # 验证配置
    validation_result = config.validate_config()
    if not validation_result['valid']:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=validation_result['error']
        )
    
    # 如果设为默认，取消同类型的其他默认配置
    if config_data.is_default:
        stmt = update(LLMConfig).where(
            LLMConfig.is_embedding == config_data.is_embedding
        ).values({"is_default": False})
        await session.execute(stmt)
    
    session.desc = f"验证大模型配置, config_data"
    # 创建配置
    config = LLMConfig_DataClass(
        name=config_data.name,
        provider=config_data.provider,
        model_name=config_data.model_name,
        api_key=config_data.api_key,
        base_url=config_data.base_url,
        max_tokens=config_data.max_tokens,
        temperature=config_data.temperature,
        top_p=config_data.top_p,
        frequency_penalty=config_data.frequency_penalty,
        presence_penalty=config_data.presence_penalty,
        description=config_data.description,
        is_active=config_data.is_active,
        is_default=config_data.is_default,
        is_embedding=config_data.is_embedding,
        extra_config=config_data.extra_config or {}
    )
    # Audit fields are set automatically by SQLAlchemy event listener
    
    session.add(config)
    await session.commit()
    await session.refresh(config)    
    session.desc = f"SUCCESS: 创建大模型配置, name={config.name}  by user {username}"
    return HxfResponse(config.to_dict())
    

@router.put("/{config_id}", response_model=LLMConfigResponse, summary="更新大模型配置")
async def update_llm_config(
    config_id: int,
    config_data: LLMConfigUpdate,
    session: Session = Depends(get_session),
    current_user: User = Depends(require_authenticated_user)
):
    """更新大模型配置."""
    username = current_user.username
    session.desc = f"START: 更新大模型配置, id={config_id}"
    stmt = select(LLMConfig).where(LLMConfig.id == config_id)
    config = (await session.execute(stmt)).scalar_one_or_none()
    if not config:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="大模型配置不存在"
        )
    
    # 检查配置名称是否已存在（排除自己）
    if config_data.name and config_data.name != config.name:
        stmt = select(LLMConfig).where(
            LLMConfig.name == config_data.name,
            LLMConfig.id != config_id
        )
        existing_config = (await session.execute(stmt)).scalar_one_or_none()
        if existing_config:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="配置名称已存在"
            )
    
    # 如果设为默认，取消同类型的其他默认配置
    if config_data.is_default is True:
        # 获取当前配置的embedding类型，如果更新中包含is_embedding则使用新值
        is_embedding = config_data.is_embedding if config_data.is_embedding is not None else config.is_embedding
        stmt = update(LLMConfig).where(
            LLMConfig.is_embedding == is_embedding,
            LLMConfig.id != config_id
        ).values({"is_default": False})
        await session.execute(stmt)
    
    # 更新字段
    update_data = config_data.model_dump(exclude_unset=True)
    was_embedding = config.is_embedding
    for field, value in update_data.items():
        setattr(config, field, value)
    
    await session.commit()
    await session.refresh(config)
    
    # 如果设置为默认嵌入模型，更新文档处理器的嵌入模型
    if config.is_embedding and config.is_default:
        try:
            document_processor = await get_document_processor(session)
            await document_processor._init_embeddings(session)
        except Exception as e:
            logger.warning(f"更新文档处理器嵌入模型失败: {str(e)}")
            # 不阻止更新配置，只记录警告
    
    session.desc = f"SUCCESS: 更新大模型配置, id={config_id} by user {username}"
    return HxfResponse(config.to_dict())

@router.delete("/{config_id}", status_code=status.HTTP_204_NO_CONTENT, summary="删除大模型配置")
async def delete_llm_config(
    config_id: int,
    session: Session = Depends(get_session),
    current_user: User = Depends(require_super_admin)
):
    """删除大模型配置."""
    username = current_user.username
    session.desc = f"START: 删除大模型配置, id={config_id}"
    stmt = select(LLMConfig).where(LLMConfig.id == config_id)
    config = (await session.execute(stmt)).scalar_one_or_none()
    if not config:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="大模型配置不存在"
        )
    session.desc = f"待删除大模型记录 {config.to_dict()}"
    # TODO: 检查是否有对话或其他功能正在使用该配置
    # 这里可以添加相关的检查逻辑
    
    # 删除配置
    await session.delete(config)
    await session.commit()
    
    session.desc = f"SUCCESS: 删除大模型配置成功, id={config_id} by user {username}"
    return HxfResponse({"message": "LLM config deleted successfully"})

@router.post("/{config_id}/test", summary="测试连接大模型配置")
async def test_llm_config(
    config_id: int,
    test_data: LLMConfigTest,
    session: Session = Depends(get_session),
    current_user: User = Depends(require_authenticated_user)
):
    """测试连接大模型配置."""
    username = current_user.username
    session.desc = f"TEST: 测试连接大模型配置 {config_id} by user {username}"
    stmt = select(LLMConfig).where(LLMConfig.id == config_id)
    config = (await session.execute(stmt)).scalar_one_or_none()
    if not config:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="大模型配置不存在"
        )
    
    logger.info(f"TEST: 测试连接大模型配置 {config_id} by user {username}")
    config_name = config.name
    # 验证配置
    validation_result = config.validate_config()
    logger.info(f"TEST: 验证大模型配置 {config_name} validation_result = {validation_result}")
    if not validation_result["valid"]:
        return {
            "success": False,
            "message": f"配置验证失败: {validation_result['error']}",
            "details": validation_result
        }
    
    session.desc = f"准备测试LLM功能  >  测试连接大模型配置 {config.to_dict()}"
    # 尝试创建客户端并发送测试请求
    try:
    #     # 这里应该根据不同的服务商创建相应的客户端
    #     # 由于具体的客户端实现可能因服务商而异，这里提供一个通用的框架
        
        test_message = test_data.message or "Hello, this is a test message."
        session.desc = f"准备测试LLM功能  >  test_message = {test_message}"
        
        # 处理 base_url：如果包含 /chat/completions，需要移除
        original_base_url = config.base_url
        if config.base_url and '/chat/completions' in config.base_url:
            # 移除 /chat/completions 后缀，ChatOpenAI 会自动添加
            config.base_url = config.base_url.replace('/chat/completions', '').rstrip('/')
            logger.info(f"调整 base_url: {original_base_url} -> {config.base_url}")
        
        # 处理 SiliconFlow 的模型名称格式
        original_model_name = config.model_name
        if 'siliconflow' in config.base_url.lower() and '/' not in config.model_name:
            # SiliconFlow 需要 org/model 格式，尝试自动转换
            model_name_lower = config.model_name.lower()
            if 'deepseek' in model_name_lower or 'r1' in model_name_lower:
                # 尝试常见的 DeepSeek 模型格式
                if 'r1' in model_name_lower:
                    config.model_name = 'deepseek-ai/DeepSeek-R1'
                elif 'v3' in model_name_lower:
                    config.model_name = 'deepseek-ai/DeepSeek-V3'
                else:
                    config.model_name = f'deepseek-ai/{config.model_name}'
                logger.info(f"调整 SiliconFlow 模型名称: {original_model_name} -> {config.model_name}")
        
        if config.is_embedding:
            config.provider = "ollama"
            streaming_llm = BGEEmbedLLM(config)
        else:
            streaming_llm = OnlineLLM(config)
        session.desc = f"创建{'EmbeddingLLM' if config.is_embedding else 'OnlineLLM'}完毕  >  测试连接大模型配置 {config.to_dict()}"
        streaming_llm.load_model()  # 加载模型
        session.desc = f"加载模型完毕，模型名称：{config.model_name}，base_url: {config.base_url}，准备测试对话..."

        if config.is_embedding:
            # 测试嵌入模型，使用嵌入API而非聊天API
            test_text = test_message or "Hello, this is a test message for embedding"
            response = streaming_llm.embed_query(test_text)
        else:
            # 测试聊天模型
            from langchain_core.messages import SystemMessage, HumanMessage
            messages = [
                SystemMessage(content="你是一个简洁的助手，回答控制在50字以内"),
                HumanMessage(content=test_message)
            ]
            # 使用异步调用
            import asyncio
            if hasattr(streaming_llm.model, 'ainvoke'):
                response = await streaming_llm.model.ainvoke(messages)
            else:
                # 如果模型不支持异步，使用同步调用但在线程中执行
                response = await asyncio.to_thread(streaming_llm.model.invoke, messages)
        session.desc = f"测试连接大模型配置 {config_name} 成功 >>> 响应: {type(response)}"
        
        return HxfResponse({
            "success": True,
            "message": "LLM测试成功",
            "request": test_message,
            "response": response.content if hasattr(response, 'content') else response,  # 使用转换后的字典
            "latency_ms": 150,  # 模拟延迟
            "config_info": config.to_dict()
        })
        
    except Exception as test_error:
        import traceback
        error_detail = str(test_error)
        error_traceback = traceback.format_exc()
        logger.error(f"测试LLM配置失败: {error_detail}\n{error_traceback}")
        session.desc = f"ERROR: 测试连接大模型配置 {config.name} 失败, error: {error_detail}"
        
        # 提取更详细的错误信息
        if hasattr(test_error, 'response') and hasattr(test_error.response, 'status_code'):
            error_detail = f"HTTP {test_error.response.status_code}: {error_detail}"
            # 如果是模型不存在的错误，提供更详细的提示
            if "Model does not exist" in error_detail or "model" in error_detail.lower():
                original_model = original_model_name if 'original_model_name' in locals() else (config.model_name if 'config' in locals() else "N/A")
                if 'siliconflow' in (original_base_url if 'original_base_url' in locals() else (config.base_url if 'config' in locals() else "")).lower():
                    error_detail += f"\n提示：SiliconFlow 的模型名称格式应为 'org/model-name'（如 'deepseek-ai/DeepSeek-R1'），当前配置: {original_model}"
        elif "Not Found" in error_detail or "404" in error_detail:
            error_detail = f"API端点未找到。请检查 base_url 配置是否正确。当前 base_url: {original_base_url if 'original_base_url' in locals() else config.base_url}"
        
        return HxfResponse({
            "success": False,
            "message": f"LLM测试失败: {error_detail}",
            "test_message": test_message if 'test_message' in locals() else "N/A",
            "config_info": config.to_dict() if 'config' in locals() else {}
        })

@router.post("/{config_id}/toggle-status", summary="切换大模型配置状态")
async def toggle_llm_config_status(
    config_id: int,
    session: Session = Depends(get_session),
    current_user: User = Depends(require_super_admin)
):
    """切换大模型配置状态."""
    username = current_user.username
    session.desc = f"START: 切换大模型配置状态, id={config_id} by user {username}"
    
    stmt = select(LLMConfig).where(LLMConfig.id == config_id)
    config = (await session.execute(stmt)).scalar_one_or_none()
    if not config:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="大模型配置不存在"
        )
    
    # 切换状态
    config.is_active = not config.is_active
    # Audit fields are set automatically by SQLAlchemy event listener
    
    await session.commit()
    await session.refresh(config)
    
    status_text = "激活" if config.is_active else "禁用"
    session.desc = f"SUCCESS: 切换大模型配置状态: {config.name} {status_text} by user {username}"
    
    return HxfResponse({
        "message": f"配置已{status_text}",
        "is_active": config.is_active
    })


@router.post("/{config_id}/set-default", summary="设置默认大模型配置")
async def set_default_llm_config(
    config_id: int,
    session: Session = Depends(get_session),
    current_user: User = Depends(require_authenticated_user)
):
    """设置默认大模型配置."""
    username = current_user.username
    session.desc = f"START: 设置大模型配置 {config_id} 为默认 by user {username}"
    
    stmt = select(LLMConfig).where(LLMConfig.id == config_id)
    config = (await session.execute(stmt)).scalar_one_or_none()
    if not config:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="大模型配置不存在"
        )
    
    # 检查配置是否激活
    if not config.is_active:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="只能将激活的配置设为默认"
        )
    
    # 取消同类型的其他默认配置
    stmt = update(LLMConfig).where(
        LLMConfig.is_embedding == config.is_embedding,
        LLMConfig.id != config_id
    ).values({"is_default": False})
    await session.execute(stmt)
    
    # 设置当前配置为默认
    config.is_default = True
    config.set_audit_fields(current_user.id, is_update=True)
    
    await session.commit()
    await session.refresh(config)
    
    model_type = "嵌入模型" if config.is_embedding else "对话模型"
    # 如果设置为默认嵌入模型，更新文档处理器的嵌入模型
    if config.is_embedding:
        try:
            document_processor = await get_document_processor(session)
            await document_processor._init_embeddings(session)
        except Exception as e:
            logger.warning(f"更新文档处理器嵌入模型失败: {str(e)}")
            # 不阻止设置默认配置，只记录警告
    session.desc = f"SUCCESS: 设置大模型配置 {config.name} ({model_type}) 为默认 by user {username}"
    return HxfResponse({
        "message": f"已将 {config.name} 设为默认{model_type}配置",
        "is_default": config.is_default
    })