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

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -1,13 +1,14 @@
 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,
@@ -53,6 +54,7 @@ async def get_all_sessions(
                 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,
             )
@@ -79,7 +81,7 @@ async def search_sessions(
     session_service: SessionService = Depends(get_session_business_service),
 ):
     """
-    Search sessions by name or content.
+    Search sessions by name/title only.
     """
     user_id = user.get("id")
     log.info(
@@ -105,6 +107,7 @@ async def search_sessions(
                 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,
             )
@@ -474,6 +477,11 @@ async def update_session_name(
 
     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(
@@ -556,6 +564,7 @@ async def move_session_to_project(
 ):
     """
     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(
@@ -575,7 +584,7 @@ async def move_session_to_project(
                 status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
-        updated_session = session_service.move_session_to_project(
+        updated_session = await session_service.move_session_to_project(
             db=db,
             session_id=session_id,
             user_id=user_id,

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)}")

solace_agent_mesh/gateway/http_sse/routers/sse.py

@@ -5,12 +5,14 @@ API Router for Server-Sent Events (SSE) subscriptions.
 import logging
 import asyncio
 import json
-from fastapi import APIRouter, Depends, Request as FastAPIRequest, HTTPException, status
+from fastapi import APIRouter, Depends, Request as FastAPIRequest, HTTPException, status, Query
+from sqlalchemy.orm import Session as DBSession
 
 from sse_starlette.sse import EventSourceResponse
 
 from ....gateway.http_sse.sse_manager import SSEManager
-from ....gateway.http_sse.dependencies import get_sse_manager
+from ....gateway.http_sse.dependencies import get_sse_manager, get_db
+from ....gateway.http_sse.repository.task_repository import TaskRepository
 
 log = logging.getLogger(__name__)
 trace_logger = logging.getLogger("sam_trace")
@@ -23,16 +25,32 @@ router = APIRouter()
 async def subscribe_to_task_events(
     task_id: str,
     request: FastAPIRequest,
+    reconnect: bool = Query(False, description="Whether this is a reconnection attempt"),
+    last_event_timestamp: int = Query(0, description="Timestamp of last received event for replay"),
     sse_manager: SSEManager = Depends(get_sse_manager),
+    db: DBSession = Depends(get_db),
 ):
     """
     Establishes an SSE connection to receive real-time updates for a specific task.
+    
+    Args:
+        task_id: The task to monitor
+        reconnect: If true, replay missed events before streaming live
+        last_event_timestamp: Timestamp of last received event (for replay)
     """
     log_prefix = "[GET /api/v1/sse/subscribe/%s] " % task_id
-    log.debug("%sClient requesting SSE subscription.", log_prefix)
+    log.debug("%sClient requesting SSE subscription (reconnect=%s).", log_prefix, reconnect)
 
     connection_queue: asyncio.Queue = None
     try:
+        # Check if this is a background task
+        repo = TaskRepository()
+        task = repo.find_by_id(db, task_id)
+        is_background_task = task and task.background_execution_enabled
+        
+        if is_background_task:
+            log.info("%sTask %s is a background task.", log_prefix, task_id)
+        
         connection_queue = await sse_manager.create_sse_connection(task_id)
         log.debug("%sSSE connection queue created.", log_prefix)
 
@@ -42,6 +60,87 @@ async def subscribe_to_task_events(
             try:
                 yield {"comment": "SSE connection established"}
                 log.debug("%sSent initial SSE comment.", log_prefix)
+                
+                # If reconnecting, replay missed events from database
+                # For background tasks, always replay ALL events from the beginning
+                # to ensure the frontend can reconstruct the full message content
+                # after a browser refresh
+                if reconnect:
+                    replay_from_timestamp = last_event_timestamp if last_event_timestamp > 0 else 0
+                    
+                    # For background tasks, always replay from the beginning
+                    # This handles the case where the browser was refreshed and
+                    # the accumulated message content was lost
+                    if is_background_task:
+                        replay_from_timestamp = 0
+                        log.info("%sBackground task reconnection - replaying ALL events from beginning", log_prefix)
+                    else:
+                        log.info("%sReplaying events since timestamp %d", log_prefix, replay_from_timestamp)
+                    
+                    task_with_events = repo.find_by_id_with_events(db, task_id)
+                    if task_with_events:
+                        _, events = task_with_events
+                        # Use >= for timestamp 0 to include all events
+                        missed_events = [e for e in events if e.created_time > replay_from_timestamp]
+                        log.info("%sReplaying %d missed events", log_prefix, len(missed_events))
+                        
+                        # For background tasks, filter out intermediate artifact update events
+                        # to prevent duplicate artifacts in chat. Only keep the final task response
+                        # which contains the complete artifact list.
+                        if is_background_task:
+                            # Find if there's a final task response
+                            has_final_response = any(
+                                e.direction == "response" and
+                                "result" in e.payload and
+                                e.payload.get("result", {}).get("kind") == "task"
+                                for e in missed_events
+                            )
+                            
+                            if has_final_response:
+                                # Filter out artifact-update events since the final response contains all artifacts
+                                filtered_events = []
+                                for e in missed_events:
+                                    if e.direction == "response" and "result" in e.payload:
+                                        result = e.payload.get("result", {})
+                                        if result.get("kind") == "artifact-update":
+                                            log.debug(
+                                                "%sFiltering out intermediate artifact-update event during replay",
+                                                log_prefix
+                                            )
+                                            continue
+                                    filtered_events.append(e)
+                                missed_events = filtered_events
+                                log.info(
+                                    "%sFiltered to %d events (removed intermediate artifact updates)",
+                                    log_prefix,
+                                    len(missed_events)
+                                )
+                        
+                        for event in missed_events:
+                            # The payload is already a JSON-RPC response, just need to determine event type
+                            # and yield it in the same format as live events
+                            event_type = "status_update"  # Default
+                            
+                            # Determine event type from the payload structure
+                            if event.direction == "response":
+                                # Check if it's a final response (Task object) or status update
+                                if "result" in event.payload:
+                                    result = event.payload.get("result", {})
+                                    if result.get("kind") == "task":
+                                        event_type = "final_response"
+                                    elif result.get("kind") == "status-update":
+                                        event_type = "status_update"
+                                    elif result.get("kind") == "artifact-update":
+                                        event_type = "artifact_update"
+                            
+                            # Yield the event in SSE format
+                            # The payload is already the complete JSON-RPC response
+                            yield {
+                                "event": event_type,
+                                "data": json.dumps(event.payload)
+                            }
+                        
+                        log.info("%sFinished replaying missed events", log_prefix)
 
                 loop_count = 0
                 while True:
@@ -55,7 +154,16 @@ async def subscribe_to_task_events(
                         "%sRequest disconnected status: %s", log_prefix, disconnected
                     )
                     if disconnected:
-                        log.info("%sClient disconnected. Breaking loop.", log_prefix)
+                        if is_background_task:
+                            log.info(
+                                "%sClient disconnected from background task %s. Draining buffers and exiting SSE stream.",
+                                log_prefix,
+                                task_id
+                            )
+                            # For background tasks, we need to drain the buffers to prevent overflow
+                            # The task will continue running, but we stop consuming events
+                        else:
+                            log.info("%sClient disconnected. Breaking loop.", log_prefix)
                         break
 
                     try:
@@ -135,6 +243,11 @@ async def subscribe_to_task_events(
                 if connection_queue:
                     await sse_manager.remove_sse_connection(task_id, connection_queue)
                     log.info("%sRemoved SSE connection queue from manager.", log_prefix)
+                    
+                    # If this was a background task, drain the buffer to prevent overflow
+                    if is_background_task:
+                        await sse_manager.drain_buffer_for_background_task(task_id)
+                        log.info("%sDrained buffer for background task %s", log_prefix, task_id)
 
         return EventSourceResponse(event_generator())