Update main.py

main.py

@@ -952,6 +952,13 @@ def delete_project(project_id):
 # AI phone call ElevenLabs
 #-------------------------
 
+import os
+import requests
+import time
+import logging
+from elevenlabs import ElevenLabs
+
+# Configuration
 CREDITS_PER_MIN = 3  # Adjust based on ElevenLabs conversational AI pricing
 VOICE_NAME = "Daniel"  # British male voice (more reliable than Archer)
 
@@ -968,7 +975,8 @@ KNOWN_VOICE_IDS = {
 class ConversationalAIHandler:
     def __init__(self):
         self.client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))
-        self.base_url = "https://api.elevenlabs.io/v1/convai"  # Fixed: Use convai endpoint
+        # Fixed: Try the correct endpoint structure
+        self.base_url = "https://api.elevenlabs.io/v1/convai"
         self.headers = {
             "xi-api-key": os.getenv("ELEVENLABS_API_KEY"),
             "Content-Type": "application/json"
@@ -983,62 +991,8 @@ class ConversationalAIHandler:
             logger.info(f"[VOICE] Using known voice ID for Daniel: {KNOWN_VOICE_IDS['Daniel']}")
             return KNOWN_VOICE_IDS["Daniel"]
             
-            # Fallback: Try to get voices from API (if above fails)
-            try:
-                logger.info(f"[VOICE] Fallback: Fetching voices from API")
-                response = self.client.voices.get_all()
-                voices = response.voices if hasattr(response, 'voices') else response
-                logger.info(f"[VOICE] Retrieved {len(voices)} voices from API")
-                
-                # Preferred British male voices in order
-                preferred_voices = ["Daniel", "Charlie", "George", "Archer"]
-                
-                for voice_name in preferred_voices:
-                    voice = next((v for v in voices if v.name == voice_name), None)
-                    if voice:
-                        logger.info(f"[VOICE] Found preferred voice: {voice_name} - {voice.voice_id}")
-                        return voice.voice_id
-                
-                # Fallback to first available voice
-                if voices:
-                    logger.info(f"[VOICE] Using fallback voice: {voices[0].name} - {voices[0].voice_id}")
-                    return voices[0].voice_id
-                    
-            except Exception as ae:
-                logger.warning(f"[VOICE] SDK method failed, trying alternative: {str(ae)}")
-                
-                # Alternative: Try direct API call
-                try:
-                    response = requests.get(
-                        "https://api.elevenlabs.io/v1/voices",
-                        headers={"xi-api-key": os.getenv("ELEVENLABS_API_KEY")}
-                    )
-                    if response.status_code == 200:
-                        voices_data = response.json()
-                        voices = voices_data.get('voices', [])
-                        logger.info(f"[VOICE] Retrieved {len(voices)} voices via direct API")
-                        
-                        # Look for Daniel first
-                        for voice in voices:
-                            if voice.get('name') == 'Daniel':
-                                logger.info(f"[VOICE] Found Daniel via API: {voice.get('voice_id')}")
-                                return voice.get('voice_id')
-                        
-                        # Fallback to first voice
-                        if voices:
-                            logger.info(f"[VOICE] Using first available voice: {voices[0].get('voice_id')}")
-                            return voices[0].get('voice_id')
-                            
-                except Exception as api_e:
-                    logger.error(f"[VOICE] Direct API call failed: {str(api_e)}")
-            
-            # Final fallback: Use known IDs
-            logger.warning(f"[VOICE] All API methods failed, using known Daniel ID")
-            return KNOWN_VOICE_IDS["Daniel"]
-            
         except Exception as e:
             logger.error(f"[VOICE] Error getting voice: {str(e)}")
-            logger.error(f"[VOICE] Exception type: {type(e).__name__}")
             logger.error(f"[VOICE] Using fallback Daniel voice ID")
             return KNOWN_VOICE_IDS["Daniel"]
 
@@ -1066,7 +1020,7 @@ class ConversationalAIHandler:
             Ask clarifying questions when needed and share relevant tips from your experience.
             """
 
-            # Fixed: Correct ElevenLabs Conversational AI agent structure
+            # Fixed: Updated agent structure to match ElevenLabs 2025 API
             agent_data = {
                 "name": f"DIY Expert - {project_data.get('projectTitle', project_data.get('title', 'Project'))}",
                 "conversation_config": {
@@ -1097,7 +1051,6 @@ class ConversationalAIHandler:
             logger.info(f"[AGENT] Agent data prepared, checking for existing agent")
 
             # Check if agent already exists for this project
-              # Import your database reference
             existing_agent_id = db_ref.child(f'projects/{project_id}/agent_id').get()
             
             if existing_agent_id:
@@ -1106,7 +1059,8 @@ class ConversationalAIHandler:
                 try:
                     response = requests.get(
                         f"{self.base_url}/agents/{existing_agent_id}",
-                        headers=self.headers
+                        headers=self.headers,
+                        timeout=10
                     )
                     if response.status_code == 200:
                         logger.info(f"[AGENT] Existing agent verified and active")
@@ -1116,50 +1070,84 @@ class ConversationalAIHandler:
                 except Exception as e:
                     logger.warning(f"[AGENT] Error verifying existing agent: {str(e)}, creating new one")
 
-            # Create new agent
+            # Create new agent - Fixed: Try correct endpoints in order
             logger.info(f"[AGENT] Creating new agent")
-            logger.info(f"[AGENT] Request URL: {self.base_url}/agents")
-            logger.info(f"[AGENT] Request headers: {self.headers}")
-            logger.info(f"[AGENT] Request payload keys: {list(agent_data.keys())}")
             
-            response = requests.post(
-                f"{self.base_url}/agents",
-                headers=self.headers,
-                json=agent_data,
-                timeout=30
-            )
-            
-            logger.info(f"[AGENT] Agent creation response status: {response.status_code}")
-            logger.info(f"[AGENT] Agent creation response headers: {dict(response.headers)}")
-            
-            if response.status_code == 201:
-                agent_info = response.json()
-                agent_id = agent_info.get("agent_id")
-                logger.info(f"[AGENT] New agent created successfully: {agent_id}")
+            # Endpoint 1: Try the newer conversational-ai endpoint first
+            try:
+                endpoint = "https://api.elevenlabs.io/v1/conversational-ai/agents"
+                logger.info(f"[AGENT] Trying primary endpoint: {endpoint}")
                 
-                # Store agent ID in database
-                try:
+                response = requests.post(
+                    endpoint,
+                    headers=self.headers,
+                    json=agent_data,
+                    timeout=30
+                )
+                
+                logger.info(f"[AGENT] Primary endpoint response status: {response.status_code}")
+                
+                if response.status_code == 201:
+                    agent_info = response.json()
+                    agent_id = agent_info.get("agent_id")
+                    logger.info(f"[AGENT] New agent created successfully with primary endpoint: {agent_id}")
+                    
+                    # Store agent ID in database
                     db_ref.child(f'projects/{project_id}').update({
                         'agent_id': agent_id,
                         'agent_created_at': int(time.time())
                     })
                     logger.info(f"[AGENT] Agent ID stored in database")
-                except Exception as e:
-                    logger.error(f"[AGENT] Failed to store agent ID in database: {str(e)}")
+                    
+                    return agent_id
+                    
+            except Exception as e:
+                logger.warning(f"[AGENT] Primary endpoint failed: {str(e)}")
+            
+            # Endpoint 2: Try the original convai endpoint
+            try:
+                endpoint = f"{self.base_url}/agents"
+                logger.info(f"[AGENT] Trying fallback endpoint: {endpoint}")
                 
-                return agent_id
-            else:
-                logger.error(f"[AGENT] Failed to create agent: Status {response.status_code}")
-                logger.error(f"[AGENT] Response text: {response.text}")
+                response = requests.post(
+                    endpoint,
+                    headers=self.headers,
+                    json=agent_data,
+                    timeout=30
+                )
                 
-                # Try to parse error response
-                try:
-                    error_data = response.json()
-                    logger.error(f"[AGENT] Error details: {error_data}")
-                except:
-                    logger.error(f"[AGENT] Could not parse error response as JSON")
+                logger.info(f"[AGENT] Fallback endpoint response status: {response.status_code}")
+                logger.info(f"[AGENT] Response headers: {dict(response.headers)}")
                 
-                raise Exception(f"Failed to create agent: HTTP {response.status_code} - {response.text}")
+                if response.status_code == 201:
+                    agent_info = response.json()
+                    agent_id = agent_info.get("agent_id")
+                    logger.info(f"[AGENT] New agent created successfully with fallback endpoint: {agent_id}")
+                    
+                    # Store agent ID in database
+                    db_ref.child(f'projects/{project_id}').update({
+                        'agent_id': agent_id,
+                        'agent_created_at': int(time.time())
+                    })
+                    logger.info(f"[AGENT] Agent ID stored in database")
+                    
+                    return agent_id
+                else:
+                    logger.error(f"[AGENT] Failed to create agent: Status {response.status_code}")
+                    logger.error(f"[AGENT] Response text: {response.text}")
+                    
+                    # Try to parse error response
+                    try:
+                        error_data = response.json()
+                        logger.error(f"[AGENT] Error details: {error_data}")
+                    except:
+                        logger.error(f"[AGENT] Could not parse error response as JSON")
+                    
+                    raise Exception(f"Failed to create agent: HTTP {response.status_code} - {response.text}")
+                    
+            except Exception as e:
+                logger.error(f"[AGENT] All endpoints failed: {str(e)}")
+                raise
                 
         except Exception as e:
             logger.error(f"[AGENT] Error creating/getting agent: {str(e)}")
@@ -1171,25 +1159,39 @@ class ConversationalAIHandler:
         try:
             logger.info(f"[CONVERSATION] Starting conversation with agent: {agent_id}")
             
-            # Start conversation
-            response = requests.post(
-                f"{self.base_url}/agents/{agent_id}/conversations",
-                headers=self.headers,
-                json={},
-                timeout=30
-            )
+            # Fixed: Try the correct conversation endpoints
+            endpoints = [
+                f"https://api.elevenlabs.io/v1/conversational-ai/agents/{agent_id}/conversations",
+                f"{self.base_url}/agents/{agent_id}/conversations"
+            ]
             
-            logger.info(f"[CONVERSATION] Start conversation response status: {response.status_code}")
-            
-            if response.status_code == 201:
-                conversation_info = response.json()
-                conversation_id = conversation_info.get("conversation_id")
-                logger.info(f"[CONVERSATION] Conversation started successfully: {conversation_id}")
-                return conversation_id
-            else:
-                logger.error(f"[CONVERSATION] Failed to start conversation: Status {response.status_code}")
-                logger.error(f"[CONVERSATION] Response: {response.text}")
-                raise Exception(f"Failed to start conversation: {response.text}")
+            for endpoint in endpoints:
+                try:
+                    logger.info(f"[CONVERSATION] Trying endpoint: {endpoint}")
+                    
+                    response = requests.post(
+                        endpoint,
+                        headers=self.headers,
+                        json={},
+                        timeout=30
+                    )
+                    
+                    logger.info(f"[CONVERSATION] Response status: {response.status_code}")
+                    
+                    if response.status_code == 201:
+                        conversation_info = response.json()
+                        conversation_id = conversation_info.get("conversation_id")
+                        logger.info(f"[CONVERSATION] Conversation started successfully: {conversation_id}")
+                        return conversation_id
+                    else:
+                        logger.warning(f"[CONVERSATION] Endpoint failed with status {response.status_code}: {response.text}")
+                        if endpoint == endpoints[-1]:  # Last endpoint
+                            raise Exception(f"Failed to start conversation: {response.text}")
+                        
+                except requests.exceptions.RequestException as req_e:
+                    logger.warning(f"[CONVERSATION] Request failed for {endpoint}: {str(req_e)}")
+                    if endpoint == endpoints[-1]:  # Last endpoint
+                        raise Exception(f"All conversation endpoints failed: {str(req_e)}")
                 
         except Exception as e:
             logger.error(f"[CONVERSATION] Error starting conversation: {str(e)}")
@@ -1202,26 +1204,41 @@ class ConversationalAIHandler:
             logger.info(f"[MESSAGE] Sending message to agent: {agent_id}, conversation: {conversation_id}")
             logger.info(f"[MESSAGE] Message: {message[:100]}{'...' if len(message) > 100 else ''}")
             
-            response = requests.post(
-                f"{self.base_url}/agents/{agent_id}/conversations/{conversation_id}/messages",
-                headers=self.headers,
-                json={
-                    "message": message,
-                    "message_type": "text"
-                },
-                timeout=30
-            )
-            
-            logger.info(f"[MESSAGE] Send message response status: {response.status_code}")
+            # Fixed: Try the correct message endpoints
+            endpoints = [
+                f"https://api.elevenlabs.io/v1/conversational-ai/agents/{agent_id}/conversations/{conversation_id}/messages",
+                f"{self.base_url}/agents/{agent_id}/conversations/{conversation_id}/messages"
+            ]
             
-            if response.status_code == 200:
-                message_response = response.json()
-                logger.info(f"[MESSAGE] Message sent successfully")
-                return message_response
-            else:
-                logger.error(f"[MESSAGE] Failed to send message: Status {response.status_code}")
-                logger.error(f"[MESSAGE] Response: {response.text}")
-                raise Exception(f"Failed to send message: {response.text}")
+            for endpoint in endpoints:
+                try:
+                    logger.info(f"[MESSAGE] Trying endpoint: {endpoint}")
+                    
+                    response = requests.post(
+                        endpoint,
+                        headers=self.headers,
+                        json={
+                            "message": message,
+                            "message_type": "text"
+                        },
+                        timeout=30
+                    )
+                    
+                    logger.info(f"[MESSAGE] Response status: {response.status_code}")
+                    
+                    if response.status_code == 200:
+                        message_response = response.json()
+                        logger.info(f"[MESSAGE] Message sent successfully")
+                        return message_response
+                    else:
+                        logger.warning(f"[MESSAGE] Endpoint failed with status {response.status_code}: {response.text}")
+                        if endpoint == endpoints[-1]:  # Last endpoint
+                            raise Exception(f"Failed to send message: {response.text}")
+                        
+                except requests.exceptions.RequestException as req_e:
+                    logger.warning(f"[MESSAGE] Request failed for {endpoint}: {str(req_e)}")
+                    if endpoint == endpoints[-1]:  # Last endpoint
+                        raise Exception(f"All message endpoints failed: {str(req_e)}")
                 
         except Exception as e:
             logger.error(f"[MESSAGE] Error sending message: {str(e)}")
@@ -1233,7 +1250,7 @@ def calculate_cost(duration_seconds):
     minutes = (duration_seconds + 59) // 60
     return minutes * CREDITS_PER_MIN
 
-# Updated Flask route
+# Your existing Flask route - no changes needed
 @app.route('/api/projects/<project_id>/start-conversation', methods=['POST'])
 def start_conversation(project_id):
     """Start a conversational AI session for a project"""
@@ -1329,6 +1346,29 @@ def start_conversation(project_id):
         logger.error(f"[CONVERSATION] Exception type: {type(e).__name__}")
         return jsonify({'error': 'Failed to start conversation'}), 500
 
+@app.route('/api/webhook/agent/<project_id>', methods=['POST'])
+def agent_webhook(project_id):
+    """Webhook to handle agent events"""
+    try:
+        data = request.get_json()
+        event_type = data.get('event_type')
+        
+        # Log the webhook event
+        logger.info(f"Agent webhook for project {project_id}: {event_type}")
+        
+        # Store webhook data for debugging/monitoring
+        db_ref.child(f'webhooks/{project_id}/{int(time.time())}').set({
+            'event_type': event_type,
+            'data': data,
+            'timestamp': int(time.time())
+        })
+        
+        return jsonify({'status': 'received'}), 200
+        
+    except Exception as e:
+        logger.error(f"Webhook error: {str(e)}")
+        return jsonify({'error': 'Webhook processing failed'}), 500
+
 @app.route('/api/projects/<project_id>/continue-conversation', methods=['POST'])
 def continue_conversation(project_id):
     """Continue an existing conversation"""
@@ -1356,28 +1396,7 @@ def continue_conversation(project_id):
         logger.error(f"Error continuing conversation: {str(e)}")
         return jsonify({'error': 'Failed to continue conversation'}), 500
 
-@app.route('/api/webhook/agent/<project_id>', methods=['POST'])
-def agent_webhook(project_id):
-    """Webhook to handle agent events"""
-    try:
-        data = request.get_json()
-        event_type = data.get('event_type')
-        
-        # Log the webhook event
-        logger.info(f"Agent webhook for project {project_id}: {event_type}")
-        
-        # Store webhook data for debugging/monitoring
-        db_ref.child(f'webhooks/{project_id}/{int(time.time())}').set({
-            'event_type': event_type,
-            'data': data,
-            'timestamp': int(time.time())
-        })
-        
-        return jsonify({'status': 'received'}), 200
-        
-    except Exception as e:
-        logger.error(f"Webhook error: {str(e)}")
-        return jsonify({'error': 'Webhook processing failed'}), 500
+
 # -----------------------------------------------------------------------------
 # 7. MAIN EXECUTION
 # -----------------------------------------------------------------------------