Update main.py

main.py

@@ -951,265 +951,105 @@ def delete_project(project_id):
 #------------------------
 # AI phone call ElevenLabs
 #-------------------------
+import math
 
-# Configuration
-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):
-        # This is the correct base URL for this specific API
-        self.base_url = "https://api.elevenlabs.io/v1/convai"
-        self.api_key = os.getenv("ELEVENLABS_API_KEY")
-        if not self.api_key:
-            logger.critical("[CONVAI] ELEVENLABS_API_KEY environment variable not set.")
-            raise ValueError("ELEVENLABS_API_KEY environment variable not set.")
-        self.headers = {
-            "xi-api-key": self.api_key,
-            "Content-Type": "application/json"
-        }
-
-    def get_british_male_voice_id(self):
-        """Gets a known British male voice ID."""
-        logger.info(f"[CONVAI] Using known voice ID for Daniel.")
-        return KNOWN_VOICE_IDS.get("Daniel", "onwK4e9ZLuTAKqWW03F9")
 
-    def create_or_get_agent(self, project_id, project_data):
-        """Creates or retrieves a Convai agent."""
-        try:
-            logger.info(f"[CONVAI] Starting agent creation/retrieval for project: {project_id}")
 
-            existing_agent_id = db_ref.child(f'projects/{project_id}/agent_id').get()
-            if existing_agent_id:
-                # The Convai API does not have a simple GET /agents/{id} endpoint for verification.
-                # We will trust the ID from our database.
-                logger.info(f"[CONVAI] Found existing agent ID in DB: {existing_agent_id}. Assuming active.")
-                return existing_agent_id
+AGENT_ID = os.getenv("AGENT_ID", "agent_01jy1vv1hqe2b9x0yyp6ayrdxj")
+ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
 
-            logger.info(f"[CONVAI] Creating new Convai agent.")
-            voice_id = self.get_british_male_voice_id()
+@app.route('/api/projects/<project_id>/initiate-call', methods=['POST'])
+def initiate_call(project_id):
+    """
+    Securely fetches a signed URL from ElevenLabs for the client-side SDK.
+    """
+    logger.info(f"[INITIATE] Received request for project: {project_id}")
+    
+    # Your real authentication logic should be active
+    uid = verify_token(request.headers.get('Authorization'))
+    if not uid:
+        return jsonify({'error': 'Unauthorized'}), 401
 
-            diy_expert_prompt = f"""
-            You are an experienced DIY expert... [Your full prompt here] ...
-            """
-            
-            agent_payload = {
-                "conversation_config": {
-                    "name": f"DIY Expert - {project_data.get('projectTitle', project_id)}",
-                    "voice_id": voice_id,
-                    "model_id": "eleven_turbo_v2",
-                    "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?",
-                    "prompt": diy_expert_prompt
-                }
-            }
-            creation_url = f"{self.base_url}/agents/create"
-            response = requests.post(creation_url, headers=self.headers, json=agent_payload, timeout=30)
-
-            if response.status_code == 200:
-                agent_info = response.json()
-                agent_id = agent_info.get("agent_id")
-                logger.info(f"[CONVAI] New agent created successfully: {agent_id}")
-                db_ref.child(f'projects/{project_id}').update({'agent_id': agent_id})
-                return agent_id
-            else:
-                logger.error(f"[CONVAI] Failed to create agent. Status: {response.status_code}, Response: {response.text}")
-                raise Exception(f"Failed to create agent: HTTP {response.status_code} - {response.text}")
+    if not ELEVENLABS_API_KEY:
+        logger.error("[INITIATE] ELEVENLABS_API_KEY is not set on the server.")
+        return jsonify({'error': 'Server configuration error.'}), 500
 
-        except Exception as e:
-            logger.error(f"[CONVAI] An exception occurred in create_or_get_agent: {e}")
-            raise
+    url = f"https://api.elevenlabs.io/v1/convai/conversation/get-signed-url?agent_id={AGENT_ID}"
+    headers = {"xi-api-key": ELEVENLABS_API_KEY}
 
-    def get_conversation_url(self, agent_id):
-        """
-        Gets a signed WebSocket URL to start a conversation.
-        This is the only method needed to start the conversation flow.
-        """
-        try:
-            logger.info(f"[CONVAI] Requesting signed WebSocket URL for agent: {agent_id}")
-            url = f"{self.base_url}/conversation/get-signed-url"
-            params = {"agent_id": agent_id}
-            
-            resp = requests.get(url, headers=self.headers, params=params, timeout=15)
+    try:
+        response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()
 
-            if resp.status_code != 200:
-                logger.error(f"[CONVAI] Signed-URL request failed ({resp.status_code}): {resp.text}")
-                raise Exception(f"Could not get signed URL: {resp.text}")
+        data = response.json()
+        signed_url = data.get("signed_url")
 
-            data = resp.json()
-            signed_url = data.get("signed_url")
-            if not signed_url:
-                logger.error("[CONVAI] Missing 'signed_url' in response.")
-                raise Exception("Invalid signed URL response from ElevenLabs")
+        if not signed_url:
+            logger.error("[INITIATE] ElevenLabs response missing 'signed_url'.")
+            return jsonify({'error': 'Failed to retrieve session URL from provider.'}), 502
 
-            logger.info("[CONVAI] Successfully retrieved WebSocket URL.")
-            return signed_url
-            
-        except Exception as e:
-            logger.error(f"[CONVAI] Exception in get_conversation_url: {e}")
-            raise
+        logger.info("[INITIATE] Successfully retrieved signed URL.")
+        return jsonify({"signed_url": signed_url}), 200
 
-    # The send_message function is intentionally removed as it is not used in this WebSocket architecture.
+    except requests.exceptions.RequestException as e:
+        logger.error(f"[INITIATE] Error calling ElevenLabs API: {e}")
+        return jsonify({'error': 'Could not connect to AI service provider.'}), 504
 
-def calculate_cost(duration_seconds):
-    """Calculate cost based on conversation duration"""
-    minutes = (duration_seconds + 59) // 60
-    return minutes * CREDITS_PER_MIN
 
-# Your existing Flask route - no changes needed
-@app.route('/api/projects/<project_id>/start-conversation', methods=['POST'])
-def start_conversation(project_id):
+@app.route('/api/projects/<project_id>/log-call-usage', methods=['POST'])
+def log_call_usage(project_id):
     """
-    Initiates a conversational AI session by providing the client with a secure WebSocket URL.
-    This backend route authorizes the user, creates/retrieves the agent, deducts an initiation
-    cost, and returns the URL. The client is responsible for the actual conversation.
+    Calculates and deducts credits from a user's account in Firebase
+    after a call is completed. This is the production-ready version.
     """
-    start_time = time.time()
-    logger.info(f"[CONVERSATION] Starting conversation initiation process for project: {project_id}")
+    logger.info(f"[LOGGING] Received usage log for project: {project_id}")
     
-    try:
-        # Step 1: Authorization and Data Validation (Unchanged)
-        uid = verify_token(request.headers.get('Authorization'))
-        if not uid:
-            logger.error(f"[CONVERSATION] ERROR: Unauthorized access for project: {project_id}")
-            return jsonify({'error': 'Unauthorized'}), 401
+    # Step 1: Authenticate the user and get their unique ID
+    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:
-            logger.error(f"[CONVERSATION] ERROR: User not found for uid: {uid}")
-            return jsonify({'error': 'User not found'}), 404
+    data = request.get_json()
+    duration_seconds = data.get("durationSeconds")
 
-        project = db_ref.child(f'projects/{project_id}').get()
-        if not project or project.get('uid') != uid:
-            logger.error(f"[CONVERSATION] ERROR: Project not found or access denied for user {uid}")
-            return jsonify({'error': 'Project not found'}), 404
+    if duration_seconds is None or not isinstance(duration_seconds, (int, float)):
+        return jsonify({'error': 'Invalid duration provided.'}), 400
 
-        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
-        
-        # The initial message is noted but will be sent by the client, not the backend.
-        initial_message = data.get('message', 'Hello, I need help with my DIY project.')
-        logger.info(f"[CONVERSATION] User's initial message (to be sent by client): {initial_message[:100]}{'...' if len(initial_message) > 100 else ''}")
-
-        # Step 2: Initialize Handler and Get Agent (Unchanged)
-        ai_handler = ConversationalAIHandler()
-        agent_id = ai_handler.create_or_get_agent(project_id, project)
-        logger.info(f"[CONVERSATION] Agent ready: {agent_id}")
-        
-        # Step 3: Get the Secure WebSocket URL (This is the new core logic)
-        # This replaces the old start_conversation and send_message calls.
-        websocket_url = ai_handler.get_conversation_url(agent_id)
-        logger.info(f"[CONVERSATION] WebSocket URL received from ElevenLabs.")
-        
-        # Step 4: Calculate Cost and Deduct Credits (Logic adapted for initiation fee)
-        # The cost is now for the service of setting up the session.
-        duration = time.time() - start_time
-        cost = calculate_cost(duration) # Or a flat fee, e.g., cost = CREDITS_PER_MIN
-        
-        user_credits = user.get('credits', 0)
-        if user_credits < cost:
-            logger.error(f"[CONVERSATION] ERROR: Insufficient credits for session initiation.")
-            return jsonify({'error': 'Insufficient credits', 'needed': cost}), 402
-        
-        new_credits = user_credits - cost
-        user_ref.update({'credits': new_credits})
-        logger.info(f"[CONVERSATION] Billed {cost} credits for session initiation. Remaining credits: {new_credits}")
-
-        # Step 5: Log the Session Initiation
-        # We log that a session was started, but not the back-and-forth messages.
-        conversation_log_id = f"{project_id}_{int(start_time)}"
-        conversation_data = {
-            'project_id': project_id,
-            'uid': uid,
-            'agent_id': agent_id,
-            'conversation_log_id': conversation_log_id, # Self-reference
-            'initial_message_prompt': initial_message,
-            'duration_seconds_backend': duration, # Log backend processing time
-            'credits_used': cost,
-            'created_at': int(start_time)
-        }
-        db_ref.child(f'conversations/{conversation_log_id}').set(conversation_data)
-        
-        # Step 6: Return the WebSocket URL to the Client
-        # The client will use this URL to establish a direct connection for the conversation.
-        return jsonify({
-            'websocket_url': websocket_url,
-            'agent_id': agent_id,
-            'conversation_log_id': conversation_log_id,
-            'status': 'success',
-            'durationSeconds': round(duration, 1),
-            'creditsDeducted': cost,
-            'remainingCredits': new_credits
-        }), 200
+    # Step 2: Calculate credit cost (3 credits per minute, always rounded up)
+    minutes = math.ceil(duration_seconds / 60)
+    cost = minutes * 3
+    
+    logger.info(f"[LOGGING] User '{uid}' call duration: {duration_seconds:.2f}s, rounded to {minutes} minute(s). Cost: {cost} credits.")
 
-    except Exception as e:
-        total_duration = time.time() - start_time
-        logger.error(f"[CONVERSATION] CRITICAL ERROR in start_conversation route: {str(e)}")
-        logger.error(f"[CONVERSATION] Exception type: {type(e).__name__}")
-        return jsonify({'error': 'Failed to initiate 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}")
+        # Step 3: Perform the database transaction
+        user_ref = db_ref.child(f'users/{uid}')
+        user_data = user_ref.get()
+
+        if user_data is None:
+            logger.error(f"[LOGGING] User with UID '{uid}' not found in the database.")
+            return jsonify({'error': 'User not found.'}), 404
+
+        current_credits = user_data.get('credits', 0)
         
-        # 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())
-        })
+        # Calculate the new balance, ensuring it doesn't go below zero.
+        new_credits = max(0, current_credits - cost)
         
-        return jsonify({'status': 'received'}), 200
+        # Update the user's credit balance in Firebase
+        user_ref.update({'credits': new_credits})
         
-    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"""
-    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)
+        logger.info(f"[LOGGING] Successfully updated credits for user '{uid}'. Old: {current_credits}, New: {new_credits}")
 
+        # Step 4: Return the successful response with the actual new balance
         return jsonify({
-            'simulation_result': result,
-            'timestamp': int(time.time())
+            "status": "success",
+            "creditsDeducted": cost,
+            "remainingCredits": new_credits
         }), 200
 
     except Exception as e:
-        logger.error(f"Error continuing conversation: {str(e)}")
-        return jsonify({'error': 'Failed to continue conversation'}), 500
+        logger.error(f"[LOGGING] A database error occurred for user '{uid}': {e}")
+        return jsonify({'error': 'A server error occurred while updating credits.'}), 500
 
 
 # -----------------------------------------------------------------------------