solace-agent-mesh 1.11.2__py3-none-any.whl

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 ..shared.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

@@ -0,0 +1,230 @@
+"""
+API Router for Server-Sent Events (SSE) subscriptions.
+"""
+
+import logging
+import asyncio
+import json
+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, get_db
+from ....gateway.http_sse.repository.task_repository import TaskRepository
+
+log = logging.getLogger(__name__)
+trace_logger = logging.getLogger("sam_trace")
+
+
+router = APIRouter()
+
+
+@router.get("/subscribe/{task_id}")
+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 (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)
+
+        async def event_generator():
+            nonlocal connection_queue
+            log.debug("%sSSE event generator started.", log_prefix)
+            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 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:
+                    loop_count += 1
+                    log.debug(
+                        "%sEvent generator loop iteration: %d", log_prefix, loop_count
+                    )
+
+                    disconnected = await request.is_disconnected()
+                    log.debug(
+                        "%sRequest disconnected status: %s", log_prefix, disconnected
+                    )
+                    if disconnected:
+                        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:
+                        log.debug("%sWaiting for event from queue...", log_prefix)
+                        event_payload = await asyncio.wait_for(
+                            connection_queue.get(), timeout=120
+                        )
+                        log.debug(
+                            "%sReceived from queue: %s",
+                            log_prefix,
+                            event_payload is not None,
+                        )
+
+                        if event_payload is None:
+                            log.info(
+                                "%sReceived None sentinel. Closing connection. Breaking loop.",
+                                log_prefix,
+                            )
+                            break
+                        if trace_logger.isEnabledFor(logging.DEBUG):
+                            trace_logger.debug(
+                                "%sYielding event_payload: %s",
+                                log_prefix, event_payload
+                            )
+                        else:
+                            log.debug(
+                                "%sYielding event: %s",
+                                log_prefix,
+                                event_payload.get("event") if event_payload else "unknown"
+                            )
+                        yield event_payload
+                        connection_queue.task_done()
+                        log.debug(
+                            "%sSent event: %s", log_prefix, event_payload.get("event")
+                        )
+
+                    except asyncio.TimeoutError:
+                        log.debug(
+                            "%sSSE queue wait timed out (iteration %d), checking disconnect status.",
+                            log_prefix,
+                            loop_count,
+                        )
+                        continue
+                    except asyncio.CancelledError:
+                        log.info(
+                            "%sSSE event generator cancelled. Breaking loop.",
+                            log_prefix,
+                        )
+                        break
+                    except Exception as q_err:
+                        log.error(
+                            "%sError getting event from queue: %s. Breaking loop.",
+                            log_prefix,
+                            q_err,
+                            exc_info=True,
+                        )
+                        yield {
+                            "event": "error",
+                            "data": json.dumps({"error": "Internal queue error"}),
+                        }
+                        break
+
+            except asyncio.CancelledError:
+                log.info(
+                    "%sSSE event generator explicitly cancelled. Breaking loop.",
+                    log_prefix,
+                )
+            except Exception as gen_err:
+                log.error(
+                    "%sError in SSE event generator: %s",
+                    log_prefix,
+                    gen_err,
+                    exc_info=True,
+                )
+            finally:
+                log.info("%sSSE event generator finished.", log_prefix)
+                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())
+
+    except Exception as e:
+        log.exception("%sError establishing SSE connection: %s", log_prefix, e)
+
+        if connection_queue:
+            await sse_manager.remove_sse_connection(task_id, connection_queue)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to establish SSE connection: %s" % e,
+        )