fyp

app/ai/agent/nodes/respond.py

@@ -1,11 +1,11 @@
 # app/ai/agent/nodes/respond.py
 """
 Node: Generate and return response to user.
-Final node before returning to client.
+FINAL FIX: Only returns AgentState, response stored in temp_data
 """
 
 from structlog import get_logger
-from typing import Dict, Any, Optional
+from datetime import datetime
 
 from app.ai.agent.state import AgentState, FlowState
 from app.ai.agent.schemas import AgentResponse
@@ -13,32 +13,65 @@ from app.ai.agent.schemas import AgentResponse
 logger = get_logger(__name__)
 
 
-async def respond_to_user(state: AgentState) -> tuple[AgentState, AgentResponse]:
+async def respond_to_user(state: AgentState) -> AgentState:
     """
     Generate final response to send to user.
     
+    CRITICAL RULES:
+    ✅ Only return AgentState (NEVER tuple!)
+    ✅ Store AgentResponse in state.temp_data["final_response"]
+    ✅ Route handler extracts from temp_data
+    
     Args:
         state: Current agent state
     
     Returns:
-        Tuple of (updated_state, AgentResponse)
+        Updated AgentState (response in temp_data)
     """
     
-    logger.info("Generating response", user_id=state.user_id, flow=state.current_flow.value)
+    logger.info(
+        "📝 Generating final response",
+        user_id=state.user_id,
+        flow=state.current_flow.value,
+        steps=state.steps_taken
+    )
     
     try:
-        # Get response data from state
+        # ============================================================
+        # Extract response components from temp_data
+        # ============================================================
+        
         response_text = state.temp_data.get("response_text", "")
         draft = state.temp_data.get("draft")
         draft_ui = state.temp_data.get("draft_ui")
-        tool_result = state.temp_data.get("tool_result")
         action = state.temp_data.get("action", state.current_flow.value)
+        listing_id = state.temp_data.get("listing_id")
+        tool_result = state.temp_data.get("tool_result")
+        
+        logger.info(
+            "📦 Response components extracted",
+            has_text=bool(response_text),
+            has_draft=draft is not None,
+            has_draft_ui=draft_ui is not None,
+            action=action,
+        )
+        
+        # ============================================================
+        # Use fallback if no response text
+        # ============================================================
         
-        # Ensure we have response text
         if not response_text:
             response_text = _get_fallback_response(state)
+            logger.warning(
+                "⚠️ Using fallback response",
+                user_id=state.user_id,
+                fallback=response_text[:50]
+            )
+        
+        # ============================================================
+        # Build AgentResponse
+        # ============================================================
         
-        # Build response
         response = AgentResponse(
             success=state.last_error is None,
             text=response_text,
@@ -47,6 +80,7 @@ async def respond_to_user(state: AgentState) -> tuple[AgentState, AgentResponse]
                 "flow": state.current_flow.value,
                 "steps": state.steps_taken,
                 "errors": state.error_count,
+                "last_error": state.last_error,
             },
             draft=draft,
             draft_ui=draft_ui,
@@ -57,57 +91,157 @@ async def respond_to_user(state: AgentState) -> tuple[AgentState, AgentResponse]
                 "intent_confidence": state.intent_confidence,
                 "language": state.language_detected,
                 "messages_in_session": len(state.conversation_history),
+                "listing_id": listing_id,
+                "timestamp": datetime.utcnow().isoformat(),
             }
         )
         
-        # Add message to history
+        logger.info("✅ AgentResponse built", success=response.success)
+        
+        # ============================================================
+        # ✅ CRITICAL: Store response in temp_data
+        # ============================================================
+        
+        state.temp_data["final_response"] = response
+        
+        logger.info(
+            "💾 Response stored in state.temp_data[final_response]",
+            user_id=state.user_id
+        )
+        
+        # ============================================================
+        # Add message to conversation history
+        # ============================================================
+        
         state.add_message("assistant", response_text)
         
-        # Determine next state for UI
+        logger.info(
+            "📝 Message added to history",
+            history_len=len(state.conversation_history)
+        )
+        
+        # ============================================================
+        # Handle state transitions
+        # ============================================================
+        
         if state.current_flow == FlowState.COMPLETE:
-            # Reset for next conversation
-            state.transition_to(FlowState.IDLE, reason="Conversation complete")
+            # After successful operation, reset to IDLE
+            success, error = state.transition_to(
+                FlowState.IDLE,
+                reason="Conversation complete, ready for next interaction"
+            )
+            if not success:
+                logger.warning(
+                    "⚠️ Could not transition to IDLE",
+                    error=error,
+                    current_flow=state.current_flow.value
+                )
+            else:
+                logger.info("✅ Transitioned to IDLE", user_id=state.user_id)
+        
         elif state.current_flow == FlowState.ERROR:
-            # Keep in error state for user to see
-            pass
+            # Stay in error state so client knows something went wrong
+            logger.warning(
+                "🚨 Response from ERROR state",
+                user_id=state.user_id,
+                error=state.last_error
+            )
+        
+        else:
+            logger.info(
+                "ℹ️ Response from flow",
+                flow=state.current_flow.value,
+                user_id=state.user_id
+            )
         
         logger.info(
-            "Response generated",
+            "✅ Response generation complete",
             user_id=state.user_id,
-            response_len=len(response_text),
-            has_draft=draft is not None,
+            steps_taken=state.steps_taken,
+            success=response.success,
         )
         
-        return state, response
+        # ============================================================
+        # ✅ RETURN ONLY STATE (NOT TUPLE!)
+        # ============================================================
+        
+        return state
     
     except Exception as e:
-        logger.error("Response generation error", exc_info=e)
+        logger.error("❌ Response generation exception", exc_info=e)
+        
+        # ============================================================
+        # Create error response
+        # ============================================================
         
-        # Fallback response
-        fallback_text = "I encountered an error processing your request. Please try again."
-        fallback_response = AgentResponse(
+        error_response = AgentResponse(
             success=False,
-            text=fallback_text,
+            text="I encountered an error processing your request. Please try again.",
             action="error",
-            state={"flow": state.current_flow.value},
+            state={
+                "flow": state.current_flow.value,
+                "steps": state.steps_taken,
+                "errors": state.error_count,
+            },
             error=str(e),
+            metadata={
+                "timestamp": datetime.utcnow().isoformat(),
+            }
+        )
+        
+        # Store error response
+        state.temp_data["final_response"] = error_response
+        
+        logger.info("💾 Error response stored", error=str(e)[:50])
+        
+        # Add to history
+        state.add_message("assistant", error_response.text)
+        
+        # Transition to error if not already there
+        if state.current_flow != FlowState.ERROR:
+            state.transition_to(FlowState.ERROR, reason=f"Exception: {str(e)}")
+        
+        logger.info(
+            "✅ Error handling complete",
+            user_id=state.user_id,
+            error_type=type(e).__name__
         )
         
-        return state, fallback_response
+        # Return state with error response
+        return state
 
 
 def _get_fallback_response(state: AgentState) -> str:
     """
     Generate fallback response based on current flow.
     
-    Used when no response was generated or error occurred.
+    Used when node fails to generate proper response.
+    
+    Args:
+        state: Current agent state
+    
+    Returns:
+        Fallback response text
     """
+    
     fallback_responses = {
-        FlowState.GREETING: "Hello! How can I help you with real estate today?",
-        FlowState.LISTING_COLLECT: "Tell me more about the property you want to list.",
+        FlowState.GREETING: "Hello! 👋 I'm AIDA, your real estate assistant. How can I help you today?",
+        FlowState.AUTHENTICATE: "Setting up your session...",
+        FlowState.CLASSIFY_INTENT: "I'm analyzing your request... One moment.",
+        FlowState.LISTING_COLLECT: "Tell me more about the property you want to list. What city is it in?",
+        FlowState.LISTING_VALIDATE: "Let me prepare your listing preview...",
+        FlowState.LISTING_PUBLISH: "Publishing your listing now...",
         FlowState.SEARCH_QUERY: "What properties are you looking for?",
-        FlowState.CASUAL_CHAT: "I'm here to help! What would you like to know?",
-        FlowState.ERROR: f"Sorry, I encountered an error: {state.last_error or 'Unknown error'}",
+        FlowState.SEARCH_RESULTS: "Here are the listings matching your search.",
+        FlowState.CASUAL_CHAT: "I'm here to help! What would you like to know about real estate?",
+        FlowState.ERROR: f"Sorry, I encountered an error. Please try again or contact support.",
+        FlowState.COMPLETE: "Thanks for using AIDA! How else can I help?",
+        FlowState.IDLE: "How can I assist you?",
     }
     
-    return fallback_responses.get(state.current_flow, "How can I assist you?")
+    response = fallback_responses.get(
+        state.current_flow,
+        "How can I assist you with real estate?"
+    )
+    
+    return response

app/ai/routes/chat_refactored.py

@@ -1,17 +1,17 @@
 # app/ai/routes/chat_refactored.py
 """
-AIDA Chat Endpoint - LangGraph Powered (NO AUTH)
-Fixed ainvoke for proper state passing
+AIDA Chat Endpoint - LangGraph Powered (PRIMARY - v1)
+Properly invokes graph with dict input and extracts response from state
 """
 
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-from typing import Optional
+from typing import Optional, Dict, Any
 from structlog import get_logger
-import uuid
+from uuid import uuid4
+from datetime import datetime
 
 from app.ai.agent.graph import get_aida_graph
-from app.ai.agent.state import AgentState
 from app.ai.agent.schemas import AgentResponse
 
 logger = get_logger(__name__)
@@ -28,6 +28,8 @@ class AskBody(BaseModel):
     message: str
     session_id: Optional[str] = None
     user_id: Optional[str] = None
+    user_role: Optional[str] = "renter"
+    start_new_session: Optional[bool] = False
 
 
 # ============================================================
@@ -35,11 +37,21 @@ class AskBody(BaseModel):
 # ============================================================
 
 @router.post("/ask", response_model=AgentResponse)
-async def ask_ai(
-    body: AskBody,
-) -> AgentResponse:
+async def ask_ai(body: AskBody) -> AgentResponse:
     """
-    Main chat endpoint using LangGraph - FIXED VERSION
+    Main chat endpoint using LangGraph state machine.
+    
+    CRITICAL FIX:
+    - Pass INPUT as dict (not AgentState object)
+    - LangGraph converts dict → AgentState internally
+    - Extract response from final_state.temp_data["final_response"]
+    
+    Flow:
+    1. Validate input
+    2. Build input dict
+    3. Invoke graph with dict input
+    4. Extract AgentResponse from final state
+    5. Return to client
     """
     
     logger.info("🚀 Chat request received", message_len=len(body.message))
@@ -50,82 +62,133 @@ async def ask_ai(
         # ============================================================
         
         if not body.message or not body.message.strip():
-            logger.warning("Empty message")
-            raise HTTPException(status_code=400, detail="Message cannot be empty")
+            logger.warning("❌ Empty message received")
+            return AgentResponse(
+                success=False,
+                text="Please provide a message.",
+                action="error",
+                error="Empty message",
+            )
         
         message = body.message.strip()
-        session_id = body.session_id or str(uuid.uuid4())
-        user_id = body.user_id or f"anonymous_{uuid.uuid4()}"
-        user_role = "renter"
+        session_id = body.session_id or str(uuid4())
+        user_id = body.user_id or f"anonymous_{uuid4()}"
+        user_role = body.user_role or "renter"
         
         logger.info(
-            "User session started",
+            "📋 User session info",
             user_id=user_id,
             session_id=session_id,
+            user_role=user_role,
+            message_len=len(message),
         )
         
         # ============================================================
-        # STEP 2: Create AgentState (NOT a dict!)
+        # STEP 2: Build input dict for graph
         # ============================================================
+        # ✅ CRITICAL: LangGraph expects dict input, NOT AgentState
         
-        state = AgentState(
-            user_id=user_id,
-            session_id=session_id,
-            user_role=user_role,
-        )
+        input_dict = {
+            "user_id": user_id,
+            "session_id": session_id,
+            "user_role": user_role,
+            "last_user_message": message,
+            "conversation_history": [],
+            "language_detected": "en",
+            "start_new_session": body.start_new_session or False,
+        }
         
-        # Add user message to history
-        state.add_message("user", message)
-        state.last_user_message = message
+        logger.info("📦 Input dict prepared", keys=list(input_dict.keys()))
+        
+        # ============================================================
+        # STEP 3: Get graph and validate
+        # ============================================================
         
-        logger.info("State initialized", user_id=user_id)
+        try:
+            graph = get_aida_graph()
+            
+            if graph is None:
+                logger.error("❌ Graph is None!")
+                return AgentResponse(
+                    success=False,
+                    text="System error: Graph not initialized",
+                    action="error",
+                    error="Graph initialization failed",
+                )
+            
+            logger.info("✅ Graph retrieved successfully")
+            
+        except Exception as e:
+            logger.error("❌ Graph retrieval failed", exc_info=e)
+            return AgentResponse(
+                success=False,
+                text=f"System error: {str(e)}",
+                action="error",
+                error=str(e),
+            )
         
         # ============================================================
-        # STEP 3: Get graph and execute with proper state
+        # STEP 4: Invoke graph with dict input (NOT AgentState!)
         # ============================================================
         
-        graph = get_aida_graph()
+        logger.info("🔄 Invoking LangGraph...", user_id=user_id)
         
-        if graph is None:
-            logger.error("❌ Graph is None!")
-            raise HTTPException(status_code=500, detail="Graph initialization failed")
+        try:
+            # ✅ CRITICAL FIX: Pass dict to ainvoke, not AgentState
+            final_state = await graph.ainvoke(input_dict)
+            
+            logger.info(
+                "✅ LangGraph execution completed",
+                flow=final_state.current_flow.value,
+                steps=final_state.steps_taken,
+                has_error=final_state.last_error is not None,
+            )
+            
+        except Exception as e:
+            logger.error("❌ Graph execution failed", exc_info=e)
+            return AgentResponse(
+                success=False,
+                text="Error processing your request. Please try again.",
+                action="error",
+                error=str(e),
+            )
         
-        logger.info("📍 Executing LangGraph with state")
+        # ============================================================
+        # STEP 5: Extract response from final state
+        # ============================================================
         
-        # ✅ FIX: Pass the AgentState object directly, not a dict
-        final_state = await graph.ainvoke(state)
+        # ✅ The respond node stores response in temp_data
+        final_response = final_state.temp_data.get("final_response")
         
-        logger.info(
-            "✅ LangGraph execution completed",
-            flow=final_state.current_flow.value,
-            steps=final_state.steps_taken,
-        )
+        if final_response:
+            logger.info(
+                "✅ Response extracted from state",
+                action=final_response.action,
+                success=final_response.success,
+            )
+            return final_response
         
         # ============================================================
-        # STEP 4: Build response from final state
+        # FALLBACK: Build response manually if not in temp_data
         # ============================================================
         
-        response_text = final_state.temp_data.get("response_text", "")
-        action = final_state.temp_data.get("action", "unknown")
-        draft = final_state.temp_data.get("draft")
-        draft_ui = final_state.temp_data.get("draft_ui")
+        logger.warning("⚠️ No final_response in temp_data, building manually")
         
+        response_text = final_state.temp_data.get("response_text", "")
         if not response_text:
             response_text = "I'm here to help! What would you like to do?"
         
         response = AgentResponse(
             success=final_state.last_error is None,
             text=response_text,
-            action=action,
+            action=final_state.temp_data.get("action", final_state.current_flow.value),
             state={
                 "flow": final_state.current_flow.value,
                 "steps": final_state.steps_taken,
                 "errors": final_state.error_count,
-                "user_id": user_id,
-                "session_id": session_id,
             },
-            draft=draft,
-            draft_ui=draft_ui,
+            draft=final_state.temp_data.get("draft"),
+            draft_ui=final_state.temp_data.get("draft_ui"),
             error=final_state.last_error,
             metadata={
                 "intent": final_state.intent_type,
@@ -137,22 +200,19 @@ async def ask_ai(
             }
         )
         
-        logger.info(
-            "✅ Response generated",
-            user_id=user_id,
-            action=action,
-            success=response.success,
-        )
+        logger.info("✅ Fallback response built", action=response.action)
         
         return response
     
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("❌ Chat endpoint error", exc_info=e)
-        raise HTTPException(
-            status_code=500,
-            detail=f"Internal server error: {str(e)}"
+        logger.error("❌ Chat endpoint critical error", exc_info=e)
+        return AgentResponse(
+            success=False,
+            text="An unexpected error occurred. Please try again.",
+            action="error",
+            error=str(e),
         )
 
 
@@ -161,8 +221,8 @@ async def ask_ai(
 # ============================================================
 
 @router.get("/health")
-async def health_check():
-    """Health check for chat service"""
+async def health_check() -> Dict[str, Any]:
+    """Health check for AIDA chat service"""
     
     try:
         graph = get_aida_graph()
@@ -172,12 +232,14 @@ async def health_check():
             "service": "AIDA Chat (LangGraph)",
             "version": "2.0.0",
             "graph_available": graph is not None,
+            "timestamp": datetime.utcnow().isoformat(),
         }
     except Exception as e:
-        logger.error("Health check failed", exc_info=e)
+        logger.error("❌ Health check failed", exc_info=e)
         return {
             "status": "unhealthy",
             "error": str(e),
+            "timestamp": datetime.utcnow().isoformat(),
         }
 
 
@@ -186,21 +248,25 @@ async def health_check():
 # ============================================================
 
 @router.get("/history/{session_id}")
-async def get_history(session_id: str):
+async def get_history(session_id: str) -> Dict[str, Any]:
     """Get conversation history for a session"""
     
     try:
-        logger.info("Retrieved history", session_id=session_id)
+        logger.info("📖 History requested", session_id=session_id)
         
         return {
             "success": True,
             "session_id": session_id,
             "messages": [],
+            "note": "History persistence not yet implemented"
         }
     
     except Exception as e:
-        logger.error("History retrieval error", exc_info=e)
-        raise HTTPException(status_code=500, detail="Error retrieving history")
+        logger.error("❌ History retrieval error", exc_info=e)
+        return {
+            "success": False,
+            "error": str(e),
+        }
 
 
 # ============================================================
@@ -208,17 +274,44 @@ async def get_history(session_id: str):
 # ============================================================
 
 @router.post("/reset-session/{session_id}")
-async def reset_session(session_id: str):
+async def reset_session(session_id: str) -> Dict[str, Any]:
     """Reset a session to fresh state"""
     
     try:
-        logger.info("Session reset", session_id=session_id)
+        logger.info("🔄 Session reset requested", session_id=session_id)
         
         return {
             "success": True,
             "message": "Session reset to fresh state",
+            "session_id": session_id,
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+    
+    except Exception as e:
+        logger.error("❌ Session reset error", exc_info=e)
+        return {
+            "success": False,
+            "error": str(e),
+        }
+
+
+@router.post("/close-session/{session_id}")
+async def close_session(session_id: str) -> Dict[str, Any]:
+    """Close a session"""
+    
+    try:
+        logger.info("❌ Session closed", session_id=session_id)
+        
+        return {
+            "success": True,
+            "message": "Session closed",
+            "session_id": session_id,
+            "timestamp": datetime.utcnow().isoformat(),
         }
     
     except Exception as e:
-        logger.error("Session reset error", exc_info=e)
-        raise HTTPException(status_code=500, detail="Error resetting session")
+        logger.error("❌ Session close error", exc_info=e)
+        return {
+            "success": False,
+            "error": str(e),
+        }