main.py

import os
from dotenv import load_dotenv
from fastapi import FastAPI, WebSocket
from elevenlabs.client import ElevenLabs
from elevenlabs.conversational_ai.conversation import Conversation, AudioInterface
import asyncio
import base64
import json
import logging
from fastapi.responses import Response

# Set up detailed logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# Load environment variables
load_dotenv()
AGENT_ID = os.getenv("ELEVENLABS_AGENT_ID")
API_KEY = os.getenv("ELEVENLABS_API_KEY")

app = FastAPI()

class TwilioAudioInterface(AudioInterface):
    def __init__(self, websocket: WebSocket):
        self.websocket = websocket
        self.stream_sid = None
        self._is_running = False
        self._input_callback = None
        self.logger = logging.getLogger(__name__)

    def start(self, input_callback=None):
        """Start the audio interface."""
        self._is_running = True
        self._input_callback = input_callback
        self.logger.info("Audio interface started with callback")

    def stop(self):
        """Stop the audio interface."""
        self._is_running = False
        self.logger.info("Audio interface stopped")

    async def output(self, audio_data: bytes):
        """Output audio data to Twilio."""
        try:
            if not self.stream_sid:
                self.logger.error("No stream_sid available")
                return
                
            if not self._is_running:
                self.logger.error("Audio interface not running")
                return

            if not audio_data:
                self.logger.error("No audio data received")
                return

            self.logger.info(f"Sending audio chunk of size {len(audio_data)} bytes to Twilio")
            
            # Create the media message
            message = {
                "event": "media",
                "streamSid": self.stream_sid,
                "media": {
                    "payload": base64.b64encode(audio_data).decode('utf-8')
                }
            }
            
            # Send audio data to Twilio
            await self.websocket.send_text(json.dumps(message))
            self.logger.info("Audio chunk sent successfully to Twilio")

        except Exception as e:
            self.logger.error(f"Error in output: {str(e)}", exc_info=True)
            raise

    def interrupt(self):
        """Interrupt current audio playback."""
        self._is_running = False
        self.logger.info("Audio playback interrupted")

    async def process_incoming_audio(self, audio_data: bytes):
        """Process incoming audio from Twilio."""
        try:
            if not self._input_callback:
                self.logger.error("No input callback registered")
                return

            if not self._is_running:
                self.logger.error("Audio interface not running")
                return

            if not audio_data:
                self.logger.error("No audio data received")
                return

            self.logger.debug(f"Processing incoming audio chunk of size {len(audio_data)} bytes")
            self._input_callback(audio_data)
            self.logger.debug("Audio chunk processed successfully")
        except Exception as e:
            self.logger.error(f"Error processing incoming audio: {str(e)}", exc_info=True)
            raise

@app.post("/incoming-call-eleven")
async def incoming_call():
    try:
        host = os.getenv('HOST')
        if not host:
            logger.error("HOST environment variable not set")
            raise ValueError("HOST not configured")

        twiml = f"""<?xml version="1.0" encoding="UTF-8"?>
            <Response>
                <Connect>
                    <Stream url="wss://{host}/media-stream" />
                </Connect>
            </Response>"""
        logger.info(f"Returning TwiML: {twiml}")
        
        return Response(
            content=twiml,
            media_type="application/xml"
        )
    except Exception as e:
        logger.error(f"Error in incoming call handler: {str(e)}", exc_info=True)
        raise

@app.websocket("/media-stream")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    logger.info("Twilio WebSocket connected")

    audio_interface = None
    conversation = None
    
    try:
        # Initialize audio interface
        audio_interface = TwilioAudioInterface(websocket)
        client = ElevenLabs(api_key=API_KEY)

        def on_agent_response(response):
            logger.info(f"Agent response: {response}")

        def on_transcript(transcript):
            logger.info(f"User transcript: {transcript}")

        def on_audio_event(audio_data):
            logger.info(f"Received audio data of size: {len(audio_data)} bytes")

        conversation = Conversation(
            client=client,
            agent_id=AGENT_ID,
            requires_auth=bool(API_KEY),
            audio_interface=audio_interface,
            callback_agent_response=on_agent_response,
            callback_user_transcript=on_transcript,
            callback_latency_measurement=lambda latency: logger.info(f"Latency: {latency}ms")
        )

        # Start conversation
        conversation.start_session()
        logger.info("Started ElevenLabs conversation session")

        # Main WebSocket message handling loop
        while True:
            try:
                message = await websocket.receive_text()
                data = json.loads(message)
                logger.info(f"Received WebSocket message type: {data.get('event')}")
                
                if data["event"] == "start":
                    audio_interface.stream_sid = data["start"]["streamSid"]
                    logger.info(f"Stream started with ID: {audio_interface.stream_sid}")
                
                elif data["event"] == "media":
                    audio_data = base64.b64decode(data["media"]["payload"])
                    await audio_interface.process_incoming_audio(audio_data)
                
                elif data["event"] == "stop":
                    logger.info("Stream stopped")
                    break
                
                elif data["event"] == "mark":
                    logger.debug(f"Received mark event: {data}")

            except json.JSONDecodeError as e:
                logger.error(f"Failed to decode WebSocket message: {e}")
                continue
            except Exception as e:
                logger.error(f"Error processing WebSocket message: {e}", exc_info=True)
                break

    except Exception as e:
        logger.error(f"Error in WebSocket connection: {e}", exc_info=True)
    
    finally:
        # Cleanup
        if audio_interface:
            audio_interface.stop()
            logger.info("Audio interface stopped")
        
        if conversation:
            conversation.end_session()
            logger.info("Ended ElevenLabs conversation session")
        
        await websocket.close()
        logger.info("WebSocket connection closed")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)