Implement Ollama-HF conversation coordination with expert-commentary approach

src/llm/coordinated_provider.py

@@ -0,0 +1,180 @@
+import time
+import logging
+from typing import List, Dict, Optional, Union
+from src.llm.base_provider import LLMProvider
+from src.llm.hf_provider import HuggingFaceProvider
+from src.llm.ollama_provider import OllamaProvider
+from utils.config import config
+
+logger = logging.getLogger(__name__)
+
+class CoordinatedProvider(LLMProvider):
+    """Coordinated provider that orchestrates Ollama and HF interaction"""
+    
+    def __init__(self, model_name: str, timeout: int = 120, max_retries: int = 2):
+        super().__init__(model_name, timeout, max_retries)
+        self.hf_provider = None
+        self.ollama_provider = None
+        
+        # Initialize providers
+        try:
+            if config.hf_token:
+                self.hf_provider = HuggingFaceProvider(
+                    model_name="DavidAU/OpenAi-GPT-oss-20b-abliterated-uncensored-NEO-Imatrix-gguf",
+                    timeout=120
+                )
+        except Exception as e:
+            logger.warning(f"Failed to initialize HF provider: {e}")
+            
+        try:
+            if config.ollama_host:
+                self.ollama_provider = OllamaProvider(
+                    model_name=config.local_model_name,
+                    timeout=60
+                )
+        except Exception as e:
+            logger.warning(f"Failed to initialize Ollama provider: {e}")
+
+    def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Generate coordinated response using HF+Ollama"""
+        try:
+            return self._retry_with_backoff(self._generate_coordinated_response, prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"Coordinated generation failed: {e}")
+            raise
+
+    def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
+        """Generate coordinated response with streaming support"""
+        try:
+            return self._retry_with_backoff(self._stream_generate_coordinated_response, prompt, conversation_history)
+        except Exception as e:
+            logger.error(f"Coordinated stream generation failed: {e}")
+            raise
+
+    def _generate_coordinated_response(self, prompt: str, conversation_history: List[Dict]) -> str:
+        """Main method that orchestrates both providers"""
+        try:
+            # Step 1: Get response from HF Endpoint (primary expert)
+            hf_response = self._get_hf_response(prompt, conversation_history)
+            
+            # Step 2: Get Ollama commentary on HF response
+            ollama_commentary = self._get_ollama_commentary(prompt, hf_response, conversation_history)
+            
+            # Step 3: Combine responses with clear formatting
+            coordinated_response = self._format_coordinated_response(hf_response, ollama_commentary)
+            
+            return coordinated_response
+            
+        except Exception as e:
+            logger.error(f"Coordinated response generation failed: {e}")
+            # Fallback to Ollama only
+            if self.ollama_provider:
+                try:
+                    ollama_response = self.ollama_provider.generate(prompt, conversation_history)
+                    # Generate self-commentary
+                    self_commentary = self._get_ollama_self_commentary(prompt, ollama_response, conversation_history)
+                    return self._format_fallback_response(ollama_response, self_commentary)
+                except Exception as fallback_error:
+                    logger.error(f"Ollama fallback also failed: {fallback_error}")
+            
+            raise Exception(f"Both HF Endpoint and Ollama failed: {str(e)}")
+
+    def _stream_generate_coordinated_response(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
+        """Implementation of streaming coordinated generation"""
+        # For simplicity, we'll return the full response as chunks
+        full_response = self._generate_coordinated_response(prompt, conversation_history)
+        return [full_response]
+
+    def _get_hf_response(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Get response from HF Endpoint (primary expert)"""
+        if not self.hf_provider:
+            return None
+            
+        try:
+            logger.info("🚀 Getting detailed response from HF Endpoint (primary expert)...")
+            response = self.hf_provider.generate(prompt, conversation_history)
+            logger.info("✅ HF Endpoint expert response received")
+            return response
+        except Exception as e:
+            logger.error(f"HF Endpoint expert failed: {e}")
+            return None
+
+    def _get_ollama_commentary(self, user_prompt: str, hf_response: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Get Ollama commentary on HF response"""
+        if not self.ollama_provider:
+            return None
+            
+        try:
+            logger.info("🐱 Getting Ollama commentary on HF response...")
+            commentary = self.ollama_provider.generate_commentary(user_prompt, hf_response, conversation_history)
+            logger.info("✅ Ollama commentary received")
+            return commentary
+        except Exception as e:
+            logger.warning(f"Ollama commentary failed: {e}")
+            return None
+
+    def _get_ollama_self_commentary(self, user_prompt: str, ollama_response: str, conversation_history: List[Dict]) -> Optional[str]:
+        """Get Ollama self-commentary when HF fails"""
+        if not self.ollama_provider:
+            return None
+            
+        try:
+            logger.info("🐱 Getting Ollama self-commentary on own response...")
+            commentary = self.ollama_provider.generate_self_commentary(user_prompt, ollama_response, conversation_history)
+            logger.info("✅ Ollama self-commentary received")
+            return commentary
+        except Exception as e:
+            logger.warning(f"Ollama self-commentary failed: {e}")
+            return None
+
+    def _format_coordinated_response(self, hf_response: str, ollama_commentary: str) -> str:
+        """Format combined response with clear separation"""
+        response_parts = []
+        
+        # Add HF Expert response
+        if hf_response:
+            response_parts.append("🤖 HF Expert Analysis\n" + hf_response)
+        else:
+            response_parts.append("🤖 HF Expert Analysis\n*No response from HF Expert*")
+        
+        # Add separator
+        response_parts.append("\n" + "="*50 + "\n")
+        
+        # Add Ollama Mentor commentary
+        if ollama_commentary:
+            response_parts.append("🐱 Ollama Mentor Commentary\n" + ollama_commentary)
+        else:
+            response_parts.append("🐱 Ollama Mentor Commentary\n*I've reviewed the HF expert's response but couldn't provide additional insights.*")
+        
+        return "\n\n".join(response_parts)
+
+    def _format_fallback_response(self, ollama_response: str, self_commentary: str) -> str:
+        """Format fallback response when HF fails"""
+        response_parts = []
+        
+        # Add Ollama main response with fallback indication
+        if ollama_response:
+            response_parts.append("🦙 Ollama Primary Response (HF Expert Unavailable)\n" + ollama_response)
+        else:
+            response_parts.append("🦙 Ollama Primary Response (HF Expert Unavailable)\n*No response generated*")
+        
+        # Add separator
+        response_parts.append("\n" + "="*50 + "\n")
+        
+        # Add Ollama self-commentary
+        if self_commentary:
+            response_parts.append("🐱 Ollama Self-Commentary\n" + self_commentary)
+        else:
+            response_parts.append("🐱 Ollama Self-Commentary\n*I've reviewed my own response but couldn't provide additional insights.*")
+        
+        return "\n\n".join(response_parts)
+
+    def validate_model(self) -> bool:
+        """Validate if coordinated system is available"""
+        # At least one provider must be available
+        hf_available = self.hf_provider and self.hf_provider.validate_model() if self.hf_provider else False
+        ollama_available = self.ollama_provider and self.ollama_provider.validate_model() if self.ollama_provider else False
+        return hf_available or ollama_available
+
+# Global instance
+coordinated_provider = CoordinatedProvider("coordinated_model")

src/llm/ollama_provider.py

@@ -4,12 +4,11 @@ import re
 from typing import List, Dict, Optional, Union
 from src.llm.base_provider import LLMProvider
 from utils.config import config
-from src.services.context_provider import context_provider
 
 logger = logging.getLogger(__name__)
 
 class OllamaProvider(LLMProvider):
-    """Ollama LLM provider implementation"""
+    """Ollama LLM provider implementation with commentary support"""
 
     def __init__(self, model_name: str, timeout: int = 60, max_retries: int = 3):
         super().__init__(model_name, timeout, max_retries)
@@ -58,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,
@@ -67,26 +65,108 @@ 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_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
+        ])
+        
+        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 with intelligent context"""
+        """Implementation of synchronous generation"""
         try:
             url = f"{self.host}/api/chat"
+            messages = conversation_history.copy()
+            messages.append({"role": "user", "content": prompt})
             
-            # Intelligently enrich context
-            enriched_history = self._enrich_context_intelligently(conversation_history)
-            
-            # Prepare messages - ensure proper format
-            messages = []
-            for msg in enriched_history:
-                if isinstance(msg, dict) and "role" in msg and "content" in msg:
-                    messages.append({
-                        "role": msg["role"],
-                        "content": str(msg["content"])
-                    })
-
             payload = {
                 "model": self.model_name,
                 "messages": messages,
@@ -103,6 +183,7 @@ class OllamaProvider(LLMProvider):
                 headers=self.headers,
                 timeout=self.timeout
             )
+            
             logger.info(f"Ollama response status: {response.status_code}")
             logger.info(f"Ollama response headers: {dict(response.headers)}")
 
@@ -110,7 +191,6 @@ class OllamaProvider(LLMProvider):
             result = response.json()
             logger.info(f"Ollama response body: {result}")
 
-            # Extract content properly with multiple fallbacks
             content = None
             if "message" in result and "content" in result["message"]:
                 content = result["message"]["content"]
@@ -122,23 +202,20 @@ class OllamaProvider(LLMProvider):
             logger.info(f"Extracted content length: {len(content) if content else 0}")
             return content if content else ""
 
-        except requests.exceptions.RequestException as e:
+        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"""
         try:
-            # Intelligently enrich context
-            enriched_history = self._enrich_context_intelligently(conversation_history)
-            
             url = f"{self.host}/api/chat"
+            messages = conversation_history.copy()
+            messages.append({"role": "user", "content": prompt})
+            
             payload = {
                 "model": self.model_name,
-                "messages": enriched_history,
+                "messages": messages,
                 "stream": True
             }
             
@@ -167,33 +244,5 @@ class OllamaProvider(LLMProvider):
             logger.error(f"Ollama stream generation failed: {e}")
             raise
 
-    def _enrich_context_intelligently(self, conversation_history: List[Dict]) -> List[Dict]:
-        """Intelligently add context only when relevant"""
-        if not conversation_history:
-            return conversation_history
-        
-        # Get the last user message to determine context needs
-        last_user_message = ""
-        for msg in reversed(conversation_history):
-            if msg["role"] == "user":
-                last_user_message = msg["content"]
-                break
-        
-        # Get intelligent context
-        context_string = context_provider.get_context_for_llm(
-            last_user_message, 
-            conversation_history
-        )
-        
-        # Only add context if it's relevant
-        if context_string:
-            context_message = {
-                "role": "system",
-                "content": context_string
-            }
-            # Insert context at the beginning
-            enriched_history = [context_message] + conversation_history
-            return enriched_history
-        
-        # Return original history if no context needed
-        return conversation_history
+# Global instance
+ollama_provider = OllamaProvider(config.local_model_name)

src/services/conversation_coordinator.py

@@ -0,0 +1,79 @@
+import time
+import logging
+from typing import List, Dict, Optional
+from src.llm.coordinated_provider import coordinated_provider
+from core.session import session_manager
+
+logger = logging.getLogger(__name__)
+
+class ConversationCoordinator:
+    """Service for managing conversation flow between HF and Ollama"""
+    
+    def __init__(self):
+        self.conversation_state = {}
+        
+    def coordinate_conversation(self, user_id: str, user_query: str) -> str:
+        """Main coordination method"""
+        try:
+            # Get conversation history
+            user_session = session_manager.get_session(user_id)
+            conversation_history = user_session.get("conversation", []).copy()
+            
+            # Add current user message
+            conversation_history.append({"role": "user", "content": user_query})
+            
+            # Generate coordinated response
+            response = coordinated_provider.generate(user_query, conversation_history)
+            
+            # Update session with conversation
+            if response:
+                conversation = user_session.get("conversation", []).copy()
+                conversation.append({"role": "user", "content": user_query})
+                conversation.append({"role": "assistant", "content": response})
+                session_manager.update_session(user_id, {"conversation": conversation})
+            
+            return response or "I'm processing your request..."
+            
+        except Exception as e:
+            logger.error(f"Conversation coordination failed: {e}")
+            raise
+
+    def track_conversation_state(self, user_id: str, state: str, details: Dict = None):
+        """Track conversation state between providers"""
+        try:
+            if user_id not in self.conversation_state:
+                self.conversation_state[user_id] = []
+                
+            state_entry = {
+                "state": state,
+                "timestamp": time.time(),
+                "details": details or {}
+            }
+            self.conversation_state[user_id].append(state_entry)
+            
+            # Keep only last 50 state entries
+            if len(self.conversation_state[user_id]) > 50:
+                self.conversation_state[user_id] = self.conversation_state[user_id][-50:]
+                
+        except Exception as e:
+            logger.warning(f"Failed to track conversation state: {e}")
+
+    def format_coordinated_response(self, hf_response: str, ollama_commentary: str) -> str:
+        """Format combined response with clear separation"""
+        return coordinated_provider._format_coordinated_response(hf_response, ollama_commentary)
+
+    def handle_error_state(self, user_id: str, error: Exception) -> str:
+        """Handle error conditions gracefully"""
+        try:
+            error_msg = str(error)
+            logger.error(f"Conversation coordinator error for user {user_id}: {error_msg}")
+            
+            # Return user-friendly error message
+            return f"Sorry, I encountered an error while processing your request: {error_msg[:100]}..."
+            
+        except Exception as e:
+            logger.error(f"Error handling failed: {e}")
+            return "Sorry, I encountered an unexpected error."
+
+# Global instance
+conversation_coordinator = ConversationCoordinator()

src/ui/chat_handler.py

@@ -2,40 +2,31 @@ import streamlit as st
 import time
 import logging
 from typing import Optional
-from src.llm.factory import llm_factory, ProviderNotAvailableError
+from src.llm.coordinated_provider import coordinated_provider
 from core.session import session_manager
 
 logger = logging.getLogger(__name__)
 
 class ChatHandler:
-    """Handles chat interactions with better UI feedback and session state handling"""
+    """Handles chat interactions with coordinated AI approach"""
     
     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 and proper session state handling"""
+        """Process user message with coordinated AI approach"""
         if not user_input or not user_input.strip():
             st.warning("Please enter a message")
             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}")
+        # Prevent duplicate processing
+        if st.session_state.get('last_processed_message') == user_input:
+            logger.info("Preventing duplicate message processing")
+            return
             
+        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")
@@ -43,33 +34,26 @@ class ChatHandler:
                 st.markdown(user_input)
                 st.caption(f"🕒 {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}")
+            # 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
+            })
             
             # Force UI update
             st.experimental_rerun()
             
         except Exception as e:
             logger.error(f"Error in initial message display: {e}", exc_info=True)
-            # 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}")
-    
+            st.session_state.is_processing = False
+            st.session_state.last_processed_message = ""
+
     def process_ai_response(self, user_input: str, selected_model: str):
-        """Process AI response with enhanced timeout handling and proper session state access"""
+        """Process AI response with coordinated approach"""
         if not user_input or not user_input.strip():
             return
             
@@ -80,13 +64,10 @@ class ChatHandler:
                 response_placeholder = st.empty()
                 
                 try:
-                    # Determine which provider will be used
-                    provider = llm_factory.get_provider()
-                    provider_name = "HF Endpoint" if "huggingface" in str(type(provider)).lower() else "Ollama"
-                    
-                    status_placeholder.info(f"🚀 Contacting {provider_name}...")
+                    # Show coordination status
+                    status_placeholder.info("🚀 Coordinating AI responses...")
                     
-                    # Get response
+                    # Generate coordinated response
                     response = None
                     try:
                         # Get session and conversation history
@@ -94,112 +75,56 @@ class ChatHandler:
                         conversation_history = user_session.get("conversation", []).copy()
                         conversation_history.append({"role": "user", "content": user_input})
                         
-                        response = provider.generate(user_input, conversation_history)
+                        response = coordinated_provider.generate(user_input, conversation_history)
                     except Exception as e:
-                        logger.error(f"AI response error: {e}")
+                        logger.error(f"Coordinated response error: {e}")
                         raise
                     
                     if response and response.strip():
-                        status_placeholder.success("✅ Response received!")
+                        status_placeholder.success("✅ Coordinated response received!")
                         response_placeholder.markdown(response)
                         
-                        # 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:
+                        # Add to session history
                         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
+                            "content": response,
+                            "timestamp": timestamp,
+                            "provider": "coordinated"
                         })
-                    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:
-                        error_message = f"Sorry, I encountered an error: {str(e)}"
-                    
-                    response_placeholder.markdown(error_message)
-                    try:
+                        status_placeholder.warning("⚠️ Empty coordinated response received")
+                        response_placeholder.markdown("*No coordinated response generated. Please try again.*")
                         timestamp = time.strftime("%H:%M:%S")
                         st.session_state.messages.append({
                             "role": "assistant",
-                            "content": error_message,
-                            "timestamp": timestamp
+                            "content": "*No coordinated response generated. Please try again.*",
+                            "timestamp": timestamp,
+                            "provider": "coordinated"
                         })
-                    except Exception as state_error:
-                        logger.error(f"Error updating session state: {state_error}")
+                        
+                except Exception as e:
+                    status_placeholder.error("❌ Coordination failed")
+                    
+                    # User-friendly error messages
+                    error_message = f"Sorry, I encountered an error: {str(e)[:100]}..."
+                    response_placeholder.markdown(error_message)
+                    timestamp = time.strftime("%H:%M:%S")
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": error_message,
+                        "timestamp": timestamp,
+                        "provider": "coordinated"
+                    })
                     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)
             st.error("An unexpected error occurred. Please try again.")
         finally:
-            # 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}")
+            st.session_state.is_processing = False
+            st.session_state.last_processed_message = ""
             time.sleep(0.1)
-    
-    def _get_provider_display_name(self, provider_name: str) -> str:
-        """Get display name for provider"""
-        display_names = {
-            "ollama": "🦙 Ollama",
-            "huggingface": "🤗 HF Endpoint"
-        }
-        return display_names.get(provider_name, provider_name)
 
 # Global instance
 chat_handler = ChatHandler()