Update main.py

main.py

@@ -952,12 +952,6 @@ 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)
@@ -972,279 +966,153 @@ KNOWN_VOICE_IDS = {
     "Antoni": "ErXwobaYiN019PkySvjV",  # American male (fallback)
 }
 
+import os
+import time
+import requests
+import logging
+
+# Assumes 'db_ref', 'logger', and 'KNOWN_VOICE_IDS' are initialized elsewhere in your application.
+# from elevenlabs import ElevenLabs # This is no longer needed for the handler's logic.
+
 class ConversationalAIHandler:
     def __init__(self):
-        self.client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))
-        # Fixed: Try the correct endpoint structure
-        self.base_url = "https://api.elevenlabs.io/v1/convai"
+        # CORRECTED: The base_url should be the root of the v1 API.
+        # Specific paths like '/agents' or '/conversations' will be appended later.
+        self.base_url = "https://api.elevenlabs.io/v1"
+        self.api_key = os.getenv("ELEVENLABS_API_KEY")
         self.headers = {
-            "xi-api-key": os.getenv("ELEVENLABS_API_KEY"),
+            "xi-api-key": self.api_key,
             "Content-Type": "application/json"
         }
 
     def get_british_male_voice_id(self):
         """Get British male voice ID"""
+        # This method's logic is sound and remains unchanged.
         try:
-            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"]
-            
         except Exception as e:
-            logger.error(f"[VOICE] Error getting voice: {str(e)}")
-            logger.error(f"[VOICE] Using fallback Daniel voice ID")
-            return KNOWN_VOICE_IDS["Daniel"]
+            logger.error(f"[VOICE] Error getting voice ID: {str(e)}. Using fallback.")
+            return KNOWN_VOICE_IDS.get("Daniel", "onwK4e9ZLuTAKqWW03F9") # Hardcoded fallback
 
     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}")
-            
+
+            # Step 1: Check for and verify an existing agent.
+            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}. Verifying...")
+                # CORRECTED: Use the correct verification endpoint.
+                verify_url = f"{self.base_url}/agents/{existing_agent_id}"
+                try:
+                    response = requests.get(verify_url, headers=self.headers, timeout=15)
+                    if response.status_code == 200:
+                        logger.info(f"[AGENT] Existing agent {existing_agent_id} verified and active.")
+                        return existing_agent_id
+                    else:
+                        logger.warning(f"[AGENT] Verification failed for agent {existing_agent_id} (Status: {response.status_code}). Creating a new one.")
+                except Exception as e:
+                    logger.warning(f"[AGENT] Error verifying existing agent: {str(e)}. Creating a new one.")
+
+            # Step 2: If no valid agent exists, create a new one.
+            logger.info(f"[AGENT] Creating new agent.")
             voice_id = self.get_british_male_voice_id()
-            if not voice_id:
-                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 
+            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'))}
+            Project: {project_data.get('projectTitle', '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. 
+            Provide helpful, step-by-step guidance while being encouraging and safety-conscious.
             Ask clarifying questions when needed and share relevant tips from your experience.
             """
 
-            # 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": {
-                    "agent": {
-                        "prompt": {
-                            "prompt": diy_expert_prompt
-                        },
-                        "first_message": "Hello! I'm your Sozo DIY expert assistant. I'm here to help you with your project. What would you like to work on today?",
-                        "language": "en"
-                    },
-                    "asr": {
-                        "provider": "deepgram",
-                        "user_input_audio_format": "pcm_16000"
-                    },
-                    "tts": {
-                        "voice_id": voice_id
-                    },
-                    "llm": {
-                        "provider": "openai",
-                        "model": "gpt-4"
-                    }
-                },
-                "platform_settings": {
-                    "webhook_url": f"{os.getenv('BASE_URL', 'https://rairo-neofix-api.hf.space')}/api/webhook/agent/{project_id}"
-                }
+            # CORRECTED: The payload for agent creation is a flatter structure.
+            # The complex 'conversation_config' is not used for the standard /agents endpoint.
+            agent_payload = {
+                "name": f"DIY Expert - {project_data.get('projectTitle', project_id)}",
+                "prompt": diy_expert_prompt,
+                "voice_id": voice_id,
+                "initial_message": "Hello! I'm your Sozo DIY expert assistant. I'm here to help you with your project. What would you like to work on today?",
+                "webhook_url": f"{os.getenv('BASE_URL', 'https://rairo-neofix-api.hf.space')}/api/webhook/agent/{project_id}",
+                "model": "eleven_turbo_v2" # A default model is recommended
             }
 
-            logger.info(f"[AGENT] Agent data prepared, checking for existing agent")
+            # CORRECTED: Use the single, correct endpoint for agent creation.
+            creation_url = f"{self.base_url}/agents"
+            logger.info(f"[AGENT] Posting to agent creation endpoint: {creation_url}")
 
-            # 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
-                try:
-                    response = requests.get(
-                        f"{self.base_url}/agents/{existing_agent_id}",
-                        headers=self.headers,
-                        timeout=10
-                    )
-                    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")
+            response = requests.post(creation_url, headers=self.headers, json=agent_payload, timeout=30)
+
+            if response.status_code == 200: # A successful creation returns status 200
+                agent_info = response.json()
+                agent_id = agent_info.get("agent_id")
+                logger.info(f"[AGENT] New agent created successfully: {agent_id}")
+
+                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:
+                # This will now give a much more informative error if the payload is wrong.
+                logger.error(f"[AGENT] Failed to create agent. Status: {response.status_code}, Response: {response.text}")
+                raise Exception(f"Failed to create agent: HTTP {response.status_code} - {response.text}")
 
-            # Create new agent - Fixed: Try correct endpoints in order
-            logger.info(f"[AGENT] Creating new agent")
-            
-            # 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}")
-                
-                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")
-                    
-                    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}")
-                
-                response = requests.post(
-                    endpoint,
-                    headers=self.headers,
-                    json=agent_data,
-                    timeout=30
-                )
-                
-                logger.info(f"[AGENT] Fallback endpoint response status: {response.status_code}")
-                logger.info(f"[AGENT] 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 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)}")
-            logger.error(f"[AGENT] Exception type: {type(e).__name__}")
+            logger.error(f"[AGENT] An exception occurred in create_or_get_agent: {e}")
             raise
 
     def start_conversation(self, agent_id):
         """Start a conversation with the agent"""
+        logger.info(f"[CONVERSATION] Starting conversation with agent: {agent_id}")
+        # CORRECTED: Use the single, correct endpoint for starting a conversation with an agent.
+        conversation_url = f"{self.base_url}/agents/{agent_id}/conversations"
         try:
-            logger.info(f"[CONVERSATION] Starting conversation with agent: {agent_id}")
-            
-            # 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"
-            ]
-            
-            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)}")
-                
+            response = requests.post(conversation_url, headers=self.headers, json={}, timeout=30)
+            if response.status_code == 200: # Successful start returns 200
+                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}, Response: {response.text}")
+                raise Exception(f"Failed to start conversation: {response.text}")
         except Exception as e:
-            logger.error(f"[CONVERSATION] Error starting conversation: {str(e)}")
-            logger.error(f"[CONVERSATION] Exception type: {type(e).__name__}")
+            logger.error(f"[CONVERSATION] An exception occurred in start_conversation: {e}")
             raise
 
     def send_message(self, agent_id, conversation_id, message):
         """Send a message to the conversation"""
+        # The 'agent_id' is not required for this endpoint, but we'll keep the signature for compatibility with your calling code.
+        logger.info(f"[MESSAGE] Sending message to conversation: {conversation_id}")
+        # CORRECTED: Use the single, correct endpoint for sending a message.
+        message_url = f"{self.base_url}/conversations/{conversation_id}/messages"
+        
+        # CORRECTED: The payload for sending a message is simpler.
+        message_payload = {
+            "text": message
+        }
+
         try:
-            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 ''}")
-            
-            # 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"
-            ]
-            
-            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)}")
-                
+            response = requests.post(message_url, headers=self.headers, json=message_payload, timeout=30)
+            if response.status_code == 200:
+                logger.info(f"[MESSAGE] Message sent successfully to {conversation_id}.")
+                # The response is streaming audio, but we can return the successful JSON confirmation.
+                return response.json()
+            else:
+                logger.error(f"[MESSAGE] Failed to send message. Status: {response.status_code}, Response: {response.text}")
+                raise Exception(f"Failed to send message: {response.text}")
         except Exception as e:
-            logger.error(f"[MESSAGE] Error sending message: {str(e)}")
-            logger.error(f"[MESSAGE] Exception type: {type(e).__name__}")
+            logger.error(f"[MESSAGE] An exception occurred in send_message: {e}")
             raise
 
+
 def calculate_cost(duration_seconds):
     """Calculate cost based on conversation duration"""
     minutes = (duration_seconds + 59) // 60