Fix session state initialization errors and enhance error handling

app.py

@@ -16,8 +16,6 @@ from core.errors import translate_error
 from core.personality import personality
 from src.analytics.user_logger import user_logger
 from src.analytics.session_analytics import session_analytics
-from src.llm.factory import llm_factory
-from src.services.hf_monitor import hf_monitor
 import logging
 
 # Set up logging
@@ -26,25 +24,49 @@ logger = logging.getLogger(__name__)
 
 st.set_page_config(page_title="CosmicCat AI Assistant", page_icon="🐱", layout="wide")
 
-# Initialize session state properly
-if "messages" not in st.session_state:
-    st.session_state.messages = []
-if "is_processing" not in st.session_state:
-    st.session_state.is_processing = False
-if "ngrok_url_temp" not in st.session_state:
-    st.session_state.ngrok_url_temp = st.session_state.get("ngrok_url", "https://7bcc180dffd1.ngrok-free.app")
-if "cosmic_mode" not in st.session_state:
-    st.session_state.cosmic_mode = True
-if "show_welcome" not in st.session_state:
-    st.session_state.show_welcome = True
-if "last_processed_message" not in st.session_state:
-    st.session_state.last_processed_message = ""
-if "session_id" not in st.session_state:
-    st.session_state.session_id = f"sess_{int(time.time())}_{abs(hash(str(time.time()))) % 10000}"
-if "selected_model_value" not in st.session_state:
-    st.session_state.selected_model_value = "auto"
+# Initialize session state properly with error handling
+def initialize_session_state():
+    """Initialize all session state variables safely"""
+    session_vars = {
+        "messages": [],
+        "is_processing": False,
+        "ngrok_url_temp": st.session_state.get("ngrok_url", "https://7bcc180dffd1.ngrok-free.app"),
+        "cosmic_mode": True,
+        "show_welcome": True,
+        "last_processed_message": "",
+        "selected_model_value": "auto",
+        "session_id": f"sess_{int(time.time())}_{abs(hash(str(time.time()))) % 10000}"
+    }
+    
+    for var_name, default_value in session_vars.items():
+        if var_name not in st.session_state:
+            st.session_state[var_name] = default_value
+            logger.info(f"Initialized session variable: {var_name}")
+
+# Initialize session state
+try:
+    initialize_session_state()
+except Exception as e:
+    logger.error(f"Session state initialization failed: {e}")
+    # Fallback initialization
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    if "is_processing" not in st.session_state:
+        st.session_state.is_processing = False
+    if "ngrok_url_temp" not in st.session_state:
+        st.session_state.ngrok_url_temp = st.session_state.get("ngrok_url", "https://7bcc180dffd1.ngrok-free.app")
+    if "cosmic_mode" not in st.session_state:
+        st.session_state.cosmic_mode = True
+    if "show_welcome" not in st.session_state:
+        st.session_state.show_welcome = True
+    if "last_processed_message" not in st.session_state:
+        st.session_state.last_processed_message = ""
+    if "selected_model_value" not in st.session_state:
+        st.session_state.selected_model_value = "auto"
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = f"sess_{int(time.time())}_{abs(hash(str(time.time()))) % 10000}"
 
-# Start session tracking
+# Start session tracking with error handling
 try:
     session_analytics.start_session_tracking("default_user", st.session_state.session_id)
 except Exception as e:
@@ -77,12 +99,8 @@ with st.sidebar:
     # Show which provider will actually be used
     actual_provider = "Unknown"
     if st.session_state.selected_model_value == "auto":
-        if config.hf_token:
-            status = hf_monitor.get_endpoint_status()
-            if status["available"]:
-                actual_provider = "🤗 HF Endpoint"
-            elif config.ollama_host:
-                actual_provider = "🦙 Ollama"
+        if config.hf_token and hf_monitor.get_endpoint_status()["available"]:
+            actual_provider = "🤗 HF Endpoint"
         elif config.ollama_host:
             actual_provider = "🦙 Ollama"
     else:
@@ -286,7 +304,6 @@ user_input = st.chat_input("Type your message here...", key="chat_input")
 
 # Process message when received
 if user_input and user_input.strip():
-    # Handle user message display first
     if not st.session_state.get('is_processing', False):
         chat_handler.process_user_message(user_input, st.session_state.selected_model_value)
     else:

src/analytics/session_analytics.py

@@ -9,14 +9,18 @@ from src.analytics.user_logger import user_logger
 logger = logging.getLogger(__name__)
 
 class SessionAnalytics:
-    """Session-level tracking and analytics"""
+    """Session-level tracking and analytics with proper error handling"""
     
     def __init__(self):
         self.redis_client = redis_client.get_client()
         
     def start_session_tracking(self, user_id: str, session_id: str):
-        """Start tracking a user session"""
+        """Start tracking a user session with error handling"""
         try:
+            if not self.redis_client:
+                logger.warning("Redis client not available for session tracking")
+                return
+                
             session_data = {
                 "user_id": user_id,
                 "session_id": session_id,
@@ -41,8 +45,12 @@ class SessionAnalytics:
             
     def track_interaction(self, user_id: str, session_id: str, interaction_type: str, 
                          details: Dict[str, Any] = None):
-        """Track a user interaction within a session"""
+        """Track a user interaction within a session with error handling"""
         try:
+            if not self.redis_client:
+                logger.warning("Redis client not available for interaction tracking")
+                return
+                
             key = f"analytics:sessions:{session_id}"
             session_data_str = self.redis_client.get(key)
             
@@ -81,8 +89,12 @@ class SessionAnalytics:
             logger.error(f"Failed to track interaction: {e}")
             
     def end_session_tracking(self, user_id: str, session_id: str):
-        """End session tracking and generate summary"""
+        """End session tracking and generate summary with error handling"""
         try:
+            if not self.redis_client:
+                logger.warning("Redis client not available for session ending")
+                return
+                
             key = f"analytics:sessions:{session_id}"
             session_data_str = self.redis_client.get(key)
             
@@ -112,8 +124,12 @@ class SessionAnalytics:
             logger.error(f"Failed to end session tracking: {e}")
             
     def get_session_summary(self, session_id: str) -> Optional[Dict[str, Any]]:
-        """Get session summary data"""
+        """Get session summary data with error handling"""
         try:
+            if not self.redis_client:
+                logger.warning("Redis client not available for session summary")
+                return None
+                
             key = f"analytics:sessions:{session_id}"
             session_data_str = self.redis_client.get(key)
             
@@ -121,17 +137,21 @@ class SessionAnalytics:
                 return json.loads(session_data_str)
             return None
         except Exception as e:
-            logger.error(f"Failed to get session summary: {e}")
+            logger.error(f"Failed to get session summary for user {session_id}: {e}")
             return None
             
     def get_user_sessions(self, user_id: str, limit: int = 10) -> List[Dict[str, Any]]:
-        """Get recent sessions for a user"""
+        """Get recent sessions for a user with error handling"""
         try:
+            if not self.redis_client:
+                logger.warning("Redis client not available for user sessions")
+                return []
+                
             # This would require a more complex indexing system
             # For now, we'll return an empty list as this requires additional implementation
             return []
         except Exception as e:
-            logger.error(f"Failed to get user sessions: {e}")
+            logger.error(f"Failed to get user sessions for user {user_id}: {e}")
             return []
 
 # Global instance

src/ui/chat_handler.py

@@ -8,25 +8,34 @@ from core.session import session_manager
 logger = logging.getLogger(__name__)
 
 class ChatHandler:
-    """Handles chat interactions with better timeout handling"""
+    """Handles chat interactions with better UI feedback and session state handling"""
     
     def __init__(self):
         self.is_processing = False
         
     def process_user_message(self, user_input: str, selected_model: str):
-        """Process user message with immediate display"""
+        """Process user message with enhanced UI feedback and proper session state handling"""
         if not user_input or not user_input.strip():
             st.warning("Please enter a message")
             return
             
-        # Prevent duplicate processing
-        if st.session_state.get('last_processed_message') == user_input:
-            logger.info("Preventing duplicate message processing")
-            return
+        # Prevent duplicate processing with proper session state access
+        try:
+            last_processed = st.session_state.get('last_processed_message', '')
+            if last_processed == user_input:
+                logger.info("Preventing duplicate message processing")
+                return
+        except Exception as e:
+            logger.warning(f"Error accessing session state: {e}")
+            # Continue processing even if session state access fails
+            
+        # Set processing flags with error handling
+        try:
+            st.session_state.is_processing = True
+            st.session_state.last_processed_message = user_input
+        except Exception as e:
+            logger.error(f"Error setting session state: {e}")
             
-        st.session_state.is_processing = True
-        st.session_state.last_processed_message = user_input
-        
         try:
             # Show user message immediately
             timestamp = time.strftime("%H:%M:%S")
@@ -34,26 +43,33 @@ class ChatHandler:
                 st.markdown(user_input)
                 st.caption(f"🕒 {timestamp}")
             
-            # Add to session state history
-            if "messages" not in st.session_state:
-                st.session_state.messages = []
-                
-            st.session_state.messages.append({
-                "role": "user",
-                "content": user_input,
-                "timestamp": timestamp
-            })
+            # Add to session state history with error handling
+            try:
+                if "messages" not in st.session_state:
+                    st.session_state.messages = []
+                    
+                st.session_state.messages.append({
+                    "role": "user",
+                    "content": user_input,
+                    "timestamp": timestamp
+                })
+            except Exception as e:
+                logger.error(f"Error updating session state messages: {e}")
             
             # Force UI update
             st.experimental_rerun()
             
         except Exception as e:
             logger.error(f"Error in initial message display: {e}", exc_info=True)
-            st.session_state.is_processing = False
-            st.session_state.last_processed_message = ""
+            # Clear processing flags on error
+            try:
+                st.session_state.is_processing = False
+                st.session_state.last_processed_message = ""
+            except Exception as state_error:
+                logger.error(f"Error clearing session state: {state_error}")
     
     def process_ai_response(self, user_input: str, selected_model: str):
-        """Process AI response with enhanced timeout handling"""
+        """Process AI response with enhanced timeout handling and proper session state access"""
         if not user_input or not user_input.strip():
             return
             
@@ -70,7 +86,7 @@ class ChatHandler:
                     
                     status_placeholder.info(f"🚀 Contacting {provider_name}...")
                     
-                    # Generate response with timeout handling
+                    # Get response
                     response = None
                     try:
                         # Get session and conversation history
@@ -79,75 +95,111 @@ class ChatHandler:
                         conversation_history.append({"role": "user", "content": user_input})
                         
                         response = provider.generate(user_input, conversation_history)
-                        
                     except Exception as e:
                         logger.error(f"AI response error: {e}")
-                        
-                        # Better error messages for timeout issues
-                        if "timeout" in str(e).lower() or "500" in str(e) or "60" in str(e):
-                            if provider_name == "Ollama":
-                                error_message = ("⏰ Ollama request timed out (60+ seconds).\n\n"
-                                               "**Recommendation:** Switch to HF Endpoint which is more reliable.\n"
-                                               "Click the '🤖 HF Expert Analysis' button below for deep analysis.")
-                            else:
-                                error_message = ("⏰ HF Endpoint is initializing (may take 2-4 minutes).\n\n"
-                                               "Please try again in a moment or use Ollama for faster responses.")
-                        else:
-                            error_message = f"Sorry, I encountered an error: {str(e)[:100]}..."
-                        
-                        status_placeholder.error(f"❌ {provider_name} Error")
-                        response_placeholder.markdown(error_message)
-                        return
+                        raise
                     
                     if response and response.strip():
                         status_placeholder.success("✅ Response received!")
                         response_placeholder.markdown(response)
                         
-                        # Add to session history
+                        # Add to session history with error handling
+                        try:
+                            timestamp = time.strftime("%H:%M:%S")
+                            provider_info = "hf_endpoint" if "huggingface" in str(type(provider)).lower() else "ollama"
+                            
+                            st.session_state.messages.append({
+                                "role": "assistant",
+                                "content": response,
+                                "timestamp": timestamp,
+                                "provider": provider_info
+                            })
+                            
+                            # Update backend session
+                            conversation = user_session.get("conversation", []).copy()
+                            conversation.append({"role": "user", "content": user_input})
+                            conversation.append({"role": "assistant", "content": response})
+                            session_manager.update_session("default_user", {"conversation": conversation})
+                            
+                        except Exception as session_error:
+                            logger.error(f"Error updating session: {session_error}")
+                    else:
+                        status_placeholder.warning("⚠️ Empty response received")
+                        response_placeholder.markdown("*No response generated. Please try again.*")
+                        try:
+                            timestamp = time.strftime("%H:%M:%S")
+                            st.session_state.messages.append({
+                                "role": "assistant",
+                                "content": "*No response generated. Please try again.*",
+                                "timestamp": timestamp
+                            })
+                        except Exception as state_error:
+                            logger.error(f"Error updating session state: {state_error}")
+                        
+                except ProviderNotAvailableError as e:
+                    status_placeholder.error("❌ No AI providers available")
+                    response_placeholder.markdown("No AI providers are configured. Please check your settings.")
+                    try:
                         timestamp = time.strftime("%H:%M:%S")
                         st.session_state.messages.append({
                             "role": "assistant",
-                            "content": response,
-                            "timestamp": timestamp,
-                            "provider": provider_name.lower().replace(" ", "_")
+                            "content": "No AI providers are configured. Please check your settings.",
+                            "timestamp": timestamp
                         })
+                    except Exception as state_error:
+                        logger.error(f"Error updating session state: {state_error}")
+                    logger.error(f"Provider not available: {e}")
+                    
+                except Exception as e:
+                    # Better user-friendly error messages
+                    status_placeholder.error("❌ Request failed")
+                    
+                    # More specific error messages
+                    if "timeout" in str(e).lower() or "500" in str(e):
+                        error_message = ("⏰ Request timed out. This might be because:\n"
+                                       "• Your Ollama server is not responding\n"
+                                       "• Network connectivity issues\n"
+                                       "• Try using the HF Endpoint instead (🟢 HF Endpoint: Available and ready)")
+                    elif "connection" in str(e).lower():
+                        error_message = ("🔌 Connection failed. This might be because:\n"
+                                       "• Your Ollama server is offline\n"
+                                       "• Incorrect Ollama URL\n"
+                                       "• Network firewall blocking connection\n"
+                                       "• Try using the HF Endpoint instead")
                     else:
-                        status_placeholder.warning("⚠️ Empty response received")
-                        response_placeholder.markdown("*No response generated. Please try again.*")
+                        error_message = f"Sorry, I encountered an error: {str(e)}"
+                    
+                    response_placeholder.markdown(error_message)
+                    try:
                         timestamp = time.strftime("%H:%M:%S")
                         st.session_state.messages.append({
                             "role": "assistant",
-                            "content": "*No response generated. Please try again.*",
+                            "content": error_message,
                             "timestamp": timestamp
                         })
-                        
-                except ProviderNotAvailableError as e:
-                    status_placeholder.error("❌ No AI providers available")
-                    response_placeholder.markdown("No AI providers are configured. Please check your settings.")
-                    timestamp = time.strftime("%H:%M:%S")
-                    st.session_state.messages.append({
-                        "role": "assistant",
-                        "content": "No AI providers are configured. Please check your settings.",
-                        "timestamp": timestamp
-                    })
-                    logger.error(f"Provider not available: {e}")
+                    except Exception as state_error:
+                        logger.error(f"Error updating session state: {state_error}")
+                    logger.error(f"Chat processing error: {e}", exc_info=True)
                     
         except Exception as e:
-            logger.error(f"Chat processing failed: {e}", exc_info=True)
+            logger.error(f"Unexpected error in process_ai_response: {e}", exc_info=True)
             st.error("An unexpected error occurred. Please try again.")
         finally:
-            st.session_state.is_processing = False
-            st.session_state.last_processed_message = ""
+            # Clear processing flags with error handling
+            try:
+                st.session_state.is_processing = False
+                st.session_state.last_processed_message = ""
+            except Exception as state_error:
+                logger.error(f"Error clearing session state: {state_error}")
             time.sleep(0.1)
     
     def _get_provider_display_name(self, provider_name: str) -> str:
         """Get display name for provider"""
         display_names = {
-            "ollama": "🦙 Ollama (Local)",
-            "huggingface": "🤗 HF Endpoint (Primary)",
-            "hf_endpoint": "🤗 HF Endpoint (Primary)"
+            "ollama": "🦙 Ollama",
+            "huggingface": "🤗 HF Endpoint"
         }
-        return display_names.get(provider_name.lower(), provider_name)
+        return display_names.get(provider_name, provider_name)
 
 # Global instance
 chat_handler = ChatHandler()