Enhanced UI: Added collapsible sidebar toggle, increased chat area size, fixed streaming bugs

config.py

@@ -2,6 +2,7 @@ import logging
 from pathlib import Path
 from enum import Enum
 from logging.handlers import RotatingFileHandler
+from typing import ClassVar
 
 def setup_logging():
     """Setup advanced logging with rotation"""
@@ -40,29 +41,29 @@ logger = setup_logging()
 
 class AppConfig:
     """Centralized application configuration"""
-    MAX_HISTORY_LENGTH: int = 10
-    MAX_CONVERSATION_STORAGE: int = 1000
-    DEFAULT_TEMPERATURE: float = 0.7
-    MIN_TEMPERATURE: float = 0.0
-    MAX_TEMPERATURE: float = 2.0
-    DEFAULT_MAX_TOKENS: int = 4000
-    MIN_TOKENS: int = 100
-    MAX_TOKENS: int = 32000
-    REQUEST_TIMEOUT: int = 60
-    MAX_RETRIES: int = 3
-    RETRY_DELAY: float = 1.0
-    CACHE_SIZE: int = 100
-    CACHE_TTL: int = 3600
-    RATE_LIMIT_REQUESTS: int = 50
-    RATE_LIMIT_WINDOW: int = 60
-    EXPORT_DIR: Path = Path("exports")
-    BACKUP_DIR: Path = Path("backups")
-    MAX_EXPORT_SIZE_MB: int = 50
-    THEME_PRIMARY: str = "purple"
-    THEME_SECONDARY: str = "blue"
-    AUTO_SAVE_INTERVAL: int = 300
-    ENABLE_ANALYTICS: bool = True
-    ANALYTICS_BATCH_SIZE: int = 10
+    MAX_HISTORY_LENGTH: ClassVar[int] = 10
+    MAX_CONVERSATION_STORAGE: ClassVar[int] = 1000
+    DEFAULT_TEMPERATURE: ClassVar[float] = 0.7
+    MIN_TEMPERATURE: ClassVar[float] = 0.0
+    MAX_TEMPERATURE: ClassVar[float] = 2.0
+    DEFAULT_MAX_TOKENS: ClassVar[int] = 4000
+    MIN_TOKENS: ClassVar[int] = 100
+    MAX_TOKENS: ClassVar[int] = 32000
+    REQUEST_TIMEOUT: ClassVar[int] = 60
+    MAX_RETRIES: ClassVar[int] = 3
+    RETRY_DELAY: ClassVar[float] = 1.0
+    CACHE_SIZE: ClassVar[int] = 100
+    CACHE_TTL: ClassVar[int] = 3600
+    RATE_LIMIT_REQUESTS: ClassVar[int] = 50
+    RATE_LIMIT_WINDOW: ClassVar[int] = 60
+    EXPORT_DIR: ClassVar[Path] = Path("exports")
+    BACKUP_DIR: ClassVar[Path] = Path("backups")
+    MAX_EXPORT_SIZE_MB: ClassVar[int] = 50
+    THEME_PRIMARY: ClassVar[str] = "purple"
+    THEME_SECONDARY: ClassVar[str] = "blue"
+    AUTO_SAVE_INTERVAL: ClassVar[int] = 300
+    ENABLE_ANALYTICS: ClassVar[bool] = True
+    ANALYTICS_BATCH_SIZE: ClassVar[int] = 10
     
     @classmethod
     def validate(cls) -> bool:
@@ -70,6 +71,7 @@ class AppConfig:
             assert cls.MIN_TEMPERATURE <= cls.DEFAULT_TEMPERATURE <= cls.MAX_TEMPERATURE
             assert cls.MIN_TOKENS <= cls.DEFAULT_MAX_TOKENS <= cls.MAX_TOKENS
             assert cls.MAX_HISTORY_LENGTH > 0
+            logger.info("Configuration validation passed")
             return True
         except AssertionError as e:
             logger.error(f"Configuration validation failed: {e}")
@@ -77,9 +79,12 @@ class AppConfig:
     
     @classmethod
     def create_directories(cls) -> None:
-        cls.EXPORT_DIR.mkdir(exist_ok=True)
-        cls.BACKUP_DIR.mkdir(exist_ok=True)
-        logger.info("Application directories initialized")
+        try:
+            cls.EXPORT_DIR.mkdir(exist_ok=True, parents=True)
+            cls.BACKUP_DIR.mkdir(exist_ok=True, parents=True)
+            logger.info("Application directories initialized")
+        except Exception as e:
+            logger.error(f"Failed to create directories: {e}")
 
 AppConfig.create_directories()
 AppConfig.validate()
@@ -185,10 +190,13 @@ CUSTOM_CSS = """
     margin: 1rem 0;
     font-family: 'JetBrains Mono', monospace;
     transition: var(--transition);
-    color: #2c3e50 !important;
     box-shadow: 0 2px 8px rgba(0,0,0,0.08);
 }
 
+.metrics-card * {
+    color: #2c3e50 !important;
+}
+
 .metrics-card strong {
     color: #1a1a1a !important;
     font-weight: 600;
@@ -208,19 +216,20 @@ CUSTOM_CSS = """
     box-shadow: var(--shadow-lg);
 }
 
-.analytics-panel h3 {
+.analytics-panel * {
     color: white !important;
+}
+
+.analytics-panel h3 {
     margin-bottom: 1rem;
     font-size: 1.5rem;
 }
 
 .analytics-panel p {
-    color: rgba(255,255,255,0.95) !important;
     line-height: 1.6;
 }
 
 .analytics-panel strong {
-    color: white !important;
     font-weight: 600;
 }
 
@@ -258,14 +267,6 @@ CUSTOM_CSS = """
 .gr-button:hover { 
     transform: translateY(-2px) !important; 
 }
-
-.gr-markdown {
-    color: #2c3e50 !important;
-}
-
-.gr-markdown strong {
-    color: #1a1a1a !important;
-}
 """
 
-logger.info("Enhanced configuration initialized")
+logger.info("Enhanced configuration initialized")

core.py

@@ -13,6 +13,7 @@ from concurrent.futures import ThreadPoolExecutor
 
 from dotenv import load_dotenv
 from groq import Groq
+import groq
 
 from config import logger, AppConfig, ReasoningMode, ModelConfig
 
@@ -53,6 +54,8 @@ class ResponseCache:
         """Clear cache"""
         with self.lock:
             self.cache.clear()
+            self.hits = 0
+            self.misses = 0
             logger.info("Cache cleared")
     
     def get_stats(self) -> Dict[str, int]:
@@ -96,7 +99,7 @@ class RateLimiter:
 
 @dataclass
 class ConversationMetrics:
-    """Enhanced metrics with advanced tracking"""
+    """Enhanced metrics with thread-safe operations"""
     reasoning_depth: int = 0
     self_corrections: int = 0
     confidence_score: float = 0.0
@@ -116,27 +119,45 @@ class ConversationMetrics:
     mode_switches: int = 0
     peak_tokens: int = 0
     total_latency: float = 0.0
+    _lock: threading.Lock = field(default_factory=threading.Lock, init=False, repr=False)
     
     def update_confidence(self) -> None:
         """Calculate confidence based on multiple factors"""
-        depth_score = min(30, self.reasoning_depth * 5)
-        correction_score = min(20, self.self_corrections * 10)
-        speed_score = min(25, 25 / max(1, self.avg_response_time))
-        consistency_score = 25
-        self.confidence_score = min(95.0, depth_score + correction_score + speed_score + consistency_score)
+        with self._lock:
+            depth_score = min(30, self.reasoning_depth * 5)
+            correction_score = min(20, self.self_corrections * 10)
+            speed_score = min(25, 25 / max(1, self.avg_response_time))
+            consistency_score = 25
+            self.confidence_score = min(95.0, depth_score + correction_score + speed_score + consistency_score)
     
     def update_tokens_per_second(self, tokens: int, time_taken: float) -> None:
         """Calculate tokens per second"""
-        if time_taken > 0:
-            self.tokens_per_second = tokens / time_taken
+        with self._lock:
+            if time_taken > 0:
+                self.tokens_per_second = tokens / time_taken
+    
+    def increment_field(self, field_name: str, value: Any = 1) -> None:
+        """Thread-safe field increment"""
+        with self._lock:
+            current = getattr(self, field_name)
+            setattr(self, field_name, current + value)
+    
+    def set_field(self, field_name: str, value: Any) -> None:
+        """Thread-safe field setter"""
+        with self._lock:
+            setattr(self, field_name, value)
     
     def reset(self) -> None:
         """Reset metrics for new session"""
-        self.__init__()
+        with self._lock:
+            self.__init__()
     
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary"""
-        return asdict(self)
+        with self._lock:
+            data = asdict(self)
+            data.pop('_lock', None)
+            return data
 
 @dataclass
 class ConversationEntry:
@@ -168,7 +189,7 @@ class ConversationEntry:
     
     def _generate_id(self) -> str:
         """Generate unique conversation ID"""
-        content = f"{self.timestamp}{self.user_message}"
+        content = f"{self.timestamp}{self.user_message[:100]}"
         return hashlib.md5(content.encode()).hexdigest()[:12]
     
     def to_dict(self) -> Dict[str, Any]:
@@ -191,7 +212,7 @@ class ConversationEntry:
             self.rating = rating
 
 def error_handler(func):
-    """Enhanced error handling decorator with retries"""
+    """Enhanced error handling decorator for generator functions"""
     @wraps(func)
     def wrapper(*args, **kwargs):
         max_retries = AppConfig.MAX_RETRIES
@@ -199,27 +220,51 @@ def error_handler(func):
         
         for attempt in range(max_retries):
             try:
-                return func(*args, **kwargs)
-            except Exception as e:
-                logger.error(f"Error in {func.__name__} (attempt {attempt+1}/{max_retries}): {str(e)}")
-                
-                if attempt < max_retries - 1:
-                    logger.info(f"Retrying in {retry_delay}s...")
-                    time.sleep(retry_delay)
-                    retry_delay *= 2
+                # Check if function is a generator
+                result = func(*args, **kwargs)
+                if hasattr(result, '__iter__') and hasattr(result, '__next__'):
+                    # It's a generator, yield from it
+                    yield from result
                 else:
-                    error_msg = f"System Error: {str(e)}\n\n"
-                    
-                    if "api" in str(e).lower() or "key" in str(e).lower():
-                        error_msg += "Please verify your GROQ_API_KEY in the .env file."
-                    elif "rate" in str(e).lower() or "limit" in str(e).lower():
-                        error_msg += "Rate limit exceeded. Please wait a moment and try again."
-                    elif "timeout" in str(e).lower():
-                        error_msg += "Request timed out. Please try again."
-                    else:
-                        error_msg += "Please try again or contact support if the issue persists."
-                    
-                    return error_msg
+                    # Regular function, return result
+                    return result
+                return  # Exit after successful completion
+                
+            except groq.APIConnectionError as e:
+                error_msg = f"🔌 **Connection Error**: Cannot reach Groq API.\n\n"
+                error_msg += "Please check your internet connection and try again."
+                logger.error(f"API Connection Error in {func.__name__}: {str(e)}")
+                
+            except groq.RateLimitError as e:
+                error_msg = f"⏱️ **Rate Limit Exceeded**: Too many requests.\n\n"
+                error_msg += "Please wait a moment and try again."
+                logger.error(f"Rate Limit Error in {func.__name__}: {str(e)}")
+                
+            except groq.AuthenticationError as e:
+                error_msg = f"🔐 **Authentication Error**: Invalid API key.\n\n"
+                error_msg += "Please verify your GROQ_API_KEY in the .env file."
+                logger.error(f"Authentication Error in {func.__name__}: {str(e)}")
+                yield error_msg
+                return  # Don't retry authentication errors
+                
+            except groq.APIStatusError as e:
+                error_msg = f"⚠️ **API Error** (Status {e.status_code}):\n\n"
+                error_msg += f"{str(e)}\n\nPlease try again or select a different model."
+                logger.error(f"API Status Error in {func.__name__}: {str(e)}")
+                
+            except Exception as e:
+                error_msg = f"❌ **System Error**: {str(e)}\n\n"
+                error_msg += "Please try again or contact support if the issue persists."
+                logger.error(f"Unexpected error in {func.__name__}: {str(e)}", exc_info=True)
+            
+            if attempt < max_retries - 1:
+                logger.info(f"Retrying in {retry_delay}s... (attempt {attempt+1}/{max_retries})")
+                time.sleep(retry_delay)
+                retry_delay *= 2
+            else:
+                yield error_msg
+                return
+    
     return wrapper
 
 @contextmanager
@@ -514,7 +559,7 @@ class ConversationExporter:
     
     @staticmethod
     def to_pdf(entries: List[ConversationEntry], filename: str) -> str:
-        """Export to PDF format"""
+        """Export to PDF format with memory optimization"""
         try:
             from reportlab.lib.pagesizes import letter
             from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
@@ -589,23 +634,25 @@ class ConversationExporter:
                 story.append(Spacer(1, 0.1*inch))
                 
                 story.append(Paragraph("<b>User:</b>", user_style))
-                user_msg = entry.user_message.replace('<', '&lt;').replace('>', '&gt;').replace('\n', '<br/>')
-                if len(user_msg) > 3000:
-                    user_msg = user_msg[:3000] + "... (truncated)"
+                # Escape and truncate for memory efficiency
+                user_msg = entry.user_message.replace('<', '&lt;').replace('>', '&gt;').replace('\n', '<br/>')[:3000]
+                if len(entry.user_message) > 3000:
+                    user_msg += "... (truncated)"
                 story.append(Paragraph(user_msg, user_style))
                 story.append(Spacer(1, 0.15*inch))
                 
                 story.append(Paragraph("<b>Assistant:</b>", ai_style))
-                ai_resp = entry.ai_response.replace('<', '&lt;').replace('>', '&gt;').replace('\n', '<br/>')
-                if len(ai_resp) > 5000:
-                    ai_resp = ai_resp[:5000] + "... (truncated)"
+                # Escape and truncate for memory efficiency
+                ai_resp = entry.ai_response.replace('<', '&lt;').replace('>', '&gt;').replace('\n', '<br/>')[:5000]
+                if len(entry.ai_response) > 5000:
+                    ai_resp += "... (truncated)"
                 story.append(Paragraph(ai_resp, ai_style))
                 
                 if i < len(entries):
                     story.append(PageBreak())
             
             doc.build(story)
-            logger.info(f"PDF exported to {filename}")
+            logger.info(f"PDF exported successfully to {filename}")
             return filename
             
         except ImportError:
@@ -613,7 +660,7 @@ class ConversationExporter:
             logger.error(error_msg)
             return ""
         except Exception as e:
-            logger.error(f"PDF export failed: {e}")
+            logger.error(f"PDF export failed: {e}", exc_info=True)
             return ""
     
     @classmethod
@@ -628,9 +675,9 @@ class ConversationExporter:
             filename = AppConfig.EXPORT_DIR / f"conversation_{timestamp}.{ext}"
             result = cls.to_pdf(entries, str(filename))
             if result:
-                return "PDF exported successfully! Check the exports folder.", str(filename)
+                return f"✅ PDF exported successfully! File: conversation_{timestamp}.pdf", str(filename)
             else:
-                return "PDF export failed. Install reportlab: pip install reportlab", ""
+                return "❌ PDF export failed. Install reportlab: pip install reportlab", ""
         
         exporters = {
             "json": lambda: cls.to_json(entries),
@@ -701,9 +748,11 @@ class AdvancedReasoner:
     
     def _generate_cache_key(self, query: str, model: str, mode: str, 
                            temp: float, template: str) -> str:
-        """Generate cache key for request"""
-        content = f"{query}|{model}|{mode}|{temp:.2f}|{template}"
-        return hashlib.sha256(content.encode()).hexdigest()
+        """Generate stable cache key for request"""
+        # Normalize inputs for consistent key generation
+        normalized_query = query.strip().lower()[:500]  # Limit length
+        content = f"{normalized_query}|{model}|{mode}|{temp:.2f}|{template}"
+        return hashlib.sha256(content.encode('utf-8')).hexdigest()
     
     def _calculate_reasoning_depth(self, response: str) -> int:
         """Calculate reasoning depth from response"""
@@ -726,18 +775,21 @@ class AdvancedReasoner:
         mode: ReasoningMode,
         template: str
     ) -> List[Dict[str, str]]:
-        """Build message list for API call"""
+        """Build message list for API call with validation"""
         messages = [
             {"role": "system", "content": self.prompt_engine.SYSTEM_PROMPTS[mode]}
         ]
         
         recent_history = history[-AppConfig.MAX_HISTORY_LENGTH:] if history else []
         for msg in recent_history:
-            clean_msg = {
-                "role": msg.get("role"),
-                "content": msg.get("content", "")
-            }
-            messages.append(clean_msg)
+            # Validate message structure
+            if isinstance(msg, dict) and "role" in msg and "content" in msg:
+                role = msg.get("role")
+                content = msg.get("content", "")
+                
+                # Only add valid user/assistant messages
+                if role in ["user", "assistant"] and content:
+                    messages.append({"role": role, "content": str(content)})
         
         enhanced_query = self.prompt_engine.build_prompt(query, mode, template)
         messages.append({"role": "user", "content": enhanced_query})
@@ -753,7 +805,7 @@ class AdvancedReasoner:
             "context": context
         }
         self.error_log.append(error_entry)
-        self.metrics.error_count += 1
+        self.metrics.increment_field("error_count")
         logger.error(f"Error logged: {error_entry}")
     
     @error_handler
@@ -769,28 +821,28 @@ class AdvancedReasoner:
         prompt_template: str = "Custom",
         use_cache: bool = True
     ) -> Generator[str, None, None]:
-        """Generate response with advanced features"""
+        """Generate response with advanced features - FIXED for streaming"""
         
         is_valid, error_msg = validate_input(query)
         if not is_valid:
-            yield f"Validation Error: {error_msg}"
+            yield f"⚠️ Validation Error: {error_msg}"
             return
         
         allowed, wait_time = self.rate_limiter.is_allowed()
         if not allowed:
-            yield f"Rate Limit: Please wait {wait_time:.1f} seconds."
+            yield f"⏱️ Rate Limit: Please wait {wait_time:.1f} seconds."
             return
         
         cache_key = self._generate_cache_key(query, model, reasoning_mode.value, temperature, prompt_template)
         if use_cache:
             cached_response = self.cache.get(cache_key)
             if cached_response:
-                self.metrics.cache_hits += 1
+                self.metrics.increment_field("cache_hits")
                 logger.info("Returning cached response")
                 yield cached_response
                 return
         
-        self.metrics.cache_misses += 1
+        self.metrics.increment_field("cache_misses")
         
         with timer(f"Response generation for {model}"):
             start_time = time.time()
@@ -808,12 +860,14 @@ class AdvancedReasoner:
                     stream=True,
                 )
                 
+                # FIXED: Only yield new content, not full_response repeatedly
                 for chunk in stream:
                     if chunk.choices[0].delta.content:
                         content = chunk.choices[0].delta.content
                         full_response += content
                         token_count += 1
-                        self.metrics.tokens_used += 1
+                        self.metrics.increment_field("tokens_used")
+                        # Yield only the accumulated response so far
                         yield full_response
             
             except Exception as e:
@@ -825,9 +879,9 @@ class AdvancedReasoner:
                 raise
             
             inference_time = time.time() - start_time
-            self.metrics.reasoning_depth = self._calculate_reasoning_depth(full_response)
+            self.metrics.set_field("reasoning_depth", self._calculate_reasoning_depth(full_response))
             self.metrics.update_tokens_per_second(token_count, inference_time)
-            self.metrics.peak_tokens = max(self.metrics.peak_tokens, token_count)
+            self.metrics.set_field("peak_tokens", max(self.metrics.peak_tokens, token_count))
             
             if enable_critique and len(full_response) > 150:
                 messages.append({"role": "assistant", "content": full_response})
@@ -837,6 +891,7 @@ class AdvancedReasoner:
                 })
                 
                 full_response += "\n\n---\n### Validation & Self-Critique\n"
+                yield full_response
                 
                 try:
                     critique_stream = self.client.chat.completions.create(
@@ -854,19 +909,19 @@ class AdvancedReasoner:
                             token_count += 1
                             yield full_response
                     
-                    self.metrics.self_corrections += 1
+                    self.metrics.increment_field("self_corrections")
                 
                 except Exception as e:
                     logger.warning(f"Critique phase failed: {e}")
             
             final_inference_time = time.time() - start_time
-            self.metrics.inference_time = final_inference_time
-            self.metrics.total_latency += final_inference_time
+            self.metrics.set_field("inference_time", final_inference_time)
+            self.metrics.increment_field("total_latency", final_inference_time)
             self.response_times.append(final_inference_time)
-            self.metrics.avg_response_time = sum(self.response_times) / len(self.response_times)
-            self.metrics.last_updated = datetime.now().strftime("%H:%M:%S")
+            self.metrics.set_field("avg_response_time", sum(self.response_times) / len(self.response_times))
+            self.metrics.set_field("last_updated", datetime.now().strftime("%H:%M:%S"))
             self.metrics.update_confidence()
-            self.metrics.total_conversations += 1
+            self.metrics.increment_field("total_conversations")
             
             self.model_usage[model] += 1
             self.mode_usage[reasoning_mode.value] += 1
@@ -894,15 +949,13 @@ class AdvancedReasoner:
             
             if len(self.conversation_history) % 10 == 0:
                 try:
-                    self.exporter.create_backup(self.conversation_history)
+                    self.executor.submit(self.exporter.create_backup, self.conversation_history.copy())
                 except Exception as e:
                     logger.warning(f"Auto-backup failed: {e}")
             
             if len(self.conversation_history) > AppConfig.MAX_CONVERSATION_STORAGE:
                 self.conversation_history = self.conversation_history[-AppConfig.MAX_CONVERSATION_STORAGE:]
                 logger.info(f"Trimmed history to {AppConfig.MAX_CONVERSATION_STORAGE} entries")
-            
-            yield full_response
     
     def export_conversation(self, format_type: str, include_metadata: bool = True) -> Tuple[str, str]:
         """Export conversation history"""
@@ -952,8 +1005,8 @@ class AdvancedReasoner:
             "total_time": total_time,
             "avg_inference_time": self.metrics.avg_response_time,
             "peak_tokens": self.metrics.peak_tokens,
-            "most_used_model": max(set(models), key=models.count),
-            "most_used_mode": max(set(modes), key=modes.count),
+            "most_used_model": max(set(models), key=models.count) if models else "N/A",
+            "most_used_mode": max(set(modes), key=modes.count) if modes else "N/A",
             "cache_hits": self.metrics.cache_hits,
             "cache_misses": self.metrics.cache_misses,
             "error_count": self.metrics.error_count
@@ -963,7 +1016,7 @@ class AdvancedReasoner:
         """Clear conversation history and reset metrics"""
         if self.conversation_history:
             try:
-                self.exporter.create_backup(self.conversation_history)
+                self.executor.submit(self.exporter.create_backup, self.conversation_history.copy())
             except Exception as e:
                 logger.warning(f"Failed to backup before clearing: {e}")
         
@@ -983,4 +1036,4 @@ class AdvancedReasoner:
             self.executor.shutdown(wait=False)
             logger.info("AdvancedReasoner cleanup completed")
         except:
-            pass
+            pass

main.py

@@ -5,6 +5,60 @@ from core import AdvancedReasoner, PromptEngine
 # Initialize system
 reasoner = AdvancedReasoner()
 
+# Enhanced CSS with sidebar toggle animation
+SIDEBAR_CSS = CUSTOM_CSS + """
+/* Sidebar toggle animations */
+.sidebar-hidden {
+    display: none !important;
+}
+
+.toggle-btn {
+    position: fixed;
+    right: 20px;
+    top: 50%;
+    transform: translateY(-50%);
+    z-index: 1000;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border: none;
+    border-radius: 50%;
+    width: 50px;
+    height: 50px;
+    cursor: pointer;
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+    transition: all 0.3s ease;
+    font-size: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.toggle-btn:hover {
+    transform: translateY(-50%) scale(1.1);
+    box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6);
+}
+
+/* Fullscreen chat mode */
+.fullscreen-chat .gradio-container {
+    max-width: 98% !important;
+}
+
+/* Smooth transitions */
+.settings-column {
+    transition: all 0.3s ease-in-out;
+}
+
+/* Mobile responsive toggle */
+@media (max-width: 768px) {
+    .toggle-btn {
+        width: 40px;
+        height: 40px;
+        font-size: 16px;
+        right: 10px;
+    }
+}
+"""
+
 def get_metrics_html() -> str:
     """Generate enhanced metrics HTML"""
     m = reasoner.metrics
@@ -34,7 +88,7 @@ def get_empty_analytics_html() -> str:
     </div>"""
 
 def create_ui() -> gr.Blocks:
-    """Create enhanced Gradio interface"""
+    """Create enhanced Gradio interface with collapsible sidebar"""
     
     with gr.Blocks(
         theme=gr.themes.Soft(
@@ -42,7 +96,7 @@ def create_ui() -> gr.Blocks:
             secondary_hue=AppConfig.THEME_SECONDARY,
             font=gr.themes.GoogleFont("Inter")
         ),
-        css=CUSTOM_CSS,
+        css=SIDEBAR_CSS,
         title="Advanced AI Reasoning System Pro"
     ) as demo:
         
@@ -55,18 +109,20 @@ def create_ui() -> gr.Blocks:
                 <span class="badge">Bai et al. 2022 - Constitutional AI</span>
                 <span class="badge">Enhanced with 6 Reasoning Modes</span>
                 <span class="badge">Performance Optimized</span>
+                <span class="badge">🎛️ Collapsible Sidebar</span>
             </div>
         </div>
         """)
         
         with gr.Tabs():
-            # Main Chat Tab
+            # Main Chat Tab with Toggle
             with gr.Tab("Reasoning Workspace"):
                 with gr.Row():
-                    with gr.Column(scale=3):
+                    # CHAT AREA - Larger with toggle support
+                    with gr.Column(scale=4):
                         chatbot = gr.Chatbot(
                             label="Reasoning Workspace",
-                            height=550,
+                            height=750,
                             show_copy_button=True,
                             type="messages",
                             avatar_images=(
@@ -86,8 +142,11 @@ def create_ui() -> gr.Blocks:
                             submit_btn = gr.Button("Process", variant="primary", scale=2)
                             clear_btn = gr.Button("Clear", scale=1)
                             pdf_btn = gr.Button("Download PDF", scale=1)
+                            # ⭐ NEW: Toggle Sidebar Button
+                            toggle_sidebar_btn = gr.Button("⚙️ Toggle Settings", scale=1, variant="secondary")
                     
-                    with gr.Column(scale=1):
+                    # COLLAPSIBLE SIDEBAR
+                    with gr.Column(scale=1, visible=True, elem_classes="settings-column") as sidebar:
                         gr.Markdown("### Configuration")
                         
                         reasoning_mode = gr.Radio(
@@ -151,6 +210,9 @@ def create_ui() -> gr.Blocks:
                             **Rate Limit:** {AppConfig.RATE_LIMIT_REQUESTS} req/{AppConfig.RATE_LIMIT_WINDOW}s  
                             **Max History:** {AppConfig.MAX_HISTORY_LENGTH} messages
                             """)
+                
+                # PDF download output
+                pdf_file_output = gr.File(label="Download Your PDF", visible=True)
             
             # Export Tab
             with gr.Tab("Export & History"):
@@ -231,12 +293,11 @@ def create_ui() -> gr.Blocks:
                 clear_cache_btn = gr.Button("Clear Cache", variant="stop")
                 cache_status = gr.Markdown("")
         
-        # Define pdf_file_output BEFORE event handlers
-        pdf_file_output = gr.File(visible=False)
+        # ==================== EVENT HANDLERS ====================
         
-        # Event handlers
         def process_message(message, history, mode, critique, model_name, temp, tokens, template, cache):
-            if not message.strip():
+            """Process message with streaming"""
+            if not message or not message.strip():
                 return history, get_metrics_html()
             
             history = history or []
@@ -247,30 +308,42 @@ def create_ui() -> gr.Blocks:
             
             history.append({"role": "assistant", "content": ""})
             
-            for response in reasoner.generate_response(
-                message, history[:-1], model_name, mode_enum, 
-                critique, temp, tokens, template, cache
-            ):
-                history[-1]["content"] = response
+            try:
+                for response in reasoner.generate_response(
+                    message, history[:-1], model_name, mode_enum, 
+                    critique, temp, tokens, template, cache
+                ):
+                    history[-1]["content"] = response
+                    yield history, get_metrics_html()
+            except Exception as e:
+                history[-1]["content"] = f"❌ **Error:** {str(e)}\n\nPlease try again."
+                logger.error(f"Error in process_message: {e}", exc_info=True)
                 yield history, get_metrics_html()
         
         def reset_chat():
+            """Reset chat"""
             reasoner.clear_history()
             return [], get_metrics_html()
         
         def export_conv(format_type, include_metadata):
+            """Export conversation"""
             content, filename = reasoner.export_conversation(format_type, include_metadata)
-            return content, filename
+            if filename:
+                return content, filename
+            else:
+                return content, None
         
         def download_chat_pdf():
-            """Download current chat as PDF"""
+            """Download PDF"""
             pdf_file = reasoner.export_current_chat_pdf()
             if pdf_file:
+                logger.info(f"PDF ready: {pdf_file}")
                 return pdf_file
             return None
         
         def search_conv(keyword):
-            if not keyword.strip():
+            """Search conversations"""
+            if not keyword or not keyword.strip():
                 return "Please enter a search keyword."
             
             results = reasoner.search_conversations(keyword)
@@ -280,7 +353,8 @@ def create_ui() -> gr.Blocks:
             output = f"### Found {len(results)} result(s) for '{keyword}'\n\n"
             for idx, entry in results[:10]:
                 output += f"**{idx + 1}.** {entry.timestamp} | {entry.model}\n"
-                output += f"**User:** {entry.user_message[:100]}...\n\n"
+                preview = entry.user_message[:100].replace('\n', ' ')
+                output += f"**User:** {preview}...\n\n"
             
             if len(results) > 10:
                 output += f"\n*Showing first 10 of {len(results)} results*"
@@ -288,6 +362,7 @@ def create_ui() -> gr.Blocks:
             return output
         
         def refresh_analytics():
+            """Refresh analytics"""
             analytics = reasoner.get_analytics()
             if not analytics:
                 return get_empty_analytics_html(), "No cache data.", "No data", "No data"
@@ -309,6 +384,7 @@ def create_ui() -> gr.Blocks:
             - Hits: {analytics['cache_hits']}
             - Misses: {analytics['cache_misses']}
             - Total: {analytics['cache_hits'] + analytics['cache_misses']}
+            - Hit Rate: {reasoner.cache.get_stats()['hit_rate']}%
             """
             
             model_dist_html = f"**Model Usage:** {analytics['most_used_model']}"
@@ -317,18 +393,33 @@ def create_ui() -> gr.Blocks:
             return analytics_html, cache_html, model_dist_html, mode_dist_html
         
         def update_history_stats():
+            """Update history"""
             count = len(reasoner.conversation_history)
             if count == 0:
                 return "No conversations yet."
             
             return f"""**Total Conversations:** {count}  
-            **Session:** {reasoner.session_id[:8]}..."""
+            **Session:** {reasoner.session_id[:8]}...  
+            **Started:** {reasoner.metrics.session_start}"""
         
         def clear_cache_action():
+            """Clear cache"""
             reasoner.cache.clear()
-            return "Cache cleared successfully!"
+            return "✅ Cache cleared successfully!"
+        
+        def toggle_sidebar(sidebar_state):
+            """⭐ NEW: Toggle sidebar visibility"""
+            new_state = not sidebar_state
+            logger.info(f"Sidebar toggled: {'Hidden' if not new_state else 'Visible'}")
+            return gr.update(visible=new_state), new_state
+        
+        # ==================== STATE MANAGEMENT ====================
+        
+        # Track sidebar visibility state
+        sidebar_visible_state = gr.State(value=True)
+        
+        # ==================== CONNECT EVENTS ====================
         
-        # Connect events
         submit_btn.click(
             process_message,
             [msg, chatbot, reasoning_mode, enable_critique, model, temperature, max_tokens, prompt_template, use_cache],
@@ -342,10 +433,15 @@ def create_ui() -> gr.Blocks:
         ).then(lambda: "", None, msg)
         
         clear_btn.click(reset_chat, None, [chatbot, metrics_display])
-        
-        # PDF Download button
         pdf_btn.click(download_chat_pdf, None, pdf_file_output)
         
+        # ⭐ NEW: Toggle Sidebar Event
+        toggle_sidebar_btn.click(
+            toggle_sidebar,
+            inputs=[sidebar_visible_state],
+            outputs=[sidebar, sidebar_visible_state]
+        )
+        
         export_btn.click(export_conv, [export_format, include_meta], [export_output, download_file])
         search_btn.click(search_conv, search_input, search_results)
         refresh_btn.click(
@@ -355,7 +451,6 @@ def create_ui() -> gr.Blocks:
         )
         clear_cache_btn.click(clear_cache_action, None, cache_status)
         
-        # Update history stats on load
         demo.load(update_history_stats, None, history_stats)
     
     return demo
@@ -363,8 +458,9 @@ def create_ui() -> gr.Blocks:
 if __name__ == "__main__":
     try:
         logger.info("="*60)
-        logger.info("Starting Advanced AI Reasoning System Pro...")
-        logger.info(f"Session ID: {reasoner.session_id}")
+        logger.info("🚀 Starting Advanced AI Reasoning System Pro...")
+        logger.info(f"📍 Session ID: {reasoner.session_id}")
+        logger.info("🎛️ Collapsible Sidebar: Enabled")
         logger.info("="*60)
         
         demo = create_ui()
@@ -376,6 +472,10 @@ if __name__ == "__main__":
             show_api=False,
             favicon_path=None
         )
+    except KeyboardInterrupt:
+        logger.info("⏹️ Application stopped by user")
     except Exception as e:
-        logger.critical(f"Failed to start application: {e}", exc_info=True)
-        raise
+        logger.critical(f"❌ Failed to start application: {e}", exc_info=True)
+        raise
+    finally:
+        logger.info("👋 Shutting down gracefully...")