solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -1,15 +1,19 @@
 import logging
+from typing import Optional
 from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
+from pydantic import ValidationError
 from sqlalchemy.orm import Session
 
 from ..dependencies import get_session_business_service, get_db
 from ..services.session_service import SessionService
-from ..shared.auth_utils import get_current_user
-from ..shared.pagination import DataResponse, PaginatedResponse, PaginationParams
-from ..shared.response_utils import create_data_response
+from solace_agent_mesh.shared.api.auth_utils import get_current_user
+from solace_agent_mesh.shared.api.pagination import DataResponse, PaginatedResponse, PaginationParams
+from solace_agent_mesh.shared.api.response_utils import create_data_response
 from .dto.requests.session_requests import (
     GetSessionRequest,
     UpdateSessionRequest,
+    MoveSessionRequest,
+    SearchSessionsRequest,
 )
 from .dto.requests.task_requests import SaveTaskRequest
 from .dto.responses.session_responses import SessionResponse
@@ -24,6 +28,7 @@ SESSION_NOT_FOUND_MSG = "Session not found."
 
 @router.get("/sessions", response_model=PaginatedResponse[SessionResponse])
 async def get_all_sessions(
+    project_id: Optional[str] = Query(default=None, alias="project_id"),
     page_number: int = Query(default=1, ge=1, alias="pageNumber"),
     page_size: int = Query(default=20, ge=1, le=100, alias="pageSize"),
     db: Session = Depends(get_db),
@@ -31,10 +36,14 @@ async def get_all_sessions(
     session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
+    log_msg = f"User '{user_id}' is listing sessions with pagination (page={page_number}, size={page_size})"
+    if project_id:
+        log_msg += f" filtered by project_id={project_id}"
+    log.info(log_msg)
 
     try:
         pagination = PaginationParams(page_number=page_number, page_size=page_size)
-        paginated_response = session_service.get_user_sessions(db, user_id, pagination)
+        paginated_response = session_service.get_user_sessions(db, user_id, pagination, project_id=project_id)
 
         session_responses = []
         for session_domain in paginated_response.data:
@@ -43,6 +52,9 @@ async def get_all_sessions(
                 user_id=session_domain.user_id,
                 name=session_domain.name,
                 agent_id=session_domain.agent_id,
+                project_id=session_domain.project_id,
+                project_name=session_domain.project_name,
+                has_running_background_task=session_domain.has_running_background_task,
                 created_time=session_domain.created_time,
                 updated_time=session_domain.updated_time,
             )
@@ -58,6 +70,64 @@ async def get_all_sessions(
         ) from e
 
 
+@router.get("/sessions/search", response_model=PaginatedResponse[SessionResponse])
+async def search_sessions(
+    query: str = Query(..., min_length=1, description="Search query"),
+    project_id: Optional[str] = Query(default=None, alias="projectId"),
+    page_number: int = Query(default=1, ge=1, alias="pageNumber"),
+    page_size: int = Query(default=20, ge=1, le=100, alias="pageSize"),
+    db: Session = Depends(get_db),
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_business_service),
+):
+    """
+    Search sessions by name/title only.
+    """
+    user_id = user.get("id")
+    log.info(
+        "User %s searching sessions with query '%s' (page=%d, size=%d)",
+        user_id,
+        query,
+        page_number,
+        page_size,
+    )
+
+    try:
+        pagination = PaginationParams(page_number=page_number, page_size=page_size)
+        paginated_response = session_service.search_sessions(
+            db, user_id, query, pagination, project_id=project_id
+        )
+
+        session_responses = []
+        for session_domain in paginated_response.data:
+            session_response = SessionResponse(
+                id=session_domain.id,
+                user_id=session_domain.user_id,
+                name=session_domain.name,
+                agent_id=session_domain.agent_id,
+                project_id=session_domain.project_id,
+                project_name=session_domain.project_name,
+                has_running_background_task=session_domain.has_running_background_task,
+                created_time=session_domain.created_time,
+                updated_time=session_domain.updated_time,
+            )
+            session_responses.append(session_response)
+
+        return PaginatedResponse(data=session_responses, meta=paginated_response.meta)
+
+    except ValueError as e:
+        log.warning("Validation error searching sessions: %s", e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+        ) from e
+    except Exception as e:
+        log.error("Error searching sessions for user %s: %s", user_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to search sessions",
+        ) from e
+
+
 @router.get("/sessions/{session_id}", response_model=DataResponse[SessionResponse])
 async def get_session(
     session_id: str,
@@ -95,6 +165,7 @@ async def get_session(
             user_id=session_domain.user_id,
             name=session_domain.name,
             agent_id=session_domain.agent_id,
+            project_id=session_domain.project_id,
             created_time=session_domain.created_time,
             updated_time=session_domain.updated_time,
         )
@@ -129,7 +200,7 @@ async def save_task(
     Creates a new task or updates an existing one.
     """
     user_id = user.get("id")
-    log.info(
+    log.debug(
         "User %s attempting to save task %s for session %s",
         user_id,
         request.task_id,
@@ -399,12 +470,18 @@ async def update_session_name(
             user_id=updated_domain.user_id,
             name=updated_domain.name,
             agent_id=updated_domain.agent_id,
+            project_id=updated_domain.project_id,
             created_time=updated_domain.created_time,
             updated_time=updated_domain.updated_time,
         )
 
     except HTTPException:
         raise
+    except ValidationError as e:
+        log.warning("Pydantic validation error updating session %s: %s", session_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+        ) from e
     except ValueError as e:
         log.warning("Validation error updating session %s: %s", session_id, e)
         raise HTTPException(
@@ -430,8 +507,11 @@ async def delete_session(
     user: dict = Depends(get_current_user),
     session_service: SessionService = Depends(get_session_business_service),
 ):
+    """
+    Soft delete a session (marks as deleted without removing from database).
+    """
     user_id = user.get("id")
-    log.info("User %s attempting to delete session %s", user_id, session_id)
+    log.info("User %s attempting to soft delete session %s", user_id, session_id)
 
     try:
         if (
@@ -452,7 +532,7 @@ async def delete_session(
                 status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
-        log.info("Session %s deleted successfully", session_id)
+        log.info("Session %s soft deleted successfully", session_id)
 
     except HTTPException:
         raise
@@ -472,3 +552,83 @@ async def delete_session(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to delete session",
         ) from e
+
+
+@router.patch("/sessions/{session_id}/project", response_model=SessionResponse)
+async def move_session_to_project(
+    session_id: str,
+    request: MoveSessionRequest,
+    db: Session = Depends(get_db),
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_business_service),
+):
+    """
+    Move a session to a different project or remove from project.
+    When moving to a project, artifacts from that project are immediately copied to the session.
+    """
+    user_id = user.get("id")
+    log.info(
+        "User %s attempting to move session %s to project %s",
+        user_id,
+        session_id,
+        request.project_id,
+    )
+
+    try:
+        if (
+            not session_id
+            or session_id.strip() == ""
+            or session_id in ["null", "undefined"]
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
+            )
+
+        updated_session = await session_service.move_session_to_project(
+            db=db,
+            session_id=session_id,
+            user_id=user_id,
+            new_project_id=request.project_id,
+        )
+
+        if not updated_session:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
+            )
+
+        log.info(
+            "Session %s moved to project %s successfully",
+            session_id,
+            request.project_id or "None",
+        )
+
+        return SessionResponse(
+            id=updated_session.id,
+            user_id=updated_session.user_id,
+            name=updated_session.name,
+            agent_id=updated_session.agent_id,
+            project_id=updated_session.project_id,
+            created_time=updated_session.created_time,
+            updated_time=updated_session.updated_time,
+        )
+
+    except HTTPException:
+        raise
+    except ValueError as e:
+        log.warning("Validation error moving session %s: %s", session_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+        ) from e
+    except Exception as e:
+        log.error(
+            "Error moving session %s for user %s: %s",
+            session_id,
+            user_id,
+            e,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to move session",
+        ) from e
+
+

solace_agent_mesh/gateway/http_sse/routers/speech.py

@@ -0,0 +1,355 @@
+"""
+Speech API routes for STT and TTS functionality.
+"""
+
+from typing import Optional
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+from fastapi.responses import StreamingResponse, Response
+from pydantic import BaseModel
+
+from solace_ai_connector.common.log import log
+
+from ..services.audio_service import AudioService
+from ..dependencies import get_audio_service
+from solace_agent_mesh.shared.api.auth_utils import get_current_user
+
+
+router = APIRouter()
+
+
+class TTSRequest(BaseModel):
+    """Request model for text-to-speech"""
+    input: str
+    voice: Optional[str] = None
+    messageId: Optional[str] = None
+    provider: Optional[str] = None
+
+
+class StreamTTSRequest(BaseModel):
+    """Request model for streaming text-to-speech"""
+    input: str
+    voice: Optional[str] = None
+    runId: Optional[str] = None
+    provider: Optional[str] = None
+
+
+@router.post("/stt")
+async def speech_to_text(
+    audio: UploadFile = File(...),
+    provider: Optional[str] = Form(None),
+    language: Optional[str] = Form(None),
+    user: dict = Depends(get_current_user),
+    audio_service: AudioService = Depends(get_audio_service)
+):
+    """
+    Transcribe audio to text using configured STT service.
+    
+    Args:
+        audio: Audio file (wav, mp3, webm, ogg)
+        provider: Optional provider override (openai, azure)
+        language: Optional language code (e.g., "en-US", "es-ES")
+        user: Current authenticated user
+        audio_service: Audio service instance
+    
+    Returns:
+        JSON with transcribed text:
+        {
+            "text": "transcribed text",
+            "language": "en",
+            "duration": 5.2
+        }
+    
+    Raises:
+        HTTPException: If transcription fails
+    """
+    log.info(
+        "[SpeechAPI] STT request from user=%s, filename=%s, provider=%s, language=%s",
+        user.get("user_id"),
+        audio.filename,
+        provider,
+        language
+    )
+    
+    try:
+        # Validate content type
+        if not audio.content_type or not audio.content_type.startswith("audio/"):
+            raise HTTPException(
+                415,
+                f"Unsupported media type: {audio.content_type}. Expected audio/*"
+            )
+        
+        result = await audio_service.transcribe_audio(
+            audio_file=audio,
+            user_id=user.get("user_id", "anonymous"),
+            session_id=user.get("session_id", "default"),
+            app_name=user.get("app_name", "webui"),
+            provider=provider,
+            language=language
+        )
+        
+        return result.to_dict()
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.exception("[SpeechAPI] STT error: %s", e)
+        raise HTTPException(500, f"Transcription failed: {str(e)}")
+
+
+@router.post("/tts")
+async def text_to_speech(
+    request: TTSRequest,
+    user: dict = Depends(get_current_user),
+    audio_service: AudioService = Depends(get_audio_service)
+):
+    """
+    Convert text to speech using configured TTS service.
+    
+    Args:
+        request: TTS request with text and voice
+        user: Current authenticated user
+        audio_service: Audio service instance
+    
+    Returns:
+        Audio data as MP3
+    
+    Raises:
+        HTTPException: If generation fails
+    """
+    log.info(
+        "[SpeechAPI] TTS request from user=%s, text_len=%d, voice=%s",
+        user.get("user_id"),
+        len(request.input),
+        request.voice
+    )
+    
+    try:
+        # Validate input
+        if not request.input or not request.input.strip():
+            raise HTTPException(400, "Input text is required")
+        
+        if len(request.input) > 10000:
+            raise HTTPException(
+                413,
+                "Text too long (max 10000 characters). Use /tts/stream for longer text."
+            )
+        
+        audio_data = await audio_service.generate_speech(
+            text=request.input,
+            voice=request.voice,
+            user_id=user.get("user_id", "anonymous"),
+            session_id=user.get("session_id", "default"),
+            app_name=user.get("app_name", "webui"),
+            message_id=request.messageId,
+            provider=request.provider  # NEW: Pass provider from request
+        )
+        
+        return Response(
+            content=audio_data,
+            media_type="audio/mpeg"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.exception("[SpeechAPI] TTS error: %s", e)
+        raise HTTPException(500, f"TTS generation failed: {str(e)}")
+
+
+@router.post("/tts/stream")
+async def stream_audio(
+    request: StreamTTSRequest,
+    user: dict = Depends(get_current_user),
+    audio_service: AudioService = Depends(get_audio_service)
+):
+    """
+    Stream TTS audio for long text (>4096 chars).
+    Uses chunking and streaming for better UX.
+    
+    Args:
+        request: Stream TTS request with text and voice
+        user: Current authenticated user
+        audio_service: Audio service instance
+    
+    Returns:
+        Streaming audio response
+    
+    Raises:
+        HTTPException: If generation fails
+    """
+    log.info(
+        "[SpeechAPI] TTS stream request from user=%s, text_len=%d",
+        user.get("user_id"),
+        len(request.input)
+    )
+    
+    try:
+        # Validate input
+        if not request.input or not request.input.strip():
+            raise HTTPException(400, "Input text is required")
+        
+        # Add max length validation to prevent abuse (100KB max for streaming)
+        if len(request.input) > 100000:
+            raise HTTPException(
+                413,
+                "Text too long (max 100000 characters for streaming)"
+            )
+        
+        async def audio_generator():
+            async for chunk in audio_service.stream_speech(
+                text=request.input,
+                voice=request.voice,
+                user_id=user.get("user_id", "anonymous"),
+                session_id=user.get("session_id", "default"),
+                app_name=user.get("app_name", "webui"),
+                provider=request.provider  # Pass provider from request
+            ):
+                yield chunk
+        
+        return StreamingResponse(
+            audio_generator(),
+            media_type="audio/mpeg",
+            headers={
+                "Content-Disposition": f"inline; filename=tts_stream_{request.runId or 'audio'}.mp3",
+                "Cache-Control": "no-cache"
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.exception("[SpeechAPI] TTS stream error: %s", e)
+        raise HTTPException(500, f"TTS streaming failed: {str(e)}")
+
+
+@router.get("/voices")
+async def get_voices(
+    provider: Optional[str] = None,  # NEW: Accept provider as query parameter
+    user: dict = Depends(get_current_user),
+    audio_service: AudioService = Depends(get_audio_service)
+):
+    """
+    Get available TTS voices based on configuration and provider.
+    
+    Args:
+        provider: Optional provider filter (azure, gemini)
+        user: Current authenticated user
+        audio_service: Audio service instance
+    
+    Returns:
+        JSON with available voices:
+        {
+            "voices": ["Kore", "Puck", "Zephyr", ...],
+            "default": "Kore"
+        }
+    """
+    log.debug("[SpeechAPI] Voices request from user=%s, provider=%s", user.get("user_id"), provider)
+    
+    try:
+        voices = await audio_service.get_available_voices(provider=provider)  # Pass provider
+        
+        # Get default voice from config
+        config = audio_service.get_speech_config()
+        default_voice = config.get("voice", "Kore")
+        
+        return {
+            "voices": voices,
+            "default": default_voice
+        }
+        
+    except Exception as e:
+        log.exception("[SpeechAPI] Error getting voices: %s", e)
+        raise HTTPException(500, f"Failed to get voices: {str(e)}")
+
+
+@router.get("/config")
+async def get_speech_config(
+    user: dict = Depends(get_current_user),
+    audio_service: AudioService = Depends(get_audio_service)
+):
+    """
+    Get speech configuration for frontend initialization.
+    
+    Args:
+        user: Current authenticated user
+        audio_service: Audio service instance
+    
+    Returns:
+        JSON with speech configuration:
+        {
+            "sttExternal": true,
+            "ttsExternal": true,
+            "speechToText": true,
+            "textToSpeech": true,
+            "engineSTT": "external",
+            "engineTTS": "external",
+            "voice": "Kore",
+            "playbackRate": 1.0,
+            "cacheTTS": true,
+            ...
+        }
+    """
+    log.debug("[SpeechAPI] Config request from user=%s", user.get("user_id"))
+    
+    try:
+        config = audio_service.get_speech_config()
+        return config
+        
+    except Exception as e:
+        log.exception("[SpeechAPI] Error getting config: %s", e)
+        raise HTTPException(500, f"Failed to get config: {str(e)}")
+
+
+@router.post("/voice-sample")
+async def get_voice_sample(
+    voice: str = Form(...),
+    provider: Optional[str] = Form(None),
+    user: dict = Depends(get_current_user),
+    audio_service: AudioService = Depends(get_audio_service)
+):
+    """
+    Generate a sample audio for a specific voice to preview before selection.
+    
+    Args:
+        voice: Voice name to sample
+        provider: Optional provider (azure, gemini)
+        user: Current authenticated user
+        audio_service: Audio service instance
+    
+    Returns:
+        Audio data as MP3
+    
+    Raises:
+        HTTPException: If generation fails
+    """
+    log.debug("[SpeechAPI] Voice sample request from user=%s, voice=%s, provider=%s",
+              user.get("user_id"), voice, provider)
+    
+    try:
+        # Validate voice parameter
+        if not voice or not voice.strip():
+            raise HTTPException(400, "Voice parameter is required")
+        
+        # Generate a sample text based on provider
+        sample_text = "Hello! This is a sample of my voice. I hope you find it pleasant to listen to."
+        
+        audio_data = await audio_service.generate_speech(
+            text=sample_text,
+            voice=voice,
+            user_id=user.get("user_id", "anonymous"),
+            session_id=user.get("session_id", "default"),
+            app_name=user.get("app_name", "webui"),
+            message_id=f"voice_sample_{voice}",
+            provider=provider
+        )
+        
+        return Response(
+            content=audio_data,
+            media_type="audio/mpeg"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.exception("[SpeechAPI] Voice sample error: %s", e)
+        raise HTTPException(500, f"Voice sample generation failed: {str(e)}")