Update app.py

app.py

@@ -106,15 +106,9 @@ if 'last_query' not in st.session_state:
 if 'marquee_content' not in st.session_state:
     st.session_state['marquee_content'] = "🚀 Welcome to TalkingAIResearcher | 🤖 Your Research Assistant"
 
-# To track user checkboxes for Claude / Arxiv / Autorun / AutoSave
-if 'run_claude' not in st.session_state:
-    st.session_state['run_claude'] = True  # enabled by default
-if 'run_arxiv' not in st.session_state:
-    st.session_state['run_arxiv'] = False  # disabled by default
-if 'autorun_searches' not in st.session_state:
-    st.session_state['autorun_searches'] = False
-if 'autosave_output' not in st.session_state:
-    st.session_state['autosave_output'] = False
+# New: default AutoRun to False (off)
+if 'autorun' not in st.session_state:
+    st.session_state['autorun'] = False
 
 # API Keys
 openai_api_key = os.getenv('OPENAI_API_KEY', "")
@@ -134,7 +128,14 @@ API_URL = os.getenv('API_URL')
 FILE_EMOJIS = {
     "md": "📝",
     "mp3": "🎵",
-    "wav": "🔊"
+    "wav": "🔊",
+    "pdf": "📕",
+    "mp4": "🎥",
+    "csv": "📈",
+    "xlsx": "📊",
+    "html": "🌐",
+    "py": "🐍",
+    "txt": "📄"
 }
 
 # ─────────────────────────────────────────────────────────
@@ -305,23 +306,18 @@ def play_and_download_audio(file_path, file_type="mp3"):
         st.markdown(dl_link, unsafe_allow_html=True)
 
 def save_qa_with_audio(question, answer, voice=None):
-    """Save Q&A to markdown and also generate audio, returning file paths."""
+    """Save Q&A to markdown and also generate audio."""
     if not voice:
         voice = st.session_state['tts_voice']
     
     combined_text = f"# Question\n{question}\n\n# Answer\n{answer}"
-    md_file = None
-    audio_file = None
-
-    # Only create the files if autosave is enabled
-    if st.session_state['autosave_output']:
-        md_file = create_file(question, answer, "md")
-        audio_text = f"{question}\n\nAnswer: {answer}"
-        audio_file = speak_with_edge_tts(
-            audio_text,
-            voice=voice,
-            file_format=st.session_state['audio_format']
-        )
+    md_file = create_file(question, answer, "md")
+    audio_text = f"{question}\n\nAnswer: {answer}"
+    audio_file = speak_with_edge_tts(
+        audio_text,
+        voice=voice,
+        file_format=st.session_state['audio_format']
+    )
     return md_file, audio_file
 
 # ─────────────────────────────────────────────────────────
@@ -392,12 +388,9 @@ def create_paper_links_md(papers):
 
 def create_paper_audio_files(papers, input_question):
     """
-    For each paper, generate TTS audio summary if autosave is on,
-    store the path in `paper['full_audio']`,
-    and store a base64 link for stable downloading.
+    For each paper, generate TTS audio summary, store the path in `paper['full_audio']`,
+    and also store a base64 link for stable downloading.
     """
-    if not st.session_state['autosave_output']:
-        return
     for paper in papers:
         try:
             audio_text = f"{paper['title']} by {paper['authors']}. {paper['summary']}"
@@ -457,35 +450,45 @@ def display_papers_in_sidebar(papers):
                 st.markdown(f"**Summary:** {paper['summary'][:300]}...")
 
 # ─────────────────────────────────────────────────────────
-# 4. ZIP FUNCTION
+# 4. ZIP & DELETE-ALL UTILS
 # ─────────────────────────────────────────────────────────
 
-def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
+def create_zip_of_all_files():
     """
-    Zip up all relevant files, limiting the final zip name to ~20 chars
+    Zip up all recognized file types, limiting the final zip name to ~20 chars
     to avoid overly long base64 strings. 
     """
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files + wav_files
+    # Patterns for .md, .pdf, .mp4, .mp3, .wav, .csv, .xlsx, .html, .py, .txt
+    file_patterns = [
+        "*.md", "*.pdf", "*.mp4", "*.mp3", "*.wav",
+        "*.csv", "*.xlsx", "*.html", "*.py", "*.txt"
+    ]
+    all_files = []
+    for pat in file_patterns:
+        all_files.extend(glob.glob(pat))
+    all_files = list(set(all_files))  # unique
+
     if not all_files:
         return None
 
+    # Combine content for naming
     all_content = []
     for f in all_files:
-        if f.endswith('.md'):
-            with open(f, 'r', encoding='utf-8') as file:
-                all_content.append(file.read())
-        elif f.endswith('.mp3') or f.endswith('.wav'):
-            basename = os.path.splitext(os.path.basename(f))[0]
-            words = basename.replace('_', ' ')
-            all_content.append(words)
-    
-    all_content.append(input_question)
+        if f.endswith(".md"):
+            with open(f, "r", encoding="utf-8") as fin:
+                all_content.append(fin.read())
+        else:
+            all_content.append(os.path.basename(f))
+
+    # Add last query if relevant
+    if st.session_state['last_query']:
+        all_content.append(st.session_state['last_query'])
+
     combined_content = " ".join(all_content)
     info_terms = get_high_info_terms(combined_content, top_n=10)
     
     timestamp = format_timestamp_prefix()
-    name_text = '-'.join(term for term in info_terms[:5])  
+    name_text = '-'.join(term for term in info_terms[:5])
     short_zip_name = (timestamp + "_" + name_text)[:20] + ".zip"
 
     with zipfile.ZipFile(short_zip_name, 'w') as z:
@@ -493,99 +496,102 @@ def create_zip_of_files(md_files, mp3_files, wav_files, input_question):
             z.write(f)
     return short_zip_name
 
+def delete_all_files():
+    """Removes all recognized file types from the directory."""
+    file_patterns = [
+        "*.md", "*.pdf", "*.mp4", "*.mp3", "*.wav",
+        "*.csv", "*.xlsx", "*.html", "*.py", "*.txt"
+    ]
+    for pat in file_patterns:
+        for f in glob.glob(pat):
+            os.remove(f)
+
 # ─────────────────────────────────────────────────────────
 # 5. MAIN LOGIC: AI LOOKUP & VOICE INPUT
 # ─────────────────────────────────────────────────────────
 
-def run_claude_search(q):
-    """Call Anthropic (Claude) for the user's query."""
+def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, 
+                     titles_summary=True, full_audio=False):
+    """Main routine that uses Anthropic (Claude) + Gradio ArXiv RAG pipeline."""
+    start = time.time()
+
+    # --- 1) Claude API
     client = anthropic.Anthropic(api_key=anthropic_key)
+    user_input = q
     response = client.messages.create(
         model="claude-3-sonnet-20240229",
         max_tokens=1000,
         messages=[
-            {"role": "user", "content": q}
+            {"role": "user", "content": user_input}
         ])
-    result = response.content[0].text
+    st.write("Claude's reply 🧠:")
+    st.markdown(response.content[0].text)
 
-    st.write("### Claude's reply 🧠:")
-    st.markdown(result)
-    return result
+    # Save & produce audio
+    result = response.content[0].text
+    create_file(q, result) 
+    md_file, audio_file = save_qa_with_audio(q, result)
+    st.subheader("📝 Main Response Audio")
+    play_and_download_audio(audio_file, st.session_state['audio_format'])
 
-def run_arxiv_search(q):
-    """Call the Arxiv RAG pipeline for the user's query."""
-    st.write("### Arxiv's AI: Mixtral 8x7B RAG")
+    # --- 2) Arxiv RAG
+    st.write("Arxiv's AI this Evening is Mixtral 8x7B...")
     client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
     refs = client.predict(
-        q,
-        10,  # topK
+        q, 
+        20, 
         "Semantic Search", 
         "mistralai/Mixtral-8x7B-Instruct-v0.1",
         api_name="/update_with_rag_md"
     )[0]
-    
     r2 = client.predict(
         q, 
         "mistralai/Mixtral-8x7B-Instruct-v0.1", 
         True, 
         api_name="/ask_llm"
     )
-    
-    # Combine the final result
+
     result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
-    st.markdown(result)
+    md_file, audio_file = save_qa_with_audio(q, result)
+    st.subheader("📝 Main Response Audio")
+    play_and_download_audio(audio_file, st.session_state['audio_format'])
 
-    # Parse + handle papers
+    # --- 3) Parse + handle papers
     papers = parse_arxiv_refs(refs)
     if papers:
-        # Create minimal links page if autosave is on
-        if st.session_state['autosave_output']:
-            paper_links = create_paper_links_md(papers)
-            create_file(q, paper_links, "md")
+        # Create minimal links page first
+        paper_links = create_paper_links_md(papers)
+        links_file = create_file(q, paper_links, "md")
+        st.markdown(paper_links)
 
+        # Then create audio for each paper
         create_paper_audio_files(papers, input_question=q)
         display_papers(papers, get_marquee_settings())
         display_papers_in_sidebar(papers)
     else:
         st.warning("No papers found in the response.")
-    return result
 
-def perform_selections(q):
-    """
-    Checks which search(s) are enabled and runs them in sequence,
-    returning a combined response string.
-    """
-    combined_response = ""
-    
-    if st.session_state['run_claude']:
-        claude_response = run_claude_search(q)
-        combined_response += "\n\nCLAUDE:\n" + claude_response
-    
-    if st.session_state['run_arxiv']:
-        arxiv_response = run_arxiv_search(q)
-        combined_response += "\n\nARXIV:\n" + arxiv_response
-    
-    return combined_response
+    elapsed = time.time() - start
+    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
+    return result
 
 def process_voice_input(text):
-    """When user sends voice query, we run whichever searches are enabled."""
+    """When user sends voice query, we run the AI lookup + Q&A with audio."""
     if not text:
         return
     st.subheader("🔍 Search Results")
-    # 1) Run the searches user has checked
-    result = perform_selections(text)
-
-    # 2) If autosave is turned on, store Q&A output
+    result = perform_ai_lookup(
+        text, 
+        vocal_summary=True,
+        extended_refs=False,
+        titles_summary=True,
+        full_audio=True
+    )
     md_file, audio_file = save_qa_with_audio(text, result)
-
-    # 3) If we saved TTS audio, play it
-    if audio_file:
-        st.subheader("📝 Generated Audio")
-        play_and_download_audio(audio_file, st.session_state['audio_format'])
-
-    # 4) Refresh the sidebar file listing if autosave was used
-    if st.session_state['autosave_output']:
-        display_file_history_in_sidebar()
+    st.subheader("📝 Generated Files")
+    st.write(f"Markdown: {md_file}")
+    st.write(f"Audio: {audio_file}")
+    play_and_download_audio(audio_file, st.session_state['audio_format'])
 
 # ─────────────────────────────────────────────────────────
 # 6. FILE HISTORY SIDEBAR
@@ -593,171 +599,146 @@ def process_voice_input(text):
 
 def display_file_history_in_sidebar():
     """
-    Shows a history of each local .md, .mp3, .wav file in descending
+    Shows a history of each recognized file in descending
     order of modification time, with quick icons and optional download links.
     """
     st.sidebar.markdown("---")
     st.sidebar.markdown("### 📂 File History")
 
-    # Add Delete All and Download All buttons in a row
-    col1, col2 = st.sidebar.columns(2)
-    with col1:
-        if st.button("🗑️ Delete All"):
-            # Delete all files except README.md
-            for pattern in ["*.md", "*.mp3", "*.wav", "*.mp4"]:
-                for f in glob.glob(pattern):
-                    if f.lower() != "readme.md":
-                        try:
-                            os.remove(f)
-                        except Exception as e:
-                            st.warning(f"Error deleting {f}: {str(e)}")
-            st.rerun()
-    
-    with col2:
-        # Get all files for potential zip
-        md_files = [f for f in glob.glob("*.md") if f.lower() != "readme.md"]
-        mp3_files = glob.glob("*.mp3")
-        wav_files = glob.glob("*.wav")
-
-        if md_files or mp3_files or wav_files:
-            zip_name = "Download.zip"
-            if 'last_query' in st.session_state and st.session_state['last_query']:
-                # Use last_query in the zip name
-                clean_q = clean_text_for_filename(st.session_state['last_query'])[:30]
-                if clean_q:
-                    zip_name = f"{clean_q}.zip"
-
-            if st.button("📦 Download All"):
-                with zipfile.ZipFile(zip_name, 'w') as z:
-                    for f in md_files + mp3_files + wav_files:
-                        z.write(f)
-                st.sidebar.markdown(get_download_link(zip_name), unsafe_allow_html=True)
-
-    # Gather all files
-    md_files = glob.glob("*.md")
-    mp3_files = glob.glob("*.mp3")
-    wav_files = glob.glob("*.wav")
-    all_files = md_files + mp3_files + wav_files
+    # Patterns for .md, .mp3, .wav, .pdf, .mp4, .csv, .xlsx, .html, .py, .txt
+    patterns = [
+        "*.md", "*.pdf", "*.mp4", "*.mp3", "*.wav",
+        "*.csv", "*.xlsx", "*.html", "*.py", "*.txt"
+    ]
+    all_files = []
+    for p in patterns:
+        all_files.extend(glob.glob(p))
+    all_files = list(set(all_files))  # unique
 
     if not all_files:
         st.sidebar.write("No files found.")
         return
 
-    # Sort by modification time descending
-    all_files_sorted = sorted(all_files, key=os.path.getmtime, reverse=True)
-
-    for f in all_files_sorted:
-        ext = os.path.splitext(f)[1].lower().replace('.', '')
-        emoji = FILE_EMOJIS.get(ext, "📁")
-        mod_time = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%m-%d %H:%M")
-        # Download link
-        dl_link = get_download_link(f, file_type=ext)
-        with st.sidebar.expander(f"{emoji} {os.path.basename(f)} [{mod_time}]"):
-            if ext in ["mp3", "wav"]:
-                st.audio(f)
+    # Sort newest first
+    all_files = sorted(all_files, key=os.path.getmtime, reverse=True)
+
+    for f in all_files:
+        fname = os.path.basename(f)
+        ext = os.path.splitext(fname)[1].lower().strip('.')
+        emoji = FILE_EMOJIS.get(ext, '📦')
+        time_str = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%Y-%m-%d %H:%M:%S")
+
+        with st.sidebar.expander(f"{emoji} {fname}"):
+            st.write(f"**Modified:** {time_str}")
             if ext == "md":
-                with open(f, 'r', encoding='utf-8') as file:
-                    content = file.read()
-                st.markdown(f"```\n{content[:500]}\n...```")
-            st.markdown(dl_link, unsafe_allow_html=True)
+                with open(f, "r", encoding="utf-8") as file_in:
+                    snippet = file_in.read(200).replace("\n", " ")
+                if len(snippet) == 200:
+                    snippet += "..."
+                st.write(snippet)
+                st.markdown(get_download_link(f, file_type="md"), unsafe_allow_html=True)
+            elif ext in ["mp3","wav"]:
+                st.audio(f)
+                st.markdown(get_download_link(f, file_type=ext), unsafe_allow_html=True)
+            else:
+                st.markdown(get_download_link(f), unsafe_allow_html=True)
 
 # ─────────────────────────────────────────────────────────
 # 7. MAIN APP
 # ─────────────────────────────────────────────────────────
 
 def main():
-    # 1) Setup marquee UI in the sidebar
+    """
+    Main Streamlit app. 
+    Now includes:
+      1) Voice & AutoRun at the top of the sidebar,
+      2) File Tools (Delete All / Zip All) in the sidebar,
+      3) A new '📤 Upload' tab, 
+      4) Everything else from your original code snippet.
+    """
+
+    # -- 1) Voice & AutoRun at top of sidebar --
+    st.sidebar.title("Global Settings")
+    selected_voice = st.sidebar.selectbox(
+        "TTS Voice",
+        options=EDGE_TTS_VOICES,
+        index=EDGE_TTS_VOICES.index(st.session_state['tts_voice'])
+    )
+    # Autorun defaults to off (False)
+    st.session_state.autorun = st.sidebar.checkbox("AutoRun", value=st.session_state.autorun)
+
+    # Audio format
+    audio_format = st.sidebar.radio("Audio Format", ["MP3","WAV"], index=0)
+    if selected_voice != st.session_state['tts_voice']:
+        st.session_state['tts_voice'] = selected_voice
+        st.experimental_rerun()
+    if audio_format.lower() != st.session_state['audio_format']:
+        st.session_state['audio_format'] = audio_format.lower()
+        st.experimental_rerun()
+
+    # -- 2) File Tools: Delete All / Zip All
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("### 🗃 File Tools")
+    col_del, col_zip = st.sidebar.columns(2)
+    with col_del:
+        if st.button("🗑 Delete All"):
+            delete_all_files()
+            st.sidebar.success("All recognized files removed!")
+            st.experimental_rerun()
+    with col_zip:
+        if st.button("📦 Zip All"):
+            zip_name = create_zip_of_all_files()
+            if zip_name:
+                st.sidebar.markdown(get_download_link(zip_name, "zip"), unsafe_allow_html=True)
+
+    # -- 3) Marquee Settings
     update_marquee_settings_ui()
     marquee_settings = get_marquee_settings()
 
-    # 2) Place the radio for main tabs AND the row of checkboxes
-    colA, colB, colC, colD, colE = st.columns([2,1,1,1,1])
-    with colA:
-        tab_main = st.radio("Action:", ["🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], horizontal=True)
-    with colB:
-        st.session_state['run_claude'] = st.checkbox("Claude", value=st.session_state['run_claude'])
-    with colC:
-        st.session_state['run_arxiv'] = st.checkbox("Arxiv", value=st.session_state['run_arxiv'])
-    with colD:
-        st.session_state['autorun_searches'] = st.checkbox("Autorun", value=st.session_state['autorun_searches'])
-    with colE:
-        st.session_state['autosave_output'] = st.checkbox("AutoSave", value=st.session_state['autosave_output'])
-
-    # 3) Display the marquee welcome
+    # -- 4) File History in sidebar
+    display_file_history_in_sidebar()
+
+    # -- 5) Display marquee
     display_marquee(st.session_state['marquee_content'], 
                     {**marquee_settings, "font-size": "28px", "lineHeight": "50px"},
                     key_suffix="welcome")
 
-    # Example custom component usage:
-    mycomponent = components.declare_component("mycomponent", path="mycomponent")
-    val = mycomponent(my_input_value="Hello")
-
-    if val:
-        val_stripped = val.replace('\\n', ' ')
-        edited_input = st.text_area("✏️ Edit Input:", value=val_stripped, height=100)
-        run_option = st.selectbox("Model:", ["Arxiv"])
-        full_audio = st.checkbox("📚FullAudio", value=False)
-        input_changed = (val != st.session_state.old_val)
-
-        # We'll define: if autorun is on, run immediately after input changes
-        if st.session_state['autorun_searches'] and input_changed:
-            st.session_state.old_val = val
-            st.session_state.last_query = edited_input
-            process_voice_input(edited_input)
-        else:
-            if st.button("▶ Run"):
-                st.session_state.old_val = val
-                st.session_state.last_query = edited_input
-                process_voice_input(edited_input)
-
-    # ────────���────────────────────────────────────────────────
-    # TAB: ArXiv
-    # (kept for demonstration if user chooses to do Arxiv only)
-    # ─────────────────────────────────────────────────────────
-    if tab_main == "🔍 ArXiv":
-        st.subheader("🔍 Query ArXiv")
-        q = st.text_input("🔍 Query:", key="arxiv_query")
-        
-        if q and st.button("🔍Run"):
-            st.session_state.last_query = q
-            # Even if the tab is "ArXiv," we can just call our standard function 
-            # that uses whichever checkboxes are selected (or you can do Arxiv only).
-            process_voice_input(q)
+    # -- 6) Main action tabs
+    tab_main = st.radio(
+        "Action:", 
+        ["📤 Upload", "🎤 Voice", "📸 Media", "🔍 ArXiv", "📝 Editor"], 
+        horizontal=True
+    )
 
-    # ─────────────────────────────────────────────────────────
-    # TAB: Voice
-    # ─────────────────────────────────────────────────────────
+    # 6a) Upload Tab
+    if tab_main == "📤 Upload":
+        st.header("📤 Upload Files")
+        accepted_types = [
+            # We'll accept basically everything (None in file_uploader),
+            # but let's specify for clarity:
+            "text/plain", "text/markdown", "audio/mpeg", "audio/wav",
+            "image/png", "image/jpeg", "video/mp4", "application/pdf",
+            "application/vnd.ms-excel",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "text/html", "application/octet-stream",
+        ]
+        uploaded = st.file_uploader("Select files to upload:", 
+                                    accept_multiple_files=True, 
+                                    type=None)
+        if uploaded:
+            for uf in uploaded:
+                with open(uf.name, "wb") as outfile:
+                    outfile.write(uf.read())
+            st.success("Uploaded!")
+            st.session_state.should_rerun = True
+
+    # 6b) Voice Tab
     elif tab_main == "🎤 Voice":
         st.subheader("🎤 Voice Input")
-        
-        st.markdown("### 🎤 Voice Settings")
-        selected_voice = st.selectbox(
-            "Select TTS Voice:",
-            options=EDGE_TTS_VOICES,
-            index=EDGE_TTS_VOICES.index(st.session_state['tts_voice'])
-            if st.session_state['tts_voice'] in EDGE_TTS_VOICES
-            else 0
-        )
-        
-        st.markdown("### 🔊 Audio Format")
-        selected_format = st.radio(
-            "Choose Audio Format:",
-            options=["MP3", "WAV"],
-            index=0 if st.session_state['audio_format'] == "mp3" else 1
-        )
-
-        # Update session state if voice/format changes
-        if selected_voice != st.session_state['tts_voice']:
-            st.session_state['tts_voice'] = selected_voice
-            st.rerun()
-        if selected_format.lower() != st.session_state['audio_format']:
-            st.session_state['audio_format'] = selected_format.lower()
-            st.rerun()
-
-        user_text = st.text_area("💬 Message:", height=100).strip().replace('\n', ' ')
+        user_text = st.text_area("💬 Message:", height=100)
+        user_text = user_text.strip().replace('\n', ' ')
+
         if st.button("📨 Send"):
-            st.session_state.last_query = user_text
-            # If autorun is off, we explicitly run
             process_voice_input(user_text)
 
         st.subheader("📜 Chat History")
@@ -765,14 +746,10 @@ def main():
             st.write("**You:**", c["user"])
             st.write("**Response:**", c["claude"])
 
-    # ─────────────────────────────────────────────────────────
-    # TAB: Media
-    # ─────────────────────────────────────────────────────────
+    # 6c) Media Tab
     elif tab_main == "📸 Media":
         st.header("📸 Media Gallery")
         tabs = st.tabs(["🎵 Audio", "🖼 Images", "🎥 Video"])
-        
-        # AUDIO sub-tab
         with tabs[0]:
             st.subheader("🎵 Audio Files")
             audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
@@ -785,8 +762,6 @@ def main():
                         st.markdown(dl_link, unsafe_allow_html=True)
             else:
                 st.write("No audio files found.")
-        
-        # IMAGES sub-tab
         with tabs[1]:
             st.subheader("🖼 Image Files")
             imgs = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
@@ -798,8 +773,6 @@ def main():
                         st.image(Image.open(f), use_container_width=True)
             else:
                 st.write("No images found.")
-        
-        # VIDEO sub-tab
         with tabs[2]:
             st.subheader("🎥 Video Files")
             vids = glob.glob("*.mp4") + glob.glob("*.mov") + glob.glob("*.avi")
@@ -810,30 +783,45 @@ def main():
             else:
                 st.write("No videos found.")
 
-    # ─────────────────────────────────────────────────────────
-    # TAB: Editor
-    # ─────────────────────────────────────────────────────────
+    # 6d) ArXiv Tab
+    elif tab_main == "🔍 ArXiv":
+        st.subheader("🔍 Query ArXiv")
+        q = st.text_input("🔍 Query:", key="arxiv_query")
+        
+        st.markdown("### 🎛 Options")
+        st.write("(AutoRun is in the sidebar.)")
+        extended_refs = st.checkbox("📜LongRefs", value=False, key="option_extended_refs")
+        titles_summary = st.checkbox("🔖TitlesOnly", value=True, key="option_titles_summary")
+        full_audio = st.checkbox("📚FullAudio", value=False, key="option_full_audio")
+        full_transcript = st.checkbox("🧾FullTranscript", value=False, key="option_full_transcript")
+        
+        if q and st.button("🔍Run"):
+            st.session_state.last_query = q
+            result = perform_ai_lookup(q, 
+                                       extended_refs=extended_refs, 
+                                       titles_summary=titles_summary, 
+                                       full_audio=full_audio)
+            if full_transcript:
+                create_file(q, result, "md")
+
+        # If AutoRun is ON and user typed something
+        if st.session_state.autorun and q:
+            st.session_state.last_query = q
+            result = perform_ai_lookup(q, 
+                                       extended_refs=extended_refs, 
+                                       titles_summary=titles_summary, 
+                                       full_audio=full_audio)
+            if full_transcript:
+                create_file(q, result, "md")
+
+    # 6e) Editor Tab
     elif tab_main == "📝 Editor":
         st.write("Select or create a file to edit. (Currently minimal demo)")
 
-    # ─────────────────────────────────────────────────────────
-    # SIDEBAR: FILE HISTORY
-    # ─────────────────────────────────────────────────────────
-    display_file_history_in_sidebar()
-
-    # Some light CSS styling
-    st.markdown("""
-    <style>
-        .main { background: linear-gradient(to right, #1a1a1a, #2d2d2d); color: #fff; }
-        .stMarkdown { font-family: 'Helvetica Neue', sans-serif; }
-        .stButton>button { margin-right: 0.5rem; }
-    </style>
-    """, unsafe_allow_html=True)
-
     # Rerun if needed
     if st.session_state.should_rerun:
         st.session_state.should_rerun = False
-        st.rerun()
+        st.experimental_rerun()
 
 if __name__ == "__main__":
     main()