Prioritize HF Endpoint as primary provider and enhance error handling

app.py

@@ -16,6 +16,8 @@ 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
@@ -56,25 +58,43 @@ with st.sidebar:
     st.title("🐱 CosmicCat AI Assistant")
     st.markdown("Your personal AI-powered assistant with a cosmic twist.")
     
-    # Model selection
+    # Show available providers
+    available_providers = []
+    if config.hf_token and hf_monitor.get_endpoint_status()["available"]:
+        available_providers.append("🤗 HF Endpoint (Primary)")
+    if config.ollama_host:
+        available_providers.append("🦙 Ollama (Local)")
+    
+    # Model selection (now shows actual providers)
     model_options = {
-        "Mistral 7B (Local)": "mistral:latest",
-        "Llama 2 7B (Local)": "llama2:latest", 
-        "OpenChat 3.5 (Local)": "openchat:latest"
+        "Auto Select": "auto",  # Will choose best available
+        "🦙 Ollama (Local)": "ollama",
+        "🤗 HF Endpoint": "huggingface"
     }
-    selected_model_name = st.selectbox(
-        "Select Model",
+    
+    selected_model_key = st.selectbox(
+        "Select Provider",
         options=list(model_options.keys()),
-        index=0,
-        on_change=lambda: session_analytics.track_interaction("default_user", st.session_state.session_id, "model_selection", {
-            "selected_model": st.session_state.selected_model if 'selected_model' in st.session_state else model_options[list(model_options.keys())[0]]
-        })
+        index=0
     )
-    st.session_state.selected_model = model_options[selected_model_name]
+    selected_model_value = model_options[selected_model_key]
+    
+    # Show which provider will actually be used
+    actual_provider = "Unknown"
+    if selected_model_value == "auto":
+        if config.hf_token and hf_monitor.get_endpoint_status()["available"]:
+            actual_provider = "🤗 HF Endpoint"
+        elif config.ollama_host:
+            actual_provider = "🦙 Ollama"
+    else:
+        actual_provider = "🤗 HF Endpoint" if selected_model_value == "huggingface" else "🦙 Ollama"
+    
+    st.info(f"**Using Provider:** {actual_provider}")
     
     # Log model selection
     session_analytics.track_interaction("default_user", st.session_state.session_id, "model_selection", {
-        "selected_model": st.session_state.selected_model
+        "selected_model": selected_model_value,
+        "actual_provider": actual_provider
     })
     
     # Cosmic mode toggle
@@ -269,7 +289,7 @@ user_input = st.chat_input("Type your message here...", key="chat_input")
 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, selected_model_name)
+        chat_handler.process_user_message(user_input, selected_model_value)
     else:
         st.warning("Still processing your previous request...")
 
@@ -277,7 +297,7 @@ if user_input and user_input.strip():
 if st.session_state.get('is_processing', False) and st.session_state.get('last_processed_message'):
     chat_handler.process_ai_response(
         st.session_state.last_processed_message, 
-        selected_model_name
+        selected_model_value
     )
 
 # About tab
@@ -299,8 +319,8 @@ with tab1:
     When enabled, the AI responds with space-themed language and metaphors.
     
     ### 🛠️ Technical Architecture
-    - **Primary model**: Ollama (local processing)
-    - **Secondary model**: HF Endpoint (advanced processing)
+    - **Primary model**: HF Endpoint (advanced processing)
+    - **Secondary model**: Ollama (local processing)
     - **Memory system**: Redis-based session management
     """)
     

src/llm/factory.py

@@ -25,54 +25,31 @@ class LLMFactory:
     def get_provider(self, preferred_provider: Optional[str] = None) -> LLMProvider:
         """
         Get an LLM provider based on preference and availability.
+        Priority: HF Endpoint > Ollama > Error
         """
-        # Try preferred provider first
-        if preferred_provider:
-            provider = self._try_provider(preferred_provider)
-            if provider:
-                return provider
-        
-        # Try HF provider if configured
+        # Check if HF token is available and endpoint is ready
         if config.hf_token:
-            provider = self._try_provider("huggingface")
-            if provider:
-                return provider
-        
-        # Try Ollama as fallback
-        if config.ollama_host:
-            provider = self._try_provider("ollama")
-            if provider:
-                return provider
-        
-        raise ProviderNotAvailableError("No LLM providers are available or configured")
-
-    def _try_provider(self, provider_name: str) -> Optional[LLMProvider]:
-        """Try to initialize a specific provider"""
-        try:
-            if provider_name == "huggingface" and config.hf_token:
-                # Check if HF endpoint is available
-                status = hf_monitor.get_endpoint_status()
-                if status["available"] or status["initializing"]:
+            status = hf_monitor.get_endpoint_status()
+            if status["available"]:
+                try:
+                    logger.info("Using HF Endpoint as primary provider")
                     return HuggingFaceProvider(
                         model_name="DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf"
                     )
-                elif status["status"] == "scaled_to_zero":
-                    # Attempt to wake up the endpoint
-                    logger.info("Attempting to wake up HF endpoint...")
-                    if hf_monitor.attempt_wake_up():
-                        return HuggingFaceProvider(
-                            model_name="DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf"
-                        )
-                        
-            elif provider_name == "ollama" and config.ollama_host:
+                except Exception as e:
+                    logger.warning(f"Failed to initialize HF provider: {e}")
+        
+        # Try Ollama as fallback
+        if config.ollama_host:
+            try:
+                logger.info("Using Ollama as provider")
                 return OllamaProvider(
                     model_name=config.local_model_name
                 )
-                
-        except Exception as e:
-            logger.warning(f"Failed to initialize {provider_name} provider: {e}")
-            
-        return None
+            except Exception as e:
+                logger.warning(f"Failed to initialize Ollama provider: {e}")
+        
+        raise ProviderNotAvailableError("No LLM providers are available or configured")
 
 # Global factory instance
 llm_factory = LLMFactory()

src/ui/chat_handler.py

@@ -4,6 +4,7 @@ import logging
 from typing import Optional
 from src.llm.factory import llm_factory, ProviderNotAvailableError
 from core.session import session_manager
+from utils.config import config
 
 logger = logging.getLogger(__name__)
 
@@ -24,18 +25,17 @@ class ChatHandler:
             logger.info("Preventing duplicate message processing")
             return
             
-        # Set processing flag
         st.session_state.is_processing = True
         st.session_state.last_processed_message = user_input
         
         try:
-            # Show user message immediately (this was missing!)
+            # Show user message immediately
             timestamp = time.strftime("%H:%M:%S")
             with st.chat_message("user"):
                 st.markdown(user_input)
                 st.caption(f"🕒 {timestamp}")
             
-            # Add to session state history immediately
+            # Add to session state history
             if "messages" not in st.session_state:
                 st.session_state.messages = []
                 
@@ -45,7 +45,7 @@ class ChatHandler:
                 "timestamp": timestamp
             })
             
-            # Force immediate UI update
+            # Force UI update
             st.experimental_rerun()
             
         except Exception as e:
@@ -65,8 +65,8 @@ class ChatHandler:
                 response_placeholder = st.empty()
                 
                 try:
-                    # Determine provider based on model selection
-                    provider_name = self._get_provider_for_model(selected_model)
+                    # Determine provider based on selection and availability
+                    provider_name = self._get_best_provider(selected_model)
                     status_placeholder.info(f"🚀 Contacting {self._get_provider_display_name(provider_name)}...")
                     
                     # Get response with timeout handling
@@ -112,12 +112,32 @@ class ChatHandler:
                     logger.error(f"Provider not available: {e}")
                     
                 except Exception as e:
-                    status_placeholder.error(f"❌ Error: {str(e)[:100]}...")
-                    response_placeholder.markdown(f"Sorry, I encountered an error: {str(e)[:100]}...")
+                    # 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 failed. This might be because:\n"
+                                       "• The AI model is taking too long to respond\n"
+                                       "• The provider is overloaded\n\n"
+                                       "**Try one of these solutions:**\n"
+                                       "1. Use the HF Endpoint (🟢 HF Endpoint: Available and ready)\n"
+                                       "2. Wait a moment and try again\n"
+                                       "3. Simplify your question")
+                    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:
+                        error_message = f"Sorry, I encountered an error: {str(e)}"
+                    
+                    response_placeholder.markdown(error_message)
                     timestamp = time.strftime("%H:%M:%S")
                     st.session_state.messages.append({
                         "role": "assistant",
-                        "content": f"Sorry, I encountered an error: {str(e)[:100]}...",
+                        "content": error_message,
                         "timestamp": timestamp
                     })
                     logger.error(f"Chat processing error: {e}", exc_info=True)
@@ -130,16 +150,27 @@ class ChatHandler:
             st.session_state.is_processing = False
             st.session_state.last_processed_message = ""
             time.sleep(0.1)
-            st.experimental_rerun()
     
-    def _get_provider_for_model(self, selected_model: str) -> str:
-        """Determine which provider to use based on model selection"""
-        model_to_provider = {
-            "Mistral 7B (Local)": "ollama",
-            "Llama 2 7B (Local)": "ollama",
-            "OpenChat 3.5 (Local)": "ollama"
-        }
-        return model_to_provider.get(selected_model, "ollama")
+    def _get_best_provider(self, selected_model: str) -> str:
+        """Determine the best available provider"""
+        from src.services.hf_monitor import hf_monitor
+        
+        # If user selected specific provider, try that
+        if selected_model == "ollama" and config.ollama_host:
+            return "ollama"
+        elif selected_model == "huggingface" and config.hf_token:
+            return "huggingface"
+        
+        # Auto-select based on availability
+        if config.hf_token:
+            status = hf_monitor.get_endpoint_status()
+            if status["available"]:
+                return "huggingface"
+        
+        if config.ollama_host:
+            return "ollama"
+            
+        return "ollama"  # Default fallback
     
     def _get_provider_display_name(self, provider_name: str) -> str:
         """Get display name for provider"""
@@ -159,7 +190,7 @@ class ChatHandler:
             # Add current user message
             conversation_history.append({"role": "user", "content": user_input})
             
-            # Get provider
+            # Get provider (with intelligent fallback)
             provider = llm_factory.get_provider(provider_name)
             
             # Generate response with timeout