Update main.py

main.py

@@ -968,7 +968,7 @@ 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"
+        self.base_url = "https://api.elevenlabs.io/v1/convai"  # Fixed: Use convai endpoint
         self.headers = {
             "xi-api-key": os.getenv("ELEVENLABS_API_KEY"),
             "Content-Type": "application/json"
@@ -984,10 +984,9 @@ class ConversationalAIHandler:
             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
+                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")
                 
@@ -1005,13 +1004,13 @@ class ConversationalAIHandler:
                     logger.info(f"[VOICE] Using fallback voice: {voices[0].name} - {voices[0].voice_id}")
                     return voices[0].voice_id
                     
-            except AttributeError as ae:
+            except Exception 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",
+                        "https://api.elevenlabs.io/v1/voices",
                         headers={"xi-api-key": os.getenv("ELEVENLABS_API_KEY")}
                     )
                     if response.status_code == 200:
@@ -1067,26 +1066,38 @@ class ConversationalAIHandler:
             Ask clarifying questions when needed and share relevant tips from your experience.
             """
 
+            # Fixed: Correct ElevenLabs Conversational AI agent structure
             agent_data = {
                 "name": f"DIY Expert - {project_data.get('projectTitle', project_data.get('title', 'Project'))}",
-                "prompt": diy_expert_prompt,
-                "voice_id": voice_id,
-                "language": "en",
                 "conversation_config": {
-                    "turn_detection": {
-                        "type": "server_vad",
-                        "threshold": 0.5,
-                        "prefix_padding_ms": 300,
-                        "silence_duration_ms": 800
+                    "agent": {
+                        "prompt": {
+                            "prompt": diy_expert_prompt
+                        },
+                        "first_message": "Hello! I'm your 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"
                     }
                 },
-                "webhook_url": f"{request.host_url}api/webhook/agent/{project_id}",
-                "max_duration_seconds": 1800  # 30 minutes max
+                "platform_settings": {
+                    "webhook_url": f"{os.getenv('BASE_URL', 'https://yourapp.com')}/api/webhook/agent/{project_id}"
+                }
             }
 
             logger.info(f"[AGENT] Agent data prepared, checking for existing agent")
 
             # Check if agent already exists for this project
+            from your_database import db_ref  # Import your database reference
             existing_agent_id = db_ref.child(f'projects/{project_id}/agent_id').get()
             
             if existing_agent_id:
@@ -1107,17 +1118,23 @@ class ConversationalAIHandler:
 
             # Create new agent
             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
+                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["id"]
+                agent_id = agent_info.get("agent_id")
                 logger.info(f"[AGENT] New agent created successfully: {agent_id}")
                 
                 # Store agent ID in database
@@ -1133,51 +1150,82 @@ class ConversationalAIHandler:
                 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}")
+                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] 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"""
+    def start_conversation(self, agent_id):
+        """Start 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 ''}")
+            logger.info(f"[CONVERSATION] Starting conversation with agent: {agent_id}")
             
-            simulation_data = {
-                "simulation_specification": {
-                    "user_message": user_message,
-                    "max_turns": 10,
-                    "evaluation_criteria": ["helpfulness", "accuracy", "clarity"]
-                }
-            }
+            # Start conversation
+            response = requests.post(
+                f"{self.base_url}/agents/{agent_id}/conversations",
+                headers=self.headers,
+                json={},
+                timeout=30
+            )
+            
+            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}")
+                
+        except Exception as e:
+            logger.error(f"[CONVERSATION] Error starting conversation: {str(e)}")
+            logger.error(f"[CONVERSATION] Exception type: {type(e).__name__}")
+            raise
+
+    def send_message(self, agent_id, conversation_id, message):
+        """Send a message to the conversation"""
+        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 ''}")
             
-            logger.info(f"[SIMULATION] Sending simulation request")
             response = requests.post(
-                f"{self.base_url}/agents/{agent_id}/simulate-conversation",
+                f"{self.base_url}/agents/{agent_id}/conversations/{conversation_id}/messages",
                 headers=self.headers,
-                json=simulation_data,
-                timeout=30  # Add timeout
+                json={
+                    "message": message,
+                    "message_type": "text"
+                },
+                timeout=30
             )
             
-            logger.info(f"[SIMULATION] Simulation response status: {response.status_code}")
+            logger.info(f"[MESSAGE] Send message response status: {response.status_code}")
             
             if response.status_code == 200:
-                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
+                message_response = response.json()
+                logger.info(f"[MESSAGE] Message sent successfully")
+                return message_response
             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}")
+                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}")
                 
         except Exception as e:
-            logger.error(f"[SIMULATION] Error simulating conversation: {str(e)}")
-            logger.error(f"[SIMULATION] Exception type: {type(e).__name__}")
+            logger.error(f"[MESSAGE] Error sending message: {str(e)}")
+            logger.error(f"[MESSAGE] Exception type: {type(e).__name__}")
             raise
 
 def calculate_cost(duration_seconds):
@@ -1185,6 +1233,7 @@ def calculate_cost(duration_seconds):
     minutes = (duration_seconds + 59) // 60
     return minutes * CREDITS_PER_MIN
 
+# Updated Flask route
 @app.route('/api/projects/<project_id>/start-conversation', methods=['POST'])
 def start_conversation(project_id):
     """Start a conversational AI session for a project"""
@@ -1192,202 +1241,92 @@ def start_conversation(project_id):
     logger.info(f"[CONVERSATION] Starting conversation process for project: {project_id}")
     
     try:
-        # Authorization timing
-        auth_start = time.time()
-        logger.info(f"[CONVERSATION] Starting authorization check for project: {project_id}")
+        # Authorization
         uid = verify_token(request.headers.get('Authorization'))
         if not uid:
             logger.error(f"[CONVERSATION] ERROR: Unauthorized access attempt for project: {project_id}")
             return jsonify({'error': 'Unauthorized'}), 401
-        auth_time = time.time() - auth_start
-        logger.info(f"[CONVERSATION] Authorization completed in {auth_time:.3f}s for user: {uid}")
 
-        # User data fetch timing
-        user_fetch_start = time.time()
-        logger.info(f"[CONVERSATION] Fetching user data for uid: {uid}")
+        # Get user data
         user_ref = db_ref.child(f'users/{uid}')
         user = user_ref.get()
         if not user:
             logger.error(f"[CONVERSATION] ERROR: User not found for uid: {uid}")
             return jsonify({'error': 'User not found'}), 404
-        user_fetch_time = time.time() - user_fetch_start
-        logger.info(f"[CONVERSATION] User data fetch completed in {user_fetch_time:.3f}s, credits: {user.get('credits', 0)}")
 
-        # Project data fetch timing
-        project_fetch_start = time.time()
-        logger.info(f"[CONVERSATION] Fetching project data for project_id: {project_id}")
+        # Get project data
         project = db_ref.child(f'projects/{project_id}').get()
-        if not project:
-            logger.error(f"[CONVERSATION] ERROR: Project not found for project_id: {project_id}")
-            return jsonify({'error': 'Project not found'}), 404
-        if project.get('uid') != uid:
-            logger.error(f"[CONVERSATION] ERROR: Project access denied - project_id: {project_id}, project_uid: {project.get('uid')}, requesting_uid: {uid}")
+        if not project or project.get('uid') != uid:
+            logger.error(f"[CONVERSATION] ERROR: Project not found or access denied")
             return jsonify({'error': 'Project not found'}), 404
-        project_fetch_time = time.time() - project_fetch_start
-        logger.info(f"[CONVERSATION] Project data fetch completed in {project_fetch_time:.3f}s for project: {project.get('projectTitle', 'Unknown')}")
 
-        # Request data parsing timing
-        data_parse_start = time.time()
-        logger.info(f"[CONVERSATION] Parsing request data")
-        try:
-            data = request.get_json()
-            if data is None:
-                logger.error(f"[CONVERSATION] ERROR: No JSON data received in request")
-                return jsonify({'error': 'No JSON data provided'}), 400
-            initial_message = data.get('message', 'Hello, I need help with my DIY project.')
-            logger.info(f"[CONVERSATION] Initial message: {initial_message[:100]}{'...' if len(initial_message) > 100 else ''}")
-        except Exception as e:
-            logger.error(f"[CONVERSATION] ERROR: Failed to parse request JSON: {str(e)}")
-            return jsonify({'error': 'Invalid JSON data'}), 400
-        data_parse_time = time.time() - data_parse_start
-        logger.info(f"[CONVERSATION] Request data parsing completed in {data_parse_time:.3f}s")
-
-        # AI Handler initialization timing
-        ai_init_start = time.time()
-        logger.info(f"[CONVERSATION] Initializing ConversationalAIHandler")
-        try:
-            ai_handler = ConversationalAIHandler()
-            logger.info(f"[CONVERSATION] ConversationalAIHandler initialized successfully")
-        except Exception as e:
-            logger.error(f"[CONVERSATION] ERROR: Failed to initialize ConversationalAIHandler: {str(e)}")
-            return jsonify({'error': 'Failed to initialize AI handler'}), 500
-        ai_init_time = time.time() - ai_init_start
-        logger.info(f"[CONVERSATION] AI handler initialization completed in {ai_init_time:.3f}s")
+        # Parse request data
+        data = request.get_json()
+        if data is None:
+            logger.error(f"[CONVERSATION] ERROR: No JSON data received")
+            return jsonify({'error': 'No JSON data provided'}), 400
         
-        # Agent creation/retrieval timing
-        agent_start = time.time()
-        logger.info(f"[CONVERSATION] Creating or getting agent for project: {project_id}")
-        try:
-            agent_id = ai_handler.create_or_get_agent(project_id, project)
-            logger.info(f"[CONVERSATION] Agent created/retrieved successfully: {agent_id}")
-        except Exception as e:
-            logger.error(f"[CONVERSATION] ERROR: Failed to create/get agent: {str(e)}")
-            return jsonify({'error': 'Failed to create AI agent'}), 500
-        agent_time = time.time() - agent_start
-        logger.info(f"[CONVERSATION] Agent creation/retrieval completed in {agent_time:.3f}s")
+        initial_message = data.get('message', 'Hello, I need help with my DIY project.')
+        logger.info(f"[CONVERSATION] Initial message: {initial_message[:100]}{'...' if len(initial_message) > 100 else ''}")
+
+        # Initialize AI Handler
+        ai_handler = ConversationalAIHandler()
         
-        # Conversation simulation timing
-        simulation_start = time.time()
-        logger.info(f"[CONVERSATION] Starting conversation simulation with agent: {agent_id}")
-        try:
-            conversation_result = ai_handler.simulate_conversation(agent_id, initial_message)
-            logger.info(f"[CONVERSATION] Conversation simulation completed successfully")
-            logger.info(f"[CONVERSATION] Simulation result type: {type(conversation_result)}")
-            if isinstance(conversation_result, dict):
-                logger.info(f"[CONVERSATION] Simulation result keys: {list(conversation_result.keys())}")
-        except Exception as e:
-            logger.error(f"[CONVERSATION] ERROR: Failed to simulate conversation: {str(e)}")
-            return jsonify({'error': 'Failed to simulate conversation'}), 500
-        simulation_time = time.time() - simulation_start
-        logger.info(f"[CONVERSATION] Conversation simulation completed in {simulation_time:.3f}s")
+        # Create or get agent
+        agent_id = ai_handler.create_or_get_agent(project_id, project)
+        logger.info(f"[CONVERSATION] Agent ready: {agent_id}")
         
-        # Duration and cost calculation timing
-        calc_start = time.time()
+        # Start conversation
+        conversation_id = ai_handler.start_conversation(agent_id)
+        logger.info(f"[CONVERSATION] Conversation started: {conversation_id}")
+        
+        # Send initial message
+        response_data = ai_handler.send_message(agent_id, conversation_id, initial_message)
+        logger.info(f"[CONVERSATION] Message sent successfully")
+        
+        # Calculate cost and duration
         duration = time.time() - start_time
-        logger.info(f"[CONVERSATION] Total duration so far: {duration:.3f}s")
-        try:
-            cost = calculate_cost(duration)
-            logger.info(f"[CONVERSATION] Calculated cost: {cost} credits")
-        except Exception as e:
-            logger.error(f"[CONVERSATION] ERROR: Failed to calculate cost: {str(e)}")
-            return jsonify({'error': 'Failed to calculate cost'}), 500
-        calc_time = time.time() - calc_start
-        logger.info(f"[CONVERSATION] Cost calculation completed in {calc_time:.3f}s")
-
-        # Credit check timing
-        credit_check_start = time.time()
+        cost = calculate_cost(duration)
+        
+        # Check and deduct credits
         user_credits = user.get('credits', 0)
-        logger.info(f"[CONVERSATION] Checking credits - User has: {user_credits}, Cost: {cost}")
         if user_credits < cost:
-            logger.error(f"[CONVERSATION] ERROR: Insufficient credits - User: {user_credits}, Needed: {cost}")
+            logger.error(f"[CONVERSATION] ERROR: Insufficient credits")
             return jsonify({'error': 'Insufficient credits', 'needed': cost}), 402
-        credit_check_time = time.time() - credit_check_start
-        logger.info(f"[CONVERSATION] Credit check completed in {credit_check_time:.3f}s")
-
-        # Credit deduction timing
-        deduction_start = time.time()
+        
         new_credits = user_credits - cost
-        logger.info(f"[CONVERSATION] Deducting {cost} credits, new balance: {new_credits}")
-        try:
-            user_ref.update({'credits': new_credits})
-            logger.info(f"[CONVERSATION] Credits updated successfully in database")
-        except Exception as e:
-            logger.error(f"[CONVERSATION] ERROR: Failed to update user credits: {str(e)}")
-            return jsonify({'error': 'Failed to update credits'}), 500
-        deduction_time = time.time() - deduction_start
-        logger.info(f"[CONVERSATION] Credit deduction completed in {deduction_time:.3f}s")
-
-        # Conversation logging timing
-        logging_start = time.time()
-        conversation_id = f"{project_id}_{int(start_time)}"
-        logger.info(f"[CONVERSATION] Logging conversation with ID: {conversation_id}")
-        try:
-            conversation_data = {
-                'project_id': project_id,
-                'uid': uid,
-                'agent_id': agent_id,
-                'initial_message': initial_message,
-                'result': conversation_result,
-                'duration_seconds': duration,
-                'credits_used': cost,
-                'created_at': int(start_time)
-            }
-            db_ref.child(f'conversations/{conversation_id}').set(conversation_data)
-            logger.info(f"[CONVERSATION] Conversation logged successfully to database")
-        except Exception as e:
-            logger.error(f"[CONVERSATION] ERROR: Failed to log conversation: {str(e)}")
-            return jsonify({'error': 'Failed to log conversation'}), 500
-        logging_time = time.time() - logging_start
-        logger.info(f"[CONVERSATION] Conversation logging completed in {logging_time:.3f}s")
-
-        # Response preparation timing
-        response_start = time.time()
-        total_duration = time.time() - start_time
-        logger.info(f"[CONVERSATION] Preparing response, total duration: {total_duration:.3f}s")
-        try:
-            response_data = {
-                'conversation_id': conversation_id,
-                'agent_id': agent_id,
-                'simulation_result': conversation_result,
-                'durationSeconds': round(total_duration, 1),
-                'creditsDeducted': cost,
-                'remainingCredits': new_credits
-            }
-            logger.info(f"[CONVERSATION] Response prepared successfully")
-        except Exception as e:
-            logger.error(f"[CONVERSATION] ERROR: Failed to prepare response: {str(e)}")
-            return jsonify({'error': 'Failed to prepare response'}), 500
-        response_time = time.time() - response_start
-        logger.info(f"[CONVERSATION] Response preparation completed in {response_time:.3f}s")
-
-        # Final success logging
-        logger.info(f"[CONVERSATION] SUCCESS: User {uid} started conversation for project {project_id}, "
-                   f"duration {total_duration:.1f}s, cost {cost} credits.")
+        user_ref.update({'credits': new_credits})
         
-        # Performance summary
-        logger.info(f"[CONVERSATION] PERFORMANCE BREAKDOWN:")
-        logger.info(f"[CONVERSATION] - Authorization: {auth_time:.3f}s")
-        logger.info(f"[CONVERSATION] - User fetch: {user_fetch_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Project fetch: {project_fetch_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Data parsing: {data_parse_time:.3f}s")
-        logger.info(f"[CONVERSATION] - AI init: {ai_init_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Agent creation: {agent_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Simulation: {simulation_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Cost calc: {calc_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Credit check: {credit_check_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Credit deduction: {deduction_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Conversation logging: {logging_time:.3f}s")
-        logger.info(f"[CONVERSATION] - Response prep: {response_time:.3f}s")
-        logger.info(f"[CONVERSATION] - TOTAL: {total_duration:.3f}s")
-
-        return jsonify(response_data), 200
+        # Log conversation
+        conversation_log_id = f"{project_id}_{int(start_time)}"
+        conversation_data = {
+            'project_id': project_id,
+            'uid': uid,
+            'agent_id': agent_id,
+            'conversation_id': conversation_id,
+            'initial_message': initial_message,
+            'response': response_data,
+            'duration_seconds': duration,
+            'credits_used': cost,
+            'created_at': int(start_time)
+        }
+        db_ref.child(f'conversations/{conversation_log_id}').set(conversation_data)
+        
+        # Return success response
+        return jsonify({
+            'conversation_log_id': conversation_log_id,
+            'agent_id': agent_id,
+            'conversation_id': conversation_id,
+            'response': response_data,
+            'durationSeconds': round(duration, 1),
+            'creditsDeducted': cost,
+            'remainingCredits': new_credits
+        }), 200
 
     except Exception as e:
         total_duration = time.time() - start_time
-        logger.error(f"[CONVERSATION] CRITICAL ERROR: Unhandled exception after {total_duration:.3f}s")
+        logger.error(f"[CONVERSATION] CRITICAL ERROR: {str(e)}")
         logger.error(f"[CONVERSATION] Exception type: {type(e).__name__}")
-        logger.error(f"[CONVERSATION] Exception message: {str(e)}")
-        logger.error(f"[CONVERSATION] Exception traceback:", exc_info=True)
         return jsonify({'error': 'Failed to start conversation'}), 500
 
 @app.route('/api/projects/<project_id>/continue-conversation', methods=['POST'])