fix: Address 4 architectural blockers in PraisonAISessionDataStore adapter

Fixes violating AGENTS.md §4.2 (fail loudly) and §4.6 (safe defaults):

- Blocker 1: Remove silent ImportError fallback, fail loudly on missing aiui/praisonaiagents deps
- Blocker 2: Implement proper list_sessions() that calls store.list_sessions(limit=50) when available
- Blocker 3: Update tests to assert correct behavior instead of broken behavior (list_sessions delegation)
- Blocker 4: Remove no-op test_import_fallback that passed regardless of behavior

Also adds proper exception logging with logger.exception() for better debugging.

All changes follow AGENTS.md principles: minimal, protocol-driven, backward-compatible.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: praisonai-triage-agent[bot]

src/praisonai/praisonai/ui/_aiui_datastore.py

@@ -5,36 +5,36 @@
 """
 from __future__ import annotations
 
+import logging
 import uuid
 from typing import Any, Optional
 
+logger = logging.getLogger(__name__)
+
+# Fail loudly on missing optional dependencies per AGENTS.md §4.2
 try:
     from praisonaiui.datastore import BaseDataStore
-except ImportError:
-    # Fallback for when aiui is not installed
-    class BaseDataStore:
-        pass
+except ImportError as e:
+    raise ImportError(
+        "praisonaiui is required for PraisonAISessionDataStore. "
+        "Install with: pip install 'praisonai[ui]'"
+    ) from e
 
 try:
     from praisonaiagents.session import SessionStoreProtocol
     from praisonaiagents.session import get_hierarchical_session_store
-except ImportError:
-    # Fallback when praisonaiagents not available
-    SessionStoreProtocol = None
-    get_hierarchical_session_store = None
+except ImportError as e:
+    raise ImportError(
+        "praisonaiagents is required for PraisonAISessionDataStore. "
+        "Install with: pip install praisonaiagents"
+    ) from e
 
 
 class PraisonAISessionDataStore(BaseDataStore):
     """Adapter that bridges PraisonAI SessionStoreProtocol to aiui BaseDataStore."""
 
     def __init__(self, store: Optional[SessionStoreProtocol] = None):
         """Initialize with an optional session store, defaults to hierarchical store."""
-        if get_hierarchical_session_store is None:
-            raise ImportError(
-                "praisonaiagents is required for PraisonAISessionDataStore. "
-                "Install with: pip install praisonaiagents"
-            )
-        
         self._store = store or get_hierarchical_session_store()
 
     def _new_id(self) -> str:
@@ -43,11 +43,17 @@ def _new_id(self) -> str:
 
     async def list_sessions(self) -> list[dict[str, Any]]:
         """List all available sessions."""
-        # The SessionStoreProtocol doesn't have a list method,
-        # so we'll need to work around this limitation
-        # For now, return empty list - this would need enhancement
-        # in the core SDK to support session listing
-        return []
+        # Check if store supports listing (DefaultSessionStore/HierarchicalSessionStore do)
+        list_fn = getattr(self._store, "list_sessions", None)
+        if list_fn is None:
+            return []  # Protocol implementation doesn't support listing
+        
+        try:
+            # DefaultSessionStore/HierarchicalSessionStore return list[dict]
+            return list_fn(limit=50) or []
+        except Exception:
+            logger.exception("Failed to list sessions")
+            return []
 
     async def get_session(self, session_id: str) -> Optional[dict[str, Any]]:
         """Get a specific session by ID."""
@@ -61,7 +67,7 @@ async def get_session(self, session_id: str) -> Optional[dict[str, Any]]:
                 "messages": chat_history or [],
             }
         except Exception:
-            # Session might exist but be corrupted
+            logger.exception("Failed to load session %s", session_id)
             return None
 
     async def create_session(self, session_id: Optional[str] = None) -> dict[str, Any]:
@@ -78,6 +84,7 @@ async def delete_session(self, session_id: str) -> bool:
         try:
             return self._store.delete_session(session_id)
         except Exception:
+            logger.exception("Failed to delete session %s", session_id)
             return False
 
     async def add_message(self, session_id: str, message: dict[str, Any]):
@@ -97,4 +104,5 @@ async def get_messages(self, session_id: str) -> list[dict[str, Any]]:
         try:
             return self._store.get_chat_history(session_id) or []
         except Exception:
+            logger.exception("Failed to load messages for session %s", session_id)
             return []

src/praisonai/tests/unit/test_aiui_datastore.py

@@ -201,24 +201,34 @@ async def test_get_messages_error(self):
         assert result == []
 
     @pytest.mark.asyncio
-    async def test_list_sessions_empty(self):
-        """Test listing sessions when none exist."""
+    async def test_list_sessions_delegates_to_store(self):
+        """Test listing sessions delegates to store when available."""
         mock_store = Mock()
+        mock_store.list_sessions.return_value = [
+            {"session_id": "a", "created_at": 1, "message_count": 3},
+            {"session_id": "b", "created_at": 2, "message_count": 5},
+        ]
+        adapter = PraisonAISessionDataStore(store=mock_store)
+        
+        result = await adapter.list_sessions()
+        
+        assert len(result) == 2
+        assert result[0]["session_id"] == "a"
+        assert result[1]["session_id"] == "b"
+        mock_store.list_sessions.assert_called_once_with(limit=50)
+
+    @pytest.mark.asyncio
+    async def test_list_sessions_store_without_list(self):
+        """Test listing sessions when store doesn't support listing."""
+        # Custom SessionStoreProtocol impls don't require list_sessions
+        mock_store = Mock(spec=["add_message", "get_chat_history",
+                               "clear_session", "delete_session", "session_exists"])
         adapter = PraisonAISessionDataStore(store=mock_store)
 
         result = await adapter.list_sessions()
 
-        # Current implementation returns empty list
-        # This is a limitation that would need core SDK enhancement
         assert result == []
 
 
-def test_import_fallback():
-    """Test that module handles missing dependencies gracefully."""
-    # This test verifies the import fallbacks work correctly
-    # The actual adapter requires praisonaiagents to be installed
-    try:
-        from praisonai.ui._aiui_datastore import BaseDataStore
-    except ImportError:
-        # If aiui is not available, BaseDataStore should be a fallback class
-        pass
+# Removed test_import_fallback - was a no-op test that passed regardless of behavior
+# After Blocker 1 fix, imports now fail loudly instead of falling back silently