Update app.py

app.py

@@ -1,9 +1,9 @@
+# 🚀 Main App - TalkingAIResearcher with Chat, Voice, Media, ArXiv, and More
 import streamlit as st
 import asyncio
 import websockets
 import uuid
 import argparse
-from datetime import datetime
 import os
 import random
 import time
@@ -17,26 +17,35 @@ import edge_tts
 from audio_recorder_streamlit import audio_recorder
 import nest_asyncio
 import re
-from streamlit_paste_button import paste_image_button
 import pytz
 import shutil
+import anthropic
+import openai
+from PyPDF2 import PdfReader
+import threading
+import json
+import zipfile
+from gradio_client import Client
+from dotenv import load_dotenv
+from streamlit_marquee import streamlit_marquee
+from datetime import datetime
+from collections import defaultdict, Counter
+import pandas as pd
 
-# Patch for nested async - sneaky fix! 🐍✨
+# 🛠️ Patch asyncio for nesting glory
 nest_asyncio.apply()
 
-# Static config - constants rule! 📏👑
-icons = '🤖🧠🔬📝'
-START_ROOM = "Sector 🌌"
-
-# Page setup - dressing up the window! 🖼️🎀
+# 🎨 Page Config
 st.set_page_config(
-    page_title="🤖🧠MMO Chat Brain📝🔬",
-    page_icon=icons,
+    page_title="🚲TalkingAIResearcher🏆",
+    page_icon="🚲🏆",
     layout="wide",
     initial_sidebar_state="auto"
 )
 
-# Funky usernames - who’s who in the zoo with unique voices! 🎭🐾🎙️
+# 🌟 Static Config
+icons = '🤖🧠🔬📝'
+START_ROOM = "Sector 🌌"
 FUN_USERNAMES = {
     "CosmicJester 🌌": "en-US-AriaNeural",
     "PixelPanda 🐼": "en-US-JennyNeural",
@@ -48,326 +57,202 @@ FUN_USERNAMES = {
     "GalacticGopher 🌍": "en-AU-WilliamNeural",
     "RocketRaccoon 🚀": "en-CA-LiamNeural",
     "EchoElf 🧝": "en-US-AnaNeural",
-    "PhantomFox 🦊": "en-US-BrandonNeural",
-    "WittyWizard 🧙": "en-GB-ThomasNeural",
-    "LunarLlama 🌙": "en-AU-FreyaNeural",
-    "SolarSloth ☀️": "en-CA-LindaNeural",
-    "AstroAlpaca 🦙": "en-US-ChristopherNeural",
-    "CyberCoyote 🐺": "en-GB-ElliotNeural",
-    "MysticMoose 🦌": "en-AU-JamesNeural",
-    "GlitchGnome 🧚": "en-CA-EthanNeural",
-    "VortexViper 🐍": "en-US-AmberNeural",
-    "ChronoChimp 🐒": "en-GB-LibbyNeural"
 }
+EDGE_TTS_VOICES = list(set(FUN_USERNAMES.values()))  # 🎙️ Voice options
+FILE_EMOJIS = {"md": "📝", "mp3": "🎵", "wav": "🔊"}
+
+# 📁 Directories
+for d in ["chat_logs", "vote_logs", "audio_logs", "history_logs", "media_files", "audio_cache"]:
+    os.makedirs(d, exist_ok=True)
 
-# Folders galore - organizing chaos! 📂🌀
-CHAT_DIR = "chat_logs"
-VOTE_DIR = "vote_logs"
-STATE_FILE = "user_state.txt"
-AUDIO_DIR = "audio_logs"
-HISTORY_DIR = "history_logs"
+CHAT_FILE = "chat_logs/global_chat.md"
+HISTORY_FILE = "history_logs/chat_history.md"
 MEDIA_DIR = "media_files"
-os.makedirs(CHAT_DIR, exist_ok=True)
-os.makedirs(VOTE_DIR, exist_ok=True)
-os.makedirs(AUDIO_DIR, exist_ok=True)
-os.makedirs(HISTORY_DIR, exist_ok=True)
-os.makedirs(MEDIA_DIR, exist_ok=True)
-
-CHAT_FILE = os.path.join(CHAT_DIR, "global_chat.md")
-QUOTE_VOTES_FILE = os.path.join(VOTE_DIR, "quote_votes.md")
-MEDIA_VOTES_FILE = os.path.join(VOTE_DIR, "media_votes.md")
-HISTORY_FILE = os.path.join(HISTORY_DIR, "chat_history.md")
-
-# Fancy digits - numbers got style! 🔢💃
-UNICODE_DIGITS = {i: f"{i}\uFE0F⃣" for i in range(10)}
-
-# Massive font collection - typography bonanza! 🖋️🎨
-UNICODE_FONTS = [
-    ("Normal", lambda x: x),
-    ("Bold", lambda x: "".join(chr(ord(c) + 0x1D400 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D41A - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Italic", lambda x: "".join(chr(ord(c) + 0x1D434 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D44E - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Bold Italic", lambda x: "".join(chr(ord(c) + 0x1D468 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D482 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Script", lambda x: "".join(chr(ord(c) + 0x1D49C - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D4B6 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Bold Script", lambda x: "".join(chr(ord(c) + 0x1D4D0 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D4EA - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Fraktur", lambda x: "".join(chr(ord(c) + 0x1D504 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D51E - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Bold Fraktur", lambda x: "".join(chr(ord(c) + 0x1D56C - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D586 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Double Struck", lambda x: "".join(chr(ord(c) + 0x1D538 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D552 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Sans Serif", lambda x: "".join(chr(ord(c) + 0x1D5A0 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D5BA - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Sans Serif Bold", lambda x: "".join(chr(ord(c) + 0x1D5D4 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D5EE - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Sans Serif Italic", lambda x: "".join(chr(ord(c) + 0x1D608 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D622 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Sans Serif Bold Italic", lambda x: "".join(chr(ord(c) + 0x1D63C - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D656 - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Monospace", lambda x: "".join(chr(ord(c) + 0x1D670 - 0x41) if 'A' <= c <= 'Z' else chr(ord(c) + 0x1D68A - 0x61) if 'a' <= c <= 'z' else c for c in x)),
-    ("Circled", lambda x: "".join(chr(ord(c) - 0x41 + 0x24B6) if 'A' <= c <= 'Z' else chr(ord(c) - 0x61 + 0x24D0) if 'a' <= c <= 'z' else c for c in x)),
-    ("Squared", lambda x: "".join(chr(ord(c) - 0x41 + 0x1F130) if 'A' <= c <= 'Z' else c for c in x)),
-    ("Negative Circled", lambda x: "".join(chr(ord(c) - 0x41 + 0x1F150) if 'A' <= c <= 'Z' else c for c in x)),
-    ("Negative Squared", lambda x: "".join(chr(ord(c) - 0x41 + 0x1F170) if 'A' <= c <= 'Z' else c for c in x)),
-    ("Regional Indicator", lambda x: "".join(chr(ord(c) - 0x41 + 0x1F1E6) if 'A' <= c <= 'Z' else c for c in x)),
-]
-
-# Global state - keeping tabs! 🌍📋
-if 'server_running' not in st.session_state:
-    st.session_state.server_running = False
-if 'server_task' not in st.session_state:
-    st.session_state.server_task = None
-if 'active_connections' not in st.session_state:
-    st.session_state.active_connections = {}
-if 'media_notifications' not in st.session_state:
-    st.session_state.media_notifications = []
-if 'last_chat_update' not in st.session_state:
-    st.session_state.last_chat_update = 0
-if 'displayed_chat_lines' not in st.session_state:
-    st.session_state.displayed_chat_lines = []
-if 'old_val' not in st.session_state:
-    st.session_state.old_val = ""
-if 'last_query' not in st.session_state:
-    st.session_state.last_query = ""
-if 'message_text' not in st.session_state:
-    st.session_state.message_text = ""
-if 'audio_cache' not in st.session_state:
-    st.session_state.audio_cache = {}
-if 'pasted_image_data' not in st.session_state:
-    st.session_state.pasted_image_data = None
-if 'quote_line' not in st.session_state:
-    st.session_state.quote_line = None
-if 'refresh_rate' not in st.session_state:
-    st.session_state.refresh_rate = 5
-if 'base64_cache' not in st.session_state:
-    st.session_state.base64_cache = {}
-if 'transcript_history' not in st.session_state:
-    st.session_state.transcript_history = []
-if 'last_transcript' not in st.session_state:
-    st.session_state.last_transcript = ""
-if 'image_hashes' not in st.session_state:
-    st.session_state.image_hashes = set()
-
-# Timestamp wizardry - clock ticks with flair! ⏰🎩
-def format_timestamp_prefix(username):
+AUDIO_CACHE_DIR = "audio_cache"
+AUDIO_DIR = "audio_logs"  # New dir for MP3s
+
+# 🔑 API Keys
+load_dotenv()
+anthropic_key = os.getenv('ANTHROPIC_API_KEY', st.secrets.get('ANTHROPIC_API_KEY', ""))
+openai_api_key = os.getenv('OPENAI_API_KEY', st.secrets.get('OPENAI_API_KEY', ""))
+openai_client = openai.OpenAI(api_key=openai_api_key)
+
+# 🕒 Timestamp Helper
+def format_timestamp_prefix(username=""):
     central = pytz.timezone('US/Central')
     now = datetime.now(central)
-    return f"{now.strftime('%I-%M-%p-ct-%m-%d-%Y')}-by-{username}"
-
-# Compute image hash from binary data
-def compute_image_hash(image_data):
-    if isinstance(image_data, Image.Image):
-        img_byte_arr = io.BytesIO()
-        image_data.save(img_byte_arr, format='PNG')
-        img_bytes = img_byte_arr.getvalue()
-    else:
-        img_bytes = image_data
-    return hashlib.md5(img_bytes).hexdigest()[:8]
-
-# Node naming - christening the beast! 🌐🍼
-def get_node_name():
-    parser = argparse.ArgumentParser(description='Start a chat node with a specific name')
-    parser.add_argument('--node-name', type=str, default=None)
-    parser.add_argument('--port', type=int, default=8501)
-    args = parser.parse_args()
-    username = st.session_state.get('username', 'System 🌟')
-    log_action(username, "🌐🍼 - Node naming - christening the beast!")
-    return args.node_name or f"node-{uuid.uuid4().hex[:8]}", args.port
-
-# Action logger - spying on deeds! 🕵️📜
-def log_action(username, action):
-    if 'action_log' not in st.session_state:
-        st.session_state.action_log = {}
-    user_log = st.session_state.action_log.setdefault(username, {})
-    current_time = time.time()
-    user_log = {k: v for k, v in user_log.items() if current_time - v < 10}
-    st.session_state.action_log[username] = user_log
-    if action not in user_log:
-        central = pytz.timezone('US/Central')
-        with open(HISTORY_FILE, 'a') as f:
-            f.write(f"[{datetime.now(central).strftime('%Y-%m-%d %H:%M:%S')}] {username}: {action}\n")
-        user_log[action] = current_time
-
-# Clean text - strip the fancy stuff! 🧹📝
-def clean_text_for_tts(text):
-    cleaned = re.sub(r'[#*!\[\]]+', '', text)
-    cleaned = ' '.join(cleaned.split())
-    return cleaned[:200] if cleaned else "No text to speak"
-
-# Chat saver - words locked tight! 💬🔒
+    return f"{now.strftime('%Y%m%d_%H%M%S')}-by-{username}"
+
+# 📈 Performance Timer
+class PerformanceTimer:
+    def __init__(self, name): self.name, self.start = name, None
+    def __enter__(self): 
+        self.start = time.time()
+        return self
+    def __exit__(self, *args): 
+        duration = time.time() - self.start
+        st.session_state['operation_timings'][self.name] = duration
+        st.session_state['performance_metrics'][self.name].append(duration)
+
+# 🎛️ Session State Init
+def init_session_state():
+    defaults = {
+        'server_running': False, 'server_task': None, 'active_connections': {},
+        'media_notifications': [], 'last_chat_update': 0, 'displayed_chat_lines': [],
+        'message_text': "", 'audio_cache': {}, 'pasted_image_data': None,
+        'quote_line': None, 'refresh_rate': 5, 'base64_cache': {},
+        'transcript_history': [], 'last_transcript': "", 'image_hashes': set(),
+        'tts_voice': "en-US-AriaNeural", 'chat_history': [], 'marquee_settings': {
+            "background": "#1E1E1E", "color": "#FFFFFF", "font-size": "14px",
+            "animationDuration": "20s", "width": "100%", "lineHeight": "35px"
+        }, 'operation_timings': {}, 'performance_metrics': defaultdict(list),
+        'enable_audio': True, 'download_link_cache': {}, 'username': None,
+        'autosend': True, 'autosearch': True, 'last_message': "", 'last_query': "",
+        'mp3_files': {}  # Store MP3s with chat lines
+    }
+    for k, v in defaults.items():
+        if k not in st.session_state: st.session_state[k] = v
+
+# 🖌️ Marquee Helpers
+def update_marquee_settings_ui():
+    # 🎨 Sidebar marquee controls
+    st.sidebar.markdown("### 🎯 Marquee Settings")
+    cols = st.sidebar.columns(2)
+    with cols[0]:
+        st.session_state['marquee_settings']['background'] = st.color_picker("🎨 Background", "#1E1E1E")
+        st.session_state['marquee_settings']['color'] = st.color_picker("✍️ Text", "#FFFFFF")
+    with cols[1]:
+        st.session_state['marquee_settings']['font-size'] = f"{st.slider('📏 Size', 10, 24, 14)}px"
+        st.session_state['marquee_settings']['animationDuration'] = f"{st.slider('⏱️ Speed', 1, 20, 20)}s"
+
+def display_marquee(text, settings, key_suffix=""):
+    # 🌈 Show marquee with truncation
+    truncated = text[:280] + "..." if len(text) > 280 else text
+    streamlit_marquee(content=truncated, **settings, key=f"marquee_{key_suffix}")
+    st.write("")
+
+# 📝 Text & File Helpers
+def clean_text_for_tts(text): return re.sub(r'[#*!\[\]]+', '', ' '.join(text.split()))[:200] or "No text"
+def clean_text_for_filename(text): return '_'.join(re.sub(r'[^\w\s-]', '', text.lower()).split())[:200]
+def get_high_info_terms(text, top_n=10):
+    stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with'}
+    words = re.findall(r'\b\w+(?:-\w+)*\b', text.lower())
+    bi_grams = [' '.join(pair) for pair in zip(words, words[1:])]
+    filtered = [t for t in words + bi_grams if t not in stop_words and len(t.split()) <= 2]
+    return [t for t, _ in Counter(filtered).most_common(top_n)]
+
+def generate_filename(prompt, response, file_type="md"):
+    # 📁 Smart filename with info terms
+    prefix = format_timestamp_prefix()
+    terms = get_high_info_terms(prompt + " " + response, 5)
+    snippet = clean_text_for_filename(prompt[:40] + " " + response[:40])
+    wct, sw = len(prompt.split()), len(response.split())
+    dur = round((wct + sw) / 2.5)
+    base = '_'.join(list(dict.fromkeys(terms + [snippet])))[:200 - len(prefix) - len(f"_wct{wct}_sw{sw}_dur{dur}.{file_type}")]
+    return f"{prefix}{base}_wct{wct}_sw{sw}_dur{dur}.{file_type}"
+
+def create_file(prompt, response, file_type="md"):
+    # 📝 Save file with Q&A
+    filename = generate_filename(prompt, response, 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="mp3"):
+    # ⬇️ Cached download link
+    cache_key = f"dl_{file}"
+    if cache_key not in st.session_state['download_link_cache']:
+        with open(file, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode()
+        st.session_state['download_link_cache'][cache_key] = f'<a href="data:audio/mpeg;base64,{b64}" download="{os.path.basename(file)}">{FILE_EMOJIS.get(file_type, "Download")} Download {os.path.basename(file)}</a>'
+    return st.session_state['download_link_cache'][cache_key]
+
+# 🎶 Audio Processing
+async def async_edge_tts_generate(text, voice, username, rate=0, pitch=0, file_format="mp3"):
+    # 🎵 Async TTS with caching and .md generation
+    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
+    start_time = time.time()
+    text = clean_text_for_tts(text)
+    if not text: return None, 0
+    filename = f"{AUDIO_DIR}/{format_timestamp_prefix(username)}_{voice}.{file_format}"
+    communicate = edge_tts.Communicate(text, voice, rate=f"{rate:+d}%", pitch=f"{pitch:+d}Hz")
+    await communicate.save(filename)
+    st.session_state['audio_cache'][cache_key] = filename
+    
+    # Generate .md file
+    md_filename = filename.replace(".mp3", ".md")
+    md_content = f"# Chat Audio Log\n\n**Player:** {username}\n**Voice:** {voice}\n**Text:**\n```markdown\n{text}\n```"
+    with open(md_filename, 'w', encoding='utf-8') as f: f.write(md_content)
+    
+    return filename, time.time() - start_time
+
+def play_and_download_audio(file_path):
+    # 🔊 Play + download
+    if file_path and os.path.exists(file_path):
+        st.audio(file_path)
+        st.markdown(get_download_link(file_path), unsafe_allow_html=True)
+
+def load_mp3_viewer():
+    # 🎵 Load all MP3s at startup
+    mp3_files = glob.glob(f"{AUDIO_DIR}/*.mp3")
+    for mp3 in mp3_files:
+        filename = os.path.basename(mp3)
+        if filename not in st.session_state['mp3_files']:
+            st.session_state['mp3_files'][filename] = mp3
+
 async def save_chat_entry(username, message, is_markdown=False):
-    await asyncio.to_thread(log_action, username, "💬🔒 - Chat saver - words locked tight!")
+    # 💬 Save chat with multicast broadcast and audio
     central = pytz.timezone('US/Central')
     timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
-    if is_markdown:
-        entry = f"[{timestamp}] {username}:\n```markdown\n{message}\n```"
-    else:
-        entry = f"[{timestamp}] {username}: {message}"
-    await asyncio.to_thread(lambda: open(CHAT_FILE, 'a').write(f"{entry}\n"))
+    entry = f"[{timestamp}] {username}: {message}" if not is_markdown else f"[{timestamp}] {username}:\n```markdown\n{message}\n```"
+    with open(CHAT_FILE, 'a') as f: f.write(f"{entry}\n")
     voice = FUN_USERNAMES.get(username, "en-US-AriaNeural")
-    cleaned_message = clean_text_for_tts(message)
-    audio_file = await async_edge_tts_generate(cleaned_message, voice)
+    audio_file, _ = await async_edge_tts_generate(message, voice, username)
     if audio_file:
-        with open(HISTORY_FILE, 'a') as f:
-            f.write(f"[{timestamp}] {username}: Audio generated - {audio_file}\n")
+        with open(HISTORY_FILE, 'a') as f: f.write(f"[{timestamp}] {username}: Audio - {audio_file}\n")
+        st.session_state['mp3_files'][os.path.basename(audio_file)] = audio_file
     await broadcast_message(f"{username}|{message}", "chat")
     st.session_state.last_chat_update = time.time()
+    st.session_state.chat_history.append(entry)
     return audio_file
 
-# Chat loader - history unleashed! 📜🚀
 async def load_chat():
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "📜🚀 - Chat loader - history unleashed!")
+    # 📜 Load chat history - Numbered
     if not os.path.exists(CHAT_FILE):
-        await asyncio.to_thread(lambda: open(CHAT_FILE, 'a').write(f"# {START_ROOM} Chat\n\nWelcome to the cosmic hub - start chatting! 🎤\n"))
-    with open(CHAT_FILE, 'r') as f:
-        content = await asyncio.to_thread(f.read)
-    return content
-
-# User lister - who’s in the gang! 👥🎉
-async def get_user_list(chat_content):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "👥🎉 - User lister - who’s in the gang!")
-    users = set()
-    for line in chat_content.split('\n'):
-        if line.strip() and ': ' in line:
-            user = line.split(': ')[1].split(' ')[0]
-            users.add(user)
-    return sorted(list(users))
-
-# Join checker - been here before? 🚪🔍
-async def has_joined_before(client_id, chat_content):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🚪🔍 - Join checker - been here before?")
-    return any(f"Client-{client_id}" in line for line in chat_content.split('\n'))
-
-# Suggestion maker - old quips resurface! 💡📝
-async def get_message_suggestions(chat_content, prefix):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "💡📝 - Suggestion maker - old quips resurface!")
-    lines = chat_content.split('\n')
-    messages = [line.split(': ', 1)[1] for line in lines if ': ' in line and line.strip()]
-    return [msg for msg in messages if msg.lower().startswith(prefix.lower())][:5]
-
-# Vote saver - cheers recorded! 👍📊
-async def save_vote(file, item, user_hash, username, comment=""):
-    await asyncio.to_thread(log_action, username, "👍📊 - Vote saver - cheers recorded!")
-    central = pytz.timezone('US/Central')
-    timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
-    entry = f"[{timestamp}] {user_hash} voted for {item}"
-    await asyncio.to_thread(lambda: open(file, 'a').write(f"{entry}\n"))
-    await asyncio.to_thread(lambda: open(HISTORY_FILE, "a").write(f"- {timestamp} - User {user_hash} voted for {item}\n"))
-    chat_message = f"{username} upvoted: \"{item}\""
-    if comment:
-        chat_message += f" - {comment}"
-    await save_chat_entry(username, chat_message)
-
-# Vote counter - tallying the love! 🏆📈
-async def load_votes(file):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🏆📈 - Vote counter - tallying the love!")
-    if not os.path.exists(file):
-        await asyncio.to_thread(lambda: open(file, 'w').write("# Vote Tally\n\nNo votes yet - get clicking! 🖱️\n"))
-    with open(file, 'r') as f:
-        content = await asyncio.to_thread(f.read)
-        lines = content.strip().split('\n')[2:]
-    votes = {}
-    user_votes = set()
-    for line in lines:
-        if line.strip() and 'voted for' in line:
-            user_hash = line.split('] ')[1].split(' voted for ')[0]
-            item = line.split('voted for ')[1]
-            vote_key = f"{user_hash}-{item}"
-            if vote_key not in user_votes:
-                votes[item] = votes.get(item, 0) + 1
-                user_votes.add(vote_key)
-    return votes
-
-# Hash generator - secret codes ahoy! 🔑🕵️
-async def generate_user_hash():
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🔑🕵️ - Hash generator - secret codes ahoy!")
-    if 'user_hash' not in st.session_state:
-        st.session_state.user_hash = hashlib.md5(str(random.getrandbits(128)).encode()).hexdigest()[:8]
-    return st.session_state.user_hash
-
-# Audio maker - voices come alive! 🎶🌟
-async def async_edge_tts_generate(text, voice, rate=0, pitch=0, file_format="mp3"):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🎶🌟 - Audio maker - voices come alive!")
-    timestamp = format_timestamp_prefix(username)
-    filename = f"{timestamp}.{file_format}"
-    filepath = os.path.join(AUDIO_DIR, filename)
-    communicate = edge_tts.Communicate(text, voice, rate=f"{rate:+d}%", pitch=f"{pitch:+d}Hz")
-    try:
-        await communicate.save(filepath)
-        return filepath if os.path.exists(filepath) else None
-    except edge_tts.exceptions.NoAudioReceived:
-        with open(HISTORY_FILE, 'a') as f:
-            central = pytz.timezone('US/Central')
-            f.write(f"[{datetime.now(central).strftime('%Y-%m-%d %H:%M:%S')}] {username}: Audio failed - No audio received for '{text}'\n")
-        return None
-
-# Audio player - tunes blast off! 🔊🚀
-def play_and_download_audio(file_path):
-    if file_path and os.path.exists(file_path):
-        st.audio(file_path)
-        if file_path not in st.session_state.base64_cache:
-            with open(file_path, "rb") as f:
-                b64 = base64.b64encode(f.read()).decode()
-            st.session_state.base64_cache[file_path] = b64
-        b64 = st.session_state.base64_cache[file_path]
-        dl_link = f'<a href="data:audio/mpeg;base64,{b64}" download="{os.path.basename(file_path)}">🎵 Download {os.path.basename(file_path)}</a>'
-        st.markdown(dl_link, unsafe_allow_html=True)
-
-# Image saver - pics preserved with naming! 📸💾
-async def save_pasted_image(image, username):
-    await asyncio.to_thread(log_action, username, "📸💾 - Image saver - pics preserved!")
-    img_hash = compute_image_hash(image)
-    if img_hash in st.session_state.image_hashes:
-        return None
-    timestamp = format_timestamp_prefix(username)
-    filename = f"{timestamp}-{img_hash}.png"
-    filepath = os.path.join(MEDIA_DIR, filename)
-    await asyncio.to_thread(image.save, filepath, "PNG")
-    st.session_state.image_hashes.add(img_hash)
-    return filepath
-
-# Video renderer - movies roll with autoplay! 🎥🎬
-async def get_video_html(video_path, width="100%"):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🎥🎬 - Video renderer - movies roll!")
-    with open(video_path, 'rb') as f:
-        video_data = await asyncio.to_thread(f.read)
-    video_url = f"data:video/mp4;base64,{base64.b64encode(video_data).decode()}"
-    return f'<video width="{width}" controls autoplay><source src="{video_url}" type="video/mp4">Your browser does not support the video tag.</video>'
-
-# Audio renderer - sounds soar! 🎶✈️
-async def get_audio_html(audio_path, width="100%"):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🎶✈️ - Audio renderer - sounds soar!")
-    audio_url = f"data:audio/mpeg;base64,{base64.b64encode(await asyncio.to_thread(open, audio_path, 'rb').read()).decode()}"
-    return f'<audio controls style="width: {width};"><source src="{audio_url}" type="audio/mpeg">Your browser does not support the audio element.</audio>'
-
-# Websocket handler - chat links up! 🌐🔗
+        with open(CHAT_FILE, 'a') as f: f.write(f"# {START_ROOM} Chat\n\nWelcome to the cosmic hub! 🎤\n")
+    with open(CHAT_FILE, 'r') as f: 
+        content = f.read().strip()
+    lines = content.split('\n')
+    numbered_content = "\n".join(f"{i+1}. {line}" for i, line in enumerate(lines) if line.strip())
+    return numbered_content
+
+# 🌐 WebSocket Handling
 async def websocket_handler(websocket, path):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🌐🔗 - Websocket handler - chat links up!")
+    # 🤝 Handle WebSocket clients
+    client_id = str(uuid.uuid4())
+    room_id = "chat"
+    if room_id not in st.session_state.active_connections:
+        st.session_state.active_connections[room_id] = {}
+    st.session_state.active_connections[room_id][client_id] = websocket
+    username = st.session_state.get('username', random.choice(list(FUN_USERNAMES.keys())))
+    chat_content = await load_chat()
+    if not any(f"Client-{client_id}" in line for line in chat_content.split('\n')):
+        await save_chat_entry("System 🌟", f"{username} has joined {START_ROOM}!")
     try:
-        client_id = str(uuid.uuid4())
-        room_id = "chat"
-        st.session_state.active_connections.setdefault(room_id, {})[client_id] = websocket
-        chat_content = await load_chat()
-        username = st.session_state.get('username', random.choice(list(FUN_USERNAMES.keys())))
-        if not await has_joined_before(client_id, chat_content):
-            await save_chat_entry(f"Client-{client_id}", f"{username} has joined {START_ROOM}!")
         async for message in websocket:
-            parts = message.split('|', 1)
-            if len(parts) == 2:
-                username, content = parts
+            if '|' in message:
+                username, content = message.split('|', 1)
                 await save_chat_entry(username, content)
+            else:
+                await websocket.send("ERROR|Message format: username|content")
     except websockets.ConnectionClosed:
-        pass
+        await save_chat_entry("System 🌟", f"{username} has left {START_ROOM}!")
     finally:
         if room_id in st.session_state.active_connections and client_id in st.session_state.active_connections[room_id]:
             del st.session_state.active_connections[room_id][client_id]
 
-# Message broadcaster - words fly far! 📢✈️
 async def broadcast_message(message, room_id):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "📢✈️ - Message broadcaster - words fly far!")
+    # 📢 Broadcast to all clients
     if room_id in st.session_state.active_connections:
         disconnected = []
         for client_id, ws in st.session_state.active_connections[room_id].items():
@@ -376,468 +261,262 @@ async def broadcast_message(message, room_id):
             except websockets.ConnectionClosed:
                 disconnected.append(client_id)
         for client_id in disconnected:
-            del st.session_state.active_connections[room_id][client_id]
+            if client_id in st.session_state.active_connections[room_id]:
+                del st.session_state.active_connections[room_id][client_id]
 
-# Server starter - web spins up! 🖥️🌀
 async def run_websocket_server():
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🖥️🌀 - Server starter - web spins up!")
+    # 🖥️ Start WebSocket server
     if not st.session_state.server_running:
         server = await websockets.serve(websocket_handler, '0.0.0.0', 8765)
         st.session_state.server_running = True
         await server.wait_closed()
 
-# Voice processor - speech to text! 🎤📝
-async def process_voice_input(audio_bytes):
-    username = st.session_state.get('username', 'System 🌟')
-    await asyncio.to_thread(log_action, username, "🎤📝 - Voice processor - speech to text!")
-    if audio_bytes:
-        text = "Voice input simulation"
-        await save_chat_entry(username, text)
-
-# Dummy AI lookup function (replace with actual implementation)
-async def perform_ai_lookup(query, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False, useArxiv=True, useArxivAudio=False):
-    username = st.session_state.get('username', 'System 🌟')
-    result = f"AI Lookup Result for '{query}' (Arxiv: {useArxiv}, Audio: {useArxivAudio})"
-    await save_chat_entry(username, result)
-    if useArxivAudio:
-        audio_file = await async_edge_tts_generate(result, FUN_USERNAMES.get(username, "en-US-AriaNeural"))
-        if audio_file:
-            st.audio(audio_file)
-
-# Delete all user files function
-def delete_user_files():
-    protected_files = {'app.py', 'requirements.txt', 'README.md'}
-    deleted_files = []
-    
-    # Directories to clear
-    directories = [MEDIA_DIR, AUDIO_DIR, CHAT_DIR, VOTE_DIR, HISTORY_DIR]
-    
-    for directory in directories:
-        if os.path.exists(directory):
-            for root, _, files in os.walk(directory):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    if os.path.basename(file_path) not in protected_files:
-                        try:
-                            os.remove(file_path)
-                            deleted_files.append(file_path)
-                        except Exception as e:
-                            st.error(f"Failed to delete {file_path}: {e}")
-            # Remove empty directories
-            try:
-                shutil.rmtree(directory, ignore_errors=True)
-                os.makedirs(directory, exist_ok=True)  # Recreate empty directory
-            except Exception as e:
-                st.error(f"Failed to remove directory {directory}: {e}")
-    
-    # Clear session state caches
-    st.session_state.image_hashes.clear()
-    st.session_state.audio_cache.clear()
-    st.session_state.base64_cache.clear()
-    st.session_state.displayed_chat_lines.clear()
-    
-    return deleted_files
-
-# ASR Component HTML
-ASR_HTML = """
-<html>
-<head>
-    <title>Continuous Speech Demo</title>
-    <style>
-        body { 
-            font-family: sans-serif; 
-            padding: 20px; 
-            max-width: 800px;
-            margin: 0 auto;
-        }
-        button { 
-            padding: 10px 20px; 
-            margin: 10px 5px;
-            font-size: 16px;
-        }
-        #status { 
-            margin: 10px 0;
-            padding: 10px;
-            background: #e8f5e9;
-            border-radius: 4px;
-        }
-        #output {
-            white-space: pre-wrap;
-            padding: 15px;
-            background: #f5f5f5;
-            border-radius: 4px;
-            margin: 10px 0;
-            min-height: 100px;
-            max-height: 400px;
-            overflow-y: auto;
-        }
-        .controls {
-            margin: 10px 0;
-        }
-    </style>
-</head>
-<body>
-    <div class="controls">
-        <button id="start">Start Listening</button>
-        <button id="stop" disabled>Stop Listening</button>
-        <button id="clear">Clear Text</button>
-    </div>
-    <div id="status">Ready</div>
-    <div id="output"></div>
-    
-    <script>
-        if (!('webkitSpeechRecognition' in window)) {
-            alert('Speech recognition not supported');
-        } else {
-            const recognition = new webkitSpeechRecognition();
-            const startButton = document.getElementById('start');
-            const stopButton = document.getElementById('stop');
-            const clearButton = document.getElementById('clear');
-            const status = document.getElementById('status');
-            const output = document.getElementById('output');
-            let fullTranscript = '';
-            let lastUpdateTime = Date.now();
-
-            recognition.continuous = true;
-            recognition.interimResults = true;
-
-            const startRecognition = () => {
-                try {
-                    recognition.start();
-                    status.textContent = 'Listening...';
-                    startButton.disabled = true;
-                    stopButton.disabled = false;
-                } catch (e) {
-                    console.error(e);
-                    status.textContent = 'Error: ' + e.message;
-                }
-            };
-
-            window.addEventListener('load', () => {
-                setTimeout(startRecognition, 1000);
-            });
-
-            startButton.onclick = startRecognition;
-
-            stopButton.onclick = () => {
-                recognition.stop();
-                status.textContent = 'Stopped';
-                startButton.disabled = false;
-                stopButton.disabled = true;
-            };
-
-            clearButton.onclick = () => {
-                fullTranscript = '';
-                output.textContent = '';
-                sendDataToPython({value: '', dataType: "json"});
-            };
-
-            recognition.onresult = (event) => {
-                let interimTranscript = '';
-                let finalTranscript = '';
-
-                for (let i = event.resultIndex; i < event.results.length; i++) {
-                    const transcript = event.results[i][0].transcript;
-                    if (event.results[i].isFinal) {
-                        finalTranscript += transcript + '\\n';
-                    } else {
-                        interimTranscript += transcript;
-                    }
-                }
-
-                if (finalTranscript || (Date.now() - lastUpdateTime > 5000)) {
-                    if (finalTranscript) {
-                        fullTranscript += finalTranscript;
-                    }
-                    lastUpdateTime = Date.now();
-                    output.textContent = fullTranscript + (interimTranscript ? '... ' + interimTranscript : '');
-                    output.scrollTop = output.scrollHeight;
-                    sendDataToPython({value: fullTranscript, dataType: "json"});
-                }
-            };
-
-            recognition.onend = () => {
-                if (!stopButton.disabled) {
-                    try {
-                        recognition.start();
-                        console.log('Restarted recognition');
-                    } catch (e) {
-                        console.error('Failed to restart recognition:', e);
-                        status.textContent = 'Error restarting: ' + e.message;
-                        startButton.disabled = false;
-                        stopButton.disabled = true;
-                    }
-                }
-            };
-
-            recognition.onerror = (event) => {
-                console.error('Recognition error:', event.error);
-                status.textContent = 'Error: ' + event.error;
-                if (event.error === 'not-allowed' || event.error === 'service-not-allowed') {
-                    startButton.disabled = false;
-                    stopButton.disabled = true;
-                }
-            };
-        }
-
-        function sendDataToPython(data) {
-            window.parent.postMessage({
-                isStreamlitMessage: true,
-                type: "streamlit:setComponentValue",
-                ...data
-            }, "*");
-        }
-
-        window.addEventListener('load', function() {
-            window.setTimeout(function() {
-                window.parent.postMessage({
-                    isStreamlitMessage: true,
-                    type: "streamlit:setFrameHeight",
-                    height: document.documentElement.clientHeight
-                }, "*");
-            }, 0);
-        });
-    </script>
-</body>
-</html>
+# 📚 PDF to Audio
+class AudioProcessor:
+    def __init__(self):
+        self.cache_dir = AUDIO_CACHE_DIR
+        os.makedirs(self.cache_dir, exist_ok=True)
+        self.metadata = json.load(open(f"{self.cache_dir}/metadata.json")) if os.path.exists(f"{self.cache_dir}/metadata.json") else {}
+
+    def _save_metadata(self):
+        with open(f"{self.cache_dir}/metadata.json", 'w') as f: json.dump(self.metadata, f)
+
+    async def create_audio(self, text, voice='en-US-AriaNeural'):
+        # 🎶 Generate cached audio
+        cache_key = hashlib.md5(f"{text}:{voice}".encode()).hexdigest()
+        cache_path = f"{self.cache_dir}/{cache_key}.mp3"
+        if cache_key in self.metadata and os.path.exists(cache_path):
+            return open(cache_path, 'rb').read()
+        text = clean_text_for_tts(text)
+        if not text: return None
+        communicate = edge_tts.Communicate(text, voice)
+        await communicate.save(cache_path)
+        self.metadata[cache_key] = {'timestamp': datetime.now().isoformat(), 'text_length': len(text), 'voice': voice}
+        self._save_metadata()
+        return open(cache_path, 'rb').read()
+
+def process_pdf(pdf_file, max_pages, voice, audio_processor):
+    # 📄 Convert PDF to audio
+    reader = PdfReader(pdf_file)
+    total_pages = min(len(reader.pages), max_pages)
+    texts, audios = [], {}
+    async def process_page(i, text): audios[i] = await audio_processor.create_audio(text, voice)
+    for i in range(total_pages):
+        text = reader.pages[i].extract_text()
+        texts.append(text)
+        threading.Thread(target=lambda: asyncio.run(process_page(i, text))).start()
+    return texts, audios, total_pages
+
+# 🔍 ArXiv & AI Lookup
+def parse_arxiv_refs(ref_text):
+    # 📜 Parse ArXiv refs into dicts
+    if not ref_text: return []
+    papers = []
+    current = {}
+    for line in ref_text.split('\n'):
+        if line.count('|') == 2:
+            if current: papers.append(current)
+            date, title, *_ = line.strip('* ').split('|')
+            url = re.search(r'(https://arxiv.org/\S+)', line).group(1) if re.search(r'(https://arxiv.org/\S+)', line) else f"paper_{len(papers)}"
+            current = {'date': date, 'title': title, 'url': url, 'authors': '', 'summary': '', 'full_audio': None, 'download_base64': ''}
+        elif current:
+            if not current['authors']: current['authors'] = line.strip('* ')
+            else: current['summary'] += ' ' + line.strip() if current['summary'] else line.strip()
+    if current: papers.append(current)
+    return papers[:20]
+
+def generate_5min_feature_markdown(paper):
+    # ✨ 5-min research paper feature
+    title, summary, authors, date, url = paper['title'], paper['summary'], paper['authors'], paper['date'], paper['url']
+    pdf_url = url.replace("abs", "pdf") + (".pdf" if not url.endswith(".pdf") else "")
+    wct, sw = len(title.split()), len(summary.split())
+    terms = get_high_info_terms(summary, 15)
+    rouge = round((len(terms) / max(sw, 1)) * 100, 2)
+    mermaid = "```mermaid\nflowchart TD\n" + "\n".join(f'    T{i+1}["{t}"] --> T{i+2}["{terms[i+1]}"]' for i in range(len(terms)-1)) + "\n```"
+    return f"""
+## 📄 {title}
+**Authors:** {authors} | **Date:** {date} | **Words:** Title: {wct}, Summary: {sw}  
+**Links:** [Abstract]({url}) | [PDF]({pdf_url})  
+**Terms:** {', '.join(terms)} | **ROUGE:** {rouge}%  
+### 🎤 TTF Read Aloud
+- **Title:** {title} | **Terms:** {', '.join(terms)} | **ROUGE:** {rouge}%  
+#### Concepts Graph
+{mermaid}
+---
 """
 
-# Main execution - let’s roll! 🎲🚀
-def main():
-    NODE_NAME, port = get_node_name()
-
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-
-    async def async_interface():
-        if 'username' not in st.session_state:
-            chat_content = await load_chat()
-            available_names = [name for name in FUN_USERNAMES if not any(f"{name} has joined" in line for line in chat_content.split('\n'))]
-            st.session_state.username = random.choice(available_names) if available_names else random.choice(list(FUN_USERNAMES.keys()))
-            st.session_state.voice = FUN_USERNAMES[st.session_state.username]
-            st.markdown(f"**🎙️ Voice Selected**: {st.session_state.voice} 🗣️ for {st.session_state.username}")
-
-        st.title(f"🤖🧠MMO {st.session_state.username}📝🔬")
-        st.markdown(f"Welcome to {START_ROOM} - chat, vote, upload, paste images, and enjoy quoting! 🎉")
-
-        if not st.session_state.server_task:
-            st.session_state.server_task = loop.create_task(run_websocket_server())
-
-        audio_bytes = audio_recorder()
-        if audio_bytes:
-            await process_voice_input(audio_bytes)
-            st.rerun()
-
-        # Continuous Speech Input (ASR)
-        st.subheader("🎤 Continuous Speech Input")
-        asr_component = components.html(ASR_HTML, height=400)
-        if asr_component and isinstance(asr_component, dict) and 'value' in asr_component:
-            transcript = asr_component['value'].strip()
-            if transcript and transcript != st.session_state.last_transcript:
-                st.session_state.transcript_history.append(transcript)
-                await save_chat_entry(st.session_state.username, transcript, is_markdown=True)
-                st.session_state.last_transcript = transcript
-                st.rerun()
-
-        # Load and display chat
+def create_detailed_paper_md(papers): return "# Detailed Summary\n" + "\n".join(generate_5min_feature_markdown(p) for p in papers)
+
+async def create_paper_audio_files(papers, query):
+    # 🎧 Generate paper audio
+    for p in papers:
+        audio_text = clean_text_for_tts(f"{p['title']} by {p['authors']}. {p['summary']}")
+        p['full_audio'], _ = await async_edge_tts_generate(audio_text, st.session_state['tts_voice'], p['authors'])
+        if p['full_audio']: p['download_base64'] = get_download_link(p['full_audio'])
+
+async def perform_ai_lookup(q, useArxiv=True, useArxivAudio=False):
+    # 🔮 AI-powered research
+    client = anthropic.Anthropic(api_key=anthropic_key)
+    response = client.messages.create(model="claude-3-sonnet-20240229", max_tokens=1000, messages=[{"role": "user", "content": q}])
+    result = response.content[0].text
+    st.markdown("### Claude's Reply 🧠\n" + result)
+    md_file = create_file(q, result)
+    audio_file, _ = await async_edge_tts_generate(result, st.session_state['tts_voice'], "System")
+    play_and_download_audio(audio_file)
+
+    if useArxiv:
+        q += result
+        gradio_client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
+        refs = gradio_client.predict(q, 10, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1", api_name="/update_with_rag_md")[0]
+        result = f"🔎 {q}\n\n{refs}"
+        md_file, audio_file = create_file(q, result), (await async_edge_tts_generate(result, st.session_state['tts_voice'], "System"))[0]
+        play_and_download_audio(audio_file)
+        papers = parse_arxiv_refs(refs)
+        if papers and useArxivAudio: await create_paper_audio_files(papers, q)
+        return result, papers
+    return result, []
+
+# 📦 Zip Files
+def create_zip_of_files(md_files, mp3_files, query):
+    # 📦 Zip it up
+    all_files = md_files + mp3_files
+    if not all_files: return None
+    terms = get_high_info_terms(" ".join([open(f, 'r', encoding='utf-8').read() if f.endswith('.md') else os.path.splitext(os.path.basename(f))[0].replace('_', ' ') for f in all_files] + [query]), 5)
+    zip_name = f"{format_timestamp_prefix()}_{'-'.join(terms)[:20]}.zip"
+    with zipfile.ZipFile(zip_name, 'w') as z: [z.write(f) for f in all_files]
+    return zip_name
+
+# 🎮 Main Interface
+async def async_interface():
+    init_session_state()
+    load_mp3_viewer()  # Load MP3s at startup
+    if not st.session_state.username:
+        available = [n for n in FUN_USERNAMES if not any(f"{n} has joined" in l for l in (await load_chat()).split('\n'))]
+        st.session_state.username = random.choice(available or list(FUN_USERNAMES.keys()))
+        st.session_state.tts_voice = FUN_USERNAMES[st.session_state.username]
+        await save_chat_entry("System 🌟", f"{st.session_state.username} has joined {START_ROOM}!")
+
+    st.title(f"🤖🧠MMO Chat & Research for {st.session_state.username}📝🔬")
+    update_marquee_settings_ui()
+    display_marquee(f"🚀 Welcome to {START_ROOM} | 🤖 {st.session_state.username}", st.session_state['marquee_settings'], "welcome")
+
+    if not st.session_state.server_task:
+        st.session_state.server_task = asyncio.create_task(run_websocket_server())
+
+    tab_main = st.radio("Action:", ["🎤 Chat & Voice", "📸 Media", "🔍 ArXiv", "📚 PDF to Audio"], horizontal=True)
+    useArxiv, useArxivAudio = st.checkbox("Search ArXiv", True), st.checkbox("ArXiv Audio", False)
+    st.session_state.autosend = st.checkbox("Autosend Chat", value=True)
+    st.session_state.autosearch = st.checkbox("Autosearch ArXiv", value=True)
+
+    # 🎤 Chat & Voice
+    if tab_main == "🎤 Chat & Voice":
         st.subheader(f"{START_ROOM} Chat 💬")
         chat_content = await load_chat()
-        chat_lines = chat_content.split('\n')
-        chat_votes = await load_votes(QUOTE_VOTES_FILE)
-
-        current_time = time.time()
-        if current_time - st.session_state.last_chat_update > 1 or not st.session_state.displayed_chat_lines:
-            new_lines = [line for line in chat_lines if line.strip() and ': ' in line and line not in st.session_state.displayed_chat_lines and not line.startswith('#')]
-            st.session_state.displayed_chat_lines.extend(new_lines)
-            st.session_state.last_chat_update = current_time
-
-        for i, line in enumerate(st.session_state.displayed_chat_lines):
-            col1, col2, col3, col4 = st.columns([3, 1, 1, 2])
-            with col1:
-                if "```markdown" in line:
-                    markdown_content = re.search(r'```markdown\n(.*?)```', line, re.DOTALL)
-                    if markdown_content:
-                        st.markdown(markdown_content.group(1))
-                    else:
-                        st.markdown(line)
-                else:
+        chat_container = st.container()
+        with chat_container:
+            lines = chat_content.split('\n')
+            for i, line in enumerate(lines):
+                if line.strip():
                     st.markdown(line)
-                if "Pasted image:" in line or "Uploaded media:" in line:
-                    file_path = line.split(': ')[-1].strip()
-                    if os.path.exists(file_path):
-                        if file_path not in st.session_state.base64_cache:
-                            with open(file_path, "rb") as f:
-                                b64 = base64.b64encode(f.read()).decode()
-                            st.session_state.base64_cache[file_path] = b64
-                        b64 = st.session_state.base64_cache[file_path]
-                        mime_type = "image/png" if file_path.endswith(('.png', '.jpg')) else "video/mp4" if file_path.endswith('.mp4') else "audio/mpeg"
-                        if file_path.endswith(('.png', '.jpg')):
-                            st.image(file_path, use_container_width=True)
-                            dl_link = f'<a href="data:{mime_type};base64,{b64}" download="{os.path.basename(file_path)}">📥 Download {os.path.basename(file_path)}</a>'
-                            st.markdown(dl_link, unsafe_allow_html=True)
-                        elif file_path.endswith('.mp4'):
-                            st.markdown(await get_video_html(file_path), unsafe_allow_html=True)
-                            dl_link = f'<a href="data:{mime_type};base64,{b64}" download="{os.path.basename(file_path)}">📥 Download {os.path.basename(file_path)}</a>'
-                            st.markdown(dl_link, unsafe_allow_html=True)
-                        elif file_path.endswith('.mp3'):
-                            st.markdown(await get_audio_html(file_path), unsafe_allow_html=True)
-                            dl_link = f'<a href="data:{mime_type};base64,{b64}" download="{os.path.basename(file_path)}">📥 Download {os.path.basename(file_path)}</a>'
-                            st.markdown(dl_link, unsafe_allow_html=True)
-            with col2:
-                vote_count = chat_votes.get(line.split('. ')[1] if '. ' in line else line, 0)
-                if st.button(f"👍 {vote_count}", key=f"chat_vote_{i}"):
-                    comment = st.session_state.message_text
-                    await save_vote(QUOTE_VOTES_FILE, line.split('. ')[1] if '. ' in line else line, await generate_user_hash(), st.session_state.username, comment)
-                    st.session_state.message_text = ''
-                    st.rerun()
-            with col3:
-                if st.button("📢 Quote", key=f"quote_{i}"):
-                    st.session_state.quote_line = line
-                    st.rerun()
-            with col4:
-                username = line.split(': ')[1].split(' ')[0]
-                cache_key = f"{line}_{FUN_USERNAMES.get(username, 'en-US-AriaNeural')}"
-                if cache_key not in st.session_state.audio_cache:
-                    cleaned_text = clean_text_for_tts(line.split(': ', 1)[1])
-                    audio_file = await async_edge_tts_generate(cleaned_text, FUN_USERNAMES.get(username, "en-US-AriaNeural"))
-                    st.session_state.audio_cache[cache_key] = audio_file
-                audio_file = st.session_state.audio_cache.get(cache_key)
-                if audio_file:
-                    play_and_download_audio(audio_file)
-
-        if st.session_state.quote_line:
-            st.markdown(f"### Quoting: {st.session_state.quote_line}")
-            quote_response = st.text_area("Add your response", key="quote_response", value=st.session_state.message_text)
-            paste_result_quote = paste_image_button("📋 Paste Image or Text with Quote", key="paste_button_quote")
-            if paste_result_quote.image_data is not None:
-                if isinstance(paste_result_quote.image_data, str):
-                    st.session_state.message_text = paste_result_quote.image_data
-                    st.text_area("Add your response", key="quote_response", value=st.session_state.message_text)
-                else:
-                    st.image(paste_result_quote.image_data, caption="Received Image for Quote")
-                    filename = await save_pasted_image(paste_result_quote.image_data, st.session_state.username)
-                    if filename:
-                        st.session_state.pasted_image_data = filename
-            if st.button("Send Quote 🚀", key="send_quote"):
-                markdown_response = f"### Quote Response\n- **Original**: {st.session_state.quote_line}\n- **{st.session_state.username} Replies**: {quote_response}"
-                if st.session_state.pasted_image_data:
-                    markdown_response += f"\n- **Image**: ![Pasted Image]({st.session_state.pasted_image_data})"
-                    await save_chat_entry(st.session_state.username, f"Pasted image: {st.session_state.pasted_image_data}")
-                    st.session_state.pasted_image_data = None
-                await save_chat_entry(st.session_state.username, markdown_response, is_markdown=True)
-                st.session_state.quote_line = None
-                st.session_state.message_text = ''
+                    # Match MP3 to line by timestamp and username
+                    for mp3_name, mp3_path in st.session_state['mp3_files'].items():
+                        if line.strip() in mp3_name and st.session_state.username in mp3_name:
+                            st.audio(mp3_path, key=f"audio_{i}_{mp3_name}")
+                            break
+        
+        message = st.text_input(f"Message as {st.session_state.username}", key="message_input")
+        if message and message != st.session_state.last_message:
+            st.session_state.last_message = message
+            if st.session_state.autosend or st.button("Send 🚀"):
+                await save_chat_entry(st.session_state.username, message, True)
                 st.rerun()
 
-        current_selection = st.session_state.username if st.session_state.username in FUN_USERNAMES else ""
-        new_username = st.selectbox("Change Name and Voice", [""] + list(FUN_USERNAMES.keys()), index=(list(FUN_USERNAMES.keys()).index(current_selection) + 1 if current_selection else 0), format_func=lambda x: f"{x} ({FUN_USERNAMES.get(x, 'No Voice')})" if x else "Select a name")
-        if new_username and new_username != st.session_state.username:
-            await save_chat_entry("System 🌟", f"{st.session_state.username} changed name to {new_username}")
-            st.session_state.username = new_username
-            st.session_state.voice = FUN_USERNAMES[new_username]
-            st.markdown(f"**🎙️ Voice Changed**: {st.session_state.voice} 🗣️ for {st.session_state.username}")
-            st.rerun()
-
-        message = st.text_input(f"Message as {st.session_state.username} (Voice: {st.session_state.voice})", key="message_input", value=st.session_state.message_text)
-        paste_result_msg = paste_image_button("📋 Paste Image or Text with Message", key="paste_button_msg")
-        if paste_result_msg.image_data is not None:
-            if isinstance(paste_result_msg.image_data, str):
-                st.session_state.message_text = paste_result_msg.image_data
-                st.text_input(f"Message as {st.session_state.username} (Voice: {st.session_state.voice})", key="message_input_paste", value=st.session_state.message_text)
-            else:
-                st.image(paste_result_msg.image_data, caption="Received Image for Message")
-                filename = await save_pasted_image(paste_result_msg.image_data, st.session_state.username)
-                if filename:
-                    st.session_state.pasted_image_data = filename
-        if st.button("Send 🚀", key="send_button") and (message.strip() or st.session_state.pasted_image_data):
-            if message.strip():
-                audio_file = await save_chat_entry(st.session_state.username, message, is_markdown=True)
-                if audio_file:
-                    st.session_state.audio_cache[f"{message}_{FUN_USERNAMES[st.session_state.username]}"] = audio_file
-            if st.session_state.pasted_image_data:
-                await save_chat_entry(st.session_state.username, f"Pasted image: {st.session_state.pasted_image_data}")
-                st.session_state.pasted_image_data = None
-            st.session_state.message_text = ''
-            st.rerun()
+        st.subheader("🎤 Speech-to-Chat")
+        speech_component = components.declare_component("speech_component", path="mycomponent")
+        transcript_data = speech_component(default_value=st.session_state.get('last_transcript', ''))
+        if transcript_data and 'value' in transcript_data:
+            transcript = transcript_data['value'].strip()
+            st.write(f"🎙️ You said: {transcript}")
+            if transcript and transcript != st.session_state.last_transcript:
+                st.session_state.last_transcript = transcript
+                if st.session_state.autosend:
+                    await save_chat_entry(st.session_state.username, transcript, True)
+                    st.rerun()
+                elif st.button("Send to Chat"):
+                    await save_chat_entry(st.session_state.username, transcript, True)
+                    st.rerun()
 
-        tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], horizontal=True)
-        useArxiv = st.checkbox("Search Arxiv for Research Paper Answers", value=True)
-        useArxivAudio = st.checkbox("Generate Audio File for Research Paper Answers", value=False)
+    # 📸 Media
+    elif tab_main == "📸 Media":
+        st.header("📸 Media Gallery")
+        tabs = st.tabs(["🎵 Audio", "🖼 Images", "🎥 Video"])
+        with tabs[0]:
+            for a in glob.glob(f"{MEDIA_DIR}/*.mp3"):
+                with st.expander(os.path.basename(a)): play_and_download_audio(a)
+        with tabs[1]:
+            imgs = glob.glob(f"{MEDIA_DIR}/*.png") + glob.glob(f"{MEDIA_DIR}/*.jpg")
+            if imgs:
+                cols = st.columns(3)
+                for i, f in enumerate(imgs): cols[i % 3].image(f, use_container_width=True)
+        with tabs[2]:
+            for v in glob.glob(f"{MEDIA_DIR}/*.mp4"):
+                with st.expander(os.path.basename(v)): st.video(v)
 
-        st.subheader("Upload Media 🎨🎶🎥")
         uploaded_file = st.file_uploader("Upload Media", type=['png', 'jpg', 'mp4', 'mp3'])
         if uploaded_file:
-            timestamp = format_timestamp_prefix(st.session_state.username)
-            username = st.session_state.username
-            ext = uploaded_file.name.split('.')[-1]
-            file_hash = hashlib.md5(uploaded_file.getbuffer()).hexdigest()[:8]
-            if file_hash not in st.session_state.image_hashes:
-                filename = f"{timestamp}-{file_hash}.{ext}"
-                file_path = os.path.join(MEDIA_DIR, filename)
-                await asyncio.to_thread(lambda: open(file_path, 'wb').write(uploaded_file.getbuffer()))
-                st.success(f"Uploaded {filename}")
-                await save_chat_entry(username, f"Uploaded media: {file_path}")
-                st.session_state.image_hashes.add(file_hash)
-                if file_path.endswith('.mp4'):
-                    st.session_state.media_notifications.append(file_path)
-
-        # Big Red Delete Button
-        st.subheader("🛑 Danger Zone")
-        if st.button("Try Not To Delete It All On Your First Day", key="delete_all", help="Deletes all user-added files!", type="primary", use_container_width=True):
-            deleted_files = delete_user_files()
-            if deleted_files:
-                st.markdown("### 🗑️ Deleted Files:\n" + "\n".join([f"- `{file}`" for file in deleted_files]))
-            else:
-                st.markdown("### 🗑️ Nothing to Delete!")
-            st.session_state.image_hashes.clear()
-            st.session_state.audio_cache.clear()
-            st.session_state.base64_cache.clear()
-            st.session_state.displayed_chat_lines.clear()
+            filename = f"{format_timestamp_prefix(st.session_state.username)}-{hashlib.md5(uploaded_file.getbuffer()).hexdigest()[:8]}.{uploaded_file.name.split('.')[-1]}"
+            with open(f"{MEDIA_DIR}/{filename}", 'wb') as f: f.write(uploaded_file.getbuffer())
+            await save_chat_entry(st.session_state.username, f"Uploaded: {filename}")
             st.rerun()
 
-        st.subheader("Media Gallery 🎨🎶🎥")
-        media_files = glob.glob(f"{MEDIA_DIR}/*.png") + glob.glob(f"{MEDIA_DIR}/*.jpg") + glob.glob(f"{MEDIA_DIR}/*.mp4") + glob.glob(f"{MEDIA_DIR}/*.mp3")
-        if media_files:
-            media_votes = await load_votes(MEDIA_VOTES_FILE)
-            st.write("### All Media Uploads")
-            seen_files = set()
-            for media_file in sorted(media_files, key=os.path.getmtime, reverse=True):
-                if media_file not in seen_files:
-                    seen_files.add(media_file)
-                    filename = os.path.basename(media_file)
-                    vote_count = media_votes.get(media_file, 0)
-                    col1, col2 = st.columns([3, 1])
-                    with col1:
-                        st.markdown(f"**{filename}**")
-                        if media_file.endswith(('.png', '.jpg')):
-                            st.image(media_file, use_container_width=True)
-                        elif media_file.endswith('.mp4'):
-                            st.markdown(await get_video_html(media_file), unsafe_allow_html=True)
-                        elif media_file.endswith('.mp3'):
-                            st.markdown(await get_audio_html(media_file), unsafe_allow_html=True)
-                    with col2:
-                        if st.button(f"👍 {vote_count}", key=f"media_vote_{media_file}"):
-                            await save_vote(MEDIA_VOTES_FILE, media_file, await generate_user_hash(), st.session_state.username)
-                            st.rerun()
-
-        st.subheader("Refresh ⏳")
-        refresh_rate = st.slider("Refresh Rate", 1, 300, st.session_state.refresh_rate)
-        st.session_state.refresh_rate = refresh_rate
-        timer_placeholder = st.empty()
-        for i in range(st.session_state.refresh_rate, -1, -1):
-            font_name, font_func = random.choice(UNICODE_FONTS)
-            countdown_str = "".join(UNICODE_DIGITS[int(d)] for d in str(i)) if i < 10 else font_func(str(i))
-            timer_placeholder.markdown(f"<p class='timer'>⏳ {font_func('Refresh in:')} {countdown_str}</p>", unsafe_allow_html=True)
-            time.sleep(1)
+    # 🔍 ArXiv
+    elif tab_main == "🔍 ArXiv":
+        q = st.text_input("🔍 Query:", key="arxiv_query")
+        if q and q != st.session_state.last_query:
+            st.session_state.last_query = q
+            if st.session_state.autosearch or st.button("🔍 Run"):
+                result, papers = await perform_ai_lookup(q, useArxiv, useArxivAudio)
+                for i, p in enumerate(papers, 1):
+                    with st.expander(f"{i}. 📄 {p['title']}"):
+                        st.markdown(f"**{p['date']} | {p['title']}** — [Link]({p['url']})")
+                        st.markdown(generate_5min_feature_markdown(p))
+                        if p.get('full_audio'): play_and_download_audio(p['full_audio'])
+
+    # 📚 PDF to Audio
+    elif tab_main == "📚 PDF to Audio":
+        audio_processor = AudioProcessor()
+        pdf_file = st.file_uploader("Choose PDF", "pdf")
+        max_pages = st.slider('Pages', 1, 100, 10)
+        if pdf_file:
+            with st.spinner('Processing...'):
+                texts, audios, total = process_pdf(pdf_file, max_pages, st.session_state['tts_voice'], audio_processor)
+                for i, text in enumerate(texts):
+                    with st.expander(f"Page {i+1}"):
+                        st.markdown(text)
+                        while i not in audios: time.sleep(0.1)
+                        if audios[i]:
+                            st.audio(audios[i], format='audio/mp3')
+                            st.markdown(get_download_link(io.BytesIO(audios[i]), "mp3"), unsafe_allow_html=True)
+
+    # 🗂️ Sidebar
+    st.sidebar.subheader("Voice Settings")
+    new_username = st.sidebar.selectbox("Change Name/Voice", list(FUN_USERNAMES.keys()), index=list(FUN_USERNAMES.keys()).index(st.session_state.username))
+    if new_username != st.session_state.username:
+        await save_chat_entry("System 🌟", f"{st.session_state.username} changed to {new_username}")
+        st.session_state.username, st.session_state.tts_voice = new_username, FUN_USERNAMES[new_username]
         st.rerun()
 
-        st.sidebar.subheader("Chat History 📜")
-        with open(HISTORY_FILE, 'r') as f:
-            history_content = f.read()
-        st.sidebar.markdown(history_content)
+    md_files, mp3_files = glob.glob("*.md"), glob.glob(f"{AUDIO_DIR}/*.mp3")
+    st.sidebar.markdown("### 📂 File History")
+    for f in sorted(md_files + mp3_files, key=os.path.getmtime, reverse=True)[:10]:
+        st.sidebar.write(f"{FILE_EMOJIS.get(f.split('.')[-1], '📄')} {os.path.basename(f)}")
+    if st.sidebar.button("⬇️ Zip All"):
+        zip_name = create_zip_of_files(md_files, mp3_files, "latest_query")
+        if zip_name: st.sidebar.markdown(get_download_link(zip_name, "zip"), unsafe_allow_html=True)
 
-    loop.run_until_complete(async_interface())
+def main():
+    # 🎉 Kick it off
+    asyncio.run(async_interface())
 
 if __name__ == "__main__":
     main()