Update app.py

app.py

@@ -14,23 +14,21 @@ import base64
 import io
 import streamlit.components.v1 as components
 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
-from urllib.parse import urlencode
-from PyPDF2 import PdfReader
-import json
 
-# Patch for nested async - sneaky fix, a loop’s heroic mix, in Streamlit’s nix! 🐍✨
+# Patch for nested async - sneaky fix! 🐍✨
 nest_asyncio.apply()
 
-# Static config - constants rule, a cosmic tool, our saga’s jewel, in shared school! 📏👑
+# Static config - constants rule! 📏👑
 icons = '🤖🧠🔬📝'
 START_ROOM = "Sector 🌌"
 
-# Page setup - dressing up with flair, a UI so rare, in Streamlit’s glare, in shared air! 🖼️🎀
+# Page setup - dressing up the window! 🖼️🎀
 st.set_page_config(
     page_title="🤖🧠MMO Chat Brain📝🔬",
     page_icon=icons,
@@ -38,7 +36,7 @@ st.set_page_config(
     initial_sidebar_state="auto"
 )
 
-# Funky usernames with voices - a cosmic cast, shared memory’s blast, in shared past! 🌌🎭
+# Funky usernames - who’s who in the zoo with unique voices! 🎭🐾🎙️
 FUN_USERNAMES = {
     "CosmicJester 🌌": "en-US-AriaNeural",
     "PixelPanda 🐼": "en-US-JennyNeural",
@@ -62,21 +60,28 @@ FUN_USERNAMES = {
     "ChronoChimp 🐒": "en-GB-LibbyNeural"
 }
 
-# Top-level files and directories - the treasure trove, shared memory’s grove, in shared cove! 🗺️📜
-CHAT_FILE = "global_chat.md"
-QUOTE_VOTES_FILE = "quote_votes.md"
-MEDIA_VOTES_FILE = "media_votes.md"
-HISTORY_FILE = "chat_history.md"
+# 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"
 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)
 
-# Fancy digits - numbers dance, in shared cache, a numeric trance, in shared glance! 🔢💃
+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’s spree, in shared cache, a scribe’s decree, in shared sea! 🖋️🎨
+# 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)),
@@ -99,7 +104,7 @@ UNICODE_FONTS = [
     ("Regional Indicator", lambda x: "".join(chr(ord(c) - 0x41 + 0x1F1E6) if 'A' <= c <= 'Z' else c for c in x)),
 ]
 
-# Global state - keeping tabs, a shared saga’s grab, in Streamlit’s crab! 🌍📋 – epic memory’s lab!
+# 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:
@@ -112,6 +117,10 @@ 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:
@@ -124,22 +133,20 @@ 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()
-if 'gallery_columns' not in st.session_state:
-    st.session_state.gallery_columns = 1
-if 'user_id' not in st.session_state:
-    st.session_state.user_id = None
-if 'user_hash' not in st.session_state:
-    st.session_state.user_hash = None
-
-# Timestamp wizardry - clock ticks with flair, a temporal affair, in shared air, in Streamlit’s lair! ⏰🎩
+
+# Timestamp wizardry - clock ticks with flair! ⏰🎩
 def format_timestamp_prefix(username):
     central = pytz.timezone('US/Central')
     now = datetime.now(central)
-    return f"{username}-{now.strftime('%I-%M-%p-%m-%d-%Y')}-{st.session_state.user_id}"
+    return f"{now.strftime('%I-%M-%p-ct-%m-%d-%Y')}-by-{username}"
 
-# Compute image hash - a cryptographic clash, securing our flash, in shared dash, in Streamlit’s sash! 🛡️🔍
+# Compute image hash from binary data
 def compute_image_hash(image_data):
     if isinstance(image_data, Image.Image):
         img_byte_arr = io.BytesIO()
@@ -149,7 +156,7 @@ def compute_image_hash(image_data):
         img_bytes = image_data
     return hashlib.md5(img_bytes).hexdigest()[:8]
 
-# Node naming - christening the beast, a heroic feast, in shared yeast, in Streamlit’s east! 🌐🍼
+# 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)
@@ -159,7 +166,7 @@ def get_node_name():
     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, a stealthy steed, in shared need, in Streamlit’s seed! 🕵️📜
+# Action logger - spying on deeds! 🕵️📜
 def log_action(username, action):
     if 'action_log' not in st.session_state:
         st.session_state.action_log = {}
@@ -173,206 +180,34 @@ def log_action(username, action):
             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 fluff, a scribe’s tough bluff, in shared puff, in Streamlit’s cuff! 🧹📝
+# Clean text - strip the fancy stuff! 🧹📝
 def clean_text_for_tts(text):
     cleaned = re.sub(r'[#*!\[\]]+', '', text)
     cleaned = ' '.join(cleaned.split())
-    return cleaned if cleaned else "No text to speak"  # Default if empty
-
-# Shared Memory Cache - the epic vault, a shared memory assault, in Streamlit’s fault, in sync’s assault! 🗳️💾
-@st.cache_resource
-def get_shared_memory():
-    """
-    Oh, the cache, a grand, shared hall, where data dances, never to fall!
-    Thread-safe and global, it holds our lore, across users and sessions, forevermore, in Streamlit’s core! 🌍🧙
-    """
-    class SharedMemory:
-        def __init__(self):
-            self.chat_history = []  # Condensed dialogs, epic tales condensed, in sync intense!
-            self.media_files = []  # Media treasures, shared with flair and bends, in sync’s blends!
-            self.cache_time = datetime.now()  # Timestamp of glory, a hero’s blend, in sync’s trend!
-
-        def update_chat(self, entry):
-            """Add a chat entry, a rhyme in the stream, keeping our saga supreme, in sync’s dream, in Streamlit’s beam! 💬🎶"""
-            self.chat_history.append(entry)
-            if len(self.chat_history) > 100:  # Limit to keep it tight, a knight’s fight, in sync’s light!
-                self.chat_history.pop(0)
-
-        def update_media(self, media_path):
-            """Store media files, a visual dream, in our shared cache, a radiant beam, in sync’s gleam, in Streamlit’s stream! 🖼️🌟"""
-            self.media_files.append(media_path)
-            if len(self.media_files) > 50:  # Cap the hoard, lest it grow too wide, in sync’s tide!
-                self.media_files.pop(0)
-
-        def get_condensed_dialogs(self):
-            """Condense the chatter, a poetic pact, short and sweet, our story intact, in sync’s act, in Streamlit’s tract! 🗣️✨"""
-            return "\n".join(f"- {entry.split(': ')[1][:50]}" for entry in self.chat_history[-10:])
-
-        def clear(self):
-            """Clear the cache, a dramatic purge, resetting our tale, a new surge, in sync’s urge, in Streamlit’s surge! 🌀🔥"""
-            self.chat_history.clear()
-            self.media_files.clear()
-            self.cache_time = datetime.now()
-
-    return SharedMemory()
-
-# Audio Processor Class - voices echo, a sonic hero, in shared zero, in Streamlit’s hero! 🎶🌟
-class AudioProcessor:
-    def __init__(self):
-        self.cache_dir = AUDIO_DIR
-        os.makedirs(self.cache_dir, exist_ok=True)
-        self.metadata = self._load_metadata()
-
-    def _load_metadata(self):
-        metadata_file = os.path.join(self.cache_dir, "metadata.json")
-        return json.load(open(metadata_file)) if os.path.exists(metadata_file) else {}
-
-    def _save_metadata(self):
-        metadata_file = os.path.join(self.cache_dir, "metadata.json")
-        with open(metadata_file, 'w') as f:
-            json.dump(self.metadata, f)
-
-    async def create_audio(self, text, voice='en-US-AriaNeural', filename=None):
-        """
-        Create audio, a voice that roars, in our shared cache, through cosmic doors, in sync’s shores, in Streamlit’s roars! 🎤🌌
-        """
-        cache_key = hashlib.md5(f"{text}:{voice}".encode()).hexdigest()
-        timestamp = format_timestamp_prefix(st.session_state.username)
-        filename = filename or os.path.join(self.cache_dir, f"audio_{timestamp}_{random.randint(1000, 9999)}.mp3")
-
-        if cache_key in self.metadata and os.path.exists(filename):
-            return filename
-
-        # Clean text for speech, a bard’s clean sweep, in sync’s deep, in Streamlit’s keep!
-        text = text.replace("\n", " ").replace("</s>", " ").strip()
-        if not text:
-            return None
-
-        # Generate audio, a sonic leap, with edge_tts, our voices deep, in sync’s heap, in Streamlit’s leap!
-        try:
-            communicate = edge_tts.Communicate(text, voice)
-            await communicate.save(filename)
-            if not os.path.exists(filename):
-                raise edge_tts.exceptions.NoAudioReceived("No audio file created")
-        except edge_tts.exceptions.NoAudioReceived as e:
-            log_action("System 🌟", f"TTS failed for text '{text}' with voice '{voice}': {str(e)}")
-            return None
-
-        # Update metadata, our epic creed, in shared memory, a heroic deed, in sync’s need, in Streamlit’s deed!
-        self.metadata[cache_key] = {
-            'timestamp': datetime.now().isoformat(),
-            'text_length': len(text),
-            'voice': voice
-        }
-        self._save_metadata()
-
-        return filename
+    return cleaned[:200] if cleaned else "No text to speak"
 
-# Chat saver - words locked tight, in shared memory’s light, a shared fight, in Streamlit’s sight! 💬🔒
-async def save_chat_entry(username, message, is_markdown=False, quote_line=None, media_file=None, skip_audio=False):
-    """
-    Save chats with flair, in shared cache we dare, a rhyming affair, in sync’s air, in Streamlit’s stare! ✨🎉
-    """
+# Chat saver - words locked tight! 💬🔒
+async def save_chat_entry(username, message, is_markdown=False):
+    await asyncio.to_thread(log_action, username, "💬🔒 - Chat saver - words locked tight!")
     central = pytz.timezone('US/Central')
     timestamp = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
-    user_history_file = f"{username}_history.md"
-    voice = st.session_state.voice if username == st.session_state.username else FUN_USERNAMES.get(username, "en-US-AriaNeural")
-    indent = "  " if quote_line else ""  # Nesting for replies, a poetic spree, in sync’s tree!
-
-    # Prepare entry, a verse so bright, in shared memory’s sight, a shared delight, in Streamlit’s light!
     if is_markdown:
-        entry = f"{indent}[{timestamp}] {username}:\n{indent}```markdown\n{indent}{message}\n{indent}```"
+        entry = f"[{timestamp}] {username}:\n```markdown\n{message}\n```"
     else:
-        entry = f"{indent}[{timestamp}] {username}: {message}"
-    if quote_line:
-        entry = f"{indent}> {quote_line}\n{entry}"
-
-    # Save to global chat file, a shared epic tale, never frail, in sync’s gale, in Streamlit’s veil!
-    with open(CHAT_FILE, 'a') as f:
-        f.write(f"{entry}\n")
-
-    # Save to user-specific history, a personal rhyme, in shared time, a shared chime, in Streamlit’s chime!
-    if not os.path.exists(user_history_file):
-        with open(user_history_file, 'w') as f:
-            f.write(f"# Chat History for {username} (Voice: {voice})\n\n")
-    with open(user_history_file, 'a') as f:
-        f.write(f"{entry}\n")
-
-    # Generate audio, unless we skip, in shared cache, a sonic grip, in sync’s rip, in Streamlit’s slip!
-    audio_filename = None  # Initialize, lest our tale derail, in sync’s veil, in Streamlit’s trail!
-    if not skip_audio and message.strip():
-        cleaned_message = clean_text_for_tts(message)
-        audio_processor = AudioProcessor()
-        audio_filename = await audio_processor.create_audio(cleaned_message, voice)
-        if audio_filename:
-            with open(HISTORY_FILE, 'a') as f:
-                f.write(f"[{timestamp}] {username} ({voice}): Audio generated - {audio_filename}\n")
-            with open(user_history_file, 'a') as f:
-                f.write(f"{indent}[{timestamp}] Audio: {audio_filename}\n")
-            with open(CHAT_FILE, 'a') as f:
-                f.write(f"{indent}[{timestamp}] Audio: {audio_filename}\n")
-
-    # Handle media files, a visual quest, in shared memory, our treasure chest, in sync’s zest, in Streamlit’s nest!
-    if media_file:
-        if isinstance(media_file, Image.Image):
-            timestamp_prefix = format_timestamp_prefix(username)
-            media_filename = f"{username}-{timestamp_prefix.split('-')[-1]}.{media_file.format.lower()}"
-            media_path = os.path.join(MEDIA_DIR, media_filename)
-            img_byte_arr = io.BytesIO()
-            media_file.save(img_byte_arr, format=media_file.format)
-            await asyncio.to_thread(lambda: open(media_path, 'wb').write(img_byte_arr.getvalue()))
-            media_file = media_filename
-        elif media_file.name in ['png', 'jpg', 'mp4', 'mp3', 'wav']:
-            timestamp_prefix = format_timestamp_prefix(username)
-            media_filename = f"{username}-{timestamp_prefix.split('-')[-1]}.{media_file.name.split('.')[-1]}"
-            media_path = os.path.join(MEDIA_DIR, media_filename)
-            await asyncio.to_thread(lambda: open(media_path, 'wb').write(media_file.getbuffer()))
-            media_file = media_filename
-        elif media_file.name == 'pdf':
-            timestamp_prefix = format_timestamp_prefix(username)
-            file_hash = hashlib.md5(media_file.getbuffer()).hexdigest()[:8]
-            media_filename = f"{username}-{timestamp_prefix.split('-')[-1]}-{file_hash}.pdf"
-            media_path = os.path.join(MEDIA_DIR, media_filename)
-            await asyncio.to_thread(lambda: open(media_path, 'wb').write(media_file.getbuffer()))
-            media_file = media_filename
-        with open(CHAT_FILE, 'a') as f:
-            f.write(f"{indent}[{timestamp}] Media: ![Media]({media_file})\n")
-        with open(user_history_file, 'a') as f:
-            f.write(f"{indent}[{timestamp}] Media: ![Media]({media_file})\n")
-
-    # Update shared memory, our epic lore, in cache forevermore, in sync’s core, in Streamlit’s lore!
-    shared_memory = get_shared_memory()
-    shared_memory.update_chat(entry)
-    if media_file:
-        shared_memory.update_media(os.path.join(MEDIA_DIR, media_file))
-
+        entry = f"[{timestamp}] {username}: {message}"
+    await asyncio.to_thread(lambda: open(CHAT_FILE, 'a').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)
+    if audio_file:
+        with open(HISTORY_FILE, 'a') as f:
+            f.write(f"[{timestamp}] {username}: Audio generated - {audio_file}\n")
     await broadcast_message(f"{username}|{message}", "chat")
     st.session_state.last_chat_update = time.time()
-    return audio_filename  # Return, even if silent, our tale’s delight, in sync’s flight, in Streamlit’s sight!
+    return audio_file
 
-# Save chat history with image or PDF - a scribe’s historic flight, in shared night, in Streamlit’s light! 📜🚀
-async def save_chat_history_with_image(username, image_path):
-    """
-    Save history, a scribe’s grand sight, in shared memory, pure and bright, in sync’s light, in Streamlit’s right! ✨📖
-    """
-    central = pytz.timezone('US/Central')
-    timestamp = datetime.now(central).strftime("%Y-%m-%d_%H-%M-%S")
-    user_history_file = f"{username}_history.md"
-    chat_content = await load_chat()
-    voice = st.session_state.voice if username == st.session_state.username else FUN_USERNAMES.get(username, "en-US-AriaNeural")
-    if not os.path.exists(user_history_file):
-        with open(user_history_file, 'w') as f:
-            f.write(f"# Chat History for {username} (Voice: {voice})\n\n")
-    with open(user_history_file, 'a') as f:
-        f.write(f"[{timestamp}] {username} (Voice: {voice}) Shared Media: {os.path.basename(image_path)}\n")
-        f.write(f"```markdown\n{chat_content}\n```\n")
-
-# Chat loader - history unleashed, a shared epic feast, in shared beast, in Streamlit’s east! 📜🚀
-@st.cache_resource
+# Chat loader - history unleashed! 📜🚀
 async def load_chat():
-    """
-    Load chats, a shared memory spree, from cache with glee, our history free, in sync’s sea, in Streamlit’s tree! 🌟💬
-    """
     username = st.session_state.get('username', 'System 🌟')
     await asyncio.to_thread(log_action, username, "📜🚀 - Chat loader - history unleashed!")
     if not os.path.exists(CHAT_FILE):
@@ -381,11 +216,8 @@ async def load_chat():
         content = await asyncio.to_thread(f.read)
     return content
 
-# User lister - who’s in the gang, a shared memory bang, in shared rang, in Streamlit’s gang! 👥🎉
+# User lister - who’s in the gang! 👥🎉
 async def get_user_list(chat_content):
-    """
-    List users, a shared roster’s rhyme, in cache divine, through space and time, in sync’s chime, in Streamlit’s time! 🌍🎭
-    """
     username = st.session_state.get('username', 'System 🌟')
     await asyncio.to_thread(log_action, username, "👥🎉 - User lister - who’s in the gang!")
     users = set()
@@ -395,32 +227,22 @@ async def get_user_list(chat_content):
             users.add(user)
     return sorted(list(users))
 
-# Join checker - been here before, in shared cache, a lore galore, in shared shore, in Streamlit’s lore! 🚪🔍
+# Join checker - been here before? 🚪🔍
 async def has_joined_before(client_id, chat_content):
-    """
-    Check joins, a shared memory chore, in cache secure, forevermore, in sync’s lore, in Streamlit’s core! 🌀🔐
-    """
     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, in shared cache, a verse so fierce, in shared pierce, in Streamlit’s fierce! 💡📝
+# Suggestion maker - old quips resurface! 💡📝
 async def get_message_suggestions(chat_content, prefix):
-    """
-    Suggest quips, a shared memory jest, in cache we nest, our humor blessed, in sync’s zest, in Streamlit’s best! 😂🌟
-    """
     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, in shared cache, our cheers restored, in shared chord, in Streamlit’s cord! 👍📊
-@st.cache_resource
+# Vote saver - cheers recorded! 👍📊
 async def save_vote(file, item, user_hash, username, comment=""):
-    """
-    Save votes, a shared tally’s cheer, in cache so clear, our triumph near, in sync’s spear, in Streamlit’s near! 🏆🎉
-    """
     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")
@@ -431,14 +253,9 @@ async def save_vote(file, item, user_hash, username, comment=""):
     if comment:
         chat_message += f" - {comment}"
     await save_chat_entry(username, chat_message)
-    return entry  # Return for caching, our epic fling, in sync’s ring, in Streamlit’s sing!
 
-# Vote counter - tallying the love, in shared cache, a tale above, in shared glove, in Streamlit’s love! 🏆📈
-@st.cache_resource
+# Vote counter - tallying the love! 🏆📈
 async def load_votes(file):
-    """
-    Count votes, a shared tally’s might, in cache so bright, our victory’s light, in sync’s fight, in Streamlit’s light! 🌟📊
-    """
     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):
@@ -458,139 +275,74 @@ async def load_votes(file):
                 user_votes.add(vote_key)
     return votes
 
-# Hash generator - secret codes ahoy, in shared cache, a cryptic joy, in shared toy, in Streamlit’s joy! 🔑🕵️
+# Hash generator - secret codes ahoy! 🔑🕵️
 async def generate_user_hash():
-    """
-    Generate hashes, a shared code’s chime, in cache sublime, through space and time, in sync’s rhyme, in Streamlit’s chime! 🌌🔐
-    """
     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, in shared cache, a sonic dive, in shared hive, in Streamlit’s dive! 🎶🌟
+# Audio maker - voices come alive! 🎶🌟
 async def async_edge_tts_generate(text, voice, rate=0, pitch=0, file_format="mp3"):
-    """
-    Make audio, a shared voice’s thrill, in cache we fill, with sonic will, in sync’s hill, in Streamlit’s will! 🎤🔊
-    """
     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 = os.path.join(AUDIO_DIR, f"audio_{timestamp}_{random.randint(1000, 9999)}.mp3")
+    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(filename)
-        return filename if os.path.exists(filename) else None
+        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, in shared cache, a musical scoff, in shared toff, in Streamlit’s scoff! 🔊🚀
+# Audio player - tunes blast off! 🔊🚀
 def play_and_download_audio(file_path):
-    """
-    Play tunes, a shared melody’s jest, in cache expressed, our audio quest, in sync’s zest, in Streamlit’s quest! 🎵🌌
-    """
     if file_path and os.path.exists(file_path):
         st.audio(file_path)
-        with open(file_path, "rb") as f:
-            b64 = base64.b64encode(f.read()).decode()
+        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, in shared cache, a visual burst, in shared thirst, in Streamlit’s burst! 📸💾
+# Image saver - pics preserved with naming! 📸💾
 async def save_pasted_image(image, username):
-    """
-    Save images, a shared sight’s cheer, in cache so clear, our vision near, in sync’s spear, in Streamlit’s near! 🖼️🌟
-    """
     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)
-    media_filename = f"{username}-{timestamp.split('-')[-1]}.png"
-    media_path = os.path.join(MEDIA_DIR, media_filename)
-    img_byte_arr = io.BytesIO()
-    image.save(img_byte_arr, format='PNG')
-    await asyncio.to_thread(lambda: open(media_path, 'wb').write(img_byte_arr.getvalue()))
-    return media_filename
-
-# Video and Audio savers - media magic, in shared cache, a heroic tragic, in shared magic, in Streamlit’s magic! 🎥🎶
-async def save_media(file, username, ext):
-    """
-    Save media, a shared epic’s might, in cache so bright, our treasures ignite, in sync’s kite, in Streamlit’s kite! 🧙🔥
-    """
-    await asyncio.to_thread(log_action, username, f"📸💾 - Media saver - {ext} preserved!")
-    timestamp = format_timestamp_prefix(username)
-    media_filename = f"{username}-{timestamp.split('-')[-1]}.{ext}"
-    media_path = os.path.join(MEDIA_DIR, media_filename)
-    await asyncio.to_thread(lambda: open(media_path, 'wb').write(file.getbuffer()))
-    return media_filename
-
-# PDF saver and audio generator - documents dance, in shared cache, a chance, in shared trance, in Streamlit’s dance! 📜🎶
-async def save_pdf_and_generate_audio(pdf_file, username, max_pages=10):
-    """
-    Save PDFs, a shared document’s glee, in cache we see, our history’s key, in sync’s sea, in Streamlit’s key! 📚🌟
-    """
-    await asyncio.to_thread(log_action, username, "📜🎶 - PDF saver and audio generator!")
-    timestamp = format_timestamp_prefix(username)
-    file_hash = hashlib.md5(pdf_file.getbuffer()).hexdigest()[:8]
-    pdf_filename = f"{username}-{timestamp.split('-')[-1]}-{file_hash}.pdf"
-    media_path = os.path.join(MEDIA_DIR, pdf_filename)
-    with open(media_path, 'wb') as f:
-        f.write(pdf_file.getbuffer())
-
-    reader = PdfReader(media_path)
-    total_pages = min(len(reader.pages), max_pages)
-    texts = []
-    audio_files = []
-
-    audio_processor = AudioProcessor()
-    voice = st.session_state.voice if username == st.session_state.username else FUN_USERNAMES.get(username, "en-US-AriaNeural")
-
-    for i in range(total_pages):
-        text = reader.pages[i].extract_text()
-        texts.append(text)
-        audio_filename = f"{username}-{timestamp.split('-')[-1]}-page{i+1}-{file_hash}-voice-{voice}.mp3"
-        audio_path = os.path.join(AUDIO_DIR, audio_filename)
-        audio_data = await audio_processor.create_audio(text, voice, audio_path)
-        if audio_data:
-            audio_files.append(audio_filename)
-
-    return pdf_filename, texts, audio_files
-
-# Video renderer - movies roll, in shared cache, a visual toll, in shared roll, in Streamlit’s roll! 🎥🎬
-def get_video_html(video_path, width="100px"):
-    """
-    Render videos, a shared screen’s thrill, in cache we fill, with cinematic will, in sync’s hill, in Streamlit’s will! 📺🌌
-    """
-    video_url = f"data:video/mp4;base64,{base64.b64encode(open(os.path.join(MEDIA_DIR, video_path), 'rb').read()).decode()}"
-    return f'''
-    <video width="{width}" controls autoplay muted loop>
-        <source src="{video_url}" type="video/mp4">
-        Your browser does not support the video tag.
-    </video>
-    '''
-
-# Audio renderer - sounds soar, in shared cache, a sonic roar, in shared roar, in Streamlit’s roar! 🎶✈️
-async def get_audio_html(audio_path, width="100px"):
-    """
-    Render audio, a shared sound’s cheer, in cache so clear, our music near, in sync’s spear, in Streamlit’s near! 🎵🌟
-    """
+    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, os.path.join(AUDIO_DIR, 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, in shared cache, a connection’s cup, in shared cup, in Streamlit’s cup! 🌐🔗
+    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! 🌐🔗
 async def websocket_handler(websocket, path):
-    """
-    Handle chats, a shared link’s might, in cache so bright, our network’s light, in sync’s night, in Streamlit’s light! 🌍🔌
-    """
     username = st.session_state.get('username', 'System 🌟')
     await asyncio.to_thread(log_action, username, "🌐🔗 - Websocket handler - chat links up!")
     try:
@@ -612,11 +364,8 @@ async def websocket_handler(websocket, path):
         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, in shared cache, a starry czar, in shared star, in Streamlit’s star! 📢✈️
+# Message broadcaster - words fly far! 📢✈️
 async def broadcast_message(message, room_id):
-    """
-    Broadcast words, a shared echo’s cheer, in cache so clear, our message near, in sync’s spear, in Streamlit’s near! 🌠📡
-    """
     username = st.session_state.get('username', 'System 🌟')
     await asyncio.to_thread(log_action, username, "📢✈️ - Message broadcaster - words fly far!")
     if room_id in st.session_state.active_connections:
@@ -629,11 +378,8 @@ async def broadcast_message(message, room_id):
         for client_id in disconnected:
             del st.session_state.active_connections[room_id][client_id]
 
-# Server starter - web spins up, in shared cache, a digital pup, in shared pup, in Streamlit’s pup! 🖥️🌀
+# Server starter - web spins up! 🖥️🌀
 async def run_websocket_server():
-    """
-    Start server, a shared spin’s delight, in cache so right, our web takes flight, in sync’s night, in Streamlit’s flight! 🚀🌐
-    """
     username = st.session_state.get('username', 'System 🌟')
     await asyncio.to_thread(log_action, username, "🖥️🌀 - Server starter - web spins up!")
     if not st.session_state.server_running:
@@ -641,212 +387,327 @@ async def run_websocket_server():
         st.session_state.server_running = True
         await server.wait_closed()
 
-# Delete all user files - a purge so grand, in shared cache, a clearing band, in shared land, in Streamlit’s band! 🗑️🔥
+# 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():
-    """
-    Delete files, a shared purge’s might, in cache so light, our slate wiped tight, in sync’s night, in Streamlit’s tight! 🧹🌌
-    """
-    protected_files = {'app.py', 'requirements.txt', 'README.md', CHAT_FILE, QUOTE_VOTES_FILE, MEDIA_VOTES_FILE, HISTORY_FILE, STATE_FILE, AUDIO_DIR, MEDIA_DIR}
+    protected_files = {'app.py', 'requirements.txt', 'README.md'}
     deleted_files = []
-    for file in os.listdir('.'):
-        if file not in protected_files and not file.endswith('_history.md'):
-            try:
-                os.remove(file)
-                deleted_files.append(file)
-            except Exception as e:
-                st.error(f"Failed to delete {file}: {e}")
-    for root, dirs, files in os.walk(AUDIO_DIR):
-        for file in files:
-            file_path = os.path.join(root, file)
+    
+    # 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:
-                os.remove(file_path)
-                deleted_files.append(file_path)
+                shutil.rmtree(directory, ignore_errors=True)
+                os.makedirs(directory, exist_ok=True)  # Recreate empty directory
             except Exception as e:
-                st.error(f"Failed to delete {file_path}: {e}")
-    for root, dirs, files in os.walk(MEDIA_DIR):
-        for file in files:
-            file_path = os.path.join(root, file)
-            try:
-                os.remove(file_path)
-                deleted_files.append(file_path)
-            except Exception as e:
-                st.error(f"Failed to delete {file_path}: {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()
-    shared_memory = get_shared_memory()
-    shared_memory.clear()  # Clear shared cache on purge, in sync’s surge, in Streamlit’s surge!
+    
     return deleted_files
 
-# Query parameter checker - parse q with flair, in shared cache, a naming affair, in shared air, in Streamlit’s air! 🚪🔍
-def check_query_params():
-    """
-    Check queries, a shared name’s quest, in cache so blessed, our path expressed, in sync’s zest, in Streamlit’s best! 🌟🔍
-    """
-    query_params = st.query_params if hasattr(st, 'query_params') else st.experimental_get_query_params()
-    q_value = query_params.get("q", [None])[0]
-    if q_value and q_value in FUN_USERNAMES:
-        st.session_state.username = q_value
-        st.session_state.voice = FUN_USERNAMES[q_value]
-        return q_value
-    elif q_value:
-        st.session_state.user_id = q_value  # Use as user_id if not a valid username
-    return None
-
-# Mermaid graph generator - visualize our tale, in shared cache, a graphic gale, in shared vale, in Streamlit’s gale! 🌳📈
-def generate_mermaid_graph(chat_lines):
-    """
-    Generate graphs, a shared vision’s rhyme, in cache sublime, our story’s chime, in sync’s time, in Streamlit’s chime! 🧩🌌
-    """
-    mermaid_code = "graph TD\n"
-    nodes = {}
-    edges = []
-    for i, line in enumerate(chat_lines):
-        if line.strip() and not line.startswith('  '):
-            timestamp = line.split('] ')[0][1:] if '] ' in line else "Unknown"
-            content = line.split(': ', 1)[1] if ': ' in line else line
-            user = content.split(' ')[0]
-            message = content.split(' ', 1)[1] if ' ' in content else ''
-            node_id = f"{user}_{i}"
-            nodes[node_id] = f"{user}: {message[:20]}..." if len(message) > 20 else f"{user}: {message}"
-            if i + 1 < len(chat_lines) and "Audio:" in chat_lines[i + 1]:
-                audio_node = f"audio_{i}"
-                nodes[audio_node] = "🎵"
-                edges.append(f"{node_id} --> {audio_node}")
-            if i + 2 < len(chat_lines) and "Media:" in chat_lines[i + 2]:
-                media_node = f"media_{i}"
-                nodes[media_node] = "🖼"
-                edges.append(f"{node_id} --> {media_node}")
-            if i > 0 and "> " in line:
-                parent_user = chat_lines[i-1].split(': ')[1].split(' ')[0]
-                parent_id = f"{parent_user}_{i-1}"
-                edges.append(f"{parent_id} --> {node_id}")
-
-    for node_id, label in nodes.items():
-        mermaid_code += f"    {node_id}[\"{label}\"]\n"
-    mermaid_code += "\n".join(f"    {edge}" for edge in edges)
-    return mermaid_code
-
-# Main execution - let’s roll, in shared cache, a heroic toll, in shared soul, in Streamlit’s roll! 🎲🚀
+# 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>
+"""
+
+# Main execution - let’s roll! 🎲🚀
 def main():
-    """
-    Launch our saga, a shared memory’s cheer, in Streamlit’s cache, our epic year, in sync’s spear, in Streamlit’s year! 🚀✨
-    """
     NODE_NAME, port = get_node_name()
 
-    # Use Streamlit’s event loop or create a new one safely, avoiding reuse errors! 🌀🔄
-    try:
-        loop = asyncio.get_event_loop()
-        if loop.is_closed():
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-    except RuntimeError:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-
-    # Run async interface within the loop, ensuring no reuse or nested awaits! 🌟🎭
-    loop.run_until_complete(async_interface())
-    loop.close()
-
-# Async interface - our epic quest, in shared cache, a tale expressed, in sync’s zest, in Streamlit’s quest! 🎭🌟
-async def async_interface():
-    # Generate user ID and hash, a shared identity’s clash, in sync’s flash, in Streamlit’s clash! 🆔🔮
-    if not st.session_state.user_id:
-        st.session_state.user_id = str(uuid.uuid4())
-        st.session_state.user_hash = await generate_user_hash()
-
-    # Check query params, a shared name’s quest, in cache expressed, our path impressed, in sync’s zest, in Streamlit’s quest! 🚪🔍
-    q_value = check_query_params()
-    if not q_value and '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}")
-
-    # Check existing history, a shared memory’s cheer, in cache so clear, our lore near, in sync’s spear, in Streamlit’s near! 📜🌟
-    user_history_file = f"{st.session_state.username}_history.md"
-    if os.path.exists(user_history_file):
-        with open(user_history_file, 'r') as f:
-            st.session_state.displayed_chat_lines = f.read().split('\n')
-
-    user_url = f"/q={st.session_state.username}"
-    with st.container():
-        st.markdown(f"<small>Your unique URL path: [{user_url}]({user_url})</small>", unsafe_allow_html=True)
-
-    with st.container():
-        st.markdown(f"#### 🤖🧠MMO {st.session_state.username}📝🔬")
-        st.markdown(f"<small>Welcome to {START_ROOM} - chat, vote, upload, paste images, and enjoy quoting! 🎉 User ID: {st.session_state.user_id}</small>", unsafe_allow_html=True)
-
-    if not st.session_state.server_task:
-        st.session_state.server_task = asyncio.create_task(run_websocket_server())
-
-    # Unified Chat History at Top - a shared epic’s roar, condensed and stored, in sync’s cord, in Streamlit’s cord! 💬🌌
-    with st.container():
-        st.markdown(f"##### {START_ROOM} Chat History 💬")
-        shared_memory = get_shared_memory()
+    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
+        st.subheader(f"{START_ROOM} Chat 💬")
         chat_content = await load_chat()
-        chat_lines = [line for line in chat_content.split('\n') if line.strip() and not line.startswith('#')]
-        if chat_lines:
-            chat_by_minute = {}
-            for line in reversed(chat_lines):
-                timestamp = line.split('] ')[0][1:] if '] ' in line else "Unknown"
-                minute_key = timestamp[:16]  # Up to minute
-                if minute_key not in chat_by_minute:
-                    chat_by_minute[minute_key] = []
-                chat_by_minute[minute_key].append(line)
-
-            markdown_output = ""
-            for minute, lines in chat_by_minute.items():
-                minute_output = f"###### {minute[-5:]}\n"  # Show only HH:MM
-                for line in lines:
-                    if ': ' in line and not line.startswith('  '):
-                        user_message = line.split(': ', 1)[1]
-                        user = user_message.split(' ')[0]
-                        msg = user_message.split(' ', 1)[1] if ' ' in user_message else ''
-                        audio_html = ""
-                        media_content = ""
-                        next_lines = chat_lines[chat_lines.index(line)+1:chat_lines.index(line)+3]
-                        for nl in next_lines:
-                            if "Audio:" in nl:
-                                audio_file = nl.split("Audio: ")[-1].strip()
-                                audio_html = play_and_download_audio(audio_file)
-                            elif "Media:" in nl:
-                                media_file = nl.split("Media: ")[-1].strip('![]()')
-                                media_path = os.path.join(MEDIA_DIR, media_file)
-                                if os.path.exists(media_path):
-                                    if media_file.endswith(('.png', '.jpg')):
-                                        media_content = f"<img src='file://{media_path}' width='100'>"
-                                    elif media_file.endswith('.mp4'):
-                                        media_content = get_video_html(media_file)
-                                    elif media_file.endswith('.mp3'):
-                                        media_content = await get_audio_html(media_file)
-                                    elif media_file.endswith('.pdf'):
-                                        media_content = f"📜 {os.path.basename(media_file)}"
-                        minute_output += f"- 💬 **{user}**: {msg[:50]}... {audio_html} {media_content}\n"  # Condensed dialog
-                markdown_output += minute_output
-            st.markdown(markdown_output, unsafe_allow_html=True)
-            shared_memory.update_chat(markdown_output)  # Cache condensed dialogs, in sync’s log, in Streamlit’s fog!
-
-        # Condensed Dialogs Display - a shared tale, concise and hale, in shared vale, in Streamlit’s tale! 🗣️✨
-        st.markdown("###### Condensed Dialogs 🗣️")
-        condensed_dialogs = shared_memory.get_condensed_dialogs()
-        st.markdown(condensed_dialogs)
-
-        # Mermaid Graph Visualization - a shared map, our chat’s trap, in shared cap, in Streamlit’s map! 🌳📈
-        st.markdown("###### Chat Relationship Tree 🌳")
-        mermaid_code = generate_mermaid_graph(chat_lines)
-        mermaid_html = f"""
-        <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
-        <div class="mermaid" style="height: 200px; overflow: auto;">{mermaid_code}</div>
-        <script>mermaid.initialize({{startOnLoad:true}});</script>
-        """
-        components.html(mermaid_html, height=250)
-
-    with st.container():
+        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:
+                    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}")
+            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:
@@ -858,14 +719,13 @@ async def async_interface():
                     filename = await save_pasted_image(paste_result_quote.image_data, st.session_state.username)
                     if filename:
                         st.session_state.pasted_image_data = filename
-                        await save_chat_entry(st.session_state.username, f"Pasted image: {filename}", quote_line=st.session_state.quote_line, media_file=paste_result_quote.image_data)
             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}", quote_line=st.session_state.quote_line, media_file=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, quote_line=st.session_state.quote_line)
+                await save_chat_entry(st.session_state.username, markdown_response, is_markdown=True)
                 st.session_state.quote_line = None
                 st.session_state.message_text = ''
                 st.rerun()
@@ -879,157 +739,105 @@ async def async_interface():
             st.markdown(f"**🎙️ Voice Changed**: {st.session_state.voice} 🗣️ for {st.session_state.username}")
             st.rerun()
 
-        # Message input with Send button - a shared chat’s might, in shared night, in Streamlit’s might! 💬🚀
-        col_input, col_send = st.columns([5, 1])
-        with col_input:
-            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)
-        with col_send:
-            if st.button("Send 🚀", key="send_button"):
-                if message.strip() or st.session_state.pasted_image_data:
-                    await save_chat_entry(st.session_state.username, message if message.strip() else "Image shared", is_markdown=True, media_file=st.session_state.pasted_image_data if st.session_state.pasted_image_data else None, skip_audio=not message.strip())
-                    if st.session_state.pasted_image_data:
-                        st.session_state.pasted_image_data = None
-                st.session_state.message_text = ''
-                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 Quote")
+                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:
-                    await save_chat_entry(st.session_state.username, "Image shared", is_markdown=True, media_file=paste_result_msg.image_data, skip_audio=True)
-                    st.session_state.pasted_image_data = None
-                    st.rerun()
+                    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()
 
-    with st.container():
-        st.markdown("###### Upload Media 🎨🎶📜🎥")
-        uploaded_file = st.file_uploader("Upload Media", type=['png', 'jpg', 'mp4', 'mp3', 'wav', 'pdf', 'txt', 'md', 'py'])
+        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)
+
+        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].lower()
-            if ext in ['png', 'jpg']:
-                filename = await save_pasted_image(uploaded_file, username)
-            elif ext in ['mp4', 'mp3', 'wav']:
-                filename = await save_media(uploaded_file, username, ext)
-            elif ext == 'pdf':
-                pdf_filename, _, _ = await save_pdf_and_generate_audio(uploaded_file, username)
-                filename = pdf_filename
-            else:
-                filename = f"{username}-{timestamp.split('-')[-1]}.{ext}"
-                media_path = os.path.join(MEDIA_DIR, filename)
-                await asyncio.to_thread(lambda: open(media_path, 'wb').write(uploaded_file.getbuffer()))
-            await save_chat_entry(username, f"Uploaded {ext.upper()}: {os.path.basename(filename)}", media_file=uploaded_file, skip_audio=True)
-            shared_memory = get_shared_memory()
-            shared_memory.update_media(os.path.join(MEDIA_DIR, filename))  # Cache media, in sync’s sea, in Streamlit’s sea!
-            st.success(f"Uploaded {filename}")
-
-        # Big Red Delete Button - a purge so grand, clearing our shared land, in sync’s sand, in Streamlit’s sand! 🗑️🔥
-        st.markdown("###### 🛑 Danger Zone")
+            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]))
-                shared_memory = get_shared_memory()
-                shared_memory.clear()  # Clear shared cache on purge, in sync’s surge, in Streamlit’s surge!
             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()
             st.rerun()
 
-        st.markdown("###### Refresh ⏳")
+        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"<small>⏳ {font_func('Refresh in:')} {countdown_str}</small>", unsafe_allow_html=True)
-            await asyncio.sleep(1)  # Use asyncio.sleep for async context, in sync’s nest, in Streamlit’s nest!
+            timer_placeholder.markdown(f"<p class='timer'>⏳ {font_func('Refresh in:')} {countdown_str}</p>", unsafe_allow_html=True)
+            time.sleep(1)
         st.rerun()
 
-    # Separate Galleries for Own and Shared Files - a shared gallery’s glare, in shared air, in Streamlit’s air! 🖼️🎥
-    with st.container():
-        all_files = glob.glob(os.path.join(MEDIA_DIR, "*.md")) + glob.glob(os.path.join(MEDIA_DIR, "*.pdf")) + glob.glob(os.path.join(MEDIA_DIR, "*.txt")) + glob.glob(os.path.join(MEDIA_DIR, "*.py")) + glob.glob(os.path.join(MEDIA_DIR, "*.png")) + glob.glob(os.path.join(MEDIA_DIR, "*.jpg")) + glob.glob(os.path.join(MEDIA_DIR, "*.mp3")) + glob.glob(os.path.join(MEDIA_DIR, "*.mp4")) + glob.glob(os.path.join(AUDIO_DIR, "*.mp3"))
-        shared_memory = get_shared_memory()
-        own_files = [f for f in all_files if st.session_state.user_id in os.path.basename(f) or st.session_state.username in os.path.basename(f)]
-        shared_files = [f for f in all_files if f not in own_files and not f in [CHAT_FILE, QUOTE_VOTES_FILE, MEDIA_VOTES_FILE, HISTORY_FILE, STATE_FILE, os.path.join(AUDIO_DIR, "*"), os.path.join(MEDIA_DIR, "*")]]
-
-        st.markdown("###### Your Files 📂")
-        st.markdown("###### Image Gallery 🖼")
-        own_image_files = [f for f in own_files if f.endswith(('.png', '.jpg'))]
-        image_cols = st.slider("Image Gallery Columns 🖼 (Own)", min_value=1, max_value=15, value=5)
-        cols = st.columns(image_cols)
-        for idx, image_file in enumerate(own_image_files):
-            with cols[idx % image_cols]:
-                st.image(image_file, use_container_width=True)
-                shared_memory.update_media(image_file)  # Cache media, in sync’s sea, in Streamlit’s sea!
-
-        st.markdown("###### Video Gallery 🎥")
-        own_video_files = [f for f in own_files if f.endswith('.mp4')]
-        video_cols = st.slider("Video Gallery Columns 🎬 (Own)", min_value=1, max_value=5, value=3)
-        cols = st.columns(video_cols)
-        for idx, video_file in enumerate(own_video_files):
-            with cols[idx % video_cols]:
-                st.markdown(get_video_html(video_file), unsafe_allow_html=True)
-                shared_memory.update_media(video_file)  # Cache media, in sync’s lea, in Streamlit’s lea!
-
-        st.markdown("###### Audio Gallery 🎧")
-        own_audio_files = [f for f in own_files if f.endswith(('.mp3', '.wav')) or f.startswith(os.path.join(AUDIO_DIR, "audio_"))]
-        audio_cols = st.slider("Audio Gallery Columns 🎶 (Own)", min_value=1, max_value=15, value=5)
-        cols = st.columns(audio_cols)
-        for idx, audio_file in enumerate(own_audio_files):
-            with cols[idx % audio_cols]:
-                st.markdown(await get_audio_html(audio_file), unsafe_allow_html=True)
-                shared_memory.update_media(audio_file)  # Cache media, in sync’s tea, in Streamlit’s tea!
-
-        st.markdown("###### Shared Files 📤")
-        st.markdown("###### Image Gallery 🖼")
-        shared_image_files = [f for f in shared_files if f.endswith(('.png', '.jpg'))]
-        image_cols = st.slider("Image Gallery Columns 🖼 (Shared)", min_value=1, max_value=15, value=5)
-        cols = st.columns(image_cols)
-        for idx, image_file in enumerate(shared_image_files):
-            with cols[idx % image_cols]:
-                st.image(image_file, use_container_width=True)
-                shared_memory.update_media(image_file)  # Cache media, in sync’s bee, in Streamlit’s bee!
-
-        st.markdown("###### Video Gallery 🎥")
-        shared_video_files = [f for f in shared_files if f.endswith('.mp4')]
-        video_cols = st.slider("Video Gallery Columns 🎬 (Shared)", min_value=1, max_value=5, value=3)
-        cols = st.columns(video_cols)
-        for idx, video_file in enumerate(shared_video_files):
-            with cols[idx % video_cols]:
-                st.markdown(get_video_html(video_file), unsafe_allow_html=True)
-                shared_memory.update_media(video_file)  # Cache media, in sync’s tree, in Streamlit’s tree!
-
-        st.markdown("###### Audio Gallery 🎧")
-        shared_audio_files = [f for f in shared_files if f.endswith(('.mp3', '.wav')) or f.startswith(os.path.join(AUDIO_DIR, "audio_"))]
-        audio_cols = st.slider("Audio Gallery Columns 🎶 (Shared)", min_value=1, max_value=15, value=5)
-        cols = st.columns(audio_cols)
-        for idx, audio_file in enumerate(shared_audio_files):
-            with cols[idx % audio_cols]:
-                st.markdown(await get_audio_html(audio_file), unsafe_allow_html=True)
-                shared_memory.update_media(audio_file)  # Cache media, in sync’s glee, in Streamlit’s glee!
-
-    # Full Log at End with Download - a shared epic’s end, our tale to mend, in sync’s bend, in Streamlit’s end! 📜📥
-    with st.container():
-        st.markdown("###### Full Chat Log 📜")
-        with open(CHAT_FILE, 'r') as f:
+        st.sidebar.subheader("Chat History 📜")
+        with open(HISTORY_FILE, 'r') as f:
             history_content = f.read()
-        st.markdown(history_content)
-        st.download_button("Download Chat Log as .md", history_content, file_name=f"chat_{st.session_state.user_id}.md", mime="text/markdown")
+        st.sidebar.markdown(history_content)
 
-    # Clear Cache Button - purge the cache, a shared epic’s crash, in sync’s flash, in Streamlit’s crash! 🗑️🔄
-    if st.button("Clear Shared Memory Cache", key="clear_cache"):
-        shared_memory = get_shared_memory()
-        shared_memory.clear()
-        st.success("Shared memory cache cleared, a fresh start with a bard’s heart, in sync’s art, in Streamlit’s art! 🌟🎶")
+    loop.run_until_complete(async_interface())
 
 if __name__ == "__main__":
-    """
-    Launch our saga, a shared memory’s cheer, in Streamlit’s cache, our epic year, in sync’s spear, in Streamlit’s year! 🚀✨
-    """
     main()