Enhanced system initialization, context awareness, and debug information

app.py

@@ -15,6 +15,7 @@ from core.coordinator import coordinator
 from core.errors import translate_error
 from core.personality import personality
 from services.hf_endpoint_monitor import hf_monitor
+from services.weather import weather_service
 import logging
 
 # Set up logging
@@ -116,15 +117,24 @@ with st.sidebar:
             
         try:
             hf_status = hf_monitor.check_endpoint_status()
-            if hf_status['available']:
+            # Enhanced HF status display
+            if hf_status.get('available'):
                 if hf_status.get('initialized', False):
-                    st.success("🤗 HF: Available & Initialized")
+                    st.success(f"🤗 HF Endpoint: Available ({hf_status.get('status_code')} OK)")
+                    if hf_status.get('model'):
+                        st.info(f"   Model: {hf_status.get('model')}")
+                    if hf_status.get('region'):
+                        st.info(f"   Region: {hf_status.get('region')}")
+                    if hf_status.get('warmup_count'):
+                        st.info(f"   Warmup Count: {hf_status.get('warmup_count')}")
                 else:
-                    st.warning("⚡ HF: Initializing...")
+                    st.warning("⏳ Initializing...")
+            elif hf_status.get('status_code') == 200:
+                st.info("📡 Connecting...")
             else:
-                st.info("🤗 HF: Not configured")
-        except:
-            st.info("🤗 HF: Unknown")
+                st.error("🔴 Unavailable")
+        except Exception as e:
+            st.info("⏳ Initializing...")
             
         if check_redis_health():
             st.success("💾 Redis: Connected")
@@ -134,20 +144,57 @@ with st.sidebar:
     st.divider()
     
     st.subheader("🐛 Debug Info")
-    # Show current configuration
-    st.markdown(f"Environment: {'HF Space' if config.is_hf_space else 'Local'}")
-    st.markdown(f"Model: {st.session_state.selected_model}")
-    st.markdown(f"Cosmic Mode: {'Enabled' if st.session_state.cosmic_mode else 'Disabled'}")
+    # Show enhanced debug information
+    st.markdown(f"**Environment:** {'HF Space' if config.is_hf_space else 'Local'}")
+    st.markdown(f"**Model:** {st.session_state.selected_model}")
+    st.markdown(f"**Fallback:** {'Enabled' if config.use_fallback else 'Disabled'}")
     
     # Show active features
     features = []
-    if config.hf_token:
-        features.append("HF Expert")
     if os.getenv("TAVILY_API_KEY"):
         features.append("Web Search")
     if config.openweather_api_key:
         features.append("Weather")
-    st.markdown(f"Active Features: {', '.join(features) if features else 'None'}")
+    st.markdown(f"**Active Features:** {', '.join(features) if features else 'None'}")
+    
+    # Show recent activity
+    try:
+        user_session = session_manager.get_session("default_user")
+        coord_stats = user_session.get('ai_coordination', {})
+        if coord_stats and coord_stats.get('last_coordination'):
+            st.markdown(f"**Last Request:** {coord_stats.get('last_coordination')}")
+        else:
+            st.markdown("**Last Request:** N/A")
+    except:
+        st.markdown("**Last Request:** N/A")
+        
+    # Show Ollama ping status
+    try:
+        import requests
+        import time
+        start_time = time.time()
+        headers = {
+            "ngrok-skip-browser-warning": "true",
+            "User-Agent": "CosmicCat-Debug"
+        }
+        response = requests.get(
+            f"{st.session_state.ngrok_url_temp}/api/tags",
+            headers=headers,
+            timeout=15
+        )
+        ping_time = round((time.time() - start_time) * 1000)
+        if response.status_code == 200:
+            st.markdown(f"**Ollama Ping:** {response.status_code} OK ({ping_time}ms)")
+        else:
+            st.markdown(f"**Ollama Ping:** {response.status_code} Error")
+    except Exception as e:
+        st.markdown("**Ollama Ping:** Unreachable")
+        
+    # Redis status
+    if check_redis_health():
+        st.markdown("**Redis:** Healthy")
+    else:
+        st.markdown("**Redis:** Unhealthy")
 
 # Main interface
 st.title("🐱 CosmicCat AI Assistant")
@@ -543,8 +590,6 @@ with tab2:
     features = []
     if config.use_fallback:
         features.append("Fallback Mode")
-    if config.hf_token:
-        features.append("HF Deep Analysis")
     if os.getenv("TAVILY_API_KEY"):
         features.append("Web Search")
     if config.openweather_api_key:

core/coordinator.py

@@ -72,59 +72,6 @@ class AICoordinator:
             "reasoning": f"Found topics requiring current info: {', '.join(search_topics)}" if search_topics else "No current info needed"
         }
         
-    def manual_hf_analysis(self, user_id: str, conversation_history: List[Dict]) -> str:
-        """Perform manual HF analysis with web search integration"""
-        try:
-            # Determine research needs
-            research_decision = self.determine_web_search_needs(conversation_history)
-            
-            # Prepare enhanced prompt for HF
-            system_prompt = f"""
-You are a deep analysis expert joining an ongoing conversation.
-Research Decision: {research_decision['reasoning']}
-Please provide:
-1. Deep insights on conversation themes
-2. Research/web search needs (if any)
-3. Strategic recommendations
-4. Questions to explore further
-Conversation History:
-"""
-            
-            # Add conversation history to messages
-            messages = [{"role": "system", "content": system_prompt}]
-            
-            # Add recent conversation (last 15 messages for context)
-            for msg in conversation_history[-15:]:  # Ensure all messages have proper format
-                if isinstance(msg, dict) and "role" in msg and "content" in msg:
-                    messages.append({
-                        "role": msg["role"],
-                        "content": msg["content"]
-                    })
-            
-            # Get HF provider
-            from core.llm_factory import llm_factory
-            hf_provider = llm_factory.get_provider('huggingface')
-            
-            if hf_provider:
-                # Generate deep analysis with full 8192 token capacity
-                response = hf_provider.generate("Deep analysis request", messages)
-                return response or "HF Expert analysis completed."
-            else:
-                return "❌ HF provider not available."
-                
-        except Exception as e:
-            return f"❌ HF analysis failed: {str(e)}"
-            
-    # Add this method to show HF engagement status
-    def get_hf_engagement_status(self) -> Dict:
-        """Get current HF engagement status"""
-        return {
-            "hf_available": self._check_hf_availability(),
-            "web_search_configured": bool(self.tavily_client),
-            "research_needs_detected": False,  # Will be determined per conversation
-            "last_hf_analysis": None  # Track last analysis time
-        }
-        
     async def coordinate_cosmic_response(self, user_id: str, user_query: str) -> AsyncGenerator[Dict, None]:
         """
         Three-stage cosmic response cascade:

core/providers/huggingface.py

@@ -4,7 +4,9 @@ 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__)
+
 try:
     from openai import OpenAI
     HUGGINGFACE_SDK_AVAILABLE = True
@@ -14,18 +16,19 @@ except ImportError:
 
 class HuggingFaceProvider(LLMProvider):
     """Hugging Face LLM provider implementation"""
-
+    
     def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 3):
         super().__init__(model_name, timeout, max_retries)
         logger.info(f"Initializing HuggingFaceProvider with:")
         logger.info(f" HF_API_URL: {config.hf_api_url}")
         logger.info(f" HF_TOKEN SET: {bool(config.hf_token)}")
-
+        
         if not HUGGINGFACE_SDK_AVAILABLE:
             raise ImportError("Hugging Face provider requires 'openai' package")
+            
         if not config.hf_token:
             raise ValueError("HF_TOKEN not set - required for Hugging Face provider")
-
+            
         # Make sure NO proxies parameter is included
         try:
             self.client = OpenAI(
@@ -37,7 +40,7 @@ class HuggingFaceProvider(LLMProvider):
             logger.error(f"Failed to initialize HuggingFaceProvider: {e}")
             logger.error(f"Error type: {type(e)}")
             raise
-
+            
     def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
         """Generate a response synchronously"""
         try:
@@ -45,7 +48,7 @@ class HuggingFaceProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Hugging Face generation failed: {e}")
             return None
-
+            
     def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
         """Generate a response with streaming support"""
         try:
@@ -53,7 +56,7 @@ class HuggingFaceProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Hugging Face stream generation failed: {e}")
             return None
-
+            
     def validate_model(self) -> bool:
         """Validate if the model is available"""
         # For Hugging Face endpoints, we'll assume the model is valid if we can connect
@@ -64,14 +67,18 @@ class HuggingFaceProvider(LLMProvider):
         except Exception as e:
             logger.warning(f"Hugging Face model validation failed: {e}")
             return False
-
+            
     def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
-        """Implementation of synchronous generation with proper configuration"""
-        # Inject current time as first message
+        """Implementation of synchronous generation with proper configuration and context injection"""
+        # Inject context message with current time/date/weather
         current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-        time_context = {"role": "system", "content": f"[Current Date & Time: {current_time}]"}
-        enhanced_history = [time_context] + conversation_history
-
+        weather_summary = self._get_weather_summary()
+        context_msg = {
+            "role": "system",
+            "content": f"[Current Context: {current_time} | Weather: {weather_summary}]"
+        }
+        enhanced_history = [context_msg] + conversation_history
+        
         try:
             response = self.client.chat.completions.create(
                 model=self.model_name,
@@ -88,6 +95,7 @@ class HuggingFaceProvider(LLMProvider):
             if self._is_scale_to_zero_error(e):
                 logger.info("Hugging Face endpoint is scaling up, waiting...")
                 time.sleep(60)  # Wait for endpoint to initialize
+                
                 # Retry once after waiting
                 response = self.client.chat.completions.create(
                     model=self.model_name,
@@ -101,14 +109,18 @@ class HuggingFaceProvider(LLMProvider):
                 return response.choices[0].message.content
             else:
                 raise
-
+                
     def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
-        """Implementation of streaming generation with proper configuration"""
-        # Inject current time as first message
+        """Implementation of streaming generation with proper configuration and context injection"""
+        # Inject context message with current time/date/weather
         current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-        time_context = {"role": "system", "content": f"[Current Date & Time: {current_time}]"}
-        enhanced_history = [time_context] + conversation_history
-
+        weather_summary = self._get_weather_summary()
+        context_msg = {
+            "role": "system",
+            "content": f"[Current Context: {current_time} | Weather: {weather_summary}]"
+        }
+        enhanced_history = [context_msg] + conversation_history
+        
         try:
             response = self.client.chat.completions.create(
                 model=self.model_name,
@@ -120,19 +132,18 @@ class HuggingFaceProvider(LLMProvider):
                 presence_penalty=0.1,
                 stream=True  # Enable streaming
             )
-
             chunks = []
             for chunk in response:
                 content = chunk.choices[0].delta.content
                 if content:
                     chunks.append(content)
-
             return chunks
         except Exception as e:
             # Handle scale-to-zero behavior
             if self._is_scale_to_zero_error(e):
                 logger.info("Hugging Face endpoint is scaling up, waiting...")
                 time.sleep(60)  # Wait for endpoint to initialize
+                
                 # Retry once after waiting
                 response = self.client.chat.completions.create(
                     model=self.model_name,
@@ -144,21 +155,33 @@ class HuggingFaceProvider(LLMProvider):
                     presence_penalty=0.1,
                     stream=True  # Enable streaming
                 )
-
                 chunks = []
                 for chunk in response:
                     content = chunk.choices[0].delta.content
                     if content:
                         chunks.append(content)
-
                 return chunks
             else:
                 raise
-
+                
     def _is_scale_to_zero_error(self, error: Exception) -> bool:
         """Check if the error is related to scale-to-zero initialization"""
         error_str = str(error).lower()
         scale_to_zero_indicators = [
-            "503", "service unavailable", "initializing", "cold start"
+            "503",
+            "service unavailable",
+            "initializing",
+            "cold start"
         ]
         return any(indicator in error_str for indicator in scale_to_zero_indicators)
+        
+    def _get_weather_summary(self) -> str:
+        """Get formatted weather summary"""
+        try:
+            weather = weather_service.get_current_weather("New York")
+            if weather:
+                return f"{weather.get('temperature', 'N/A')}°C, {weather.get('description', 'Clear skies')}"
+            else:
+                return "Clear skies"
+        except:
+            return "Clear skies"

core/providers/ollama.py

@@ -5,14 +5,15 @@ from datetime import datetime
 from typing import List, Dict, Optional, Union
 from core.providers.base import LLMProvider
 from utils.config import config
-from core.personality import personality
+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
+    def __init__(self, model_name: str, timeout: int = 60, max_retries: int = 3):
+        # Increased timeout from 30 to 60
         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
@@ -20,7 +21,7 @@ class OllamaProvider(LLMProvider):
             "ngrok-skip-browser-warning": "true",
             "User-Agent": "CosmicCat-AI-Assistant"
         }
-    
+        
     def _sanitize_host(self, host: str) -> str:
         """Sanitize host URL by removing whitespace and control characters"""
         if not host:
@@ -33,7 +34,7 @@ class OllamaProvider(LLMProvider):
         if not host.startswith(('http://', 'https://')):
             host = 'http://' + host
         return host
-    
+        
     def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
         """Generate a response synchronously"""
         try:
@@ -41,7 +42,7 @@ class OllamaProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Ollama generation failed: {e}")
             return None
-    
+            
     def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
         """Generate a response with streaming support"""
         try:
@@ -49,7 +50,7 @@ class OllamaProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Ollama stream generation failed: {e}")
             return None
-    
+            
     def validate_model(self) -> bool:
         """Validate if the model is available"""
         try:
@@ -74,19 +75,28 @@ class OllamaProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Model validation failed: {e}")
             return False
-    
+            
     def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
-        """Implementation of synchronous generation"""
+        """Implementation of synchronous generation with context injection"""
         url = f"{self.host}/api/chat"
         messages = conversation_history.copy()
         
+        # Inject context message with current time/date/weather
+        current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
+        weather_summary = self._get_weather_summary()
+        context_msg = {
+            "role": "system",
+            "content": f"[Current Context: {current_time} | Weather: {weather_summary}]"
+        }
+        enhanced_messages = [context_msg] + messages
+        
         # Add the current prompt if not already in history
         if not messages or messages[-1].get("content") != prompt:
-            messages.append({"role": "user", "content": prompt})
-        
+            enhanced_messages.append({"role": "user", "content": prompt})
+            
         payload = {
             "model": self.model_name,
-            "messages": messages,
+            "messages": enhanced_messages,
             "stream": False
         }
         
@@ -99,19 +109,28 @@ class OllamaProvider(LLMProvider):
         response.raise_for_status()
         result = response.json()
         return result["message"]["content"]
-    
+        
     def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
-        """Implementation of streaming generation"""
+        """Implementation of streaming generation with context injection"""
         url = f"{self.host}/api/chat"
         messages = conversation_history.copy()
         
+        # Inject context message with current time/date/weather
+        current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
+        weather_summary = self._get_weather_summary()
+        context_msg = {
+            "role": "system",
+            "content": f"[Current Context: {current_time} | Weather: {weather_summary}]"
+        }
+        enhanced_messages = [context_msg] + messages
+        
         # Add the current prompt if not already in history
         if not messages or messages[-1].get("content") != prompt:
-            messages.append({"role": "user", "content": prompt})
-        
+            enhanced_messages.append({"role": "user", "content": prompt})
+            
         payload = {
             "model": self.model_name,
-            "messages": messages,
+            "messages": enhanced_messages,
             "stream": True
         }
         
@@ -135,3 +154,14 @@ class OllamaProvider(LLMProvider):
                 except:
                     continue
         return chunks
+        
+    def _get_weather_summary(self) -> str:
+        """Get formatted weather summary"""
+        try:
+            weather = weather_service.get_current_weather("New York")
+            if weather:
+                return f"{weather.get('temperature', 'N/A')}°C, {weather.get('description', 'Clear skies')}"
+            else:
+                return "Clear skies"
+        except:
+            return "Clear skies"

services/hf_endpoint_monitor.py

@@ -3,12 +3,11 @@ import time
 import logging
 from typing import Dict, Optional
 from utils.config import config
-
 logger = logging.getLogger(__name__)
 
 class HFEndpointMonitor:
     """Monitor Hugging Face endpoint status and health"""
-
+    
     def __init__(self):
         # Clean the endpoint URL
         raw_url = config.hf_api_url or ""
@@ -23,38 +22,31 @@ class HFEndpointMonitor:
         self.successful_requests = 0
         self.failed_requests = 0
         self.avg_response_time = 0
-
         logger.info(f"Initialized HF Monitor with URL: {self.endpoint_url}")
-
+        
     def _clean_endpoint_url(self, url: str) -> str:
         """Clean and validate endpoint URL"""
         if not url:
             return ""
-
         # Remove environment variable names if present
         url = url.replace('hf_api_endpoint_url=', '')
         url = url.replace('HF_API_ENDPOINT_URL=', '')
-
         # Strip whitespace
         url = url.strip()
-
         # Ensure it starts with https://
         if url and not url.startswith(('http://', 'https://')):
             if 'huggingface.cloud' in url:
                 url = 'https://' + url
             else:
                 url = 'https://' + url
-
         # Remove trailing slashes but keep /v1 if present
         if url.endswith('/'):
             url = url.rstrip('/')
-
         return url
-
+        
     def check_endpoint_status(self) -> Dict:
         """Check if HF endpoint is available and initialized with rate limiting"""
         current_time = time.time()
-
         # Don't check too frequently - minimum 1 minute between checks
         if current_time - self.last_check < 60:
             # Return cached status or basic status
@@ -64,10 +56,8 @@ class HFEndpointMonitor:
                 'initialized': getattr(self, '_last_initialized', False),
                 'timestamp': self.last_check
             }
-
         # Proceed with actual check
         self.last_check = current_time
-
         try:
             if not self.endpoint_url or not self.hf_token:
                 status_info = {
@@ -81,15 +71,12 @@ class HFEndpointMonitor:
                 # Properly construct the models endpoint URL
                 models_url = f"{self.endpoint_url.rstrip('/')}/models"
                 logger.info(f"Checking HF endpoint at: {models_url}")
-
                 headers = {"Authorization": f"Bearer {self.hf_token}"}
-
                 response = requests.get(
                     models_url,
                     headers=headers,
                     timeout=15
                 )
-
                 status_info = {
                     'available': response.status_code in [200, 201],
                     'status_code': response.status_code,
@@ -97,23 +84,34 @@ class HFEndpointMonitor:
                     'response_time': response.elapsed.total_seconds(),
                     'timestamp': time.time()
                 }
-
+                
+                # Enhanced status info with model and region if available
+                if response.status_code in [200, 201]:
+                    try:
+                        data = response.json()
+                        if 'data' in data and len(data['data']) > 0:
+                            status_info['model'] = data['data'][0].get('id', 'Unknown')
+                        # Try to extract region from URL if possible
+                        if 'us-east-1' in self.endpoint_url:
+                            status_info['region'] = 'us-east-1'
+                        elif 'us-west' in self.endpoint_url:
+                            status_info['region'] = 'us-west'
+                    except:
+                        pass
+                        
+                    status_info['warmup_count'] = getattr(self, 'warmup_count', 0)
+                    
                 if response.status_code not in [200, 201]:
                     status_info['error'] = f"HTTP {response.status_code}: {response.text[:200]}"
-
                 logger.info(f"HF Endpoint Status: {status_info}")
-
-            # Cache the results
-            self._last_available = status_info['available']
-            self._last_status_code = status_info['status_code']
-            self._last_initialized = status_info.get('initialized', False)
-
+                # Cache the results
+                self._last_available = status_info['available']
+                self._last_status_code = status_info['status_code']
+                self._last_initialized = status_info.get('initialized', False)
             return status_info
-
         except Exception as e:
             error_msg = str(e)
             logger.error(f"HF endpoint check failed: {error_msg}")
-
             status_info = {
                 'available': False,
                 'status_code': None,
@@ -121,14 +119,12 @@ class HFEndpointMonitor:
                 'error': error_msg,
                 'timestamp': time.time()
             }
-
             # Cache the results
             self._last_available = False
             self._last_status_code = None
             self._last_initialized = False
-
             return status_info
-
+            
     def _is_endpoint_initialized(self, response) -> bool:
         """Determine if endpoint is fully initialized"""
         try:
@@ -136,40 +132,34 @@ class HFEndpointMonitor:
             return 'data' in data or 'models' in data
         except:
             return response.status_code in [200, 201]
-
+            
     def warm_up_endpoint(self) -> bool:
         """Send a warm-up request to initialize the endpoint"""
         try:
             if not self.endpoint_url or not self.hf_token:
                 logger.warning("Cannot warm up HF endpoint - URL or token not configured")
                 return False
-
             self.warmup_attempts += 1
             logger.info(f"Warming up HF endpoint (attempt {self.warmup_attempts})...")
-
             headers = {
                 "Authorization": f"Bearer {self.hf_token}",
                 "Content-Type": "application/json"
             }
-
             # Construct proper chat completions URL
             chat_url = f"{self.endpoint_url.rstrip('/')}/chat/completions"
             logger.info(f"Sending warm-up request to: {chat_url}")
-
             payload = {
-                "model": "DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf",
+                "model": "meta-llama/Llama-2-7b-chat-hf",
                 "messages": [{"role": "user", "content": "Hello"}],
                 "max_tokens": 10,
                 "stream": False
             }
-
             response = requests.post(
                 chat_url,
                 headers=headers,
                 json=payload,
                 timeout=45  # Longer timeout for cold start
             )
-
             success = response.status_code in [200, 201]
             if success:
                 self.is_initialized = True
@@ -179,14 +169,12 @@ class HFEndpointMonitor:
             else:
                 logger.warning(f"⚠️ HF endpoint warm-up response: {response.status_code}")
                 logger.debug(f"Response body: {response.text[:500]}")
-
             return success
-
         except Exception as e:
             logger.error(f"HF endpoint warm-up failed: {e}")
             self.failed_requests += 1
             return False
-
+            
     def get_status_summary(self) -> str:
         """Get human-readable status summary"""
         status = self.check_endpoint_status()
@@ -197,11 +185,10 @@ class HFEndpointMonitor:
                 return "🟡 HF Endpoint: Available but Initializing"
         else:
             return "🔴 HF Endpoint: Unavailable"
-
+            
     def handle_scale_to_zero(self) -> bool:
         """Handle scale-to-zero behavior with user feedback"""
         logger.info("HF endpoint appears to be scaled to zero. Attempting to wake it up...")
-
         # Try to warm up the endpoint
         for attempt in range(self.max_warmup_attempts):
             logger.info(f"Wake-up attempt {attempt + 1}/{self.max_warmup_attempts}")
@@ -209,15 +196,13 @@ class HFEndpointMonitor:
                 logger.info("✅ HF endpoint successfully woken up!")
                 return True
             time.sleep(10)  # Wait between attempts
-
         logger.error("❌ Failed to wake up HF endpoint after all attempts")
         return False
-
+        
     def get_detailed_status(self) -> Dict:
         """Get detailed HF endpoint status with metrics"""
         try:
             headers = {"Authorization": f"Bearer {self.hf_token}"}
-
             # Get model info
             models_url = f"{self.endpoint_url.rstrip('/')}/models"
             model_response = requests.get(
@@ -225,7 +210,6 @@ class HFEndpointMonitor:
                 headers=headers,
                 timeout=10
             )
-
             # Get endpoint info if available
             endpoint_info = {}
             try:
@@ -239,7 +223,6 @@ class HFEndpointMonitor:
                     endpoint_info = info_response.json()
             except:
                 pass
-
             status_info = {
                 'available': model_response.status_code == 200,
                 'status_code': model_response.status_code,
@@ -249,9 +232,7 @@ class HFEndpointMonitor:
                 'warmup_attempts': getattr(self, 'warmup_attempts', 0),
                 'is_warming_up': getattr(self, 'is_warming_up', False)
             }
-
             return status_info
-
         except Exception as e:
             return {
                 'available': False,
@@ -260,7 +241,7 @@ class HFEndpointMonitor:
                 'error': str(e),
                 'last_checked': time.time()
             }
-
+            
     def get_performance_metrics(self) -> Dict:
         """Get HF endpoint performance metrics"""
         return {
@@ -269,12 +250,11 @@ class HFEndpointMonitor:
             'failed_requests': getattr(self, 'failed_requests', 0),
             'average_response_time': getattr(self, 'avg_response_time', 0)
         }
-
+        
     # Add enhanced status tracking methods
     def get_enhanced_status(self) -> Dict:
         """Get enhanced HF endpoint status with engagement tracking"""
         basic_status = self.check_endpoint_status()
-
         return {
             **basic_status,
             "engagement_level": self._determine_engagement_level(),
@@ -282,7 +262,7 @@ class HFEndpointMonitor:
             "total_engagements": getattr(self, '_total_engagements', 0),
             "current_research_topic": getattr(self, '_current_research_topic', None)
         }
-
+        
     def _determine_engagement_level(self) -> str:
         """Determine current engagement level"""
         if not self.is_initialized:
@@ -293,7 +273,7 @@ class HFEndpointMonitor:
             return "research_pending"
         else:
             return "ready"
-
+            
     def start_hf_analysis(self, topic: str = None):
         """Start HF analysis with topic tracking"""
         self._currently_analyzing = True
@@ -301,7 +281,7 @@ class HFEndpointMonitor:
         self._total_engagements = getattr(self, '_total_engagements', 0) + 1
         if topic:
             self._current_research_topic = topic
-
+            
     def finish_hf_analysis(self):
         """Finish HF analysis"""
         self._currently_analyzing = False

services/weather.py

@@ -11,15 +11,7 @@ class WeatherService:
         self.base_url = "http://api.openweathermap.org/data/2.5"
         
     def get_current_weather(self, city: str) -> Optional[Dict[str, Any]]:
-        """
-        Get current weather for a city
-        
-        Args:
-            city: Name of the city
-            
-        Returns:
-            Dictionary with weather information or None if failed
-        """
+        """Get current weather for a city"""
         if not self.api_key:
             print("OpenWeather API key not configured")
             return None
@@ -30,13 +22,11 @@ class WeatherService:
                 'appid': self.api_key,
                 'units': 'metric'  # Celsius
             }
-            
             response = requests.get(
                 f"{self.base_url}/weather",
                 params=params,
                 timeout=10
             )
-            
             if response.status_code == 200:
                 data = response.json()
                 return {
@@ -51,22 +41,12 @@ class WeatherService:
             else:
                 print(f"Weather API error: {response.status_code} - {response.text}")
                 return None
-                
         except Exception as e:
             print(f"Error fetching weather data: {e}")
             return None
-    
-    def get_forecast(self, city: str, days: int = 5) -> Optional[Dict[str, Any]]:
-        """
-        Get weather forecast for a city
-        
-        Args:
-            city: Name of the city
-            days: Number of days to forecast (default: 5)
             
-        Returns:
-            Dictionary with forecast information or None if failed
-        """
+    def get_forecast(self, city: str, days: int = 5) -> Optional[Dict[str, Any]]:
+        """Get weather forecast for a city"""
         if not self.api_key:
             print("OpenWeather API key not configured")
             return None
@@ -78,17 +58,14 @@ class WeatherService:
                 'units': 'metric',
                 'cnt': days
             }
-            
             response = requests.get(
                 f"{self.base_url}/forecast",
                 params=params,
                 timeout=10
             )
-            
             if response.status_code == 200:
                 data = response.json()
                 forecasts = []
-                
                 for item in data['list']:
                     forecasts.append({
                         'datetime': item['dt_txt'],
@@ -96,7 +73,6 @@ class WeatherService:
                         'description': item['weather'][0]['description'],
                         'icon': item['weather'][0]['icon']
                     })
-                
                 return {
                     'city': data['city']['name'],
                     'country': data['city']['country'],
@@ -105,10 +81,20 @@ class WeatherService:
             else:
                 print(f"Forecast API error: {response.status_code} - {response.text}")
                 return None
-                
         except Exception as e:
             print(f"Error fetching forecast data: {e}")
             return None
+            
+    def get_weather_summary(self, city="New York") -> str:
+        """Get formatted weather summary"""
+        try:
+            weather = self.get_current_weather(city)
+            if weather:
+                return f"{weather.get('temperature', 'N/A')}°C, {weather.get('description', 'Clear skies')}"
+            else:
+                return "Clear skies"
+        except:
+            return "Clear skies"
 
 # Global weather service instance
 weather_service = WeatherService()