Fix UI issues, restore advanced debug panel, and improve Ollama connection handling

app.py

@@ -10,7 +10,6 @@ from utils.config import config
 from core.llm import send_to_ollama, send_to_hf
 from core.session import session_manager
 from core.memory import check_redis_health
-from core.coordinator import coordinator
 import logging
 
 # Set up logging
@@ -26,10 +25,10 @@ if "last_error" not in st.session_state:
     st.session_state.last_error = ""
 if "is_sending" not in st.session_state:
     st.session_state.is_sending = False
-if "current_coordination" not in st.session_state:
-    st.session_state.current_coordination = None
+if "ngrok_url_temp" not in st.session_state:
+    st.session_state.ngrok_url_temp = st.session_state.get("ngrok_url", "https://7bcc180dffd1.ngrok-free.app")
 
-# Enhanced Sidebar
+# Sidebar with restored advanced debug panel
 with st.sidebar:
     st.title("AI Life Coach 🧠")
     st.markdown("Your personal AI-powered life development assistant")
@@ -47,16 +46,44 @@ with st.sidebar:
     )
     st.session_state.selected_model = model_options[selected_model_name]
     
-    # Ollama URL input
-    st.session_state.ngrok_url = st.text_input(
+    # Ollama URL input with better feedback
+    st.subheader("Ollama Configuration")
+    ngrok_url_input = st.text_input(
         "Ollama Server URL",
-        value=st.session_state.get("ngrok_url", "http://localhost:11434"),
-        help="Enter the URL to your Ollama server"
+        value=st.session_state.ngrok_url_temp,
+        help="Enter your ngrok URL (e.g., https://abcd1234.ngrok-free.app)",
+        key="ngrok_url_input"
     )
     
-    # Enhanced Conversation History
+    # Update URL with feedback
+    if ngrok_url_input != st.session_state.ngrok_url_temp:
+        st.session_state.ngrok_url_temp = ngrok_url_input
+        st.success("✅ URL updated! Click 'Test Connection' below.")
+    
+    # Test connection button
+    if st.button("📡 Test Ollama Connection"):
+        try:
+            import requests
+            headers = {
+                "ngrok-skip-browser-warning": "true",
+                "User-Agent": "AI-Life-Coach-Test"
+            }
+            response = requests.get(
+                f"{ngrok_url_input}/api/tags",
+                headers=headers,
+                timeout=10
+            )
+            if response.status_code == 200:
+                st.success("✅ Ollama connection successful!")
+                st.session_state.ngrok_url = ngrok_url_input
+            else:
+                st.error(f"❌ Connection failed: {response.status_code}")
+        except Exception as e:
+            st.error(f"❌ Connection error: {str(e)}")
+    
+    # Conversation history
     st.subheader("Conversation History")
-    if st.button("Clear History 🗑️"):
+    if st.button("🗑️ Clear History"):
         st.session_state.messages = []
         st.success("History cleared!")
     
@@ -66,64 +93,87 @@ with st.sidebar:
         ai_msgs = len([m for m in st.session_state.messages if m["role"] == "assistant"])
         st.caption(f"💬 {user_msgs} user messages, {ai_msgs} AI responses")
     
-    # Enhanced Debug Panel
-    with st.expander("🔍 Advanced System Monitor", expanded=True):
+    # Restored Advanced Debug Panel
+    with st.expander("🔍 Advanced System Monitor", expanded=False):
         st.subheader("🎛️ System Controls")
         
-        # Real-time coordination status
-        if st.session_state.current_coordination:
-            coord = st.session_state.current_coordination
-            st.info(f"🔄 Coordination in progress...")
-            st.caption(f"Phase: {coord.get('phase', 'Unknown')}")
-            st.caption(f"Status: {coord.get('status', 'Unknown')}")
+        # Fallback Mode Toggle
+        fallback_mode = st.checkbox(
+            "Enable Provider Fallback",
+            value=config.use_fallback,
+            help="Enable automatic fallback between AI providers"
+        )
+        
+        # HF Deep Analysis Toggle
+        hf_analysis = st.checkbox(
+            "Enable HF Deep Analysis",
+            value=bool(config.hf_token),
+            help="Enable Hugging Face endpoint for deep analysis"
+        )
         
-        # HF Endpoint Status with detailed monitoring
+        st.divider()
+        
+        st.subheader("📊 Provider Status")
+        
+        # Ollama Status
+        try:
+            from services.ollama_monitor import check_ollama_status
+            ollama_status = check_ollama_status()
+            if ollama_status.get("running"):
+                st.success(f"🦙 Ollama: Running")
+                if ollama_status.get("model_loaded"):
+                    st.caption(f"Model: {ollama_status['model_loaded']}")
+            else:
+                st.error("🦙 Ollama: Unavailable")
+        except Exception as e:
+            st.warning("🦙 Ollama: Status check failed")
+        
+        # HF Endpoint Status
         try:
             from services.hf_endpoint_monitor import hf_monitor
             hf_status = hf_monitor.check_endpoint_status()
-            
             if hf_status['available']:
                 if hf_status.get('initialized'):
                     st.success("🤗 HF Endpoint: Available & Initialized")
                 else:
                     st.warning("🤗 HF Endpoint: Available (Initializing)")
-                    if st.button("⚡ Wake Up HF Endpoint"):
-                        with st.spinner("Waking up HF endpoint... (2-4 minutes)"):
-                            success = hf_monitor.handle_scale_to_zero()
-                            if success:
-                                st.success("✅ HF endpoint activated!")
-                                time.sleep(1)
-                                st.experimental_rerun()
             else:
                 st.error("🤗 HF Endpoint: Scaled to Zero")
-                st.caption(f"Status Code: {hf_status.get('status_code', 'N/A')}")
-        
         except Exception as e:
             st.warning("🤗 HF Endpoint: Monitor unavailable")
+        
+        # Redis Status
+        redis_healthy = check_redis_health()
+        if redis_healthy:
+            st.success("💾 Redis: Connected")
+        else:
+            st.error("💾 Redis: Disconnected")
+        
+        st.divider()
+        
+        st.subheader("📈 Session Statistics")
+        
+        # Session Stats
+        try:
+            user_session = session_manager.get_session("default_user")
+            conversation = user_session.get("conversation", [])
+            st.caption(f"💬 Messages: {len(conversation)}")
+        except Exception as e:
+            st.caption("💬 Session: Not initialized")
 
-# Enhanced Main Interface
+# Main chat interface
 st.title("🧠 AI Life Coach")
 st.markdown("Ask me anything about personal development, goal setting, or life advice!")
 
-# Display chat messages with enhanced formatting
-for i, message in enumerate(st.session_state.messages):
+# Display chat messages
+for message in st.session_state.messages:
     with st.chat_message(message["role"]):
-        # Add message metadata
-        if message["role"] == "assistant":
-            # Show which model responded
-            if "Note: A more comprehensive analysis" in message["content"]:
-                st.caption("🦙 Ollama (initial response)")
-            elif "🎯 HF analysis complete" in str(message.get("metadata", "")):
-                st.caption("🤗 HF Endpoint (deep analysis)")
-        
         st.markdown(message["content"])
-        
-        # Show message timestamp
         if "timestamp" in message:
             st.caption(f"🕒 {message['timestamp']}")
 
-# Enhanced chat input with better feedback
-col1, col2, col3 = st.columns([3, 1, 1])
+# Enhanced chat input with proper feedback
+col1, col2 = st.columns([4, 1])
 with col1:
     user_input = st.text_input(
         "Your message...",
@@ -134,21 +184,17 @@ with col1:
     )
 with col2:
     send_button = st.button(
-        "Send 🚀" if not st.session_state.is_sending else "Sending...",
+        "Send" if not st.session_state.is_sending else "⏳ Sending...",
         key="send_message_button",
         use_container_width=True,
         disabled=st.session_state.is_sending or not user_input.strip()
     )
-with col3:
-    # Add a "thinking" indicator
-    if st.session_state.is_sending:
-        st.info("🧠 Thinking...")
 
-# Enhanced message sending with coordination feedback
+# Improved message sending
 if send_button and user_input.strip() and not st.session_state.is_sending:
     st.session_state.is_sending = True
     
-    # Display user message immediately
+    # Display user message immediately and clear input
     with st.chat_message("user"):
         st.markdown(user_input)
     
@@ -162,97 +208,72 @@ if send_button and user_input.strip() and not st.session_state.is_sending:
     # Reset error state
     st.session_state.last_error = ""
     
-    # Enhanced coordination processing
+    # Process AI response
     with st.chat_message("assistant"):
-        # Create containers for different response components
-        ollama_container = st.empty()
-        coordination_status = st.empty()
-        hf_thinking_container = st.empty()
-        final_response_container = st.empty()
-        
-        try:
-            # Use enhanced coordinator with real-time feedback
-            import asyncio
+        with st.spinner("🧠 AI Coach is thinking..."):
+            ai_response = None
+            error_msg = ""
             
-            async def process_with_feedback():
-                user_id = "default_user"
-                full_response = ""
-                ollama_response = ""
-                hf_response = ""
-                
-                # Track coordination phases
-                st.session_state.current_coordination = {
-                    "phase": "starting",
-                    "status": "Initializing coordination..."
-                }
+            try:
+                # Use session manager for conversation history
+                user_session = session_manager.get_session("default_user")
+                conversation = user_session.get("conversation", [])
+                conversation_history = conversation[-5:]  # Last 5 messages
+                conversation_history.append({"role": "user", "content": user_input})
                 
-                async for response_chunk in coordinator.coordinate_hierarchical_conversation(user_id, user_input):
-                    st.session_state.current_coordination = {
-                        "phase": response_chunk['type'],
-                        "status": response_chunk['content'][:100]
-                    }
+                # Try Ollama first with improved timeout handling
+                try:
+                    ai_response = send_to_ollama(
+                        user_input,
+                        conversation_history,
+                        st.session_state.ngrok_url_temp,
+                        st.session_state.selected_model
+                    )
+                    if ai_response:
+                        st.success("✅ Response received!")
+                    else:
+                        st.warning("⚠️ Empty response from Ollama")
+                except Exception as e:
+                    error_msg = f"Ollama error: {str(e)}"
+                    st.error(f"❌ Ollama failed: {str(e)[:100]}...")
                     
-                    if response_chunk['type'] == 'initial_response':
-                        ollama_response = response_chunk['content']
-                        ollama_container.markdown(f"**🦙 Ollama (Fast Response):**\n\n{ollama_response}")
-                        full_response = ollama_response
-                    
-                    elif response_chunk['type'] == 'coordination_status':
-                        coordination_status.info(f"🤖 {response_chunk['content']}")
+                    # Fallback to Hugging Face if configured
+                    if config.hf_token:
+                        try:
+                            st.info("🔄 Falling back to Hugging Face...")
+                            ai_response = send_to_hf(user_input, conversation_history)
+                            if ai_response:
+                                st.success("✅ HF Response received!")
+                        except Exception as hf_e:
+                            error_msg += f" | HF error: {str(hf_e)}"
+                            st.error(f"❌ HF also failed: {str(hf_e)[:100]}...")
+                
+                if ai_response:
+                    st.markdown(ai_response)
                     
-                    elif response_chunk['type'] == 'hf_thinking':
-                        hf_response += response_chunk['content']
-                        with hf_thinking_container.container():
-                            st.markdown(f"**🤗 HF Endpoint (Deep Analysis):**")
-                            st.info(hf_response)
-                        full_response = hf_response
+                    # Update conversation history
+                    conversation.append({"role": "user", "content": user_input})
+                    conversation.append({"role": "assistant", "content": ai_response})
+                    user_session["conversation"] = conversation
+                    session_manager.update_session("default_user", user_session)
                     
-                    elif response_chunk['type'] == 'final_response':
-                        hf_response = response_chunk['content']
-                        final_response_container.markdown(f"**🎯 Final Response:**\n\n{hf_response}")
-                        full_response = hf_response
-                        coordination_status.success("✅ Coordination complete!")
-                
-                return full_response
-            
-            # Run the enhanced processing
-            full_response = asyncio.run(process_with_feedback())
-            
-            # Update session with complete conversation
-            user_session = session_manager.get_session("default_user")
-            conversation = user_session.get("conversation", [])
-            conversation.append({"role": "user", "content": user_input})
-            conversation.append({"role": "assistant", "content": full_response})
-            user_session["conversation"] = conversation
-            session_manager.update_session("default_user", user_session)
+                    # Add assistant response to history
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": ai_response,
+                        "timestamp": datetime.now().strftime("%H:%M:%S")
+                    })
+                else:
+                    st.error("❌ Failed to get response from any provider.")
+                    st.session_state.last_error = error_msg or "No response from either provider"
             
-            # Add to message history
-            st.session_state.messages.append({
-                "role": "assistant",
-                "content": full_response,
-                "timestamp": datetime.now().strftime("%H:%M:%S"),
-                "metadata": {"source": "coordinated_response"}
-            })
-        
-        except Exception as e:
-            st.error(f"❌ Error: {str(e)}")
-            st.session_state.last_error = str(e)
-        finally:
-            st.session_state.is_sending = False
-            st.session_state.current_coordination = None
-    
-    # Force rerun to update UI
-    st.experimental_rerun()
+            except Exception as e:
+                st.error(f"❌ Unexpected error: {str(e)}")
+                st.session_state.last_error = str(e)
+            finally:
+                st.session_state.is_sending = False
 
-# Add conversation export feature
-if st.session_state.messages and st.sidebar.button("📤 Export Conversation"):
-    conversation_text = ""
-    for msg in st.session_state.messages:
-        conversation_text += f"{msg['role'].upper()}: {msg['content']}\n\n"
-    
-    st.sidebar.download_button(
-        label="💾 Download Conversation",
-        data=conversation_text,
-        file_name=f"ai_life_coach_conversation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
-        mime="text/plain"
-    )
+# Clear input and refresh (this helps clear the text input)
+if st.session_state.is_sending:
+    time.sleep(0.1)  # Brief pause
+    st.experimental_rerun()

core/providers/ollama.py

@@ -10,7 +10,7 @@ logger = logging.getLogger(__name__)
 class OllamaProvider(LLMProvider):
     """Ollama LLM provider implementation"""
     
-    def __init__(self, model_name: str, timeout: int = 30, max_retries: int = 3):
+    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
@@ -18,24 +18,20 @@ class OllamaProvider(LLMProvider):
             "ngrok-skip-browser-warning": "true",
             "User-Agent": "AI-Life-Coach-Ollama"
         }
-    
+
     def _sanitize_host(self, host: str) -> str:
         """Sanitize host URL by removing whitespace and control characters"""
         if not host:
             return "http://localhost:11434"
-        
         # Remove leading/trailing whitespace and control characters
         host = host.strip()
-        
         # Remove any newlines or control characters
         host = re.sub(r'[\r\n\t\0]+', '', host)
-        
         # Ensure URL has a scheme
         if not host.startswith(('http://', 'https://')):
             host = 'http://' + host
-            
         return host
-    
+
     def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
         """Generate a response synchronously"""
         try:
@@ -43,7 +39,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:
@@ -51,7 +47,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:
@@ -60,7 +56,6 @@ class OllamaProvider(LLMProvider):
                 headers=self.headers,
                 timeout=self.timeout
             )
-            
             if response.status_code == 200:
                 models = response.json().get("models", [])
                 model_names = [model.get("name") for model in models]
@@ -73,62 +68,53 @@ class OllamaProvider(LLMProvider):
                     timeout=self.timeout
                 )
                 return response2.status_code == 200
-            
             return False
         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"""
         url = f"{self.host}/api/chat"
         messages = conversation_history.copy()
-        
         # Add the current prompt if not already in history
         if not messages or messages[-1].get("content") != prompt:
             messages.append({"role": "user", "content": prompt})
-        
         payload = {
             "model": self.model_name,
             "messages": messages,
             "stream": False
         }
-        
         response = requests.post(
-            url, 
-            json=payload, 
+            url,
+            json=payload,
             headers=self.headers,
             timeout=self.timeout
         )
         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"""
         url = f"{self.host}/api/chat"
         messages = conversation_history.copy()
-        
         # Add the current prompt if not already in history
         if not messages or messages[-1].get("content") != prompt:
             messages.append({"role": "user", "content": prompt})
-        
         payload = {
             "model": self.model_name,
             "messages": messages,
             "stream": True
         }
-        
         response = requests.post(
-            url, 
-            json=payload, 
+            url,
+            json=payload,
             headers=self.headers,
             timeout=self.timeout,
             stream=True
         )
         response.raise_for_status()
-        
         chunks = []
         for line in response.iter_lines():
             if line:
@@ -140,5 +126,4 @@ class OllamaProvider(LLMProvider):
                         chunks.append(content)
                 except:
                     continue
-                    
         return chunks

test_ui_fixes.py

@@ -0,0 +1,89 @@
+import sys
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+def test_ui_fixes():
+    """Test the UI fixes and improvements"""
+    print("=== UI Fixes Test ===")
+    print()
+    
+    # Test 1: Check if app.py was updated correctly
+    print("1. Testing app.py structure:")
+    try:
+        with open('app.py', 'r') as f:
+            content = f.read()
+            
+        # Check for key components
+        required_components = [
+            'st.session_state.ngrok_url_temp',
+            'Test Ollama Connection',
+            'Advanced System Monitor',
+            '📡 Test Ollama Connection',
+            'is_sending'
+        ]
+        
+        missing_components = []
+        for component in required_components:
+            if component not in content:
+                missing_components.append(component)
+        
+        if missing_components:
+            print(f"   ❌ Missing components: {missing_components}")
+        else:
+            print("   ✅ All required UI components present")
+            
+    except Exception as e:
+        print(f"   ❌ Error reading app.py: {e}")
+    
+    print()
+    
+    # Test 2: Check Ollama provider timeout
+    print("2. Testing Ollama provider timeout:")
+    try:
+        with open('core/providers/ollama.py', 'r') as f:
+            content = f.read()
+            
+        if 'timeout: int = 60' in content:
+            print("   ✅ Ollama timeout increased to 60 seconds")
+        else:
+            print("   ❌ Ollama timeout not updated")
+            
+    except Exception as e:
+        print(f"   ❌ Error reading Ollama provider: {e}")
+    
+    print()
+    
+    # Test 3: Check for debug panel restoration
+    print("3. Testing debug panel restoration:")
+    try:
+        with open('app.py', 'r') as f:
+            content = f.read()
+            
+        debug_features = [
+            'Advanced System Monitor',
+            'System Controls',
+            'Provider Status',
+            'Session Statistics'
+        ]
+        
+        missing_features = []
+        for feature in debug_features:
+            if feature not in content:
+                missing_features.append(feature)
+        
+        if missing_features:
+            print(f"   ❌ Missing debug features: {missing_features}")
+        else:
+            print("   ✅ All debug panel features restored")
+            
+    except Exception as e:
+        print(f"   ❌ Error checking debug panel: {e}")
+    
+    print()
+    print("🎉 UI Fixes Test Completed!")
+
+if __name__ == "__main__":
+    test_ui_fixes()