Fix critical issues: session state error, Ollama timeouts, redundant logging

app.py

@@ -7,8 +7,7 @@ from datetime import datetime
 from pathlib import Path
 sys.path.append(str(Path(__file__).parent))
 
-# Import modules
-from src.ui.chat_handler import chat_handler
+# Import modules from src.ui.chat_handler import chat_handler
 from utils.config import config
 from core.session import session_manager
 from core.memory import check_redis_health
@@ -61,7 +60,7 @@ with st.sidebar:
     
     # Model selection
     model_options = {
-        "Auto Select": "auto",  # Will choose best available
+        "Auto Select": "auto",
         "🦙 Ollama (Local)": "ollama",
         "🤗 HF Endpoint": "huggingface"
     }
@@ -76,7 +75,6 @@ with st.sidebar:
     # Show which provider will actually be used
     actual_provider = "Unknown"
     if st.session_state.selected_model_value == "auto":
-        # Import HF monitor here to avoid undefined error
         try:
             from src.services.hf_endpoint_monitor import hf_monitor
             if config.hf_token:
@@ -200,12 +198,12 @@ with st.sidebar:
                 st.info(status_message)
             else:
                 st.info(status_message)
-                
+            
             # Show initialization progress if applicable
             init_progress = hf_monitor.get_initialization_progress()
             if init_progress:
                 st.info(init_progress)
-                
+            
             # Add wake-up button if scaled to zero or initializing
             if "scaled to zero" in status_message.lower() or "initializing" in status_message.lower():
                 if st.button("⚡ Wake Up HF Endpoint", key="wake_up_hf"):
@@ -228,7 +226,7 @@ with st.sidebar:
                                 "response_time": end_time - start_time
                             })
                             user_logger.log_error("default_user", "hf_wake_up", "Failed to wake up HF endpoint")
-                            
+        
         except Exception as e:
             st.info(f"🤗 HF Endpoint: Error checking status - {str(e)}")
             session_analytics.track_interaction("default_user", st.session_state.session_id, "hf_status_error", {

core/providers/ollama.py

@@ -1,22 +1,18 @@
 import requests
 import logging
 import re
-from datetime import datetime
 from typing import List, Dict, Optional, Union
 from core.providers.base import LLMProvider
 from utils.config import config
-from services.weather import weather_service
 
 logger = logging.getLogger(__name__)
 
 class OllamaProvider(LLMProvider):
-    """Ollama LLM provider implementation"""
-    
-    def __init__(self, model_name: str, timeout: int = 60, max_retries: int = 3):
-        # Increased timeout from 30 to 60
+    """Ollama LLM provider implementation with commentary support"""
+
+    def __init__(self, model_name: str, timeout: int = 120, max_retries: int = 3):  # Increased timeout to 120s
         super().__init__(model_name, timeout, max_retries)
         self.host = self._sanitize_host(config.ollama_host or "http://localhost:11434")
-        # Headers to skip ngrok browser warning
         self.headers = {
             "ngrok-skip-browser-warning": "true",
             "User-Agent": "CosmicCat-AI-Assistant"
@@ -26,11 +22,8 @@ class OllamaProvider(LLMProvider):
         """Sanitize host URL by removing whitespace and control characters"""
         if not host:
             return "http://localhost:11434"
-        # Remove leading/trailing whitespace and control characters
         host = host.strip()
-        # Remove any newlines or control characters
         host = re.sub(r'[\r\n\t\0]+', '', host)
-        # Ensure URL has a scheme
         if not host.startswith(('http://', 'https://')):
             host = 'http://' + host
         return host
@@ -64,7 +57,6 @@ class OllamaProvider(LLMProvider):
                 model_names = [model.get("name") for model in models]
                 return self.model_name in model_names
             elif response.status_code == 404:
-                # Try alternative endpoint
                 response2 = requests.get(
                     f"{self.host}",
                     headers=self.headers,
@@ -73,43 +65,121 @@ class OllamaProvider(LLMProvider):
                 return response2.status_code == 200
             return False
         except Exception as e:
-            logger.error(f"Model validation failed: {e}")
+            logger.warning(f"Model validation failed: {e}")
             return False
 
-    def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
-        """Implementation of synchronous generation with enhanced debugging"""
-        url = f"{self.host}/api/chat"
-        
-        # Prepare messages - ensure proper format
-        messages = []
-        for msg in conversation_history:
-            if isinstance(msg, dict) and "role" in msg and "content" in msg:
-                messages.append({
-                    "role": msg["role"],
-                    "content": str(msg["content"])
-                })
-        
-        # Add the current prompt if not already in history
-        if not messages or messages[-1].get("content") != prompt:
-            messages.append({"role": "user", "content": prompt})
-        
-        payload = {
-            "model": self.model_name,
-            "messages": messages,
-            "stream": False
-        }
+    def generate_commentary(self, user_prompt: str, hf_response: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Generate commentary on HF response"""
+        try:
+            commentary_prompt = self._create_commentary_prompt(user_prompt, hf_response, conversation_history)
+            return self._retry_with_backoff(self._generate_impl, commentary_prompt, [])
+        except Exception as e:
+            logger.error(f"Ollama commentary generation failed: {e}")
+            return None
+
+    def generate_self_commentary(self, user_prompt: str, ollama_response: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Generate self-commentary on own response"""
+        try:
+            commentary_prompt = self._create_self_commentary_prompt(user_prompt, ollama_response, conversation_history)
+            return self._retry_with_backoff(self._generate_impl, commentary_prompt, [])
+        except Exception as e:
+            logger.error(f"Ollama self-commentary generation failed: {e}")
+            return None
+
+    def _create_commentary_prompt(self, user_prompt: str, hf_response: str, conversation_history: List[Dict]) -> str:
+        """Create prompt for Ollama to comment on HF response"""
+        conversation_context = "\n".join([
+            f"{msg['role']}: {msg['content']}" 
+            for msg in conversation_history[-3:]  # Last 3 messages for context
+        ])
         
-        logger.info(f"Ollama request URL: {url}")
-        logger.info(f"Ollama request payload: {payload}")
-        logger.info(f"Ollama headers: {self.headers}")
+        prompt = f"""
+You are an AI mentor and conversation analyst. Your job is to analyze the interaction between a user and an expert AI, then provide insightful commentary.
+
+ANALYZE THIS INTERACTION:
+User Question: "{user_prompt}"
+Expert Response: "{hf_response}"
+
+Recent Conversation Context: {conversation_context}
+
+PROVIDE YOUR COMMENTARY IN THIS FORMAT:
+
+I've reviewed the HF expert's response and here's my insight:
+
+Key Points Observed:
+
+[Point 1]
+[Point 2]
+My Perspective: [Your commentary on the HF response]
+
+Suggestions:
+
+[Suggestion 1]
+[Suggestion 2]
+
+Keep your analysis concise but insightful. Focus on helping the user achieve their goals through better questioning and information gathering.
+"""
+        return prompt
+
+    def _create_self_commentary_prompt(self, user_prompt: str, ollama_response: str, conversation_history: List[Dict]) -> str:
+        """Create prompt for Ollama to comment on its own response"""
+        conversation_context = "\n".join([
+            f"{msg['role']}: {msg['content']}" 
+            for msg in conversation_history[-3:]  # Last 3 messages for context
+        ])
         
+        prompt = f"""
+You are an AI mentor and conversation analyst. Your job is to analyze your own response to a user question, then provide insightful self-reflection.
+
+ANALYZE YOUR RESPONSE:
+User Question: "{user_prompt}"
+Your Response: "{ollama_response}"
+
+Recent Conversation Context: {conversation_context}
+
+PROVIDE YOUR SELF-COMMENTARY IN THIS FORMAT:
+
+I've reviewed my own response and here's my self-reflection:
+
+Key Points Addressed:
+
+[Point 1]
+[Point 2]
+My Self-Assessment: [Your reflection on your own response quality]
+
+Areas for Improvement:
+
+[Area 1]
+[Area 2]
+
+Keep your analysis honest and constructive. Focus on how you could have provided better assistance.
+"""
+        return prompt
+
+    def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
+        """Implementation of synchronous generation"""
         try:
+            url = f"{self.host}/api/chat"
+            messages = conversation_history.copy()
+            messages.append({"role": "user", "content": prompt})
+            
+            payload = {
+                "model": self.model_name,
+                "messages": messages,
+                "stream": False
+            }
+            
+            logger.info(f"Ollama request URL: {url}")
+            logger.info(f"Ollama request payload: {payload}")
+            logger.info(f"Ollama headers: {self.headers}")
+            
             response = requests.post(
                 url,
                 json=payload,
                 headers=self.headers,
                 timeout=self.timeout
             )
+            
             logger.info(f"Ollama response status: {response.status_code}")
             logger.info(f"Ollama response headers: {dict(response.headers)}")
             
@@ -117,56 +187,58 @@ class OllamaProvider(LLMProvider):
             result = response.json()
             logger.info(f"Ollama response body: {result}")
             
-            # Extract content properly
+            content = None
             if "message" in result and "content" in result["message"]:
                 content = result["message"]["content"]
-                logger.info(f"Extracted content: {content[:100] if content else 'None'}")
-                return content
             elif "response" in result:
                 content = result["response"]
-                logger.info(f"Extracted response: {content[:100] if content else 'None'}")
-                return content
             else:
                 content = str(result)
-                logger.info(f"Raw result as string: {content[:100]}")
-                return content
-                
-        except requests.exceptions.RequestException as e:
+            
+            logger.info(f"Extracted content length: {len(content) if content else 0}")
+            return content if content else ""
+        
+        except Exception as e:
             logger.error(f"Ollama API request error: {str(e)}")
             raise Exception(f"Ollama API error: {str(e)}")
-        except Exception as e:
-            logger.error(f"Failed to parse Ollama response: {str(e)}")
-            raise Exception(f"Failed to parse Ollama response: {str(e)}")
 
     def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
         """Implementation of streaming generation"""
-        url = f"{self.host}/api/chat"
-        messages = conversation_history.copy()
-        # Add the current prompt if not already in history
-        if not messages or messages[-1].get("content") != prompt:
+        try:
+            url = f"{self.host}/api/chat"
+            messages = conversation_history.copy()
             messages.append({"role": "user", "content": prompt})
-        payload = {
-            "model": self.model_name,
-            "messages": messages,
-            "stream": True
-        }
-        response = requests.post(
-            url,
-            json=payload,
-            headers=self.headers,
-            timeout=self.timeout,
-            stream=True
-        )
-        response.raise_for_status()
-        chunks = []
-        for line in response.iter_lines():
-            if line:
-                chunk = line.decode('utf-8')
-                try:
-                    data = eval(chunk)  # Simplified JSON parsing
-                    content = data.get("message", {}).get("content", "")
-                    if content:
-                        chunks.append(content)
-                except:
-                    continue
-        return chunks
+            
+            payload = {
+                "model": self.model_name,
+                "messages": messages,
+                "stream": True
+            }
+            
+            response = requests.post(
+                url,
+                json=payload,
+                headers=self.headers,
+                timeout=self.timeout,
+                stream=True
+            )
+            response.raise_for_status()
+            
+            chunks = []
+            for line in response.iter_lines():
+                if line:
+                    chunk = line.decode('utf-8')
+                    try:
+                        data = eval(chunk)  # Simplified JSON parsing
+                        content = data.get("message", {}).get("content", "")
+                        if content:
+                            chunks.append(content)
+                    except:
+                        continue
+            return chunks
+        except Exception as e:
+            logger.error(f"Ollama stream generation failed: {e}")
+            raise
+
+# Global instance
+ollama_provider = OllamaProvider(config.local_model_name)

core/session.py

@@ -11,7 +11,7 @@ logger = logging.getLogger(__name__)
 
 class SessionManager:
     """Manages user sessions and conversation context with optimized operations"""
-    
+
     def __init__(self, session_timeout: int = 7200):  # Increased from 3600 to 7200 (2 hours)
         """Initialize session manager
         Args:
@@ -62,7 +62,7 @@ class SessionManager:
             
             # Update with new data
             session.update(data)
-            session['last_activity'] = time.time()
+            session['last_activity'] = time.time()  # Always update last activity
             
             # Serialize complex data types for Redis
             redis_data = {}
@@ -84,7 +84,7 @@ class SessionManager:
                 logger.warning(f"Failed to save session for user {user_id}")
             
             return result
-            
+        
         except Exception as e:
             logger.error(f"Error updating session for user {user_id}: {e}")
             return False

src/analytics/session_analytics.py

@@ -10,17 +10,17 @@ logger = logging.getLogger(__name__)
 
 class SessionAnalytics:
     """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 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,
@@ -42,15 +42,26 @@ class SessionAnalytics:
             logger.info(f"Started session tracking: {session_id}")
         except Exception as e:
             logger.error(f"Failed to start session tracking: {e}")
-            
-    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 with error handling"""
+
+    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 with error handling and debouncing"""
         try:
             if not self.redis_client:
                 logger.warning("Redis client not available for interaction tracking")
                 return
-                
+            
+            # Debounce repeated events - only log if more than 1 second since last event of same type
+            last_event_key = f"analytics:last_event:{user_id}:{interaction_type}"
+            last_event_time = self.redis_client.get(last_event_key)
+            
+            if last_event_time:
+                if time.time() - float(last_event_time) < 1.0:  # Throttle to once per second
+                    return
+            
+            # Update last event time
+            self.redis_client.setex(last_event_key, 10, time.time())  # Expire in 10 seconds
+            
             key = f"analytics:sessions:{session_id}"
             session_data_str = self.redis_client.get(key)
             
@@ -71,7 +82,7 @@ class SessionAnalytics:
                 # Update page views for navigation events
                 if interaction_type == "page_view":
                     session_data["page_views"] += 1
-                    
+                
                 # Update duration
                 start_time = datetime.fromisoformat(session_data["start_time"])
                 session_data["duration"] = (datetime.now() - start_time).total_seconds()
@@ -84,17 +95,17 @@ class SessionAnalytics:
                     "session_id": session_id,
                     "details": details or {}
                 })
-                
+        
         except Exception as e:
             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 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)
             
@@ -119,17 +130,17 @@ class SessionAnalytics:
                 })
                 
                 logger.info(f"Ended session tracking: {session_id}")
-                
+        
         except Exception as e:
             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 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)
             
@@ -139,14 +150,14 @@ class SessionAnalytics:
         except Exception as 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 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 []