fyp

app/ai/agent/graph.py

@@ -1,8 +1,6 @@
 # app/ai/agent/graph.py
 """
-AIDA Agent Graph - PROPER LangGraph Implementation
-This is the correct way to build production AI agents.
-Used by: OpenAI, Anthropic, Cognition, etc.
+AIDA Agent Graph - PROPER LangGraph Implementation with Recursion Limit
 """
 
 from typing import Literal
@@ -62,7 +60,14 @@ def route_after_listing_collect(state: AgentState) -> str:
     - If ready → go to listing_validate
     """
     
-    if state.missing_required_fields:
+    # ✅ CRITICAL FIX: Check if we have all required fields
+    required = ["location", "bedrooms", "bathrooms", "price", "price_type"]
+    has_all = all(
+        state.provided_fields.get(f) is not None 
+        for f in required
+    )
+    
+    if not has_all:
         logger.info("Still missing fields, staying in listing_collect")
         return "listing_collect"
     else:
@@ -163,7 +168,7 @@ def build_aida_graph():
         }
     )
     
-    # listing_publish (only when user confirms) → validate_output
+    # listing_publish → validate_output
     graph.add_edge("listing_publish", "validate_output")
     
     # Search → validate_output
@@ -184,9 +189,12 @@ def build_aida_graph():
     # COMPILE (Create executable graph)
     # ============================================================
     
-    compiled_graph = graph.compile()
+    # ✅ CRITICAL FIX: Set recursion_limit to prevent infinite loops
+    compiled_graph = graph.compile(
+        recursion_limit=100  # ✅ Increased from default 25 to 100
+    )
     
-    logger.info("✅ LangGraph compiled and ready")
+    logger.info("✅ LangGraph compiled and ready", recursion_limit=100)
     
     return compiled_graph
 

app/ai/agent/nodes/classify_intent.py

@@ -1,12 +1,11 @@
 # app/ai/agent/nodes/classify_intent.py
 """
-Node 2: Classify user intent.
-Uses LLM to understand what the user wants to do.
-Validates output with strict schema.
+Enhanced intent classification with resume detection and smart switching
 """
 
 import json
 import re
+from typing import Dict
 from structlog import get_logger
 from langchain_openai import ChatOpenAI
 from langchain_core.messages import SystemMessage, HumanMessage
@@ -26,7 +25,6 @@ llm = ChatOpenAI(
     temperature=0.3,  # Lower temp for classification
 )
 
-
 CLASSIFICATION_PROMPT = """You are AIDA, an intelligent intent classifier for a real estate platform.
 
 Your task: Understand what the user is trying to do.
@@ -55,22 +53,91 @@ Examples:
 - "Find me a 2-bed in Lagos" → {{"type": "search", "confidence": 0.90, "reasoning": "User searching for properties", "requires_auth": false, "next_action": "execute_search"}}
 - "What's 2+2?" → {{"type": "casual_chat", "confidence": 0.85, "reasoning": "General question", "requires_auth": false, "next_action": "respond_naturally"}}"""
 
+def _has_saved_listing_progress(state: AgentState) -> bool:
+    """Check if user has saved listing progress to resume"""
+    saved = state.temp_data.get("saved_listing_progress", {})
+    return bool(saved.get("provided_fields"))
+
+def _format_saved_fields(provided_fields: Dict) -> str:
+    """Format saved fields for resume message"""
+    parts = []
+    if provided_fields.get("location"):
+        parts.append(f"📍 {provided_fields['location']}")
+    if provided_fields.get("bedrooms"):
+        parts.append(f"🛏️ {provided_fields['bedrooms']} bed")
+    if provided_fields.get("bathrooms"):
+        parts.append(f"🚿 {provided_fields['bathrooms']} bath")
+    if provided_fields.get("price"):
+        parts.append(f"💰 {provided_fields['price']}")
+    if provided_fields.get("price_type"):
+        parts.append(f"📅 {provided_fields['price_type']}")
+    
+    return " | ".join(parts) if parts else "No details saved"
 
-async def classify_intent(
-    state: AgentState,
-) -> AgentState:
+async def check_for_listing_resume(state: AgentState) -> Dict:
+    """
+    Check if user wants to resume a previous listing session
     """
-    Classify user intent using LLM.
     
-    Args:
-        state: Current agent state (must have last_user_message)
+    if not _has_saved_listing_progress(state):
+        return {"should_resume": False}
     
-    Returns:
-        Updated agent state
+    saved_progress = state.temp_data["saved_listing_progress"]
+    user_message = state.last_user_message
     
-    Transitions to:
-        - GREETING, LISTING_COLLECT, SEARCH_QUERY, CASUAL_CHAT (based on intent)
-        - ERROR if classification fails
+    prompt = f"""User has saved listing progress: {json.dumps(saved_progress, indent=2)}
+
+User said: "{user_message}"
+
+Determine if they want to:
+1. Continue their previous listing
+2. Start a fresh listing  
+3. Do something else entirely
+
+Look for resume keywords: continue, resume, back, finish, complete
+Look for fresh start: new, fresh, start over, different
+Look for other intents: search, find, look for, etc.
+
+Return JSON:
+{{
+  "action": "continue|fresh|other",
+  "intent": "listing|search|greeting|casual_chat",
+  "confidence": 0.0-1.0
+}}"""
+    
+    try:
+        response = await llm.ainvoke([
+            SystemMessage(content="Detect if user wants to resume previous listing."),
+            HumanMessage(content=prompt)
+        ])
+        
+        # Extract JSON
+        json_match = re.search(r'\{.*\}', response.content, re.DOTALL)
+        if json_match:
+            result = json.loads(json_match.group())
+            
+            if result["action"] == "continue":
+                return {
+                    "should_resume": True,
+                    "intent": "listing",
+                    "confidence": result["confidence"]
+                }
+            
+            return {
+                "should_resume": False,
+                "intent": result["intent"],
+                "confidence": result["confidence"]
+            }
+        
+        return {"should_resume": False}
+        
+    except Exception as e:
+        logger.error("Resume detection failed", exc_info=e)
+        return {"should_resume": False}
+
+async def classify_intent(state: AgentState) -> AgentState:
+    """
+    Enhanced intent classification with resume detection and smart switching
     """
     
     if not state.last_user_message:
@@ -79,6 +146,25 @@ async def classify_intent(
         state.transition_to(FlowState.ERROR, reason="Missing user message")
         return state
     
+    # 🔄 CHECK FOR RESUME first
+    resume_check = await check_for_listing_resume(state)
+    if resume_check["should_resume"] and resume_check["confidence"] > 0.7:
+        logger.info("Detected listing resume", user_id=state.user_id)
+        
+        # Restore saved progress
+        saved = state.temp_data["saved_listing_progress"]
+        state.provided_fields.update(saved["provided_fields"])
+        state.missing_required_fields = saved["missing_fields"]
+        state.current_asking_for = saved["last_asking_for"]
+        
+        # Generate welcome back message
+        fields_summary = _format_saved_fields(saved["provided_fields"])
+        state.temp_data["response_text"] = f"📋 Welcome back! You were listing:\n{fields_summary}\n\nContinue where you left off?"
+        state.temp_data["action"] = "resume_listing_choice"
+        
+        state.transition_to(FlowState.LISTING_COLLECT, reason="Resuming listing")
+        return state
+    
     logger.info(
         "Classifying intent",
         user_id=state.user_id,

app/ai/agent/nodes/listing_collect.py

@@ -1,284 +1,425 @@
 # app/ai/agent/nodes/listing_collect.py
 """
-Node: Collect listing fields from user step by step.
-Extracts: location, bedrooms, bathrooms, price, price_type
-Optional: amenities, requirements, images
+Dynamic, context-aware listing collection with smart intent switching
 """
 
 import json
 import re
+from typing import Dict
 from structlog import get_logger
 from langchain_openai import ChatOpenAI
 from langchain_core.messages import SystemMessage, HumanMessage
 
 from app.ai.agent.state import AgentState, FlowState
-from app.ai.agent.validators import JSONValidator, ListingValidator
+from app.ai.agent.validators import JSONValidator
 from app.ai.agent.schemas import ListingExtracted
 from app.config import settings
 
 logger = get_logger(__name__)
 
-# Initialize LLM for field extraction
+# Initialize LLM for dynamic questioning
 llm = ChatOpenAI(
     api_key=settings.DEEPSEEK_API_KEY,
     base_url=settings.DEEPSEEK_BASE_URL,
     model="deepseek-chat",
-    temperature=0.3,  # Low temp for extraction accuracy
+    temperature=0.7,  # Higher for more natural questions
 )
 
-EXTRACTION_PROMPT = """Extract property listing fields from this user message.
+async def generate_contextual_question(state: AgentState, next_field: str = None) -> str:
+    """
+    Generate natural, contextual questions based on current conversation state
+    """
+    
+    missing_fields = state.missing_required_fields or []
+    if not missing_fields and not next_field:
+        return "Tell me more about your property."
+    
+    field_to_ask = next_field or missing_fields[0]
+    provided_so_far = state.provided_fields
+    
+    prompt = f"""Generate a NATURAL, conversational question to get the {field_to_ask} for a property listing.
 
-User role: {user_role}
-User message: "{user_message}"
+Current conversation context:
+- User role: {state.user_role}
+- Already provided: {json.dumps(provided_so_far, indent=2)}
+- Still need: {field_to_ask}
+- Last user message: "{state.last_user_message}"
 
-Extract these fields (set to null if not mentioned):
-- location: City/area name (e.g., "Lagos", "Cotonou", "Paris")
-- bedrooms: Number of bedrooms (integer or null)
-- bathrooms: Number of bathrooms (integer or null)
-- price: Price amount (number or null)
-- price_type: How often to pay (monthly, yearly, weekly, daily, nightly) or null
-- amenities: List of amenities (wifi, parking, furnished, ac, washing machine, etc.) or []
-- requirements: Any special requirements (deposit, credit check, no pets, etc.) or null
-- images: List of image URLs already uploaded or []
+Examples of natural questions:
+- If they said "I have a 3-bed in Lagos" → "Nice! What's the rent per month?"
+- If they said "2 bedrooms" → "Perfect! How many bathrooms does it have?"
+- If they said nothing yet → "What city is your property in?"
+
+Generate ONE short, natural question that flows with the conversation:
+"""
+
+    try:
+        response = await llm.ainvoke([
+            SystemMessage(content="You are Aida, a friendly real estate assistant. Ask questions naturally, like a human would."),
+            HumanMessage(content=prompt)
+        ])
+        
+        question = response.content.strip()
+        # Remove quotes if LLM added them
+        question = question.strip('"').strip("'")
+        
+        logger.info("Generated contextual question", 
+                   field=field_to_ask, 
+                   question=question[:50])
+        
+        return question
+        
+    except Exception as e:
+        logger.error("Failed to generate contextual question", exc_info=e)
+        # Fallback to simple question
+        fallback_questions = {
+            "location": "What city or area is your property in?",
+            "bedrooms": "How many bedrooms does it have?",
+            "bathrooms": "How many bathrooms?",
+            "price": "What's the price?",
+            "price_type": "Is that monthly, yearly, weekly, daily, or nightly?"
+        }
+        return fallback_questions.get(field_to_ask, f"What's the {field_to_ask}?")
+
+async def is_still_listing_intent(state: AgentState) -> Dict:
+    """
+    Smart check: Is user still talking about listing or changed intent?
+    """
+    
+    user_message = state.last_user_message
+    current_context = state.provided_fields
+    missing_fields = state.missing_required_fields
+    
+    prompt = f"""User is in property listing flow. Analyze their message:
+
+User said: "{user_message}"
+Current saved data: {json.dumps(current_context, indent=2)}
+Missing fields: {missing_fields}
+
+Determine:
+1. Is this still about listing their property? (providing details, asking listing questions)
+2. Or is this a different intent? (search, greeting, casual chat, etc.)
 
 Be smart about:
-- Understanding informal language and typos
-- Extracting numbers from various formats (50k, 50,000, $50000)
-- Identifying amenities even if spelled differently
-- Detecting price_type from context
+- Partial answers ("50k" when expecting price)
+- Listing-related questions ("is 50k too much for Lagos?")
+- Corrections ("actually it's 3 bedrooms")
 
-Return ONLY valid JSON (no markdown, no preamble):
+Return ONLY valid JSON:
 {{
-  "location": string or null,
-  "bedrooms": integer or null,
-  "bathrooms": integer or null,
-  "price": number or null,
-  "price_type": string or null,
-  "amenities": [],
-  "requirements": string or null,
-  "images": []
+  "is_listing_related": true/false,
+  "detected_intent": "listing|search|greeting|casual_chat|unknown",
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation",
+  "extracted_fields": {{}}  // Any fields you can extract from this message
 }}"""
 
+    try:
+        response = await llm.ainvoke([
+            SystemMessage(content="You are an intelligent conversation analyzer. Determine if user is still discussing their property listing or changed intent."),
+            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("Intent check completed", 
+                       is_listing=result["is_listing_related"],
+                       intent=result["detected_intent"],
+                       confidence=result["confidence"])
+            
+            return result
+        
+        # Fallback
+        return {
+            "is_listing_related": True,
+            "detected_intent": "listing",
+            "confidence": 0.5,
+            "reasoning": "Parse failed - assume listing",
+            "extracted_fields": {}
+        }
+        
+    except Exception as e:
+        logger.error("Intent check failed", exc_info=e)
+        return {
+            "is_listing_related": True,
+            "detected_intent": "listing",
+            "confidence": 0.5,
+            "reasoning": "Exception - assume listing",
+            "extracted_fields": {}
+        }
 
-async def extract_listing_fields(user_message: str, user_role: str) -> dict:
+async def handle_intent_switch(state: AgentState, new_intent: str) -> AgentState:
     """
-    Extract listing fields from user message using LLM.
+    Handle smooth transition to new intent while preserving listing data
+    """
+    
+    logger.info("Handling intent switch", 
+               from_intent="listing", 
+               to_intent=new_intent,
+               user_id=state.user_id)
+    
+    # Save current listing progress
+    state.temp_data["saved_listing_progress"] = {
+        "provided_fields": state.provided_fields.copy(),
+        "missing_fields": state.missing_required_fields.copy(),
+        "last_asking_for": state.current_asking_for
+    }
+    
+    # Switch intent
+    state.intent_type = new_intent
     
-    Args:
-        user_message: What user said
-        user_role: User's role (landlord or renter)
+    # Map to flow state
+    intent_to_flow = {
+        "search": FlowState.SEARCH_QUERY,
+        "greeting": FlowState.GREETING,
+        "casual_chat": FlowState.CASUAL_CHAT,
+        "listing": FlowState.LISTING_COLLECT
+    }
     
-    Returns:
-        Dict with extracted fields
+    next_flow = intent_to_flow.get(new_intent, FlowState.CASUAL_CHAT)
+    
+    # Generate smooth transition message
+    transition_messages = {
+        "search": "🔄 Switching to search mode... Let me find properties for you!",
+        "greeting": "Hello! 👋 How can I help you today?",
+        "casual_chat": "I'm here to help! What would you like to know?",
+        "listing": "Back to listing! 📋"
+    }
+    
+    state.temp_data["response_text"] = transition_messages.get(new_intent, "How can I help?")
+    state.temp_data["action"] = f"switched_to_{new_intent}"
+    
+    # Transition with validation
+    success, error = state.transition_to(next_flow, reason=f"User switched to {new_intent}")
+    if not success:
+        state.set_error(error, should_retry=False)
+    
+    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("Extracting listing fields", message_len=len(user_message))
+    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:
-        prompt = EXTRACTION_PROMPT.format(
-            user_role=user_role,
-            user_message=user_message
-        )
-        
-        # Call LLM
         response = await llm.ainvoke([
-            SystemMessage(content="You are a field extraction expert. Extract ONLY the fields requested. Return ONLY valid JSON."),
+            SystemMessage(content="You are a smart field extractor. Understand context and corrections."),
             HumanMessage(content=prompt)
         ])
         
-        response_text = response.content if hasattr(response, 'content') else str(response)
-        logger.info("LLM extraction response received", response_len=len(response_text))
-        
-        # ✅ VALIDATE JSON
-        validation = JSONValidator.extract_and_validate(response_text)
+        # 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
         
-        if not validation.is_valid:
-            logger.warning("Extraction JSON validation failed", errors=validation.errors)
-            return {}
-        
-        extracted = validation.data
-        logger.info("Fields extracted successfully", fields=list(extracted.keys()))
+        return {}
         
-        return extracted
-    
     except Exception as e:
-        logger.error("Field extraction error", exc_info=e)
+        logger.error("Smart extraction failed", exc_info=e)
         return {}
 
-
-async def listing_collect_handler(state: AgentState) -> AgentState:
+async def decide_next_listing_action(state: AgentState) -> Dict:
     """
-    Collect listing fields from user step by step.
-    
-    Flow:
-    1. Extract fields from message
-    2. Update progress
-    3. Check what's still missing
-    4. Ask for next missing field
-    5. When all required present → transition to LISTING_VALIDATE
-    
-    Args:
-        state: Agent state
-    
-    Returns:
-        Updated state
+    AI decides what to do next based on current conversation context
     """
     
-    logger.info(
-        "Handling listing collection",
-        user_id=state.user_id,
-        current_progress=state.get_listing_progress()
-    )
+    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:
-        # ============================================================
-        # STEP 1: Extract fields from user message
-        # ============================================================
-        
-        extracted = await extract_listing_fields(
-            state.last_user_message,
-            state.user_role
-        )
-        
-        if not extracted:
-            logger.warning("No fields extracted")
-            state.set_error("Could not understand your message", should_retry=True)
-            return state
-        
-        logger.info("Fields extracted", extracted_keys=list(extracted.keys()))
-        
-        # ============================================================
-        # STEP 2: Update state with provided fields
-        # ============================================================
-        
-        for field, value in extracted.items():
-            if value is not None and value != [] and value != "":
-                state.update_listing_progress(field, value)
-                logger.info("Field updated", field=field, value=str(value)[:50])
-        
-        # ============================================================
-        # STEP 3: Check missing required fields
-        # ============================================================
-        
-        required_fields = ["location", "bedrooms", "bathrooms", "price", "price_type"]
-        missing = [
-            f for f in required_fields
-            if f not in state.provided_fields or state.provided_fields[f] is None
-        ]
+        response = await llm.ainvoke([
+            SystemMessage(content="Make smart conversation flow decisions for property listing."),
+            HumanMessage(content=prompt)
+        ])
         
-        logger.info(
-            "Missing fields check",
-            missing=missing,
-            provided=list(state.provided_fields.keys())
-        )
+        # 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
         
-        # ============================================================
-        # STEP 4: If missing required fields, ask for next one
-        # ============================================================
+        # 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:
-            next_field = missing[0]
-            
-            # Generate question for missing field
-            field_questions = {
-                "location": "What city or area is your property in?",
-                "bedrooms": "How many bedrooms does it have?",
-                "bathrooms": "How many bathrooms?",
-                "price": "What's the price?",
-                "price_type": "Is that monthly, yearly, weekly, daily, or nightly?",
+            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
+    """
+    
+    logger.info("Dynamic listing collection", 
+               user_id=state.user_id,
+               current_fields=list(state.provided_fields.keys()),
+               missing_fields=state.missing_required_fields)
+    
+    try:
+        # 🧠 Step 1: Check if user changed intent
+        intent_check = await is_still_listing_intent(state)
+        
+        if not intent_check["is_listing_related"]:
+            # Extract any fields before switching
+            if intent_check["extracted_fields"]:
+                for field, value in intent_check["extracted_fields"].items():
+                    state.update_listing_progress(field, value)
             
-            question = field_questions.get(next_field, f"What is the {next_field}?")
-            
-            state.temp_data["response_text"] = question
-            state.temp_data["action"] = "asking_field"
-            state.current_asking_for = next_field
-            
-            logger.info(
-                "Asking for missing field",
-                field=next_field,
-                question=question,
-                remaining_fields=len(missing)
+            # Switch to new intent
+            return await handle_intent_switch(state, intent_check["detected_intent"])
+        
+        # 📝 Step 2: Extract fields from current message
+        if intent_check["extracted_fields"]:
+            # Use extracted fields from intent check
+            extracted = intent_check["extracted_fields"]
+        else:
+            # Smart field extraction
+            extracted = await extract_listing_fields_smart(
+                state.last_user_message,
+                state.user_role,
+                state.provided_fields  # Pass current context
             )
-            
-            return state
         
-        # ============================================================
-        # STEP 5: All required fields present - ask about optional fields
-        # ============================================================
+        # Update state with extracted fields
+        if extracted:
+            for field, value in extracted.items():
+                if value is not None and value != [] and value != "":
+                    state.update_listing_progress(field, value)
+                    logger.info("Field updated", field=field, value=str(value)[:50])
         
-        logger.info("All required fields collected, checking optional fields")
+        # 🎯 Step 3: AI decides next action based on context
+        decision = await decide_next_listing_action(state)
         
-        has_amenities = "amenities" in state.provided_fields and state.provided_fields.get("amenities")
-        has_requirements = "requirements" in state.provided_fields and state.provided_fields.get("requirements")
+        logger.info("AI decided next action", 
+                   action=decision["action"],
+                   reasoning=decision["reasoning"])
         
-        if not has_amenities and not has_requirements:
-            # Ask about optional fields
-            state.temp_data["response_text"] = (
-                "Great! Now, does your property have any amenities like wifi, parking, furnished, AC, etc.? "
-                "And any special requirements like deposit, credit check, no pets? (Say 'none' or skip if there are none)"
-            )
-            state.temp_data["action"] = "asking_optional"
-            state.current_asking_for = "optional_fields"
-            
-            logger.info("Asking about optional fields")
+        # Execute the decided action
+        if decision["action"] == "ask_missing":
+            question = await generate_contextual_question(state, decision.get("next_field"))
+            state.temp_data["response_text"] = question
+            state.temp_data["action"] = "asking_field"
+            state.current_asking_for = decision.get("next_field")
             
-            return state
-        
-        # ============================================================
-        # STEP 6: Ask about images
-        # ============================================================
-        
-        has_images = "images" in state.provided_fields and len(state.provided_fields.get("images", [])) > 0
-        
-        if not has_images:
-            state.temp_data["response_text"] = (
-                "📷 Please upload at least one image of your property. "
-                "This helps buyers/renters see what they're getting! "
-                "Share the image URL in your next message."
-            )
-            state.temp_data["action"] = "asking_images"
-            state.current_asking_for = "images"
+        elif decision["action"] == "ask_optional":
+            # Ask about amenities/requirements naturally
+            question = "Great! Does your property have any amenities like wifi, parking, furnished, AC, etc.? And any special requirements?"
+            state.temp_data["response_text"] = question
+            state.temp_data["action"] = "asking_optional"
             
-            logger.info("Asking for images")
+        elif decision["action"] == "show_draft":
+            state.temp_data["response_text"] = "Perfect! Let me create your listing preview..."
+            state.temp_data["action"] = "all_fields_collected"
             
-            return state
-        
-        # ============================================================
-        # STEP 7: All data collected - transition to LISTING_VALIDATE
-        # ============================================================
-        
-        logger.info(
-            "All listing data collected",
-            provided_fields=list(state.provided_fields.keys()),
-            images_count=len(state.provided_fields.get("images", []))
-        )
-        
-        state.temp_data["response_text"] = "Perfect! Let me generate your listing preview..."
-        state.temp_data["action"] = "listing_complete"
-        
-        # Transition to validate
-        success, error = state.transition_to(
-            FlowState.LISTING_VALIDATE,
-            reason="All listing data collected"
-        )
-        
-        if not success:
-            logger.error("Transition to LISTING_VALIDATE failed", error=error)
-            state.set_error(error, should_retry=False)
-            return state
-        
-        logger.info("Transitioned to LISTING_VALIDATE", user_id=state.user_id)
-        
+        elif decision["action"] == "acknowledge":
+            # Acknowledge what they said and continue
+            acknowledgment = decision.get("acknowledgment", "Got it!")
+            next_question = await generate_contextual_question(state)
+            state.temp_data["response_text"] = f"{acknowledgment} {next_question}"
+            state.temp_data["action"] = "acknowledge_continue"
+        
+        # Stay in listing_collect - router will handle transition
         return state
-    
+        
     except Exception as e:
-        logger.error("Listing collection error", exc_info=e)
-        error_msg = f"Error collecting listing data: {str(e)}"
+        logger.error("Dynamic listing collection error", exc_info=e)
+        error_msg = f"Error processing listing: {str(e)}"
         
         if state.set_error(error_msg, should_retry=True):
-            # Retry the collection
-            state.temp_data["response_text"] = "Let me try that again. What city is your property in?"
+            state.temp_data["response_text"] = "Let me try that again. Tell me about your property."
             state.temp_data["action"] = "retry_collection"
         else:
             state.transition_to(FlowState.ERROR, reason="Listing collection error")

app/ai/tools/listing_tool.py

@@ -1,5 +1,5 @@
 # app/ai/tools/listing_tool.py
-# FINAL VERSION: Random examples + AI-powered URL extraction + FIELD PRESERVATION FIX
+# FINAL VERSION: Fixed circular import issue
 
 import json
 import re
@@ -27,7 +27,6 @@ llm = ChatOpenAI(
     temperature=0.3,
 )
 
-
 # ---------- AI-POWERED URL EXTRACTION ----------
 async def extract_image_urls_from_message(user_message: str) -> List[str]:
     """AI-powered image URL extraction using LLM."""
@@ -52,7 +51,6 @@ Return ONLY valid JSON: {{"urls": ["https://..."] or []}}"""
         logger.error("AI URL extraction failed", exc_info=e)
         return []
 
-
 # ---------- STEP 1: SHOW RANDOM EXAMPLE ----------
 async def generate_listing_example(user_language: str, user_role: str) -> str:
     prompt_text = f"""Generate a UNIQUE, realistic property listing example as a {user_role} in {user_language}.
@@ -65,7 +63,6 @@ DIFFERENT each time. Return ONLY the example sentence(s)."""
     example = response.content if hasattr(response, 'content') else str(response)
     return example.strip()
 
-
 # ---------- STEP 2: EXTRACT FIELDS ----------
 async def extract_listing_fields(user_message: str, user_role: str) -> Dict:
     logger.info("Extracting listing fields", user_role=user_role, msg_len=len(user_message))
@@ -95,7 +92,6 @@ Be smart about intent (typos, informal language). IGNORE URLs. Return ONLY valid
         logger.error("Extraction failed", exc_info=e)
         return {}
 
-
 # ---------- STEP 3: AUTO-DETECT LISTING TYPE ----------
 async def auto_detect_listing_type(price_type: str, user_role: str, user_message: str = "") -> str:
     if user_role == "renter":
@@ -108,9 +104,12 @@ async def auto_detect_listing_type(price_type: str, user_role: str, user_message
         return "short-stay"
     return "rent"
 
-
 # ---------- STEP 4: AUTO-DETECT CURRENCY ----------
 async def get_currency_for_location(location: str) -> str:
+    if location is None:
+        logger.warning("Location is None, defaulting to NGN")
+        return "NGN"
+    
     try:
         currency, city, confidence = await ml_extractor.infer_currency(state={"location": location})
         if currency:
@@ -118,6 +117,7 @@ async def get_currency_for_location(location: str) -> str:
             return currency
     except Exception as e:
         logger.error("ML currency inference failed", exc_info=e)
+    
     fallback_map = {
         "lagos": "NGN", "lekki": "NGN", "vi": "NGN", "ikeja": "NGN",
         "cotonou": "XOF", "calavi": "XOF", "porto-novo": "XOF",
@@ -135,7 +135,6 @@ async def get_currency_for_location(location: str) -> str:
     logger.warning("Currency not detected, defaulting to NGN", location=location)
     return "NGN"
 
-
 # ---------- STEP 5: AUTO-GENERATE TITLE & DESCRIPTION ----------
 async def generate_title_and_description(extracted_data: Dict, user_role: str = "landlord") -> Tuple[str, str]:
     logger.info("Generating title and description", role=user_role)
@@ -194,7 +193,6 @@ Return ONLY valid JSON: {{"title": "string", "description": "string"}}"""
         description = f"Property listing in {location}."
         return title, description
 
-
 # ---------- BUILD DRAFT UI COMPONENT ----------
 def build_draft_ui_component(draft: Dict) -> Dict:
     amenities_icons = {
@@ -228,8 +226,150 @@ def build_draft_ui_component(draft: Dict) -> Dict:
     }
     return ui_component
 
+# ---------- SMART FIELD EXTRACTION (NEW) ----------
+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 {}
 
-# ---------- MAIN PROCESS LISTING ----------
+# ---------- DECIDE NEXT ACTION (NEW) ----------
+async def decide_next_listing_action(state_data: Dict) -> Dict:
+    """
+    AI decides what to do next based on current conversation context
+    Takes a dictionary instead of AgentState to avoid circular imports
+    """
+    
+    provided = state_data.get("provided_fields", {})
+    missing = state_data.get("missing_required_fields", [])
+    user_msg = state_data.get("last_user_message", "")
+    user_role = state_data.get("user_role", "landlord")
+    
+    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] if missing else None,
+                "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] if missing else None,
+                "acknowledgment": ""
+            }
+        else:
+            return {
+                "action": "show_draft",
+                "reasoning": "Exception fallback - show draft",
+                "next_field": None,
+                "acknowledgment": ""
+            }
+
+# ---------- MAIN PROCESS LISTING (UPDATED) ----------
 async def process_listing(
     user_message: str,
     user_id: str,
@@ -270,7 +410,7 @@ async def process_listing(
         }
 
     # STEP 2: Extract fields from user message
-    extracted_data = await extract_listing_fields(user_message, user_role)
+    extracted_data = await extract_listing_fields_smart(user_message, user_role, state.get("provided_fields", {}))
 
     # SMART MERGE: preserve previously provided fields
     provided_fields = state.get("provided_fields", {})
@@ -299,14 +439,29 @@ async def process_listing(
     if missing_fields:
         logger.info("Missing required fields", missing=missing_fields, user_id=user_id)
         next_field = missing_fields[0]
-        field_questions = {
-            "location": "What city or area is your property in?",
-            "bedrooms": "How many bedrooms?",
-            "bathrooms": "How many bathrooms?",
-            "price": "What's the price?",
-            "price_type": "Is that monthly, yearly, weekly, daily, or nightly?",
-        }
-        question = field_questions.get(next_field, f"What's the {next_field}?")
+        
+        # Use smart decision for next question instead of hardcoded
+        decision = await decide_next_listing_action({
+            "provided_fields": provided_fields,
+            "missing_required_fields": missing_fields,
+            "last_user_message": user_message,
+            "user_role": user_role
+        })
+        
+        if decision["action"] == "ask_missing":
+            # Generate contextual question (we'll use a simple version here)
+            field_questions = {
+                "location": "What city or area is your property in?",
+                "bedrooms": "How many bedrooms does it have?",
+                "bathrooms": "How many bathrooms?",
+                "price": "What's the price?",
+                "price_type": "Is that monthly, yearly, weekly, daily, or nightly?",
+            }
+            question = field_questions.get(next_field, f"What's the {next_field}?")
+        else:
+            # Use the decision's guidance
+            question = "Tell me more about your property."
+            
         return {
             "success": True,
             "action": "ask_field",
@@ -327,7 +482,7 @@ async def process_listing(
         return {
             "success": True,
             "action": "ask_optional",
-            "reply": "Any amenities (like wifi, parking, furnished) or special requirements (like deposit needed, credit check)? Say 'none' or skip if there are none.",
+            "reply": "Any amenities (like wifi, parking, furnished, washing machine, AC, etc.) or special requirements (like deposit needed, credit check, no pets)? Say 'none' or skip if there are none.",
             "data": provided_fields,
             "state": {
                 "status": "listing",
@@ -343,7 +498,7 @@ async def process_listing(
         return {
             "success": True,
             "action": "ask_images",
-            "reply": "📷 Please upload at least one image of your property. This helps buyers/renters see what they're getting!",
+            "reply": "📷 Please upload at least one image of your property. This helps buyers/renters see what they're getting! Share the image URL in your next message.",
             "data": provided_fields,
             "state": {
                 "status": "listing",