Enhance AI chat functionality with image request handling and intent classification updates

- Added direct handling for image requests in the chat function, providing immediate responses for users requesting images.
- Updated the intent classification logic to include detailed context analysis for image requests, improving accuracy in identifying user needs.
- Enhanced the end chat detection mechanism using AI to better understand user intent for ending conversations.
- Refactored the image request handling to streamline the process and improve user experience when multiple properties are discussed.
- Introduced additional debug logging for better traceability of user interactions and AI responses.

ai_chat.py

@@ -21,8 +21,22 @@ def chat_with_session_memory(state):
     # Get properties from state
     props = state.get("properties", [])
     search_status = state.get("search_status_message", "")
+    classification = state.get("classification", "")
     
-
+    # Check if this is an image request and handle it directly
+    if classification.startswith("request_images"):
+        print("DEBUG - Image request detected in chat function")
+        # This will be handled by the async wrapper that calls handle_image_request
+        # For now, just return a placeholder response
+        return {
+            "response": "I'll get those images for you right away!",
+            "user_message": user_message,
+            "ai_response": "I'll get those images for you right away!",
+            "session_id": session_id,
+            "wa_id": wa_id,
+            "wamid": wamid,
+            "classification": classification
+        }
     
     # Add system message with user context
     system_message = (
@@ -331,16 +345,51 @@ async def classify_user_intent(state):
     """
     print("DEBUG - Starting classify_user_intent")
     user_message = state["user_message"]
+    
+    # Get available properties for context
+    props = state.get("properties", [])
+    prop_titles = [p.get("title", "").lower() for p in props]
+    
+    # Get recent conversation context
+    session_messages = state.get("session_messages", [])
+    recent_context = ""
+    if session_messages:
+        recent_messages = session_messages[-5:]  # Last 5 messages
+        recent_context = "\n".join([f"{msg.get('role')}: {msg.get('content', '')}" for msg in recent_messages])
+    
     prompt = f"""
 Classify the user's message into exactly one of:
 - search_listings  (user wants to see property listings)
 - request_images   (user wants to see images/photos/pictures of a listing)
 - request_address  (user wants the address/location of a listing)
 - request_details  (user wants specific property info like price, features, floorplan, video, size, etc.)
-- other             (anything else)
+- other             (anything else, including greetings, goodbyes, general conversation, end of conversation)
+
+If the user is asking for images and mentions a specific property, extract the property identifier and return: request_images:IDENTIFIER
+
+Available properties for context: {prop_titles}
+
+Recent conversation context:
+{recent_context}
 
-If the user is asking for images and mentions a specific property (like "option 1", "the office", "warehouse", etc.), 
-extract the property identifier and return: request_images:IDENTIFIER
+Property identifier extraction rules:
+1. If user says "option X" or "option X images" → request_images:option X
+2. If user mentions a property type (warehouse, office, space) and it matches a property title → request_images:PROPERTY_TYPE
+3. If user says "this property", "that property", "the property" → request_images:this
+4. If user says "show me images" without specific reference → request_images
+5. If user mentions specific location/area that matches a property → request_images:LOCATION
+6. If user asks for images in context where only one property is being discussed → request_images:this
+7. If user uses pronouns like "it", "this", "that" when asking for images → request_images:this
+
+Context analysis:
+- If the user has been discussing a specific property and now asks for images, classify as request_images:this
+- If there's only one property available and user asks for images, classify as request_images:this
+- If user asks for images after a property search, assume they want images of the most relevant property
+
+End of conversation indicators (classify as "other"):
+- Goodbyes: "bye", "goodbye", "see you", "take care"
+- Completion: "I'm all good", "that's all", "no thanks", "I'm done"
+- General conversation: greetings, casual chat, non-property related topics
 
 Examples:
 - "How much is this warehouse?" → request_details
@@ -348,10 +397,19 @@ Examples:
 - "What are the features?" → request_details
 - "How big is it?" → request_details
 - "Show me images" → request_images
+- "Show me images of option 1" → request_images:option 1
+- "I want to see the warehouse images" → request_images:warehouse
+- "Show me pictures of this property" → request_images:this
+- "Can I see images of it?" → request_images:this
+- "Show me the images" → request_images:this
 - "What do you have in JHB?" → search_listings
 - "Do you have any properties for sale?" → search_listings
 - "Any properties available?" → search_listings
 - "Show me properties" → search_listings
+- "I'm all good" → other
+- "Goodbye" → other
+- "Thanks for your help" → other
+- "That's all I need" → other
 
 Return only the tag (and identifier if applicable).
 Message: {user_message}
@@ -432,20 +490,57 @@ async def extract_and_search_properties(state):
 
 async def detect_end_chat(state):
     """
-    Detect if the user wants to end the chat session.
+    Detect if the user wants to end the chat session using AI.
     """
-    user_message = state["user_message"].lower()
+    user_message = state["user_message"]
     session_id = state["session_id"]
     
-    if any(phrase in user_message for phrase in ["thank you", "thanks", "bye", "goodbye", "end chat"]):
-        await end_session(session_id)
-        return {"response": "Thanks for chatting! I've ended this session. Goodbye!"}
+    # Use AI to detect if user wants to end the conversation
+    prompt = f"""
+Analyze this user message and determine if they want to end the conversation or are saying goodbye.
+
+User message: "{user_message}"
+
+Consider these scenarios as "end conversation":
+- User is satisfied and ending the conversation (e.g., "I'm all good", "that's all", "no thanks")
+- User is saying goodbye (e.g., "bye", "goodbye", "see you", "take care")
+- User is declining further assistance (e.g., "not interested", "maybe later", "I'll think about it")
+- User is indicating they're done (e.g., "I'm done", "that's it", "nothing else")
+- User is politely ending the conversation (e.g., "thanks for your help", "appreciate it")
+
+Consider these scenarios as "continue conversation":
+- User is asking questions about properties
+- User is providing feedback but wants to continue
+- User is making small talk but not ending
+- User is asking for more information
+
+Respond with ONLY:
+- "end" if the user wants to end the conversation
+- "continue" if the user wants to continue the conversation
+
+Response:"""
     
-    return {"response": None}
+    try:
+        response = await llm.ainvoke([{"role": "user", "content": prompt}])
+        result = response.content.strip().lower()
+        
+        print(f"DEBUG - End chat AI detection: '{result}' for message: '{user_message}'")
+        
+        if result == "end":
+            await end_session(session_id)
+            return {"response": "Thanks for chatting! I've ended this session. Goodbye!"}
+        
+        return {"response": None}
+        
+    except Exception as e:
+        print(f"DEBUG - Error in end chat detection: {e}")
+        # Fallback to continue conversation if AI fails
+        return {"response": None}
 
 # --- Build LangGraph ---
 graph = StateGraph(ChatState)
 graph.add_node("persona_update", RunnableLambda(extract_and_update_persona))
+graph.add_node("exit_check_early", RunnableLambda(detect_end_chat))
 graph.add_node("classify_intent", RunnableLambda(classify_user_intent))
 graph.add_node("intent_update", RunnableLambda(extract_and_update_intent))
 graph.add_node("property_search", RunnableLambda(extract_and_search_properties))
@@ -460,7 +555,11 @@ def should_continue(state):
     print(f"DEBUG - should_continue: response={state.get('response')}, has_response={has_response}, should_continue={not has_response}")
     return not has_response
 
-graph.add_edge("persona_update", "classify_intent")
+graph.add_edge("persona_update", "exit_check_early")
+graph.add_conditional_edges("exit_check_early", should_continue, {
+    True: "classify_intent",
+    False: END
+})
 graph.add_edge("classify_intent", "intent_update")
 graph.add_conditional_edges("intent_update", should_continue, {
     True: "property_search",
@@ -500,6 +599,36 @@ async def process_message(user_message: str, user_info: dict = None, session_id:
         "properties": properties or []
     })
     
+    # Check if this is an image request and handle it
+    classification = result.get("classification", "")
+    if classification.startswith("request_images"):
+        print("DEBUG - Processing image request in process_message")
+        # Create state for image request handling
+        image_state = {
+            "user_message": user_message,
+            "properties": result.get("properties", []),
+            "classification": classification,
+            "session_messages": session_messages
+        }
+        
+        # Handle image request
+        image_messages = await handle_image_request(image_state)
+        
+        if image_messages:
+            # Save the first text message to database
+            if session_id and wa_id and wamid:
+                await save_message(session_id, wa_id, wamid, "user", user_message)
+                # Save the first text response
+                if isinstance(image_messages[0], str):
+                    await save_message(session_id, wa_id, f"{wamid}_ai", "assistant", image_messages[0])
+            
+            return {
+                "response": image_messages[0] if isinstance(image_messages[0], str) else "Here are the images you requested!",
+                "properties": result.get("properties", []),
+                "classification": classification,
+                "image_messages": image_messages  # Additional field for image handling
+            }
+    
     # Save messages to database
     if session_id and wa_id and wamid:
         await save_message(session_id, wa_id, wamid, "user", user_message)
@@ -609,6 +738,58 @@ async def handle_image_request(state):
     if selected_property_context:
         selected_property = selected_property_context
     
+    # Enhanced context analysis for "this", "that", pronouns, etc.
+    if not selected_property:
+        # Check if user is using pronouns or demonstratives
+        user_message_lower = state["user_message"].lower()
+        is_pronoun_reference = any(word in user_message_lower for word in ["this", "that", "it", "the property", "the listing"])
+        
+        if is_pronoun_reference:
+            print("DEBUG - User using pronoun/demonstrative reference, analyzing recent context")
+            
+            # Look for the most recently discussed property in the conversation
+            recent_messages = session_messages[-10:]  # Last 10 messages
+            property_mentions = {}
+            
+            for msg in recent_messages:
+                content = msg.get("content", "").lower()
+                for i, prop in enumerate(props):
+                    title = prop.get("title", "").lower()
+                    location = prop.get("location", "").lower()
+                    city = prop.get("city", "").lower()
+                    
+                    # Check for property mentions with higher weight for recent messages
+                    score = 0
+                    title_words = title.split()
+                    
+                    # Check if property title words are mentioned
+                    for word in title_words[:3]:  # First 3 words of title
+                        if word in content:
+                            score += 2
+                    
+                    # Check if location is mentioned
+                    if location in content:
+                        score += 1
+                    
+                    # Check if city is mentioned
+                    if city in content:
+                        score += 1
+                    
+                    # Give higher weight to more recent messages
+                    message_index = recent_messages.index(msg)
+                    recency_weight = 10 - message_index  # More recent = higher weight
+                    score *= recency_weight
+                    
+                    if score > 0:
+                        property_mentions[i] = property_mentions.get(i, 0) + score
+                        print(f"DEBUG - Found mention of property {i} (score {score}): {title}")
+            
+            # Use most mentioned property from recent conversation
+            if property_mentions:
+                most_mentioned = max(property_mentions.items(), key=lambda x: x[1])
+                selected_property = props[most_mentioned[0]]
+                print(f"DEBUG - Selected property from pronoun context: {selected_property.get('title')}")
+    
     # Fallback: Use conversation context to find which property user was discussing
     if not selected_property and len(props) > 1:
         # Check conversation history for property context
@@ -639,13 +820,36 @@ async def handle_image_request(state):
             selected_property = props[most_mentioned[0]]
             print(f"DEBUG - Selected property from conversation context: {selected_property.get('title')}")
         else:
-            # Multiple properties available - ask user to specify
-            prop_options = []
-            for i, prop in enumerate(props[:3], 1):  # Show first 3 options
-                prop_options.append(f"Option {i}: {prop.get('title')}")
-            
-            options_text = "\n".join(prop_options)
-            return [f"I have multiple properties available. Which one would you like to see images of?\n\n{options_text}\n\nPlease let me know which option you'd like images for."]
+            # Check if user is asking for images in a general way (like "show me images")
+            # and there's only one property or clear context from recent messages
+            if len(props) == 1:
+                # Only one property available - use it
+                selected_property = props[0]
+                print(f"DEBUG - Only one property available, using: {selected_property.get('title')}")
+            else:
+                # Look for any recent property discussion in the last few messages
+                very_recent_messages = session_messages[-5:]  # Last 5 messages
+                for msg in very_recent_messages:
+                    if msg.get("role") == "assistant":
+                        content = msg.get("content", "").lower()
+                        # Check if any property was mentioned in the last AI response
+                        for i, prop in enumerate(props):
+                            title = prop.get("title", "").lower()
+                            if any(word in content for word in title.split()[:3]):  # Check first 3 words of title
+                                selected_property = prop
+                                print(f"DEBUG - Found recent mention of property: {prop.get('title')}")
+                                break
+                        if selected_property:
+                            break
+                
+                # If still no property selected, only then ask user to specify
+                if not selected_property:
+                    prop_options = []
+                    for i, prop in enumerate(props[:3], 1):  # Show first 3 options
+                        prop_options.append(f"Option {i}: {prop.get('title')}")
+                    
+                    options_text = "\n".join(prop_options)
+                    return [f"I have multiple properties available. Which one would you like to see images of?\n\n{options_text}\n\nPlease let me know which option you'd like images for."]
     
     # Final fallback: use first property if only one or no context found
     if not selected_property:

main.py

@@ -5,7 +5,7 @@ from fastapi.responses import JSONResponse
 from config import supabase
 from database import get_or_create_user, update_user_activity, get_or_create_active_session, get_user_persona, get_or_create_user_intent
 from whatsapp import send_whatsapp_message, send_multiple_messages
-from ai_chat import process_message, handle_image_request
+from ai_chat import process_message
 from api_routes import router
 
 # --- FastAPI App Setup ---
@@ -65,23 +65,11 @@ async def receive_message(req: Request):
             
             ai_response = ai_result["response"]
             properties = ai_result.get("properties", [])
-            
-            # Check if this is an image request
-            state = {
-                "user_message": user_message,
-                "properties": properties
-            }
+            image_messages = ai_result.get("image_messages")
             
             # Check if this is an image request
             classification = ai_result.get("classification", "")
             print(f"DEBUG - main.py classification: '{classification}'")
-            image_messages = None
-            
-            if classification.startswith("request_images") or "image" in user_message.lower() or "photo" in user_message.lower():
-                print(f"DEBUG - Calling handle_image_request with classification: '{classification}'")
-                # Ensure classification is passed to handle_image_request
-                state["classification"] = classification
-                image_messages = await handle_image_request(state)
             
             if image_messages:
                 # Send images