fyp

app/ai/agent/brain.py

@@ -101,7 +101,7 @@ async def generate_localized_response(
     max_retries: int = 3
 ) -> str:
     """
-    Generate a response using LLM in the specified language with retry logic and caching.
+    Generate a response using LLM in the specified language with retry logic.
 
     This replaces hardcoded messages with dynamic LLM-generated responses
     that respect the user's language preference.
@@ -125,13 +125,9 @@ async def generate_localized_response(
         "Super ! 🎉 Votre annonce a été enregistrée avec succès !"
     """
     import asyncio
-    from app.ai.agent.message_cache import get_cached_message, cache_message
 
-    # Check cache first (reduces LLM calls for common messages)
-    cached = get_cached_message(context, language, tone, max_length)
-    if cached:
-        logger.debug("Using cached message", language=language, context=context[:30])
-        return cached
+    # NOTE: Caching disabled per requirements - always generate fresh responses
+    # This ensures dynamic, context-aware messages every time
 
     language_names = {
         "en": "English",
@@ -173,9 +169,6 @@ Response:"""
             response = await brain_llm.ainvoke([HumanMessage(content=prompt)])
             generated_message = response.content.strip().strip('"')
 
-            # Cache the generated message
-            cache_message(context, language, tone, max_length, generated_message)
-
             return generated_message
         except Exception as e:
             logger.warning(
@@ -185,8 +178,8 @@ Response:"""
             # If this was the last attempt, use generic English fallback
             if attempt == max_retries - 1:
                 logger.error(f"All {max_retries} attempts failed. Using generic English fallback.")
-                # Generic English fallback only (as per user's preference)
-                return "I'm here to help! How can I assist you?"
+                # Generic English fallback (no multilingual fallbacks as per spec)
+                return "Service temporarily unavailable. Please try again."
 
             # Wait before retrying (exponential backoff: 0.5s, 1s, 2s)
             await asyncio.sleep(0.5 * (2 ** attempt))

app/ai/agent/message_cache.py

@@ -1,107 +1,17 @@
 # app/ai/agent/message_cache.py
 """
-Simple in-memory cache for frequently used LLM-generated messages.
-Reduces latency and costs by caching common responses per language.
-"""
-
-import hashlib
-from datetime import datetime, timedelta
-from typing import Optional, Dict
-from structlog import get_logger
-
-logger = get_logger(__name__)
-
-
-class MessageCache:
-    """
-    In-memory cache for LLM-generated messages.
-
-    Cache key format: hash(context + language + tone + max_length)
-    TTL: 24 hours (messages are regenerated daily for freshness)
-    """
-
-    def __init__(self, ttl_hours: int = 24):
-        self._cache: Dict[str, Dict] = {}
-        self._ttl = timedelta(hours=ttl_hours)
-        logger.info("MessageCache initialized", ttl_hours=ttl_hours)
-
-    def _generate_key(self, context: str, language: str, tone: str, max_length: str) -> str:
-        """Generate cache key from parameters."""
-        combined = f"{context}|{language}|{tone}|{max_length}"
-        return hashlib.md5(combined.encode()).hexdigest()
-
-    def get(
-        self,
-        context: str,
-        language: str,
-        tone: str,
-        max_length: str
-    ) -> Optional[str]:
-        """
-        Retrieve cached message if available and not expired.
-
-        Returns:
-            Cached message or None if not found/expired
-        """
-        key = self._generate_key(context, language, tone, max_length)
+DEPRECATED: Message caching has been disabled.
 
-        if key not in self._cache:
-            return None
-
-        entry = self._cache[key]
-
-        # Check if expired
-        if datetime.utcnow() > entry["expires_at"]:
-            del self._cache[key]
-            logger.debug("Cache entry expired", key=key[:8])
-            return None
-
-        logger.debug("Cache hit", key=key[:8], language=language)
-        return entry["message"]
-
-    def set(
-        self,
-        context: str,
-        language: str,
-        tone: str,
-        max_length: str,
-        message: str
-    ):
-        """Store message in cache with expiration."""
-        key = self._generate_key(context, language, tone, max_length)
-
-        self._cache[key] = {
-            "message": message,
-            "created_at": datetime.utcnow(),
-            "expires_at": datetime.utcnow() + self._ttl,
-            "language": language,
-        }
-
-        logger.debug("Cache entry created", key=key[:8], language=language)
-
-    def clear(self):
-        """Clear all cache entries."""
-        count = len(self._cache)
-        self._cache.clear()
-        logger.info("Cache cleared", entries_removed=count)
-
-    def get_stats(self) -> Dict:
-        """Get cache statistics."""
-        total = len(self._cache)
-        expired = sum(
-            1 for entry in self._cache.values()
-            if datetime.utcnow() > entry["expires_at"]
-        )
-
-        return {
-            "total_entries": total,
-            "expired_entries": expired,
-            "active_entries": total - expired,
-        }
+As of 2026-02-16, all LLM responses are generated fresh to ensure:
+1. Dynamic, context-aware messages
+2. No stale cached responses
+3. Accurate language-specific generation
 
+This file is kept as a placeholder to prevent import errors.
+All cache functions are no-ops that do nothing.
+"""
 
-# Global cache instance
-_message_cache = MessageCache(ttl_hours=24)
+from typing import Optional, Dict
 
 
 def get_cached_message(
@@ -110,8 +20,8 @@ def get_cached_message(
     tone: str,
     max_length: str
 ) -> Optional[str]:
-    """Get message from cache."""
-    return _message_cache.get(context, language, tone, max_length)
+    """DEPRECATED: Always returns None (cache disabled)."""
+    return None
 
 
 def cache_message(
@@ -121,15 +31,20 @@ def cache_message(
     max_length: str,
     message: str
 ):
-    """Store message in cache."""
-    _message_cache.set(context, language, tone, max_length, message)
+    """DEPRECATED: No-op (cache disabled)."""
+    pass
 
 
 def clear_message_cache():
-    """Clear all cached messages."""
-    _message_cache.clear()
+    """DEPRECATED: No-op (cache disabled)."""
+    pass
 
 
 def get_cache_stats() -> Dict:
-    """Get cache statistics."""
-    return _message_cache.get_stats()
+    """DEPRECATED: Returns empty stats (cache disabled)."""
+    return {
+        "total_entries": 0,
+        "expired_entries": 0,
+        "active_entries": 0,
+        "status": "DISABLED"
+    }

app/ai/agent/nodes/my_listings.py

@@ -59,7 +59,10 @@ async def my_listings_handler(state: AgentState) -> AgentState:
         
         # Store in state
         state.my_listings = listings
-        
+
+        # CRITICAL: Store listings in temp_data so frontend can render the cards
+        state.temp_data["listings"] = listings
+
         # Generate personalized message using LLM-based function from brain.py
         from app.ai.agent.brain import _generate_my_listings_message
 

pytest.ini

@@ -0,0 +1,17 @@
+[pytest]
+# Pytest configuration for AIDA tests
+
+# Add AIDA directory to Python path
+pythonpath = .
+
+# Test discovery patterns
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+
+# Enable asyncio mode for async tests
+asyncio_mode = auto
+
+# Verbose output by default
+addopts = -v

tests/conftest.py

@@ -0,0 +1,14 @@
+# tests/conftest.py
+"""
+Pytest configuration file.
+
+Sets up Python path so that tests can import from the app module.
+"""
+
+import sys
+import os
+
+# Add the AIDA directory to Python path so 'app' module can be found
+aida_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if aida_dir not in sys.path:
+    sys.path.insert(0, aida_dir)

tests/test_language_refactor.py

@@ -0,0 +1,224 @@
+# tests/test_language_refactor.py
+"""
+Verification tests for the language logic refactoring.
+
+Tests:
+1. _generate_my_listings_message returns a string
+2. Language detection works for "Bonjour" (mocking the LLM response)
+3. Caching is indeed removed (no import errors)
+
+Run with: pytest tests/test_language_refactor.py -v
+"""
+
+import pytest
+import asyncio
+from unittest.mock import AsyncMock, patch, MagicMock
+
+
+class TestCachingRemoved:
+    """Test that caching has been properly disabled."""
+
+    def test_cache_functions_are_noops(self):
+        """Verify cache functions exist but do nothing."""
+        from app.ai.agent.message_cache import (
+            get_cached_message,
+            cache_message,
+            clear_message_cache,
+            get_cache_stats
+        )
+
+        # get_cached_message should always return None
+        result = get_cached_message("test context", "en", "friendly", "short")
+        assert result is None, "get_cached_message should always return None (caching disabled)"
+
+        # cache_message should not raise
+        cache_message("test context", "en", "friendly", "short", "test message")
+
+        # clear_message_cache should not raise
+        clear_message_cache()
+
+        # get_cache_stats should return disabled status
+        stats = get_cache_stats()
+        assert stats.get("status") == "DISABLED" or stats.get("active_entries") == 0
+
+    def test_generate_localized_response_no_cache_import_issues(self):
+        """Verify generate_localized_response can be imported without errors."""
+        try:
+            from app.ai.agent.brain import generate_localized_response
+            assert callable(generate_localized_response)
+        except ImportError as e:
+            pytest.fail(f"Import error: {e}")
+
+
+class TestGenerateMyListingsMessage:
+    """Test the _generate_my_listings_message function."""
+
+    @pytest.mark.asyncio
+    async def test_returns_string_for_empty_listings(self):
+        """Test that empty listings returns a helpful message."""
+        from app.ai.agent.brain import _generate_my_listings_message
+
+        # Mock the LLM call
+        with patch('app.ai.agent.brain.brain_llm') as mock_llm:
+            mock_response = MagicMock()
+            mock_response.content = "You don't have any listings yet! 🏠 Would you like me to help you create your first one?"
+            mock_llm.ainvoke = AsyncMock(return_value=mock_response)
+
+            result = await _generate_my_listings_message(
+                listings=[],
+                language="en",
+                user_name="John"
+            )
+
+            assert isinstance(result, str), "_generate_my_listings_message should return a string"
+            assert len(result) > 0, "Result should not be empty"
+
+    @pytest.mark.asyncio
+    async def test_returns_string_for_listings_with_data(self):
+        """Test that listings with data returns a personalized message."""
+        from app.ai.agent.brain import _generate_my_listings_message
+
+        # Mock the LLM call
+        with patch('app.ai.agent.brain.brain_llm') as mock_llm:
+            mock_response = MagicMock()
+            mock_response.content = "Hey John! 🏠 Here are your 2 listings (1 for rent, 1 for sale). 💡 Tip: Long-press any listing to edit or delete it!"
+            mock_llm.ainvoke = AsyncMock(return_value=mock_response)
+
+            test_listings = [
+                {"_id": "123", "title": "Apartment", "listing_type": "rent"},
+                {"_id": "456", "title": "House", "listing_type": "sale"},
+            ]
+
+            result = await _generate_my_listings_message(
+                listings=test_listings,
+                language="en",
+                user_name="John Doe"
+            )
+
+            assert isinstance(result, str), "_generate_my_listings_message should return a string"
+            assert len(result) > 0, "Result should not be empty"
+
+
+class TestLanguageDetection:
+    """Test language detection in classify_intent."""
+
+    @pytest.mark.asyncio
+    async def test_french_detection_bonjour(self):
+        """Test that 'Bonjour' is detected as French."""
+        from app.ai.agent.state import AgentState
+
+        # Mock the LLM response for classification
+        with patch('app.ai.agent.nodes.classify_intent.llm') as mock_llm:
+            mock_response = MagicMock()
+            mock_response.content = '''
+            {
+                "type": "greeting",
+                "confidence": 0.95,
+                "reasoning": "User greeted in French",
+                "language": "fr",
+                "requires_auth": false,
+                "next_action": "greet"
+            }
+            '''
+            mock_llm.ainvoke = AsyncMock(return_value=mock_response)
+
+            from app.ai.agent.nodes.classify_intent import classify_intent
+
+            # Create minimal state with required fields
+            state = AgentState(
+                user_id="test_user",
+                session_id="test_session",
+                user_role="renter"  # Required field
+            )
+            state.last_user_message = "Bonjour"
+
+            result_state = await classify_intent(state)
+
+            # Verify language was detected
+            assert result_state.language_detected == "fr", \
+                f"Expected language_detected='fr', got '{result_state.language_detected}'"
+
+    @pytest.mark.asyncio
+    async def test_spanish_detection_hola(self):
+        """Test that 'Hola' is detected as Spanish."""
+        from app.ai.agent.state import AgentState
+
+        # Mock the LLM response for classification
+        with patch('app.ai.agent.nodes.classify_intent.llm') as mock_llm:
+            mock_response = MagicMock()
+            mock_response.content = '''
+            {
+                "type": "greeting",
+                "confidence": 0.95,
+                "reasoning": "User greeted in Spanish",
+                "language": "es",
+                "requires_auth": false,
+                "next_action": "greet"
+            }
+            '''
+            mock_llm.ainvoke = AsyncMock(return_value=mock_response)
+
+            from app.ai.agent.nodes.classify_intent import classify_intent
+
+            # Create minimal state with required fields
+            state = AgentState(
+                user_id="test_user",
+                session_id="test_session",
+                user_role="renter"  # Required field
+            )
+            state.last_user_message = "Hola, busco un apartamento"
+
+            result_state = await classify_intent(state)
+
+            # Verify language was detected
+            assert result_state.language_detected == "es", \
+                f"Expected language_detected='es', got '{result_state.language_detected}'"
+
+
+class TestGenerateLocalizedResponse:
+    """Test the generate_localized_response function."""
+
+    @pytest.mark.asyncio
+    async def test_returns_string_on_success(self):
+        """Test that a successful LLM call returns a string."""
+        from app.ai.agent.brain import generate_localized_response
+
+        # Mock the LLM call
+        with patch('app.ai.agent.brain.brain_llm') as mock_llm:
+            mock_response = MagicMock()
+            mock_response.content = "Bienvenue! Comment puis-je vous aider?"
+            mock_llm.ainvoke = AsyncMock(return_value=mock_response)
+
+            result = await generate_localized_response(
+                context="Greet user warmly",
+                language="fr",
+                tone="friendly",
+                max_length="short"
+            )
+
+            assert isinstance(result, str)
+            assert len(result) > 0
+
+    @pytest.mark.asyncio
+    async def test_fallback_on_failure(self):
+        """Test that LLM failure returns generic English fallback."""
+        from app.ai.agent.brain import generate_localized_response
+
+        # Mock the LLM call to fail
+        with patch('app.ai.agent.brain.brain_llm') as mock_llm:
+            mock_llm.ainvoke = AsyncMock(side_effect=Exception("LLM Error"))
+
+            result = await generate_localized_response(
+                context="Greet user warmly",
+                language="fr",
+                tone="friendly",
+                max_length="short",
+                max_retries=1  # Reduce retries for faster test
+            )
+
+            # Should return the fallback message
+            assert result == "Service temporarily unavailable. Please try again."
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])