Prioritize HF Endpoint as primary provider and improve timeout handling

app.py

@@ -60,14 +60,7 @@ with st.sidebar:
     st.title("🐱 CosmicCat AI Assistant")
     st.markdown("Your personal AI-powered assistant with a cosmic twist.")
     
-    # 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 selection
     model_options = {
         "Auto Select": "auto",  # Will choose best available
         "🦙 Ollama (Local)": "ollama",
@@ -84,8 +77,12 @@ 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 and hf_monitor.get_endpoint_status()["available"]:
-            actual_provider = "🤗 HF Endpoint"
+        if config.hf_token:
+            status = hf_monitor.get_endpoint_status()
+            if status["available"]:
+                actual_provider = "🤗 HF Endpoint"
+            elif config.ollama_host:
+                actual_provider = "🦙 Ollama"
         elif config.ollama_host:
             actual_provider = "🦙 Ollama"
     else:

src/llm/factory.py

@@ -1,7 +1,6 @@
 import logging
 from typing import Optional
 from src.llm.base_provider import LLMProvider
-from src.llm.mentor_provider import MentorProvider
 from src.llm.hf_provider import HuggingFaceProvider
 from src.llm.ollama_provider import OllamaProvider
 from utils.config import config
@@ -14,9 +13,10 @@ class ProviderNotAvailableError(Exception):
     pass
 
 class LLMFactory:
-    """Factory for creating LLM providers with mentor approach"""
+    """Factory for creating LLM providers with intelligent priority"""
     
     _instance = None
+    _providers = {}
 
     def __new__(cls):
         if cls._instance is None:
@@ -26,39 +26,31 @@ class LLMFactory:
     def get_provider(self, preferred_provider: Optional[str] = None) -> LLMProvider:
         """
         Get an LLM provider based on preference and availability.
-        Default: Mentor approach (HF expert + Ollama mentor)
+        NEW PRIORITY: HF Endpoint > Ollama > Error
         """
-        try:
-            # Try mentor provider first (HF expert + Ollama mentor)
-            logger.info("Initializing Mentor Provider (HF Expert + Ollama Mentor)")
-            return MentorProvider(
-                model_name="mentor_model"
-            )
-        except Exception as e:
-            logger.warning(f"Failed to initialize Mentor provider: {e}")
-            
-            # Fallback to individual providers
-            if config.hf_token:
-                status = hf_monitor.get_endpoint_status()
-                if status["available"]:
-                    try:
-                        logger.info("Falling back to HF Endpoint")
-                        return HuggingFaceProvider(
-                            model_name="DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf"
-                        )
-                    except Exception as hf_error:
-                        logger.warning(f"Failed to initialize HF provider: {hf_error}")
-            
-            if config.ollama_host:
+        # Check if HF should be primary (when token available and endpoint ready)
+        if config.hf_token:
+            hf_status = hf_monitor.get_endpoint_status()
+            if hf_status["available"]:
                 try:
-                    logger.info("Falling back to Ollama")
-                    return OllamaProvider(
-                        model_name=config.local_model_name
+                    logger.info("🎯 Using HF Endpoint as PRIMARY provider")
+                    return HuggingFaceProvider(
+                        model_name="DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf"
                     )
-                except Exception as ollama_error:
-                    logger.warning(f"Failed to initialize Ollama provider: {ollama_error}")
+                except Exception as e:
+                    logger.warning(f"Failed to initialize HF provider: {e}")
         
-        raise ProviderNotAvailableError("No LLM providers are available or configured")
+        # Try Ollama as secondary
+        if config.ollama_host:
+            try:
+                logger.info("🦙 Using Ollama as SECONDARY provider")
+                return OllamaProvider(
+                    model_name=config.local_model_name
+                )
+            except Exception as e:
+                logger.warning(f"Failed to initialize Ollama provider: {e}")
+        
+        raise ProviderNotAvailableError("No LLM providers are available")
 
 # Global factory instance
 llm_factory = LLMFactory()

src/ui/chat_handler.py

@@ -8,13 +8,13 @@ from core.session import session_manager
 logger = logging.getLogger(__name__)
 
 class ChatHandler:
-    """Handles chat interactions with mentor AI approach"""
+    """Handles chat interactions with better timeout handling"""
     
     def __init__(self):
         self.is_processing = False
         
     def process_user_message(self, user_input: str, selected_model: str):
-        """Process user message with enhanced UI feedback"""
+        """Process user message with immediate display"""
         if not user_input or not user_input.strip():
             st.warning("Please enter a message")
             return
@@ -53,7 +53,7 @@ class ChatHandler:
             st.session_state.last_processed_message = ""
     
     def process_ai_response(self, user_input: str, selected_model: str):
-        """Process AI response with mentor approach"""
+        """Process AI response with enhanced timeout handling"""
         if not user_input or not user_input.strip():
             return
             
@@ -64,17 +64,13 @@ class ChatHandler:
                 response_placeholder = st.empty()
                 
                 try:
-                    # Get mentor provider
-                    status_placeholder.info("🚀 Activating AI Mentor System...")
+                    # Determine which provider will be used
                     provider = llm_factory.get_provider()
+                    provider_name = "HF Endpoint" if "huggingface" in str(type(provider)).lower() else "Ollama"
                     
-                    # Show system status
-                    if hasattr(provider, 'hf_provider') and provider.hf_provider:
-                        status_placeholder.info("🤖 Consulting HF Expert + 🐱 Getting Ollama Mentor Insights...")
-                    else:
-                        status_placeholder.info("🦙 Consulting Local Ollama...")
+                    status_placeholder.info(f"🚀 Contacting {provider_name}...")
                     
-                    # Get response
+                    # Generate response with timeout handling
                     response = None
                     try:
                         # Get session and conversation history
@@ -83,27 +79,37 @@ 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}")
-                        raise
+                        
+                        # 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
                     
                     if response and response.strip():
-                        status_placeholder.success("✅ Expert Response + Mentor Insights Received!")
+                        status_placeholder.success("✅ Response received!")
                         response_placeholder.markdown(response)
                         
-                        # Add to session history with provider info
+                        # Add to session history
                         timestamp = time.strftime("%H:%M:%S")
-                        provider_info = "mentor_system"
-                        if hasattr(provider, 'hf_provider') and provider.hf_provider:
-                            provider_info = "mentor_hf"
-                        elif hasattr(provider, 'ollama_provider') and provider.ollama_provider:
-                            provider_info = "ollama_only"
-                            
                         st.session_state.messages.append({
                             "role": "assistant",
                             "content": response,
                             "timestamp": timestamp,
-                            "provider": provider_info
+                            "provider": provider_name.lower().replace(" ", "_")
                         })
                     else:
                         status_placeholder.warning("⚠️ Empty response received")
@@ -112,8 +118,7 @@ class ChatHandler:
                         st.session_state.messages.append({
                             "role": "assistant",
                             "content": "*No response generated. Please try again.*",
-                            "timestamp": timestamp,
-                            "provider": "unknown"
+                            "timestamp": timestamp
                         })
                         
                 except ProviderNotAvailableError as e:
@@ -127,33 +132,10 @@ class ChatHandler:
                     })
                     logger.error(f"Provider not available: {e}")
                     
-                except Exception as e:
-                    status_placeholder.error("❌ Request failed")
-                    
-                    # User-friendly error messages
-                    if "timeout" in str(e).lower() or "500" in str(e):
-                        error_message = ("⏰ Request timed out. The AI is taking too long to respond.\n\n"
-                                       "**Current setup:**\n"
-                                       "• 🤖 HF Expert: Providing deep analysis\n"
-                                       "• 🐱 Ollama Mentor: Analyzing thinking patterns\n\n"
-                                       "Please try again or simplify your question.")
-                    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": error_message,
-                        "timestamp": timestamp
-                    })
-                    logger.error(f"Chat processing error: {e}", exc_info=True)
-                    
         except Exception as e:
-            logger.error(f"Unexpected error in process_ai_response: {e}", exc_info=True)
+            logger.error(f"Chat processing failed: {e}", exc_info=True)
             st.error("An unexpected error occurred. Please try again.")
         finally:
-            # Clear processing flags
             st.session_state.is_processing = False
             st.session_state.last_processed_message = ""
             time.sleep(0.1)
@@ -161,11 +143,11 @@ class ChatHandler:
     def _get_provider_display_name(self, provider_name: str) -> str:
         """Get display name for provider"""
         display_names = {
-            "ollama_only": "🦙 Ollama (Local)",
-            "mentor_hf": "🎓 Mentor System (HF Expert + Ollama Mentor)",
-            "mentor_system": "🔄 Mentor System Active"
+            "ollama": "🦙 Ollama (Local)",
+            "huggingface": "🤗 HF Endpoint (Primary)",
+            "hf_endpoint": "🤗 HF Endpoint (Primary)"
         }
-        return display_names.get(provider_name, provider_name)
+        return display_names.get(provider_name.lower(), provider_name)
 
 # Global instance
 chat_handler = ChatHandler()