Update app.py

app.py

@@ -1,5 +1,19 @@
 import streamlit as st
-import anthropic, openai, base64, cv2, glob, json, math, os, pytz, random, re, requests, textract, time, zipfile
+import anthropic
+import openai 
+import base64
+import cv2
+import glob
+import json
+import math
+import os
+import pytz
+import random
+import re
+import requests
+import textract
+import time
+import zipfile
 import plotly.graph_objects as go
 import streamlit.components.v1 as components
 from datetime import datetime
@@ -20,6 +34,9 @@ from streamlit.runtime.scriptrunner import get_script_run_ctx
 import asyncio
 import edge_tts
 from streamlit_marquee import streamlit_marquee
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+from typing import Dict, List, Optional, Tuple, Union
 
 # ─────────────────────────────────────────────────────────
 # 1. CORE CONFIGURATION & SETUP
@@ -35,6 +52,7 @@ st.set_page_config(
         'About': "🚲TalkingAIResearcher🏆"
     }
 )
+
 load_dotenv()
 
 # Available English voices for Edge TTS
@@ -50,66 +68,51 @@ EDGE_TTS_VOICES = [
     "en-CA-LiamNeural"
 ]
 
-# Session state variables
-if 'marquee_settings' not in st.session_state:
-    st.session_state['marquee_settings'] = {
+# Session state initialization with default values
+DEFAULT_SESSION_STATE = {
+    'marquee_settings': {
         "background": "#1E1E1E",
         "color": "#FFFFFF",
         "font-size": "14px",
         "animationDuration": "20s",
         "width": "100%",
         "lineHeight": "35px"
-    }
-
-if 'tts_voice' not in st.session_state:
-    st.session_state['tts_voice'] = EDGE_TTS_VOICES[0]
-
-if 'audio_format' not in st.session_state:
-    st.session_state['audio_format'] = 'mp3'
-
-if 'transcript_history' not in st.session_state:
-    st.session_state['transcript_history'] = []
-
-if 'chat_history' not in st.session_state:
-    st.session_state['chat_history'] = []
-
-if 'openai_model' not in st.session_state:
-    st.session_state['openai_model'] = "gpt-4o-2024-05-13"
-
-if 'messages' not in st.session_state:
-    st.session_state['messages'] = []
-
-if 'last_voice_input' not in st.session_state:
-    st.session_state['last_voice_input'] = ""
-
-if 'editing_file' not in st.session_state:
-    st.session_state['editing_file'] = None
-
-if 'edit_new_name' not in st.session_state:
-    st.session_state['edit_new_name'] = ""
-
-if 'edit_new_content' not in st.session_state:
-    st.session_state['edit_new_content'] = ""
-
-if 'viewing_prefix' not in st.session_state:
-    st.session_state['viewing_prefix'] = None
-
-if 'should_rerun' not in st.session_state:
-    st.session_state['should_rerun'] = False
-
-if 'old_val' not in st.session_state:
-    st.session_state['old_val'] = None
-
-if 'last_query' not in st.session_state:
-    st.session_state['last_query'] = ""
+    },
+    'tts_voice': EDGE_TTS_VOICES[0],
+    'audio_format': 'mp3',
+    'transcript_history': [],
+    'chat_history': [],
+    'openai_model': "gpt-4o-2024-05-13",
+    'messages': [],
+    'last_voice_input': "",
+    'editing_file': None,
+    'edit_new_name': "",
+    'edit_new_content': "",
+    'viewing_prefix': None,
+    'should_rerun': False,
+    'old_val': None,
+    'last_query': "",
+    'marquee_content': "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant",
+    'enable_audio': False,
+    'enable_download': False,
+    'enable_claude': True,
+    'audio_cache': {},
+    'paper_cache': {},
+    'download_link_cache': {},
+    'performance_metrics': defaultdict(list),
+    'operation_timings': defaultdict(float)
+}
 
-if 'marquee_content' not in st.session_state:
-    st.session_state['marquee_content'] = "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant"
+# Initialize session state
+for key, value in DEFAULT_SESSION_STATE.items():
+    if key not in st.session_state:
+        st.session_state[key] = value
 
-# API Keys
+# API Keys and Configuration
 openai_api_key = os.getenv('OPENAI_API_KEY', "")
 anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
-xai_key = os.getenv('xai',"")
+xai_key = os.getenv('xai', "")
+
 if 'OPENAI_API_KEY' in st.secrets:
     openai_api_key = st.secrets['OPENAI_API_KEY']
 if 'ANTHROPIC_API_KEY' in st.secrets:
@@ -120,109 +123,476 @@ openai_client = OpenAI(api_key=openai.api_key, organization=os.getenv('OPENAI_OR
 HF_KEY = os.getenv('HF_KEY')
 API_URL = os.getenv('API_URL')
 
-# Helper constants
+# File type emojis for display
 FILE_EMOJIS = {
     "md": "📝",
     "mp3": "🎵",
-    "wav": "🔊"
+    "wav": "🔊",
+    "pdf": "📄",
+    "txt": "📋",
+    "json": "📊",
+    "csv": "📈"
 }
 
 # ─────────────────────────────────────────────────────────
-# 2. HELPER FUNCTIONS
+# 2. PERFORMANCE MONITORING & TIMING
+# ────────────────────────────────────────────���────────────
+
+class PerformanceTimer:
+    """Context manager for timing operations with automatic logging."""
+    def __init__(self, operation_name: str):
+        self.operation_name = operation_name
+        self.start_time = None
+        
+    def __enter__(self):
+        self.start_time = time.time()
+        return self
+        
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not exc_type:  # Only log if no exception occurred
+            duration = time.time() - self.start_time
+            st.session_state['operation_timings'][self.operation_name] = duration
+            st.session_state['performance_metrics'][self.operation_name].append(duration)
+
+def log_performance_metrics():
+    """Display performance metrics in the sidebar."""
+    st.sidebar.markdown("### ⏱️ Performance Metrics")
+    
+    metrics = st.session_state['operation_timings']
+    if metrics:
+        total_time = sum(metrics.values())
+        st.sidebar.write(f"**Total Processing Time:** {total_time:.2f}s")
+        
+        # Create timing breakdown
+        for operation, duration in metrics.items():
+            percentage = (duration / total_time) * 100
+            st.sidebar.write(f"**{operation}:** {duration:.2f}s ({percentage:.1f}%)")
+            
+        # Show timing history chart
+        if st.session_state['performance_metrics']:
+            history_data = []
+            for op, times in st.session_state['performance_metrics'].items():
+                if times:  # Only show if we have timing data
+                    avg_time = sum(times) / len(times)
+                    history_data.append({"Operation": op, "Avg Time (s)": avg_time})
+            
+            if history_data:  # Create chart if we have data
+                st.sidebar.markdown("### 📈 Timing History")
+                chart_data = pd.DataFrame(history_data)
+                st.sidebar.bar_chart(chart_data.set_index("Operation"))
+
+# ─────────────────────────────────────────────────────────
+# 3. OPTIMIZED AUDIO GENERATION
+# ─────────────────────────────────────────────────────────
+
+def clean_for_speech(text: str) -> str:
+    """Clean up text for TTS output with enhanced cleaning."""
+    with PerformanceTimer("text_cleaning"):
+        # Remove markdown formatting
+        text = re.sub(r'#+ ', '', text)  # Remove headers
+        text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)  # Clean links
+        text = re.sub(r'[*_~`]', '', text)  # Remove emphasis markers
+        
+        # Remove code blocks
+        text = re.sub(r'```[\s\S]*?```', '', text)
+        text = re.sub(r'`[^`]*`', '', text)
+        
+        # Clean up whitespace
+        text = re.sub(r'\s+', ' ', text)
+        text = text.replace("\n", " ")
+        text = text.replace("</s>", " ")
+        
+        # Remove URLs
+        text = re.sub(r'https?://\S+', '', text)
+        text = re.sub(r'\(https?://[^\)]+\)', '', text)
+        
+        # Final cleanup
+        text = text.strip()
+        return text
+
+async def async_edge_tts_generate(
+    text: str,
+    voice: str,
+    rate: int = 0,
+    pitch: int = 0,
+    file_format: str = "mp3"
+) -> Tuple[Optional[str], float]:
+    """Asynchronous TTS generation with performance tracking and caching."""
+    with PerformanceTimer("tts_generation") as timer:
+        # Clean and validate text
+        text = clean_for_speech(text)
+        if not text.strip():
+            return None, 0
+        
+        # Check cache
+        cache_key = f"{text[:100]}_{voice}_{rate}_{pitch}_{file_format}"
+        if cache_key in st.session_state['audio_cache']:
+            return st.session_state['audio_cache'][cache_key], 0
+        
+        try:
+            # Generate audio
+            rate_str = f"{rate:+d}%"
+            pitch_str = f"{pitch:+d}Hz"
+            communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
+            
+            # Generate unique filename
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"audio_{timestamp}_{random.randint(1000, 9999)}.{file_format}"
+            
+            # Save audio file
+            await communicate.save(filename)
+            
+            # Cache result
+            st.session_state['audio_cache'][cache_key] = filename
+            return filename, time.time() - timer.start_time
+            
+        except Exception as e:
+            st.error(f"Error generating audio: {str(e)}")
+            return None, 0
+
+async def async_save_qa_with_audio(
+    question: str,
+    answer: str,
+    voice: Optional[str] = None
+) -> Tuple[str, Optional[str], float, float]:
+    """Asynchronously save Q&A to markdown and generate audio with timing."""
+    voice = voice or st.session_state['tts_voice']
+    
+    with PerformanceTimer("qa_save") as timer:
+        # Save markdown
+        md_start = time.time()
+        combined_text = f"# Question\n{question}\n\n# Answer\n{answer}"
+        md_file = create_file(question, answer, "md")
+        md_time = time.time() - md_start
+        
+        # Generate audio if enabled
+        audio_file = None
+        audio_time = 0
+        if st.session_state['enable_audio']:
+            audio_text = f"{question}\n\nAnswer: {answer}"
+            audio_file, audio_time = await async_edge_tts_generate(
+                audio_text,
+                voice=voice,
+                file_format=st.session_state['audio_format']
+            )
+        
+        return md_file, audio_file, md_time, audio_time
+
+def create_download_link_with_cache(
+    file_path: str,
+    file_type: str = "mp3"
+) -> str:
+    """Create download link with caching and error handling."""
+    with PerformanceTimer("download_link_generation"):
+        # Check cache first
+        cache_key = f"dl_{file_path}"
+        if cache_key in st.session_state['download_link_cache']:
+            return st.session_state['download_link_cache'][cache_key]
+        
+        try:
+            with open(file_path, "rb") as f:
+                b64 = base64.b64encode(f.read()).decode()
+            
+            # Generate appropriate link based on file type
+            filename = os.path.basename(file_path)
+            if file_type == "mp3":
+                link = f'<a href="data:audio/mpeg;base64,{b64}" download="{filename}">🎵 Download {filename}</a>'
+            elif file_type == "wav":
+                link = f'<a href="data:audio/wav;base64,{b64}" download="{filename}">🔊 Download {filename}</a>'
+            elif file_type == "md":
+                link = f'<a href="data:text/markdown;base64,{b64}" download="{filename}">📝 Download {filename}</a>'
+            else:
+                link = f'<a href="data:application/octet-stream;base64,{b64}" download="{filename}">⬇️ Download {filename}</a>'
+            
+            # Cache and return
+            st.session_state['download_link_cache'][cache_key] = link
+            return link
+            
+        except Exception as e:
+            st.error(f"Error creating download link: {str(e)}")
+            return ""
+
+# ─────────────────────────────────────────────────────────
+# 4. PAPER PROCESSING & DISPLAY
+# ─────────────────────────────────────────────────────────
+
+def parse_arxiv_refs(ref_text: str) -> List[Dict[str, str]]:
+    """Parse arxiv references with improved error handling."""
+    if not ref_text:
+        return []
+
+    with PerformanceTimer("parse_refs"):
+        results = []
+        current_paper = {}
+        lines = ref_text.split('\n')
+        
+        for i, line in enumerate(lines):
+            try:
+                if line.count('|') == 2:
+                    # Found a new paper line
+                    if current_paper:
+                        results.append(current_paper)
+                        if len(results) >= 20:  # Limit to 20 papers
+                            break
+                    
+                    # Parse header parts
+                    header_parts = line.strip('* ').split('|')
+                    date = header_parts[0].strip()
+                    title = header_parts[1].strip()
+                    url_match = re.search(r'(https://arxiv.org/\S+)', line)
+                    url = url_match.group(1) if url_match else f"paper_{len(results)}"
+                    
+                    current_paper = {
+                        'date': date,
+                        'title': title,
+                        'url': url,
+                        'authors': '',
+                        'summary': '',
+                        'full_audio': None,
+                        'download_base64': '',
+                    }
+                
+                elif current_paper:
+                    # Add content to current paper
+                    line = line.strip('* ')
+                    if not current_paper['authors']:
+                        current_paper['authors'] = line
+                    else:
+                        if current_paper['summary']:
+                            current_paper['summary'] += ' ' + line
+                        else:
+                            current_paper['summary'] = line
+            
+            except Exception as e:
+                st.warning(f"Error parsing line {i}: {str(e)}")
+                continue
+        
+        # Add final paper if exists
+        if current_paper:
+            results.append(current_paper)
+        
+        return results[:20]  # Ensure we don't exceed 20 papers
+
+async def create_paper_audio_files(papers: List[Dict], input_question: str):
+    """Generate audio files for papers asynchronously with progress tracking."""
+    with PerformanceTimer("paper_audio_generation"):
+        tasks = []
+        for paper in papers:
+            try:
+                # Prepare text for audio generation
+                audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
+                audio_text = clean_for_speech(audio_text)
+                
+                # Create task for audio generation
+                task = async_edge_tts_generate(
+                    audio_text,
+                    voice=st.session_state['tts_voice'],
+                    file_format=st.session_state['audio_format']
+                )
+                tasks.append((paper, task))
+            
+            except Exception as e:
+                st.warning(f"Error preparing audio for paper {paper['title']}: {str(e)}")
+                continue
+        
+        # Process all audio generation tasks concurrently
+        for paper, task in tasks:
+            try:
+                audio_file, gen_time = await task
+                if audio_file:
+                    paper['full_audio'] = audio_file
+                    if st.session_state['enable_download']:
+                        paper['download_base64'] = create_download_link_with_cache(
+                            audio_file,
+                            st.session_state['audio_format']
+                        )
+            except Exception as e:
+                st.warning(f"Error generating audio for paper {paper['title']}: {str(e)}")
+                paper['full_audio'] = None
+                paper['download_base64'] = ''
+
+def display_papers(papers: List[Dict], marquee_settings: Dict):
+    """Display paper information with enhanced visualization."""
+    with PerformanceTimer("paper_display"):
+        st.write("## 📚 Research Papers")
+        
+        # Create tabs for different views
+        tab1, tab2 = st.tabs(["📋 List View", "📊 Grid View"])
+        
+        with tab1:
+            for i, paper in enumerate(papers, start=1):
+                # Create marquee for paper title
+                marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:120]}"
+                display_marquee(marquee_text, marquee_settings, key_suffix=f"paper_{i}")
+                
+                # Paper details expander
+                with st.expander(f"{i}. 📄 {paper['title']}", expanded=True):
+                    # Create PDF link
+                    pdf_url = paper['url'].replace('/abs/', '/pdf/')
+                    
+                    # Display paper information
+                    st.markdown(f"""
+                        **Date:** {paper['date']}  
+                        **Title:** {paper['title']}  
+                        **Links:** 📄 [Abstract]({paper['url']}) | 📑 [PDF]({pdf_url})
+                    """)
+                    st.markdown(f"**Authors:** {paper['authors']}")
+                    st.markdown(f"**Summary:** {paper['summary']}")
+                    
+                    # Audio player and download if available
+                    if paper.get('full_audio'):
+                        st.write("🎧 Paper Audio Summary")
+                        st.audio(paper['full_audio'])
+                        if paper['download_base64']:
+                            st.markdown(paper['download_base64'], unsafe_allow_html=True)
+        
+        with tab2:
+            # Create a grid layout of papers
+            cols = st.columns(3)
+            for i, paper in enumerate(papers):
+                with cols[i % 3]:
+                    st.markdown(f"""
+                        ### 📄 {paper['title'][:50]}...
+                        **Date:** {paper['date']}  
+                        [Abstract]({paper['url']}) | [PDF]({paper['url'].replace('/abs/', '/pdf/')})
+                    """)
+                    if paper.get('full_audio'):
+                        st.audio(paper['full_audio'])
+
+def display_papers_in_sidebar(papers: List[Dict]):
+    """Display paper listing in sidebar with lazy loading."""
+    with PerformanceTimer("sidebar_display"):
+        st.sidebar.title("📚 Papers Overview")
+        
+        # Add filter options
+        filter_date = st.sidebar.date_input("Filter by date:", None)
+        search_term = st.sidebar.text_input("Search papers:", "")
+        
+        # Filter papers based on criteria
+        filtered_papers = papers
+        if filter_date:
+            filtered_papers = [p for p in filtered_papers 
+                             if filter_date.strftime("%Y-%m-%d") in p['date']]
+        if search_term:
+            search_lower = search_term.lower()
+            filtered_papers = [p for p in filtered_papers 
+                             if search_lower in p['title'].lower() 
+                             or search_lower in p['authors'].lower()]
+        
+        # Display filtered papers
+        for i, paper in enumerate(filtered_papers, start=1):
+            paper_key = f"paper_{paper['url']}"
+            if paper_key not in st.session_state:
+                st.session_state[paper_key] = False
+            
+            with st.sidebar.expander(f"{i}. {paper['title'][:50]}...", expanded=False):
+                # Paper metadata
+                st.markdown(f"**Date:** {paper['date']}")
+                
+                # Links
+                pdf_url = paper['url'].replace('/abs/', '/pdf/')
+                st.markdown(f"📄 [Abstract]({paper['url']}) | 📑 [PDF]({pdf_url})")
+                
+                # Preview of authors and summary
+                st.markdown(f"**Authors:** {paper['authors'][:100]}...")
+                if paper['summary']:
+                    st.markdown(f"**Summary:** {paper['summary'][:200]}...")
+                
+                # Audio controls
+                if paper['full_audio']:
+                    if st.button("🎵 Load Audio", key=f"btn_{paper_key}"):
+                        st.session_state[paper_key] = True
+                    
+                    if st.session_state[paper_key]:
+                        st.audio(paper['full_audio'])
+                        if paper['download_base64']:
+                            st.markdown(paper['download_base64'], unsafe_allow_html=True)
+
+# ─────────────────────────────────────────────────────────
+# 5. FILE MANAGEMENT & HISTORY
 # ─────────────────────────────────────────────────────────
 
-def get_central_time():
-    """Get current time in US Central timezone."""
-    central = pytz.timezone('US/Central')
-    return datetime.now(central)
-
-def format_timestamp_prefix():
-    """Generate timestamp prefix in format MM_dd_yy_hh_mm_AM/PM."""
-    ct = get_central_time()
-    return ct.strftime("%m_%d_%y_%I_%M_%p")
-
-def initialize_marquee_settings():
-    if 'marquee_settings' not in st.session_state:
-        st.session_state['marquee_settings'] = {
-            "background": "#1E1E1E",
-            "color": "#FFFFFF",
-            "font-size": "14px",
-            "animationDuration": "20s",
-            "width": "100%",
-            "lineHeight": "35px"
-        }
-
-def get_marquee_settings():
-    initialize_marquee_settings()
-    return st.session_state['marquee_settings']
-
-def update_marquee_settings_ui():
-    """Add color pickers & sliders for marquee config in sidebar."""
-    st.sidebar.markdown("### 🎯 Marquee Settings")
-    cols = st.sidebar.columns(2)
-    with cols[0]:
-        bg_color = st.color_picker("🎨 Background", 
-                                  st.session_state['marquee_settings']["background"], 
-                                  key="bg_color_picker")
-        text_color = st.color_picker("✍️ Text", 
-                                    st.session_state['marquee_settings']["color"], 
-                                    key="text_color_picker")
-    with cols[1]:
-        font_size = st.slider("📏 Size", 10, 24, 14, key="font_size_slider")
-        duration = st.slider("⏱️ Speed", 1, 20, 20, key="duration_slider")
-
-    st.session_state['marquee_settings'].update({
-        "background": bg_color,
-        "color": text_color,
-        "font-size": f"{font_size}px",
-        "animationDuration": f"{duration}s"
-    })
-
-def display_marquee(text, settings, key_suffix=""):
-    """Show marquee text with style from settings."""
-    truncated_text = text[:280] + "..." if len(text) > 280 else text
-    streamlit_marquee(
-        content=truncated_text,
-        **settings,
-        key=f"marquee_{key_suffix}"
-    )
-    st.write("")
-
-def get_high_info_terms(text: str, top_n=10) -> list:
-    """Extract top_n freq words or bigrams (excluding stopwords)."""
-    stop_words = set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with'])
+def create_file(prompt: str, response: str, file_type: str = "md") -> str:
+    """Create a file with proper naming and error handling."""
+    with PerformanceTimer("file_creation"):
+        try:
+            # Generate filename
+            filename = generate_filename(prompt.strip(), response.strip(), file_type)
+            
+            # Ensure directory exists
+            os.makedirs("generated_files", exist_ok=True)
+            filepath = os.path.join("generated_files", filename)
+            
+            # Write content
+            with open(filepath, 'w', encoding='utf-8') as f:
+                if file_type == "md":
+                    f.write(f"# Query\n{prompt}\n\n# Response\n{response}")
+                else:
+                    f.write(f"{prompt}\n\n{response}")
+            
+            return filepath
+        
+        except Exception as e:
+            st.error(f"Error creating file: {str(e)}")
+            return ""
+
+def get_high_info_terms(text: str, top_n: int = 10) -> List[str]:
+    """Extract most informative terms from text."""
+    # Common English stop words to filter out
+    stop_words = set([
+        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 
+        'for', 'of', 'with', 'by', 'from', 'up', 'about', 'into', 'over',
+        'after', 'the', 'this', 'that', 'these', 'those', 'what', 'which'
+    ])
+    
+    # Extract words and bi-grams
     words = re.findall(r'\b\w+(?:-\w+)*\b', text.lower())
     bi_grams = [' '.join(pair) for pair in zip(words, words[1:])]
+    
+    # Combine and filter terms
     combined = words + bi_grams
-    filtered = [term for term in combined if term not in stop_words and len(term.split()) <= 2]
+    filtered = [term for term in combined 
+               if term not in stop_words 
+               and len(term.split()) <= 2 
+               and len(term) > 3]
+    
+    # Count and return top terms
     counter = Counter(filtered)
     return [term for term, freq in counter.most_common(top_n)]
 
 def clean_text_for_filename(text: str) -> str:
-    """Remove special chars, short words, etc. for filenames."""
+    """Clean text for use in filenames."""
+    # Remove special characters
     text = text.lower()
     text = re.sub(r'[^\w\s-]', '', text)
+    
+    # Remove common unhelpful words
+    stop_words = set([
+        'the', 'and', 'for', 'with', 'this', 'that', 'what', 'which',
+        'where', 'when', 'why', 'how', 'who', 'whom', 'whose', 'ai',
+        'library', 'function', 'method', 'class', 'object', 'variable'
+    ])
+    
     words = text.split()
-    # remove short or unhelpful words
-    stop_short = set(['the', 'and', 'for', 'with', 'this', 'that', 'ai', 'library'])
-    filtered = [w for w in words if len(w) > 3 and w not in stop_short]
+    filtered = [w for w in words if len(w) > 3 and w not in stop_words]
+    
     return '_'.join(filtered)[:200]
 
-def generate_filename(prompt, response, file_type="md", max_length=200):
-    """
-    Generate a shortened filename by:
-      1) extracting high-info terms,
-      2) snippet from prompt+response,
-      3) remove duplicates,
-      4) truncate if needed.
-    """
+def generate_filename(prompt: str, response: str, file_type: str = "md", 
+                     max_length: int = 200) -> str:
+    """Generate descriptive filename from content."""
+    # Get timestamp prefix
     prefix = format_timestamp_prefix() + "_"
-    combined_text = (prompt + " " + response)[:200]  
-    info_terms = get_high_info_terms(combined_text, top_n=5)  
+    
+    # Extract informative terms
+    combined_text = (prompt + " " + response)[:500]
+    info_terms = get_high_info_terms(combined_text, top_n=5)
+    
+    # Get content snippet
     snippet = (prompt[:40] + " " + response[:40]).strip()
     snippet_cleaned = clean_text_for_filename(snippet)
     
-    # remove duplicates
+    # Combine and deduplicate parts
     name_parts = info_terms + [snippet_cleaned]
     seen = set()
     unique_parts = []
@@ -231,6 +601,7 @@ def generate_filename(prompt, response, file_type="md", max_length=200):
             seen.add(part)
             unique_parts.append(part)
     
+    # Create final filename
     full_name = '_'.join(unique_parts).strip('_')
     leftover_chars = max_length - len(prefix) - len(file_type) - 1
     if len(full_name) > leftover_chars:
@@ -238,710 +609,414 @@ def generate_filename(prompt, response, file_type="md", max_length=200):
     
     return f"{prefix}{full_name}.{file_type}"
 
-def create_file(prompt, response, file_type="md"):
-    """Create a text file from prompt + response with sanitized filename."""
-    filename = generate_filename(prompt.strip(), response.strip(), file_type)
-    with open(filename, 'w', encoding='utf-8') as f:
-        f.write(prompt + "\n\n" + response)
-    return filename
-
-def get_download_link(file, file_type="zip"):
-    """
-    Convert a file to base64 and return an HTML link for download.
-    """
-    with open(file, "rb") as f:
-        b64 = base64.b64encode(f.read()).decode()
-    if file_type == "zip":
-        return f'<a href="data:application/zip;base64,{b64}" download="{os.path.basename(file)}">📂 Download {os.path.basename(file)}</a>'
-    elif file_type == "mp3":
-        return f'<a href="data:audio/mpeg;base64,{b64}" download="{os.path.basename(file)}">🎵 Download {os.path.basename(file)}</a>'
-    elif file_type == "wav":
-        return f'<a href="data:audio/wav;base64,{b64}" download="{os.path.basename(file)}">🔊 Download {os.path.basename(file)}</a>'
-    elif file_type == "md":
-        return f'<a href="data:text/markdown;base64,{b64}" download="{os.path.basename(file)}">📝 Download {os.path.basename(file)}</a>'
-    else:
-        return f'<a href="data:application/octet-stream;base64,{b64}" download="{os.path.basename(file)}">Download {os.path.basename(file)}</a>'
-
-def clean_for_speech(text: str) -> str:
-    """Clean up text for TTS output."""
-    text = text.replace("\n", " ")
-    text = text.replace("</s>", " ")
-    text = text.replace("#", "")
-    text = re.sub(r"\(https?:\/\/[^\)]+\)", "", text)
-    text = re.sub(r"\s+", " ", text).strip()
-    return text
-
-async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
-    """Async TTS generation with edge-tts library."""
-    text = clean_for_speech(text)
-    if not text.strip():
-        return None
-    rate_str = f"{rate:+d}%"
-    pitch_str = f"{pitch:+d}Hz"
-    communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
-    out_fn = generate_filename(text, text, file_type=file_format)
-    await communicate.save(out_fn)
-    return out_fn
-
-def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
-    """Wrapper for the async TTS generate call."""
-    return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch, file_format))
-
-def play_and_download_audio(file_path, file_type="mp3"):
-    """Streamlit audio + a quick download link."""
-    if file_path and os.path.exists(file_path):
-        st.audio(file_path)
-        dl_link = get_download_link(file_path, file_type=file_type)
-        st.markdown(dl_link, unsafe_allow_html=True)
-
-def save_qa_with_audio(question, answer, voice=None):
-    """Save Q&A to markdown and also generate audio."""
-    if not voice:
-        voice = st.session_state['tts_voice']
-    
-    combined_text = f"# Question\n{question}\n\n# Answer\n{answer}"
-    md_file = create_file(question, answer, "md")
-    audio_text = f"{question}\n\nAnswer: {answer}"
-    audio_file = speak_with_edge_tts(
-        audio_text,
-        voice=voice,
-        file_format=st.session_state['audio_format']
-    )
-    return md_file, audio_file
-
-# ─────────────────────────────────────────────────────────
-# 3. PAPER PARSING & DISPLAY
-# ─────────────────────────────────────────────────────────
-
-def parse_arxiv_refs(ref_text: str):
-    """
-    Given a multi-line markdown with arxiv references, parse them into
-    a list of dicts: {date, title, url, authors, summary, ...}.
-    """
-    if not ref_text:
-        return []
-
-    results = []
-    current_paper = {}
-    lines = ref_text.split('\n')
-    
-    for i, line in enumerate(lines):
-        if line.count('|') == 2:
-            # Found a new paper line
-            if current_paper:
-                results.append(current_paper)
-                if len(results) >= 20:
-                    break
-            try:
-                header_parts = line.strip('* ').split('|')
-                date = header_parts[0].strip()
-                title = header_parts[1].strip()
-                url_match = re.search(r'(https://arxiv.org/\S+)', line)
-                url = url_match.group(1) if url_match else f"paper_{len(results)}"
-                
-                current_paper = {
-                    'date': date,
-                    'title': title,
-                    'url': url,
-                    'authors': '',
-                    'summary': '',
-                    'full_audio': None,
-                    'download_base64': '',
-                }
-            except Exception as e:
-                st.warning(f"Error parsing paper header: {str(e)}")
-                current_paper = {}
-                continue
+def create_zip_of_files(md_files: List[str], mp3_files: List[str], 
+                       wav_files: List[str], input_question: str) -> Optional[str]:
+    """Create zip archive of files with optimization."""
+    with PerformanceTimer("zip_creation"):
+        # Filter out readme and empty files
+        md_files = [f for f in md_files 
+                   if os.path.basename(f).lower() != 'readme.md'
+                   and os.path.getsize(f) > 0]
         
-        elif current_paper:
-            # If authors not set, fill it; otherwise, fill summary
-            if not current_paper['authors']:
-                current_paper['authors'] = line.strip('* ')
-            else:
-                if current_paper['summary']:
-                    current_paper['summary'] += ' ' + line.strip()
-                else:
-                    current_paper['summary'] = line.strip()
-    
-    if current_paper:
-        results.append(current_paper)
-    
-    return results[:20]
-
-def create_paper_links_md(papers):
-    """Creates a minimal .md content linking to each paper's arxiv URL."""
-    lines = ["# Paper Links\n"]
-    for i, p in enumerate(papers, start=1):
-        lines.append(f"{i}. **{p['title']}** — [Arxiv]({p['url']})")
-    return "\n".join(lines)
-
-def create_paper_audio_files(papers, input_question):
-    """
-    For each paper, generate TTS audio summary, store the path in `paper['full_audio']`,
-    and also store a base64 link for stable downloading.
-    """
-    for paper in papers:
-        try:
-            audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
-            audio_text = clean_for_speech(audio_text)
-            file_format = st.session_state['audio_format']
-            audio_file = speak_with_edge_tts(
-                audio_text, 
-                voice=st.session_state['tts_voice'], 
-                file_format=file_format
-            )
-            paper['full_audio'] = audio_file
-
-            if audio_file:
-                with open(audio_file, "rb") as af:
-                    b64_data = base64.b64encode(af.read()).decode()
-                download_filename = os.path.basename(audio_file)
-                mime_type = "mpeg" if file_format == "mp3" else "wav"
-                paper['download_base64'] = (
-                    f'<a href="data:audio/{mime_type};base64,{b64_data}" '
-                    f'download="{download_filename}">🎵 Download {download_filename}</a>'
-                )
-
-        except Exception as e:
-            st.warning(f"Error processing paper {paper['title']}: {str(e)}")
-            paper['full_audio'] = None
-            paper['download_base64'] = ''
-
-            
-def display_file_history_in_sidebar():
-    """
-    Shows a history of files grouped by query, with lazy loading of audio and content.
-    """
-    st.sidebar.markdown("---")
-    st.sidebar.markdown("### 📂 File History")
-
-    # Gather all files
-    md_files = glob.glob("*.md")
-    mp3_files = glob.glob("*.mp3")
-    wav_files = glob.glob("*.wav")
-    all_files = md_files + mp3_files + wav_files
-
-    if not all_files:
-        st.sidebar.write("No files found.")
-        return
-
-    # Group files by their query prefix (timestamp_query)
-    grouped_files = {}
-    for f in all_files:
-        fname = os.path.basename(f)
-        prefix = '_'.join(fname.split('_')[:6])  # Get timestamp part
-        if prefix not in grouped_files:
-            grouped_files[prefix] = {'md': [], 'audio': [], 'loaded': False}
+        all_files = md_files + mp3_files + wav_files
+        if not all_files:
+            return None
         
-        ext = os.path.splitext(fname)[1].lower()
-        if ext == '.md':
-            grouped_files[prefix]['md'].append(f)
-        elif ext in ['.mp3', '.wav']:
-            grouped_files[prefix]['audio'].append(f)
-
-    # Sort groups by timestamp (newest first)
-    sorted_groups = sorted(grouped_files.items(), key=lambda x: x[0], reverse=True)
-
-    # 🗑⬇️ Sidebar delete all and zip all download
-    col1, col4 = st.sidebar.columns(2)
-    with col1:
-        if st.button("🗑 Delete All"):
+        try:
+            # Generate zip name
+            all_content = []
             for f in all_files:
-                os.remove(f)
-            st.session_state.should_rerun = True
-    with col4:
-        if st.button("⬇️ Zip All"):
-            zip_name = create_zip_of_files(md_files, mp3_files, wav_files, 
-                                         st.session_state.get('last_query', ''))
-            if zip_name:
-                st.sidebar.markdown(get_download_link(zip_name, "zip"), 
-                                  unsafe_allow_html=True)
-
-    # Display grouped files
-    for prefix, files in sorted_groups:
-        # Get a preview of content from first MD file
-        preview = ""
-        if files['md']:
-            with open(files['md'][0], "r", encoding="utf-8") as f:
-                preview = f.read(200).replace("\n", " ")
-                if len(preview) > 200:
-                    preview += "..."
-
-        # Create unique key for this group
-        group_key = f"group_{prefix}"
-        if group_key not in st.session_state:
-            st.session_state[group_key] = False
-
-        # Display group expander
-        with st.sidebar.expander(f"📑 Query Group: {prefix}"):
-            st.write("**Preview:**")
-            st.write(preview)
+                if f.endswith('.md'):
+                    with open(f, 'r', encoding='utf-8') as file:
+                        all_content.append(file.read())
+                elif f.endswith(('.mp3', '.wav')):
+                    basename = os.path.splitext(os.path.basename(f))[0]
+                    all_content.append(basename.replace('_', ' '))
             
-            # Load full content button
-            if st.button("📖 View Full Content", key=f"btn_{prefix}"):
-                st.session_state[group_key] = True
-
-            # Only show full content and audio if button was clicked
-            if st.session_state[group_key]:
-                # Display markdown files
-                for md_file in files['md']:
-                    with open(md_file, "r", encoding="utf-8") as f:
-                        content = f.read()
-                    st.markdown("**Full Content:**")
-                    st.markdown(content)
-                    st.markdown(get_download_link(md_file, file_type="md"), 
-                              unsafe_allow_html=True)
-
-                # Display audio files
-                usePlaySidebar=False
-                if usePlaySidebar:
-                    for audio_file in files['audio']:
-                        ext = os.path.splitext(audio_file)[1].replace('.', '')
-                        st.audio(audio_file)
-                        st.markdown(get_download_link(audio_file, file_type=ext), 
-                                  unsafe_allow_html=True)
-
-def display_papers(papers, marquee_settings):
-    """Display paper info with both abs and PDF links."""
-    st.write("## Research Papers")
-    for i, paper in enumerate(papers, start=1):
-        marquee_text = f"📄 {paper['title']} | 👤 {paper['authors'][:120]}"
-        display_marquee(marquee_text, marquee_settings, key_suffix=f"paper_{i}")
-        
-        with st.expander(f"{i}. 📄 {paper['title']}", expanded=True):
-            # Create PDF link by replacing 'abs' with 'pdf' in arxiv URL
-            pdf_url = paper['url'].replace('/abs/', '/pdf/')
-            st.markdown(f"""
-                **{paper['date']} | {paper['title']}**  
-                📄 [Abstract]({paper['url']}) | 📑 [PDF]({pdf_url})
-            """)
-            st.markdown(f"*Authors:* {paper['authors']}")
-            st.markdown(paper['summary'])
-            if paper.get('full_audio'):
-                st.write("📚 Paper Audio")
-                st.audio(paper['full_audio'])
-                if paper['download_base64']:
-                    st.markdown(paper['download_base64'], unsafe_allow_html=True)
-
-def display_papers_in_sidebar(papers):
-    """Mirrors the paper listing in sidebar with lazy loading."""
-    st.sidebar.title("🎶 Papers & Audio")
-    for i, paper in enumerate(papers, start=1):
-        paper_key = f"paper_{paper['url']}"
-        if paper_key not in st.session_state:
-            st.session_state[paper_key] = False
-
-        with st.sidebar.expander(f"{i}. {paper['title']}"):
-            # Create PDF link
-            pdf_url = paper['url'].replace('/abs/', '/pdf/')
-            st.markdown(f"📄 [Abstract]({paper['url']}) | 📑 [PDF]({pdf_url})")
+            all_content.append(input_question)
+            combined_content = " ".join(all_content)
+            info_terms = get_high_info_terms(combined_content, top_n=10)
             
-            # Preview of authors and summary
-            st.markdown(f"**Authors:** {paper['authors'][:100]}...")
-            if paper['summary']:
-                st.markdown(f"**Summary:** {paper['summary'][:200]}...")
+            timestamp = format_timestamp_prefix()
+            name_text = '-'.join(term for term in info_terms[:5])
+            zip_name = f"archive_{timestamp}_{name_text[:50]}.zip"
             
-            # Load audio button
-            if paper['full_audio'] and st.button("🎵 Load Audio", 
-                                               key=f"btn_{paper_key}"):
-                st.session_state[paper_key] = True
+            # Create zip file
+            with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as z:
+                for f in all_files:
+                    z.write(f, os.path.basename(f))
             
-            # Show audio player and download only if requested
-            if st.session_state[paper_key] and paper['full_audio']:
-                st.audio(paper['full_audio'])
-                if paper['download_base64']:
-                    st.markdown(paper['download_base64'], unsafe_allow_html=True)
-                    
-# ─────────────────────────────────────────────────────────
-# 4. ZIP FUNCTION
-# ─────────────────────────────────────────────────────────
-
-def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
-    """
-    Zip up all relevant files, limiting the final zip name to ~20 chars
-    to avoid overly long base64 strings. 
-    """
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files + wav_files
-    if not all_files:
-        return None
-
-    all_content = []
-    for f in all_files:
-        if f.endswith('.md'):
-            with open(f, 'r', encoding='utf-8') as file:
-                all_content.append(file.read())
-        elif f.endswith('.mp3') or f.endswith('.wav'):
-            basename = os.path.splitext(os.path.basename(f))[0]
-            words = basename.replace('_', ' ')
-            all_content.append(words)
-    
-    all_content.append(input_question)
-    combined_content = " ".join(all_content)
-    info_terms = get_high_info_terms(combined_content, top_n=10)
-    
-    timestamp = format_timestamp_prefix()
-    name_text = '-'.join(term for term in info_terms[:5])  
-    short_zip_name = (timestamp + "_" + name_text)[:20] + ".zip"
-
-    with zipfile.ZipFile(short_zip_name, 'w') as z:
-        for f in all_files:
-            z.write(f)
-    return short_zip_name
+            return zip_name
+            
+        except Exception as e:
+            st.error(f"Error creating zip archive: {str(e)}")
+            return None
 
 # ─────────────────────────────────────────────────────────
-# 5. MAIN LOGIC: AI LOOKUP & VOICE INPUT
+# 6. OPTIMIZED AI LOOKUP & PROCESSING
 # ─────────────────────────────────────────────────────────
 
-def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
-                     titles_summary=True, full_audio=False):
-    """Main routine that uses Anthropic (Claude) + Gradio ArXiv RAG pipeline."""
-    start = time.time()
-    ai_constitution = """
-    You are a talented AI coder and songwriter...
-    """
-
-    # --- 1) Claude API
-    client = anthropic.Anthropic(api_key=anthropic_key)
-    user_input = q
-    response = client.messages.create(
-        model="claude-3-sonnet-20240229",
-        max_tokens=1000,
-        messages=[
-            {"role": "user", "content": user_input}
-        ])
-    st.write("Claude's reply 🧠:")
-    st.markdown(response.content[0].text)
-
-    # Save & produce audio
-    result = response.content[0].text
-    create_file(q, result) 
-    md_file, audio_file = save_qa_with_audio(q, result)
-    st.subheader("📝 Main Response Audio")
-    play_and_download_audio(audio_file, st.session_state['audio_format'])
-
-    # --- 2) Arxiv RAG
-    #st.write("Arxiv's AI this Evening is Mixtral 8x7B...")
-    st.write('Running Arxiv RAG with Claude inputs.')
-    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    refs = client.predict(
-        q, 
-        10, 
-        "Semantic Search", 
-        "mistralai/Mixtral-8x7B-Instruct-v0.1",
-        api_name="/update_with_rag_md"
-    )[0]
-
-    #r2 = client.predict(
-    #    q, 
-    #    "mistralai/Mixtral-8x7B-Instruct-v0.1", 
-    #    True, 
-    #    api_name="/ask_llm"
-    #)
-
-    # --- 3) Claude API with arxiv list of papers to app.py
-    client = anthropic.Anthropic(api_key=anthropic_key)
-    user_input = q + '\n\n' + 'Use the paper list below to answer the question thinking through step by step how to create a streamlit app.py and requirements.txt for the solution that answers the questions with a working app to demonstrate.'+ '\n\n'
-    response = client.messages.create(
-        model="claude-3-sonnet-20240229",
-        max_tokens=1000,
-        messages=[
-            {"role": "user", "content": user_input}
-        ])
-    r2 = response.content[0].text
-    st.write("Claude's reply 🧠:")
-    st.markdown(r2)
-    
-    #result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
-    result = f"🔎 {r2}\n\n{refs}"
-    md_file, audio_file = save_qa_with_audio(q, result)
-    st.subheader("📝 Main Response Audio")
-    play_and_download_audio(audio_file, st.session_state['audio_format'])
-
-    # --- 3) Parse + handle papers
-    papers = parse_arxiv_refs(refs)
-    if papers:
-        # Create minimal links page first
-        paper_links = create_paper_links_md(papers)
-        links_file = create_file(q, paper_links, "md")
-        st.markdown(paper_links)
-
-        # Then create audio for each paper
-        create_paper_audio_files(papers, input_question=q)
-        display_papers(papers, get_marquee_settings())
-        display_papers_in_sidebar(papers)
-    else:
-        st.warning("No papers found in the response.")
-
-    elapsed = time.time() - start
-    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-    return result
-
-def process_voice_input(text):
-    """When user sends voice query, we run the AI lookup + Q&A with audio."""
+def perform_ai_lookup(q: str, vocal_summary: bool = True, 
+                     extended_refs: bool = False,
+                     titles_summary: bool = True, 
+                     full_audio: bool = False) -> Tuple[str, Dict[str, float]]:
+    """Main AI lookup routine with performance optimization."""
+    with PerformanceTimer("total_lookup") as total_timer:
+        timings = {}
+
+        # Add operation controls if not present
+        if 'operation_controls' not in st.session_state:
+            st.sidebar.markdown("### 🔧 Operation Controls")
+            st.session_state['enable_claude'] = st.sidebar.checkbox(
+                "Enable Claude Search", 
+                value=st.session_state['enable_claude']
+            )
+            st.session_state['enable_audio'] = st.sidebar.checkbox(
+                "Generate Audio", 
+                value=st.session_state['enable_audio']
+            )
+            st.session_state['enable_download'] = st.sidebar.checkbox(
+                "Create Download Links", 
+                value=st.session_state['enable_download']
+            )
+            st.session_state['operation_controls'] = True
+
+        result = ""
+        
+        # 1. Claude API (if enabled)
+        if st.session_state['enable_claude']:
+            with PerformanceTimer("claude_api") as claude_timer:
+                try:
+                    client = anthropic.Anthropic(api_key=anthropic_key)
+                    response = client.messages.create(
+                        model="claude-3-sonnet-20240229",
+                        max_tokens=1000,
+                        messages=[{"role": "user", "content": q}]
+                    )
+                    st.write("Claude's reply 🧠:")
+                    st.markdown(response.content[0].text)
+                    result = response.content[0].text
+                    timings['claude_api'] = time.time() - claude_timer.start_time
+                except Exception as e:
+                    st.error(f"Error with Claude API: {str(e)}")
+                    result = "Error occurred during Claude API call"
+                    timings['claude_api'] = 0
+
+        # 2. Async save and audio generation
+        async def process_results():
+            with PerformanceTimer("results_processing") as proc_timer:
+                md_file, audio_file, md_time, audio_time = await async_save_qa_with_audio(
+                    q, result
+                )
+                timings['markdown_save'] = md_time
+                timings['audio_generation'] = audio_time
+                
+                if audio_file and st.session_state['enable_audio']:
+                    st.subheader("📝 Main Response Audio")
+                    st.audio(audio_file)
+                    
+                    if st.session_state['enable_download']:
+                        st.markdown(
+                            create_download_link_with_cache(
+                                audio_file, 
+                                st.session_state['audio_format']
+                            ),
+                            unsafe_allow_html=True
+                        )
+
+        # Run async operations
+        asyncio.run(process_results())
+
+        # 3. Arxiv RAG with performance tracking
+        if st.session_state['enable_claude']:
+            with PerformanceTimer("arxiv_rag") as rag_timer:
+                try:
+                    st.write('Running Arxiv RAG with Claude inputs.')
+                    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
+                    refs = client.predict(
+                        q, 
+                        10, 
+                        "Semantic Search", 
+                        "mistralai/Mixtral-8x7B-Instruct-v0.1",
+                        api_name="/update_with_rag_md"
+                    )[0]
+                    timings['arxiv_rag'] = time.time() - rag_timer.start_time
+
+                    # Process papers asynchronously
+                    papers = parse_arxiv_refs(refs)
+                    if papers:
+                        with PerformanceTimer("paper_processing") as paper_timer:
+                            async def process_papers():
+                                # Create minimal links page
+                                paper_links = create_paper_links_md(papers)
+                                links_file = create_file(q, paper_links, "md")
+                                st.markdown(paper_links)
+                                
+                                # Generate audio and display papers
+                                await create_paper_audio_files(papers, q)
+                                display_papers(papers, get_marquee_settings())
+                                display_papers_in_sidebar(papers)
+                            
+                            asyncio.run(process_papers())
+                            timings['paper_processing'] = time.time() - paper_timer.start_time
+                    else:
+                        st.warning("No papers found in the response.")
+                except Exception as e:
+                    st.error(f"Error during Arxiv RAG: {str(e)}")
+                    timings['arxiv_rag'] = 0
+
+        return result, timings
+
+def process_voice_input(text: str):
+    """Process voice input with enhanced error handling and feedback."""
     if not text:
+        st.warning("Please provide some input text.")
         return
-    st.subheader("🔍 Search Results")
-    result = perform_ai_lookup(
-        text, 
-        vocal_summary=True,
-        extended_refs=False,
-        titles_summary=True,
-        full_audio=True
-    )
-    md_file, audio_file = save_qa_with_audio(text, result)
-    st.subheader("📝 Generated Files")
-    st.write(f"Markdown: {md_file}")
-    st.write(f"Audio: {audio_file}")
-    play_and_download_audio(audio_file, st.session_state['audio_format'])
+
+    with PerformanceTimer("voice_processing"):
+        try:
+            st.subheader("🔍 Search Results")
+            result, timings = perform_ai_lookup(
+                text, 
+                vocal_summary=True,
+                extended_refs=False,
+                titles_summary=True,
+                full_audio=True
+            )
+
+            # Save results
+            md_file, audio_file = save_qa_with_audio(text, result)
+            
+            # Display results
+            st.subheader("📝 Generated Files")
+            col1, col2 = st.columns(2)
+            with col1:
+                st.write(f"📄 Markdown: {os.path.basename(md_file)}")
+                st.markdown(get_download_link(md_file, "md"), unsafe_allow_html=True)
+            
+            with col2:
+                if audio_file:
+                    st.write(f"🎵 Audio: {os.path.basename(audio_file)}")
+                    play_and_download_audio(
+                        audio_file, 
+                        st.session_state['audio_format']
+                    )
+
+        except Exception as e:
+            st.error(f"Error processing voice input: {str(e)}")
 
 # ─────────────────────────────────────────────────────────
-# 6. FILE HISTORY SIDEBAR
+# 7. SIDEBAR AND FILE HISTORY
 # ─────────────────────────────────────────────────────────
 
 def display_file_history_in_sidebar():
-    """
-    Shows a history of each local .md, .mp3, .wav file in descending
-    order of modification time, with quick icons and optional download links.
-    """
-    st.sidebar.markdown("---")
-    st.sidebar.markdown("### 📂 File History")
-
-    # Gather all files
-    md_files = glob.glob("*.md")
-    mp3_files = glob.glob("*.mp3")
-    wav_files = glob.glob("*.wav")
-    all_files = md_files + mp3_files + wav_files
-
-    if not all_files:
-        st.sidebar.write("No files found.")
-        return
+    """Display file history with enhanced organization and filtering."""
+    with PerformanceTimer("file_history"):
+        st.sidebar.markdown("---")
+        st.sidebar.markdown("### 📂 File History")
+
+        # Gather all files
+        md_files = glob.glob("*.md")
+        mp3_files = glob.glob("*.mp3")
+        wav_files = glob.glob("*.wav")
+        all_files = md_files + mp3_files + wav_files
+
+        if not all_files:
+            st.sidebar.write("No files found.")
+            return
+
+        # Add file management controls
+        col1, col2 = st.sidebar.columns(2)
+        with col1:
+            if st.button("🗑 Delete All"):
+                try:
+                    for f in all_files:
+                        os.remove(f)
+                    st.session_state.should_rerun = True
+                    st.success("All files deleted successfully.")
+                except Exception as e:
+                    st.error(f"Error deleting files: {str(e)}")
 
-    # 🗑⬇️ Sidebar delete all and zip all download
-    col1, col4 = st.sidebar.columns(2)
-    with col1:
-        if st.button("🗑 Delete All"):
-            for f in all_md:
-                os.remove(f)
-            for f in all_mp3:
-                os.remove(f)
-            for f in all_wav:
-                os.remove(f)
-            st.session_state.should_rerun = True
-    with col4:
-        if st.button("⬇️ Zip All"):
-            zip_name = create_zip_of_files(md_files, mp3_files, wav_files, st.session_state.get('last_query', ''))
-            if zip_name:
-                st.sidebar.markdown(get_download_link(zip_name, "zip"), unsafe_allow_html=True)
-    
-    # Sort newest first
-    all_files = sorted(all_files, key=os.path.getmtime, reverse=True)
-
-    for f in all_files:
-        fname = os.path.basename(f)
-        ext = os.path.splitext(fname)[1].lower().strip('.')
-        emoji = FILE_EMOJIS.get(ext, '📦')
-        time_str = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%Y-%m-%d %H:%M:%S")
-
-        with st.sidebar.expander(f"{emoji} {fname}"):
-            st.write(f"**Modified:** {time_str}")
-            if ext == "md":
-                with open(f, "r", encoding="utf-8") as file_in:
-                    snippet = file_in.read(200).replace("\n", " ")
-                if len(snippet) == 200:
-                    snippet += "..."
-                st.write(snippet)
-                st.markdown(get_download_link(f, file_type="md"), unsafe_allow_html=True)
-            elif ext in ["mp3","wav"]:
-                st.audio(f)
-                st.markdown(get_download_link(f, file_type=ext), unsafe_allow_html=True)
-            else:
-                st.markdown(get_download_link(f), unsafe_allow_html=True)
+        with col2:
+            if st.button("⬇️ Zip All"):
+                zip_name = create_zip_of_files(
+                    md_files, 
+                    mp3_files, 
+                    wav_files, 
+                    st.session_state.get('last_query', '')
+                )
+                if zip_name:
+                    st.sidebar.markdown(
+                        get_download_link(zip_name, "zip"),
+                        unsafe_allow_html=True
+                    )
+
+        # Add file filtering options
+        st.sidebar.markdown("### 🔍 Filter Files")
+        file_search = st.sidebar.text_input("Search files:", "")
+        file_type_filter = st.sidebar.multiselect(
+            "File types:",
+            ["Markdown", "Audio"],
+            default=["Markdown", "Audio"]
+        )
+
+        # Sort files by modification time
+        all_files.sort(key=os.path.getmtime, reverse=True)
+
+        # Filter files based on search and type
+        filtered_files = []
+        for f in all_files:
+            if file_search.lower() in f.lower():
+                ext = os.path.splitext(f)[1].lower()
+                if (("Markdown" in file_type_filter and ext == ".md") or
+                    ("Audio" in file_type_filter and ext in [".mp3", ".wav"])):
+                    filtered_files.append(f)
+
+        # Display filtered files
+        for f in filtered_files:
+            fname = os.path.basename(f)
+            ext = os.path.splitext(fname)[1].lower().strip('.')
+            emoji = FILE_EMOJIS.get(ext, '📦')
+            
+            # Get file metadata
+            mod_time = datetime.fromtimestamp(os.path.getmtime(f))
+            time_str = mod_time.strftime("%Y-%m-%d %H:%M:%S")
+            file_size = os.path.getsize(f) / 1024  # Size in KB
+
+            with st.sidebar.expander(f"{emoji} {fname}"):
+                st.write(f"**Modified:** {time_str}")
+                st.write(f"**Size:** {file_size:.1f} KB")
+                
+                if ext == "md":
+                    try:
+                        with open(f, "r", encoding="utf-8") as file_in:
+                            snippet = file_in.read(200).replace("\n", " ")
+                        if len(snippet) == 200:
+                            snippet += "..."
+                        st.write(snippet)
+                        st.markdown(
+                            get_download_link(f, file_type="md"),
+                            unsafe_allow_html=True
+                        )
+                    except Exception as e:
+                        st.error(f"Error reading markdown file: {str(e)}")
+                
+                elif ext in ["mp3", "wav"]:
+                    st.audio(f)
+                    st.markdown(
+                        get_download_link(f, file_type=ext),
+                        unsafe_allow_html=True
+                    )
+                
+                else:
+                    st.markdown(get_download_link(f), unsafe_allow_html=True)
 
 # ─────────────────────────────────────────────────────────
-# 7. MAIN APP
+# 8. MAIN APPLICATION
 # ─────────────────────────────────────────────────────────
 
 def main():
-    # 1) Setup marquee UI in the sidebar
-    update_marquee_settings_ui()
-    marquee_settings = get_marquee_settings()
-
-    # 2) Display the marquee welcome
-    display_marquee(st.session_state['marquee_content'], 
-                    {**marquee_settings, "font-size": "28px", "lineHeight": "50px"},
-                    key_suffix="welcome")
-
-    # 3) Main action tabs
-    tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], 
-                        horizontal=True)
-
-    # Example custom component usage
-    mycomponent = components.declare_component("mycomponent", path="mycomponent")
-    val = mycomponent(my_input_value="Hello")
-
-    if val:
-        val_stripped = val.replace('\\n', ' ')
-        edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100)
-        run_option = st.selectbox("Model:", ["Arxiv"])
-        col1, col2 = st.columns(2)
-        with col1:
-            autorun = st.checkbox("⚙ AutoRun", value=True)
-        with col2:
-            full_audio = st.checkbox("📚FullAudio", value=False)
-
-        input_changed = (val != st.session_state.old_val)
-
-        if autorun and input_changed:
-            st.session_state.old_val = val
-            st.session_state.last_query = edited_input
-            perform_ai_lookup(edited_input, 
-                              vocal_summary=True, 
-                              extended_refs=False, 
-                              titles_summary=True, 
-                              full_audio=full_audio)
-        else:
-            if st.button("▶ Run"):
-                st.session_state.old_val = val
-                st.session_state.last_query = edited_input
-                perform_ai_lookup(edited_input, 
-                                  vocal_summary=True, 
-                                  extended_refs=False, 
-                                  titles_summary=True, 
-                                  full_audio=full_audio)
-    
-    # ─────────────────────────────────────────────────────────
-    # TAB: ArXiv
-    # ─────────────────────────────────────────────────────────
-    if tab_main == "🔍 ArXiv":
-        st.subheader("🔍 Query ArXiv")
-        q = st.text_input("🔍 Query:", key="arxiv_query")
-        
-        st.markdown("### 🎛 Options")
-        vocal_summary = st.checkbox("🎙ShortAudio", value=True, key="option_vocal_summary")
-        extended_refs = st.checkbox("📜LongRefs", value=False, key="option_extended_refs")
-        titles_summary = st.checkbox("🔖TitlesOnly", value=True, key="option_titles_summary")
-        full_audio = st.checkbox("📚FullAudio", value=False, key="option_full_audio")
-        full_transcript = st.checkbox("🧾FullTranscript", value=False, key="option_full_transcript")
-        
-        if q and st.button("🔍Run"):
-            st.session_state.last_query = q
-            result = perform_ai_lookup(q, vocal_summary=vocal_summary, extended_refs=extended_refs, 
-                                       titles_summary=titles_summary, full_audio=full_audio)
-            if full_transcript:
-                create_file(q, result, "md")
-
-    # ─────────────────────────────────────────────────────────
-    # TAB: Voice
-    # ─────────────────────────────────────────────────────────
-    elif tab_main == "🎤 Voice":
-        st.subheader("🎤 Voice Input")
-        
-        st.markdown("### 🎤 Voice Settings")
-        selected_voice = st.selectbox(
-            "Select TTS Voice:",
-            options=EDGE_TTS_VOICES,
-            index=EDGE_TTS_VOICES.index(st.session_state['tts_voice'])
-        )
-        
-        st.markdown("### 🔊 Audio Format")
-        selected_format = st.radio(
-            "Choose Audio Format:",
-            options=["MP3", "WAV"],
-            index=0
+    """Main application entry point with enhanced UI and error handling."""
+    try:
+        # 1. Setup marquee UI in sidebar
+        update_marquee_settings_ui()
+        marquee_settings = get_marquee_settings()
+
+        # 2. Display welcome marquee
+        display_marquee(
+            st.session_state['marquee_content'],
+            {**marquee_settings, "font-size": "28px", "lineHeight": "50px"},
+            key_suffix="welcome"
         )
 
-        # Update session state if voice/format changes
-        if selected_voice != st.session_state['tts_voice']:
-            st.session_state['tts_voice'] = selected_voice
-            st.rerun()
-        if selected_format.lower() != st.session_state['audio_format']:
-            st.session_state['audio_format'] = selected_format.lower()
-            st.rerun()
-
-        # Input text
-        user_text = st.text_area("💬 Message:", height=100)
-        user_text = user_text.strip().replace('\n', ' ')
+        # 3. Main action tabs
+        tab_main = st.radio(
+            "Action:",
+            ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"],
+            horizontal=True
+        )
 
-        if st.button("📨 Send"):
-            process_voice_input(user_text)
+        # Custom component usage
+        mycomponent = components.declare_component(
+            "mycomponent",
+            path="mycomponent"
+        )
+        val = mycomponent(my_input_value="Hello")
+
+        if val:
+            # Process input value
+            val_stripped = val.replace('\\n', ' ')
+            edited_input = st.text_area(
+                "✏️ Edit Input:",
+                value=val_stripped,
+                height=100
+            )
 
-        st.subheader("📜 Chat History")
-        for c in st.session_state.chat_history:
-            st.write("**You:**", c["user"])
-            st.write("**Response:**", c["claude"])
+            # Model selection and options
+            run_option = st.selectbox("Model:", ["Arxiv"])
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                autorun = st.checkbox("⚙ AutoRun", value=True)
+            with col2:
+                full_audio = st.checkbox("📚 FullAudio", value=False)
 
-    # ─────────────────────────────────────────────────────────
-    # TAB: Media
-    # ─────────────────────────────────────────────────────────
-    elif tab_main == "📸 Media":
-        st.header("📸 Media Gallery")
+            # Check for input changes
+            input_changed = (val != st.session_state.old_val)
 
-        # By default, show audio first
-        tabs = st.tabs(["🎵 Audio", "🖼 Images", "🎥 Video"])
-        
-        # AUDIO sub-tab
-        with tabs[0]:
-            st.subheader("🎵 Audio Files")
-            audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
-            if audio_files:
-                for a in audio_files:
-                    with st.expander(os.path.basename(a)):
-                        st.audio(a)
-                        ext = os.path.splitext(a)[1].replace('.', '')
-                        dl_link = get_download_link(a, file_type=ext)
-                        st.markdown(dl_link, unsafe_allow_html=True)
-            else:
-                st.write("No audio files found.")
-        
-        # IMAGES sub-tab
-        with tabs[1]:
-            st.subheader("🖼 Image Files")
-            imgs = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
-            if imgs:
-                c = st.slider("Cols", 1, 5, 3, key="cols_images")
-                cols = st.columns(c)
-                for i, f in enumerate(imgs):
-                    with cols[i % c]:
-                        st.image(Image.open(f), use_container_width=True)
-            else:
-                st.write("No images found.")
-        
-        # VIDEO sub-tab
-        with tabs[2]:
-            st.subheader("🎥 Video Files")
-            vids = glob.glob("*.mp4") + glob.glob("*.mov") + glob.glob("*.avi")
-            if vids:
-                for v in vids:
-                    with st.expander(os.path.basename(v)):
-                        st.video(v)
+            if autorun and input_changed:
+                st.session_state.old_val = val
+                st.session_state.last_query = edited_input
+                result, timings = perform_ai_lookup(
+                    edited_input,
+                    vocal_summary=True,
+                    extended_refs=False,
+                    titles_summary=True,
+                    full_audio=full_audio
+                )
+                
+                # Display performance metrics
+                display_performance_metrics(timings)
+            
             else:
-                st.write("No videos found.")
-
-    # ─────────────────────────────────────────────────────────
-    # TAB: Editor
-    # ─────────────────────────────────────────────────────────
-    elif tab_main == "📝 Editor":
-        st.write("Select or create a file to edit. (Currently minimal demo)")
-
-    # ─────────────────────────────────────────────────────────
-    # SIDEBAR: FILE HISTORY
-    # ─────────────────────────────────────────────────────────
-    display_file_history_in_sidebar()
-
-    # Some light CSS styling
-    st.markdown("""
-    <style>
-        .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
-        .stMarkdown { font-family: 'Helvetica Neue', sans-serif; }
-        .stButton>button { margin-right: 0.5rem; }
-    </style>
-    """, unsafe_allow_html=True)
-
-    # Rerun if needed
-    if st.session_state.should_rerun:
-        st.session_state.should_rerun = False
-        st.rerun()
+                if st.button("▶ Run"):
+                    st.session_state.old_val = val
+                    st.session_state.last_query = edited_input
+                    result, timings = perform_ai_lookup(
+                        edited_input,
+                        vocal_summary=True,
+                        extended_refs=False,
+                        titles_summary=True,
+                        full_audio=full_audio
+                    )
+                    
+                    # Display performance metrics
+                    display_performance_metrics(timings)
+
+        # Tab-specific content
+        if tab_main == "🔍 ArXiv":
+            display_arxiv_tab()
+        elif tab_main == "🎤 Voice":
+            display_voice_tab()
+        elif tab_main == "📸 Media":
+            display_media_tab()
+        elif tab_main == "📝 Editor":
+            display_editor_tab()
+
+        # Display file history
+        display_file_history_in_sidebar()
+
+        # Apply styling
+        apply_custom_styling()
+
+        # Check for rerun
+        if st.session_state.should_rerun:
+            st.session_state.should_rerun = False
+            st.rerun()
+
+    except Exception as e:
+        st.error(f"An error occurred in the main application: {str(e)}")
+        st.info("Please try refreshing the page or contact support if the issue persists.")
 
 if __name__ == "__main__":
-    main()
+    main()