persona simplified

ai_chat.py

@@ -19,16 +19,13 @@ def chat_with_session_memory(state):
         session_messages = state.get("session_messages", [])
     
     # Add system message with user context
-    system_message = "You are a helpful and concise property agent."
+    system_message = f"Hello {user_info.get('name','there')}! 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']}."
     
     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]'}. "
+        f" The user prefers {p.get('language','[unspecified]')} and wants a {p.get('tone','neutral')} tone."
     )
     
     # Build messages array with history
@@ -72,58 +69,47 @@ class ChatState(TypedDict):
     persona: dict
 
 async def extract_and_update_persona(state):
+    # a. Define which persona fields to track
+    persona_fields = ["language", "tone"]
+    user_message = state["user_message"]
+    wa_id = state["wa_id"]
     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)
-    ]
-    # 2. If any fields are missing:
+
+    # b. Build a one-shot extraction prompt
+    extraction_prompt = f"""
+    Extract and normalize the user's language and tone preferences from this message:
+    {user_message}
+
+    Normalize any shorthand or typos before deciding language and tone.
+    Return only a JSON object with keys "language" and "tone", and use null for unknown.
+    """
+
+    # c. Call the LLM
+    response = await llm.ainvoke([{"role":"user","content":extraction_prompt}])
+    import json
+    extracted = {}
+    try:
+        extracted = json.loads(response.content)
+    except:
+        print("Failed to parse persona JSON:", response.content)
+
+    # d. Update DB and in-memory state for any changed values
+    for field in persona_fields:
+        new_val = extracted.get(field)
+        old_val = persona.get(field)
+        if new_val is not None and new_val != old_val:
+            await update_user_persona(wa_id, {field: new_val})
+            persona[field] = new_val
+
+    state["persona"] = persona
+
+    # e. If any field still unset, ask a gentle follow-up
+    missing = [f for f in persona_fields if state["persona"].get(f) is None]
     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"]}
-        
-        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")
-        
-        Missing fields: {', '.join(missing)}
-        
-        Return only a JSON object with the extracted values for the missing fields. If a field cannot be determined, use null.
-        """
-        
-        try:
-            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}")
-        
-        # • 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:
+        state["response"] = f"Hi there! What is your {missing[0]} preference?"
+        return state
+
+    # f. All persona fields present—proceed to chat
     return {"response": None}
 
 # --- Build LangGraph ---

database.py

@@ -220,4 +220,51 @@ async def update_user_persona(wa_id: str, updates: dict):
             .eq("wa_id", wa_id)\
             .execute()
     except Exception as e:
-        print(f"Error updating user persona: {e}") 
+        print(f"Error updating user persona: {e}")
+
+# --- Intent Management ---
+async def get_or_create_user_intent(session_id: str, wa_id: str) -> dict:
+    """
+    Fetches the intent row for this session. 
+    If none exists, inserts a new empty intent record and returns it.
+    """
+    if not supabase or session_id == "local_session":
+        return {"session_id": session_id, "wa_id": wa_id, "created_at": datetime.utcnow().isoformat(), "updated_at": datetime.utcnow().isoformat()}
+    
+    try:
+        resp = supabase\
+            .table("user_intents")\
+            .select("*")\
+            .eq("session_id", session_id)\
+            .single()\
+            .execute()
+        if resp.data:
+            return resp.data
+        new_intent = {
+            "session_id": session_id,
+            "wa_id":      wa_id,
+            "created_at": datetime.utcnow().isoformat(),
+            "updated_at": datetime.utcnow().isoformat()
+        }
+        insert = supabase.table("user_intents").insert(new_intent).execute()
+        return insert.data[0] if insert.data else new_intent
+    except Exception as e:
+        print(f"Error in get_or_create_user_intent: {e}")
+        return {"session_id": session_id, "wa_id": wa_id, "created_at": datetime.utcnow().isoformat(), "updated_at": datetime.utcnow().isoformat()}
+
+async def update_user_intent(session_id: str, updates: dict):
+    """
+    Patches only the fields in the intent row that have changed.
+    """
+    if not supabase or session_id == "local_session":
+        return
+    
+    try:
+        updates_with_ts = {**updates, "updated_at": datetime.utcnow().isoformat()}
+        supabase\
+            .table("user_intents")\
+            .update(updates_with_ts)\
+            .eq("session_id", session_id)\
+            .execute()
+    except Exception as e:
+        print(f"Error updating user intent: {e}")