Implement enhanced UI with better feedback and detailed AI coordination tracking

app.py

@@ -10,6 +10,7 @@ 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
@@ -23,22 +24,14 @@ if "messages" not in st.session_state:
     st.session_state.messages = []
 if "last_error" not in st.session_state:
     st.session_state.last_error = ""
-if "last_ollama_call_success" not in st.session_state:
-    st.session_state.last_ollama_call_success = None
-if "last_ollama_call_time" not in st.session_state:
-    st.session_state.last_ollama_call_time = ""
-if "last_ollama_response_preview" not in st.session_state:
-    st.session_state.last_ollama_response_preview = ""
-if "last_hf_call_success" not in st.session_state:
-    st.session_state.last_hf_call_success = None
-if "last_hf_call_time" not in st.session_state:
-    st.session_state.last_hf_call_time = ""
-if "last_hf_response_preview" not in st.session_state:
-    st.session_state.last_hf_response_preview = ""
+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
 
-# Sidebar
+# Enhanced Sidebar
 with st.sidebar:
-    st.title("AI Life Coach")
+    st.title("AI Life Coach 🧠")
     st.markdown("Your personal AI-powered life development assistant")
     
     # Model selection
@@ -61,272 +54,205 @@ with st.sidebar:
         help="Enter the URL to your Ollama server"
     )
     
-    # Conversation history
+    # Enhanced Conversation History
     st.subheader("Conversation History")
-    if st.button("Clear History"):
+    if st.button("Clear History 🗑️"):
         st.session_state.messages = []
         st.success("History cleared!")
     
+    # Show conversation stats
+    if st.session_state.messages:
+        user_msgs = len([m for m in st.session_state.messages if m["role"] == "user"])
+        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.sidebar.expander("🔍 Advanced System Monitor", expanded=False):
+    with st.expander("🔍 Advanced System Monitor", expanded=True):
         st.subheader("🎛️ System Controls")
         
-        # 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"
-        )
-        
-        # Web Search Toggle
-        web_search = st.checkbox(
-            "Enable Web Research",
-            value=bool(os.getenv("TAVILY_API_KEY")),
-            help="Enable Tavily/DDG web search integration"
-        )
-        
-        st.divider()
-        
-        st.subheader("📊 Provider Status")
-        
-        # Ollama Status with Detailed Info
-        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']}")
-                st.caption(f"URL: {ollama_status.get('ngrok_url', 'N/A')}")
-            else:
-                st.error("🦙 Ollama: Unavailable")
-                if st.button("🔄 Refresh Ollama Status", key="refresh_ollama"):
-                    st.experimental_rerun()
-        except Exception as e:
-            st.warning(f"🦙 Ollama: Status check failed")
+        # 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')}")
         
-        # HF Endpoint Status with Scale-to-Zero Handling
+        # HF Endpoint Status with detailed monitoring
         try:
             from services.hf_endpoint_monitor import hf_monitor
-            hf_status_detail = hf_monitor.check_endpoint_status()
+            hf_status = hf_monitor.check_endpoint_status()
             
-            if hf_status_detail['available']:
-                if hf_status_detail.get('initialized', False):
+            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")
-            
-            # Show detailed status
-            st.caption(f"Status Code: {hf_status_detail.get('status_code', 'N/A')}")
-            if 'response_time' in hf_status_detail:
-                st.caption(f"Response Time: {hf_status_detail['response_time']:.2f}s")
-            
-            # Wake-up button for scaled-to-zero endpoints
-            if not hf_status_detail['available'] and config.hf_token:
-                if st.button("⚡ Wake Up HF Endpoint", key="wake_hf"):
-                    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(2)
-                            st.experimental_rerun()
-                        else:
-                            st.error("❌ Failed to activate HF endpoint")
-        
-        except Exception as e:
-            st.warning(f"🤗 HF Endpoint: Monitor unavailable")
-            st.caption(f"Error: {str(e)[:50]}...")
-        
-        # Redis Status
-        redis_healthy = check_redis_health()
-        if redis_healthy:
-            st.success("💾 Redis: Connected")
-        else:
-            st.error("💾 Redis: Disconnected")
-        
-        st.divider()
-        
-        st.subheader("🌐 External Services")
-        
-        # Web Search Status
-        tavily_key = os.getenv("TAVILY_API_KEY")
-        if tavily_key:
-            st.success("🔍 Web Search: Tavily API Active")
-            # Test search button
-            if st.button("🧪 Test Web Search", key="test_web_search"):
-                try:
-                    from tavily import TavilyClient
-                    tavily = TavilyClient(api_key=tavily_key)
-                    with st.spinner("Testing web search..."):
-                        test_result = tavily.search("AI life coach benefits", max_results=1)
-                        st.success("✅ Web search working!")
-                except Exception as e:
-                    st.error(f"❌ Web search test failed: {str(e)[:30]}...")
-        else:
-            st.info("🔍 Web Search: Not configured")
-        
-        # Weather Service
-        if config.openweather_api_key:
-            st.success("🌤️ Weather: API Active")
-            if st.button("🌡️ Test Weather", key="test_weather"):
-                try:
-                    from services.weather import weather_service
-                    with st.spinner("Testing weather service..."):
-                        test_weather = weather_service.get_current_weather("New York")
-                        if test_weather:
-                            st.success(f"✅ Weather working! {test_weather['temperature']}°C in New York")
-                        else:
-                            st.warning("⚠️ Weather service returned no data")
-                except Exception as e:
-                    st.error(f"❌ Weather test failed: {str(e)[:30]}...")
-        else:
-            st.info("🌤️ Weather: Not configured")
-        
-        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)}")
-            
-            # AI Coordination Stats (if available)
-            coord_stats = user_session.get('ai_coordination', {})
-            if coord_stats:
-                st.caption(f"🤖 AI Requests: {coord_stats.get('requests_processed', 0)}")
-                st.caption(f"🦙 Ollama Responses: {coord_stats.get('ollama_responses', 0)}")
-                st.caption(f"🤗 HF Responses: {coord_stats.get('hf_responses', 0)}")
-            else:
-                st.caption("🤖 AI Coordination: Not active")
+                st.caption(f"Status Code: {hf_status.get('status_code', 'N/A')}")
         
         except Exception as e:
-            st.caption("💬 Session: Not initialized")
-        
-        st.divider()
-        
-        st.subheader("⚙️ Configuration")
-        st.caption(f"**Environment**: {'☁️ HF Space' if config.is_hf_space else '🏠 Local'}")
-        st.caption(f"**Primary Model**: {config.local_model_name or 'Not set'}")
-        
-        # Feature Flags Summary
-        features = []
-        if fallback_mode:
-            features.append("Fallback")
-        if hf_analysis and config.hf_token:
-            features.append("HF Deep Analysis")
-        if web_search and tavily_key:
-            features.append("Web Search")
-        if config.openweather_api_key:
-            features.append("Weather")
-        
-        if features:
-            st.caption(f"**Active Features**: {', '.join(features)}")
-        else:
-            st.caption("**Active Features**: None")
+            st.warning("🤗 HF Endpoint: Monitor unavailable")
 
-# Main chat interface
+# Enhanced Main Interface
 st.title("🧠 AI Life Coach")
 st.markdown("Ask me anything about personal development, goal setting, or life advice!")
 
-# Display chat messages
-for message in st.session_state.messages:
+# Display chat messages with enhanced formatting
+for i, message in enumerate(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']}")
 
-# Chat input and send button
-col1, col2 = st.columns([4, 1])
+# Enhanced chat input with better feedback
+col1, col2, col3 = st.columns([3, 1, 1])
 with col1:
     user_input = st.text_input(
         "Your message...",
         key="user_message_input",
         placeholder="Type your message here...",
-        label_visibility="collapsed"
+        label_visibility="collapsed",
+        disabled=st.session_state.is_sending
     )
 with col2:
-    send_button = st.button("Send", key="send_message_button", use_container_width=True)
+    send_button = st.button(
+        "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...")
 
-if send_button and user_input.strip():
-    # Display user message
+# Enhanced message sending with coordination feedback
+if send_button and user_input.strip() and not st.session_state.is_sending:
+    st.session_state.is_sending = True
+    
+    # Display user message immediately
     with st.chat_message("user"):
         st.markdown(user_input)
     
-    # Add user message to history
-    st.session_state.messages.append({"role": "user", "content": user_input})
+    # Add to message history with timestamp
+    st.session_state.messages.append({
+        "role": "user",
+        "content": user_input,
+        "timestamp": datetime.now().strftime("%H:%M:%S")
+    })
     
     # Reset error state
     st.session_state.last_error = ""
     
-    # Get 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})
-    
-    # Send to backend
+    # Enhanced coordination processing
     with st.chat_message("assistant"):
-        with st.spinner("AI Coach is thinking..."):
-            ai_response = None
-            backend_used = ""
-            error_msg = ""
+        # 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
             
-            # Try Ollama first if not falling back
-            if not config.use_fallback:
-                try:
-                    ai_response = send_to_ollama(
-                        user_input, conversation_history, st.session_state.ngrok_url, st.session_state.selected_model
-                    )
-                    backend_used = "Ollama"
-                    # Capture success metadata
-                    st.session_state.last_ollama_call_success = True
-                    st.session_state.last_ollama_call_time = str(datetime.utcnow())
-                    st.session_state.last_ollama_response_preview = ai_response[:200] if ai_response else ""
-                except Exception as e:
-                    error_msg = f"Ollama error: {str(e)}"
-                    # Capture failure metadata
-                    st.session_state.last_ollama_call_success = False
-                    st.session_state.last_ollama_call_time = str(datetime.utcnow())
-                    st.session_state.last_ollama_response_preview = str(e)[:200]
+            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..."
+                }
+                
+                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]
+                    }
+                    
+                    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']}")
+                    
+                    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
+                    
+                    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
             
-            # Fallback to Hugging Face if not ai_response and config.hf_token
-            if not ai_response and config.hf_token:
-                try:
-                    ai_response = send_to_hf(user_input, conversation_history)
-                    backend_used = "Hugging Face"
-                    # Capture success metadata
-                    st.session_state.last_hf_call_success = True
-                    st.session_state.last_hf_call_time = str(datetime.utcnow())
-                    st.session_state.last_hf_response_preview = ai_response[:200] if ai_response else ""
-                except Exception as e:
-                    error_msg = f"Hugging Face error: {str(e)}"
-                    # Capture failure metadata
-                    st.session_state.last_hf_call_success = False
-                    st.session_state.last_hf_call_time = str(datetime.utcnow())
-                    st.session_state.last_hf_response_preview = str(e)[:200]
+            # Run the enhanced processing
+            full_response = asyncio.run(process_with_feedback())
             
-            if ai_response:
-                st.markdown(f"{ai_response}")
-                # Update conversation history
-                conversation.append({"role": "user", "content": user_input})
-                conversation.append({"role": "assistant", "content": ai_response})
-                # Update session using the correct method
-                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})
-            else:
-                st.error("Failed to get response from both providers.")
-                st.session_state.last_error = error_msg or "No response from either provider"
+            # 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 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
     
-    # Clear input by forcing rerun
+    # Force rerun to update UI
     st.experimental_rerun()
+
+# 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"
+    )

core/coordinator.py

@@ -52,66 +52,116 @@ Your role is to:
 
     async def coordinate_hierarchical_conversation(self, user_id: str, user_query: str) -> AsyncGenerator[Dict, None]:
         """
-        Coordinate hierarchical conversation flow with HF as authoritative layer
-        
-        Yields:
-            Dict with 'type' and 'content' fields:
-            - {'type': 'initial_response', 'content': str}
-            - {'type': 'coordination_status', 'content': str}
-            - {'type': 'hf_thinking', 'content': str}  # Streaming HF response
-            - {'type': 'final_response', 'content': str}
+        Enhanced coordination with detailed tracking and feedback
         """
         try:
             # Get conversation history
             session = session_manager.get_session(user_id)
             conversation_history = session.get("conversation", []).copy()
             
-            yield {'type': 'coordination_status', 'content': '🚀 Initiating hierarchical AI coordination...'}
+            yield {
+                'type': 'coordination_status',
+                'content': '🚀 Initiating hierarchical AI coordination...',
+                'details': {
+                    'conversation_length': len(conversation_history),
+                    'user_query_length': len(user_query)
+                }
+            }
             
-            # Step 1: Gather external data
-            yield {'type': 'coordination_status', 'content': '🔍 Gathering external context...'}
+            # Step 1: Gather external data with detailed logging
+            yield {
+                'type': 'coordination_status',
+                'content': '🔍 Gathering external context...',
+                'details': {'phase': 'external_data_gathering'}
+            }
             external_data = await self._gather_external_data(user_query)
             
-            # Step 2: Get initial Ollama response with hierarchical awareness
-            yield {'type': 'coordination_status', 'content': '🦙 Getting initial response from Ollama...'}
+            # Log what external data was gathered
+            if external_data:
+                data_summary = []
+                if 'search_results' in external_data:
+                    data_summary.append(f"Web search: {len(external_data['search_results'])} results")
+                if 'weather' in external_data:
+                    data_summary.append("Weather data: available")
+                if 'current_datetime' in external_data:
+                    data_summary.append(f"Time: {external_data['current_datetime']}")
+                
+                yield {
+                    'type': 'coordination_status',
+                    'content': f'📊 External data gathered: {", ".join(data_summary)}',
+                    'details': {'external_data_summary': data_summary}
+                }
+            
+            # Step 2: Get initial Ollama response
+            yield {
+                'type': 'coordination_status',
+                'content': '🦙 Getting initial response from Ollama...',
+                'details': {'phase': 'ollama_response'}
+            }
             ollama_response = await self._get_hierarchical_ollama_response(
                 user_query, conversation_history, external_data
             )
             
-            # Send initial response
-            yield {'type': 'initial_response', 'content': ollama_response}
+            # Send initial response with context info
+            yield {
+                'type': 'initial_response',
+                'content': ollama_response,
+                'details': {
+                    'response_length': len(ollama_response),
+                    'external_data_injected': bool(external_data)
+                }
+            }
             
-            # Step 3: Coordinate with authoritative HF endpoint
-            yield {'type': 'coordination_status', 'content': '🤗 Engaging HF endpoint for deep analysis...'}
+            # Step 3: Coordinate with HF endpoint
+            yield {
+                'type': 'coordination_status',
+                'content': '🤗 Engaging HF endpoint for deep analysis...',
+                'details': {'phase': 'hf_coordination'}
+            }
             
-            # Check HF availability and coordinate
+            # Check HF availability
             hf_available = self._check_hf_availability()
             if hf_available:
+                # Show what context will be sent to HF
+                context_summary = {
+                    'conversation_turns': len(conversation_history),
+                    'ollama_response_length': len(ollama_response),
+                    'external_data_items': len(external_data) if external_data else 0
+                }
+                
+                yield {
+                    'type': 'coordination_status',
+                    'content': f'📋 HF context: {len(conversation_history)} conversation turns, Ollama response ({len(ollama_response)} chars)',
+                    'details': context_summary
+                }
+                
+                # Coordinate with HF
                 async for hf_chunk in self._coordinate_hierarchical_hf_response(
                     user_id, user_query, conversation_history,
                     external_data, ollama_response
                 ):
                     yield hf_chunk
             else:
-                yield {'type': 'coordination_status', 'content': 'ℹ️ HF endpoint not available - using Ollama response'}
+                yield {
+                    'type': 'coordination_status',
+                    'content': 'ℹ️ HF endpoint not available - using Ollama response',
+                    'details': {'hf_available': False}
+                }
             
             # Final coordination status
-            yield {'type': 'coordination_status', 'content': '✅ Hierarchical coordination complete'}
-            
+            yield {
+                'type': 'coordination_status',
+                'content': '✅ Hierarchical coordination complete',
+                'details': {'status': 'complete'}
+            }
+        
         except Exception as e:
             logger.error(f"Hierarchical coordination failed: {e}")
-            yield {'type': 'coordination_status', 'content': f'❌ Coordination error: {str(e)}'}
-            
-            # Fallback to simple Ollama response
-            try:
-                session = session_manager.get_session(user_id)
-                conversation_history = session.get("conversation", [])
-                fallback_response = await self._get_hierarchical_ollama_response(
-                    user_query, conversation_history, {}
-                )
-                yield {'type': 'initial_response', 'content': fallback_response}
-            except:
-                yield {'type': 'initial_response', 'content': "I'm here to help! What would you like to discuss?"}
+            yield {
+                'type': 'coordination_status',
+                'content': f'❌ Coordination error: {str(e)}',
+                'details': {'error': str(e)}
+            }
 
     async def _coordinate_hierarchical_hf_response(self, user_id: str, query: str,
                                                  history: List, external_data: Dict,

test_enhanced_features.py

@@ -0,0 +1,65 @@
+import sys
+import asyncio
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.append(str(project_root))
+
+from core.coordinator import coordinator
+from core.session import session_manager
+
+async def test_enhanced_features():
+    """Test the enhanced UI and coordination features"""
+    print("=== Enhanced Features Test ===")
+    print()
+    
+    # Test user query
+    user_query = "What are the benefits of meditation for stress management?"
+    user_id = "test_user"
+    
+    print(f"User Query: {user_query}")
+    print()
+    
+    # Test enhanced coordination with detailed tracking
+    print("1. Testing Enhanced Coordination with Detailed Tracking:")
+    try:
+        print("   Starting enhanced coordination...")
+        response_count = 0
+        
+        async for response_chunk in coordinator.coordinate_hierarchical_conversation(user_id, user_query):
+            response_count += 1
+            print(f"   Chunk {response_count}:")
+            print(f"     Type: {response_chunk['type']}")
+            print(f"     Content: {response_chunk['content'][:100]}...")
+            if 'details' in response_chunk:
+                print(f"     Details: {response_chunk['details']}")
+            print()
+            
+            # Limit output for readability
+            if response_count >= 8:
+                print("   ... (truncated for brevity)")
+                break
+        
+        print("   ✅ Enhanced Coordination Test Passed")
+    except Exception as e:
+        print(f"   ❌ Enhanced Coordination Test Failed: {e}")
+    
+    print()
+    
+    # Test coordination status
+    print("2. Testing Coordination Status:")
+    try:
+        coord_status = coordinator.get_coordination_status()
+        print(f"   Tavily Available: {coord_status.get('tavily_available', False)}")
+        print(f"   Weather Available: {coord_status.get('weather_available', False)}")
+        print(f"   Web Search Enabled: {coord_status.get('web_search_enabled', False)}")
+        print("   ✅ Coordination Status Check Passed")
+    except Exception as e:
+        print(f"   ❌ Coordination Status Check Failed: {e}")
+    
+    print()
+    print("🎉 Enhanced Features Test Completed!")
+
+if __name__ == "__main__":
+    asyncio.run(test_enhanced_features())