lily_llm_api/api/routers/context_router.py

"""
Context management router for Lily LLM API
"""
from fastapi import APIRouter, HTTPException, Form
from typing import Optional
import logging

from ...models.schemas import (
    ContextStatusResponse, ContextHistoryResponse, 
    AutoCleanupConfigResponse, AutoCleanupConfigRequest
)

logger = logging.getLogger(__name__)
router = APIRouter()

@router.get("/context/status", response_model=ContextStatusResponse)
async def get_context_status():
    """컨텍스트 관리자 상태 확인"""
    try:
        try:
            from lily_llm_core.context_manager import context_manager
            if not context_manager:
                return ContextStatusResponse(
                    status="error",
                    context_manager_available=False,
                    total_sessions=0,
                    sessions={},
                    max_tokens=0,
                    max_turns=0,
                    strategy="unknown",
                    message="Context manager not available"
                )
            
            # 세션별 정보 수집
            session_info = {}
            for session_id, conversation in context_manager.session_conversations.items():
                session_info[session_id] = {
                    "turns": len(conversation),
                    "user_messages": len([t for t in conversation if t.role == "user"]),
                    "assistant_messages": len([t for t in conversation if t.role == "assistant"])
                }
            
            return ContextStatusResponse(
                status="success",
                context_manager_available=True,
                total_sessions=len(context_manager.session_conversations),
                sessions=session_info,
                max_tokens=getattr(context_manager, 'max_tokens', 0),
                max_turns=getattr(context_manager, 'max_turns', 0),
                strategy=getattr(context_manager, 'strategy', 'unknown')
            )
        except ImportError:
            return ContextStatusResponse(
                status="error",
                context_manager_available=False,
                total_sessions=0,
                sessions={},
                max_tokens=0,
                max_turns=0,
                strategy="unknown",
                message="Context manager import failed"
            )
    except Exception as e:
        logger.error(f"컨텍스트 상태 확인 실패: {e}")
        return ContextStatusResponse(
            status="error",
            context_manager_available=False,
            total_sessions=0,
            sessions={},
            max_tokens=0,
            max_turns=0,
            strategy="unknown",
            message=str(e)
        )

@router.get("/context/history", response_model=ContextHistoryResponse)
async def get_context_history(session_id: str = None):
    """컨텍스트 히스토리 조회"""
    try:
        try:
            from lily_llm_core.context_manager import context_manager
            if not context_manager:
                return ContextHistoryResponse(
                    status="error",
                    context="",
                    history_length=0,
                    message="Context manager not available"
                )
            
            if session_id:
                # 특정 세션의 컨텍스트만 조회
                context = context_manager.get_context(include_system=True, max_length=4000, session_id=session_id)
                session_summary = context_manager.get_context_summary(session_id)
                return ContextHistoryResponse(
                    status="success",
                    session_id=session_id,
                    context=context,
                    history_length=session_summary.get("total_turns", 0),
                    session_summary=session_summary
                )
            else:
                # 전체 컨텍스트 조회
                context = context_manager.get_context(include_system=True, max_length=4000)
                return ContextHistoryResponse(
                    status="success",
                    context=context,
                    history_length=len(context_manager.conversation_history),
                    all_sessions=True
                )
        except ImportError:
            return ContextHistoryResponse(
                status="error",
                context="",
                history_length=0,
                message="Context manager import failed"
            )
    except Exception as e:
        logger.error(f"컨텍스트 히스토리 조회 실패: {e}")
        return ContextHistoryResponse(
            status="error",
            context="",
            history_length=0,
            message=str(e)
        )

@router.get("/context/auto-cleanup", response_model=AutoCleanupConfigResponse)
async def get_auto_cleanup_config():
    """자동 정리 설정 조회"""
    try:
        try:
            from lily_llm_core.context_manager import context_manager
            if not context_manager:
                return AutoCleanupConfigResponse(
                    status="error",
                    auto_cleanup_config={},
                    message="Context manager not available"
                )
            
            config = context_manager.get_auto_cleanup_config()
            return AutoCleanupConfigResponse(
                status="success",
                auto_cleanup_config=config
            )
        except ImportError:
            return AutoCleanupConfigResponse(
                status="error",
                auto_cleanup_config={},
                message="Context manager import failed"
            )
    except Exception as e:
        logger.error(f"자동 정리 설정 조회 실패: {e}")
        return AutoCleanupConfigResponse(
            status="error",
            auto_cleanup_config={},
            message=str(e)
        )

@router.post("/context/auto-cleanup")
async def set_auto_cleanup_config(
    enabled: bool = Form(True),
    interval_turns: int = Form(8),
    interval_time: int = Form(300),
    strategy: str = Form("smart")
):
    """자동 정리 설정 변경"""
    try:
        try:
            from lily_llm_core.context_manager import context_manager
            if not context_manager:
                raise HTTPException(status_code=500, detail="Context manager not available")
            
            success = context_manager.set_auto_cleanup_config(
                enabled=enabled,
                interval_turns=interval_turns,
                interval_time=interval_time,
                strategy=strategy
            )
            
            if success:
                return {"status": "success", "message": "자동 정리 설정 변경 완료"}
            else:
                raise HTTPException(status_code=500, detail="자동 정리 설정 변경 실패")
        except ImportError:
            raise HTTPException(status_code=500, detail="Context manager import failed")
    except Exception as e:
        logger.error(f"자동 정리 설정 변경 실패: {e}")
        raise HTTPException(status_code=500, detail=f"자동 정리 설정 변경 실패: {str(e)}")

@router.post("/context/cleanup")
async def cleanup_context(session_id: str = Form(None)):
    """컨텍스트 정리"""
    try:
        try:
            from lily_llm_core.context_manager import context_manager
            if not context_manager:
                raise HTTPException(status_code=500, detail="Context manager not available")
            
            if session_id:
                # 특정 세션 정리
                success = context_manager.cleanup_session(session_id)
                if success:
                    return {"status": "success", "message": f"세션 {session_id} 정리 완료"}
                else:
                    raise HTTPException(status_code=500, detail=f"세션 {session_id} 정리 실패")
            else:
                # 전체 컨텍스트 정리
                success = context_manager.cleanup_context()
                if success:
                    return {"status": "success", "message": "전체 컨텍스트 정리 완료"}
                else:
                    raise HTTPException(status_code=500, detail="전체 컨텍스트 정리 실패")
        except ImportError:
            raise HTTPException(status_code=500, detail="Context manager import failed")
    except Exception as e:
        logger.error(f"컨텍스트 정리 실패: {e}")
        raise HTTPException(status_code=500, detail=f"컨텍스트 정리 실패: {str(e)}")

@router.post("/context/summary")
async def generate_context_summary(session_id: str = Form(...)):
    """컨텍스트 요약 생성"""
    try:
        try:
            from lily_llm_core.context_manager import context_manager
            if not context_manager:
                raise HTTPException(status_code=500, detail="Context manager not available")
            
            summary = context_manager.generate_summary(session_id)
            if summary:
                return {"status": "success", "summary": summary}
            else:
                raise HTTPException(status_code=500, detail="컨텍스트 요약 생성 실패")
        except ImportError:
            raise HTTPException(status_code=500, detail="Context manager import failed")
    except Exception as e:
        logger.error(f"컨텍스트 요약 생성 실패: {e}")
        raise HTTPException(status_code=500, detail=f"컨텍스트 요약 생성 실패: {str(e)}")

@router.delete("/context/session/{session_id}")
async def delete_session(session_id: str):
    """특정 세션 삭제"""
    try:
        try:
            from lily_llm_core.context_manager import context_manager
            if not context_manager:
                raise HTTPException(status_code=500, detail="Context manager not available")
            
            success = context_manager.delete_session(session_id)
            if success:
                return {"status": "success", "message": f"세션 {session_id} 삭제 완료"}
            else:
                raise HTTPException(status_code=500, detail=f"세션 {session_id} 삭제 실패")
        except ImportError:
            raise HTTPException(status_code=500, detail="Context manager import failed")
    except Exception as e:
        logger.error(f"세션 삭제 실패: {e}")
        raise HTTPException(status_code=500, detail=f"세션 삭제 실패: {str(e)}")

@router.get("/context/sessions")
async def list_sessions():
    """사용 가능한 세션 목록"""
    try:
        try:
            from lily_llm_core.context_manager import context_manager
            if not context_manager:
                raise HTTPException(status_code=500, detail="Context manager not available")
            
            sessions = list(context_manager.session_conversations.keys())
            return {"status": "success", "sessions": sessions}
        except ImportError:
            raise HTTPException(status_code=500, detail="Context manager import failed")
    except Exception as e:
        logger.error(f"세션 목록 조회 실패: {e}")
        raise HTTPException(status_code=500, detail=f"세션 목록 조회 실패: {str(e)}")