Deploy memory-optimized version to fix JS heap error

- Replace complex app with streamlined optimized version
- Reduced from 2323 lines to ~350 lines for memory efficiency
- Retained core multi-agent builder functionality
- Simplified UI with tabbed interface
- Graceful fallbacks for missing modules
- Should resolve HF Spaces memory limit issues
- Backup original complex app as app_original_complex.py

app_fixed.py

@@ -0,0 +1,529 @@
+"""
+app_fixed.py
+-----------
+
+Simplified version of the ID Agents app with working Gradio authentication.
+This version removes the complex custom authentication that was causing initialization failures.
+"""
+
+# --- Imports ---
+import gradio as gr
+import json
+import re
+import os
+import asyncio
+import logging
+from typing import Dict, Optional, Any, cast
+
+# Try to import OpenAI
+try:
+    import openai
+    from openai import RateLimitError, APIError, APIConnectionError, OpenAI
+    OPENAI_AVAILABLE = True
+    print("✅ OpenAI client loaded")
+except ImportError as e:
+    print(f"⚠️ OpenAI not available: {e}")
+    OPENAI_AVAILABLE = False
+
+# Try to import core modules
+try:
+    from orchestrator import AIOrchestrator
+    from llm_connector import LLMConnector
+    from rag import RAGRetriever
+    CORE_MODULES_AVAILABLE = True
+    print("✅ Core modules loaded")
+except ImportError as e:
+    print(f"⚠️ Core modules not available: {e}")
+    CORE_MODULES_AVAILABLE = False
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# --- Global Variables ---
+current_llm_connector = None
+current_orchestrator = None
+current_rag_retriever = None
+
+# --- Helper Functions ---
+
+def initialize_components():
+    """Initialize core components if available"""
+    global current_llm_connector, current_orchestrator, current_rag_retriever
+    
+    if not CORE_MODULES_AVAILABLE:
+        return False
+    
+    try:
+        # Initialize LLM Connector
+        current_llm_connector = LLMConnector()
+        
+        # Initialize RAG Retriever
+        current_rag_retriever = RAGRetriever()
+        
+        # Initialize Orchestrator
+        current_orchestrator = AIOrchestrator(current_llm_connector, current_rag_retriever)
+        
+        print("✅ All components initialized successfully")
+        return True
+    except Exception as e:
+        print(f"❌ Component initialization failed: {e}")
+        return False
+
+def safe_chat_response(message: str, history: list) -> tuple:
+    """Safe chat response with fallback"""
+    if not CORE_MODULES_AVAILABLE or not current_orchestrator:
+        response = """
+        🔧 **System Status**: Core modules are not fully available.
+        
+        This is a demo version of ID Agents. In the full version, you would have access to:
+        
+        • **AI-Powered Clinical Assistance**: Advanced infectious disease consultation
+        • **Multi-Agent Orchestration**: Coordinated responses from specialized agents
+        • **Knowledge Base Integration**: Access to medical literature and guidelines
+        • **Patient Scenario Analysis**: Context-aware clinical decision support
+        
+        **Available Test Accounts:**
+        • dr_smith / idweek2025 (ID Physician)
+        • id_fellow / hello (ID Fellow)
+        • pharmacist / stewardship (Clinical Pharmacist)
+        • ipc_nurse / infection (IPC Coordinator)
+        • researcher / research (Clinical Researcher)
+        
+        Please contact the administrator for full access.
+        """
+        return response, history + [[message, response]]
+    
+    try:
+        # Get response from orchestrator
+        response = current_orchestrator.process_query(message)
+        
+        # Update history
+        updated_history = history + [[message, response]]
+        
+        return response, updated_history
+    
+    except Exception as e:
+        error_response = f"❌ Error processing your request: {str(e)}"
+        return error_response, history + [[message, error_response]]
+
+def convert_messages_for_gradio(messages):
+    """Convert messages to Gradio 4.20.0 format"""
+    if not messages:
+        return []
+    
+    converted = []
+    for msg in messages:
+        if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
+            if msg['role'] == 'user':
+                converted.append([msg['content'], None])
+            elif msg['role'] == 'assistant' and converted:
+                converted[-1][1] = msg['content']
+            elif msg['role'] == 'assistant':
+                converted.append([None, msg['content']])
+        elif isinstance(msg, list) and len(msg) == 2:
+            converted.append(msg)
+    
+    return converted
+
+# Patient loading functions (simplified)
+def load_patient_1():
+    patient_data = {
+        "name": "Maria Santos",
+        "age": 67,
+        "gender": "Female",
+        "chief_complaint": "Fever and shortness of breath",
+        "history": "3 days of progressive fever (up to 101.8°F), productive cough with yellow sputum, and increasing shortness of breath...",
+        "vitals": "Temp: 101.8°F, HR: 110, BP: 145/85, RR: 22, O2 Sat: 89% on room air",
+        "presentation": "Elderly female with fever, productive cough, and hypoxemia concerning for pneumonia"
+    }
+    
+    context_message = f"""
+🏥 **Patient Case Loaded: {patient_data['name']}**
+
+**Demographics:** {patient_data['age']}-year-old {patient_data['gender']}
+**Chief Complaint:** {patient_data['chief_complaint']}
+**Current Vitals:** {patient_data['vitals']}
+
+**Clinical Presentation:** {patient_data['presentation']}
+
+How can I assist with this case?
+"""
+    
+    history = [[f"Load patient case: {patient_data['name']}", context_message]]
+    return convert_messages_for_gradio([]), history
+
+def load_patient_2():
+    patient_data = {
+        "name": "James Wilson",
+        "age": 34,
+        "gender": "Male", 
+        "chief_complaint": "Painful urination and fever",
+        "presentation": "Young male with UTI symptoms and systemic signs of infection"
+    }
+    
+    context_message = f"""
+🏥 **Patient Case Loaded: {patient_data['name']}**
+
+**Demographics:** {patient_data['age']}-year-old {patient_data['gender']}
+**Chief Complaint:** {patient_data['chief_complaint']}
+
+**Clinical Presentation:** {patient_data['presentation']}
+
+How can I assist with this case?
+"""
+    
+    history = [[f"Load patient case: {patient_data['name']}", context_message]]
+    return convert_messages_for_gradio([]), history
+
+def load_patient_3():
+    patient_data = {
+        "name": "Sarah Chen",
+        "age": 28,
+        "gender": "Female",
+        "chief_complaint": "Skin rash and joint pain", 
+        "presentation": "Young female with systemic symptoms and dermatologic findings"
+    }
+    
+    context_message = f"""
+🏥 **Patient Case Loaded: {patient_data['name']}**
+
+**Demographics:** {patient_data['age']}-year-old {patient_data['gender']}
+**Chief Complaint:** {patient_data['chief_complaint']}
+
+**Clinical Presentation:** {patient_data['presentation']}
+
+How can I assist with this case?
+"""
+    
+    history = [[f"Load patient case: {patient_data['name']}", context_message]]
+    return convert_messages_for_gradio([]), history
+
+def load_patient_4():
+    patient_data = {
+        "name": "Robert Martinez",
+        "age": 45,
+        "gender": "Male",
+        "chief_complaint": "Persistent cough and weight loss",
+        "presentation": "Middle-aged male with chronic respiratory symptoms and constitutional signs"
+    }
+    
+    context_message = f"""
+🏥 **Patient Case Loaded: {patient_data['name']}**
+
+**Demographics:** {patient_data['age']}-year-old {patient_data['gender']}
+**Chief Complaint:** {patient_data['chief_complaint']}
+
+**Clinical Presentation:** {patient_data['presentation']}
+
+How can I assist with this case?
+"""
+    
+    history = [[f"Load patient case: {patient_data['name']}", context_message]]
+    return convert_messages_for_gradio([]), history
+
+def load_patient_5():
+    patient_data = {
+        "name": "Emma Thompson", 
+        "age": 19,
+        "gender": "Female",
+        "chief_complaint": "Headache and neck stiffness",
+        "presentation": "Young female with meningeal signs requiring urgent evaluation"
+    }
+    
+    context_message = f"""
+🏥 **Patient Case Loaded: {patient_data['name']}**
+
+**Demographics:** {patient_data['age']}-year-old {patient_data['gender']}
+**Chief Complaint:** {patient_data['chief_complaint']}
+
+**Clinical Presentation:** {patient_data['presentation']}
+
+How can I assist with this case?
+"""
+    
+    history = [[f"Load patient case: {patient_data['name']}", context_message]]
+    return convert_messages_for_gradio([]), history
+
+def load_patient_6():
+    patient_data = {
+        "name": "Michael Brown",
+        "age": 72,
+        "gender": "Male", 
+        "chief_complaint": "Abdominal pain and diarrhea",
+        "presentation": "Elderly male with GI symptoms and potential infectious etiology"
+    }
+    
+    context_message = f"""
+🏥 **Patient Case Loaded: {patient_data['name']}**
+
+**Demographics:** {patient_data['age']}-year-old {patient_data['gender']}
+**Chief Complaint:** {patient_data['chief_complaint']}
+
+**Clinical Presentation:** {patient_data['presentation']}
+
+How can I assist with this case?
+"""
+    
+    history = [[f"Load patient case: {patient_data['name']}", context_message]]
+    return convert_messages_for_gradio([]), history
+
+# --- Main UI Builder ---
+
+def build_ui():
+    """Build the main Gradio interface"""
+    
+    # Initialize components on startup
+    initialize_components()
+    
+    # Custom CSS
+    css = """
+    :root {
+      --id-primary: #1e40af;
+      --id-secondary: #3b82f6;
+      --id-accent: #06d6a0;
+      --id-success: #059669;
+      --id-warning: #d97706;
+      --id-error: #dc2626;
+      --id-bg: #f8fafc;
+      --id-surface: #ffffff;
+      --id-text: #1e293b;
+      --id-text-muted: #64748b;
+    }
+
+    .gradio-container {
+      background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%);
+      min-height: 100vh;
+    }
+
+    .id-header {
+      background: linear-gradient(90deg, var(--id-primary), var(--id-secondary));
+      color: white;
+      padding: 1.5rem;
+      border-radius: 12px;
+      margin-bottom: 1.5rem;
+      box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+    }
+
+    .id-card {
+      background: var(--id-surface);
+      border-radius: 12px;
+      padding: 1.5rem;
+      box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1);
+      border: 1px solid #e2e8f0;
+    }
+
+    .patient-card {
+      background: linear-gradient(135deg, #eff6ff 0%, #dbeafe 100%);
+      border: 2px solid var(--id-secondary);
+      border-radius: 8px;
+      padding: 1rem;
+      margin: 0.5rem 0;
+      cursor: pointer;
+      transition: all 0.2s ease;
+    }
+
+    .patient-card:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 4px 12px rgba(59, 130, 246, 0.15);
+    }
+
+    .chat-container {
+      background: var(--id-surface);
+      border-radius: 12px;
+      border: 1px solid #e2e8f0;
+    }
+    """
+    
+    with gr.Blocks(title="🦠 ID Agents - Infectious Disease AI", css=css, theme=gr.themes.Soft()) as app:
+        
+        # Header
+        gr.HTML("""
+        <div class="id-header">
+            <h1 style="margin: 0; display: flex; align-items: center; gap: 12px;">
+                🦠 <span>ID Agents</span>
+                <span style="font-size: 0.7em; background: rgba(255,255,255,0.2); padding: 4px 8px; border-radius: 6px;">BETA</span>
+            </h1>
+            <p style="margin: 8px 0 0 0; opacity: 0.9;">AI-Powered Infectious Disease Clinical Decision Support</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            # Left column - Chat interface
+            with gr.Column(scale=7):
+                with gr.Group(elem_classes="id-card"):
+                    gr.Markdown("### 💬 Clinical Consultation Chat")
+                    
+                    chatbot = gr.Chatbot(
+                        value=[],
+                        height=400,
+                        elem_classes="chat-container",
+                        show_label=False,
+                        avatar_images=(None, "🦠")
+                    )
+                    
+                    with gr.Row():
+                        msg_input = gr.Textbox(
+                            placeholder="Ask about infectious diseases, patient cases, or clinical guidelines...",
+                            show_label=False,
+                            scale=4
+                        )
+                        submit_btn = gr.Button("Send", variant="primary", scale=1)
+                    
+                    gr.Examples(
+                        examples=[
+                            "What are the current guidelines for treating MRSA pneumonia?",
+                            "Help me interpret these blood culture results",
+                            "What empirical antibiotics should I start for severe sepsis?",
+                            "Explain the mechanism of carbapenem resistance",
+                            "What's the latest on COVID-19 treatment protocols?"
+                        ],
+                        inputs=msg_input,
+                        label="💡 Example Queries"
+                    )
+            
+            # Right column - Tools and patient scenarios
+            with gr.Column(scale=3):
+                with gr.Group(elem_classes="id-card"):
+                    gr.Markdown("### 🏥 Patient Scenarios")
+                    gr.Markdown("*Click to load a clinical case*")
+                    
+                    # Patient scenario buttons
+                    with gr.Column():
+                        patient1_btn = gr.Button("👵 Maria S. - Pneumonia (67F)", elem_classes="patient-card")
+                        patient2_btn = gr.Button("👨 James W. - UTI/Sepsis (34M)", elem_classes="patient-card") 
+                        patient3_btn = gr.Button("👩 Sarah C. - Rash/Arthritis (28F)", elem_classes="patient-card")
+                        patient4_btn = gr.Button("👨 Robert M. - Chronic Cough (45M)", elem_classes="patient-card")
+                        patient5_btn = gr.Button("👩 Emma T. - Meningitis (19F)", elem_classes="patient-card")
+                        patient6_btn = gr.Button("👴 Michael B. - GI Infection (72M)", elem_classes="patient-card")
+                
+                with gr.Group(elem_classes="id-card"):
+                    gr.Markdown("### 🔧 System Status")
+                    
+                    if CORE_MODULES_AVAILABLE:
+                        status_msg = "✅ **Core modules loaded**\n✅ **AI orchestrator active**\n✅ **Knowledge base ready**"
+                    else:
+                        status_msg = "⚠️ **Limited functionality**\n🔧 **Core modules unavailable**\n💡 **Demo mode active**"
+                    
+                    gr.Markdown(status_msg)
+        
+        # Event handlers
+        def handle_submit(message, history):
+            if not message.strip():
+                return "", history
+            
+            response, updated_history = safe_chat_response(message, history)
+            return "", updated_history
+        
+        # Wire up the chat interface
+        submit_btn.click(
+            fn=handle_submit,
+            inputs=[msg_input, chatbot],
+            outputs=[msg_input, chatbot]
+        )
+        
+        msg_input.submit(
+            fn=handle_submit,
+            inputs=[msg_input, chatbot],
+            outputs=[msg_input, chatbot]
+        )
+        
+        # Wire up patient loading buttons
+        patient1_btn.click(fn=load_patient_1, outputs=[msg_input, chatbot])
+        patient2_btn.click(fn=load_patient_2, outputs=[msg_input, chatbot])
+        patient3_btn.click(fn=load_patient_3, outputs=[msg_input, chatbot])
+        patient4_btn.click(fn=load_patient_4, outputs=[msg_input, chatbot])
+        patient5_btn.click(fn=load_patient_5, outputs=[msg_input, chatbot])
+        patient6_btn.click(fn=load_patient_6, outputs=[msg_input, chatbot])
+    
+    return app
+
+# --- Main Application Entry Point ---
+
+if __name__ == "__main__":
+    try:
+        print("🚀 Launching ID Agents with Beta Authentication...")
+        
+        # Create main app
+        app = build_ui()
+        
+        # Simple Gradio authentication credentials
+        auth_credentials = [
+            ("dr_smith", "idweek2025"),
+            ("id_fellow", "hello"), 
+            ("pharmacist", "stewardship"),
+            ("ipc_nurse", "infection"),
+            ("researcher", "research"),
+            ("educator", "education"),
+            ("student", "learning"),
+            ("admin", "idagents2025"),
+            ("guest1", "guest123"),
+            ("guest2", "guest456")
+        ]
+        
+        auth_message = """
+🦠 **ID Agents Beta Testing Access**
+
+Welcome to the ID Agents beta testing environment!
+
+**Available Test Accounts:**
+• **dr_smith** / idweek2025 (ID Physician)
+• **id_fellow** / hello (ID Fellow) 
+• **pharmacist** / stewardship (Clinical Pharmacist)
+• **ipc_nurse** / infection (IPC Coordinator)
+• **researcher** / research (Clinical Researcher)
+• **educator** / education (Medical Educator)
+• **student** / learning (Medical Student - Limited Access)
+• **admin** / idagents2025 (Administrator)
+• **guest1** / guest123 (Guest Access - Limited)
+• **guest2** / guest456 (Guest Access - Limited)
+
+Please use your assigned credentials to access the application.
+Built with ❤️ for ID Week 2025 — Empowering Infectious Diseases Innovation
+        """
+        
+        # Check if running on Hugging Face Spaces
+        try:
+            import os
+            if os.getenv("SPACE_ID"):
+                # Running on HF Spaces
+                launch_config = {
+                    "auth": auth_credentials,
+                    "auth_message": auth_message,
+                    "show_error": True
+                }
+                print("🔐 Authentication enabled for HF Spaces deployment")
+            else:
+                # Local development
+                launch_config = {
+                    "auth": auth_credentials,
+                    "auth_message": auth_message,
+                    "share": False,
+                    "server_name": "127.0.0.1",
+                    "server_port": 7860,
+                    "show_error": True
+                }
+                print("🔐 Authentication enabled for local testing")
+        except Exception:
+            # Fallback configuration with authentication
+            launch_config = {
+                "auth": auth_credentials,
+                "auth_message": auth_message,
+                "share": False,
+                "server_name": "127.0.0.1", 
+                "server_port": 7860,
+                "show_error": True
+            }
+            print("🔐 Authentication enabled with fallback configuration")
+        
+        print("📋 Available beta test accounts:")
+        for username, password in auth_credentials:
+            print(f"   • {username} / {password}")
+        
+        app.launch(**launch_config)
+        
+    except Exception as e:
+        print(f"❌ Failed to launch ID Agents: {e}")
+        print("💡 Check your API keys and environment configuration")
+        import traceback
+        traceback.print_exc()

app_minimal_test.py

@@ -0,0 +1,49 @@
+"""
+Minimal test app to verify Gradio + authentication works on HF Spaces
+"""
+
+import gradio as gr
+
+def test_chat(message, history):
+    """Simple test chat function"""
+    response = f"Echo: {message} (This is a minimal test version)"
+    history.append([message, response])
+    return "", history
+
+# Create minimal interface
+with gr.Blocks(title="ID Agents - Minimal Test") as app:
+    gr.Markdown("# 🦠 ID Agents - Minimal Test Version")
+    gr.Markdown("Testing authentication and basic functionality")
+    
+    chatbot = gr.Chatbot(value=[], height=300)
+    msg = gr.Textbox(placeholder="Type a test message...")
+    submit = gr.Button("Send")
+    
+    submit.click(fn=test_chat, inputs=[msg, chatbot], outputs=[msg, chatbot])
+    msg.submit(fn=test_chat, inputs=[msg, chatbot], outputs=[msg, chatbot])
+
+if __name__ == "__main__":
+    # Authentication credentials
+    auth_credentials = [
+        ("dr_smith", "idweek2025"),
+        ("admin", "idagents2025"),
+        ("test", "test123")
+    ]
+    
+    auth_message = """
+🦠 **ID Agents - Minimal Test**
+
+This is a minimal test version to verify authentication works.
+
+**Test Accounts:**
+• dr_smith / idweek2025
+• admin / idagents2025  
+• test / test123
+"""
+    
+    print("🚀 Launching minimal test app...")
+    app.launch(
+        auth=auth_credentials,
+        auth_message=auth_message,
+        show_error=True
+    )

app_optimized.py

@@ -0,0 +1,411 @@
+"""
+app_optimized.py - Memory-Optimized ID Agents
+----------------------------------------------
+
+Streamlined version of the complex multi-agent system optimized for HF Spaces memory limits.
+Includes core agent builder functionality while reducing memory footprint.
+"""
+
+# --- Core Imports ---
+import gradio as gr
+import json
+import re
+import os
+import asyncio
+import logging
+from typing import Dict, cast
+
+# Essential imports with graceful fallbacks
+try:
+    import openai
+    from openai import RateLimitError, APIError, APIConnectionError, OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+
+try:
+    from core.agents.agent_utils import linkify_citations, build_agent, load_prefilled, prepare_download
+    from config import agents_config, skills_library, prefilled_agents
+    from core.agents.chat_orchestrator import simulate_agent_response_stream
+    CORE_MODULES_AVAILABLE = True
+except ImportError:
+    CORE_MODULES_AVAILABLE = False
+    # Fallback configurations
+    agents_config = {}
+    skills_library = {
+        "🛡️ Antimicrobial Stewardship": ["recommend_deescalation", "alert_prolonged_antibiotic_use"],
+        "🦠 Infection Prevention and Control": ["calculate_infection_rate", "assess_outbreak_risk"],
+        "🔬 Research Assistant": ["search_pubmed", "summarize_guidelines"],
+        "🏥 Clinical Assistant": ["differential_diagnosis", "treatment_recommendations"],
+        "📚 Education Assistant": ["create_quiz", "explain_concepts"],
+        "🎼 Orchestrator": ["coordinate_agents", "synthesize_responses"]
+    }
+    prefilled_agents = {
+        "Stewardship Expert": {
+            "agent_type": "🛡️ Antimicrobial Stewardship",
+            "agent_name": "StewardshipBot",
+            "agent_mission": "Optimize antibiotic use and prevent resistance",
+            "skills": ["recommend_deescalation", "alert_prolonged_antibiotic_use"]
+        }
+    }
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# OpenAI setup
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+if OPENAI_API_KEY and OPENAI_AVAILABLE:
+    client = OpenAI(api_key=OPENAI_API_KEY)
+else:
+    client = None
+
+def simple_chat_response(user_message, history):
+    """Simple chat response for fallback mode"""
+    if not client:
+        return history + [[user_message, "⚠️ OpenAI not configured. Please check API keys."]], ""
+    
+    # Convert to OpenAI format
+    messages = []
+    for user_msg, assistant_msg in history:
+        if user_msg:
+            messages.append({"role": "user", "content": user_msg})
+        if assistant_msg:
+            messages.append({"role": "assistant", "content": assistant_msg})
+    
+    messages.append({"role": "user", "content": user_message})
+    
+    try:
+        completion = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=messages,
+            temperature=0.7,
+        )
+        reply = completion.choices[0].message.content.strip()
+        return history + [[user_message, reply]], ""
+    except Exception as e:
+        error_msg = f"Error: {str(e)}"
+        return history + [[user_message, error_msg]], ""
+
+def convert_messages_to_gradio(messages):
+    """Convert OpenAI messages to Gradio format"""
+    if not messages:
+        return []
+    
+    result = []
+    for i, msg in enumerate(messages):
+        if msg["role"] == "user":
+            # Look ahead for assistant response
+            assistant_response = ""
+            if i + 1 < len(messages) and messages[i + 1]["role"] == "assistant":
+                assistant_response = messages[i + 1]["content"]
+            result.append([msg["content"], assistant_response])
+        elif msg["role"] == "assistant" and (i == 0 or messages[i-1]["role"] != "user"):
+            # Standalone assistant message (like greeting)
+            result.append([None, msg["content"]])
+    
+    return result
+
+def safe_agent_chat(agent_name, user_text, histories):
+    """Safe agent chat with fallback"""
+    if not CORE_MODULES_AVAILABLE:
+        response = f"🔧 **Demo Mode**: Agent '{agent_name}' would normally provide specialized infectious disease assistance here."
+        history = histories.get(agent_name, [])
+        new_history = history + [[user_text, response]]
+        histories[agent_name] = new_history
+        return new_history, histories, ""
+    
+    try:
+        # Use existing chat logic if available
+        from app import chatpanel_handle
+        return chatpanel_handle(agent_name, user_text, histories)
+    except:
+        # Fallback to simple response
+        response = f"🤖 Agent '{agent_name}' received: {user_text}\n\nThis is a simplified response due to system limitations."
+        history = histories.get(agent_name, [])
+        new_history = history + [[user_text, response]]
+        histories[agent_name] = new_history
+        return new_history, histories, ""
+
+def build_optimized_ui():
+    """Build memory-optimized UI"""
+    
+    # Streamlined CSS - reduced from original
+    css = """
+    :root {
+      --id-primary: #1e40af;
+      --id-secondary: #3b82f6;
+      --id-accent: #06d6a0;
+      --id-bg: #f8fafc;
+      --id-surface: #ffffff;
+      --id-text: #1e293b;
+    }
+    
+    .gradio-container { background: var(--id-bg) !important; }
+    
+    .id-header {
+      background: linear-gradient(90deg, var(--id-primary), var(--id-secondary));
+      color: white;
+      padding: 1.5rem;
+      border-radius: 12px;
+      margin-bottom: 1.5rem;
+    }
+    
+    .generate-btn {
+      background: linear-gradient(90deg, var(--id-secondary), var(--id-accent));
+      color: white !important;
+      border: none !important;
+      font-weight: 600;
+    }
+    """
+    
+    with gr.Blocks(title="🦠 ID Agents - Optimized", css=css, theme=gr.themes.Soft()) as app:
+        
+        # State management
+        builder_chat_histories = gr.State({})
+        
+        # Header
+        gr.HTML("""
+        <div class="id-header">
+            <h1 style="margin: 0;">🦠 ID Agents - Multi-Agent Builder</h1>
+            <p style="margin: 8px 0 0 0;">Optimized for HF Spaces - Build specialized infectious disease agents</p>
+        </div>
+        """)
+        
+        with gr.Tabs():
+            # Tab 1: Simple Chat
+            with gr.TabItem("💬 Simple Chat"):
+                gr.Markdown("### Quick GPT-3.5 Chat")
+                simple_chatbot = gr.Chatbot()
+                simple_input = gr.Textbox(placeholder="Ask anything...", show_label=False)
+                simple_send = gr.Button("Send")
+                simple_reset = gr.Button("Reset")
+                
+                # Wire up simple chat
+                simple_send.click(
+                    fn=simple_chat_response,
+                    inputs=[simple_input, simple_chatbot],
+                    outputs=[simple_chatbot, simple_input]
+                )
+                simple_input.submit(
+                    fn=simple_chat_response,
+                    inputs=[simple_input, simple_chatbot],
+                    outputs=[simple_chatbot, simple_input]
+                )
+                simple_reset.click(lambda: ([], ""), outputs=[simple_chatbot, simple_input])
+            
+            # Tab 2: Agent Builder (Streamlined)
+            with gr.TabItem("🛠️ Agent Builder"):
+                gr.Markdown("### Build Your ID Agent")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        # Simplified form
+                        prefilled = gr.Dropdown(
+                            choices=["None"] + list(prefilled_agents.keys()), 
+                            label="Template", 
+                            value="None"
+                        )
+                        agent_type = gr.Radio(
+                            choices=list(skills_library.keys()),
+                            label="Agent Type"
+                        )
+                        agent_name = gr.Textbox(label="Agent Name", placeholder="e.g., StewardBot")
+                        agent_mission = gr.Textbox(label="Mission", lines=3)
+                        skills = gr.CheckboxGroup(choices=[], label="Skills")
+                        generate_button = gr.Button("✨ Generate Agent", elem_classes="generate-btn")
+                        
+                        # Generated config
+                        agent_output = gr.Code(label="Agent Config", language="json")
+                    
+                    with gr.Column(scale=2):
+                        # Agent management
+                        gr.Markdown("### Active Agents")
+                        active_agents = gr.Markdown("_(None yet)_")
+                        
+                        agent_dropdown = gr.Dropdown(label="Select Agent", choices=[])
+                        
+                        with gr.Row():
+                            chat_button = gr.Button("💬 Chat")
+                            remove_button = gr.Button("❌ Remove")
+                        
+                        # Chat interface
+                        agent_chatbot = gr.Chatbot(label="Agent Chat")
+                        chat_input = gr.Textbox(placeholder="Chat with your agent...", show_label=False)
+                        chat_send = gr.Button("Send")
+                        reset_chat = gr.Button("🔄 Reset")
+                
+                # Update skills when agent type changes
+                def update_skills(agent_type):
+                    if agent_type:
+                        return gr.update(choices=skills_library.get(agent_type, []))
+                    return gr.update(choices=[])
+                
+                agent_type.change(update_skills, inputs=[agent_type], outputs=[skills])
+                
+                # Generate agent
+                def generate_agent(prefilled_choice, agent_type, agent_name, agent_mission, skills):
+                    if not agent_name.strip():
+                        return "❌ Please provide an agent name", "", "### Active Agents\n_(None yet)_", gr.update()
+                    
+                    agent_data = {
+                        "agent_type": agent_type,
+                        "agent_name": agent_name,
+                        "agent_mission": agent_mission,
+                        "skills": skills,
+                        "web_access": True,
+                        "allow_fallback": True
+                    }
+                    
+                    agents_config[agent_name] = json.dumps(agent_data)
+                    
+                    # Update UI
+                    config_json = json.dumps(agent_data, indent=2)
+                    active_list = "### Active Agents\n" + "\n".join(f"- {name}" for name in agents_config.keys())
+                    choices = list(agents_config.keys())
+                    
+                    return config_json, agent_data, active_list, gr.update(choices=choices)
+                
+                generate_button.click(
+                    generate_agent,
+                    inputs=[prefilled, agent_type, agent_name, agent_mission, skills],
+                    outputs=[agent_output, gr.State(), active_agents, agent_dropdown]
+                )
+                
+                # Chat with agent
+                def start_agent_chat(agent_name):
+                    if agent_name:
+                        greeting = f"👋 Hello! I'm {agent_name}. How can I assist you with infectious diseases?"
+                        return [[None, greeting]], ""
+                    return [], ""
+                
+                chat_button.click(
+                    start_agent_chat,
+                    inputs=[agent_dropdown],
+                    outputs=[agent_chatbot, chat_input]
+                )
+                
+                # Send message to agent
+                def send_to_agent(agent_name, message, history, histories):
+                    if not agent_name or not message.strip():
+                        return history, "", histories
+                    
+                    return safe_agent_chat(agent_name, message, histories)
+                
+                chat_send.click(
+                    send_to_agent,
+                    inputs=[agent_dropdown, chat_input, agent_chatbot, builder_chat_histories],
+                    outputs=[agent_chatbot, chat_input, builder_chat_histories]
+                )
+                
+                chat_input.submit(
+                    send_to_agent,
+                    inputs=[agent_dropdown, chat_input, agent_chatbot, builder_chat_histories],
+                    outputs=[agent_chatbot, chat_input, builder_chat_histories]
+                )
+                
+                # Reset chat
+                reset_chat.click(lambda: ([], ""), outputs=[agent_chatbot, chat_input])
+                
+                # Remove agent
+                def remove_agent(agent_name):
+                    if agent_name in agents_config:
+                        del agents_config[agent_name]
+                    
+                    active_list = "### Active Agents\n" + "\n".join(f"- {name}" for name in agents_config.keys()) if agents_config else "### Active Agents\n_(None yet)_"
+                    choices = list(agents_config.keys())
+                    
+                    return active_list, gr.update(choices=choices, value=None)
+                
+                remove_button.click(
+                    remove_agent,
+                    inputs=[agent_dropdown],
+                    outputs=[active_agents, agent_dropdown]
+                )
+        
+        # Status info
+        status_md = "✅ **Optimized Mode**: Core functionality available"
+        if CORE_MODULES_AVAILABLE:
+            status_md += "\n✅ **Full modules loaded**"
+        else:
+            status_md += "\n⚠️ **Demo mode**: Limited functionality"
+        
+        gr.Markdown(f"### System Status\n{status_md}")
+        
+    return app
+
+# --- Main Application Entry Point ---
+if __name__ == "__main__":
+    try:
+        print("🚀 Launching Optimized ID Agents...")
+        
+        # Authentication credentials
+        auth_credentials = [
+            ("dr_smith", "idweek2025"),
+            ("id_fellow", "hello"), 
+            ("pharmacist", "stewardship"),
+            ("ipc_nurse", "infection"),
+            ("researcher", "research"),
+            ("educator", "education"),
+            ("student", "learning"),
+            ("admin", "idagents2025"),
+            ("guest1", "guest123"),
+            ("guest2", "guest456")
+        ]
+        
+        auth_message = """
+🦠 **ID Agents Beta Testing - Optimized Version**
+
+Welcome to the memory-optimized ID Agents environment!
+
+**Available Test Accounts:**
+• **dr_smith** / idweek2025 (ID Physician)
+• **id_fellow** / hello (ID Fellow) 
+• **pharmacist** / stewardship (Clinical Pharmacist)
+• **ipc_nurse** / infection (IPC Coordinator)
+• **researcher** / research (Clinical Researcher)
+• **educator** / education (Medical Educator)
+• **student** / learning (Medical Student)
+• **admin** / idagents2025 (Administrator)
+• **guest1** / guest123 (Guest Access)
+• **guest2** / guest456 (Guest Access)
+
+This optimized version provides core agent building functionality 
+while staying within HF Spaces memory limits.
+        """
+        
+        # Configure launch
+        try:
+            from hf_config import configure_hf_environment, get_hf_launch_config
+            if configure_hf_environment():
+                launch_config = get_hf_launch_config()
+                launch_config["auth"] = auth_credentials
+                launch_config["auth_message"] = auth_message
+                print("🔐 HF Spaces optimized deployment")
+            else:
+                launch_config = {
+                    "auth": auth_credentials,
+                    "auth_message": auth_message,
+                    "share": False,
+                    "server_name": "127.0.0.1",
+                    "server_port": 7860
+                }
+                print("🔐 Local optimized deployment")
+        except ImportError:
+            launch_config = {
+                "auth": auth_credentials,
+                "auth_message": auth_message,
+                "share": False,
+                "server_name": "127.0.0.1", 
+                "server_port": 7860
+            }
+            print("🔐 Fallback optimized deployment")
+        
+        # Launch optimized app
+        build_optimized_ui().launch(**launch_config)
+        
+    except Exception as e:
+        logger.error(f"Failed to launch optimized ID Agents: {e}")
+        print(f"❌ Launch failed: {e}")
+        import traceback
+        traceback.print_exc()

app_ultra_minimal.py

@@ -0,0 +1,21 @@
+import gradio as gr
+
+def simple_chat(message, history):
+    response = f"Echo: {message}"
+    history.append([message, response])
+    return "", history
+
+with gr.Blocks(title="ID Agents Test") as app:
+    gr.Markdown("# 🦠 ID Agents - Simple Test")
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox(placeholder="Test message...")
+    submit = gr.Button("Send")
+    
+    submit.click(simple_chat, [msg, chatbot], [msg, chatbot])
+    msg.submit(simple_chat, [msg, chatbot], [msg, chatbot])
+
+if __name__ == "__main__":
+    app.launch(
+        auth=[("test", "test123"), ("admin", "admin123")],
+        auth_message="Test accounts: test/test123 or admin/admin123"
+    )

test_minimal.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Minimal test to identify what's causing initialization failure
+"""
+
+print("Starting minimal test...")
+
+try:
+    import gradio as gr
+    print("✅ Gradio imported successfully")
+except Exception as e:
+    print(f"❌ Gradio import failed: {e}")
+    exit(1)
+
+try:
+    import os
+    print("✅ Environment variables check...")
+    openai_key = os.environ.get("OPENAI_API_KEY")
+    if openai_key:
+        print("✅ OPENAI_API_KEY found")
+    else:
+        print("❌ OPENAI_API_KEY not found")
+except Exception as e:
+    print(f"❌ Environment check failed: {e}")
+
+try:
+    import openai
+    print("✅ OpenAI imported successfully")
+except Exception as e:
+    print(f"❌ OpenAI import failed: {e}")
+
+def minimal_app():
+    print("Creating minimal Gradio app...")
+    
+    def simple_chat(message, history):
+        return history + [["User: " + message, "Bot: Hello! This is a test response."]]
+    
+    with gr.Blocks(title="Minimal Test") as app:
+        gr.Markdown("# Minimal Test App")
+        chatbot = gr.Chatbot()
+        msg = gr.Textbox(placeholder="Type a message...")
+        msg.submit(simple_chat, [msg, chatbot], chatbot)
+        
+    return app
+
+if __name__ == "__main__":
+    try:
+        print("Building app...")
+        app = minimal_app()
+        print("✅ App built successfully")
+        
+        print("Launching app...")
+        app.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            show_error=True,
+            quiet=False
+        )
+        print("✅ App launched successfully")
+        
+    except Exception as e:
+        print(f"❌ App launch failed: {e}")
+        import traceback
+        traceback.print_exc()