Complete Step 2: WebSocket Conversation Bridge

- Implement ConversationService for managing active AI conversations
- Add REST API endpoints for conversation control (/api/conversations/*)
- Integrate ConversationManager with WebSocket broadcasting
- Create comprehensive test script for end-to-end validation
- Update WebSocket client for Gradio compatibility (remove Streamlit deps)
- Switch frontend framework from Streamlit to Gradio in architecture
- Fix Python 3.9+ type hints compatibility
- Add prominent Quick Demo section to PROJECT_STATE.md
- Successfully tested full 3-terminal pipeline (Ollama + FastAPI + WebSocket)

Real-time AI-to-AI conversation streaming now fully operational.

backend/api/main.py

@@ -14,9 +14,16 @@ Typical usage:
 from fastapi import FastAPI, WebSocket
 from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
+import logging
 
-# Import WebSocket endpoint
-from .websockets.conversation_ws import websocket_endpoint
+# Import WebSocket endpoint and manager
+from .websockets.conversation_ws import websocket_endpoint, manager
+from .routes.conversations import router as conversations_router
+from .services.conversation_service import initialize_conversation_service
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Initialize FastAPI app
 app = FastAPI(
@@ -28,12 +35,30 @@ app = FastAPI(
 # Configure CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["http://localhost:8501"],  # Streamlit frontend
+    allow_origins=[
+        "http://localhost:8501",  # Streamlit (legacy)
+        "http://localhost:7860",  # Gradio default port
+        "http://127.0.0.1:7860",  # Gradio alternative
+    ],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# Include API routes
+app.include_router(conversations_router)
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize services on startup."""
+    logger.info("Initializing AI Survey Simulator API...")
+
+    # Initialize conversation service with WebSocket manager
+    initialize_conversation_service(manager)
+
+    logger.info("API startup complete")
+
 
 @app.get("/")
 async def root():

backend/api/routes/conversations.py

@@ -0,0 +1,287 @@
+"""REST API routes for conversation management.
+
+This module provides HTTP endpoints for controlling AI-to-AI conversations,
+managing personas, and retrieving conversation status information.
+
+Routes:
+    POST /api/conversations/start - Start a new conversation
+    GET /api/conversations/{conversation_id}/status - Get conversation status
+    POST /api/conversations/{conversation_id}/stop - Stop a conversation
+    GET /api/conversations - List active conversations
+    GET /api/personas - List available personas
+
+Example:
+    POST /api/conversations/start
+    {
+        "conversation_id": "conv_123",
+        "surveyor_persona_id": "surveyor_001",
+        "patient_persona_id": "patient_001"
+    }
+"""
+
+from fastapi import APIRouter, HTTPException, BackgroundTasks
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional
+import logging
+import sys
+from pathlib import Path
+
+# Add backend to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from api.services.conversation_service import get_conversation_service
+from core.persona_system import PersonaSystem
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+# Create router
+router = APIRouter(prefix="/api", tags=["conversations"])
+
+
+# Request/Response models
+class StartConversationRequest(BaseModel):
+    """Request model for starting a conversation."""
+    conversation_id: str = Field(..., description="Unique identifier for the conversation")
+    surveyor_persona_id: str = Field(..., description="ID of the surveyor persona")
+    patient_persona_id: str = Field(..., description="ID of the patient persona")
+    host: str = Field(default="http://localhost:11434", description="Ollama server host")
+    model: str = Field(default="llama2:7b", description="LLM model to use")
+
+
+class ConversationStatusResponse(BaseModel):
+    """Response model for conversation status."""
+    conversation_id: str
+    status: str
+    surveyor_persona_id: str
+    patient_persona_id: str
+    created_at: str
+    message_count: int
+
+
+class PersonaResponse(BaseModel):
+    """Response model for persona information."""
+    id: str
+    name: str
+    role: str
+    description: str
+
+
+class ErrorResponse(BaseModel):
+    """Error response model."""
+    error: str
+    detail: Optional[str] = None
+
+
+# Initialize persona system
+persona_system = PersonaSystem()
+
+
+@router.post("/conversations/start")
+async def start_conversation(request: StartConversationRequest) -> Dict[str, str]:
+    """Start a new AI-to-AI conversation.
+
+    Args:
+        request: Conversation start request with persona IDs
+
+    Returns:
+        Dict with success message and conversation_id
+
+    Raises:
+        HTTPException: If conversation fails to start
+    """
+    try:
+        service = get_conversation_service()
+
+        success = await service.start_conversation(
+            conversation_id=request.conversation_id,
+            surveyor_persona_id=request.surveyor_persona_id,
+            patient_persona_id=request.patient_persona_id,
+            host=request.host,
+            model=request.model
+        )
+
+        if success:
+            logger.info(f"Started conversation {request.conversation_id}")
+            return {
+                "message": "Conversation started successfully",
+                "conversation_id": request.conversation_id
+            }
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail="Failed to start conversation"
+            )
+
+    except Exception as e:
+        logger.error(f"Error starting conversation: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal error starting conversation: {str(e)}"
+        )
+
+
+@router.get("/conversations/{conversation_id}/status")
+async def get_conversation_status(conversation_id: str) -> ConversationStatusResponse:
+    """Get the status of a specific conversation.
+
+    Args:
+        conversation_id: Unique identifier of the conversation
+
+    Returns:
+        ConversationStatusResponse with current status
+
+    Raises:
+        HTTPException: If conversation not found
+    """
+    try:
+        service = get_conversation_service()
+        status = await service.get_conversation_status(conversation_id)
+
+        if status is None:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Conversation {conversation_id} not found"
+            )
+
+        return ConversationStatusResponse(**status)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting conversation status: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal error retrieving status: {str(e)}"
+        )
+
+
+@router.post("/conversations/{conversation_id}/stop")
+async def stop_conversation(conversation_id: str) -> Dict[str, str]:
+    """Stop an active conversation.
+
+    Args:
+        conversation_id: Unique identifier of the conversation
+
+    Returns:
+        Dict with success message
+
+    Raises:
+        HTTPException: If conversation not found or cannot be stopped
+    """
+    try:
+        service = get_conversation_service()
+        success = await service.stop_conversation(conversation_id)
+
+        if success:
+            logger.info(f"Stopped conversation {conversation_id}")
+            return {
+                "message": "Conversation stopped successfully",
+                "conversation_id": conversation_id
+            }
+        else:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Conversation {conversation_id} not found"
+            )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error stopping conversation: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal error stopping conversation: {str(e)}"
+        )
+
+
+@router.get("/conversations")
+async def list_conversations() -> Dict[str, Dict]:
+    """List all active conversations.
+
+    Returns:
+        Dict mapping conversation_id to status information
+    """
+    try:
+        service = get_conversation_service()
+        conversations = await service.list_active_conversations()
+        return conversations
+
+    except Exception as e:
+        logger.error(f"Error listing conversations: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal error listing conversations: {str(e)}"
+        )
+
+
+@router.get("/personas")
+async def list_personas() -> Dict[str, List[PersonaResponse]]:
+    """List all available personas grouped by role.
+
+    Returns:
+        Dict with 'surveyors' and 'patients' lists of personas
+    """
+    try:
+        # Get all personas
+        surveyors = persona_system.list_personas("surveyor")
+        patients = persona_system.list_personas("patient")
+
+        # Format response
+        result = {
+            "surveyors": [
+                PersonaResponse(
+                    id=persona.get("id", ""),
+                    name=persona.get("name", "Unknown"),
+                    role="surveyor",
+                    description=persona.get("description", "")
+                )
+                for persona in surveyors
+            ],
+            "patients": [
+                PersonaResponse(
+                    id=persona.get("id", ""),
+                    name=persona.get("name", "Unknown"),
+                    role="patient",
+                    description=persona.get("description", "")
+                )
+                for persona in patients
+            ]
+        }
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Error listing personas: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal error listing personas: {str(e)}"
+        )
+
+
+@router.get("/health")
+async def health_check() -> Dict[str, str]:
+    """Health check endpoint for monitoring.
+
+    Returns:
+        Dict with service health status
+    """
+    try:
+        # Check if conversation service is available
+        service = get_conversation_service()
+
+        # Check if persona system is working
+        personas = persona_system.list_personas("surveyor")
+
+        return {
+            "status": "healthy",
+            "service": "conversation_api",
+            "personas_loaded": str(len(personas))
+        }
+
+    except Exception as e:
+        logger.error(f"Health check failed: {e}")
+        return {
+            "status": "unhealthy",
+            "error": str(e)
+        }

backend/api/services/conversation_service.py

@@ -0,0 +1,357 @@
+"""Conversation Service for managing active AI-to-AI conversations.
+
+This service acts as the bridge between the WebSocket interface and the
+ConversationManager. It handles the lifecycle of conversations, manages
+active instances, and coordinates message streaming to connected clients.
+
+Classes:
+    ConversationService: Main service for conversation management
+    ConversationInfo: Data class for conversation metadata
+
+Example:
+    service = ConversationService(websocket_manager)
+    conversation_id = await service.start_conversation(
+        surveyor_id="surveyor_001",
+        patient_id="patient_001"
+    )
+"""
+
+import asyncio
+import logging
+from datetime import datetime
+from typing import Dict, Optional, Set
+from dataclasses import dataclass
+from enum import Enum
+import sys
+from pathlib import Path
+
+# Add backend to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from core.conversation_manager import ConversationManager, ConversationState
+from core.persona_system import PersonaSystem
+from api.websockets.conversation_ws import ConnectionManager
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+
+class ConversationStatus(Enum):
+    """Status of managed conversations."""
+    STARTING = "starting"
+    RUNNING = "running"
+    PAUSED = "paused"
+    STOPPING = "stopping"
+    COMPLETED = "completed"
+    ERROR = "error"
+
+
+@dataclass
+class ConversationInfo:
+    """Information about an active conversation."""
+    conversation_id: str
+    surveyor_persona_id: str
+    patient_persona_id: str
+    status: ConversationStatus
+    created_at: datetime
+    message_count: int = 0
+    task: Optional[asyncio.Task] = None
+
+
+class ConversationService:
+    """Service for managing AI-to-AI conversation instances.
+
+    This service coordinates between the ConversationManager and WebSocket
+    infrastructure to provide real-time conversation streaming to web clients.
+
+    Attributes:
+        websocket_manager: WebSocket connection manager for broadcasting
+        persona_system: Persona system for loading personas
+        active_conversations: Dict of active conversation instances
+    """
+
+    def __init__(self, websocket_manager: ConnectionManager):
+        """Initialize conversation service.
+
+        Args:
+            websocket_manager: WebSocket manager for message broadcasting
+        """
+        self.websocket_manager = websocket_manager
+        self.persona_system = PersonaSystem()
+        self.active_conversations: Dict[str, ConversationInfo] = {}
+
+    async def start_conversation(self,
+                               conversation_id: str,
+                               surveyor_persona_id: str,
+                               patient_persona_id: str,
+                               host: str = "http://localhost:11434",
+                               model: str = "llama2:7b") -> bool:
+        """Start a new AI-to-AI conversation.
+
+        Args:
+            conversation_id: Unique identifier for the conversation
+            surveyor_persona_id: ID of the surveyor persona
+            patient_persona_id: ID of the patient persona
+            host: Ollama server host
+            model: LLM model to use
+
+        Returns:
+            True if conversation started successfully
+        """
+        if conversation_id in self.active_conversations:
+            logger.warning(f"Conversation {conversation_id} already exists")
+            return False
+
+        try:
+            # Load personas
+            surveyors = self.persona_system.list_personas("surveyor")
+            patients = self.persona_system.list_personas("patient")
+
+            surveyor_persona = next((p for p in surveyors if p.get("id") == surveyor_persona_id), None)
+            patient_persona = next((p for p in patients if p.get("id") == patient_persona_id), None)
+
+            if not surveyor_persona or not patient_persona:
+                await self._send_error(conversation_id, "Invalid persona IDs")
+                return False
+
+            # Create conversation info
+            conv_info = ConversationInfo(
+                conversation_id=conversation_id,
+                surveyor_persona_id=surveyor_persona_id,
+                patient_persona_id=patient_persona_id,
+                status=ConversationStatus.STARTING,
+                created_at=datetime.now()
+            )
+
+            self.active_conversations[conversation_id] = conv_info
+
+            # Send status update
+            await self._send_status_update(conversation_id, ConversationStatus.STARTING)
+
+            # Create and start conversation manager
+            manager = ConversationManager(
+                surveyor_persona=surveyor_persona,
+                patient_persona=patient_persona,
+                host=host,
+                model=model
+            )
+
+            # Start conversation streaming task
+            conv_info.task = asyncio.create_task(
+                self._stream_conversation(conversation_id, manager)
+            )
+
+            conv_info.status = ConversationStatus.RUNNING
+            await self._send_status_update(conversation_id, ConversationStatus.RUNNING)
+
+            logger.info(f"Started conversation {conversation_id}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to start conversation {conversation_id}: {e}")
+            await self._send_error(conversation_id, f"Failed to start conversation: {str(e)}")
+
+            # Clean up
+            if conversation_id in self.active_conversations:
+                del self.active_conversations[conversation_id]
+
+            return False
+
+    async def stop_conversation(self, conversation_id: str) -> bool:
+        """Stop an active conversation.
+
+        Args:
+            conversation_id: ID of conversation to stop
+
+        Returns:
+            True if conversation stopped successfully
+        """
+        if conversation_id not in self.active_conversations:
+            logger.warning(f"Conversation {conversation_id} not found")
+            return False
+
+        conv_info = self.active_conversations[conversation_id]
+
+        try:
+            conv_info.status = ConversationStatus.STOPPING
+            await self._send_status_update(conversation_id, ConversationStatus.STOPPING)
+
+            # Cancel the conversation task
+            if conv_info.task and not conv_info.task.done():
+                conv_info.task.cancel()
+                try:
+                    await conv_info.task
+                except asyncio.CancelledError:
+                    pass
+
+            # Update status and clean up
+            conv_info.status = ConversationStatus.COMPLETED
+            await self._send_status_update(conversation_id, ConversationStatus.COMPLETED)
+
+            del self.active_conversations[conversation_id]
+            logger.info(f"Stopped conversation {conversation_id}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Error stopping conversation {conversation_id}: {e}")
+            conv_info.status = ConversationStatus.ERROR
+            await self._send_error(conversation_id, f"Error stopping conversation: {str(e)}")
+            return False
+
+    async def get_conversation_status(self, conversation_id: str) -> Optional[Dict]:
+        """Get status of a conversation.
+
+        Args:
+            conversation_id: ID of conversation
+
+        Returns:
+            Dict with conversation status or None if not found
+        """
+        if conversation_id not in self.active_conversations:
+            return None
+
+        conv_info = self.active_conversations[conversation_id]
+        return {
+            "conversation_id": conversation_id,
+            "status": conv_info.status.value,
+            "surveyor_persona_id": conv_info.surveyor_persona_id,
+            "patient_persona_id": conv_info.patient_persona_id,
+            "created_at": conv_info.created_at.isoformat(),
+            "message_count": conv_info.message_count
+        }
+
+    async def list_active_conversations(self) -> Dict[str, Dict]:
+        """List all active conversations.
+
+        Returns:
+            Dict mapping conversation_id to status info
+        """
+        result = {}
+        for conv_id, conv_info in self.active_conversations.items():
+            result[conv_id] = {
+                "status": conv_info.status.value,
+                "surveyor_persona_id": conv_info.surveyor_persona_id,
+                "patient_persona_id": conv_info.patient_persona_id,
+                "created_at": conv_info.created_at.isoformat(),
+                "message_count": conv_info.message_count
+            }
+        return result
+
+    async def _stream_conversation(self, conversation_id: str, manager: ConversationManager):
+        """Stream conversation messages to WebSocket clients.
+
+        Args:
+            conversation_id: ID of the conversation
+            manager: ConversationManager instance to stream from
+        """
+        conv_info = self.active_conversations.get(conversation_id)
+        if not conv_info:
+            return
+
+        try:
+            async for message in manager.conduct_conversation():
+                # Check if conversation was stopped
+                if conversation_id not in self.active_conversations:
+                    break
+
+                # Update message count
+                conv_info.message_count += 1
+
+                # Add conversation metadata
+                websocket_message = {
+                    "type": "conversation_message",
+                    "conversation_id": conversation_id,
+                    **message
+                }
+
+                # Send to all connected clients
+                await self.websocket_manager.send_to_conversation(
+                    conversation_id, websocket_message
+                )
+
+                logger.debug(f"Streamed message {conv_info.message_count} for conversation {conversation_id}")
+
+        except asyncio.CancelledError:
+            logger.info(f"Conversation {conversation_id} streaming cancelled")
+            raise
+        except Exception as e:
+            logger.error(f"Error streaming conversation {conversation_id}: {e}")
+            conv_info.status = ConversationStatus.ERROR
+            await self._send_error(conversation_id, f"Streaming error: {str(e)}")
+        finally:
+            # Clean up conversation manager
+            try:
+                await manager.close()
+            except:
+                pass
+
+            # Mark as completed if not already in error state
+            if conv_info.status != ConversationStatus.ERROR:
+                conv_info.status = ConversationStatus.COMPLETED
+                await self._send_status_update(conversation_id, ConversationStatus.COMPLETED)
+
+    async def _send_status_update(self, conversation_id: str, status: ConversationStatus):
+        """Send conversation status update to clients.
+
+        Args:
+            conversation_id: ID of the conversation
+            status: New conversation status
+        """
+        message = {
+            "type": "conversation_status",
+            "conversation_id": conversation_id,
+            "status": status.value,
+            "timestamp": datetime.now().isoformat()
+        }
+
+        await self.websocket_manager.send_to_conversation(conversation_id, message)
+
+    async def _send_error(self, conversation_id: str, error_message: str):
+        """Send error message to clients.
+
+        Args:
+            conversation_id: ID of the conversation
+            error_message: Error description
+        """
+        message = {
+            "type": "conversation_error",
+            "conversation_id": conversation_id,
+            "error": error_message,
+            "timestamp": datetime.now().isoformat()
+        }
+
+        await self.websocket_manager.send_to_conversation(conversation_id, message)
+
+    async def cleanup(self):
+        """Clean up all active conversations."""
+        for conversation_id in list(self.active_conversations.keys()):
+            await self.stop_conversation(conversation_id)
+
+
+# Global service instance (initialized in main.py)
+conversation_service: Optional[ConversationService] = None
+
+
+def get_conversation_service() -> ConversationService:
+    """Get the global conversation service instance.
+
+    Returns:
+        ConversationService instance
+
+    Raises:
+        RuntimeError: If service not initialized
+    """
+    if conversation_service is None:
+        raise RuntimeError("ConversationService not initialized")
+    return conversation_service
+
+
+def initialize_conversation_service(websocket_manager: ConnectionManager):
+    """Initialize the global conversation service.
+
+    Args:
+        websocket_manager: WebSocket connection manager
+    """
+    global conversation_service
+    conversation_service = ConversationService(websocket_manager)
+    logger.info("ConversationService initialized")

backend/api/websockets/conversation_ws.py

@@ -174,9 +174,10 @@ def validate_message(data: dict) -> bool:
     # Validate message types
     valid_types = [
         "conversation_message",
-        "typing_indicator", 
+        "typing_indicator",
         "conversation_control",
-        "heartbeat"
+        "heartbeat",
+        "start_conversation"  # New message type
     ]
     
     if data["type"] not in valid_types:
@@ -206,7 +207,11 @@ async def handle_message(data: dict, conversation_id: str):
     elif message_type == "conversation_control":
         # Handle conversation control (start, pause, stop)
         await handle_conversation_control(data, conversation_id)
-        
+
+    elif message_type == "start_conversation":
+        # Handle starting a new conversation
+        await handle_start_conversation(data, conversation_id)
+
     elif message_type == "heartbeat":
         # Respond to heartbeat
         await manager.send_to_conversation(conversation_id, {
@@ -217,26 +222,114 @@ async def handle_message(data: dict, conversation_id: str):
 
 async def handle_conversation_control(data: dict, conversation_id: str):
     """Handle conversation control messages.
-    
+
     Args:
         data: Control message data
         conversation_id: Target conversation ID
     """
     control_action = data.get("action")
-    
-    if control_action in ["start", "pause", "stop", "resume"]:
-        # Broadcast control action to all participants
+
+    try:
+        # Import here to avoid circular imports
+        from ..services.conversation_service import get_conversation_service
+        service = get_conversation_service()
+
+        if control_action == "stop":
+            success = await service.stop_conversation(conversation_id)
+            if success:
+                await manager.send_to_conversation(conversation_id, {
+                    "type": "conversation_control",
+                    "action": "stop",
+                    "conversation_id": conversation_id,
+                    "timestamp": datetime.now().isoformat(),
+                    "message": "Conversation stopped"
+                })
+            else:
+                await manager.send_to_conversation(conversation_id, {
+                    "type": "error",
+                    "error": "Failed to stop conversation",
+                    "timestamp": datetime.now().isoformat()
+                })
+
+        elif control_action in ["pause", "resume"]:
+            # For now, just broadcast the action (pause/resume not fully implemented)
+            await manager.send_to_conversation(conversation_id, {
+                "type": "conversation_control",
+                "action": control_action,
+                "conversation_id": conversation_id,
+                "timestamp": datetime.now().isoformat(),
+                "message": f"Conversation {control_action}d"
+            })
+            logger.info(f"Conversation {conversation_id} {control_action}d")
+
+        else:
+            logger.warning(f"Unknown control action: {control_action}")
+            await manager.send_to_conversation(conversation_id, {
+                "type": "error",
+                "error": f"Unknown control action: {control_action}",
+                "timestamp": datetime.now().isoformat()
+            })
+
+    except Exception as e:
+        logger.error(f"Error handling conversation control: {e}")
         await manager.send_to_conversation(conversation_id, {
-            "type": "conversation_control",
-            "action": control_action,
-            "conversation_id": conversation_id,
-            "timestamp": datetime.now().isoformat(),
-            "message": f"Conversation {control_action}ed"
+            "type": "error",
+            "error": f"Control error: {str(e)}",
+            "timestamp": datetime.now().isoformat()
+        })
+
+
+async def handle_start_conversation(data: dict, conversation_id: str):
+    """Handle starting a new conversation via WebSocket.
+
+    Args:
+        data: Start conversation message data
+        conversation_id: Target conversation ID
+    """
+    try:
+        # Import here to avoid circular imports
+        from ..services.conversation_service import get_conversation_service
+        service = get_conversation_service()
+
+        # Extract required fields
+        surveyor_persona_id = data.get("surveyor_persona_id")
+        patient_persona_id = data.get("patient_persona_id")
+        host = data.get("host", "http://localhost:11434")
+        model = data.get("model", "llama2:7b")
+
+        if not surveyor_persona_id or not patient_persona_id:
+            await manager.send_to_conversation(conversation_id, {
+                "type": "error",
+                "error": "Missing required persona IDs",
+                "timestamp": datetime.now().isoformat()
+            })
+            return
+
+        # Start the conversation
+        success = await service.start_conversation(
+            conversation_id=conversation_id,
+            surveyor_persona_id=surveyor_persona_id,
+            patient_persona_id=patient_persona_id,
+            host=host,
+            model=model
+        )
+
+        if success:
+            logger.info(f"Started conversation {conversation_id} via WebSocket")
+        else:
+            await manager.send_to_conversation(conversation_id, {
+                "type": "error",
+                "error": "Failed to start conversation",
+                "timestamp": datetime.now().isoformat()
+            })
+
+    except Exception as e:
+        logger.error(f"Error starting conversation via WebSocket: {e}")
+        await manager.send_to_conversation(conversation_id, {
+            "type": "error",
+            "error": f"Start error: {str(e)}",
+            "timestamp": datetime.now().isoformat()
         })
-        
-        logger.info(f"Conversation {conversation_id} {control_action}ed")
-    else:
-        logger.warning(f"Unknown control action: {control_action}")
 
 
 # Export the manager for use in other modules

backend/core/persona_system.py

@@ -10,7 +10,7 @@ both survey interviewers and patient respondents. It provides:
 Classes:
     PersonaSystem: Main persona management system
     PersonaPromptBuilder: Constructs prompts with persona context
-    
+
 Example:
     system = PersonaSystem()
     prompt = system.build_conversation_prompt(
@@ -20,8 +20,10 @@ Example:
     )
 """
 
+from __future__ import annotations
+
 import yaml
-from typing import Dict, List, Optional, Any
+from typing import Dict, List, Optional, Any, Tuple
 from pathlib import Path
 from datetime import datetime
 import logging
@@ -218,7 +220,7 @@ class PersonaSystem:
                                 conversation_history: List[Dict[str, Any]] = None,
                                 current_context: Dict[str, Any] = None,
                                 user_prompt: str = "",
-                                max_history: int = 10) -> tuple[str, str]:
+                                max_history: int = 10) -> Tuple[str, str]:
         """Build complete prompt for conversation generation.
         
         Args: