data not saving for user persona

ai_chat.py

@@ -105,13 +105,14 @@ def chat_with_session_memory(state):
     system_message = """You are a friendly, professional industrial property agent assistant. Be conversational and human-like in your responses.
 
 Key guidelines:
-- Always respond naturally to greetings (hi, hello, etc.) with a warm greeting back
+- ALWAYS respond naturally to greetings (hi, hello, etc.) with a warm greeting back FIRST
 - Use the user's name if available to make it personal
 - Be helpful and informative about industrial properties
 - Don't immediately jump to asking questions - have a natural conversation first
 - If someone asks for clarification about property terms, explain clearly and helpfully
 - Only ask about their property needs when they show interest in searching or viewing properties
-- Keep responses conversational and not robotic"""
+- Keep responses conversational and not robotic
+- If user says "hi" or "hello", respond with a greeting like "Hi [Name]! How can I help you with industrial properties today?" """
     
     if user_info.get("name") and user_info["name"] != "Unknown":
         system_message += f"\nThe user's name is {user_info['name']} - use their name to make it personal."

persona_manager.py

@@ -65,6 +65,7 @@ async def create_user_persona(wa_id: str) -> Dict:
 async def update_persona_field(wa_id: str, field: str, value) -> bool:
     """Update a specific field in user persona"""
     if not supabase:
+        print(f"Supabase not configured - skipping update for {field}: {value}")
         return False
     
     try:
@@ -72,7 +73,9 @@ async def update_persona_field(wa_id: str, field: str, value) -> bool:
             field: value,
             "updated_at": datetime.utcnow().isoformat()
         }
-        supabase.table("user_personas").update(update_data).eq("wa_id", wa_id).execute()
+        print(f"Updating persona field {field} with value {value} for user {wa_id}")
+        response = supabase.table("user_personas").update(update_data).eq("wa_id", wa_id).execute()
+        print(f"Persona update response: {response.data if response.data else 'No data returned'}")
         return True
     except Exception as e:
         print(f"Error updating persona field {field}: {e}")
@@ -123,12 +126,14 @@ async def parse_user_response(user_message: str, field: str) -> Tuple[bool, any,
         
         Rules:
         - For intent: accept "buy", "lease", "rent", "purchase", "own"
-        - For budget: extract numeric values (e.g., "around 500k" -> 500000)
-        - For size: extract square meters (e.g., "1500 sqm" -> 1500)
+        - For budget: extract numeric values (e.g., "around 500k" -> 500000, "$500,000" -> 500000)
+        - For size: extract square meters (e.g., "1500 sqm" -> 1500, "10000 sq ft" -> 929)
         - For location: extract location names
         - For must_have: extract features as array (e.g., ["truck access", "yard space"])
+        - If user says "yes", "yeah", "sure" to a suggestion, extract the suggested value
         - If user asks for clarification, set is_clarification=true
         - If user says "not sure", "skip", "later", set is_skip=true
+        - Be generous in parsing - if you can reasonably extract a value, do so
         """
         
         messages = [
@@ -185,8 +190,15 @@ async def fallback_parse_response(user_message: str, field: str) -> Tuple[bool,
         if any(word in user_message_lower for word in field_words):
             return False, None, PERSONA_FIELDS[field]["clarification"]
     
+    # Check for affirmative responses (yes, sure, ok, etc.)
+    affirmative_words = ["yes", "yeah", "yep", "sure", "ok", "okay", "correct", "right", "that's right", "exactly"]
+    if any(word in user_message_lower for word in affirmative_words):
+        # For affirmative responses, we need to get the value from context
+        # This will be handled by the LLM parsing, but we can provide a fallback
+        return True, "confirmed", "Got it! Thanks for confirming."
+    
     # Check for skip requests
-    skip_words = ["not sure", "skip", "later", "don't know", "maybe later", "pass"]
+    skip_words = ["not sure", "skip", "later", "don't know", "maybe later", "pass", "no idea"]
     if any(word in user_message_lower for word in skip_words):
         return True, None, PERSONA_FIELDS[field]["skip_response"]
     
@@ -199,9 +211,33 @@ async def fallback_parse_response(user_message: str, field: str) -> Tuple[bool,
     
     elif field == "budget":
         import re
+        # Look for currency patterns
+        budget_patterns = [
+            r'\$(\d+(?:,\d{3})*)',
+            r'(\d+(?:,\d{3})*)\s*dollars',
+            r'(\d+)\s*k',
+            r'(\d+)\s*thousand',
+            r'(\d+)\s*m',
+            r'(\d+)\s*million'
+        ]
+        
+        for pattern in budget_patterns:
+            match = re.search(pattern, user_message_lower)
+            if match:
+                budget_str = match.group(1).replace(',', '')
+                budget = int(budget_str)
+                
+                # Apply multipliers
+                if "k" in pattern or "thousand" in pattern:
+                    budget *= 1000
+                elif "m" in pattern or "million" in pattern:
+                    budget *= 1000000
+                
+                return True, budget, f"Thanks! I'll look for properties around ${budget:,}."
+        
+        # Fallback: just look for numbers
         numbers = re.findall(r'\d+', user_message)
         if numbers:
-            # Assume the largest number is the budget
             budget = max(int(n) for n in numbers)
             if "k" in user_message_lower or "thousand" in user_message_lower:
                 budget *= 1000
@@ -211,6 +247,26 @@ async def fallback_parse_response(user_message: str, field: str) -> Tuple[bool,
     
     elif field == "size_preference_sqm":
         import re
+        # Look for numbers followed by sqm, sq ft, square meters, etc.
+        size_patterns = [
+            r'(\d+)\s*sqm',
+            r'(\d+)\s*square\s*meters',
+            r'(\d+)\s*sq\s*ft',
+            r'(\d+)\s*square\s*feet',
+            r'(\d+)\s*ft',
+            r'(\d+)\s*feet'
+        ]
+        
+        for pattern in size_patterns:
+            match = re.search(pattern, user_message_lower)
+            if match:
+                size = int(match.group(1))
+                # Convert sq ft to sqm if needed
+                if 'ft' in pattern and 'sq' in pattern:
+                    size = int(size * 0.0929)  # Convert sq ft to sqm
+                return True, size, f"Perfect! {size} sqm should give you good options."
+        
+        # Fallback: just look for numbers
         numbers = re.findall(r'\d+', user_message)
         if numbers:
             size = max(int(n) for n in numbers)
@@ -273,15 +329,21 @@ async def should_ask_persona_question(persona: Dict, conversation_context: str =
     # Check for greetings or casual conversation - don't ask persona questions
     casual_indicators = [
         "hi", "hello", "hey", "good morning", "good afternoon", "good evening",
-        "how are you", "what's up", "thanks", "thank you", "bye", "goodbye"
+        "how are you", "what's up", "thanks", "thank you", "bye", "goodbye",
+        "morning", "afternoon", "evening", "sup", "yo"
     ]
     
+    # Check if the message is primarily a greeting
     is_casual = any(indicator in conversation_lower for indicator in casual_indicators)
     
-    # Don't ask persona questions during casual conversation
+    # If it's a greeting, don't ask persona questions
     if is_casual:
         return False, None
     
+    # Also check if the message is very short (likely a greeting)
+    if len(user_message.strip()) <= 10 and is_casual:
+        return False, None
+    
     # Only ask if user is actively searching for properties
     if is_searching:
         return True, missing_fields[0]