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

from core_domain import ServiceHealth
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.infrastructure.runtime_client import RuntimeServiceClient, RuntimeServiceClientError
from app.schemas.message import MessageCreateRequest, MessageResponse
from app.schemas.run_request import (
    DispatchRunRequest,
    DispatchRunResponse,
    RunRequestCreateRequest,
    RunRequestResponse,
)
from app.schemas.session import SessionCreateRequest, 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),
        runtime_client=RuntimeServiceClient(base_url=settings.runtime_service_url))


@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("/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("/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/dispatch", response_model=DispatchRunResponse)
def dispatch_run_request(
    payload: DispatchRunRequest,
    service: SessionApplicationService = Depends(get_session_application_service)) -> DispatchRunResponse:
    try:
        return service.dispatch_run_request(payload)
    except RuntimeServiceClientError as exc:
        raise HTTPException(status_code=502, detail=str(exc)) from exc