gems

app/ai/graph.py

@@ -9,6 +9,7 @@ from app.ai.nodes.publish_node       import publish_node
 from app.ai.nodes.edit_node          import edit_node
 from app.ai.nodes.discard_node       import discard_node
 from structlog import get_logger
+from typing import Dict
 
 logger = get_logger(__name__)
 
@@ -22,61 +23,103 @@ workflow.add_node("create_draft",      draft_node)
 workflow.add_node("handle_publish",    publish_node)
 workflow.add_node("handle_edit",       edit_node)
 workflow.add_node("handle_discard",    discard_node)
+workflow.add_node("route_after_draft", lambda state: state) # Dummy node for routing
 
-# ---------- EDGES ----------
-workflow.add_edge(START, "parse_intent")
-
-def route_from_intent(state: ChatState):
-    intent = state.get("intent")
-    if intent in {"search", "list"}:
-        return "check_permissions"
-    return END
-workflow.add_conditional_edges("parse_intent", route_from_intent,
-                               {"check_permissions": "check_permissions", END: END})
-
-def route_from_permissions(state: ChatState):
-    if not state.get("allowed", False):
-        return END
-    return "search_listings" if state.get("intent") == "search" else "create_draft"
-workflow.add_conditional_edges("check_permissions", route_from_permissions,
-                               {"search_listings": "search_listings",
-                                "create_draft": "create_draft", END: END})
-
-workflow.add_edge("search_listings", END)
-
-# ---------- POST-DRAFT ROUTING (language-agnostic) ----------
+# ---------- KEYWORDS FOR ROUTING ----------
 _KEYWORDS_PUBLISH = {"publish", "publier", "go live", "post it", "list it", "confirm", "yes", "ok", "okay"}
-_KEYWORDS_EDIT    = {"edit", "modifier", "change", "update", "correction", "fix"}
+_KEYWORDS_EDIT = {"edit", "change", "modify", "correction", "fix"}
 _KEYWORDS_DISCARD = {"discard", "delete", "cancel", "annuler", "remove", "start over"}
 
+# ---------- ROUTERS / GATES ----------
+
+def gate_before_intent(state: ChatState):
+    """Route from START: Check if a draft preview is shown."""
+    # If draft is on screen (preview_shown or waiting_for_images), go straight to post-draft router
+    if state.get("status") in {"preview_shown", "waiting_for_images", "editing"}:
+        # In a real app, 'editing' status might route to a special node, but for now, 
+        # any status related to an active draft should go to the draft router.
+        return "route_after_draft"
+    return "parse_intent"
+
 def route_after_draft(state: ChatState):
+    """Route after draft preview based on user's command (publish/edit/discard)."""
     last = state["messages"][-1]["content"].lower()
+    
+    # Check for keywords that trigger final actions
     if any(k in last for k in _KEYWORDS_PUBLISH):
         return "handle_publish"
     if any(k in last for k in _KEYWORDS_EDIT):
         return "handle_edit"
     if any(k in last for k in _KEYWORDS_DISCARD):
         return "handle_discard"
-    return "parse_intent"   # fall back to normal intent
+    
+    # If the status is 'editing', any user input is the new value for the field.
+    # We should go straight to the draft node to process it.
+    if state.get("status") == "editing":
+        return "create_draft"
+        
+    return "parse_intent"   # fall back to normal intent for casual chat
 
-def gate_before_intent(state: ChatState):
-    # if draft is on screen, go straight to post-draft router
-    if state.get("status") == "preview_shown":
-        return "route_after_draft"
-    return "parse_intent"
+def route_after_permissions(state: ChatState) -> str:
+    """Route after permissions check based on intent/allowed status."""
+    if state.get("intent") == "search":
+        return "search_listings"
+    
+    # If allowed (or we need to collect more data for a list)
+    if state.get("allowed", True) and state.get("intent") == "list":
+        return "create_draft"
+        
+    # Blocked by role gate (user is not allowed to list this type)
+    return END
+
+# ---------- EDGES ----------
+
+# 1. Initial Entry: Check if a post-draft action is expected
+workflow.add_conditional_edges(
+    START, 
+    gate_before_intent,
+    {"route_after_draft": "route_after_draft", "parse_intent": "parse_intent"}
+)
 
-workflow.add_conditional_edges(START, gate_before_intent,
-                               {"route_after_draft": "route_after_draft",
-                                "parse_intent": "parse_intent"})
-workflow.add_conditional_edges("route_after_draft", route_after_draft,
-                               {"handle_publish": "handle_publish",
-                                "handle_edit":    "handle_edit",
-                                "handle_discard": "handle_discard",
-                                "parse_intent":   "parse_intent"})
+# 2. Intent detection -> Permission check
+workflow.add_edge("parse_intent", "check_permissions")
 
+# 3. Permission Check -> Route to Listing or Search, or END
+workflow.add_conditional_edges(
+    "check_permissions", 
+    route_after_permissions,
+    {"search_listings": "search_listings", "create_draft": "create_draft", END: END}
+)
+
+# 4. Listing Collection Flow: The main loop for drafting
+# Note: create_draft will update state with new info, then its output routes back 
+# to check_permissions (which currently routes back to create_draft if intent is list)
+# We will simplify this by having draft_node route to END only when the draft is finalized
+# and the user is *not* ready to publish. For simplicity, we loop back to check_permissions 
+# until the `route_after_draft` gate is triggered.
+workflow.add_edge("create_draft", "parse_intent") # After draft, always re-parse the user's new message
+
+# 5. Post-Draft Actions Routing (triggered when status is 'preview_shown')
+workflow.add_conditional_edges(
+    "route_after_draft", 
+    route_after_draft,
+    {
+        "handle_publish": "handle_publish",
+        "handle_edit":    "handle_edit",
+        "handle_discard": "handle_discard",
+        "parse_intent":   "parse_intent",
+        "create_draft":   "create_draft", # Needed for when status is 'editing'
+    }
+)
+
+# 6. Final States: Publish/Discard/Search ends the current turn
 workflow.add_edge("handle_publish", END)
-workflow.add_edge("handle_edit",    END)
 workflow.add_edge("handle_discard", END)
+workflow.add_edge("search_listings", END)
+
+# 7. Edit Action: Go back to `create_draft` to process the change and re-show the preview
+workflow.add_edge("handle_edit", "create_draft")
+
 
-agent = workflow.compile()
-logger.info("✅ LangGraph compiled – post-draft routing active")
+# Compile the graph
+agent = workflow.compile()

app/ai/nodes/discard_node.py

@@ -10,6 +10,7 @@ async def discard_node(state: Dict) -> Dict:
                 "price", "listing_type", "price_type", "amenities", "requirements",
                 "missing_fields", "editing_field"]:
         state.pop(key, None)
+        
     state.update({
         "status":   "discarded",
         "ai_reply": "Brouillon supprimé. Que souhaitez-vous faire ensuite ?",

app/ai/nodes/draft_node.py

@@ -1,34 +1,22 @@
-# app/ai/nodes/draft_node.py – COMPLETE FILE (final)
+# app/ai/nodes/draft_node.py – COMPLETE FILE (final with editing logic)
 import datetime
-from typing import Dict
+import json
+from typing import Dict, List
 from bson import ObjectId
-from app.database import get_db
 from app.ai.state import ListingDraft
 from structlog import get_logger
-from openai import AsyncOpenAI
-from app.config import settings
-from app.ml.models.ml_listing_extractor import get_ml_extractor
+from app.ml.models.ml_listing_extractor import get_ml_extractor # Assuming this is available
+from app.ai.nodes.intent_node import get_llm_chain, _clean_json # Import helper functions
 
 logger = get_logger(__name__)
 
-client = AsyncOpenAI(api_key=settings.OPENAI_API_KEY)
 ml_extractor = get_ml_extractor()
 
-# ========== AMENITY ICONS ==========
+# ========== AMENITY ICONS (Keep as is) ==========
 AMENITY_ICONS = {
-    "wifi": "📶",
-    "parking": "🅿️",
-    "furnished": "🛋️",
-    "washing machine": "🧼",
-    "washing": "🧼",
-    "dryer": "🔥",
-    "balcony": "🏖️",
-    "pool": "🏊",
-    "gym": "💪",
-    "garden": "🌿",
-    "air conditioning": "❄️",
-    "ac": "❄️",
-    "kitchen": "🍳",
+    "wifi": "📶", "parking": "🅿️", "furnished": "🛋️", "washing machine": "🧼",
+    "washing": "🧼", "dryer": "🔥", "balcony": "🏖️", "pool": "🏊", "gym": "💪",
+    "garden": "🌿", "air conditioning": "❄️", "ac": "❄️", "kitchen": "🍳",
 }
 
 def _add_amenity_icons(amenities: list) -> str:
@@ -38,155 +26,151 @@ def _add_amenity_icons(amenities: list) -> str:
     for amenity in amenities:
         amenity_lower = amenity.lower().strip()
         icon = AMENITY_ICONS.get(amenity_lower, "✓")
-        icons_text.append(f"{icon} {amenity.title()}")
+        icons_text.append(f"{icon} {amenity}")
     return " | ".join(icons_text)
 
-def _generate_title(state: Dict) -> str:
-    bedrooms = state.get("bedrooms", "")
-    location = state.get("location", "").title()
-    listing_type = state.get("listing_type", "").title()
-    if bedrooms and location:
-        return f"{bedrooms}-Bedroom {listing_type} in {location}"
-    return f"Property in {location}"
-
-def _generate_description(state: Dict) -> str:
-    bedrooms = state.get("bedrooms", "")
-    bathrooms = state.get("bathrooms", "")
-    location = state.get("location", "").title()
-    amenities = state.get("amenities", [])
-    price = state.get("price", "")
-    price_type = state.get("price_type", "").title()
-    listing_type = state.get("listing_type", "").title()
-    requirements = state.get("requirements", "")
-
-    desc = f"Spacious {bedrooms}-bedroom, {bathrooms}-bathroom {listing_type} "
-    desc += f"located in {location}. "
-
-    if price:
-        desc += f"Priced at {price:,} {price_type}. "
-
-    if amenities:
-        desc += f"Fully furnished with modern amenities including {', '.join(amenities)}. "
-
-    if requirements:
-        desc += f"Requirements: {requirements}. "
-
-    desc += "Perfect for large families or shared accommodation."
-    return desc
-
-# ========== MAIN NODE ==========
-async def draft_node(state: Dict) -> Dict:
-    """
-    LangGraph node:
-    - Check if status == "checking_optional" (amenities/requirements missing)
-    - Ask for amenities and requirements
-    - Move to "draft_ready"
-    - Or status == "draft_ready" → show preview
-    """
-
-    # ✅ NEW: Check if amenities/requirements are missing
-    if state.get("status") == "checking_optional":
-        amenities = state.get("amenities", [])
-        requirements = state.get("requirements")
-
-        missing_optional = []
-        if not amenities:
-            missing_optional.append("amenities")
-        if not requirements:
-            missing_optional.append("requirements")
-
-        if missing_optional:
-            state["status"] = "collecting_optional"
-            state["missing_fields"] = missing_optional
-
-            questions = []
-            if "amenities" in missing_optional:
-                questions.append("Any amenities? (e.g., wifi, parking, balcony, pool, furnished, kitchen, dryer, garden, etc.)")
-            if "requirements" in missing_optional:
-                questions.append("Any special requirements for renters?")
-
-            state["ai_reply"] = "Just a couple more things...\n\n" + "\n".join([f"• {q}" for q in questions])
-            logger.info("ℹ️ Asking for optional fields", missing=missing_optional)
+def _generate_title(draft: Dict) -> str:
+    """Simple title generation based on key fields."""
+    bds = draft.get("bedrooms", "N/A")
+    loc = draft.get("location", "N/A")
+    price = f"{draft.get('price', 0):,.0f}"
+    p_type = draft.get("price_type", "monthly").capitalize()
+    
+    return f"{bds}-Bed {draft['listing_type'].capitalize()} in {loc} | {price} {p_type}"
+
+
+def _update_draft_fields(state: Dict) -> Dict:
+    """Updates the draft object with all current fields from state."""
+    # The fields should already be updated in the state by the intent_node
+    # but we consolidate them here for clarity and ML checks.
+    
+    # 1. Handle Editing Mode
+    if state.get("status") == "editing" and state.get("editing_field"):
+        field = state["editing_field"]
+        last_message = state["messages"][-1]["content"]
+        
+        # Use ML extractor to infer the new value from the user's message
+        # We try to re-run the extraction on the single user message for better parsing
+        try:
+            extracted = ml_extractor.extract_fields(last_message, state.get("user_id"))
+            new_value = extracted.get(field)
+            
+            if new_value is not None:
+                state[field] = new_value
+                state["editing_field"] = None # Clear editing field
+                state["status"] = "collecting" # Go back to collecting/validating
+                logger.info(f"✅ Field updated by edit", field=field, value=new_value)
+            else:
+                # If ML extractor fails to find the field in the simple message, 
+                # keep editing status and ask again.
+                state["ai_reply"] = f"Désolé, je n'ai pas compris la nouvelle valeur pour **{field}**. Pouvez-vous l'indiquer clairement ?"
+                logger.warning(f"⚠️ Failed to update field, asking again", field=field)
+                return state
+                
+        except Exception as e:
+            logger.error("❌ ML Extraction failed during edit", exc_info=e)
+            state["ai_reply"] = f"Une erreur s'est produite lors de la mise à jour de **{field}**. Veuillez réessayer plus tard."
+            state["editing_field"] = None
+            state["status"] = "collecting"
             return state
-        else:
-            # All optional fields provided, move to draft
-            state["status"] = "draft_ready"
-
-    # Only process if listing creation with all fields ready
-    if state.get("intent") != "list" or state.get("status") != "draft_ready":
-        return state
-
-    user_id = state.get("user_id")
-
-    # ✅ ML VALIDATION before drafting
-    try:
-        validation = ml_extractor.validate_all_fields(state, user_id)
 
-        if not validation["all_valid"]:
-            issues_text = "\n".join([f"❌ {issue}" for issue in validation["issues"]])
-            state["ai_reply"] = f"""I found some issues with your listing:
 
-{issues_text}
-
-Let me ask again - could you clarify these fields?"""
+    # 2. Build current draft (using all state fields)
+    draft_dict = {
+        "owner_id":     state["user_id"],
+        "listing_type": state.get("listing_type"),
+        "location":     state.get("location"),
+        "bedrooms":     state.get("bedrooms"),
+        "bathrooms":    state.get("bathrooms"),
+        "price":        state.get("price"),
+        "price_type":   state.get("price_type"),
+        "currency":     state.get("currency", "XOF"),
+        "amenities":    state.get("amenities", []),
+        "requirements": state.get("requirements"),
+        "images":       state.get("draft_preview", {}).get("images", []), # Preserve images if exists
+    }
+    
+    # Use ML to fill in or validate missing Title and Description
+    if draft_dict.get("location") and draft_dict.get("price"):
+        # We need a placeholder title/description for validation and preview
+        draft_dict["title"] = _generate_title(draft_dict)
+        draft_dict["description"] = "A lovely property located in the heart of the city."
+        
+        # In a real setup, you would call the LLM again here to generate a high-quality 
+        # Title and Description based on all collected data.
+        # e.g., draft_dict["title"], draft_dict["description"] = await _generate_content_with_llm(draft_dict)
+
+    state["draft"] = ListingDraft.parse_obj(draft_dict)
+    
+    return state
+
+# ------------------------------------------------------------------
+# MAIN NODE FUNCTION
+# ------------------------------------------------------------------
 
-            state["status"] = "collecting"
-            state["missing_fields"] = [
-                field for field, result in validation["field_validations"].items()
-                if not result["is_valid"]
-            ]
+async def draft_node(state: Dict) -> Dict:
+    logger.info("🔨 Entering draft_node", status=state.get("status"), editing_field=state.get("editing_field"))
+    
+    # 1. Update the draft object from state fields, applying edits if needed
+    state = _update_draft_fields(state)
+    
+    # Check if a specific reply was set during editing or validation
+    if state.get("ai_reply") and state["status"] == "editing":
+        return state # The edit process set a question, return now.
+
+    # 2. Re-extract missing fields for the next step
+    required_fields = ["location", "bedrooms", "bathrooms", "price", "listing_type", "price_type"]
+    missing_fields = [f for f in required_fields if not state.get(f)]
+    state["missing_fields"] = missing_fields
+
+    # 3. Determine Next Action
+    if missing_fields:
+        # Ask for the next required field
+        next_field = missing_fields[0]
+        questions = {
+            "location": "Great! What city is the property located in?",
+            "bedrooms": "How many bedrooms does it have?",
+            "bathrooms": "And how many bathrooms?",
+            "price": "What is the price, and is that monthly, nightly, or yearly?",
+            "listing_type": "Is this for rent, short-stay, or sale?",
+            "price_type": "Please clarify the price type (e.g., monthly, nightly).",
+        }
+        state["ai_reply"] = questions.get(next_field, "I need a little more information to create your listing.")
+        state["status"] = "collecting"
+        logger.info("❓ Asking for missing field", field=next_field)
 
-            logger.warning("🚫 Fields failed ML validation", issues=validation["issues"])
-            return state
+    else:
+        # All required fields are present: generate preview
+        return await _generate_preview_and_ask_publish(state)
 
-        logger.info("✅ All fields passed ML validation", user_id=user_id)
+    return state
 
-    except Exception as e:
-        logger.error("❌ ML validation error", exc_info=e)
-        state["ai_reply"] = "Sorry, I couldn't validate your listing. Please try again."
-        state["status"] = "error"
-        return state
 
-    # Generate title and description
-    title = _generate_title(state)
-    description = _generate_description(state)
-    amenities_with_icons = _add_amenity_icons(state.get("amenities", []))
+# ------------------------------------------------------------------
+# PREVIEW GENERATION
+# ------------------------------------------------------------------
 
-    # ✅ Get images from state (if any were uploaded)
-    images = state.get("draft", {}).get("images", []) if isinstance(state.get("draft"), dict) else []
+async def _generate_preview_and_ask_publish(state: Dict) -> Dict:
+    """Generates the final human-readable preview."""
+    
+    draft = state["draft"].dict() # Use the consolidated draft model
+    images = state.get("draft_preview", {}).get("images", []) # Get images from previous state
 
-    # Build draft preview with all fields including images and icons
+    # Create the human-readable preview
     draft_preview = {
-        "title": title,
-        "description": description,
-        "location": state.get("location", "").title(),
-        "bedrooms": state.get("bedrooms"),
-        "bathrooms": state.get("bathrooms"),
-        "price": state.get("price"),
-        "price_type": state.get("price_type"),
-        "listing_type": state.get("listing_type"),
-        "amenities": state.get("amenities", []),
-        "amenities_with_icons": amenities_with_icons,
-        "requirements": state.get("requirements"),
-        "currency": state.get("currency", "XOF"),
-        "images": images,
-        "field_confidences": validation["field_validations"],
+        'title': draft.get('title', _generate_title(draft)),
+        'location': draft['location'],
+        'bedrooms': draft['bedrooms'],
+        'bathrooms': draft['bathrooms'],
+        'price': draft['price'],
+        'price_type': draft['price_type'],
+        'currency': draft['currency'],
+        'description': draft.get('description', 'No description yet.'),
+        'amenities_with_icons': _add_amenity_icons(draft.get('amenities', [])),
+        'images': images,
     }
 
-    logger.info("🎯 Draft preview generated",
-                title=title,
-                location=state.get("location"),
-                image_count=len(images),
-                amenities=state.get("amenities", []))
-
-    # Build nice preview message for user
-    images_section = ""
-    if images:
-        images_section = f"\n📷 Images: {len(images)} uploaded\n"
-        for idx, img_url in enumerate(images[:3], 1):
-            images_section += f"   {idx}. {img_url[:60]}...\n"
-        if len(images) > 3:
-            images_section += f"   ... and {len(images) - 3} more\n"
+    images_section = f"\n🖼️ Images uploaded: {len(images)}" if images else "❌ No images uploaded."
 
     preview_text = f"""
 ┌────────────────────────────────────────────────────────────────────────┐
@@ -198,7 +182,7 @@ Let me ask again - could you clarify these fields?"""
 📍 Location: {draft_preview['location']}
 🛏️ Bedrooms: {draft_preview['bedrooms']}
 🚿 Bathrooms: {draft_preview['bathrooms']}
-💰 Price: {draft_preview['price']:,} {draft_preview['price_type']} ({draft_preview['currency']})
+💰 Price: {draft_preview['price']:,.0f} {draft_preview['price_type']} ({draft_preview['currency']})
 
 {draft_preview['description']}
 
@@ -207,25 +191,24 @@ Let me ask again - could you clarify these fields?"""
 └────────────────────────────────────────────────────────────────────────��
 """
 
-    # ✅ Check if images uploaded, ask if not
+    # Ask for final action
     if not images:
         preview_text += """
-📸 Upload property images to make your listing more attractive!
+📸 **Upload property images** to make your listing more attractive! (Or say 'publish' now)
 
-Then say **publish** to make it live!
+You can also say **'edit the price'** or **'discard'** to start over.
 """
-        state["status"] = "waiting_for_images"  # ✅ Wait for images
+        state["status"] = "waiting_for_images"
     else:
         preview_text += """
-✅ Perfect! Say **publish** to make your listing live!
+✅ Perfect! You can now say **'publish'** to make your listing live!
+
+You can also say **'edit the location'** or **'discard'** to start over.
 """
-        state["status"] = "preview_shown"  # ✅ Ready to publish
+        state["status"] = "preview_shown"
 
     state["draft_preview"] = draft_preview
     state["ai_reply"] = preview_text
 
-    # ------------------------------------------------------------------
-    #  FINAL FLAG – triggers the gate in graph.py
-    # ------------------------------------------------------------------
-    state["status"] = "preview_shown"
+    logger.info("📢 Draft preview generated", status=state["status"])
     return state

app/ai/nodes/edit_node.py

@@ -10,7 +10,7 @@ _KEYWORDS_MAP = {
     "bedrooms":   {"bedroom", "chambre", "piece", "pièce"},
     "bathrooms":  {"bathroom", "salle de bain", "toilet", "douche"},
     "amenities":  {"amenity", "equipment", "équipement", "wifi", "parking"},
-    "requirements":{"requirement", "condition", "exigence"},
+    "requirements": {"requirement", "condition", "exigence"},
 }
 
 def _detect_field_to_edit(text: str) -> str | None:
@@ -30,8 +30,7 @@ async def edit_node(state: Dict) -> Dict:
         state["ai_reply"]      = f"Quelle est la nouvelle valeur pour **{field}** ?"
     else:
         state["status"]   = "editing"
-        state["ai_reply"] = ("Que souhaitez-vous modifier ?  \n"
-                             "– location  \n– price  \n– bedrooms  \n– bathrooms  \n"
-                             "– amenities  \n– requirements")
-    logger.info("📝 Edit requested", field=field)
+        state["ai_reply"] = "Quel champ souhaitez-vous modifier ? (par ex. 'price', 'location', etc.)"
+        
+    logger.info("✏️ Draft edit requested", field=field)
     return state

app/ai/nodes/intent_node.py

@@ -1,4 +1,4 @@
-# app/ai/nodes/intent_node.py – COMPLETE FILE
+# app/ai/nodes/intent_node.py – COMPLETE FILE (with command-lock & language-lock)
 import json, re, os
 from typing import Dict, List
 from tenacity import retry, stop_after_attempt, wait_exponential
@@ -41,15 +41,13 @@ def _get_next_question(missing: List[str]) -> str | None:
 # ---------- system prompt ----------
 _SYSTEM_PROMPT_PATH = os.path.join(os.path.dirname(__file__), "../prompts/system_prompt.txt")
 with open(_SYSTEM_PROMPT_PATH, encoding="utf-8") as f:
-    SYSTEM_PROMPT = f.read()
+    SYSTEM_PROMPT_RAW = f.read()
 
 # ---------- dynamic example ----------
-async def _generate_complete_example_in_user_language(human_msg: str) -> str:
+async def _generate_complete_example_in_user_language(human_msg: str, lang: str) -> str:
     prompt = f"""
 You are Aida, Lojiz's real-estate assistant.  The user wants to list a property.
-Generate a SHORT property listing example in the EXACT SAME LANGUAGE as this message: "{human_msg}"
-
-IMPORTANT: respond ENTIRELY in that language.  Every word must be in the user's language.
+Generate a SHORT property listing example in {lang.upper()}.  
 The example must briefly contain:
 - location (city/area)
 - bedrooms & bathrooms
@@ -62,7 +60,7 @@ Keep it SHORT – 2 sentences, conversational.
 Use a DIFFERENT, natural introductory phrase each time (vary it).
 
 Output format (nothing else):
-[Natural intro in user's language]
+[Natural intro in {lang}]
 
 📍 **Example:**  
 "[2-sentence listing with all fields]"
@@ -77,9 +75,19 @@ Output format (nothing else):
         return resp.choices[0].message.content.strip()
     except Exception as e:
         logger.warning("⚠️ Example generation failed", exc_info=e)
-        # ultra-short fallback – still in user’s language (model will detect)
         return "📍 **Example:**  \n\"Bel appartement 2 chambres, 1 salle de bain à Cotonou, avec wifi et parking.  50 000 F CFA par mois, 1 mois de caution requis.\""
 
+# ---------- language detector ----------
+def _detect_language(msg: str) -> str:
+    msg_l = msg.lower()
+    if any(w in msg_l for w in {"français", "bonjour", "prix", "loyer", "salut", "appartement"}):
+        return "french"
+    if any(w in msg_l for w in {"hola", "precio", "alquiler", "casa", "habitación"}):
+        return "spanish"
+    if any(w in msg_l for w in {"ola", "preço", "aluguel", "casa", "quarto"}):
+        return "portuguese"
+    return "english"
+
 # ---------- main node ----------
 @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=5))
 async def intent_node(state: Dict) -> Dict:
@@ -87,7 +95,40 @@ async def intent_node(state: Dict) -> Dict:
     user_role = state["user_role"]
     human_msg = state["messages"][-1]["content"]
 
-    # ===== 1.  HANDLE ON-GOING EDIT  (language agnostic) =====
+    # ===== 0.  LANGUAGE LOCK (once per conversation) =====
+    if "user_language" not in state:
+        state["user_language"] = _detect_language(human_msg)
+    lang = state["user_language"]
+
+    # ===== 1.  COMMAND CHECK (only when draft is on screen) =====
+    last_msg = human_msg.lower().strip()
+    if state.get("status") == "preview_shown":
+        if any(k in last_msg for k in {"publish", "publier", "confirmer", "go live", "post it", "list it", "yes", "ok", "okay"}):
+            state.update({
+                "intent": "list",
+                "status": "publishing",
+                "ai_reply": "✅ Publishing your listing now..." if lang=="english" else "✅ Publication en cours...",
+            })
+            logger.info("🔒 Command detected: publish")
+            return state
+        if any(k in last_msg for k in {"edit", "modifier", "change", "update", "correction", "fix"}):
+            state.update({
+                "intent": "list",
+                "status": "editing",
+                "ai_reply": "What would you like to change?" if lang=="english" else "Que voulez-vous modifier ?",
+            })
+            logger.info("🔒 Command detected: edit")
+            return state
+        if any(k in last_msg for k in {"discard", "delete", "cancel", "annuler", "remove", "start over"}):
+            state.update({
+                "intent": "list",
+                "status": "discarding",
+                "ai_reply": "Draft cleared. What would you like to do next?" if lang=="english" else "Brouillon supprimé. Que souhaitez-vous faire ensuite ?",
+            })
+            logger.info("🔒 Command detected: discard")
+            return state
+
+    # ===== 2.  HANDLE ON-GOING EDIT  (language agnostic) =====
     if state.get("status") == "editing" and state.get("editing_field"):
         field = state.pop("editing_field")
         new_raw = human_msg
@@ -107,12 +148,14 @@ async def intent_node(state: Dict) -> Dict:
             state["requirements"] = new_raw.strip()
 
         state["status"]   = "draft_ready"
-        state["ai_reply"] = "✅ Mis à jour !  Voici la nouvelle pré-visualisation :"  # LLM will override with user language
+        state["ai_reply"] = "✅ Updated! Here’s the new preview:" if lang=="english" else "✅ Mis à jour ! Voici la nouvelle pré-visualisation :"
         return state
     # ============================================================
 
+    # ===== 3.  NORMAL INTENT PARSING =====
+    SYSTEM_PROMPT = SYSTEM_PROMPT_RAW.replace("{user_role}", user_role) + f"\nRespond entirely in {lang}."
     messages = [
-        {"role": "system", "content": SYSTEM_PROMPT.replace("{user_role}", user_role)},
+        {"role": "system", "content": SYSTEM_PROMPT},
         {"role": "user",   "content": human_msg},
     ]
     logger.info("🤖 Aida intent call", user_role=user_role, msg=human_msg[:80])
@@ -148,7 +191,7 @@ async def intent_node(state: Dict) -> Dict:
                 "next_question": _get_next_question(missing),
             })
             if should_show_example:
-                dynamic_example = await _generate_complete_example_in_user_language(human_msg)
+                dynamic_example = await _generate_complete_example_in_user_language(human_msg, lang)
                 data["ai_reply"] = dynamic_example
             else:
                 data["ai_reply"] = _get_next_question(missing)
@@ -156,7 +199,7 @@ async def intent_node(state: Dict) -> Dict:
             data.update({
                 "status": "checking_optional",
                 "missing_fields": [],
-                "ai_reply": "Perfect! Any amenities or special requirements?",
+                "ai_reply": "Perfect! Any amenities or special requirements?" if lang=="english" else "Parfait ! Des équipements ou exigences particulières ?",
             })
 
     # ---------- search ----------

app/ai/quota/quota_manager.py

@@ -0,0 +1,135 @@
+# app/ai/quota/quota_manager.py - Track daily listing & search quota
+import json
+from datetime import datetime, timedelta
+from typing import Dict, Tuple
+from app.ai.config import redis_client
+from structlog import get_logger
+
+logger = get_logger(__name__)
+
+class QuotaManager:
+    """Manage daily quota for listings and searches"""
+    
+    # Quota limits (per day)
+    FREE_LISTING_QUOTA = 3
+    FREE_SEARCH_QUOTA = 10
+    PREMIUM_LISTING_QUOTA = float('inf')
+    PREMIUM_SEARCH_QUOTA = float('inf')
+    
+    @staticmethod
+    def _get_quota_key(user_id: str, quota_type: str) -> str:
+        """Generate Redis key for quota tracking"""
+        today = datetime.utcnow().strftime("%Y-%m-%d")
+        return f"quota:{user_id}:{quota_type}:{today}"
+    
+    @staticmethod
+    def _get_ttl_seconds() -> int:
+        """Get seconds until end of day (UTC)"""
+        now = datetime.utcnow()
+        tomorrow = now + timedelta(days=1)
+        end_of_day = tomorrow.replace(hour=0, minute=0, second=0, microsecond=0)
+        return int((end_of_day - now).total_seconds())
+    
+    @staticmethod
+    async def check_listing_quota(user_id: str, subscription_type: str) -> Tuple[bool, Dict]:
+        """
+        Check if user can create another listing today
+        Returns: (allowed: bool, info: Dict with current_count and limit)
+        """
+        quota_key = QuotaManager._get_quota_key(user_id, "listings")
+        
+        # Get current count
+        current_count = await redis_client.get(quota_key)
+        current_count = int(current_count) if current_count else 0
+        
+        # Determine limit based on subscription
+        if subscription_type == "premium":
+            limit = QuotaManager.PREMIUM_LISTING_QUOTA
+            allowed = True
+        else:
+            limit = QuotaManager.FREE_LISTING_QUOTA
+            allowed = current_count < limit
+        
+        info = {
+            "current_count": current_count,
+            "limit": limit,
+            "remaining": limit - current_count if limit != float('inf') else float('inf'),
+            "allowed": allowed
+        }
+        
+        logger.info("🔍 Listing quota check", user_id=user_id, 
+                   subscription=subscription_type, current=current_count, limit=limit)
+        
+        return allowed, info
+    
+    @staticmethod
+    async def increment_listing_quota(user_id: str) -> None:
+        """Increment listing count for today"""
+        quota_key = QuotaManager._get_quota_key(user_id, "listings")
+        ttl = QuotaManager._get_ttl_seconds()
+        
+        # Increment and set expiry
+        await redis_client.incr(quota_key)
+        await redis_client.expire(quota_key, ttl)
+        
+        current = await redis_client.get(quota_key)
+        logger.info("📝 Listing quota incremented", user_id=user_id, current_count=int(current))
+    
+    @staticmethod
+    async def check_search_quota(user_id: str, subscription_type: str) -> Tuple[bool, Dict]:
+        """
+        Check if user can perform another search today
+        Returns: (allowed: bool, info: Dict with current_count and limit)
+        """
+        quota_key = QuotaManager._get_quota_key(user_id, "searches")
+        
+        # Get current count
+        current_count = await redis_client.get(quota_key)
+        current_count = int(current_count) if current_count else 0
+        
+        # Determine limit based on subscription
+        if subscription_type == "premium":
+            limit = QuotaManager.PREMIUM_SEARCH_QUOTA
+            allowed = True
+        else:
+            limit = QuotaManager.FREE_SEARCH_QUOTA
+            allowed = current_count < limit
+        
+        info = {
+            "current_count": current_count,
+            "limit": limit,
+            "remaining": limit - current_count if limit != float('inf') else float('inf'),
+            "allowed": allowed
+        }
+        
+        logger.info("🔍 Search quota check", user_id=user_id, 
+                   subscription=subscription_type, current=current_count, limit=limit)
+        
+        return allowed, info
+    
+    @staticmethod
+    async def increment_search_quota(user_id: str) -> None:
+        """Increment search count for today"""
+        quota_key = QuotaManager._get_quota_key(user_id, "searches")
+        ttl = QuotaManager._get_ttl_seconds()
+        
+        # Increment and set expiry
+        await redis_client.incr(quota_key)
+        await redis_client.expire(quota_key, ttl)
+        
+        current = await redis_client.get(quota_key)
+        logger.info("🔎 Search quota incremented", user_id=user_id, current_count=int(current))
+    
+    @staticmethod
+    async def get_quota_status(user_id: str, subscription_type: str) -> Dict:
+        """Get complete quota status for user"""
+        listing_allowed, listing_info = await QuotaManager.check_listing_quota(user_id, subscription_type)
+        search_allowed, search_info = await QuotaManager.check_search_quota(user_id, subscription_type)
+        
+        return {
+            "listings": listing_info,
+            "searches": search_info,
+            "can_list": listing_allowed,
+            "can_search": search_allowed,
+            "subscription_type": subscription_type
+        }

app/ai/state.py

@@ -1,4 +1,4 @@
-# app/ai/state.py – COMPLETE
+# app/ai/state.py - FIXED WITH ML FIELDS
 from typing import TypedDict, List, Optional, Dict, Any
 from pydantic import BaseModel, Field
 from datetime import datetime
@@ -9,14 +9,16 @@ class PyObjectId(str):
     @classmethod
     def __get_validators__(cls):
         yield cls.validate
+
     @classmethod
     def validate(cls, v):
         if not ObjectId.is_valid(v):
             raise ValueError("Invalid ObjectId")
         return str(v)
 
-# ---------- Mongo shape ----------
+# ---------- models ----------
 class ListingDraft(BaseModel):
+    """Pure MongoDB shape (source of truth)"""
     id: Optional[PyObjectId] = Field(default_factory=PyObjectId, alias="_id")
     owner_id: str
     type: str  # rent | short_stay | roommate | sale
@@ -30,71 +32,75 @@ class ListingDraft(BaseModel):
     amenities: List[str] = []
     requirements: Optional[str] = None
     currency: str = "XOF"
-    images: List[str] = []
-    status: str = "draft"
+    images: List[str] = []  # ✅ NEW: Cloudflare image URLs
+    status: str = "draft"  # draft | published
     created_at: datetime = Field(default_factory=datetime.utcnow)
     updated_at: datetime = Field(default_factory=datetime.utcnow)
-    views: int = 0
-    favorites: int = 0
+    views: int = 0  # ✅ NEW: View counter
+    favorites: int = 0  # ✅ NEW: Favorites counter
 
     class Config:
         populate_by_name = True
         json_encoders = {ObjectId: str}
 
 class VectorMeta(BaseModel):
-    mongo_id: str
-    embedding: List[float]
+    """What we push to Qdrant (search-only)"""
+    mongo_id: str  # same _id as Mongo
+    embedding: List[float]  # 1536-dim vector
     location: str
     price: float
     bedrooms: Optional[int] = None
     price_type: str
 
-# ========== LangGraph state ==========
+# ========== LangGraph state with ML fields ==========
 class ChatState(TypedDict):
-    # --- core ---
+    # ========== Core Fields ==========
     user_id: str
     user_role: str  # landlord | renter
-    messages: List[dict]
+    messages: List[dict]  # chat history
     draft: Optional[ListingDraft]
-    vector_meta: Optional[VectorMeta]
+    vector_meta: Optional[VectorMeta]  # for hybrid search
     allowed: bool
     ai_reply: str
-    status: Optional[str]
-
-    # --- search filters ---
+    # ✅ Note: "intent" is passed through messages but NOT stored as state field
+    # This avoids LangGraph node name conflicts
+    status: Optional[str]  # collecting | draft_ready | preview_shown | published | error
+    
+    # ========== Search filters (from LLM) ==========
     location: Optional[str]
     min_price: Optional[float]
     max_price: Optional[float]
     bedrooms: Optional[int]
     bathrooms: Optional[int]
     amenities: List[str]
-
-    # --- listing creation ---
-    listing_type: Optional[str]
+    
+    # ========== Listing creation fields (from LLM) ==========
+    listing_type: Optional[str]  # rent | short_stay | sale | roommate
     price: Optional[float]
-    price_type: Optional[str]
+    price_type: Optional[str]  # monthly | nightly | yearly | daily | weekly
     currency: str
     requirements: Optional[str]
-
-    # --- flow helpers ---
+    
+    # ========== Collection Flow ==========
     missing_fields: List[str]
     next_question: Optional[str]
+    
+    # ========== Search results ==========
     search_query: Optional[str]
     search_results: Optional[List[dict]]
     suggestions: Optional[List[dict]]
+    
+    # ========== Image upload ==========
     image: Optional[Dict[str, str]]  # {mime, data}
-
-    # --- ML fields ---
-    field_validations: Optional[Dict[str, Dict]]
-    field_confidences: Optional[Dict[str, float]]
-    location_details: Optional[Dict[str, Any]]
-    validation_suggestions: Optional[List[str]]
-    listing_confidence: Optional[float]
-    currency_confidence: Optional[float]
-
-    # --- draft & publish ---
+    
+    # ========== ML Fields (NEW - for validation & inference) ==========
+    field_validations: Optional[Dict[str, Dict]]  # {field: {is_valid, confidence, suggestion}}
+    field_confidences: Optional[Dict[str, float]]  # {field: confidence_score}
+    location_details: Optional[Dict[str, Any]]  # {city, country, lat, lon, country_code}
+    validation_suggestions: Optional[List[str]]  # ["✅ field: suggestion"]
+    listing_confidence: Optional[float]  # Confidence for inferred listing_type
+    currency_confidence: Optional[float]  # Confidence for inferred currency
+    
+    # ========== Draft & Publishing ==========
     draft_preview: Optional[Dict]
-    mongo_id: Optional[str]
-
-    # --- NEW: editing ---
-    editing_field: Optional[str]
+    mongo_id: Optional[str]

debug_flow.py

@@ -0,0 +1,27 @@
+# debug_flow.py
+import asyncio
+from app.ai.service import aida_chat_sync
+
+async def test_flow():
+    user_id = "debug_user"
+    user_role = "landlord"
+    messages = [
+        "I want to list my 2-bedroom apartment in Lagos for 50k monthly",
+        "2 bathrooms",
+        "wifi and parking",
+        "no requirements",
+        "publish"
+    ]
+
+    state = None
+    for msg in messages:
+        print(f"\n[USER]: {msg}")
+        state = await aida_chat_sync(user_id, user_role, msg)
+        print(f"[AIDA]: {state.get('ai_reply')}")
+        print(f"[STATUS]: {state.get('status')}")
+        print(f"[MISSING]: {state.get('missing_fields')}")
+        print(f"[DRAFT]: {state.get('draft_preview') is not None}")
+        print(f"[MONGO_ID]: {state.get('mongo_id')}")
+
+if __name__ == "__main__":
+    asyncio.run(test_flow())