Update main.py

main.py

@@ -947,7 +947,263 @@ def delete_project(project_id):
         blob.delete()
     return jsonify({"success": True, "message": f"Project {project_id} deleted."})
 
+# AI call ElevenLabs
+CREDITS_PER_MIN = 3  # Adjust based on ElevenLabs conversational AI pricing
+VOICE_NAME = "Daniel"  # British male voice (more reliable than Archer)
+
+class ConversationalAIHandler:
+    def __init__(self):
+        self.client = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))
+        self.base_url = "https://api.elevenlabs.io/v1"
+        self.headers = {
+            "xi-api-key": os.getenv("ELEVENLABS_API_KEY"),
+            "Content-Type": "application/json"
+        }
+
+    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"]
+            
+            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
+            
+            # 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
+
+    def create_or_get_agent(self, project_id, project_data):
+        """Create or retrieve existing agent for the project"""
+        try:
+            voice_id = self.get_british_male_voice_id()
+            if not voice_id:
+                raise Exception("No suitable voice available")
+
+            # 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')}
+            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')}",
+                "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
+                    }
+                },
+                "webhook_url": f"{request.host_url}api/webhook/agent/{project_id}",
+                "max_duration_seconds": 1800  # 30 minutes max
+            }
+
+            # 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:
+                # 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
+
+            # Create new agent
+            response = requests.post(
+                f"{self.base_url}/agents",
+                headers=self.headers,
+                json=agent_data
+            )
+            
+            if response.status_code == 201:
+                agent_info = response.json()
+                agent_id = agent_info["id"]
+                
+                # Store agent ID in database
+                db_ref.child(f'projects/{project_id}').update({
+                    'agent_id': agent_id,
+                    'agent_created_at': int(time.time())
+                })
+                
+                return agent_id
+            else:
+                raise Exception(f"Failed to create agent: {response.text}")
+                
+        except Exception as e:
+            logger.error(f"Error creating/getting agent: {str(e)}")
+            raise
+
+    def simulate_conversation(self, agent_id, user_message):
+        """Simulate a conversation with the agent"""
+        try:
+            simulation_data = {
+                "simulation_specification": {
+                    "user_message": user_message,
+                    "max_turns": 10,
+                    "evaluation_criteria": ["helpfulness", "accuracy", "clarity"]
+                }
+            }
+            
+            response = requests.post(
+                f"{self.base_url}/agents/{agent_id}/simulate-conversation",
+                headers=self.headers,
+                json=simulation_data
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            else:
+                raise Exception(f"Simulation failed: {response.text}")
+                
+        except Exception as e:
+            logger.error(f"Error simulating conversation: {str(e)}")
+            raise
+
+def calculate_cost(duration_seconds):
+    """Calculate cost based on conversation duration"""
+    minutes = (duration_seconds + 59) // 60
+    return minutes * CREDITS_PER_MIN
+
+@app.route('/api/projects/<project_id>/start-conversation', methods=['POST'])
+def start_conversation(project_id):
+    """Start a conversational AI session for a project"""
+    t0 = time.time()
+    
+    try:
+        uid = verify_token(request.headers.get('Authorization'))
+        if not uid:
+            return jsonify({'error': 'Unauthorized'}), 401
+
+        user_ref = db_ref.child(f'users/{uid}')
+        user = user_ref.get()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+
+        project = db_ref.child(f'projects/{project_id}').get()
+        if not project or project.get('uid') != uid:
+            return jsonify({'error': 'Project not found'}), 404
 
+        data = request.get_json()
+        initial_message = data.get('message', 'Hello, I need help with my DIY project.')
+
+        # Initialize conversational AI handler
+        ai_handler = ConversationalAIHandler()
+        
+        # Create or get existing agent
+        agent_id = ai_handler.create_or_get_agent(project_id, project)
+        
+        # Start conversation simulation
+        conversation_result = ai_handler.simulate_conversation(agent_id, initial_message)
+        
+        duration = time.time() - t0
+        cost = calculate_cost(duration)
+
+        # Check credits
+        if user.get('credits', 0) < cost:
+            return jsonify({'error': 'Insufficient credits', 'needed': cost}), 402
+
+        # Deduct credits
+        new_credits = user['credits'] - cost
+        user_ref.update({'credits': new_credits})
+
+        # Log the conversation
+        conversation_id = f"{project_id}_{int(t0)}"
+        db_ref.child(f'conversations/{conversation_id}').set({
+            '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(t0)
+        })
+
+        logger.info(f"User {uid} started conversation for project {project_id}, "
+                   f"duration {duration:.1f}s, cost {cost} credits.")
+
+        return jsonify({
+            'conversation_id': conversation_id,
+            'agent_id': agent_id,
+            'simulation_result': conversation_result,
+            'durationSeconds': round(duration, 1),
+            'creditsDeducted': cost,
+            'remainingCredits': new_credits
+        }), 200
+
+    except Exception as e:
+        logger.error(f"Error starting conversation: {str(e)}")
+        return jsonify({'error': 'Failed to start conversation'}), 500
+
+@app.route('/api/projects/<project_id>/continue-conversation', methods=['POST'])
+def continue_conversation(project_id):
+    """Continue an existing conversation"""
+    try:
+        uid = verify_token(request.headers.get('Authorization'))
+        if not uid:
+            return jsonify({'error': 'Unauthorized'}), 401
+
+        data = request.get_json()
+        agent_id = data.get('agent_id')
+        message = data.get('message')
+
+        if not agent_id or not message:
+            return jsonify({'error': 'agent_id and message required'}), 400
+
+        ai_handler = ConversationalAIHandler()
+        result = ai_handler.simulate_conversation(agent_id, message)
+
+        return jsonify({
+            'simulation_result': result,
+            'timestamp': int(time.time())
+        }), 200
+
+    except Exception as e:
+        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
 # -----------------------------------------------------------------------------