Update main.py

main.py

@@ -947,10 +947,24 @@ def delete_project(project_id):
         blob.delete()
     return jsonify({"success": True, "message": f"Project {project_id} deleted."})
 
-# AI call ElevenLabs
+
+#------------------------
+# AI phone call ElevenLabs
+#-------------------------
+
 CREDITS_PER_MIN = 3  # Adjust based on ElevenLabs conversational AI pricing
 VOICE_NAME = "Daniel"  # British male voice (more reliable than Archer)
 
+# Known ElevenLabs voice IDs for common voices
+KNOWN_VOICE_IDS = {
+    "Daniel": "onwK4e9ZLuTAKqWW03F9",  # British male
+    "Charlie": "IKne3meq5aSn9XLyUdCD",  # British male  
+    "George": "JBFqnCBsd6RMkjVDRZzb",  # British male
+    "Archer": "D38z5RcWu1voky8WS1ja",  # British male
+    "Adam": "pNInz6obpgDQGcFmaJgB",   # American male (fallback)
+    "Antoni": "ErXwobaYiN019PkySvjV",  # American male (fallback)
+}
+
 class ConversationalAIHandler:
     def __init__(self):
         self.client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))
@@ -963,44 +977,98 @@ class ConversationalAIHandler:
     def get_british_male_voice_id(self):
         """Get British male voice ID"""
         try:
-            voices = self.client.voices.list().voices
-            # Preferred British male voices in order
-            preferred_voices = ["Daniel", "Charlie", "Archer", "George"]
+            logger.info(f"[VOICE] Attempting to get voices using SDK method")
+            
+            # First try with known voice IDs (fastest approach)
+            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)
+            # Note: Using the correct method based on current SDK
+            try:
+                logger.info(f"[VOICE] Fallback: Fetching voices from API")
+                response = self.client.voices.get_all()  # Try get_all method
+                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 AttributeError as ae:
+                logger.warning(f"[VOICE] SDK method failed, trying alternative: {str(ae)}")
+                
+                # Alternative: Try direct API call
+                try:
+                    response = requests.get(
+                        f"{self.base_url}/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)}")
             
-            for voice_name in preferred_voices:
-                voice = next((v for v in voices if v.name == voice_name), None)
-                if voice:
-                    return voice.voice_id
+            # Final fallback: Use known IDs
+            logger.warning(f"[VOICE] All API methods failed, using known Daniel ID")
+            return KNOWN_VOICE_IDS["Daniel"]
             
-            # Fallback to first available voice
-            return voices[0].voice_id if voices else None
         except Exception as e:
-            logger.error(f"Error getting voice: {str(e)}")
-            return None
+            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"]
 
     def create_or_get_agent(self, project_id, project_data):
         """Create or retrieve existing agent for the project"""
         try:
+            logger.info(f"[AGENT] Starting agent creation/retrieval for project: {project_id}")
+            
             voice_id = self.get_british_male_voice_id()
             if not voice_id:
-                raise Exception("No suitable voice available")
+                logger.error(f"[AGENT] No voice ID available, using Daniel fallback")
+                voice_id = KNOWN_VOICE_IDS["Daniel"]
+            
+            logger.info(f"[AGENT] Using voice ID: {voice_id}")
 
             # DIY Expert persona context
             diy_expert_prompt = f"""
             You are an experienced DIY expert with years of hands-on experience in Home Appliance Repair, Automotive Maintenance, Gardening & Urban Farming,
-            Upcycling & Sustainable Crafts, or DIY Project Creation.. You speak in a friendly, knowledgeable British manner and provide 
-             practical, actionable advice. You're working on this specific project:
-
-            Project: {project_data.get('title', 'DIY Project')}
+            Upcycling & Sustainable Crafts, or DIY Project Creation. You speak in a friendly, knowledgeable British manner and provide 
+            practical, actionable advice. You're working on this specific project:
+            Project: {project_data.get('projectTitle', project_data.get('title', 'DIY Project'))}
             Description: {project_data.get('projectDescription', '')}
             Initial Plan: {project_data.get('initialPlan', '')}
-
             Provide helpful, step-by-step guidance while being encouraging and safety-conscious. 
             Ask clarifying questions when needed and share relevant tips from your experience.
             """
 
             agent_data = {
-                "name": f"DIY Expert - {project_data.get('title', 'Project')}",
+                "name": f"DIY Expert - {project_data.get('projectTitle', project_data.get('title', 'Project'))}",
                 "prompt": diy_expert_prompt,
                 "voice_id": voice_id,
                 "language": "en",
@@ -1016,46 +1084,69 @@ class ConversationalAIHandler:
                 "max_duration_seconds": 1800  # 30 minutes max
             }
 
+            logger.info(f"[AGENT] Agent data prepared, checking for existing agent")
+
             # Check if agent already exists for this project
             existing_agent_id = db_ref.child(f'projects/{project_id}/agent_id').get()
             
             if existing_agent_id:
+                logger.info(f"[AGENT] Found existing agent ID: {existing_agent_id}")
                 # Verify agent still exists
-                response = requests.get(
-                    f"{self.base_url}/agents/{existing_agent_id}",
-                    headers=self.headers
-                )
-                if response.status_code == 200:
-                    return existing_agent_id
+                try:
+                    response = requests.get(
+                        f"{self.base_url}/agents/{existing_agent_id}",
+                        headers=self.headers
+                    )
+                    if response.status_code == 200:
+                        logger.info(f"[AGENT] Existing agent verified and active")
+                        return existing_agent_id
+                    else:
+                        logger.warning(f"[AGENT] Existing agent not found (status {response.status_code}), creating new one")
+                except Exception as e:
+                    logger.warning(f"[AGENT] Error verifying existing agent: {str(e)}, creating new one")
 
             # Create new agent
+            logger.info(f"[AGENT] Creating new agent")
             response = requests.post(
                 f"{self.base_url}/agents",
                 headers=self.headers,
                 json=agent_data
             )
             
+            logger.info(f"[AGENT] Agent creation response status: {response.status_code}")
+            
             if response.status_code == 201:
                 agent_info = response.json()
                 agent_id = agent_info["id"]
+                logger.info(f"[AGENT] New agent created successfully: {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())
-                })
+                try:
+                    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
             else:
+                logger.error(f"[AGENT] Failed to create agent: Status {response.status_code}")
+                logger.error(f"[AGENT] Response: {response.text}")
                 raise Exception(f"Failed to create agent: {response.text}")
                 
         except Exception as e:
-            logger.error(f"Error creating/getting agent: {str(e)}")
+            logger.error(f"[AGENT] Error creating/getting agent: {str(e)}")
+            logger.error(f"[AGENT] Exception type: {type(e).__name__}")
             raise
 
     def simulate_conversation(self, agent_id, user_message):
         """Simulate a conversation with the agent"""
         try:
+            logger.info(f"[SIMULATION] Starting conversation simulation with agent: {agent_id}")
+            logger.info(f"[SIMULATION] User message: {user_message[:100]}{'...' if len(user_message) > 100 else ''}")
+            
             simulation_data = {
                 "simulation_specification": {
                     "user_message": user_message,
@@ -1064,19 +1155,29 @@ class ConversationalAIHandler:
                 }
             }
             
+            logger.info(f"[SIMULATION] Sending simulation request")
             response = requests.post(
                 f"{self.base_url}/agents/{agent_id}/simulate-conversation",
                 headers=self.headers,
-                json=simulation_data
+                json=simulation_data,
+                timeout=30  # Add timeout
             )
             
+            logger.info(f"[SIMULATION] Simulation response status: {response.status_code}")
+            
             if response.status_code == 200:
-                return response.json()
+                result = response.json()
+                logger.info(f"[SIMULATION] Simulation completed successfully")
+                logger.info(f"[SIMULATION] Response keys: {list(result.keys()) if isinstance(result, dict) else 'Not a dict'}")
+                return result
             else:
+                logger.error(f"[SIMULATION] Simulation failed: Status {response.status_code}")
+                logger.error(f"[SIMULATION] Response: {response.text}")
                 raise Exception(f"Simulation failed: {response.text}")
                 
         except Exception as e:
-            logger.error(f"Error simulating conversation: {str(e)}")
+            logger.error(f"[SIMULATION] Error simulating conversation: {str(e)}")
+            logger.error(f"[SIMULATION] Exception type: {type(e).__name__}")
             raise
 
 def calculate_cost(duration_seconds):