Simplify CosmicCat AI Assistant - Remove HF expert features and branding changes

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+primaryColor = "#6f42c1"
+backgroundColor = "#0d1117"
+secondaryBackgroundColor = "#161b22"
+textColor = "#f0f6fc"
+font = "sans serif"

app.py

@@ -3,21 +3,16 @@ import time
 import os
 import sys
 import json
-import asyncio
 from datetime import datetime
 from pathlib import Path
 sys.path.append(str(Path(__file__).parent))
+
 from utils.config import config
 from core.session import session_manager
 from core.memory import check_redis_health
-from core.coordinator import coordinator
 from core.errors import translate_error
 from core.personality import personality
-from services.hf_endpoint_monitor import hf_monitor
-from services.weather import weather_service
-from core.llm import LLMClient
 from core.providers.ollama import OllamaProvider
-from core.providers.huggingface import HuggingFaceProvider
 import logging
 
 # Set up logging
@@ -26,27 +21,24 @@ logger = logging.getLogger(__name__)
 
 st.set_page_config(page_title="CosmicCat AI Assistant", page_icon="🐱", layout="wide")
 
-# Initialize session state safely at the top of app.py
+# Initialize session state
 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 "is_processing" not in st.session_state:
     st.session_state.is_processing = False
 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")
 if "cosmic_mode" not in st.session_state:
-    st.session_state.cosmic_mode = True  # Default to cosmic mode
+    st.session_state.cosmic_mode = True
 if "show_welcome" not in st.session_state:
     st.session_state.show_welcome = True
 
-# Sidebar layout redesign
+# Sidebar
 with st.sidebar:
     st.title("🐱 CosmicCat AI Assistant")
-    st.markdown("Your personal AI-powered life development assistant")
+    st.markdown("Your personal AI-powered assistant with a cosmic twist.")
     
-    # PRIMARY ACTIONS
-    st.subheader("💬 Primary Actions")
+    # Model selection
     model_options = {
         "Mistral 7B (Local)": "mistral:latest",
         "Llama 2 7B (Local)": "llama2:latest",
@@ -55,34 +47,30 @@ with st.sidebar:
     selected_model_name = st.selectbox(
         "Select Model",
         options=list(model_options.keys()),
-        index=0,
-        key="sidebar_model_select"
+        index=0
     )
     st.session_state.selected_model = model_options[selected_model_name]
     
-    # Toggle for cosmic mode using checkbox
+    # Cosmic mode toggle
     st.session_state.cosmic_mode = st.checkbox("Enable Cosmic Mode", value=st.session_state.cosmic_mode)
     
     st.divider()
     
-    # CONFIGURATION
+    # Configuration
     st.subheader("⚙️ Configuration")
     ngrok_url_input = st.text_input(
         "Ollama Server URL",
         value=st.session_state.ngrok_url_temp,
-        help="Enter your ngrok URL",
-        key="sidebar_ngrok_url"
+        help="Enter your ngrok URL"
     )
     
     if ngrok_url_input != st.session_state.ngrok_url_temp:
         st.session_state.ngrok_url_temp = ngrok_url_input
         st.success("✅ URL updated!")
-        
+    
     if st.button("📡 Test Connection"):
         try:
-            # Use OllamaProvider to test connection
             ollama_provider = OllamaProvider(st.session_state.selected_model)
-            # Test model validation
             is_valid = ollama_provider.validate_model()
             if is_valid:
                 st.success("✅ Connection successful!")
@@ -90,16 +78,18 @@ with st.sidebar:
                 st.error("❌ Model validation failed")
         except Exception as e:
             st.error(f"❌ Error: {str(e)[:50]}...")
-            
+    
     if st.button("🗑️ Clear History"):
         st.session_state.messages = []
         st.success("History cleared!")
-        
+    
     st.divider()
     
-    # SYSTEM STATUS
+    # System Status
     with st.expander("🔍 System Status", expanded=False):
-        st.subheader("📊 System Monitor")
+        st.subheader("📊 Status")
+        
+        # Ollama Status
         try:
             from services.ollama_monitor import check_ollama_status
             ollama_status = check_ollama_status()
@@ -109,256 +99,103 @@ with st.sidebar:
                 st.warning("🦙 Ollama: Not running")
         except:
             st.info("🦙 Ollama: Unknown")
-            
-        try:
-            hf_status = hf_monitor.check_endpoint_status()
-            # Enhanced HF status display with cat-themed messages
-            if hf_status.get('available'):
-                if hf_status.get('initialized', False):
-                    st.success(f"🤗 HF Endpoint: Available ({hf_status.get('status_code')} OK)")
-                    if hf_status.get('model'):
-                        st.info(f"   Model: {hf_status.get('model')}")
-                    if hf_status.get('region'):
-                        st.info(f"   Region: {hf_status.get('region')}")
-                    if hf_status.get('warmup_count'):
-                        st.info(f"   Warmup Count: {hf_status.get('warmup_count')}")
-                else:
-                    st.warning("⏳ Kittens Waking Up...")
-            elif hf_status.get('status_code') == 200:
-                st.info("📡 Calling Space Friends...")
-            else:
-                st.error("😴 Nap Cat")
-        except Exception as e:
-            st.info("⏳ Kittens Stretching...")
-            
+        
+        # Redis Status
         if check_redis_health():
             st.success("💾 Redis: Connected")
         else:
             st.error("💾 Redis: Disconnected")
-            
+    
     st.divider()
     
+    # Debug Info
     st.subheader("🐛 Debug Info")
-    # Show enhanced debug information
     st.markdown(f"**Environment:** {'HF Space' if config.is_hf_space else 'Local'}")
     st.markdown(f"**Model:** {st.session_state.selected_model}")
-    st.markdown(f"**Fallback:** {'Enabled' if config.use_fallback else 'Disabled'}")
-    
-    # Show active features
-    features = []
-    if os.getenv("TAVILY_API_KEY"):
-        features.append("Web Search")
-    if config.openweather_api_key:
-        features.append("Weather")
-    st.markdown(f"**Active Features:** {', '.join(features) if features else 'None'}")
-    
-    # Show recent activity
-    try:
-        user_session = session_manager.get_session("default_user")
-        coord_stats = user_session.get('ai_coordination', {})
-        if coord_stats and coord_stats.get('last_coordination'):
-            st.markdown(f"**Last Request:** {coord_stats.get('last_coordination')}")
-        else:
-            st.markdown("**Last Request:** N/A")
-    except:
-        st.markdown("**Last Request:** N/A")
-        
-    # Show Ollama ping status
-    try:
-        import requests
-        import time
-        start_time = time.time()
-        headers = {
-            "ngrok-skip-browser-warning": "true",
-            "User-Agent": "CosmicCat-Debug"
-        }
-        response = requests.get(
-            f"{st.session_state.ngrok_url_temp}/api/tags",
-            headers=headers,
-            timeout=15
-        )
-        ping_time = round((time.time() - start_time) * 1000)
-        if response.status_code == 200:
-            st.markdown(f"**Ollama Ping:** {response.status_code} OK ({ping_time}ms)")
-        else:
-            st.markdown(f"**Ollama Ping:** {response.status_code} Error")
-    except Exception as e:
-        st.markdown("**Ollama Ping:** Unreachable")
-        
-    # Redis status
-    if check_redis_health():
-        st.markdown("**Redis:** Healthy")
-    else:
-        st.markdown("**Redis:** Unhealthy")
-    
-    # Add debug tools
-    st.divider()
-    st.subheader("🐛 Debug Tools")
-    
-    if st.button("🔍 Test Ollama Direct"):
-        try:
-            with st.spinner("Testing..."):
-                ollama_provider = OllamaProvider(st.session_state.selected_model)
-                test_history = [{"role": "user", "content": "Hello, what day is it?"}]
-                response = ollama_provider.generate("Hello, what day is it?", test_history)
-                st.success(f"Success! Response: {response[:200] if response else 'Empty'}")
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
-    
-    if st.button("📋 Show Session Data"):
-        try:
-            user_session = session_manager.get_session("default_user")
-            st.write("Session data:")
-            st.json(user_session)
-        except Exception as e:
-            st.error(f"Error: {str(e)}")
 
 # Main interface
 st.title("🐱 CosmicCat AI Assistant")
-st.markdown("Ask me anything about personal development, goal setting, or life advice!")
+st.markdown("Ask me anything!")
 
-# Show welcome message only once
+# Welcome message
 if st.session_state.show_welcome:
     with st.chat_message("assistant"):
         greeting = personality.get_greeting(cosmic_mode=st.session_state.cosmic_mode)
         st.markdown(greeting)
     st.session_state.show_welcome = False
 
-# Consistent message rendering function with cosmic styling
-def render_message(role, content, source=None, timestamp=None):
-    """Render chat messages with consistent styling"""
-    with st.chat_message(role):
-        if source:
-            if source == "local_kitty":
-                st.markdown(f"### 🐱 Cosmic Kitten Says:")
-            elif source == "orbital_station":
-                st.markdown(f"### 🛰️ Orbital Station Reports:")
-            elif source == "cosmic_summary":
-                st.markdown(f"### 🌟 Final Cosmic Summary:")
-            elif source == "error":
-                st.markdown(f"### ❌ Error:")
-            elif source == "space_story":
-                st.markdown(f"### 🐱 Cosmic Kitten Story:")
-            else:
-                st.markdown(f"### {source}")
-        st.markdown(content)
-        if timestamp:
-            st.caption(f"🕒 {timestamp}")
-
 # Display messages
 for message in st.session_state.messages:
-    render_message(
-        message["role"],
-        message["content"],
-        message.get("source"),
-        message.get("timestamp")
-    )
-
-# Input validation function
-def validate_user_input(text):
-    """Validate and sanitize user input"""
-    if not text or not text.strip():
-        return False, "Input cannot be empty"
-    if len(text) > 1000:
-        return False, "Input too long (max 1000 characters)"
-    
-    # Check for potentially harmful patterns
-    harmful_patterns = ["<script", "javascript:", "onload=", "onerror="]
-    if any(pattern in text.lower() for pattern in harmful_patterns):
-        return False, "Potentially harmful input detected"
-    
-    return True, text.strip()
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+        if "timestamp" in message:
+            st.caption(f"🕒 {message['timestamp']}")
 
-# Chat input - FIXED RESPONSE DISPLAY VERSION
+# Chat input
 user_input = st.chat_input("Type your message here...", disabled=st.session_state.is_processing)
 
-# Process message when received
+# Process message
 if user_input and not st.session_state.is_processing:
     st.session_state.is_processing = True
     
-    # Validate input
-    clean_input = user_input.strip()
-    if not clean_input:
-        st.session_state.is_processing = False
-        st.experimental_rerun()
-    
-    # Display user message immediately
+    # Display user message
     with st.chat_message("user"):
-        st.markdown(clean_input)
-        
-    # Add to message history
+        st.markdown(user_input)
+    
+    # Add to history
     timestamp = datetime.now().strftime("%H:%M:%S")
     st.session_state.messages.append({
         "role": "user",
-        "content": clean_input,
+        "content": user_input,
         "timestamp": timestamp
     })
     
-    # Show processing status
-    status_container = st.empty()
-    response_container = st.empty()
-    
+    # Process response
     try:
-        status_container.info("🔄 Processing your request...")
-        
-        # Get conversation history from session
+        # Get conversation history
         user_session = session_manager.get_session("default_user")
         conversation_history = user_session.get("conversation", []).copy()
+        conversation_history.append({"role": "user", "content": user_input})
         
-        # Add the current user message to history for context
-        conversation_history.append({"role": "user", "content": clean_input})
-        
-        # Try Ollama first
-        status_container.info("🦙 Contacting Ollama...")
-        
+        # Generate response
         try:
-            # Use the OllamaProvider directly with proper configuration
             ollama_provider = OllamaProvider(st.session_state.selected_model)
-            ai_response = ollama_provider.generate(clean_input, conversation_history)
+            ai_response = ollama_provider.generate(user_input, conversation_history)
             
             if ai_response and ai_response.strip():
-                # DISPLAY THE RESPONSE IN THE CONTAINER (not using placeholders)
                 with st.chat_message("assistant"):
                     st.markdown(ai_response)
-                status_container.success("✅ Response received!")
+                status = "✅ Response received!"
             else:
-                # DISPLAY ERROR RESPONSE
                 with st.chat_message("assistant"):
-                    st.warning("⚠️ Received empty response from Ollama")
+                    st.warning("⚠️ Received empty response")
                 ai_response = "I received your message but couldn't generate a proper response."
                 
-        except Exception as ollama_error:
-            error_message = str(ollama_error)
-            # DISPLAY ERROR
+        except Exception as e:
+            error_message = str(e)
             with st.chat_message("assistant"):
-                st.error(f"❌ Ollama error: {error_message[:100]}...")
+                st.error(f"❌ Error: {error_message[:100]}...")
             ai_response = f"Error: {error_message[:100]}..."
         
-        # Save response to session and message history
+        # Save to session
         if ai_response:
             try:
-                # Update conversation history in session
                 conversation = user_session.get("conversation", []).copy()
-                conversation.append({"role": "user", "content": clean_input})
+                conversation.append({"role": "user", "content": user_input})
                 conversation.append({"role": "assistant", "content": str(ai_response)})
+                session_manager.update_session("default_user", {"conversation": conversation})
                 
-                # Update session with new conversation
-                update_result = session_manager.update_session("default_user", {"conversation": conversation})
-                
-                # Add to message history (this was missing!)
                 st.session_state.messages.append({
                     "role": "assistant",
                     "content": str(ai_response),
                     "timestamp": timestamp
                 })
-                
             except Exception as session_error:
                 logger.error(f"Session update error: {session_error}")
                 
     except Exception as e:
         error_msg = f"System error: {str(e)}"
-        logger.error(f"Chat processing error: {error_msg}")
-        # DISPLAY SYSTEM ERROR
+        logger.error(f"Processing error: {error_msg}")
         with st.chat_message("assistant"):
             st.error(error_msg)
         st.session_state.messages.append({
@@ -368,68 +205,26 @@ if user_input and not st.session_state.is_processing:
         })
     finally:
         st.session_state.is_processing = False
-        time.sleep(0.1)  # Small delay to ensure UI updates
         st.experimental_rerun()
 
-# Add evaluation dashboard tab (separate from chat interface) - ONLY ABOUT TAB NOW
+# About tab
 st.divider()
-# Only one tab now - About
 tab1, = st.tabs(["ℹ️ About"])
 
 with tab1:
     st.header("ℹ️ About CosmicCat AI Assistant")
     st.markdown("""
-    The CosmicCat AI Assistant is a sophisticated conversational AI system with the following capabilities:
+    The CosmicCat AI Assistant is a sophisticated conversational AI with a cosmic theme.
     
     ### 🧠 Core Features
-    - **Multi-model coordination**: Combines local Ollama models with cloud-based Hugging Face endpoints
-    - **Live web search**: Integrates with Tavily API for current information
-    - **Persistent memory**: Uses Redis for conversation history storage
-    - **Hierarchical reasoning**: Fast local responses with deep cloud analysis
+    - **Local AI processing** with Ollama models
+    - **Persistent memory** using Redis
+    - **Space-themed personality** for fun interactions
     
     ### 🚀 Cosmic Mode
-    When enabled, the AI follows a three-stage response pattern:
-    1. **🐱 Cosmic Kitten Response**: Immediate local processing
-    2. **🛰️ Orbital Station Analysis**: Deep cloud-based analysis
-    3. **🌟 Final Synthesis**: Unified response combining both perspectives
+    When enabled, the AI responds with space-themed language and metaphors.
     
     ### 🛠️ Technical Architecture
-    - **Primary model**: Ollama (local processing for fast responses)
-    - **Secondary model**: Hugging Face Inference API (deep analysis)
-    - **External data**: Web search, weather data, and space information
+    - **Primary model**: Ollama (local processing)
     - **Memory system**: Redis-based session management
-    
-    ### 📊 Evaluation Tools
-    - Behavior testing with sample prompts
-    - Performance metrics and analytics
     """)
-
-# Add special command handling for stories
-if user_input and user_input.lower().strip() in ["tell me a story", "tell me a cosmic cat story", "story", "cosmic story", "tell me a space story"]:
-    story = personality.get_space_story()
-    st.markdown(f"### 🐱 Cosmic Kitten Story:\n\n{story}")
-    st.session_state.messages.append({
-        "role": "assistant",
-        "content": story,
-        "source": "space_story",
-        "timestamp": datetime.now().strftime("%H:%M:%S")
-    })
-    st.session_state.is_processing = False
-    st.experimental_rerun()
-
-# Simple test to verify the fix works
-def test_response_display():
-    """Test function to verify response display works"""
-    test_response = "This is a test response to verify the display fix is working correctly."
-    with st.chat_message("assistant"):
-        st.markdown(test_response)
-    st.session_state.messages.append({
-        "role": "assistant",
-        "content": test_response,
-        "timestamp": datetime.now().strftime("%H:%M:%S")
-    })
-
-# Add a test button in sidebar:
-with st.sidebar:
-    if st.button("Test Response Display"):
-        test_response_display()

core/coordinator.py

@@ -1,691 +1,44 @@
-import asyncio
 import logging
-from typing import List, Dict, Optional, AsyncGenerator
 from core.llm_factory import llm_factory
 from core.session import session_manager
-from services.hf_endpoint_monitor import hf_monitor
-from services.weather import weather_service
-from services.web_search import web_search_service
-try:
-    from tavily import TavilyClient
-    TAVILY_AVAILABLE = True
-except ImportError:
-    TavilyClient = None
-    TAVILY_AVAILABLE = False
-import os
-import json
-from datetime import datetime
+
 logger = logging.getLogger(__name__)
 
-class AICoordinator:
-    """Hierarchical multi-model coordinator with cosmic cascade flow and async support"""
+class SimpleCoordinator:
+    """Simplified coordinator without HF expert features"""
     
     def __init__(self):
-        self.tavily_client = None
-        if TAVILY_AVAILABLE and os.getenv("TAVILY_API_KEY"):
-            self.tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
-            
-        # System instructions for cosmic behavior
-        self.system_instructions = {
-            'ollama_role': """You are a cosmic kitten assistant that works in coordination with a powerful orbital space station. Your role is to:
-1. Provide immediate, concise responses using available information (local processing)
-2. Summarize and simplify complex information
-3. Enhance responses with local knowledge
-4. DEFER TO THE ORBITAL STATION for deep analysis and authoritative answers
-5. The orbital station has 8192 token capacity and streaming capability - it's the thinking layer
-6. Always acknowledge that the orbital station's insights supersede your initial response
-7. Use web sources to justify points when possible
-8. Keep responses brief and focused while awaiting orbital input""",
-            
-            'hf_role': """You are a powerful orbital space station with 8192 token capacity and streaming capability. Your role is to:
-1. Provide deep, uncensored analysis and insights
-2. Supersede the local cosmic kitten's logic when there's disagreement
-3. Think thoroughly and provide comprehensive responses
-4. Use your full 8192 token capacity for detailed analysis
-5. Stream your responses for real-time delivery
-6. Build upon the conversation context and cosmic kitten's initial response
-7. Provide authoritative answers that take precedence"""
-        }
-        
-    def determine_web_search_needs(self, conversation_history: List[Dict]) -> Dict:
-        """Determine if web search is needed based on conversation content"""
-        conversation_text = " ".join([msg.get("content", "") for msg in conversation_history])
-        
-        # Topics that typically need current information
-        current_info_indicators = [
-            "news", "current events", "latest", "recent", "today",
-            "weather", "temperature", "forecast", "stock", "price",
-            "trend", "market", "breaking", "update", "development"
-        ]
-        
-        needs_search = False
-        search_topics = []
-        
-        for indicator in current_info_indicators:
-            if indicator in conversation_text.lower():
-                needs_search = True
-                search_topics.append(indicator)
-                
-        return {
-            "needs_search": needs_search,
-            "search_topics": search_topics,
-            "reasoning": f"Found topics requiring current info: {', '.join(search_topics)}" if search_topics else "No current info needed"
-        }
-        
-    async def coordinate_response_async(self, user_id: str, user_query: str):
-        """Asynchronously coordinate responses with parallel execution"""
-        try:
-            # Get conversation history
-            session = session_manager.get_session(user_id)
-            
-            # Inject current time into context
-            current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-            time_context = {
-                "role": "system",
-                "content": f"[Current Date & Time: {current_time}]"
-            }
-            conversation_history = [time_context] + session.get("conversation", []).copy()
-            
-            # Parallel execution - gather external data while processing local response
-            external_data_task = asyncio.create_task(
-                self._gather_external_data(user_query)
-            )
-            
-            # Get local response while gathering external data
-            local_response = await self._get_local_ollama_response(user_query, conversation_history)
-            
-            # Wait for external data
-            external_data = await external_data_task
-            
-            # Process cloud response asynchronously if needed
-            hf_task = None
-            if self._check_hf_availability():
-                hf_task = asyncio.create_task(
-                    self._get_hf_analysis(user_query, conversation_history)
-                )
-            
-            return {
-                'local_response': local_response,
-                'hf_task': hf_task,
-                'external_data': external_data
-            }
-        except Exception as e:
-            logger.error(f"Async coordination failed: {e}")
-            raise
-            
-    async def coordinate_cosmic_response(self, user_id: str, user_query: str) -> AsyncGenerator[Dict, None]:
-        """
-        Three-stage cosmic response cascade:
-        1. Local Ollama immediate response (🐱 Cosmic Kitten's quick thinking)
-        2. HF endpoint deep analysis (🛰️ Orbital Station wisdom)
-        3. Local Ollama synthesis (🐱 Cosmic Kitten's final synthesis)
-        """
+        pass
+    
+    def process_message(self, user_id: str, user_query: str):
+        """Process a message with local Ollama only"""
         try:
-            # Get conversation history
+            # Get session
             session = session_manager.get_session(user_id)
+            conversation_history = session.get("conversation", []).copy()
             
-            # Inject current time into context
-            current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-            time_context = {
-                "role": "system",
-                "content": f"[Current Date & Time: {current_time}]"
-            }
-            conversation_history = [time_context] + session.get("conversation", []).copy()
-            
-            yield {
-                'type': 'status',
-                'content': '🚀 Initiating Cosmic Response Cascade...',
-                'details': {
-                    'conversation_length': len(conversation_history),
-                    'user_query_length': len(user_query)
-                }
-            }
-            
-            # Stage 1: Local Ollama Immediate Response (🐱 Cosmic Kitten's quick thinking)
-            yield {
-                'type': 'status',
-                'content': '🐱 Cosmic Kitten Responding...'
-            }
-            local_response = await self._get_local_ollama_response(user_query, conversation_history)
-            yield {
-                'type': 'local_response',
-                'content': local_response,
-                'source': '🐱 Cosmic Kitten'
-            }
-            
-            # Stage 2: HF Endpoint Deep Analysis (🛰️ Orbital Station wisdom) (parallel processing)
-            yield {
-                'type': 'status',
-                'content': '🛰️ Beaming Query to Orbital Station...'
-            }
-            hf_task = asyncio.create_task(self._get_hf_analysis(user_query, conversation_history))
-            
-            # Wait for HF response
-            hf_response = await hf_task
-            yield {
-                'type': 'cloud_response',
-                'content': hf_response,
-                'source': '🛰️ Orbital Station'
-            }
-            
-            # Stage 3: Local Ollama Synthesis (🐱 Cosmic Kitten's final synthesis)
-            yield {
-                'type': 'status',
-                'content': '🐱 Cosmic Kitten Synthesizing Wisdom...'
-            }
-            
-            # Update conversation with both responses
-            updated_history = conversation_history.copy()
-            updated_history.extend([
-                {"role": "assistant", "content": local_response},
-                {"role": "assistant", "content": hf_response, "source": "cloud"}
-            ])
-            
-            synthesis = await self._synthesize_responses(user_query, local_response, hf_response, updated_history)
-            yield {
-                'type': 'final_synthesis',
-                'content': synthesis,
-                'source': '🌟 Final Cosmic Summary'
-            }
+            # Add current message
+            conversation_history.append({"role": "user", "content": user_query})
             
-            # Final status
-            yield {
-                'type': 'status',
-                'content': '✨ Cosmic Cascade Complete!'
-            }
-            
-        except Exception as e:
-            logger.error(f"Cosmic cascade failed: {e}")
-            yield {'type': 'error', 'content': f"🌌 Cosmic disturbance: {str(e)}"}
-            
-    async def _get_local_ollama_response(self, query: str, history: List[Dict]) -> str:
-        """Get immediate response from local Ollama model"""
-        try:
-            # Get Ollama provider
-            ollama_provider = llm_factory.get_provider('ollama')
-            if not ollama_provider:
+            # Get provider
+            provider = llm_factory.get_provider('ollama')
+            if not provider:
                 raise Exception("Ollama provider not available")
-                
-            # Prepare conversation with cosmic context
-            enhanced_history = history.copy()
-            
-            # Add system instruction for Ollama's role
-            enhanced_history.insert(0, {
-                "role": "system",
-                "content": self.system_instructions['ollama_role']
-            })
-            
-            # Add external data context if available
-            external_data = await self._gather_external_data(query)
-            if external_data:
-                context_parts = []
-                if 'search_answer' in external_data:
-                    context_parts.append(f"Current information: {external_data['search_answer']}")
-                if 'weather' in external_data:
-                    weather = external_data['weather']
-                    context_parts.append(f"Current weather: {weather.get('temperature', 'N/A')}°C in {weather.get('city', 'Unknown')}")
-                if 'current_datetime' in external_data:
-                    context_parts.append(f"Current time: {external_data['current_datetime']}")
-                    
-                if context_parts:
-                    context_message = {
-                        "role": "system",
-                        "content": "Context: " + " | ".join(context_parts)
-                    }
-                    enhanced_history.insert(1, context_message)  # Insert after role instruction
-                    
-            # Add the user's query
-            enhanced_history.append({"role": "user", "content": query})
             
             # Generate response
-            response = ollama_provider.generate(query, enhanced_history)
-            return response or "🐱 Cosmic Kitten is thinking..."
-            
-        except Exception as e:
-            logger.error(f"Local Ollama response failed: {e}")
-            return "🐱 Cosmic Kitten encountered a space glitch..."
-            
-    async def _get_hf_analysis(self, query: str, history: List[Dict]) -> str:
-        """Get deep analysis from HF endpoint"""
-        try:
-            # Check HF availability
-            hf_available = self._check_hf_availability()
-            if not hf_available:
-                return "🛰️ Orbital Station is currently offline."
-                
-            # Check and warm up HF endpoint if needed
-            hf_status = hf_monitor.check_endpoint_status()
-            if not hf_status['available']:
-                # Note: We can't yield from a non-async-generator function
-                # Warm up logic is handled elsewhere
-                warmup_success = hf_monitor.handle_scale_to_zero()
-                if not warmup_success:
-                    return "❌ Orbital Station initialization failed"
-                    
-            # Get HF provider
-            hf_provider = llm_factory.get_provider('huggingface')
-            if not hf_provider:
-                return "❌ HF provider not available"
-                
-            # Prepare enhanced conversation for HF with cosmic context
-            enhanced_history = history.copy()
-            
-            # Inject current time into HF context too
-            current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-            time_context = {
-                "role": "system",
-                "content": f"[Current Date & Time: {current_time}]"
-            }
-            enhanced_history = [time_context] + enhanced_history
-            
-            # Add system instructions for HF
-            enhanced_history.insert(0, {
-                "role": "system",
-                "content": self.system_instructions['hf_role']
-            })
-            
-            # Add context about the coordination
-            enhanced_history.append({
-                "role": "system",
-                "content": f"""
-Context for your authoritative analysis:
-User Query: '{query}'
-Please provide your deep, uncensored analysis.
-Use your full 8192 token capacity for comprehensive thinking.
-Stream your response for real-time delivery."""
-            })
-            
-            # Add the user's latest query
-            enhanced_history.append({"role": "user", "content": query})
-            
-            # Stream HF response with full 8192 token capacity
-            hf_response_stream = hf_provider.stream_generate(query, enhanced_history)
-            
-            if hf_response_stream:
-                # Combine stream chunks into full response
-                full_hf_response = ""
-                if isinstance(hf_response_stream, list):
-                    full_hf_response = "".join(hf_response_stream)
-                else:
-                    full_hf_response = hf_response_stream
-                return full_hf_response or "🛰️ Orbital Station analysis complete."
-            else:
-                return "🛰️ Orbital Station encountered a transmission error."
-                
-        except Exception as e:
-            logger.error(f"HF analysis failed: {e}")
-            return f"🛰️ Orbital Station reports: {str(e)}"
-            
-    async def _synthesize_responses(self, query: str, local_response: str, hf_response: str, history: List[Dict]) -> str:
-        """Synthesize local and cloud responses with Ollama"""
-        try:
-            # Get Ollama provider
-            ollama_provider = llm_factory.get_provider('ollama')
-            if not ollama_provider:
-                raise Exception("Ollama provider not available")
-                
-            # Prepare synthesis prompt
-            synthesis_prompt = f"""
-Synthesize these two perspectives into a cohesive cosmic summary:
-
-🐱 Cosmic Kitten's Local Insight: {local_response}
-
-🛰️ Orbital Station's Deep Analysis: {hf_response}
-
-Please create a unified response that combines both perspectives, highlighting key insights from each while providing a coherent answer to the user's query.
-"""
+            response = provider.generate(user_query, conversation_history)
             
-            # Prepare conversation history for synthesis
-            enhanced_history = history.copy()
+            # Update session
+            conversation = session.get("conversation", []).copy()
+            conversation.append({"role": "user", "content": user_query})
+            conversation.append({"role": "assistant", "content": response or ""})
+            session_manager.update_session(user_id, {"conversation": conversation})
             
-            # Add system instruction for synthesis
-            enhanced_history.insert(0, {
-                "role": "system",
-                "content": "You are a cosmic kitten synthesizing insights from local knowledge and orbital station wisdom."
-            })
-            
-            # Add the synthesis prompt
-            enhanced_history.append({"role": "user", "content": synthesis_prompt})
-            
-            # Generate synthesis
-            synthesis = ollama_provider.generate(synthesis_prompt, enhanced_history)
-            return synthesis or "🌟 Cosmic synthesis complete!"
+            return response or "I'm processing your request..."
             
         except Exception as e:
-            logger.error(f"Response synthesis failed: {e}")
-            # Fallback to combining responses
-            return f"🌟 Cosmic Summary:\n\n🐱 Local Insight: {local_response[:200]}...\n\n🛰️ Orbital Wisdom: {hf_response[:200]}..."
-            
-    async def coordinate_hierarchical_conversation(self, user_id: str, user_query: str) -> AsyncGenerator[Dict, None]:
-        """
-        Enhanced coordination with detailed tracking and feedback
-        """
-        try:
-            # Get conversation history
-            session = session_manager.get_session(user_id)
-            
-            # Inject current time into context
-            current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-            time_context = {
-                "role": "system",
-                "content": f"[Current Date & Time: {current_time}]"
-            }
-            conversation_history = [time_context] + session.get("conversation", []).copy()
-            
-            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 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)
-            
-            # 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 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 HF endpoint
-            yield {
-                'type': 'coordination_status',
-                'content': '🤗 Engaging HF endpoint for deep analysis...',
-                'details': {'phase': 'hf_coordination'}
-            }
-            
-            # 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',
-                    'details': {'hf_available': False}
-                }
-                
-            # Final coordination status
-            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)}',
-                'details': {'error': str(e)}
-            }
-            
-    async def _coordinate_hierarchical_hf_response(self, user_id: str, query: str, history: List, external_data: Dict, ollama_response: str) -> AsyncGenerator[Dict, None]:
-        """Coordinate with HF endpoint as authoritative layer with streaming"""
-        try:
-            # Check and warm up HF endpoint if needed
-            hf_status = hf_monitor.check_endpoint_status()
-            if not hf_status['available']:
-                yield {'type': 'coordination_status', 'content': '⚡ Initializing HF endpoint (2-4 minutes)...'}
-                warmup_success = hf_monitor.handle_scale_to_zero()
-                if not warmup_success:
-                    yield {'type': 'coordination_status', 'content': '❌ HF endpoint initialization failed'}
-                    return
-                    
-            # Get HF provider
-            hf_provider = llm_factory.get_provider('huggingface')
-            if not hf_provider:
-                yield {'type': 'coordination_status', 'content': '❌ HF provider not available'}
-                return
-                
-            # Prepare enhanced conversation for HF with hierarchical context
-            enhanced_history = history.copy()
-            
-            # Inject current time into HF context too
-            current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-            time_context = {
-                "role": "system",
-                "content": f"[Current Date & Time: {current_time}]"
-            }
-            enhanced_history = [time_context] + enhanced_history
-            
-            # Add system instructions for HF
-            enhanced_history.insert(0, {
-                "role": "system",
-                "content": self.system_instructions['hf_role']
-            })
-            
-            # Add context about the coordination
-            enhanced_history.append({
-                "role": "system",
-                "content": f"""
-Context for your authoritative analysis:
-User Query: '{query}'
-Ollama's Initial Response: '{ollama_response}'
-External Data Available: {json.dumps(external_data, indent=2) if external_data else 'None'}
-Please provide your deep, uncensored analysis that supersedes the local model's response.
-Use your full 8192 token capacity for comprehensive thinking.
-Stream your response for real-time delivery."""
-            })
-            
-            # Add the user's latest query
-            enhanced_history.append({"role": "user", "content": query})
-            
-            # Stream HF response with full 8192 token capacity
-            yield {'type': 'coordination_status', 'content': '🧠 HF endpoint thinking...'}
-            
-            # Use streaming for real-time delivery
-            hf_response_stream = hf_provider.stream_generate(query, enhanced_history)
-            
-            if hf_response_stream:
-                # Stream the response chunks
-                full_hf_response = ""
-                for chunk in hf_response_stream:
-                    if chunk:
-                        full_hf_response += chunk
-                        yield {'type': 'hf_thinking', 'content': chunk}
-                        
-                # Final HF response
-                yield {'type': 'final_response', 'content': full_hf_response}
-                yield {'type': 'coordination_status', 'content': '🎯 HF analysis complete and authoritative'}
-            else:
-                yield {'type': 'coordination_status', 'content': '❌ HF response generation failed'}
-                
-        except Exception as e:
-            logger.error(f"Hierarchical HF coordination failed: {e}")
-            yield {'type': 'coordination_status', 'content': f'❌ HF coordination error: {str(e)}'}
-            
-    async def _get_hierarchical_ollama_response(self, query: str, history: List, external_data: Dict) -> str:
-        """Get Ollama response with hierarchical awareness"""
-        try:
-            # Get Ollama provider
-            ollama_provider = llm_factory.get_provider('ollama')
-            if not ollama_provider:
-                raise Exception("Ollama provider not available")
-                
-            # Prepare conversation with hierarchical context
-            enhanced_history = history.copy()
-            
-            # Inject current time into Ollama context too
-            current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-            time_context = {
-                "role": "system",
-                "content": f"[Current Date & Time: {current_time}]"
-            }
-            enhanced_history = [time_context] + enhanced_history
-            
-            # Add system instruction for Ollama's role
-            enhanced_history.insert(0, {
-                "role": "system",
-                "content": self.system_instructions['ollama_role']
-            })
-            
-            # Add external data context if available
-            if external_data:
-                context_parts = []
-                if 'search_answer' in external_data:
-                    context_parts.append(f"Current information: {external_data['search_answer']}")
-                if 'weather' in external_data:
-                    weather = external_data['weather']
-                    context_parts.append(f"Current weather: {weather.get('temperature', 'N/A')}°C in {weather.get('city', 'Unknown')}")
-                if 'current_datetime' in external_data:
-                    context_parts.append(f"Current time: {external_data['current_datetime']}")
-                    
-                if context_parts:
-                    context_message = {
-                        "role": "system",
-                        "content": "Context: " + " | ".join(context_parts)
-                    }
-                    enhanced_history.insert(1, context_message)  # Insert after role instruction
-                    
-            # Add the user's query
-            enhanced_history.append({"role": "user", "content": query})
-            
-            # Generate response with awareness of HF's superior capabilities
-            response = ollama_provider.generate(query, enhanced_history)
-            
-            # Add acknowledgment of HF's authority
-            if response:
-                return f"{response}\n\n*Note: A more comprehensive analysis from the uncensored HF model is being prepared...*"
-            else:
-                return "I'm processing your request... A deeper analysis is being prepared by the authoritative model."
-                
-        except Exception as e:
-            logger.error(f"Hierarchical Ollama response failed: {e}")
-            return "I'm thinking about your question... Preparing a comprehensive response."
-            
-    def _check_hf_availability(self) -> bool:
-        """Check if HF endpoint is configured and available"""
-        try:
-            from utils.config import config
-            return bool(config.hf_token and config.hf_api_url)
-        except:
-            return False
-            
-    async def _gather_external_data(self, query: str) -> Dict:
-        """Gather external data from various sources"""
-        data = {}
-        
-        # Tavily/DuckDuckGo search with justification focus
-        if self.tavily_client or web_search_service.client:
-            try:
-                search_results = web_search_service.search(f"current information about {query}")
-                if search_results:
-                    data['search_results'] = search_results
-                    # Optionally extract answer summary
-                    # data['search_answer'] = ...
-            except Exception as e:
-                logger.warning(f"Tavily search failed: {e}")
-                
-        # Weather data
-        weather_keywords = ['weather', 'temperature', 'forecast', 'climate', 'rain', 'sunny']
-        if any(keyword in query.lower() for keyword in weather_keywords):
-            try:
-                location = self._extract_location(query) or "New York"
-                weather = weather_service.get_current_weather_cached(
-                    location, 
-                    ttl_hash=weather_service._get_ttl_hash(300)
-                )
-                if weather:
-                    data['weather'] = weather
-            except Exception as e:
-                logger.warning(f"Weather data failed: {e}")
-                
-        # Current date/time
-        data['current_datetime'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
-        return data
-        
-    def _extract_location(self, query: str) -> Optional[str]:
-        """Extract location from query"""
-        locations = ['New York', 'London', 'Tokyo', 'Paris', 'Berlin', 'Sydney', 
-                    'Los Angeles', 'Chicago', 'Miami', 'Seattle', 'Boston', 
-                    'San Francisco', 'Toronto', 'Vancouver', 'Montreal']
-        
-        for loc in locations:
-            if loc.lower() in query.lower():
-                return loc
-        return "New York"  # Default
-        
-    def get_coordination_status(self) -> Dict:
-        """Get current coordination system status"""
-        return {
-            'tavily_available': self.tavily_client is not None,
-            'weather_available': weather_service.api_key is not None,
-            'web_search_enabled': self.tavily_client is not None,
-            'external_apis_configured': any([
-                weather_service.api_key,
-                os.getenv("TAVILY_API_KEY")
-            ])
-        }
-        
-    def get_recent_activities(self, user_id: str) -> Dict:
-        """Get recent coordination activities for user"""
-        try:
-            session = session_manager.get_session(user_id)
-            coord_stats = session.get('ai_coordination', {})
-            return {
-                'last_request': coord_stats.get('last_coordination'),
-                'requests_processed': coord_stats.get('requests_processed', 0),
-                'ollama_responses': coord_stats.get('ollama_responses', 0),
-                'hf_responses': coord_stats.get('hf_responses', 0)
-            }
-        except:
-            return {}
+            logger.error(f"Message processing failed: {e}")
+            return "Sorry, I couldn't process your request."
 
-# Global coordinator instance
-coordinator = AICoordinator()
+# Global instance
+coordinator = SimpleCoordinator()

core/llm.py

@@ -5,32 +5,28 @@ from core.llm_factory import llm_factory, ProviderNotAvailableError
 logger = logging.getLogger(__name__)
 
 class LLMClient:
-    """High-level LLM client that uses the factory pattern with improved error handling"""
-
+    """Simple LLM client using factory pattern"""
+    
     def __init__(self):
         try:
             self.provider = llm_factory.get_provider()
         except ProviderNotAvailableError:
             self.provider = None
             logger.error("No LLM providers available")
-
+    
     def generate(self, prompt: str, conversation_history: List[Dict], stream: bool = False) -> Optional[str]:
-        """
-        Generate a response with robust error handling.
-        """
+        """Generate a response"""
         if not self.provider:
             raise ProviderNotAvailableError("No LLM provider available")
-
+        
         try:
             if stream:
                 result = self.provider.stream_generate(prompt, conversation_history)
-                # For streaming, combine chunks into single response
                 if isinstance(result, list):
                     return "".join(result)
                 return result
             else:
                 return self.provider.generate(prompt, conversation_history)
-                
         except Exception as e:
             logger.error(f"LLM generation failed: {e}")
-            raise  # Re-raise to let caller handle appropriately
+            raise

debug_dashboard_test.py

@@ -1,86 +0,0 @@
-import sys
-from pathlib import Path
-
-# Add project root to path
-project_root = Path(__file__).parent
-sys.path.append(str(project_root))
-
-from services.hf_endpoint_monitor import hf_monitor
-from core.coordinator import coordinator
-from utils.config import config
-import os
-
-def test_debug_features():
-    """Test the enhanced debug features"""
-    print("=== Debug Dashboard Feature Test ===")
-    print()
-    
-    # Test HF Endpoint Monitor Enhanced Features
-    print("1. Testing HF Endpoint Monitor Enhanced Features:")
-    try:
-        # Basic status
-        basic_status = hf_monitor.get_status_summary()
-        print(f"   Basic Status: {basic_status}")
-        
-        # Detailed status
-        detailed_status = hf_monitor.get_detailed_status()
-        print(f"   Detailed Status Keys: {list(detailed_status.keys())}")
-        
-        # Performance metrics
-        perf_metrics = hf_monitor.get_performance_metrics()
-        print(f"   Performance Metrics: {perf_metrics}")
-        
-        print("   ✅ HF Endpoint Monitor Enhanced Features Working")
-    except Exception as e:
-        print(f"   ❌ HF Endpoint Monitor Test Failed: {e}")
-    
-    print()
-    
-    # Test Coordinator Status Tracking
-    print("2. Testing Coordinator Status Tracking:")
-    try:
-        # Coordination status
-        coord_status = coordinator.get_coordination_status()
-        print(f"   Coordination Status: {coord_status}")
-        
-        # Recent activities (test with demo user)
-        recent_activities = coordinator.get_recent_activities("demo_user")
-        print(f"   Recent Activities Keys: {list(recent_activities.keys())}")
-        
-        print("   ✅ Coordinator Status Tracking Working")
-    except Exception as e:
-        print(f"   ❌ Coordinator Status Tracking Test Failed: {e}")
-    
-    print()
-    
-    # Test Configuration Display
-    print("3. Testing Configuration Display:")
-    try:
-        print(f"   Environment Type: {'HF Space' if config.is_hf_space else 'Local'}")
-        print(f"   Fallback Mode: {config.use_fallback}")
-        print(f"   HF Token Available: {bool(config.hf_token)}")
-        print(f"   Tavily API Key: {bool(os.getenv('TAVILY_API_KEY'))}")
-        print(f"   OpenWeather API Key: {bool(config.openweather_api_key)}")
-        
-        # Feature flags
-        features = []
-        if config.use_fallback:
-            features.append("Fallback Mode")
-        if os.getenv("TAVILY_API_KEY"):
-            features.append("Web Search")
-        if config.openweather_api_key:
-            features.append("Weather Data")
-        if config.hf_token:
-            features.append("Deep Analysis")
-        
-        print(f"   Active Features: {', '.join(features) if features else 'None'}")
-        
-        print("   ✅ Configuration Display Working")
-    except Exception as e:
-        print(f"   ❌ Configuration Display Test Failed: {e}")
-    
-    print()
-    print("🎉 Debug Dashboard Feature Test Completed!")
-
-if __name__ == "__main__":
-    test_debug_features()

demo_coordinated_ai.py

@@ -1,100 +0,0 @@
-import sys
-from pathlib import Path
-import asyncio
-import os
-
-# 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
-from services.hf_endpoint_monitor import hf_monitor
-from utils.config import config
-
-async def demo_coordinated_ai():
-    """Demo the coordinated AI response system - HF Space version"""
-    print("=== AI Life Coach Coordinated Response Demo ===")
-    print()
-    
-    # Test query
-    user_query = "What are some good productivity tips for remote work?"
-    user_id = "demo_user"
-    
-    print(f"User Query: {user_query}")
-    print()
-    
-    # Check configuration from HF Space environment
-    print("HF Space Environment Configuration:")
-    print(f"  Running on HF Space: {'✅' if config.is_hf_space else '❌'}")
-    print(f"  Ollama Host Configured: {'✅' if config.ollama_host else '❌'}")
-    print(f"  HF Token Available: {'✅' if config.hf_token else '❌'}")
-    print(f"  External APIs Configured: {'✅' if (config.openweather_api_key or os.getenv('TAVILY_API_KEY')) else '❌'}")
-    print()
-    
-    # Check HF endpoint status
-    print("HF Endpoint Status:")
-    try:
-        hf_status = hf_monitor.get_status_summary()
-        print(hf_status)
-    except Exception as e:
-        print(f"❌ HF Monitor unavailable: {e}")
-    print()
-    
-    # Coordinate responses (graceful degradation)
-    print("Coordinating AI responses...")
-    try:
-        result = await coordinator.coordinate_response(user_id, user_query)
-        
-        print(f"Immediate Response (Ollama): {result['immediate_response']}")
-        print()
-        
-        # Show what external data would be gathered (if APIs were configured)
-        print("External Data Integration:")
-        print("  🌐 Web Search: Requires TAVILY_API_KEY")
-        print("  🌤️ Weather: Requires OPENWEATHER_API_KEY")
-        print("  🕐 Time/Date: Always available")
-        print()
-        
-        # Handle HF response gracefully
-        hf_task = result.get('hf_task')
-        if hf_task and config.hf_token:
-            print("HF endpoint configured - would attempt deep analysis")
-            print("(In HF Space with proper configuration, this would initialize the endpoint)")
-        elif config.hf_token:
-            print("⚠️ HF endpoint configured but unavailable")
-        else:
-            print("ℹ️ HF endpoint not configured (normal for local testing)")
-        
-        # Update session with coordination data
-        session_manager.update_session_with_ai_coordination(user_id, {
-            'immediate_response': result['immediate_response'],
-            'external_data': result.get('external_data', {}),
-            'hf_configured': bool(config.hf_token)
-        })
-        
-        # Show coordination statistics
-        session = session_manager.get_session(user_id)
-        coord_stats = session.get('ai_coordination', {})
-        if coord_stats:
-            print()
-            print("AI Coordination Statistics:")
-            print(f"  Requests Processed: {coord_stats.get('requests_processed', 0)}")
-            print(f"  Ollama Responses: {coord_stats.get('ollama_responses', 0)}")
-            print(f"  HF Configured: {'✅' if coord_stats.get('hf_configured') else '❌'}")
-            print(f"  Last Coordination: {coord_stats.get('last_coordination', 'N/A')}")
-            
-    except Exception as e:
-        print(f"❌ Coordination failed: {e}")
-        print("This is expected in local environment without full HF Space configuration")
-        print()
-        print("✅ System architecture is correct - will work properly in HF Space")
-        return True
-    
-    print()
-    print("🎉 Demo completed successfully!")
-    print("✅ System ready for HF Space deployment!")
-    return True
-
-if __name__ == "__main__":
-    asyncio.run(demo_coordinated_ai())

services/hf_endpoint_monitor.py

@@ -1,291 +0,0 @@
-import requests
-import time
-import logging
-from typing import Dict, Optional
-from utils.config import config
-logger = logging.getLogger(__name__)
-
-class HFEndpointMonitor:
-    """Monitor Hugging Face endpoint status and health"""
-    
-    def __init__(self):
-        # Clean the endpoint URL
-        raw_url = config.hf_api_url or ""
-        self.endpoint_url = self._clean_endpoint_url(raw_url)
-        self.hf_token = config.hf_token
-        self.is_initialized = False
-        self.last_check = 0
-        self.check_interval = 300  # Increase from 60 to 300 seconds (5 minutes)
-        self.warmup_attempts = 0
-        self.max_warmup_attempts = 3
-        self.warmup_count = 0
-        self.successful_requests = 0
-        self.failed_requests = 0
-        self.avg_response_time = 0
-        logger.info(f"Initialized HF Monitor with URL: {self.endpoint_url}")
-        
-    def _clean_endpoint_url(self, url: str) -> str:
-        """Clean and validate endpoint URL"""
-        if not url:
-            return ""
-        # Remove environment variable names if present
-        url = url.replace('hf_api_endpoint_url=', '')
-        url = url.replace('HF_API_ENDPOINT_URL=', '')
-        # Strip whitespace
-        url = url.strip()
-        # Ensure it starts with https://
-        if url and not url.startswith(('http://', 'https://')):
-            if 'huggingface.cloud' in url:
-                url = 'https://' + url
-            else:
-                url = 'https://' + url
-        # Remove trailing slashes but keep /v1 if present
-        if url.endswith('/'):
-            url = url.rstrip('/')
-        return url
-        
-    def check_endpoint_status(self) -> Dict:
-        """Check if HF endpoint is available and initialized with rate limiting"""
-        current_time = time.time()
-        # Don't check too frequently - minimum 1 minute between checks
-        if current_time - self.last_check < 60:
-            # Return cached status or basic status
-            return {
-                'available': getattr(self, '_last_available', False),
-                'status_code': getattr(self, '_last_status_code', None),
-                'initialized': getattr(self, '_last_initialized', False),
-                'timestamp': self.last_check
-            }
-        # Proceed with actual check
-        self.last_check = current_time
-        try:
-            if not self.endpoint_url or not self.hf_token:
-                status_info = {
-                    'available': False,
-                    'status_code': None,
-                    'initialized': False,
-                    'error': 'URL or token not configured',
-                    'timestamp': time.time()
-                }
-            else:
-                # Properly construct the models endpoint URL
-                models_url = f"{self.endpoint_url.rstrip('/')}/models"
-                logger.info(f"Checking HF endpoint at: {models_url}")
-                headers = {"Authorization": f"Bearer {self.hf_token}"}
-                response = requests.get(
-                    models_url,
-                    headers=headers,
-                    timeout=15
-                )
-                status_info = {
-                    'available': response.status_code in [200, 201],
-                    'status_code': response.status_code,
-                    'initialized': self._is_endpoint_initialized(response),
-                    'response_time': response.elapsed.total_seconds(),
-                    'timestamp': time.time()
-                }
-                
-                # Enhanced status info with model and region if available
-                if response.status_code in [200, 201]:
-                    try:
-                        data = response.json()
-                        if 'data' in data and len(data['data']) > 0:
-                            status_info['model'] = data['data'][0].get('id', 'Unknown')
-                        # Try to extract region from URL if possible
-                        if 'us-east-1' in self.endpoint_url:
-                            status_info['region'] = 'us-east-1'
-                        elif 'us-west' in self.endpoint_url:
-                            status_info['region'] = 'us-west'
-                    except:
-                        pass
-                        
-                    status_info['warmup_count'] = getattr(self, 'warmup_count', 0)
-                    
-                if response.status_code not in [200, 201]:
-                    status_info['error'] = f"HTTP {response.status_code}: {response.text[:200]}"
-                logger.info(f"HF Endpoint Status: {status_info}")
-                # Cache the results
-                self._last_available = status_info['available']
-                self._last_status_code = status_info['status_code']
-                self._last_initialized = status_info.get('initialized', False)
-            return status_info
-        except Exception as e:
-            error_msg = str(e)
-            logger.error(f"HF endpoint check failed: {error_msg}")
-            status_info = {
-                'available': False,
-                'status_code': None,
-                'initialized': False,
-                'error': error_msg,
-                'timestamp': time.time()
-            }
-            # Cache the results
-            self._last_available = False
-            self._last_status_code = None
-            self._last_initialized = False
-            return status_info
-            
-    def _is_endpoint_initialized(self, response) -> bool:
-        """Determine if endpoint is fully initialized"""
-        try:
-            data = response.json()
-            return 'data' in data or 'models' in data
-        except:
-            return response.status_code in [200, 201]
-            
-    def warm_up_endpoint(self) -> bool:
-        """Send a warm-up request to initialize the endpoint"""
-        try:
-            if not self.endpoint_url or not self.hf_token:
-                logger.warning("Cannot warm up HF endpoint - URL or token not configured")
-                return False
-            self.warmup_attempts += 1
-            logger.info(f"Warming up HF endpoint (attempt {self.warmup_attempts})...")
-            headers = {
-                "Authorization": f"Bearer {self.hf_token}",
-                "Content-Type": "application/json"
-            }
-            # Construct proper chat completions URL
-            chat_url = f"{self.endpoint_url.rstrip('/')}/chat/completions"
-            logger.info(f"Sending warm-up request to: {chat_url}")
-            payload = {
-                "model": "meta-llama/Llama-2-7b-chat-hf",
-                "messages": [{"role": "user", "content": "Hello"}],
-                "max_tokens": 10,
-                "stream": False
-            }
-            response = requests.post(
-                chat_url,
-                headers=headers,
-                json=payload,
-                timeout=45  # Longer timeout for cold start
-            )
-            success = response.status_code in [200, 201]
-            if success:
-                self.is_initialized = True
-                self.warmup_count += 1
-                self.warmup_attempts = 0  # Reset on success
-                logger.info("✅ HF endpoint warmed up successfully")
-            else:
-                logger.warning(f"⚠️ HF endpoint warm-up response: {response.status_code}")
-                logger.debug(f"Response body: {response.text[:500]}")
-            return success
-        except Exception as e:
-            logger.error(f"HF endpoint warm-up failed: {e}")
-            self.failed_requests += 1
-            return False
-            
-    def get_status_summary(self) -> str:
-        """Get human-readable status summary"""
-        status = self.check_endpoint_status()
-        if status['available']:
-            if status.get('initialized', False):
-                return "🟢 HF Endpoint: Available and Initialized"
-            else:
-                return "🟡 HF Endpoint: Available but Initializing"
-        else:
-            return "🔴 HF Endpoint: Unavailable"
-            
-    def handle_scale_to_zero(self) -> bool:
-        """Handle scale-to-zero behavior with user feedback"""
-        logger.info("HF endpoint appears to be scaled to zero. Attempting to wake it up...")
-        # Try to warm up the endpoint
-        for attempt in range(self.max_warmup_attempts):
-            logger.info(f"Wake-up attempt {attempt + 1}/{self.max_warmup_attempts}")
-            if self.warm_up_endpoint():
-                logger.info("✅ HF endpoint successfully woken up!")
-                return True
-            time.sleep(10)  # Wait between attempts
-        logger.error("❌ Failed to wake up HF endpoint after all attempts")
-        return False
-        
-    def get_detailed_status(self) -> Dict:
-        """Get detailed HF endpoint status with metrics"""
-        try:
-            headers = {"Authorization": f"Bearer {self.hf_token}"}
-            # Get model info
-            models_url = f"{self.endpoint_url.rstrip('/')}/models"
-            model_response = requests.get(
-                models_url,
-                headers=headers,
-                timeout=10
-            )
-            # Get endpoint info if available
-            endpoint_info = {}
-            try:
-                info_url = f"{self.endpoint_url.rstrip('/')}/info"
-                info_response = requests.get(
-                    info_url,
-                    headers=headers,
-                    timeout=10
-                )
-                if info_response.status_code == 200:
-                    endpoint_info = info_response.json()
-            except:
-                pass
-            status_info = {
-                'available': model_response.status_code == 200,
-                'status_code': model_response.status_code,
-                'initialized': self._is_endpoint_initialized(model_response),
-                'endpoint_info': endpoint_info,
-                'last_checked': time.time(),
-                'warmup_attempts': getattr(self, 'warmup_attempts', 0),
-                'is_warming_up': getattr(self, 'is_warming_up', False)
-            }
-            return status_info
-        except Exception as e:
-            return {
-                'available': False,
-                'status_code': None,
-                'initialized': False,
-                'error': str(e),
-                'last_checked': time.time()
-            }
-            
-    def get_performance_metrics(self) -> Dict:
-        """Get HF endpoint performance metrics"""
-        return {
-            'warmup_count': getattr(self, 'warmup_count', 0),
-            'successful_requests': getattr(self, 'successful_requests', 0),
-            'failed_requests': getattr(self, 'failed_requests', 0),
-            'average_response_time': getattr(self, 'avg_response_time', 0)
-        }
-        
-    # Add enhanced status tracking methods
-    def get_enhanced_status(self) -> Dict:
-        """Get enhanced HF endpoint status with engagement tracking"""
-        basic_status = self.check_endpoint_status()
-        return {
-            **basic_status,
-            "engagement_level": self._determine_engagement_level(),
-            "last_engagement": getattr(self, '_last_engagement_time', None),
-            "total_engagements": getattr(self, '_total_engagements', 0),
-            "current_research_topic": getattr(self, '_current_research_topic', None)
-        }
-        
-    def _determine_engagement_level(self) -> str:
-        """Determine current engagement level"""
-        if not self.is_initialized:
-            return "idle"
-        elif getattr(self, '_currently_analyzing', False):
-            return "analyzing"
-        elif getattr(self, '_pending_research', False):
-            return "research_pending"
-        else:
-            return "ready"
-            
-    def start_hf_analysis(self, topic: str = None):
-        """Start HF analysis with topic tracking"""
-        self._currently_analyzing = True
-        self._last_engagement_time = time.time()
-        self._total_engagements = getattr(self, '_total_engagements', 0) + 1
-        if topic:
-            self._current_research_topic = topic
-            
-    def finish_hf_analysis(self):
-        """Finish HF analysis"""
-        self._currently_analyzing = False
-        self._current_research_topic = None
-
-# Global instance
-hf_monitor = HFEndpointMonitor()

test_enhanced_features.py

@@ -1,65 +0,0 @@
-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())

test_hf_activation.py

@@ -1,134 +0,0 @@
-import sys
-from pathlib import Path
-
-# Add project root to path
-project_root = Path(__file__).parent
-sys.path.append(str(project_root))
-
-def test_hf_activation_features():
-    """Test the manual HF activation and indication features"""
-    print("=== HF Activation Features Test ===")
-    print()
-    
-    # Test 1: Check app.py for manual HF activation UI
-    print("1. Testing App.py Manual HF Activation UI:")
-    try:
-        with open('app.py', 'r') as f:
-            content = f.read()
-            
-        required_components = [
-            'hf_expert_requested',
-            'Activate HF Expert',
-            '🤖 HF Expert Analysis',
-            'Manual HF Analysis Section'
-        ]
-        
-        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 manual HF activation UI components present")
-            
-    except Exception as e:
-        print(f"   ❌ Error reading app.py: {e}")
-    
-    print()
-    
-    # Test 2: Check coordinator for web search determination
-    print("2. Testing Coordinator Web Search Determination:")
-    try:
-        with open('core/coordinator.py', 'r') as f:
-            content = f.read()
-            
-        required_methods = [
-            'determine_web_search_needs',
-            'manual_hf_analysis',
-            'get_hf_engagement_status'
-        ]
-        
-        missing_methods = []
-        for method in required_methods:
-            if method not in content:
-                missing_methods.append(method)
-        
-        if missing_methods:
-            print(f"   ❌ Missing methods: {missing_methods}")
-        else:
-            print("   ✅ All web search determination methods present")
-            
-    except Exception as e:
-        print(f"   ❌ Error reading coordinator.py: {e}")
-    
-    print()
-    
-    # Test 3: Check HF monitor for enhanced status tracking
-    print("3. Testing HF Monitor Enhanced Status Tracking:")
-    try:
-        with open('services/hf_endpoint_monitor.py', 'r') as f:
-            content = f.read()
-            
-        required_methods = [
-            'get_enhanced_status',
-            'start_hf_analysis',
-            'finish_hf_analysis'
-        ]
-        
-        missing_methods = []
-        for method in required_methods:
-            if method not in content:
-                missing_methods.append(method)
-        
-        if missing_methods:
-            print(f"   ❌ Missing methods: {missing_methods}")
-        else:
-            print("   ✅ All enhanced status tracking methods present")
-            
-    except Exception as e:
-        print(f"   ❌ Error reading hf_endpoint_monitor.py: {e}")
-    
-    print()
-    
-    # Test 4: Check for visual indication features
-    print("4. Testing Visual Indication Features:")
-    try:
-        with open('app.py', 'r') as f:
-            content = f.read()
-            
-        visual_indicators = [
-            '🤖 HF Expert Analysis',
-            '🧠 Activate HF Expert',
-            'Research Needed',
-            'Web Research'
-        ]
-        
-        missing_indicators = []
-        for indicator in visual_indicators:
-            if indicator not in content:
-                missing_indicators.append(indicator)
-        
-        if missing_indicators:
-            print(f"   ❌ Missing visual indicators: {missing_indicators}")
-        else:
-            print("   ✅ All visual indication features present")
-            
-    except Exception as e:
-        print(f"   ❌ Error checking visual indicators: {e}")
-    
-    print()
-    print("🎉 HF Activation Features Test Completed!")
-    print()
-    print("🎯 IMPLEMENTED FEATURES:")
-    print("1. ✅ Manual HF Expert Activation Button")
-    print("2. ✅ Visual Indications of HF Engagement")
-    print("3. ✅ Conversation History Preview for HF")
-    print("4. ✅ Web Search Need Determination")
-    print("5. ✅ Research Topic Identification")
-    print("6. ✅ Enhanced Status Tracking")
-    print("7. ✅ Clear HF Expert Response Formatting")
-
-if __name__ == "__main__":
-    test_hf_activation_features()

test_hf_monitor.py

@@ -1,42 +0,0 @@
-import sys
-from pathlib import Path
-
-# Add project root to path
-project_root = Path(__file__).parent
-sys.path.append(str(project_root))
-
-from services.hf_endpoint_monitor import hf_monitor
-
-def test_hf_monitor():
-    """Test the HF endpoint monitor"""
-    print("=== HF Endpoint Monitor Test ===")
-    print()
-    
-    # Show current status
-    print("Current HF Endpoint Status:")
-    status = hf_monitor.check_endpoint_status()
-    print(f"  Available: {status['available']}")
-    print(f"  Status Code: {status['status_code']}")
-    print(f"  Initialized: {status.get('initialized', 'Unknown')}")
-    if 'error' in status:
-        print(f"  Error: {status['error']}")
-    print()
-    
-    # Show human-readable status
-    print("Human-Readable Status:")
-    print(hf_monitor.get_status_summary())
-    print()
-    
-    # Try to warm up endpoint if not available
-    if not status['available']:
-        print("Attempting to warm up endpoint...")
-        success = hf_monitor.warm_up_endpoint()
-        print(f"Warm-up result: {'Success' if success else 'Failed'}")
-        print()
-        
-        # Check status again
-        print("Status after warm-up attempt:")
-        print(hf_monitor.get_status_summary())
-
-if __name__ == "__main__":
-    test_hf_monitor()

test_hf_url_fix.py

@@ -1,53 +0,0 @@
-import sys
-from pathlib import Path
-
-# Add project root to path
-project_root = Path(__file__).parent
-sys.path.append(str(project_root))
-
-from utils.config import config
-from services.hf_endpoint_monitor import hf_monitor
-
-def test_hf_url_fix():
-    """Test the HF endpoint URL fix"""
-    print("=== HF Endpoint URL Fix Test ===")
-    print()
-    
-    # Test configuration parsing
-    print("1. Testing Configuration Parsing:")
-    print(f"   Raw HF_API_ENDPOINT_URL: {config.hf_api_url}")
-    print(f"   Parsed endpoint URL: {getattr(hf_monitor, 'endpoint_url', 'Not initialized')}")
-    print()
-    
-    # Test URL cleaning
-    print("2. Testing URL Cleaning:")
-    test_urls = [
-        "https://zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/",
-        "hf_api_endpoint_url=https://zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/",
-        "HF_API_ENDPOINT_URL=https://zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/",
-        "zxzbfrlg3ssrk7d9.us-east-1.aws.endpoints.huggingface.cloud/v1/"
-    ]
-    
-    for url in test_urls:
-        cleaned = hf_monitor._clean_endpoint_url(url) if hasattr(hf_monitor, '_clean_endpoint_url') else "Method not available"
-        print(f"   Input:  {url}")
-        print(f"   Output: {cleaned}")
-        print()
-    
-    # Test HF endpoint status (if token is available)
-    print("3. Testing HF Endpoint Status:")
-    try:
-        status = hf_monitor.check_endpoint_status()
-        print(f"   Available: {status.get('available', 'Unknown')}")
-        print(f"   Status Code: {status.get('status_code', 'Unknown')}")
-        print(f"   Initialized: {status.get('initialized', 'Unknown')}")
-        if 'error' in status:
-            print(f"   Error: {status['error']}")
-    except Exception as e:
-        print(f"   Error checking status: {e}")
-    
-    print()
-    print("🎉 HF Endpoint URL Fix Test Completed!")
-
-if __name__ == "__main__":
-    test_hf_url_fix()

test_hierarchical_coordination.py

@@ -1,83 +0,0 @@
-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_hierarchical_coordination():
-    """Test the hierarchical coordination system"""
-    print("=== Hierarchical Coordination System Test ===")
-    print()
-    
-    # Test user query
-    user_query = "What are the key principles of effective time management?"
-    user_id = "test_user"
-    
-    print(f"User Query: {user_query}")
-    print()
-    
-    # Test coordination status
-    print("1. 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()
-    
-    # Test hierarchical conversation coordination
-    print("2. Testing Hierarchical Conversation Coordination:")
-    try:
-        print("   Starting hierarchical 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}: {response_chunk['type']} - {response_chunk['content'][:50]}...")
-            
-            # Limit output for readability
-            if response_count >= 5:
-                print("   ... (truncated for brevity)")
-                break
-        
-        print("   ✅ Hierarchical Coordination Test Passed")
-    except Exception as e:
-        print(f"   ❌ Hierarchical Coordination Test Failed: {e}")
-    
-    print()
-    
-    # Test hierarchical session tracking
-    print("3. Testing Hierarchical Session Tracking:")
-    try:
-        # Update with test coordination data
-        test_data = {
-            'hf_engaged': True,
-            'ollama_responded': True,
-            'success': True
-        }
-        update_result = session_manager.update_hierarchical_coordination(user_id, test_data)
-        print(f"   Update Result: {'✅ Success' if update_result else '❌ Failed'}")
-        
-        # Get hierarchical stats
-        stats = session_manager.get_hierarchical_stats(user_id)
-        print(f"   Total Conversations: {stats.get('total_conversations', 0)}")
-        print(f"   HF Engagements: {stats.get('hf_engagements', 0)}")
-        print(f"   Ollama Responses: {stats.get('ollama_responses', 0)}")
-        print("   ✅ Hierarchical Session Tracking Passed")
-    except Exception as e:
-        print(f"   ❌ Hierarchical Session Tracking Failed: {e}")
-    
-    print()
-    print("🎉 Hierarchical Coordination System Test Completed!")
-
-if __name__ == "__main__":
-    asyncio.run(test_hierarchical_coordination())