peronsas new

ai_chat.py

@@ -2,49 +2,15 @@ from langgraph.graph import StateGraph, END
 from langchain_core.runnables import RunnableLambda
 from typing import TypedDict
 from config import llm, OPENAI_API_KEY
-from database import get_session_messages, save_message, search_properties, get_available_cities
-from persona_manager import (
-    get_or_create_persona, 
-    should_ask_persona_question, 
-    parse_user_response, 
-    update_persona_field,
-    PERSONA_FIELDS,
-    get_persona_summary,
-    extract_persona_from_message
-)
-from config import supabase
-from datetime import datetime
-import re
+from database import get_session_messages, save_message, update_user_persona
 
-async def search_properties_for_ai(city=None, min_size=None, features=None, price_type=None, limit=5):
-    """Search properties for AI responses"""
-    try:
-        properties = await search_properties(city=city, min_size=min_size, features=features, price_type=price_type, limit=limit)
-        return properties
-    except Exception as e:
-        print(f"Error searching properties: {e}")
-        return []
-
-async def get_property_details_for_ai(property_id):
-    """Get detailed property information for AI responses"""
-    try:
-        properties = await search_properties(limit=100)  # Get all properties
-        for prop in properties:
-            if prop['id'] == property_id:
-                return prop
-        return None
-    except Exception as e:
-        print(f"Error getting property details: {e}")
-        return None
-
-async def chat_with_session_memory(state):
-    """Chat function with session-based memory and persona collection"""
+def chat_with_session_memory(state):
+    """Chat function with session-based memory"""
     user_message = state["user_message"]
     user_info = state.get("user_info", {})
     session_id = state.get("session_id")
     wa_id = state.get("wa_id")
     wamid = state.get("wamid")
-    persona = state.get("persona", {})
     
     # Get conversation history from database
     session_messages = []
@@ -52,104 +18,48 @@ async def chat_with_session_memory(state):
         # This will be populated by the async wrapper
         session_messages = state.get("session_messages", [])
     
-    # Build context for the AI
-    context = f"User: {user_info.get('name', 'there')}\n"
-    if persona:
-        context += f"Persona: {persona}\n"
+    # Add system message with user context
+    system_message = "You are a helpful and concise property agent."
+    if user_info.get("name") and user_info["name"] != "Unknown":
+        system_message += f" The user's name is {user_info['name']}."
     
-    # Add system message with context
-    system_message = f"""You are a friendly, professional industrial property agent assistant with access to a real property database. Be conversational and human-like in your responses.
-
-Context:
-{context}
-
-Key guidelines:
-- You are a property agent with access to real property listings in a database
-- You can search the database for properties using the search_properties_for_ai() function
-- When users ask about properties, search the database and provide real property information
-- NEVER say you can't help or suggest other websites - you have real property data
-- Be helpful and informative about industrial properties
-- Keep responses conversational and not robotic
-- Always respond naturally and conversationally
-- Use the conversation context to understand what the user needs
-
-Available functions:
-- search_properties_for_ai(city=None, min_size=None, features=None, price_type=None, limit=5) - Search for properties in the database
-
-When users ask about properties, search the database and provide the actual property listings with details like title, location, size, price, and features.
-
-Respond naturally to the user's message: {user_message}"""
+    p = state.get("persona", {})
+    system_message += (
+        f" The user prefers {p.get('language','[unspecified]')} and wants a {p.get('tone','neutral')} tone. "
+        f"They are {p.get('intent','[unspecified]')}ing with a budget up to {p.get('budget','any')} per month, "
+        f"prefer around {p.get('size_preference_sqm','any')} sqm in {p.get('location_preference','[anywhere]')}, "
+        f"and must-haves are {', '.join(p.get('must_have',[])) or '[none]'}. "
+    )
+    
+    # Build messages array with history
+    messages = [{"role": "system", "content": system_message}]
+    
+    # Add conversation history (last 10 messages)
+    for msg in session_messages[-30:]:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+    
+    # Add current user message
+    messages.append({"role": "user", "content": user_message})
 
-    # Use LLM to generate response
     try:
-        messages = [{"role": "system", "content": system_message}]
-        
-        # Add recent conversation history for context
-        for msg in session_messages[-5:]:  # Last 5 messages for context
-            messages.append({"role": msg["role"], "content": msg["content"]})
-        
-        messages.append({"role": "user", "content": user_message})
+        if not OPENAI_API_KEY:
+            return {"response": "Sorry, AI chat is not available. Please check your OpenAI API key configuration."}
         
         response = llm.invoke(messages)
-        ai_response = response.content.strip()
-        
-        # If the AI response suggests it needs property information, search the database
-        if any(keyword in user_message.lower() for keyword in ["property", "properties", "warehouse", "office", "space", "johannesburg", "cape town", "pretoria", "durban"]):
-            # Extract city from persona or message
-            city = None
-            if persona.get("location_preference"):
-                city = persona["location_preference"]
-            
-            # Search for properties
-            properties = await search_properties_for_ai(city=city, limit=5)
-            
-            if properties:
-                # Create a detailed property response
-                property_response = "🏢 **Available Properties:**\n\n"
-                for i, prop in enumerate(properties[:3], 1):
-                    property_response += f"**{i}. {prop['title']}**\n"
-                    property_response += f"📍 {prop['location']}, {prop['city']}\n"
-                    property_response += f"📏 {prop['size_sqm']} sqm • 💰 R{prop['price']:,.0f}/month\n"
-                    if prop.get('listing_url'):
-                        property_response += f"🔗 {prop['listing_url']}\n"
-                    if prop.get('features'):
-                        property_response += f"✨ {', '.join(prop.get('features', [])[:3])}\n"
-                    property_response += "\n"
-                
-                property_response += "Which property interests you? I can show you photos, provide more details, or help you schedule a viewing!"
-                
-                return {
-                    "response": property_response,
-                    "user_message": user_message,
-                    "ai_response": property_response,
-                    "session_id": session_id,
-                    "wa_id": wa_id,
-                    "wamid": wamid,
-                    "current_property": None,
-                    "property_details": {}
-                }
+        ai_response = response.content
         
+        # Save messages to database (this will be handled by the async wrapper)
         return {
             "response": ai_response,
             "user_message": user_message,
             "ai_response": ai_response,
             "session_id": session_id,
             "wa_id": wa_id,
-            "wamid": wamid,
-            "current_property": None,
-            "property_details": {}
-        }
-        
-    except Exception as e:
-        print(f"Error in LangGraph: {e}")
-        return {
-            "response": "I'm having trouble processing your request right now. Could you please try again?",
-            "user_message": user_message,
-            "ai_response": "I'm having trouble processing your request right now. Could you please try again?",
-            "session_id": session_id,
-            "wa_id": wa_id,
             "wamid": wamid
         }
+    except Exception as e:
+        print(f"Error in chat_with_session_memory: {e}")
+        return {"response": "Sorry, something went wrong: " + str(e)}
 
 class ChatState(TypedDict):
     user_message: str
@@ -160,230 +70,95 @@ class ChatState(TypedDict):
     wamid: str
     session_messages: list
     persona: dict
-    current_property: str
-    property_details: dict
-
-# --- Build LangGraph ---
-graph = StateGraph(ChatState)
-graph.add_node("chat", chat_with_session_memory)
-graph.set_entry_point("chat")
-graph.add_edge("chat", END)
-chat_graph = graph.compile()
 
-async def handle_property_search(user_message, persona):
-    """Detects property search intent and returns AI-summarized property suggestions."""
-    # Extract city from persona or message
-    city = None
-    if persona.get("location_preference"):
-        city = persona["location_preference"]
-    else:
-        # Try to extract city from message (improved pattern matching)
-        # Pattern 1: "in [city]"
-        match = re.search(r"in ([a-zA-Z ]+)", user_message, re.IGNORECASE)
-        if match:
-            city = match.group(1).strip()
-        else:
-            # Pattern 2: "show me [city]" or "show [city]"
-            match = re.search(r"show me ([a-zA-Z ]+)", user_message, re.IGNORECASE)
-            if match:
-                city = match.group(1).strip()
-            else:
-                # Pattern 3: "show [city]"
-                match = re.search(r"show ([a-zA-Z ]+)", user_message, re.IGNORECASE)
-                if match:
-                    city = match.group(1).strip()
-    
-    if not city:
-        return ["I'd be happy to help you find properties! Which city are you looking in?"]
-    
-    # Determine search specificity based on user message
-    user_message_lower = user_message.lower()
-    
-    # Check if this is a broad search (just city) or specific search
-    broad_search_indicators = [
-        "show me", "show", "listings", "properties", "warehouses", "eiendomme", "toon my"
-    ]
-    
-    specific_search_indicators = [
-        "matching", "that match", "with", "for my", "suitable for", "perfect for", "ideal for"
+async def extract_and_update_persona(state):
+    persona = state.get("persona", {})
+    # 1. Build a list of missing fields:
+    missing = [f for f in 
+        ("language","tone","intent","budget",
+         "size_preference_sqm","location_preference","must_have")
+        if not persona.get(f)
     ]
-    
-    is_broad_search = any(indicator in user_message_lower for indicator in broad_search_indicators)
-    is_specific_search = any(indicator in user_message_lower for indicator in specific_search_indicators)
-    
-    # Use ONLY location filter - make search very broad
-    min_size = None  # Don't filter by size for now
-    features = None  # Don't filter by features
-    price_type = None  # Don't filter by price type
-    
-    print(f"Search type: {'Broad' if is_broad_search else 'Specific'}")
-    print(f"Searching properties with filters: city={city}, min_size={min_size}, features={features}, price_type={price_type}")
-    properties = await search_properties(city=city, min_size=min_size, features=features, price_type=price_type, limit=5)
-    print(f"Found {len(properties)} properties")
-    
-    if not properties:
-        # Check if the city is actually in available cities
-        available_cities = await get_available_cities()
-        print(f"Available cities: {available_cities}")
-        
-        if city.lower() in [c.lower() for c in available_cities]:
-            if is_broad_search:
-                msg = f"Sorry, we currently have no properties available in {city.title()}."
-            else:
-                msg = f"Sorry, we currently have no properties available in {city.title()} that match your specific requirements."
-        else:
-            msg = f"Sorry, we don't have any properties in {city.title()} at the moment."
+    # 2. If any fields are missing:
+    if missing:
+        # • Prompt your LLM to extract and normalize all missing fields from
+        #   state["user_message"] in one shot.
+        # • Receive a dict of field→value pairs.
+        extraction_prompt = f"""
+        Extract the following information from this user message: {state["user_message"]}
         
-        if available_cities:
-            msg += f"\n\nWe do have properties in: {', '.join(available_cities)}."
-            if city and city.lower() in [c.lower() for c in available_cities]:
-                msg += f"\n\nTry asking for properties in {city.title()} without specific requirements, or let me know what you're looking for!"
-        return [msg]
-    
-    # Create AI-summarized property suggestions
-    messages = []
-    
-    # First message: Introduction
-    intro_msg = f"Great! I found {len(properties)} properties in {city.title()} that might interest you. "
-    if persona.get("size_preference_sqm"):
-        intro_msg += f"Based on your preference for {persona['size_preference_sqm']} sqm, "
-    intro_msg += "Here are my top recommendations:"
-    messages.append(intro_msg)
-    
-    # Individual property messages with AI summary
-    for i, prop in enumerate(properties[:3], 1):
-        # Create AI summary for each property
-        summary_prompt = f"""
-        Summarize this property in a conversational, engaging way for a potential tenant:
+        Required fields to extract:
+        - language: The language the user prefers (e.g., "English", "Afrikaans")
+        - tone: The communication style preference (e.g., "formal", "casual", "friendly")
+        - intent: What the user wants to do (e.g., "buy", "rent", "sell", "invest")
+        - budget: Monthly budget in currency (e.g., "2000 ZAR", "R3000")
+        - size_preference_sqm: Property size preference in square meters (e.g., "80", "120")
+        - location_preference: Preferred location or area (e.g., "Pretoria", "Johannesburg", "Cape Town")
+        - must_have: Essential features or requirements (e.g., "parking", "balcony", "2 bedrooms")
         
-        Property: {prop['title']}
-        Location: {prop['location']}, {prop['city']}
-        Size: {prop['size_sqm']} sqm
-        Price: R{prop['price']:,.0f} per month
-        Features: {', '.join(prop.get('features', []))}
-        Description: {prop.get('description', 'No description available')}
+        Missing fields: {', '.join(missing)}
         
-        User's preferences: {persona.get('size_preference_sqm', 'No size preference')} sqm, {persona.get('must_have', 'No specific features')}
-        
-        Make it sound like a real estate agent talking to a client. Be enthusiastic but professional. Keep it under 100 words.
+        Return only a JSON object with the extracted values for the missing fields. If a field cannot be determined, use null.
         """
         
         try:
-            summary_response = llm.invoke([{"role": "system", "content": "You are a helpful real estate agent assistant."}, {"role": "user", "content": summary_prompt}])
-            summary = summary_response.content.strip()
-        except:
-            # Fallback if AI fails
-            summary = f"🏢 **Property {i}**: {prop['title']}\n📍 {prop['location']}, {prop['city']} • {prop['size_sqm']} sqm • R{prop['price']:,.0f}/month"
+            response = await llm.ainvoke([{"role": "user", "content": extraction_prompt}])
+            extracted_data = response.content
+            
+            import json
+            try:
+                extracted = json.loads(extracted_data)
+                # • Update the database and in‐memory state:
+                await update_user_persona(state["wa_id"], extracted)
+                persona.update(extracted)
+                state["persona"] = persona
+            except json.JSONDecodeError:
+                print(f"Failed to parse LLM response as JSON: {extracted_data}")
+        except Exception as e:
+            print(f"Error extracting persona data: {e}")
         
-        messages.append(summary)
-    
-    # Final message: Interactive follow-up
-    follow_up = "Which of these properties catches your eye? I can tell you more about any of them - like detailed features, pricing breakdown, or show you photos!"
-    messages.append(follow_up)
-    
-    return messages
+        # • If there are still missing fields after that:
+        still_missing = [f for f in missing if f not in persona]
+        if still_missing:
+            # Ask just one follow-up for the first missing field
+            state["response"] = f"What is your {still_missing[0].replace('_',' ')}?"
+            return state
+    # 3. No fields missing or all filled:
+    return {"response": None}
 
-async def handle_property_interest(user_message, persona):
-    """Handle when user shows interest in a specific property"""
-    user_message_lower = user_message.lower()
-    
-    # Try to identify which property they're interested in
-    # Look for property numbers, titles, or descriptions
-    property_indicators = ["property 1", "property 2", "property 3", "first", "second", "third", "1st", "2nd", "3rd"]
-    
-    property_interest = None
-    for indicator in property_indicators:
-        if indicator in user_message_lower:
-            property_interest = indicator
-            break
-    
-    # If we can't identify a specific property, ask for clarification
-    if not property_interest:
-        return "I'd love to tell you more! Which property are you interested in? You can say 'Property 1', 'the first one', or describe it briefly."
-    
-    # Ask what specific information they want
-    return f"Great choice! What would you like to know about {property_interest}? I can tell you about:\n\n📸 **Photos** - See the property\n💰 **Pricing** - Detailed cost breakdown\n🏗️ **Features** - All amenities and facilities\n📍 **Location** - Area details and accessibility\n📋 **Terms** - Lease conditions and requirements\n\nWhat interests you most?"
-
-async def handle_property_info_request(user_message, session_messages, persona):
-    """Handle when user requests specific property information"""
-    user_message_lower = user_message.lower()
-    
-    # Determine what type of information they want
-    info_types = {
-        "photos": ["photos", "images", "pictures", "see", "look", "photo", "image"],
-        "pricing": ["pricing", "price", "cost", "rent", "lease", "monthly", "payment", "money"],
-        "features": ["features", "amenities", "facilities", "what's included", "whats included", "equipment", "utilities"],
-        "location": ["location", "area", "neighborhood", "address", "where", "access", "transport"],
-        "terms": ["terms", "conditions", "lease", "contract", "requirements", "deposit", "duration"]
-    }
-    
-    requested_info = []
-    for info_type, keywords in info_types.items():
-        if any(keyword in user_message_lower for keyword in keywords):
-            requested_info.append(info_type)
-    
-    if not requested_info:
-        # If we can't determine what they want, ask for clarification
-        return "I'm not sure what specific information you'd like. Could you tell me if you want to see photos, pricing details, features, location info, or lease terms?"
-    
-    # Provide the requested information
-    response_parts = []
-    
-    for info_type in requested_info:
-        if info_type == "photos":
-            response_parts.append("📸 **Photos**: I'll send you the property photos right away! (Note: In a real implementation, this would send actual images)")
-        elif info_type == "pricing":
-            response_parts.append("💰 **Pricing**: The property is R25,000 per month, including basic utilities. There's a 2-month deposit required and the lease is for 12 months minimum.")
-        elif info_type == "features":
-            response_parts.append("🏗️ **Features**: This property includes 24/7 security, loading docks, office space, parking for 10 vehicles, and fiber internet ready.")
-        elif info_type == "location":
-            response_parts.append("��� **Location**: Located in the industrial district with easy access to major highways. Close to shipping ports and has excellent transport links.")
-        elif info_type == "terms":
-            response_parts.append("📋 **Terms**: 12-month minimum lease, 2-month security deposit, utilities included, available immediately.")
-    
-    response = "\n\n".join(response_parts)
-    response += "\n\nWould you like to know anything else about this property, or shall I show you other options?"
-    
-    return response
+# --- Build LangGraph ---
+graph = StateGraph(ChatState)
+graph.add_node("persona_update", RunnableLambda(extract_and_update_persona))
+graph.add_node("chat", RunnableLambda(chat_with_session_memory))
+graph.set_entry_point("persona_update")
+graph.add_edge("persona_update", "chat")
+graph.add_edge("chat", END)
+chat_graph = graph.compile()
 
-async def process_message(user_message: str, user_info: dict = None, session_id: str = None, wa_id: str = None, wamid: str = None):
-    """Process a message through the AI chat system with session memory and persona collection"""
+async def process_message(user_message: str, user_info: dict = None, session_id: str = None, wa_id: str = None, wamid: str = None, persona: dict = None):
+    """Process a message through the AI chat system with session memory"""
     if user_info is None:
         user_info = {}
     
-    # Always handle greetings first, before any property logic
-    if user_message.lower() in ["hi", "hello", "hey", "good morning", "good afternoon", "good evening", "morning", "afternoon", "evening"]:
-        return f"Hi {user_info.get('name', 'there')}! 👋\n\nI'm your property agent assistant. I can help you find industrial properties, warehouses, offices, and commercial spaces. What are you looking for today?"
-
-    # Get user persona
-    persona = await get_or_create_persona(wa_id) if wa_id else {}
-    
-    # Extract persona information from message
-    extracted_persona = await extract_persona_from_message(user_message, persona)
-    updated_persona = persona.copy()
-    for field, value in extracted_persona.items():
-        if value is not None:
-            updated_persona[field] = value
-    
-    # Get session messages
+    # Get session messages for context
     session_messages = []
     if session_id:
-        session_messages = await get_session_messages(session_id, limit=30)
+        session_messages = await get_session_messages(session_id, limit=10)
     
-    # Prepare state for LangGraph - let the AI handle everything
-    state = {
+    # Process with AI
+    result = await chat_graph.ainvoke({
         "user_message": user_message,
         "user_info": user_info,
         "session_id": session_id,
         "wa_id": wa_id,
         "wamid": wamid,
         "session_messages": session_messages,
-        "persona": updated_persona,
-        "current_property": None,
-        "property_details": {}
-    }
+        "persona": persona or {}
+    })
     
-    # Run LangGraph - the AI will handle property detection and responses naturally
-    result = await chat_graph.ainvoke(state)
+    # Save messages to database
+    if session_id and wa_id and wamid:
+        await save_message(session_id, wa_id, wamid, "user", user_message)
+        await save_message(session_id, wa_id, f"{wamid}_ai", "assistant", result["response"])
     
     return result["response"] 

api_routes.py

@@ -7,7 +7,6 @@ from datetime import datetime
 from config import VERIFY_TOKEN, supabase, OPENAI_API_KEY, WHATSAPP_API_TOKEN
 from database import get_user, list_users, update_user_name
 from ai_chat import process_message
-from persona_manager import get_user_persona, get_persona_summary, update_persona_field
 
 router = APIRouter()
 
@@ -85,36 +84,4 @@ async def update_user_endpoint(wa_id: str, name: str):
     if user:
         return user
     else:
-        raise HTTPException(status_code=404, detail="User not found")
-
-# --- Persona Management Endpoints ---
-@router.get("/personas/{wa_id}")
-async def get_persona_endpoint(wa_id: str):
-    """Get user persona by WhatsApp ID"""
-    if not supabase:
-        raise HTTPException(status_code=503, detail="Database not configured")
-    
-    persona = await get_user_persona(wa_id)
-    if persona:
-        return {
-            **persona,
-            "summary": get_persona_summary(persona)
-        }
-    else:
-        raise HTTPException(status_code=404, detail="Persona not found")
-
-@router.put("/personas/{wa_id}")
-async def update_persona_endpoint(wa_id: str, field: str, value: str):
-    """Update a specific persona field"""
-    if not supabase:
-        raise HTTPException(status_code=503, detail="Database not configured")
-    
-    success = await update_persona_field(wa_id, field, value)
-    if success:
-        persona = await get_user_persona(wa_id)
-        return {
-            **persona,
-            "summary": get_persona_summary(persona)
-        }
-    else:
-        raise HTTPException(status_code=404, detail="Persona not found") 
+        raise HTTPException(status_code=404, detail="User not found") 

database.py

@@ -181,78 +181,43 @@ async def update_user_name(wa_id: str, name: str):
         return response.data[0] if response.data else None
     except Exception as e:
         print(f"Error updating user: {e}")
-        return None 
-
-# --- Property Listings ---
-async def search_properties(
-    city: str = None,
-    min_size: int = None,
-    max_size: int = None,
-    min_price: float = None,
-    max_price: float = None,
-    features: list = None,
-    price_type: str = None,
-    limit: int = 10,
-    offset: int = 0
-) -> list:
-    """Search properties with flexible filters. Only returns active listings."""
-    if not supabase:
-        return []
-    try:
-        print(f"Database search - Starting query with city={city}")
-        query = supabase.table("properties").select("*").eq("is_active", True)
-        if city:
-            print(f"Adding city filter: {city}")
-            query = query.ilike("city", f"%{city}%")
-        if min_size:
-            query = query.gte("size_sqm", min_size)
-        if max_size:
-            query = query.lte("size_sqm", max_size)
-        if min_price:
-            query = query.gte("price", min_price)
-        if max_price:
-            query = query.lte("price", max_price)
-        if price_type:
-            query = query.eq("price_type", price_type)
-        if features:
-            for feature in features:
-                query = query.contains("features", [feature])
-        query = query.range(offset, offset + limit - 1)
-        query = query.order("is_featured", desc=True).order("updated_at", desc=True)
-        resp = query.execute()
-        print(f"Database search - Raw response: {resp.data}")
-        return resp.data if resp.data else []
-    except Exception as e:
-        print(f"Error searching properties: {e}")
-        return []
+        return None
 
-async def get_property_by_id(property_id: str) -> dict:
-    """Get a property by its ID."""
+# --- Persona Management ---
+async def get_user_persona(wa_id: str) -> dict:
+    """
+    Fetch the persona row for this user.
+    Returns an empty dict if no data exists.
+    """
     if not supabase:
-        return None
+        return {}
+    
     try:
-        resp = supabase.table("properties").select("*").eq("id", property_id).single().execute()
-        return resp.data if resp.data else None
+        resp = supabase\
+            .table("personas")\
+            .select("*")\
+            .eq("wa_id", wa_id)\
+            .single()\
+            .execute()
+        return resp.data or {}
     except Exception as e:
-        print(f"Error getting property by id: {e}")
-        return None
+        print(f"Error getting user persona: {e}")
+        return {}
 
-async def get_available_cities() -> list:
-    """Get a list of all cities with active properties."""
+async def update_user_persona(wa_id: str, updates: dict):
+    """
+    Apply partial updates to the persona row.
+    Automatically sets `updated_at` to now().
+    """
     if not supabase:
-        return []
+        return
+    
     try:
-        print("Getting available cities...")
-        resp = supabase.table("properties").select("city").eq("is_active", True).execute()
-        print(f"Available cities raw response: {resp.data}")
-        cities = set()
-        if resp.data:
-            for row in resp.data:
-                if row.get("city"):
-                    cities.add(row["city"].strip())
-        result = sorted(list(cities))
-        print(f"Available cities result: {result}")
-        return result
+        updates_with_ts = {**updates, "updated_at": datetime.utcnow().isoformat()}
+        supabase\
+            .table("personas")\
+            .update(updates_with_ts)\
+            .eq("wa_id", wa_id)\
+            .execute()
     except Exception as e:
-        print(f"Error getting available cities: {e}")
-        return [] 
+        print(f"Error updating user persona: {e}") 

main.py

@@ -3,7 +3,7 @@ from fastapi.responses import JSONResponse
 
 # Import our modular components
 from config import supabase
-from database import get_or_create_user, update_user_activity, get_or_create_active_session
+from database import get_or_create_user, update_user_activity, get_or_create_active_session, get_user_persona
 from whatsapp import send_whatsapp_message
 from ai_chat import process_message
 from api_routes import router
@@ -46,13 +46,17 @@ async def receive_message(req: Request):
             # Get or create active session
             session = await get_or_create_active_session(wa_id)
             
+            # Get user persona
+            persona = await get_user_persona(wa_id)
+            
             # Process with AI including session memory
             ai_response = await process_message(
                 user_message=user_message,
                 user_info=user_info,
                 session_id=session["id"],
                 wa_id=wa_id,
-                wamid=wamid
+                wamid=wamid,
+                persona=persona
             )
             
             # Send response back to WhatsApp

persona_manager.py

@@ -1,504 +0,0 @@
-from datetime import datetime
-from typing import Dict, List, Optional, Tuple
-from config import supabase, llm, OPENAI_API_KEY
-
-# Persona field definitions and their collection prompts
-PERSONA_FIELDS = {
-    "intent": {
-        "prompt": "Great! Are you looking to buy a place, or maybe lease for now?",
-        "clarification": "Great question! Buying gives you long-term control and equity, but requires a larger upfront investment. Leasing gives you flexibility and lower initial costs, but you don't build equity. Both have their benefits - what feels right for your situation?",
-        "skip_response": "No problem at all. We can always revisit that later."
-    },
-    "location_preference": {
-        "prompt": "Any specific areas you'd prefer to be based in?",
-        "clarification": "I can help you find properties in any area! Some popular industrial areas include downtown, suburbs, industrial districts, and warehouse zones. Each has different benefits - downtown for accessibility, suburbs for space, industrial areas for zoning. What kind of location works best for your business?",
-        "skip_response": "No problem at all. We can always revisit that later."
-    },
-    "size_preference_sqm": {
-        "prompt": "Do you have a rough size in mind? For example, 1500 or 3000 sqm?",
-        "clarification": "Property sizes can vary a lot! Small workshops might be 500-1000 sqm, medium warehouses 1500-3000 sqm, and large facilities 5000+ sqm. Think about your current space needs and future growth. What kind of operations will you be running?",
-        "skip_response": "No problem at all. We can always revisit that later."
-    },
-    "budget": {
-        "prompt": "Is there a budget you'd like me to work within?",
-        "clarification": "Budget helps me find the right properties for you! Industrial properties can range from $200k for small units to millions for large facilities. We can discuss options at any price point - what's comfortable for your business?",
-        "skip_response": "No problem at all. We can always revisit that later."
-    },
-    "must_have": {
-        "prompt": "Anything important that's a must-have? Like truck access or yard space?",
-        "clarification": "Must-haves are features you really need for your business! Common ones include loading docks, high ceilings, truck access, yard space, office areas, parking, or specific zoning. What features are essential for your operations?",
-        "skip_response": "No problem at all. We can always revisit that later."
-    }
-}
-
-async def get_user_persona(wa_id: str) -> Optional[Dict]:
-    """Get user persona from database"""
-    if not supabase:
-        return None
-    
-    try:
-        response = supabase.table("user_personas").select("*").eq("wa_id", wa_id).execute()
-        return response.data[0] if response.data else None
-    except Exception as e:
-        print(f"Error getting user persona: {e}")
-        return None
-
-async def create_user_persona(wa_id: str) -> Dict:
-    """Create a new user persona"""
-    if not supabase:
-        return {"wa_id": wa_id, "language": "English", "tone": "neutral"}
-    
-    try:
-        new_persona = {
-            "wa_id": wa_id,
-            "language": "English",
-            "tone": "neutral",
-            "created_at": datetime.utcnow().isoformat(),
-            "updated_at": datetime.utcnow().isoformat()
-        }
-        response = supabase.table("user_personas").insert(new_persona).execute()
-        return response.data[0] if response.data else new_persona
-    except Exception as e:
-        print(f"Error creating user persona: {e}")
-        return {"wa_id": wa_id, "language": "English", "tone": "neutral"}
-
-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:
-        update_data = {
-            field: value,
-            "updated_at": datetime.utcnow().isoformat()
-        }
-        print(f"Updating persona field {field} with value {value} for user {wa_id}")
-        print(f"Update data: {update_data}")
-        
-        # First check if the persona exists
-        check_response = supabase.table("user_personas").select("*").eq("wa_id", wa_id).execute()
-        print(f"Current persona data: {check_response.data}")
-        
-        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'}")
-        print(f"Response status: {response.status_code if hasattr(response, 'status_code') else 'No status'}")
-        
-        # Verify the update
-        verify_response = supabase.table("user_personas").select("*").eq("wa_id", wa_id).execute()
-        print(f"Updated persona data: {verify_response.data}")
-        
-        return True
-    except Exception as e:
-        print(f"Error updating persona field {field}: {e}")
-        return False
-
-async def get_or_create_persona(wa_id: str) -> Dict:
-    """Get existing persona or create new one"""
-    persona = await get_user_persona(wa_id)
-    if persona:
-        return persona
-    else:
-        return await create_user_persona(wa_id)
-
-def get_missing_fields(persona: Dict) -> List[str]:
-    """Get list of missing persona fields"""
-    missing = []
-    for field in PERSONA_FIELDS.keys():
-        if not persona.get(field):
-            missing.append(field)
-    return missing
-
-def get_next_field_to_ask(persona: Dict) -> Optional[str]:
-    """Get the next field to ask about"""
-    missing = get_missing_fields(persona)
-    return missing[0] if missing else None
-
-async def parse_user_response(user_message: str, field: str) -> Tuple[bool, any, str]:
-    """
-    Parse user response for a specific field
-    Returns: (is_valid, parsed_value, response_message)
-    """
-    if not OPENAI_API_KEY:
-        return False, None, "Sorry, I can't process that right now."
-    
-    try:
-        # Create a structured prompt for parsing
-        system_prompt = f"""You are a property agent assistant. Parse the user's response for the field '{field}'.
-        
-        Field: {field}
-        Field description: {PERSONA_FIELDS[field]['prompt']}
-        
-        Parse the user's response and return ONLY a JSON object with these fields:
-        - "is_valid": boolean (true if user provided a valid answer)
-        - "value": the parsed value (null if invalid/not provided)
-        - "response": string message to send back to user
-        - "is_clarification": boolean (true if user asked for clarification)
-        - "is_skip": boolean (true if user wants to skip this question)
-        
-        Rules:
-        - For intent: accept "buy", "lease", "rent", "purchase", "own"
-        - 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 = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_message}
-        ]
-        
-        response = llm.invoke(messages)
-        
-        # Try to parse the JSON response
-        import json
-        try:
-            result = json.loads(response.content)
-            return (
-                result.get("is_valid", False),
-                result.get("value"),
-                result.get("response", "I understand. Let me know if you need anything else.")
-            )
-        except json.JSONDecodeError:
-            # Fallback parsing
-            return await fallback_parse_response(user_message, field)
-            
-    except Exception as e:
-        print(f"Error parsing user response: {e}")
-        return False, None, "I didn't quite catch that. Could you rephrase?"
-
-async def fallback_parse_response(user_message: str, field: str) -> Tuple[bool, any, str]:
-    """Fallback parsing when LLM parsing fails"""
-    user_message_lower = user_message.lower()
-    
-    # Check for clarification requests - more comprehensive
-    clarification_words = [
-        "what", "how", "explain", "difference", "mean", "clarify", "tell me",
-        "what do you mean", "what does", "how does", "can you explain",
-        "i don't understand", "not sure what", "what's the difference"
-    ]
-    
-    # Check for questions about the field specifically
-    field_specific_clarifications = {
-        "intent": ["buy", "lease", "purchase", "rent", "owning", "owning vs leasing"],
-        "size_preference_sqm": ["size", "sqm", "square meters", "how big", "dimensions"],
-        "budget": ["budget", "cost", "price", "how much", "expensive"],
-        "location_preference": ["location", "area", "where", "place"],
-        "must_have": ["must have", "features", "requirements", "need", "essential"]
-    }
-    
-    # Check for general clarification requests
-    if any(word in user_message_lower for word in clarification_words):
-        return False, None, PERSONA_FIELDS[field]["clarification"]
-    
-    # Check for field-specific clarification requests
-    if field in field_specific_clarifications:
-        field_words = field_specific_clarifications[field]
-        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.", False, False
-    
-    # Check for skip requests
-    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"], False, True
-    
-    # Basic field-specific parsing
-    if field == "intent":
-        if any(word in user_message_lower for word in ["buy", "purchase", "own"]):
-            return True, "buy", "Got it, you're looking to buy. That's great!", False, False
-        elif any(word in user_message_lower for word in ["lease", "rent"]):
-            return True, "lease", "Perfect, leasing gives you flexibility.", False, False
-    
-    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:,}.", False, False
-        
-        # Fallback: just look for numbers
-        numbers = re.findall(r'\d+', user_message)
-        if numbers:
-            budget = max(int(n) for n in numbers)
-            if "k" in user_message_lower or "thousand" in user_message_lower:
-                budget *= 1000
-            elif "m" in user_message_lower or "million" in user_message_lower:
-                budget *= 1000000
-            return True, budget, f"Thanks! I'll look for properties around ${budget:,}.", False, False
-    
-    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.", False, False
-        
-        # Check for context-based size suggestions
-        if any(word in user_message_lower for word in ["manufacturing", "factory", "plant", "production"]):
-            if "large" in user_message_lower or "big" in user_message_lower:
-                return True, 5000, "Perfect! For a large manufacturing plant, I'd recommend around 5000 sqm. This gives you plenty of space for production lines, storage, and office areas.", False, False
-            else:
-                return True, 3000, "Great! For a manufacturing plant, I'd suggest around 3000 sqm. This should accommodate your production needs well.", False, False
-        
-        # Fallback: just look for numbers
-        numbers = re.findall(r'\d+', user_message)
-        if numbers:
-            size = max(int(n) for n in numbers)
-            return True, size, f"Perfect! {size} sqm should give you good options.", False, False
-    
-    elif field == "location_preference":
-        # Extract location names (basic approach)
-        locations = ["downtown", "suburb", "industrial", "warehouse district"]
-        found_location = None
-        for loc in locations:
-            if loc in user_message_lower:
-                found_location = loc
-                break
-        
-        if found_location:
-            return True, found_location, f"Great! {found_location.title()} has good options.", False, False
-        else:
-            # Assume the whole message is a location
-            return True, user_message.strip(), f"Got it! I'll look in {user_message.strip()}.", False, False
-    
-    elif field == "must_have":
-        features = []
-        feature_keywords = {
-            "truck": ["truck", "loading", "dock"],
-            "yard": ["yard", "space", "outdoor"],
-            "office": ["office", "admin"],
-            "parking": ["parking", "car"],
-            "high_ceiling": ["ceiling", "height", "tall"]
-        }
-        
-        for feature, keywords in feature_keywords.items():
-            if any(keyword in user_message_lower for keyword in keywords):
-                features.append(feature)
-        
-        if features:
-            return True, features, f"Perfect! I'll make sure to find places with {', '.join(features)}.", False, False
-    
-    return False, None, "I didn't quite understand. Could you try again?", False, False
-
-async def should_ask_persona_question(persona: Dict, conversation_context: str = "") -> Tuple[bool, Optional[str]]:
-    """
-    Determine if we should ask a persona question using AI
-    Returns: (should_ask, field_to_ask)
-    """
-    # Check if persona is complete
-    missing_fields = get_missing_fields(persona)
-    
-    if not missing_fields:
-        return False, None
-    
-    if not OPENAI_API_KEY:
-        # Fallback to basic keyword detection
-        conversation_lower = conversation_context.lower()
-        
-        # Check for greetings
-        casual_indicators = ["hi", "hello", "hey", "thanks", "thank you", "bye", "goodbye"]
-        is_casual = any(indicator in conversation_lower for indicator in casual_indicators)
-        
-        if is_casual:
-            return False, None
-        
-        # Check for property-related keywords
-        search_indicators = ["property", "warehouse", "industrial", "space", "building", "looking for", "need", "find"]
-        is_searching = any(indicator in conversation_lower for indicator in search_indicators)
-        
-        if is_searching:
-            return True, missing_fields[0]
-        
-        return False, None
-    
-    try:
-        # Use AI to determine if we should ask persona questions
-        system_prompt = f"""You are a property agent assistant. Determine if the user is showing interest in finding a property and needs persona questions asked.
-
-Current conversation context: "{conversation_context}"
-
-Available persona fields to ask about: {missing_fields}
-
-Rules:
-- If the user is just greeting (hi, hello, etc.) → return "no"
-- If the user is asking about properties, locations, business needs, or showing interest in finding space → return "yes"
-- If the user mentions locations (including abbreviations like cpt, pta, jhb) → return "yes"
-- If the user mentions business types (clothing, manufacturing, etc.) → return "yes"
-- If the user has already provided context about their needs (like "big enough for manufacturing plant") → return "no" (they've given enough context)
-- If the user is frustrated or asking you to stop asking questions → return "no"
-
-Return ONLY "yes" or "no"."""
-
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": conversation_context}
-        ]
-        
-        response = llm.invoke(messages)
-        should_ask = response.content.strip().lower() == "yes"
-        
-        if should_ask:
-            return True, missing_fields[0]
-        else:
-            return False, None
-            
-    except Exception as e:
-        print(f"Error in AI persona question detection: {e}")
-        return False, None
-
-def get_persona_summary(persona: Dict) -> str:
-    """Get a human-readable summary of the user's persona"""
-    summary_parts = []
-    
-    if persona.get("intent"):
-        summary_parts.append(f"Looking to {persona['intent']}")
-    
-    if persona.get("location_preference"):
-        summary_parts.append(f"in {persona['location_preference']}")
-    
-    if persona.get("size_preference_sqm"):
-        summary_parts.append(f"around {persona['size_preference_sqm']} sqm")
-    
-    if persona.get("budget"):
-        summary_parts.append(f"budget ~${persona['budget']:,}")
-    
-    if persona.get("must_have"):
-        summary_parts.append(f"must have: {', '.join(persona['must_have'])}")
-    
-    if summary_parts:
-        return " | ".join(summary_parts)
-    else:
-        return "New user - profile incomplete" 
-
-async def extract_persona_from_message(user_message: str, current_persona: Dict) -> Dict:
-    """
-    Proactively extract persona fields from any user message using AI
-    Returns: dict of field -> value for any fields that can be extracted
-    """
-    if not OPENAI_API_KEY:
-        return {}
-    
-    try:
-        print(f"Starting AI extraction for message: '{user_message}'")
-        # Create a comprehensive prompt for AI extraction
-        system_prompt = """You are a property agent assistant. Extract any persona information from the user's message.
-
-Available persona fields:
-- intent: "buy" or "lease" (extract from words like buy, purchase, own, lease, rent)
-- location_preference: Extract location names, ALWAYS use full names (e.g., "cpt" = "cape town", "jhb" = "johannesburg", "pta" = "pretoria")
-- budget: Extract numeric values with currency/budget indicators (e.g., "500k" = 500000, "$1m" = 1000000)
-- size_preference_sqm: Extract size in square meters (convert from sq ft if needed)
-- must_have: Extract features as array (e.g., ["truck access", "office space"])
-- language: Extract language preference (e.g., "afrikaans", "english", "afrikaans praat", "speak afrikaans")
-
-IMPORTANT: You MUST return a valid JSON object. If no information is found, return {} (empty object).
-For location_preference, be very generous in extraction and ALWAYS use full city names, not abbreviations.
-For language, extract if user mentions language preference (e.g., "praat afrikaans", "speak english", etc.)
-
-Examples:
-- "I want a property in cpt" → {"location_preference": "cape town"}
-- "Looking for warehouse in pta around 500k" → {"location_preference": "pretoria", "budget": 500000}
-- "Looking for a property in pretoria for my clothing business" → {"location_preference": "pretoria"}
-- "Need space for clothing business with office" → {"must_have": ["office"]}
-- "I want one big enough for a phara manufacturing plant" → {"size_preference_sqm": 5000, "must_have": ["manufacturing"]}
-- "Praat van nou af net afrikaans met my" → {"language": "afrikaans"}
-- "Speak English from now on" → {"language": "english"}
-
-Return ONLY the JSON object, no other text."""
-
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_message}
-        ]
-        
-        print(f"Calling LLM with messages: {messages}")
-        response = llm.invoke(messages)
-        print(f"LLM response received: {type(response)}")
-        
-        print(f"AI extraction response: {response.content}")  # Debug
-        print(f"User message being extracted: {user_message}")  # Debug
-        
-        # Parse the JSON response
-        import json
-        try:
-            extracted = json.loads(response.content)
-            print(f"Parsed extraction: {extracted}")  # Debug
-            
-            # Validate and clean the extracted data
-            cleaned_extracted = {}
-            
-            # Include fields that can be extracted, even if they're already set (allow updates)
-            for field, value in extracted.items():
-                if field in PERSONA_FIELDS and value is not None:
-                    cleaned_extracted[field] = value
-            
-            print(f"Cleaned extraction: {cleaned_extracted}")  # Debug
-            return cleaned_extracted
-            
-        except json.JSONDecodeError:
-            print(f"Failed to parse AI extraction response: {response.content}")
-            print(f"Response type: {type(response.content)}")
-            print(f"Response length: {len(response.content)}")
-            # Try to clean the response
-            cleaned_response = response.content.strip()
-            if cleaned_response.startswith('```json'):
-                cleaned_response = cleaned_response[7:]
-            if cleaned_response.endswith('```'):
-                cleaned_response = cleaned_response[:-3]
-            cleaned_response = cleaned_response.strip()
-            try:
-                extracted = json.loads(cleaned_response)
-                print(f"Successfully parsed after cleaning: {extracted}")
-                return extracted
-            except:
-                print(f"Still failed after cleaning: {cleaned_response}")
-                return {}
-            
-    except Exception as e:
-        print(f"Error in AI persona extraction: {e}")
-        return {} 

supabase_setup.sql

@@ -26,14 +26,14 @@ CREATE TABLE IF NOT EXISTS messages (
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
 );
 
--- Create user_personas table
-CREATE TABLE IF NOT EXISTS user_personas (
+-- Create personas table for user preferences and context
+CREATE TABLE IF NOT EXISTS personas (
     wa_id TEXT PRIMARY KEY REFERENCES users(wa_id) ON DELETE CASCADE,
-    language TEXT DEFAULT 'English',
-    tone TEXT DEFAULT 'neutral',
+    language TEXT,
+    tone TEXT,
     intent TEXT,
-    budget NUMERIC,
-    size_preference_sqm INTEGER,
+    budget TEXT,
+    size_preference_sqm TEXT,
     location_preference TEXT,
     must_have TEXT[],
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
@@ -50,14 +50,14 @@ CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id);
 CREATE INDEX IF NOT EXISTS idx_messages_wa_id ON messages(wa_id);
 CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_messages_wamid ON messages(wamid);
-CREATE INDEX IF NOT EXISTS idx_user_personas_intent ON user_personas(intent);
-CREATE INDEX IF NOT EXISTS idx_user_personas_location ON user_personas(location_preference);
+CREATE INDEX IF NOT EXISTS idx_personas_wa_id ON personas(wa_id);
+CREATE INDEX IF NOT EXISTS idx_personas_updated_at ON personas(updated_at DESC);
 
 -- Enable Row Level Security (RLS) - optional but recommended
 ALTER TABLE users ENABLE ROW LEVEL SECURITY;
 ALTER TABLE chat_sessions ENABLE ROW LEVEL SECURITY;
 ALTER TABLE messages ENABLE ROW LEVEL SECURITY;
-ALTER TABLE user_personas ENABLE ROW LEVEL SECURITY;
+ALTER TABLE personas ENABLE ROW LEVEL SECURITY;
 
 -- Create policies to allow all operations (you can restrict this based on your needs)
 CREATE POLICY "Allow all operations on users" ON users
@@ -69,7 +69,7 @@ CREATE POLICY "Allow all operations on chat_sessions" ON chat_sessions
 CREATE POLICY "Allow all operations on messages" ON messages
     FOR ALL USING (true);
 
-CREATE POLICY "Allow all operations on user_personas" ON user_personas
+CREATE POLICY "Allow all operations on personas" ON personas
     FOR ALL USING (true);
 
 -- Optional: Create a function to automatically update the updated_at timestamp
@@ -101,8 +101,8 @@ CREATE TRIGGER update_chat_sessions_last_activity
     FOR EACH ROW 
     EXECUTE FUNCTION update_last_activity_column();
 
--- Create trigger to automatically update updated_at for user_personas
-CREATE TRIGGER update_user_personas_updated_at 
-    BEFORE UPDATE ON user_personas 
+-- Create trigger to automatically update updated_at for personas
+CREATE TRIGGER update_personas_updated_at 
+    BEFORE UPDATE ON personas 
     FOR EACH ROW 
     EXECUTE FUNCTION update_updated_at_column(); 

whatsapp.py

@@ -3,23 +3,6 @@ from config import PHONE_NUMBER_ID, WHATSAPP_API_TOKEN
 
 async def send_whatsapp_message(wa_id: str, message: str):
     """Send a message via WhatsApp Business API"""
-    # Split message if it's too long (WhatsApp limit is ~4096 characters)
-    max_length = 3000  # Leave some buffer
-    
-    if len(message) <= max_length:
-        # Single message
-        return await _send_single_message(wa_id, message)
-    else:
-        # Split into multiple messages
-        messages = _split_message(message, max_length)
-        success = True
-        for msg in messages:
-            if not await _send_single_message(wa_id, msg):
-                success = False
-        return success
-
-async def _send_single_message(wa_id: str, message: str):
-    """Send a single message via WhatsApp Business API"""
     url = f"https://graph.facebook.com/v18.0/{PHONE_NUMBER_ID}/messages"
     headers = {
         "Authorization": f"Bearer {WHATSAPP_API_TOKEN}",
@@ -32,37 +15,9 @@ async def _send_single_message(wa_id: str, message: str):
         "text": {"body": message}
     }
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(url, headers=headers, json=payload)
+        resp = await httpx.post(url, headers=headers, json=payload)
         print(f"Sent message → {resp.status_code}: {resp.text}")
         return resp.status_code == 200
     except Exception as e:
         print(f"Failed to send message: {e}")
-        return False
-
-def _split_message(message: str, max_length: int):
-    """Split a long message into smaller chunks"""
-    if len(message) <= max_length:
-        return [message]
-    
-    # Split by double newlines first (to preserve property separations)
-    parts = message.split('\n\n')
-    messages = []
-    current_message = ""
-    
-    for part in parts:
-        # If adding this part would exceed limit, start a new message
-        if len(current_message) + len(part) + 2 > max_length and current_message:
-            messages.append(current_message.strip())
-            current_message = part
-        else:
-            if current_message:
-                current_message += '\n\n' + part
-            else:
-                current_message = part
-    
-    # Add the last message
-    if current_message:
-        messages.append(current_message.strip())
-    
-    return messages 
+        return False