agent-platform/services/session-service/app/api/routes.py

from core_domain import ServiceHealth
from core_shared import error_detail
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import text
from sqlalchemy.orm import Session

from app.application.services import SessionApplicationService
from app.bootstrap.settings import SessionServiceSettings
from app.db.session import get_db
from app.domain.repositories import MessageRepository, RunRequestRepository, SessionRepository
from app.schemas.message import MessageCreateRequest, MessageListRequest, MessageResponse
from app.schemas.run_request import (
    RunRequestCreateRequest,
    RunRequestDetailRequest,
    RunRequestListRequest,
    RunRequestResponse,
    RunRequestUpdateRequest,
)
from app.schemas.session import SessionCreateRequest, SessionDetailRequest, SessionListRequest, SessionResponse

router = APIRouter()


def get_session_settings() -> SessionServiceSettings:
    return SessionServiceSettings()


def get_session_application_service(
    db: Session = Depends(get_db),
    settings: SessionServiceSettings = Depends(get_session_settings)) -> SessionApplicationService:
    return SessionApplicationService(
        session_repository=SessionRepository(db),
        message_repository=MessageRepository(db),
        run_request_repository=RunRequestRepository(db))


@router.get("/health", response_model=ServiceHealth)
def health_check(db: Session = Depends(get_db)) -> ServiceHealth:
    db.execute(text("SELECT 1"))
    return ServiceHealth(service="session-service", status="ok", database="ok")


@router.post("", response_model=SessionResponse)
def create_session(
    payload: SessionCreateRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> SessionResponse:
    entity = service.create_session(payload)
    return SessionResponse.from_entity(entity)


@router.get("", response_model=list[SessionResponse])
def list_sessions(
    app_id: str | None = Query(default=None),
    service: SessionApplicationService = Depends(get_session_application_service)) -> list[SessionResponse]:
    return [SessionResponse.from_entity(item) for item in service.list_sessions(app_id)]


@router.post("/list", response_model=list[SessionResponse])
def list_sessions_post(
    payload: SessionListRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> list[SessionResponse]:
    return [SessionResponse.from_entity(item) for item in service.list_sessions(payload.app_id)]


@router.post("/detail", response_model=SessionResponse)
def detail_session(
    payload: SessionDetailRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> SessionResponse:
    entity = service.get_session(session_id=payload.session_id)
    if entity is None:
        raise HTTPException(status_code=404, detail=error_detail("error.session.not_found", id=payload.session_id))
    return SessionResponse.from_entity(entity)


@router.post("/messages", response_model=MessageResponse)
def create_message(
    payload: MessageCreateRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> MessageResponse:
    entity = service.create_message(payload)
    return MessageResponse.from_entity(entity)


@router.get("/messages", response_model=list[MessageResponse])
def list_messages(
    session_id: str = Query(...),
    service: SessionApplicationService = Depends(get_session_application_service)) -> list[MessageResponse]:
    return [
        MessageResponse.from_entity(item)
        for item in service.list_messages(session_id=session_id)
    ]


@router.post("/messages/list", response_model=list[MessageResponse])
def list_messages_post(
    payload: MessageListRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> list[MessageResponse]:
    return [
        MessageResponse.from_entity(item)
        for item in service.list_messages(session_id=payload.session_id)
    ]


@router.post("/run-requests", response_model=RunRequestResponse)
def create_run_request(
    payload: RunRequestCreateRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> RunRequestResponse:
    entity = service.create_run_request(payload)
    return RunRequestResponse.from_entity(entity)


@router.get("/run-requests", response_model=list[RunRequestResponse])
def list_run_requests(
    session_id: str = Query(...),
    service: SessionApplicationService = Depends(get_session_application_service)) -> list[RunRequestResponse]:
    return [
        RunRequestResponse.from_entity(item)
        for item in service.list_run_requests(session_id=session_id)
    ]


@router.post("/run-requests/list", response_model=list[RunRequestResponse])
def list_run_requests_post(
    payload: RunRequestListRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> list[RunRequestResponse]:
    return [
        RunRequestResponse.from_entity(item)
        for item in service.list_run_requests(session_id=payload.session_id)
    ]


@router.post("/run-requests/detail", response_model=RunRequestResponse)
def get_run_request(
    payload: RunRequestDetailRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> RunRequestResponse:
    entity = service.run_request_repository.get_by_id(run_request_id=payload.run_request_id)
    if entity is None:
        raise HTTPException(status_code=404, detail=error_detail("error.run_request.not_found", id=payload.run_request_id))
    return RunRequestResponse.from_entity(entity)


@router.post("/run-requests/update", response_model=RunRequestResponse)
def update_run_request(
    payload: RunRequestUpdateRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> RunRequestResponse:
    entity = service.update_run_request(payload)
    if entity is None:
        raise HTTPException(status_code=404, detail=error_detail("error.run_request.not_found", id=payload.run_request_id))
    return RunRequestResponse.from_entity(entity)