Update app.py

app.py

@@ -1,11 +1,9 @@
 import streamlit as st
 import anthropic, openai, base64, cv2, glob, json, math, os, pytz, random, re, requests, textract, time, zipfile
-import plotly.graph_objects as go
 import streamlit.components.v1 as components
 from datetime import datetime
-from audio_recorder_streamlit import audio_recorder
 from bs4 import BeautifulSoup
-from collections import defaultdict, deque
+from collections import defaultdict
 from dotenv import load_dotenv
 from gradio_client import Client
 from huggingface_hub import InferenceClient
@@ -13,17 +11,13 @@ from io import BytesIO
 from PIL import Image
 from PyPDF2 import PdfReader
 from urllib.parse import quote
-from xml.etree import ElementTree as ET
-from openai import OpenAI
-import extra_streamlit_components as stx
-from streamlit.runtime.scriptrunner import get_script_run_ctx
 import asyncio
 import edge_tts
 import io
 import sys
 import subprocess
 
-# 1. Core Configuration & Setup
+# 🧹 Clean up the environment and load keys
 st.set_page_config(
     page_title="🚲BikeAI🏆 Claude/GPT Research",
     page_icon="🚲🏆",
@@ -37,152 +31,76 @@ st.set_page_config(
 )
 load_dotenv()
 
-# 2. API Setup & Clients
 openai_api_key = os.getenv('OPENAI_API_KEY', "")
-anthropic_key = os.getenv('ANTHROPIC_API_KEY_3', "")
-if 'OPENAI_API_KEY' in st.secrets:
-    openai_api_key = st.secrets['OPENAI_API_KEY']
-if 'ANTHROPIC_API_KEY' in st.secrets:
-    anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
-
+anthropic_key = os.getenv('ANTHROPIC_API_KEY', "")
+if 'OPENAI_API_KEY' in st.secrets: openai_api_key = st.secrets['OPENAI_API_KEY']
+if 'ANTHROPIC_API_KEY' in st.secrets: anthropic_key = st.secrets["ANTHROPIC_API_KEY"]
 openai.api_key = openai_api_key
-claude_client = anthropic.Anthropic(api_key=anthropic_key)
-openai_client = OpenAI(api_key=openai.api_key, organization=os.getenv('OPENAI_ORG_ID'))
 HF_KEY = os.getenv('HF_KEY')
 API_URL = os.getenv('API_URL')
 
-# 3. Session State Management
-if 'transcript_history' not in st.session_state:
-    st.session_state['transcript_history'] = []
-if 'chat_history' not in st.session_state:
-    st.session_state['chat_history'] = []
-if 'openai_model' not in st.session_state:
-    st.session_state['openai_model'] = "gpt-4o-2024-05-13"
-if 'messages' not in st.session_state:
-    st.session_state['messages'] = []
-if 'last_voice_input' not in st.session_state:
-    st.session_state['last_voice_input'] = ""
-if 'editing_file' not in st.session_state:
-    st.session_state['editing_file'] = None
-if 'edit_new_name' not in st.session_state:
-    st.session_state['edit_new_name'] = ""
-if 'edit_new_content' not in st.session_state:
-    st.session_state['edit_new_content'] = ""
-if 'viewing_prefix' not in st.session_state:
-    st.session_state['viewing_prefix'] = None
-if 'should_rerun' not in st.session_state:
-    st.session_state['should_rerun'] = False
-if 'old_val' not in st.session_state:
-    st.session_state['old_val'] = None
-
-# 4. Custom CSS
+claude_client = anthropic.Anthropic(api_key=anthropic_key)
+# For GPT-4o calls
+openai_client = openai.ChatCompletion
+
+# 🧠 Session State
+for var in ['transcript_history','chat_history','openai_model','messages','last_voice_input',
+            'editing_file','edit_new_name','edit_new_content','viewing_prefix','should_rerun',
+            'old_val']:
+    if var not in st.session_state:
+        st.session_state[var] = [] if var.endswith('history') else None if var.startswith('view') else ""
+
+if not st.session_state.openai_model:
+    st.session_state.openai_model = "gpt-4-0613"  # Update to a stable GPT-4 model if needed
+
+# 🎨 Custom CSS
 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;
-    }
+    .stButton>button { margin-right: 0.5rem; }
 </style>
 """, unsafe_allow_html=True)
 
-FILE_EMOJIS = {
-    "md": "📝",
-    "mp3": "🎵",
-}
-
-# 5. High-Information Content Extraction
+# 🏷️ Helper for extracting high-info terms
 def get_high_info_terms(text: str) -> list:
     stop_words = set([
-        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with',
-        'by', 'from', 'up', 'about', 'into', 'over', 'after', 'is', 'are', 'was', 'were',
-        'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
-        'should', 'could', 'might', 'must', 'shall', 'can', 'may', 'this', 'that', 'these',
-        'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'what', 'which', 'who',
-        'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most',
-        'other', 'some', 'such', 'than', 'too', 'very', 'just', 'there'
+        'the','a','an','and','or','but','in','on','at','to','for','of','with','by','from','up','about','into','over','after','is','are','was','were','be','been','being','have','has','had','do','does','did','will','would','should','could','might','must','shall','can','may','this','that','these','those','i','you','he','she','it','we','they','what','which','who','when','where','why','how','all','any','both','each','few','more','most','other','some','such','than','too','very','just','there'
     ])
-
-    key_phrases = [
-        'artificial intelligence', 'machine learning', 'deep learning', 'neural network',
-        'personal assistant', 'natural language', 'computer vision', 'data science',
-        'reinforcement learning', 'knowledge graph', 'semantic search', 'time series',
-        'large language model', 'transformer model', 'attention mechanism',
-        'autonomous system', 'edge computing', 'quantum computing', 'blockchain technology',
-        'cognitive science', 'human computer', 'decision making', 'arxiv search',
-        'research paper', 'scientific study', 'empirical analysis'
-    ]
-
-    preserved_phrases = []
-    lower_text = text.lower()
-    for phrase in key_phrases:
-        if phrase in lower_text:
-            preserved_phrases.append(phrase)
-            text = text.replace(phrase, '')
-
-    words = re.findall(r'\b\w+(?:-\w+)*\b', text)
-    high_info_words = [
-        word.lower() for word in words 
-        if len(word) > 3
-        and word.lower() not in stop_words
-        and not word.isdigit()
-        and any(c.isalpha() for c in word)
-    ]
-
-    all_terms = preserved_phrases + high_info_words
+    text_lower = text.lower()
+    words = re.findall(r'\b\w+(?:-\w+)*\b', text_lower)
+    meaningful = [w for w in words if len(w)>3 and w not in stop_words and any(c.isalpha() for c in w)]
+    # Deduplicate while preserving order
     seen = set()
-    unique_terms = []
-    for term in all_terms:
-        if term not in seen:
-            seen.add(term)
-            unique_terms.append(term)
-
-    max_terms = 5
-    return unique_terms[:max_terms]
-
-# 6. Filename Generation
-def generate_filename(content, file_type="md"):
-    prefix = datetime.now().strftime("%y%m_%H%M") + "_"
-    info_terms = get_high_info_terms(content)
-    name_text = '_'.join(term.replace(' ', '-') for term in info_terms) if info_terms else 'file'
-    
-    max_length = 100
-    if len(name_text) > max_length:
-        name_text = name_text[:max_length]
-    
-    filename = f"{prefix}{name_text}.{file_type}"
-    return filename
-
-# 7. Audio Processing
+    uniq = [w for w in meaningful if not (w in seen or seen.add(w))]
+    return uniq[:5]
+
+# 🍱 Improved filename generation includes prompt & response terms
+def generate_filename(prompt, response, file_type="md"):
+    # Combine prompt & response for naming. The prompt terms have priority.
+    prompt_terms = get_high_info_terms(prompt)
+    response_terms = get_high_info_terms(response)
+    combined_terms = prompt_terms + [t for t in response_terms if t not in prompt_terms]
+    name_text = '_'.join(t.replace(' ','-') for t in combined_terms) or 'file'
+    # Limit length
+    name_text = name_text[:100]
+    prefix = datetime.now().strftime("%y%m_%H%M_")
+    return f"{prefix}{name_text}.{file_type}"
+
+# 🗣️ Clean text for speech
 def clean_for_speech(text: str) -> str:
-    text = text.replace("\n", " ")
-    text = text.replace("</s>", " ")
-    text = text.replace("#", "")
+    text = text.replace("\n", " ").replace("</s>", " ").replace("#","")
     text = re.sub(r"\(https?:\/\/[^\)]+\)", "", text)
-    text = re.sub(r"\s+", " ", text).strip()
-    return text
-
-@st.cache_resource
-def speech_synthesis_html(result):
-    html_code = f"""
-    <html><body>
-    <script>
-    var msg = new SpeechSynthesisUtterance("{result.replace('"', '')}");
-    window.speechSynthesis.speak(msg);
-    </script>
-    </body></html>
-    """
-    components.html(html_code, height=0)
+    return re.sub(r"\s+", " ", text).strip()
 
 async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0):
     text = clean_for_speech(text)
-    if not text.strip():
-        return None
+    if not text.strip(): return None
     rate_str = f"{rate:+d}%"
     pitch_str = f"{pitch:+d}Hz"
-    communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
-    out_fn = generate_filename(text, "mp3")
-    await communicate.save(out_fn)
+    com = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
+    out_fn = generate_filename(text, text, "mp3")
+    await com.save(out_fn)
     return out_fn
 
 def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0):
@@ -191,558 +109,271 @@ def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0):
 def play_and_download_audio(file_path):
     if file_path and os.path.exists(file_path):
         st.audio(file_path)
-        dl_link = f'<a href="data:audio/mpeg;base64,{base64.b64encode(open(file_path,"rb").read()).decode()}" download="{os.path.basename(file_path)}">Download {os.path.basename(file_path)}</a>'
-        st.markdown(dl_link, unsafe_allow_html=True)
-
-# 8. Media Processing
-def process_image(image_path, user_prompt):
-    with open(image_path, "rb") as imgf:
-        image_data = imgf.read()
-    b64img = base64.b64encode(image_data).decode("utf-8")
-    resp = openai_client.chat.completions.create(
-        model=st.session_state["openai_model"],
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": [
-                {"type": "text", "text": user_prompt},
-                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64img}"}}
-            ]}
-        ],
-        temperature=0.0,
-    )
-    return resp.choices[0].message.content
-
-def process_audio(audio_path):
-    with open(audio_path, "rb") as f:
-        transcription = openai_client.audio.transcriptions.create(model="whisper-1", file=f)
-    st.session_state.messages.append({"role":"user","content":transcription.text})
-    return transcription.text
-
-def process_video(video_path, seconds_per_frame=1):
-    vid = cv2.VideoCapture(video_path)
-    total = int(vid.get(cv2.CAP_PROP_FRAME_COUNT))
-    fps = vid.get(cv2.CAP_PROP_FPS)
-    skip = int(fps*seconds_per_frame)
-    frames_b64 = []
-    for i in range(0, total, skip):
-        vid.set(cv2.CAP_PROP_POS_FRAMES, i)
-        ret, frame = vid.read()
-        if not ret: break
-        _, buf = cv2.imencode(".jpg", frame)
-        frames_b64.append(base64.b64encode(buf).decode("utf-8"))
-    vid.release()
-    return frames_b64
-
-def process_video_with_gpt(video_path, prompt):
-    frames = process_video(video_path)
-    resp = openai_client.chat.completions.create(
-        model=st.session_state["openai_model"],
-        messages=[
-            {"role":"system","content":"Analyze video frames."},
-            {"role":"user","content":[
-                {"type":"text","text":prompt},
-                *[{"type":"image_url","image_url":{"url":f"data:image/jpeg;base64,{fr}"}} for fr in frames]
-            ]}
-        ]
-    )
-    return resp.choices[0].message.content
-
-# Execution context for code blocks
+        enc = base64.b64encode(open(file_path,"rb").read()).decode()
+        st.markdown(f'<a href="data:audio/mpeg;base64,{enc}" download="{os.path.basename(file_path)}">Download {os.path.basename(file_path)}</a>', unsafe_allow_html=True)
+
+# 🧰 Code execution environment
 context = {}
 
-# 9. Updated create_file function with error handling
-def create_file(filename, prompt, response, should_save=True):
-    if not should_save:
-        return
+# 🛠️ Executes Python code blocks safely, returning combined output
+def execute_python_blocks(response):
+    combined = ""
+    code_blocks = re.findall(r'```(?:python\s*)?([\s\S]*?)```', response, re.IGNORECASE)
+    for code_block in code_blocks:
+        old_stdout = sys.stdout
+        sys.stdout = io.StringIO()
+        try:
+            exec(code_block, context)
+            code_output = sys.stdout.getvalue()
+            combined += f"# Code Execution Output\n```\n{code_output}\n```\n\n"
+            st.code(code_output)
+        except Exception as e:
+            combined += f"# Execution Error\n```python\n{e}\n```\n\n"
+        finally:
+            sys.stdout = old_stdout
+    return combined
+
+# 🗃️ Creates & saves a file with prompt/response and executed code results
+def create_file(filename, prompt, response):
+    base, ext = os.path.splitext(filename)
+    content = f"# Prompt 📝\n{prompt}\n\n# Response 💬\n{response}\n\n"
+    # Execute code in response
+    exec_results = execute_python_blocks(response)
+    content += exec_results
+    # Save
+    with open(f"{base}.md", 'w', encoding='utf-8') as file:
+        file.write(content)
+    # Download link
+    with open(f"{base}.md", 'rb') as file:
+        encoded = base64.b64encode(file.read()).decode()
+    href = f'<a href="data:file/markdown;base64,{encoded}" download="{filename}">Download File 📄</a>'
+    st.markdown(href, unsafe_allow_html=True)
+
+# 🎨 Unified AI call helper
+def call_model(model_type, text):
+    # model_type: "Arxiv", "GPT-4", or "Claude"
+    # Returns (answer, filename)
+    if model_type == "Claude":
+        try:
+            r = claude_client.completions.create(
+                prompt=anthropic.HUMAN_PROMPT + text + anthropic.AI_PROMPT, 
+                model="claude-instant-1", 
+                max_tokens_to_sample=1000
+            )
+            ans = r.completion.strip()
+        except Exception as e:
+            ans = f"Error calling Claude: {e}"
+    elif model_type == "Arxiv":
+        # ArXiv RAG flow
+        client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
+        refs = client.predict(text,20,"Semantic Search","mistralai/Mixtral-8x7B-Instruct-v0.1",api_name="/update_with_rag_md")[0]
+        r2 = client.predict(text,"mistralai/Mixtral-8x7B-Instruct-v0.1",True,api_name="/ask_llm")
+        ans = f"### 🔎 {text}\n\n{r2}\n\n{refs}"
+    else:
+        # GPT-4o call
+        try:
+            c = openai_client.create(
+                model=st.session_state.openai_model,
+                messages=[{"role":"system","content":"You are a helpful assistant."},{"role":"user","content":text}]
+            )
+            ans = c.choices[0].message.content.strip()
+        except Exception as e:
+            ans = f"Error calling GPT-4: {e}"
+    filename = generate_filename(text, ans, "md")
+    create_file(filename, text, ans)
+    return ans
 
-    base_filename, ext = os.path.splitext(filename)
-    combined_content = ""
-
-    combined_content += "# Prompt 📝\n" + prompt + "\n\n"
-    combined_content += "# Response 💬\n" + response + "\n\n"
-
-    resources = re.findall(r"```([\s\S]*?)```", response)
-    for resource in resources:
-        if "python" in resource.lower():
-            cleaned_code = re.sub(r'^\s*python', '', resource, flags=re.IGNORECASE | re.MULTILINE)
-
-            combined_content += "# Code Results 🚀\n"
-
-            original_stdout = sys.stdout
-            sys.stdout = io.StringIO()
-            try:
-                exec(cleaned_code, context)
-                code_output = sys.stdout.getvalue()
-                combined_content += f"```\n{code_output}\n```\n\n"
-                realtimeEvalResponse = "# Code Results 🚀\n" + "```" + code_output + "```\n\n"
-                st.code(realtimeEvalResponse)
-            except Exception as e:
-                combined_content += f"```python\nError executing Python code: {e}\n```\n\n"
-            sys.stdout = original_stdout
-        else:
-            combined_content += "# Resource 🛠️\n" + "```" + resource + "```\n\n"
-
-    if should_save:
-        with open(f"{base_filename}.md", 'w') as file:
-            file.write(combined_content)
-            st.code(combined_content)
-
-    with open(f"{base_filename}.md", 'rb') as file:
-        encoded_file = base64.b64encode(file.read()).decode()
-        href = f'<a href="data:file/markdown;base64,{encoded_file}" download="{filename}">Download File 📄</a>'
-        st.markdown(href, unsafe_allow_html=True)
-
-def generate_code_from_paper(title, summary, instructions):
-    code_prompt = f"""
-You are a coding assistant. 
-Given the paper titled: "{title}"
-Summary: "{summary}"
-
-The user wants to implement the following steps in Python code. Provide a minimal, self-contained Python code snippet that:
-
-1. Uses only standard libraries if possible. If a library is required, include a code snippet that uses subprocess to install it (like `subprocess.run(['pip','install','somepackage'])`).
-2. Implement the requested functionality as simple functions and variables, minimal code.
-3. Include error handling: if a file is missing, print an error message. Wrap code in a `try/except` block.
-4. Output should be minimal, just the code block (no extra explanations), enclosed in triple backticks.
-
-User instructions: "{instructions}"
-"""
-
-    try:
-        completion = openai_client.chat.completions.create(
-            model=st.session_state["openai_model"],
-            messages=[
-                {"role": "system", "content": "You are a helpful coding assistant."},
-                {"role": "user", "content": code_prompt}
-            ],
-            temperature=0.0
-        )
-        generated_code = completion.choices[0].message.content
-        return generated_code
-    except Exception as e:
-        st.error(f"Error generating code: {e}")
-        return ""
-
-# 10. AI Model Integration
-def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False):
-    start = time.time()
-    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-    r = client.predict(q,20,"Semantic Search","mistralai/Mixtral-8x7B-Instruct-v0.1",api_name="/update_with_rag_md")
-    refs = r[0]
-    r2 = client.predict(q,"mistralai/Mixtral-8x7B-Instruct-v0.1",True,api_name="/ask_llm")
-    result = f"### 🔎 {q}\n\n{r2}\n\n{refs}"
-
-    st.markdown(result)
+# 🎶 Audio response options
+def handle_audio_generation(q, ans, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False):
+    # This is used only for ArXiv results
+    if not ans.startswith("### 🔎"):
+        return
+    # Extract sections for audio generation
+    # The main short answer is r2: We'll approximate by splitting at double-newline.
+    parts = ans.split("\n\n")
+    if len(parts)>2:
+        short_answer = parts[1]
+        refs = parts[-1]
+    else:
+        short_answer = ans
+        refs = ""
 
     if full_audio:
-        complete_text = f"Complete response for query: {q}. {clean_for_speech(r2)} {clean_for_speech(refs)}"
-        audio_file_full = speak_with_edge_tts(complete_text)
+        complete_text = f"Complete response for query: {q}. {clean_for_speech(short_answer)} {clean_for_speech(refs)}"
+        f_all = speak_with_edge_tts(complete_text)
         st.write("### 📚 Complete Audio Response")
-        play_and_download_audio(audio_file_full)
+        play_and_download_audio(f_all)
 
     if vocal_summary:
-        main_text = clean_for_speech(r2)
-        audio_file_main = speak_with_edge_tts(main_text)
-        st.write("### 🎙️ Vocal Summary (Short Answer)")
-        play_and_download_audio(audio_file_main)
-
-    if extended_refs:
-        summaries_text = "Here are the summaries from the references: " + refs.replace('"','')
-        summaries_text = clean_for_speech(summaries_text)
-        audio_file_refs = speak_with_edge_tts(summaries_text)
+        main_audio = speak_with_edge_tts(short_answer)
+        st.write("### 🎙️ Vocal Summary")
+        play_and_download_audio(main_audio)
+
+    if extended_refs and refs.strip():
+        ref_audio = speak_with_edge_tts("Here are the extended references: " + refs)
         st.write("### 📜 Extended References & Summaries")
-        play_and_download_audio(audio_file_refs)
-
-    if titles_summary:
-        titles = []
-        for line in refs.split('\n'):
-            m = re.search(r"\[([^\]]+)\]", line)
-            if m:
-                titles.append(m.group(1))
+        play_and_download_audio(ref_audio)
+
+    if titles_summary and refs.strip():
+        titles = [m.group(1) for line in refs.split('\n') for m in [re.search(r"\[([^\]]+)\]", line)] if m]
         if titles:
             titles_text = "Here are the titles of the papers: " + ", ".join(titles)
-            titles_text = clean_for_speech(titles_text)
-            audio_file_titles = speak_with_edge_tts(titles_text)
+            t_audio = speak_with_edge_tts(titles_text)
             st.write("### 🔖 Paper Titles")
-            play_and_download_audio(audio_file_titles)
-
-    elapsed = time.time()-start
-    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-
-    filename = generate_filename(result, "md")
-    create_file(filename, q, result, should_save=True)
-
-    # Parse out papers
-    papers_raw = refs.strip().split("[Title]")
-    papers = []
-    for p in papers_raw:
-        p = p.strip()
-        if not p:
-            continue
-        lines = p.split("\n")
-        title_line = lines[0].strip() if lines else ""
-        summary_line = ""
-        link_line = ""
-        pdf_line = ""
-        for line in lines[1:]:
-            line = line.strip()
-            if line.startswith("Summary:"):
-                summary_line = line.replace("Summary:", "").strip()
-            elif line.startswith("Link:"):
-                link_line = line.replace("Link:", "").strip()
-            elif line.startswith("PDF:"):
-                pdf_line = line.replace("PDF:", "").strip()
-
-        if title_line and summary_line:
-            papers.append({
-                "title": title_line,
-                "summary": summary_line,
-                "link": link_line,
-                "pdf": pdf_line
-            })
-
-    st.write("## Code Interpreter Options for Each Paper")
-    for i, paper in enumerate(papers):
-        st.write(f"**Paper {i+1}:** {paper['title']}")
-        st.write(f"**Summary:** {paper['summary']}")
-        if paper['link']:
-            st.write(f"[Arxiv Link]({paper['link']})")
-        if paper['pdf']:
-            st.write(f"[PDF]({paper['pdf']})")
-
-        # UI for generating code steps
-        with st.expander("Generate Python Code Steps"):
-            instructions = st.text_area(
-                f"Enter instructions for Python code implementation for this paper:",
-                height=100, key=f"code_task_{i}"
-            )
-            if st.button(f"Generate Python Code Steps for Paper {i+1}", key=f"gen_code_{i}"):
-                if instructions.strip():
-                    generated_code = generate_code_from_paper(paper['title'], paper['summary'], instructions)
-                    if generated_code.strip():
-                        st.write("### Generated Code")
-                        st.code(generated_code, language="python")
-
-                        # Attempt to run the generated code
-                        if '```' in generated_code:
-                            # Extract code blocks
-                            code_blocks = re.findall(r"```([\s\S]*?)```", generated_code)
-                            for cb in code_blocks:
-                                # Try executing cb
-                                original_stdout = sys.stdout
-                                sys.stdout = io.StringIO()
-                                try:
-                                    exec(cb, {})
-                                    exec_output = sys.stdout.getvalue()
-                                    if exec_output.strip():
-                                        st.write("### Code Output")
-                                        st.write(exec_output)
-                                        # TTS on code output
-                                        audio_file = speak_with_edge_tts(exec_output)
-                                        if audio_file:
-                                            play_and_download_audio(audio_file)
-                                except Exception as e:
-                                    st.error(f"Error executing code: {e}")
-                                finally:
-                                    sys.stdout = original_stdout
-                    else:
-                        st.error("No code was generated.")
-                else:
-                    st.warning("Please provide instructions before generating code.")
-
-    return result
-
-def process_with_gpt(text):
-    if not text: return
-    st.session_state.messages.append({"role":"user","content":text})
-    with st.chat_message("user"):
-        st.markdown(text)
-    with st.chat_message("assistant"):
-        try:
-            c = openai_client.chat.completions.create(
-                model=st.session_state["openai_model"],
-                messages=st.session_state.messages,
-                stream=False
-            )
-            ans = c.choices[0].message.content
-        except Exception as e:
-            ans = f"Error calling GPT-4 API: {e}"
+            play_and_download_audio(t_audio)
 
-        st.write("GPT-4o: " + ans)
-        filename = generate_filename(ans.strip() if ans.strip() else text.strip(), "md")
-        create_file(filename, text, ans, should_save=True)
-        st.session_state.messages.append({"role":"assistant","content":ans})
-    return ans
-
-def process_with_claude(text):
-    if not text: return
-    with st.chat_message("user"):
-        st.markdown(text)
-    with st.chat_message("assistant"):
-        try:
-            r = claude_client.messages.create(
-                model="claude-3-sonnet-20240229",
-                max_tokens=1000,
-                messages=[{"role":"user","content":text}]
-            )
-            ans = r.content[0].text
-        except Exception as e:
-            ans = f"Error calling Claude API: {e}"
-
-        st.write("Claude-3.5: " + ans)
-        filename = generate_filename(ans.strip() if ans.strip() else text.strip(), "md")
-        create_file(filename, text, ans, should_save=True)
-        st.session_state.chat_history.append({"user":text,"claude":ans})
-    return ans
-
-# 11. File Management
-def create_zip_of_files(md_files, mp3_files):
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files
-    if not all_files:
-        return None
-
-    all_content = []
+# 🏦 File Management
+def create_zip_of_files():
+    md_files = glob.glob("*.md")
+    mp3_files = glob.glob("*.mp3")
+    if not (md_files or mp3_files): return None
+    all_files = md_files+mp3_files
+    # Derive name from their content
+    text_combined = ""
     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'):
-            all_content.append(os.path.basename(f))
-    
-    combined_content = " ".join(all_content)
-    info_terms = get_high_info_terms(combined_content)
-    
-    timestamp = datetime.now().strftime("%y%m_%H%M")
-    name_text = '_'.join(term.replace(' ', '-') for term in info_terms[:3])
-    zip_name = f"{timestamp}_{name_text}.zip"
-    
+        if f.endswith(".md"):
+            text_combined += open(f,'r',encoding='utf-8').read()
+    terms = get_high_info_terms(text_combined)
+    name_text = '_'.join(terms[:3]) or 'archive'
+    zip_name = f"{datetime.now().strftime('%y%m_%H%M')}_{name_text}.zip"
     with zipfile.ZipFile(zip_name,'w') as z:
         for f in all_files:
             z.write(f)
-    
     return zip_name
 
 def load_files_for_sidebar():
-    md_files = glob.glob("*.md")
-    mp3_files = glob.glob("*.mp3")
-
-    md_files = [f for f in md_files if os.path.basename(f).lower() != 'readme.md']
-    all_files = md_files + mp3_files
-
+    md = glob.glob("*.md")
+    mp3 = glob.glob("*.mp3")
+    allf = md+mp3
     groups = defaultdict(list)
-    for f in all_files:
-        fname = os.path.basename(f)
-        prefix = fname[:10]
+    for f in allf:
+        prefix = os.path.basename(f)[:10]
         groups[prefix].append(f)
+    sorted_pref = sorted(groups.keys(), key=lambda pre: max(os.path.getmtime(x) for x in groups[pre]), reverse=True)
+    return groups, sorted_pref
 
-    for prefix in groups:
-        groups[prefix].sort(key=lambda x: os.path.getmtime(x), reverse=True)
-
-    sorted_prefixes = sorted(groups.keys(), 
-                           key=lambda pre: max(os.path.getmtime(x) for x in groups[pre]), 
-                           reverse=True)
-    return groups, sorted_prefixes
-
-def extract_keywords_from_md(files):
-    text = ""
-    for f in files:
-        if f.endswith(".md"):
-            c = open(f,'r',encoding='utf-8').read()
-            text += " " + c
-    return get_high_info_terms(text)
-
-def display_file_manager_sidebar(groups, sorted_prefixes):
+def display_file_manager_sidebar():
     st.sidebar.title("🎵 Audio & Document Manager")
+    groups, sorted_pref = load_files_for_sidebar()
 
-    all_md = []
-    all_mp3 = []
-    for prefix in groups:
-        for f in groups[prefix]:
-            if f.endswith(".md"):
-                all_md.append(f)
-            elif f.endswith(".mp3"):
-                all_mp3.append(f)
+    all_md = [f for f in glob.glob("*.md") if os.path.basename(f).lower()!='readme.md']
+    all_mp3 = glob.glob("*.mp3")
 
     top_bar = st.sidebar.columns(3)
     with top_bar[0]:
         if st.button("🗑 Del All MD"):
-            for f in all_md:
-                os.remove(f)
+            for f in all_md: os.remove(f)
             st.session_state.should_rerun = True
     with top_bar[1]:
         if st.button("🗑 Del All MP3"):
-            for f in all_mp3:
-                os.remove(f)
+            for f in all_mp3: os.remove(f)
             st.session_state.should_rerun = True
     with top_bar[2]:
         if st.button("⬇️ Zip All"):
-            z = create_zip_of_files(all_md, all_mp3)
+            z = create_zip_of_files()
             if z:
-                with open(z, "rb") as f:
+                with open(z,"rb") as f:
                     b64 = base64.b64encode(f.read()).decode()
-                dl_link = f'<a href="data:file/zip;base64,{b64}" download="{os.path.basename(z)}">📂 Download {os.path.basename(z)}</a>'
-                st.sidebar.markdown(dl_link,unsafe_allow_html=True)
+                st.sidebar.markdown(f'<a href="data:file/zip;base64,{b64}" download="{os.path.basename(z)}">📂 Download {os.path.basename(z)}</a>', unsafe_allow_html=True)
 
-    for prefix in sorted_prefixes:
+    for prefix in sorted_pref:
         files = groups[prefix]
-        kw = extract_keywords_from_md(files)
-        keywords_str = " ".join(kw) if kw else "No Keywords"
-        with st.sidebar.expander(f"{prefix} Files ({len(files)}) - Keywords: {keywords_str}", expanded=True):
+        # Extract simple keywords
+        txt = ""
+        for f in files:
+            if f.endswith(".md"):
+                txt+=open(f,'r',encoding='utf-8').read()+" "
+        kw = get_high_info_terms(txt)
+        kw_str = " ".join(kw) if kw else "No Keywords"
+        with st.sidebar.expander(f"{prefix} Files ({len(files)}) - {kw_str}", expanded=True):
             c1,c2 = st.columns(2)
             with c1:
-                if st.button("👀View Group", key="view_group_"+prefix):
+                if st.button("👀View Group", key="view_"+prefix):
                     st.session_state.viewing_prefix = prefix
             with c2:
-                if st.button("🗑Del Group", key="del_group_"+prefix):
-                    for f in files:
-                        os.remove(f)
-                    st.success(f"Deleted all files in group {prefix} successfully!")
+                if st.button("🗑Del Group", key="del_"+prefix):
+                    for f in files: os.remove(f)
+                    st.success(f"Deleted group {prefix}")
                     st.session_state.should_rerun = True
-
             for f in files:
-                fname = os.path.basename(f)
                 ctime = datetime.fromtimestamp(os.path.getmtime(f)).strftime("%Y-%m-%d %H:%M:%S")
-                st.write(f"**{fname}** - {ctime}")
+                st.write(f"**{os.path.basename(f)}** - {ctime}")
+
+    # Viewing group
+    if st.session_state.viewing_prefix and st.session_state.viewing_prefix in groups:
+        st.write("---")
+        st.write(f"**Viewing Group:** {st.session_state.viewing_prefix}")
+        for f in groups[st.session_state.viewing_prefix]:
+            ext = f.split('.')[-1].lower()
+            st.write(f"### {os.path.basename(f)}")
+            if ext == "md":
+                c = open(f,'r',encoding='utf-8').read()
+                st.markdown(c)
+            elif ext == "mp3":
+                st.audio(f)
+            else:
+                with open(f,"rb") as fil:
+                    enc = base64.b64encode(fil.read()).decode()
+                st.markdown(f'<a href="data:file/{ext};base64,{enc}" download="{os.path.basename(f)}">Download {os.path.basename(f)}</a>', unsafe_allow_html=True)
+        if st.button("Close Group View"):
+            st.session_state.viewing_prefix = None
 
-# 12. Main Application
 def main():
     st.sidebar.markdown("### 🚲BikeAI🏆 Multi-Agent Research AI")
-    tab_main = st.radio("Action:",["🎤 Voice Input","📸 Media Gallery","🔍 Search ArXiv","📝 File Editor"],horizontal=True)
+    tab_main = st.radio("Action:",["🎤 Voice Input","🔍 Search ArXiv","📝 File Editor"],horizontal=True)
 
+    # A small custom component hook (if used)
     mycomponent = components.declare_component("mycomponent", path="mycomponent")
     val = mycomponent(my_input_value="Hello")
 
-    # Show input in a text box for editing if detected
+    # If we have component input, show controls
     if val:
-        val_stripped = val.replace('\n', ' ')
-        edited_input = st.text_area("Edit your detected input:", value=val_stripped, height=100)
-        run_option = st.selectbox("Select AI Model:", ["Arxiv", "GPT-4o", "Claude-3.5"])
+        edited_input = st.text_area("Edit your detected input:", value=val.strip().replace('\n',' '), height=100)
+        run_option = st.selectbox("Select AI Model:", ["Arxiv", "GPT-4", "Claude"])
         col1, col2 = st.columns(2)
         with col1:
             autorun = st.checkbox("AutoRun on input change", value=False)
         with col2:
-            full_audio = st.checkbox("Generate Complete Audio", value=False, 
-                                   help="Generate audio for the complete response including all papers and summaries")
-
+            full_audio = st.checkbox("Generate Complete Audio", value=False)
         input_changed = (val != st.session_state.old_val)
 
-        if autorun and input_changed:
+        if (autorun and input_changed) or st.button("Process Input"):
             st.session_state.old_val = val
-            if run_option == "Arxiv":
-                perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                titles_summary=True, full_audio=full_audio)
-            else:
-                if run_option == "GPT-4o":
-                    process_with_gpt(edited_input)
-                elif run_option == "Claude-3.5":
-                    process_with_claude(edited_input)
-        else:
-            if st.button("Process Input"):
-                st.session_state.old_val = val
-                if run_option == "Arxiv":
-                    perform_ai_lookup(edited_input, vocal_summary=True, extended_refs=False, 
-                                    titles_summary=True, full_audio=full_audio)
-                else:
-                    if run_option == "GPT-4o":
-                        process_with_gpt(edited_input)
-                    elif run_option == "Claude-3.5":
-                        process_with_claude(edited_input)
+            ans = call_model("Arxiv" if run_option=="Arxiv" else ("Claude" if run_option=="Claude" else "GPT-4"), edited_input)
+            if run_option=="Arxiv":
+                # Audio generation for Arxiv
+                handle_audio_generation(edited_input, ans, True, False, True, full_audio)
 
     if tab_main == "🔍 Search ArXiv":
-        st.subheader("🔍 Search ArXiv")
         q = st.text_input("Research query:")
-
         st.markdown("### 🎛️ Audio Generation Options")
-        vocal_summary = st.checkbox("🎙️ Vocal Summary (Short Answer)", value=True)
-        extended_refs = st.checkbox("📜 Extended References & Summaries (Long)", value=False)
-        titles_summary = st.checkbox("🔖 Paper Titles Only", value=True)
-        full_audio = st.checkbox("📚 Generate Complete Audio Response", value=False,
-                               help="Generate audio for the complete response including all papers and summaries")
+        vocal_summary = st.checkbox("Short Answer Audio", True)
+        extended_refs = st.checkbox("Extended References Audio", False)
+        titles_summary = st.checkbox("Paper Titles Audio", True)
+        full_audio = st.checkbox("Full Audio Response", False)
 
         if q and st.button("Run ArXiv Query"):
-            perform_ai_lookup(q, vocal_summary=vocal_summary, extended_refs=extended_refs, 
-                            titles_summary=titles_summary, full_audio=full_audio)
+            ans = call_model("Arxiv", q)
+            handle_audio_generation(q, ans, vocal_summary, extended_refs, titles_summary, full_audio)
 
     elif tab_main == "🎤 Voice Input":
-        st.subheader("🎤 Voice Recognition")
         user_text = st.text_area("Message:", height=100)
-        user_text = user_text.strip().replace('\n', ' ')
+        user_text = user_text.strip()
         if st.button("Send 📨"):
-            process_with_gpt(user_text)
+            ans = call_model("GPT-4", user_text)
+            st.session_state.messages.append({"role":"user","content":user_text})
+            st.session_state.messages.append({"role":"assistant","content":ans})
         st.subheader("📜 Chat History")
-        t1,t2=st.tabs(["Claude History","GPT-4o History"])
-        with t1:
-            for c in st.session_state.chat_history:
-                st.write("**You:**", c["user"])
-                st.write("**Claude:**", c["claude"])
-        with t2:
-            for m in st.session_state.messages:
-                with st.chat_message(m["role"]):
-                    st.markdown(m["content"])
-
-    elif tab_main == "📸 Media Gallery":
-        st.header("🎬 Media Gallery - Images and Videos")
-        tabs = st.tabs(["🖼️ Images", "🎥 Video"])
-        with tabs[0]:
-            imgs = glob.glob("*.png")+glob.glob("*.jpg")
-            if imgs:
-                c = st.slider("Cols",1,5,3)
-                cols = st.columns(c)
-                for i,f in enumerate(imgs):
-                    with cols[i%c]:
-                        st.image(Image.open(f),use_container_width=True)
-                        if st.button(f"👀 Analyze {os.path.basename(f)}", key=f"analyze_{f}"):
-                            a = process_image(f,"Describe this image.")
-                            st.markdown(a)
-            else:
-                st.write("No images found.")
-        with tabs[1]:
-            vids = glob.glob("*.mp4")
-            if vids:
-                for v in vids:
-                    with st.expander(f"🎥 {os.path.basename(v)}"):
-                        st.video(v)
-                        if st.button(f"Analyze {os.path.basename(v)}", key=f"analyze_{v}"):
-                            a = process_video_with_gpt(v,"Describe video.")
-                            st.markdown(a)
-            else:
-                st.write("No videos found.")
+        for m in st.session_state.messages:
+            with st.chat_message(m["role"]):
+                st.markdown(m["content"])
 
     elif tab_main == "📝 File Editor":
-        if getattr(st.session_state,'current_file',None):
-            st.subheader(f"Editing: {st.session_state.current_file}")
-            new_text = st.text_area("Content:", st.session_state.file_content, height=300)
-            if st.button("Save"):
-                with open(st.session_state.current_file,'w',encoding='utf-8') as f:
-                    f.write(new_text)
-                st.success("Updated!")
-                st.session_state.should_rerun = True
-        else:
-            st.write("Select a file from the sidebar to edit.")
-
-    groups, sorted_prefixes = load_files_for_sidebar()
-    display_file_manager_sidebar(groups, sorted_prefixes)
+        # For simplicity, user selects from sidebar
+        st.write("Select a file from the sidebar to edit.")
 
-    if st.session_state.viewing_prefix and st.session_state.viewing_prefix in groups:
-        st.write("---")
-        st.write(f"**Viewing Group:** {st.session_state.viewing_prefix}")
-        for f in groups[st.session_state.viewing_prefix]:
-            fname = os.path.basename(f)
-            ext = os.path.splitext(fname)[1].lower().strip('.')
-            st.write(f"### {fname}")
-            if ext == "md":
-                content = open(f,'r',encoding='utf-8').read()
-                st.markdown(content)
-            elif ext == "mp3":
-                st.audio(f)
-            else:
-                with open(f, "rb") as file:
-                    b64 = base64.b64encode(file.read()).decode()
-                dl_link = f'<a href="data:file/{ext};base64,{b64}" download="{fname}">Download {fname}</a>'
-                st.markdown(dl_link, unsafe_allow_html=True)
-        if st.button("Close Group View"):
-            st.session_state.viewing_prefix = None
+    # Display File Manager
+    display_file_manager_sidebar()
 
     if st.session_state.should_rerun:
         st.session_state.should_rerun = False