Update app.py

app.py

@@ -10,7 +10,8 @@ from admin_messages import extract_admin_message, save_admin_message
 
 app = Flask(__name__)
 
-
+# Cache for user profiles to reduce API calls
+user_profile_cache = {}
 
 chat_histories = {}
 
@@ -33,6 +34,47 @@ def verify_webhook():
         print(f"Verification failed: mode={mode}, token={token}")  # Debug log
         return "Verification failed", 403
 
+def get_user_profile(sender_id, page_token):
+    """Get user profile with fallback mechanisms"""
+    # Check cache first
+    cache_key = f"{sender_id}_{page_token[:10]}"  # Use first 10 chars of token for cache key
+    if cache_key in user_profile_cache:
+        print(f"Using cached profile for {sender_id}")
+        return user_profile_cache[cache_key]
+
+    # Default fallback name
+    user_full_name = "User"
+
+    try:
+        proxy_params = {
+            "sender_id": sender_id,
+            "page_token": page_token
+        }
+
+        # Add timeout to prevent hanging
+        proxy_response = requests.get(PROXY_API_URL, params=proxy_params, timeout=5)
+
+        # Even if the request fails with non-200 status, continue with default name
+        if proxy_response.status_code == 200:
+            proxy_data = proxy_response.json()
+            if proxy_data.get("success", False):
+                user_full_name = proxy_data.get("full_name", "User")
+                # Cache the successful result
+                user_profile_cache[cache_key] = user_full_name
+            else:
+                print(f"Proxy API returned error: {proxy_data.get('error', 'Unknown error')}")
+        else:
+            print(f"Proxy API returned status code: {proxy_response.status_code}")
+
+    except requests.exceptions.Timeout:
+        print(f"Timeout when calling proxy API for user {sender_id}")
+    except requests.exceptions.RequestException as e:
+        print(f"Error calling proxy API: {str(e)}")
+    except Exception as e:
+        print(f"Unexpected error getting user profile: {str(e)}")
+
+    return user_full_name
+
 @app.route("/webhook", methods=["POST"])
 def handle_message():
     body = request.get_json()
@@ -97,24 +139,8 @@ def handle_message():
                 sender_id = messaging_event["sender"]["id"]
                 message = messaging_event["message"]
 
-                # Fetch the user's profile information via the proxy API
-                user_full_name = "User"  # Default fallback
-
-                try:
-                    proxy_params = {
-                        "sender_id": sender_id,
-                        "page_token": page_token
-                    }
-                    proxy_response = requests.get(PROXY_API_URL, params=proxy_params)
-                    proxy_response.raise_for_status()
-                    proxy_data = proxy_response.json()
-
-                    if proxy_data["success"]:
-                        user_full_name = proxy_data["full_name"]
-                    else:
-                        print(f"Proxy API error: {proxy_data['error']}")
-                except Exception as e:
-                    print(f"Error calling proxy API: {str(e)}")
+                # Get user profile with improved error handling
+                user_full_name = get_user_profile(sender_id, page_token)
 
                 # Get or create chat history for this user
                 user_history = chat_histories.setdefault(sender_id, {
@@ -137,7 +163,7 @@ def handle_message():
                         if attachment["type"] == "image":
                             image_url = attachment["payload"]["url"]
                             try:
-                                img_response = requests.get(image_url)
+                                img_response = requests.get(image_url, timeout=10)
                                 img_response.raise_for_status()
                                 temp_path = f"temp_{uuid.uuid4()}.jpg"
                                 with open(temp_path, "wb") as f:
@@ -154,7 +180,7 @@ def handle_message():
                         elif attachment["type"] == "audio":
                             audio_url = attachment["payload"]["url"]
                             try:
-                                audio_response = requests.get(audio_url)
+                                audio_response = requests.get(audio_url, timeout=10)
                                 audio_response.raise_for_status()
 
                                 # Extract file extension from the original filename
@@ -214,43 +240,66 @@ def handle_message():
                 while len(user_history['history']) > 5:
                     user_history['history'].pop(0)
 
-                # Generate AI response using the dynamically updated system prompt
-                ai_response = get_qwen_response(
-                    system_prompt=user_history['system_prompt'],
-                    chat_history=user_history['history']
-                )
-
-                # Check if the AI response contains an admin message
-                admin_message, cleaned_response = extract_admin_message(ai_response)
-
-                # Always add the original response to chat history (with admin tags if present)
-                user_history['history'].append({
-                    "role": "assistant",
-                    "content": [{"type": "text", "text": ai_response}]
-                })
+                try:
+                    # Generate AI response using the dynamically updated system prompt
+                    ai_response = get_qwen_response(
+                        system_prompt=user_history['system_prompt'],
+                        chat_history=user_history['history']
+                    )
+
+                    # Check if the AI response contains an admin message
+                    admin_message, cleaned_response = extract_admin_message(ai_response)
+
+                    # Always add the original response to chat history (with admin tags if present)
+                    user_history['history'].append({
+                        "role": "assistant",
+                        "content": [{"type": "text", "text": ai_response}]
+                    })
+
+                    # If there's an admin message, save it to the GitHub JSON file
+                    if admin_message:
+                        print(f"Admin message detected: {admin_message}")
+                        save_admin_message(page_id, admin_message, sender_id, user_full_name)
+
+                        # Send the cleaned response (without admin tags) to the user
+                        response_to_send = cleaned_response
+                    else:
+                        # No admin message, send the original response
+                        response_to_send = ai_response
+
+                    # Send the appropriate response back to the user
+                    try:
+                        headers = {
+                            "Authorization": f"Bearer {AI_SERVICE_TOKEN}",
+                            "Content-Type": "application/json"
+                        }
+                        payload = {
+                            "recipient_id": sender_id,
+                            "message_text": response_to_send,
+                            "page_access_token": page_token
+                        }
+                        send_response = requests.post(AI_SERVICE_URL, json=payload, headers=headers, timeout=10)
+                        send_response.raise_for_status()
+                        print(f"Response sent successfully to {sender_id}")
+                    except Exception as e:
+                        print(f"Error sending response to user: {str(e)}")
 
-                # If there's an admin message, save it to the GitHub JSON file
-                if admin_message:
-                    print(f"Admin message detected: {admin_message}")
-                    save_admin_message(page_id, admin_message, sender_id, user_full_name)
-
-                    # Send the cleaned response (without admin tags) to the user
-                    response_to_send = cleaned_response
-                else:
-                    # No admin message, send the original response
-                    response_to_send = ai_response
-
-                # Send the appropriate response back to the user
-                headers = {
-                    "Authorization": f"Bearer {AI_SERVICE_TOKEN}",
-                    "Content-Type": "application/json"
-                }
-                payload = {
-                    "recipient_id": sender_id,
-                    "message_text": response_to_send,
-                    "page_access_token": page_token
-                }
-                requests.post(AI_SERVICE_URL, json=payload, headers=headers)
+                except Exception as e:
+                    print(f"Error generating AI response: {str(e)}")
+                    # Send a fallback message if AI response generation fails
+                    try:
+                        headers = {
+                            "Authorization": f"Bearer {AI_SERVICE_TOKEN}",
+                            "Content-Type": "application/json"
+                        }
+                        payload = {
+                            "recipient_id": sender_id,
+                            "message_text": "I'm sorry, I'm having trouble processing your request right now. Please try again later.",
+                            "page_access_token": page_token
+                        }
+                        requests.post(AI_SERVICE_URL, json=payload, headers=headers, timeout=10)
+                    except Exception as send_err:
+                        print(f"Error sending fallback message: {str(send_err)}")
 
     return "OK", 200