fyp

app/ai/agent/nodes/listing_collect.py

@@ -1,6 +1,6 @@
 # app/ai/agent/nodes/listing_collect.py
 """
-Dynamic, context-aware listing collection with smart intent switching
+Dynamic listing collection with proper example flow and null handling
 """
 
 import json
@@ -12,7 +12,11 @@ from langchain_core.messages import SystemMessage, HumanMessage
 
 from app.ai.agent.state import AgentState, FlowState
 from app.ai.agent.validators import JSONValidator
-from app.ai.agent.schemas import ListingExtracted
+from app.ai.tools.listing_tool import (
+    extract_listing_fields_smart,
+    decide_next_listing_action,
+    generate_listing_example
+)
 from app.config import settings
 
 logger = get_logger(__name__)
@@ -22,7 +26,7 @@ llm = ChatOpenAI(
     api_key=settings.DEEPSEEK_API_KEY,
     base_url=settings.DEEPSEEK_BASE_URL,
     model="deepseek-chat",
-    temperature=0.7,  # Higher for more natural questions
+    temperature=0.7,
 )
 
 async def generate_contextual_question(state: AgentState, next_field: str = None) -> str:
@@ -199,148 +203,9 @@ async def handle_intent_switch(state: AgentState, new_intent: str) -> AgentState
     
     return state
 
-async def extract_listing_fields_smart(user_message: str, user_role: str, current_fields: Dict = None) -> Dict:
-    """
-    Smart field extraction that understands context, corrections, and partial info
-    """
-    
-    logger.info("Smart field extraction", 
-               msg_len=len(user_message),
-               current_fields=list(current_fields.keys()) if current_fields else [])
-    
-    context = f"\nCurrently saved: {json.dumps(current_fields, indent=2)}" if current_fields else ""
-    
-    prompt = f"""Extract property information from this user message. Be smart about context and corrections.
-
-User role: {user_role}
-User message: "{user_message}"{context}
-
-Extract these fields (set to null if not mentioned, extract corrections if present):
-- location: City/area name or null
-- bedrooms: Number or null (handle "3", "three", "3bed")
-- bathrooms: Number or null (handle "2", "two", "2bath") 
-- price: Amount or null (handle "50k", "50,000", "50000")
-- price_type: "monthly", "yearly", "weekly", "daily", "nightly" or null
-- amenities: List or [] (wifi, parking, furnished, ac, etc.)
-- requirements: Text or null
-
-Be smart about:
-- Corrections: "actually it's 3 bedrooms" → update bedrooms to 3
-- Partial info: "50k" when expecting price → extract price: 50000
-- Context: Use conversation history to understand
-
-Return ONLY valid JSON with extracted fields."""
-    
-    try:
-        response = await llm.ainvoke([
-            SystemMessage(content="You are a smart field extractor. Understand context and corrections."),
-            HumanMessage(content=prompt)
-        ])
-        
-        # Extract JSON from response
-        json_match = re.search(r'\{.*\}', response.content, re.DOTALL)
-        if json_match:
-            result = json.loads(json_match.group())
-            logger.info("Smart extraction successful", extracted=list(result.keys()))
-            return result
-        
-        return {}
-        
-    except Exception as e:
-        logger.error("Smart extraction failed", exc_info=e)
-        return {}
-
-async def decide_next_listing_action(state: AgentState) -> Dict:
-    """
-    AI decides what to do next based on current conversation context
-    """
-    
-    provided = state.provided_fields
-    missing = state.missing_required_fields
-    user_msg = state.last_user_message
-    
-    prompt = f"""You are Aida managing a property listing conversation. Decide next action.
-
-Current state:
-- Provided fields: {json.dumps(provided, indent=2)}
-- Missing required: {missing}
-- User just said: "{user_msg}"
-
-Available actions:
-1. "ask_missing" - Ask for next missing required field
-2. "ask_optional" - Ask about amenities/requirements (when required complete)
-3. "show_draft" - All required fields complete, show preview
-4. "acknowledge" - Acknowledge what user said, then continue
-5. "clarify" - Need clarification on what user meant
-
-Consider:
-- If missing required fields → "ask_missing"
-- If all required complete → "ask_optional" or "show_draft"
-- If user provided info → "acknowledge" then continue
-- If unclear → "clarify"
-
-Return ONLY valid JSON:
-{{
-  "action": "ask_missing|ask_optional|show_draft|acknowledge|clarify",
-  "reasoning": "why this action",
-  "next_field": "field to ask about (if ask_missing)",
-  "acknowledgment": "what to acknowledge (if acknowledge)"
-}}"""
-    
-    try:
-        response = await llm.ainvoke([
-            SystemMessage(content="Make smart conversation flow decisions for property listing."),
-            HumanMessage(content=prompt)
-        ])
-        
-        # Extract JSON
-        json_match = re.search(r'\{.*\}', response.content, re.DOTALL)
-        if json_match:
-            result = json.loads(json_match.group())
-            
-            logger.info("AI flow decision", 
-                       action=result["action"],
-                       reasoning=result["reasoning"])
-            
-            return result
-        
-        # Fallback decision
-        if missing:
-            return {
-                "action": "ask_missing",
-                "reasoning": "Fallback - ask missing field",
-                "next_field": missing[0],
-                "acknowledgment": ""
-            }
-        else:
-            return {
-                "action": "show_draft",
-                "reasoning": "Fallback - show draft",
-                "next_field": None,
-                "acknowledgment": ""
-            }
-        
-    except Exception as e:
-        logger.error("Flow decision failed", exc_info=e)
-        # Safe fallback
-        if missing:
-            return {
-                "action": "ask_missing",
-                "reasoning": "Exception fallback - ask missing field",
-                "next_field": missing[0],
-                "acknowledgment": ""
-            }
-        else:
-            return {
-                "action": "show_draft",
-                "reasoning": "Exception fallback - show draft",
-                "next_field": None,
-                "acknowledgment": ""
-            }
-
 async def listing_collect_handler(state: AgentState) -> AgentState:
     """
-    Dynamic listing collection with smart intent detection and contextual questioning
+    Dynamic listing collection with smart example flow and proper validation
     """
     
     logger.info("Dynamic listing collection", 
@@ -361,7 +226,18 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
             # Switch to new intent
             return await handle_intent_switch(state, intent_check["detected_intent"])
         
-        # 📝 Step 2: Extract fields from current message
+        # 📝 Step 2: Check if this is the initial state (no fields provided yet)
+        if not state.provided_fields and state.last_user_message in ["i want to list", "i want to list a property", "list my property"]:
+            logger.info("Initial listing request - showing example first")
+            
+            # Show random example
+            example = await generate_listing_example("en", state.user_role)
+            state.temp_data["response_text"] = f"Great! 🏠 Here's an example of how you could describe it:\n\n\"{example}\"\n\nNow tell me about your property."
+            state.temp_data["action"] = "show_example"
+            
+            return state  # Stay in listing_collect, wait for actual details
+        
+        # 📝 Step 3: Extract fields from current message
         if intent_check["extracted_fields"]:
             # Use extracted fields from intent check
             extracted = intent_check["extracted_fields"]
@@ -380,8 +256,28 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
                     state.update_listing_progress(field, value)
                     logger.info("Field updated", field=field, value=str(value)[:50])
         
-        # 🎯 Step 3: AI decides next action based on context
-        decision = await decide_next_listing_action(state)
+        # 🎯 Step 4: Check if we have actual data to proceed
+        required_fields = ["location", "bedrooms", "bathrooms", "price", "price_type"]
+        has_any_real_data = any(
+            state.provided_fields.get(f) is not None 
+            for f in required_fields
+        )
+        
+        if not has_any_real_data:
+            # Still no real data - ask naturally for first field
+            question = await generate_contextual_question(state, "location")
+            state.temp_data["response_text"] = question
+            state.temp_data["action"] = "asking_first_field"
+            state.current_asking_for = "location"
+            return state
+        
+        # 🎯 Step 5: AI decides next action based on context
+        decision = await decide_next_listing_action({
+            "provided_fields": state.provided_fields,
+            "missing_required_fields": state.missing_required_fields,
+            "last_user_message": state.last_user_message,
+            "user_role": state.user_role
+        })
         
         logger.info("AI decided next action", 
                    action=decision["action"],
@@ -401,8 +297,18 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
             state.temp_data["action"] = "asking_optional"
             
         elif decision["action"] == "show_draft":
-            state.temp_data["response_text"] = "Perfect! Let me create your listing preview..."
-            state.temp_data["action"] = "all_fields_collected"
+            # Check we actually have required fields before showing draft
+            missing_required = [f for f in required_fields if state.provided_fields.get(f) is None]
+            if missing_required:
+                # Still missing required fields - ask for next one
+                question = await generate_contextual_question(state, missing_required[0])
+                state.temp_data["response_text"] = question
+                state.temp_data["action"] = "asking_field"
+                state.current_asking_for = missing_required[0]
+            else:
+                # All required fields complete - show draft
+                state.temp_data["response_text"] = "Perfect! Let me create your listing preview..."
+                state.temp_data["action"] = "all_fields_collected"
             
         elif decision["action"] == "acknowledge":
             # Acknowledge what they said and continue

app/ai/tools/casual_chat_tool.py

@@ -1,163 +1,170 @@
-# app/ai/tools/casual_chat_tool.py
-# UPGRADED: LangChain Chain with Memory Management (FIXED IMPORTS)
+# app/ai/agent/nodes/casual_chat.py
+"""
+Node: Handle casual conversation with proper state transitions
+FIXED: Transitions to IDLE instead of COMPLETE to allow conversation continuation
+"""
 
-from typing import Dict, Optional
 from structlog import get_logger
 from langchain_openai import ChatOpenAI
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import RunnablePassthrough
+from langchain_core.messages import SystemMessage, HumanMessage
 
-from app.config import settings
+from app.ai.agent.state import AgentState, FlowState
+from app.ai.agent.validators import ResponseValidator
 from app.ai.prompts.system_prompt import get_system_prompt
+from app.config import settings
 
 logger = get_logger(__name__)
 
-
-# INITIALIZE LLM
+# Initialize LLM for casual conversation
 llm = ChatOpenAI(
     api_key=settings.DEEPSEEK_API_KEY,
     base_url=settings.DEEPSEEK_BASE_URL,
     model="deepseek-chat",
-    temperature=0.8,
-    max_tokens=500,
+    temperature=0.8,  # Higher temp for more natural conversation
 )
 
-
-# PROMPT TEMPLATE
-CASUAL_CHAT_PROMPT = ChatPromptTemplate.from_messages([
-    ("system", "{system_prompt}"),
-    ("human", "{input}"),
-])
-
-
-# MEMORY MANAGEMENT (simplified without deprecated classes)
-def create_chat_history(conversation_history: list = None) -> str:
-    """Convert conversation history to formatted string"""
-    if not conversation_history:
-        return ""
+def build_conversation_context(state: AgentState) -> str:
+    """
+    Build conversation context from history.
+    
+    Args:
+        state: Agent state with conversation history
+    
+    Returns:
+        Formatted conversation history string
+    """
+    
+    messages = state.conversation_history[-6:]  # Last 6 messages for context
+    
+    if not messages:
+        return "(New conversation)"
     
     formatted = []
-    for msg in conversation_history[-10:]:  # Last 10 messages
-        role = "Aida" if msg.get("role") == "assistant" else "You"
-        content = msg.get("content", "")
+    for msg in messages:
+        role = "User" if msg["role"] == "user" else "Aida"
+        content = msg["content"]
         formatted.append(f"{role}: {content}")
     
     return "\n".join(formatted)
 
-
-# CASUAL CHAT TOOL
-async def process_casual_chat(
-    user_message: str,
-    user_id: str,
-    user_role: str = "renter",
-    conversation_history: list = None,
-) -> Dict:
+async def casual_chat_handler(state: AgentState) -> AgentState:
     """
-    Process casual chat message using LangChain LCEL (modern approach).
+    Handle casual conversation with proper state transitions.
+    
+    FIXED: Transitions to IDLE instead of COMPLETE to allow conversation continuation
     
     Args:
-        user_message: What user said
-        user_id: User ID
-        user_role: User's role (landlord or renter)
-        conversation_history: Previous messages in conversation
+        state: Agent state
     
     Returns:
-        {
-            "success": bool,
-            "action": "casual_chat",
-            "reply": str (Aida's response),
-            "state": dict
-        }
+        Updated state
     """
     
     logger.info(
-        "Processing casual chat with LangChain LCEL",
-        user_id=user_id,
-        message_len=len(user_message)
+        "Handling casual chat",
+        user_id=state.user_id,
+        message=state.last_user_message[:50]
     )
     
     try:
-        # Get system prompt
-        system_prompt = get_system_prompt(user_role=user_role)
+        # ============================================================
+        # STEP 1: Build conversation context
+        # ============================================================
+        
+        conv_context = build_conversation_context(state)
+        
+        logger.info("Conversation context built", context_len=len(conv_context))
+        
+        # ============================================================
+        # STEP 2: Get system prompt
+        # ============================================================
+        
+        system_prompt = get_system_prompt(user_role=state.user_role)
+        
+        logger.info("System prompt loaded", user_role=state.user_role)
+        
+        # ============================================================
+        # STEP 3: Build chat prompt with context
+        # ============================================================
         
-        # Format conversation history
-        chat_history = create_chat_history(conversation_history)
+        chat_prompt = f"""{system_prompt}
+
+CONVERSATION HISTORY:
+{conv_context}
+
+CURRENT USER MESSAGE: {state.last_user_message}
+
+Respond naturally and helpfully. Keep your response conversational and friendly (2-3 sentences max)."""
+        
+        # ============================================================
+        # STEP 4: Call LLM for response
+        # ============================================================
+        
+        response = await llm.ainvoke([
+            SystemMessage(content="You are AIDA, a warm and helpful real estate AI assistant. Respond naturally to user questions."),
+            HumanMessage(content=chat_prompt)
+        ])
+        
+        response_text = response.content if hasattr(response, 'content') else str(response)
         
-        # Create LCEL chain (modern approach)
-        chain = CASUAL_CHAT_PROMPT | llm
+        logger.info("LLM response generated", response_len=len(response_text))
         
-        # Prepare context
-        context = {
-            "system_prompt": system_prompt,
-            "input": user_message,
-            "chat_history": chat_history
-        }
+        # ============================================================
+        # STEP 5: Validate response
+        # ============================================================
         
-        # Run chain
-        response = await chain.ainvoke(context)
+        is_valid, cleaned_text, error = ResponseValidator.validate_response_text(response_text)
         
-        # Extract text from response
-        if hasattr(response, 'content'):
-            aida_reply = response.content.strip()
+        if not is_valid:
+            logger.warning("Response validation failed", error=error)
+            # Use fallback
+            cleaned_text = "I'm here to help with real estate questions. What would you like to know?"
         else:
-            aida_reply = str(response).strip()
+            # Sanitize
+            cleaned_text = ResponseValidator.sanitize_response(cleaned_text)
+        
+        logger.info("Response validated", text_len=len(cleaned_text))
+        
+        # ============================================================
+        # STEP 6: Store in state
+        # ============================================================
+        
+        state.temp_data["response_text"] = cleaned_text
+        state.temp_data["action"] = "casual_chat"
+        
+        logger.info("Response stored in state", user_id=state.user_id)
+        
+        # ============================================================
+        # STEP 7: ✅ FIXED - Transition to IDLE (not COMPLETE!)
+        # ============================================================
+        
+        success, error = state.transition_to(FlowState.IDLE, reason="Casual chat completed, ready for next interaction")
+        
+        if not success:
+            logger.error("Transition to IDLE failed", error=error)
+            state.set_error(error, should_retry=False)
+            return state
         
         logger.info(
-            "Casual chat response generated",
-            reply_len=len(aida_reply)
+            "Casual chat completed",
+            user_id=state.user_id,
+            steps=state.steps_taken
         )
         
-        return {
-            "success": True,
-            "action": "casual_chat",
-            "reply": aida_reply,
-            "state": {
-                "status": "chatting",
-                "last_message_type": "casual_chat",
-            }
-        }
+        return state
     
     except Exception as e:
         logger.error("Casual chat error", exc_info=e)
+        error_msg = f"Chat error: {str(e)}"
         
-        fallback_reply = "Sorry, I had a moment there! What were you saying?"
-        
-        return {
-            "success": False,
-            "action": "casual_chat",
-            "reply": fallback_reply,
-            "state": {
-                "status": "chatting",
-                "error": str(e),
-            }
-        }
-
-
-# TEST
-async def test():
-    """Test the LangChain chat"""
-    
-    test_messages = [
-        "Hi, how are you?",
-        "Who created you?",
-        "What's the weather like?",
-        "Can you help me list my apartment?",
-    ]
-    
-    print("\nTesting LangChain Casual Chat\n" + "="*70 + "\n")
-    
-    for message in test_messages:
-        print(f"User: {message}")
+        # Set fallback response
+        state.temp_data["response_text"] = "Sorry, I had a moment there! What were you saying?"
+        state.temp_data["action"] = "casual_chat"
         
-        result = await process_casual_chat(
-            user_message=message,
-            user_id="test_user",
-            user_role="landlord"
-        )
+        # Try to recover
+        if state.set_error(error_msg, should_retry=True):
+            state.transition_to(FlowState.IDLE, reason="Chat with error recovery")
+        else:
+            state.transition_to(FlowState.ERROR, reason="Casual chat error")
         
-        print(f"Aida: {result['reply']}\n")
-
-
-if __name__ == "__main__":
-    import asyncio
-    asyncio.run(test())
+        return state

app/ai/tools/listing_tool.py

@@ -1,5 +1,5 @@
 # app/ai/tools/listing_tool.py
-# FINAL VERSION: Fixed circular import issue
+# FINAL VERSION: Complete dynamic listing tool with null safety and smart extraction
 
 import json
 import re
@@ -106,6 +106,7 @@ async def auto_detect_listing_type(price_type: str, user_role: str, user_message
 
 # ---------- STEP 4: AUTO-DETECT CURRENCY ----------
 async def get_currency_for_location(location: str) -> str:
+    # CRITICAL FIX: Handle None location
     if location is None:
         logger.warning("Location is None, defaulting to NGN")
         return "NGN"