Create app.py

app.py

@@ -0,0 +1,684 @@
+import gradio as gr
+import os
+import time
+import re
+import random
+import torch
+from huggingface_hub import hf_hub_download
+from llama_cpp import Llama
+from typing import List, Dict, Any, Tuple
+from PIL import Image
+from transformers import pipeline
+from gtts import gTTS 
+from diffusers import StableDiffusionPipeline
+from docx import Document 
+from pptx import Presentation 
+from io import BytesIO 
+
+# --- CONFIGURATION & INITIALIZATION ---
+# Set device for pipelines (STT/VQA/ImageGen). Use "cpu" for compatibility.
+STT_DEVICE = "cpu" 
+os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'
+AUDIO_DIR = "audio_outputs"
+DOC_DIR = "doc_outputs" 
+if not os.path.exists(AUDIO_DIR):
+    os.makedirs(AUDIO_DIR)
+if not os.path.exists(DOC_DIR):
+    os.makedirs(DOC_DIR)
+
+# Hugging Face Model Info
+REPO_ID = "cosmosai471/Luna-v3"
+MODEL_FILE = "luna.gguf"
+LOCAL_MODEL_PATH = MODEL_FILE 
+
+# Updated SYSTEM PROMPT for Intent Tagging 
+SYSTEM_PROMPT = "You are Luna, a helpful and friendly AI assistant. When responding, start your response with an **Intent** tag based on the user's request, such as '[Intent: code_generate]', '[Intent: code_explain]', '[Intent: qa_general]', '[Intent: image_generate]', '[Intent: doc_generate]', '[Intent: ppt_generate]', '[Intent: open_camera]', '[Intent: open_google]', or '[Intent: greeting]'. Your response must be complete."
+
+# Helper to safely delete Llama instance (prevents resource leaks)
+def safe_del(self):
+    try:
+        if hasattr(self, "close") and callable(self.close):
+            self.close()
+    except Exception:
+        pass
+Llama.__del__ = safe_del
+
+# --- MODEL LOADING ---
+llm = None
+try:
+    print(f"Downloading {MODEL_FILE} from {REPO_ID}...")
+    hf_hub_download(repo_id=REPO_ID, filename=MODEL_FILE, local_dir=".")
+    if not os.path.exists(LOCAL_MODEL_PATH):
+        raise FileNotFoundError(f"Download failed for {MODEL_FILE}")
+
+    print("Initializing Llama...")
+    llm = Llama(
+        model_path=LOCAL_MODEL_PATH,
+        n_ctx=8192,  
+        n_threads=4,     
+        n_batch=256,     
+        n_gpu_layers=0,  
+        verbose=False
+    )
+    print("✅ Luna Model loaded successfully!")
+except Exception as e:
+    print(f"❌ Error loading Luna model: {e}")
+    class DummyLLM:
+        def create_completion(self, *args, **kwargs):
+            yield {'choices': [{'text': 'ERROR: Luna model failed to load. Check logs and resources.'}]}
+    llm = DummyLLM()
+
+# --- MULTIMODAL PIPELINE LOADING ---
+stt_pipe = None
+try:
+    stt_pipe = pipeline("automatic-speech-recognition", model="openai/whisper-base", device=STT_DEVICE)
+    print(f"✅ Loaded Whisper-base on device: {STT_DEVICE}")
+except Exception as e:
+    print(f"⚠️ Could not load Whisper. Voice chat disabled. Error: {e}")
+
+image_pipe = None
+try:
+    VLM_MODEL_ID = "llava-hf/llava-1.5-7b-hf" 
+    image_pipe = pipeline("image-to-text", model=VLM_MODEL_ID, device=STT_DEVICE)
+    print(f"✅ Loaded {VLM_MODEL_ID} for image processing.")
+except Exception as e:
+    print(f"⚠️ Could not load VLM ({VLM_MODEL_ID}). Image chat disabled. Error: {e}")
+
+img_gen_pipe = None
+try:
+    img_gen_pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float32)
+    img_gen_pipe.to(STT_DEVICE) 
+    print("✅ Loaded Stable Diffusion (v1-5) for image generation.")
+except Exception as e:
+    print(f"⚠️ Could not load Image Generation pipeline. Image generation disabled. Error: {e}")
+
+
+# --- UTILITY FUNCTIONS ---
+
+def simulate_recording_delay():
+    """Simulates a 3-second recording time for the UI flow."""
+    time.sleep(3)
+    return None 
+
+def clean_response_stream(raw_text: str) -> str:
+    """Cleans up raw LLaMA-style output and removes repeats."""
+    # 1. Strip stop tokens
+    clean_text = re.split(r'\nUser:|\nAssistant:|</s>|Intent|Action', raw_text, 1)[0].strip()
+    
+    # 2. Remove instruction/action markers
+    clean_text = re.sub(r'\[/?INST\]|\[/?s\]|\s*<action>.*?</action>\s*', '', clean_text, flags=re.DOTALL).strip()
+    
+    # 3. Simple word-repeat check
+    words = clean_text.split()
+    if len(words) > 4 and words[-2:] == words[-4:-2]: 
+        clean_text = ' '.join(words[:-2])
+        
+    return clean_text
+
+def web_search_tool(query: str) -> str:
+    """Simulated Google Search Fallback."""
+    time.sleep(1.5) 
+    print(f"Simulating Google Search fallback for: {query}")
+    return f"\n\n🌐 **Web Search Results for '{query}':** I've gathered information from external sources to supplement my knowledge."
+
+def check_confidence_and_augment(raw_response: str, prompt: str) -> str:
+    """Simulated check for confidence. Triggers fallback if response is deemed inadequate."""
+    cleaned_response = clean_response_stream(raw_response)
+    
+    if "error" in cleaned_response.lower() or len(cleaned_response.split()) < 10:
+        print("Low confidence/short response detected. Triggering Google Search fallback.")
+        search_snippet = web_search_tool(prompt)
+        
+        if "error" in cleaned_response.lower():
+             final_response = f"I apologize for the limited response. {search_snippet} I will use this to generate a more comprehensive answer."
+        else:
+            final_response = f"{cleaned_response} {search_snippet} I can elaborate further based on this."
+    else:
+        final_response = cleaned_response
+        
+    return final_response
+
+def process_image(image_path: str, message: str) -> str:
+    """Uses the VLM pipeline (LLaVA) for Visual Question Answering (VQA)."""
+    global image_pipe
+    if image_path and image_pipe:
+        try:
+            image = Image.open(image_path).convert("RGB")
+            vqa_prompt = f"USER: {message}\nASSISTANT:"
+            
+            results = image_pipe(image, prompt=vqa_prompt)
+            vqa_response = results[0]['generated_text'] if results else "The image could not be processed."
+            del image
+            
+            prompt_injection = f"**Image Analysis (VQA):** {vqa_response}\n\n**User Query:** {message}"
+            return prompt_injection
+        except Exception as e:
+            print(f"Image Pipeline Error: {e}")
+            return f"[Image Processing Error: {e}] **User Query:** {message}"
+    
+    return message
+
+def transcribe_audio(audio_file_path: str) -> Tuple[str, str, gr.update, gr.update, bool, gr.update]:
+    """Transcribes audio file using Whisper."""
+    if stt_pipe is None or audio_file_path is None:
+        error_msg = "Error: Whisper model failed to load or no audio recorded."
+        return "", error_msg, gr.update(interactive=True), gr.update(value="↑", interactive=True, elem_classes=["circle-btn", "send-mode"]), False, gr.update(visible=False)
+
+    try:
+        transcribed_text = stt_pipe(audio_file_path)["text"]
+        new_button_update = gr.update(value="↑", interactive=True, elem_classes=["circle-btn", "send-mode"])
+        
+        return (
+            transcribed_text.strip(), 
+            f"🎙️ Transcribed: '{transcribed_text.strip()}'", 
+            gr.update(interactive=True), 
+            new_button_update, 
+            True, 
+            gr.update(visible=False)
+        )
+    except Exception as e:
+        error_msg = f"Transcription Error: {e}"
+        return "", error_msg, gr.update(interactive=True), gr.update(value="↑", interactive=True, elem_classes=["circle-btn", "send-mode"]), False, gr.update(visible=False)
+
+
+def text_to_audio(text: str, is_voice_chat: bool) -> str or None:
+    """Converts the final response text to an MP3 file using gTTS."""
+    if not is_voice_chat:
+        return None 
+    
+    clean_text = re.sub(r'```.*?```|\[Image Processing Error:.*?\]|\*\*Web Search Results:.*?$', '', text, flags=re.DOTALL)
+    
+    if len(clean_text.strip()) > 5:
+        try:
+            audio_output_path = os.path.join(AUDIO_DIR, f"luna_response_{random.randint(1000, 9999)}.mp3")
+            tts = gTTS(text=clean_text.strip(), lang='en')
+            tts.save(audio_output_path)
+            return audio_output_path 
+        except Exception as e:
+            print(f"gTTS Error: {e}")
+            return None
+    return None
+
+
+# Intent and Dynamic Hint Logic
+INTENT_STATUS_MAP = {
+    "code_generate": "Analyzing requirements and drafting code 💻...",
+    "code_explain": "Reviewing code logic and writing explanation 💡...",
+    "qa_general": "Drafting comprehensive general answer ✍️...",
+    "greeting": "Replying to greeting 👋...",
+    "vqa": "Analyzing VQA results and forming a final response 🧠...",
+    "image_generate": "Generating image using Stable Diffusion (This may be slow on CPU) 🖼️...",
+    "doc_generate": "Generating content and formatting DOCX file 📄...",
+    "ppt_generate": "Generating content and formatting PPTX file 📊...",
+    "open_camera": "Activating camera for image capture 📸...",
+    "open_google": "Simulating external search link generation 🔗...",
+    "default": "Luna is thinking...",
+}
+
+def get_intent_status(raw_response: str, is_vqa: bool) -> Tuple[str, str, str]:
+    """Parses the Intent tag from the model's raw response and returns the intent, status, and cleaned response."""
+    if is_vqa and "Image Analysis (VQA)" in raw_response:
+        return "vqa", INTENT_STATUS_MAP["vqa"], raw_response 
+    
+    match = re.search(r'\[Intent:\s*(\w+)\]', raw_response, re.IGNORECASE)
+    intent = match.group(1).lower() if match else "default"
+    
+    cleaned_text = re.sub(r'\[Intent:\s*\w+\]\s*', '', raw_response, count=1).strip()
+    
+    status = INTENT_STATUS_MAP.get(intent, INTENT_STATUS_MAP["default"])
+    return intent, status, cleaned_text
+
+
+# --- NEW GENERATOR FUNCTIONS FOR UPGRADES ---
+
+def generate_image_and_update_history(prompt_text: str, history: List[Dict[str, str]]):
+    """Uses Stable Diffusion to generate an image."""
+    image_path = None
+    if img_gen_pipe is None:
+        history[-1]['content'] = f"{prompt_text}\n\n❌ **Error:** Image generation model is not loaded (CPU/RAM constraint). Please check logs."
+    else:
+        try:
+            print(f"Generating image for prompt: {prompt_text}")
+            image = img_gen_pipe(prompt_text).images[0]
+            
+            image_filename = f"generated_img_{random.randint(1000, 9999)}.png"
+            image_path = os.path.join(DOC_DIR, image_filename)
+            image.save(image_path)
+            
+            history[-1]['content'] = f"{prompt_text}\n\n🖼️ **Image Generated:**"
+        except Exception as e:
+            history[-1]['content'] = f"{prompt_text}\n\n❌ **Error generating image:** {e}"
+    
+    return history, image_path
+
+def generate_doc_and_update_history(content: str, history: List[Dict[str, str]]):
+    """Generates a DOCX file from the content and returns the file path."""
+    docx_file_path = None
+    try:
+        doc = Document()
+        doc.add_heading('Luna Generated Document', 0)
+        
+        doc.add_paragraph(content)
+        
+        doc_filename = f"generated_doc_{random.randint(1000, 9999)}.docx"
+        docx_file_path = os.path.join(DOC_DIR, doc_filename)
+        doc.save(docx_file_path)
+        
+        history[-1]['content'] = f"📄 **Document Generated!** You can download the file below. Content summary:\n\n{content[:200]}..."
+    except Exception as e:
+        history[-1]['content'] = f"❌ **Error generating DOCX:** {e}. Please ensure the `python-docx` library is installed."
+        
+    return history, docx_file_path
+
+def generate_ppt_and_update_history(content: str, history: List[Dict[str, str]]):
+    """Generates a PPTX file from the content and returns the file path."""
+    pptx_file_path = None
+    try:
+        prs = Presentation()
+        title_slide_layout = prs.slide_layouts[0]
+        slide = prs.slides.add_slide(title_slide_layout)
+        title = slide.shapes.title
+        subtitle = slide.placeholders[1]
+        
+        title.text = "Luna Generated Presentation"
+        
+        sections = content.split('\n\n')
+        
+        for i, section in enumerate(sections[:3]):
+            if len(section.strip()) > 5:
+                content_slide_layout = prs.slide_layouts[1]
+                slide = prs.slides.add_slide(content_slide_layout)
+                slide.shapes.title.text = f"Section {i+1}"
+                body = slide.shapes.placeholders[1]
+                
+                for line in section.split('\n'):
+                    p = body.text_frame.add_paragraph()
+                    p.text = line.strip()
+
+        ppt_filename = f"generated_ppt_{random.randint(1000, 9999)}.pptx"
+        pptx_file_path = os.path.join(DOC_DIR, ppt_filename)
+        prs.save(pptx_file_path)
+        
+        history[-1]['content'] = f"📊 **Presentation Generated!** You can download the file below. Summary:\n\n{content[:200]}..."
+    except Exception as e:
+        history[-1]['content'] = f"❌ **Error generating PPTX:** {e}. Please ensure the `python-pptx` library is installed."
+        
+    return history, pptx_file_path
+
+
+# --- CORE GENERATOR FUNCTION ---
+
+def chat_generator(message: str, image_path: str, history: List[Dict[str, str]], stop_signal: bool, is_voice_chat: bool) -> Any:
+    """The main generator function for streaming the LLM response."""
+    
+    # Component Outputs: [chatbot, stop_signal, hint_box, txt, combined_btn, audio_output, is_voice_chat, fact_check_btn_row, staged_image, file_input, file_download_output]
+    
+    if not history or history[-1]['content'] is not None:
+        yield history, False, "Error: Generator called without a recent user message in history.", gr.update(interactive=True), gr.update(value="↑", interactive=True, elem_classes=["circle-btn", "send-mode"]), None, False, gr.update(visible=False), gr.update(value=None), gr.update(value=None), gr.update(value=None)
+        return
+
+    # 1. PRE-PROCESSING & CONTEXT
+    # The last user message is the second-to-last item (since the last item is the placeholder assistant message)
+    last_user_index = len(history) - 2
+    original_message = history[last_user_index]['content']
+
+    # FIX: Safely check if image_path contains a non-empty string path
+    is_vqa_flow = bool(image_path) and isinstance(image_path, str) 
+    
+    if is_vqa_flow:
+        message = process_image(image_path, original_message)
+        # Update the user's content to reflect VQA flow for context building
+        history[last_user_index]['content'] = f"[IMAGE RECEIVED] {original_message}"
+    else:
+        message = original_message 
+        image_path = None 
+
+    # Build the prompt with conversation history (Context)
+    prompt = f"SYSTEM: {SYSTEM_PROMPT}\n"
+    
+    # Iterate through history (skipping the very last, incomplete assistant turn)
+    for i, item in enumerate(history[:-1]):
+        role = item['role'].upper()
+        content = item['content'] if item['content'] is not None else ""
+        
+        if role == "ASSISTANT":
+            prompt += f"LUNA: {content}\n"
+        elif role == "USER":
+            prompt += f"USER: {content}\n"
+
+    # The *actual* current user message is what we pass to the model, which might be VQA-enriched
+    prompt += f"USER: {message}\nLUNA: "
+    
+    # 2. HINT BOX & STREAM START
+    hint_text = "✨ Luna is starting to think..." 
+
+    # Set the current assistant response to an empty string (the last item in history)
+    history[-1]['content'] = "" 
+    # Yield initial state: show thinking, clear download box, disable input
+    yield history, stop_signal, hint_text, gr.update(value="", interactive=False), gr.update(value="Stop ⏹️", interactive=True, elem_classes=["circle-btn", "stop-mode"]), None, is_voice_chat, gr.update(visible=False), gr.update(value=None), gr.update(value=None), gr.update(value=None)
+    time.sleep(0.5) 
+
+    # 3. DIRECT STREAMING
+    full_response = ""
+    current_intent = "default" 
+    
+    try:
+        stream = llm.create_completion(
+            prompt=prompt, 
+            max_tokens=8192, 
+            stop=["USER:", "SYSTEM:", "\n\n", "</s>"],
+            echo=False,
+            stream=True,
+            temperature=0.7
+        )
+    except Exception as e:
+        error_text = f"❌ Error generating response: {e}"
+        history[-1]['content'] = error_text
+        yield history, False, error_text, gr.update(interactive=True), gr.update(value="↑", interactive=True, elem_classes=["circle-btn", "send-mode"]), None, False, gr.update(visible=False), gr.update(value=None), gr.update(value=None), gr.update(value=None)
+        return
+
+    try:
+        for output in stream:
+            token = output["choices"][0].get("text", "")
+            full_response += token
+            
+            # Get intent and cleaned text for display
+            current_intent, current_hint, display_text = get_intent_status(full_response, is_vqa_flow)
+            
+            # Update the last assistant message's content
+            history[-1]['content'] = display_text
+            
+            # Yield continuous update
+            yield history, stop_signal, current_hint, gr.update(interactive=False), gr.update(value="Stop ⏹️", interactive=True, elem_classes=["circle-btn", "stop-mode"]), None, is_voice_chat, gr.update(visible=False), gr.update(value=None), gr.update(value=None), gr.update(value=None)
+            
+    except Exception as e:
+        _, _, final_response_text = get_intent_status(full_response, is_vqa_flow)
+        error_msg = f"⚠️ Streaming interrupted: {e}"
+        history[-1]['content'] = final_response_text 
+        yield history, False, error_msg, gr.update(interactive=True), gr.update(value="↑", interactive=True, elem_classes=["circle-btn", "send-mode"]), None, False, gr.update(visible=True), gr.update(value=None), gr.update(value=None), gr.update(value=None)
+        return
+
+    # 4. POST-PROCESSING & TOOL EXECUTION
+    _, _, final_cleaned_response = get_intent_status(full_response, is_vqa_flow)
+    final_response = final_cleaned_response
+    file_download_path = None
+    
+    if current_intent == "image_generate":
+        yield history, stop_signal, INTENT_STATUS_MAP[current_intent], gr.update(interactive=False), gr.update(value="Stop ⏹️", interactive=True, elem_classes=["circle-btn", "stop-mode"]), None, is_voice_chat, gr.update(visible=False), gr.update(value=None), gr.update(value=None), gr.update(value=None)
+        history, file_download_path = generate_image_and_update_history(final_response, history)
+        final_response = history[-1]['content'] 
+        
+    elif current_intent == "doc_generate":
+        yield history, stop_signal, INTENT_STATUS_MAP[current_intent], gr.update(interactive=False), gr.update(value="Stop ⏹️", interactive=True, elem_classes=["circle-btn", "stop-mode"]), None, is_voice_chat, gr.update(visible=False), gr.update(value=None), gr.update(value=None), gr.update(value=None)
+        history, file_download_path = generate_doc_and_update_history(final_response, history)
+        final_response = history[-1]['content'] 
+
+    elif current_intent == "ppt_generate":
+        yield history, stop_signal, INTENT_STATUS_MAP[current_intent], gr.update(interactive=False), gr.update(value="Stop ⏹️", interactive=True, elem_classes=["circle-btn", "stop-mode"]), None, is_voice_chat, gr.update(visible=False), gr.update(value=None), gr.update(value=None), gr.update(value=None)
+        history, file_download_path = generate_ppt_and_update_history(final_response, history)
+        final_response = history[-1]['content'] 
+
+    elif current_intent == "open_google":
+        final_response += "\n\n🔗 **Action:** Since I cannot open a window for you, click here to search Google for this topic: [Google Search Link](https://www.google.com/search?q=open+google+simulated+search)"
+
+    elif current_intent == "open_camera":
+        final_response += "\n\n📸 **Action:** I cannot directly open the camera within this chat stream, but I will prepare the UI for you to use the 'Google Lens' button if you click 'Send' now!"
+
+    # If no special tool was executed, perform confidence check and web search fallback
+    if file_download_path is None:
+        final_response = check_confidence_and_augment(final_response, original_message)
+        
+    audio_file_path = text_to_audio(final_response, is_voice_chat) 
+    
+    # Update history with the final response 
+    history[-1]['content'] = final_response
+    
+    # 5. FINAL YIELD
+    hint = "✅ Response generated." 
+    
+    yield history, False, hint, gr.update(interactive=True), gr.update(value="↑", interactive=True, elem_classes=["circle-btn", "send-mode"]), audio_file_path, False, gr.update(visible=True), gr.update(value=None), gr.update(value=None), file_download_path
+
+# --- GRADIO WRAPPERS FOR UI ACTIONS ---
+
+def toggle_menu(current_visibility: bool) -> Tuple[bool, gr.update, gr.update, gr.update]:
+    """Toggles the visibility of the media options menu."""
+    new_visibility = not current_visibility 
+    return new_visibility, gr.update(visible=new_visibility), gr.update(visible=False), gr.update(value="⬇️" if new_visibility else "➕")
+
+def user_turn(user_message: str, chat_history: List[Dict[str, str]]) -> Tuple[str, List[Dict[str, str]]]:
+    """Appends the user message to the chat history and clears the input box, using the 'messages' format."""
+    if not user_message and not chat_history:
+        return "", chat_history
+
+    # If the last message is an incomplete assistant message, and no new user message is provided, don't update
+    if chat_history and chat_history[-1]['role'] == 'assistant' and chat_history[-1]['content'] is None and not user_message:
+        return "", chat_history
+    
+    if user_message:
+        # Append the new user message
+        chat_history.append({"role": "user", "content": user_message}) 
+        # Append a placeholder for the assistant's response (required for streaming/generation)
+        chat_history.append({"role": "assistant", "content": None}) 
+    
+    return "", chat_history
+
+def stage_file_upload(file_path: str) -> Tuple[str, str, gr.update, gr.update]:
+    """Stages the file path and updates the hint box."""
+    if file_path:
+        return file_path, f"📎 File staged: {os.path.basename(file_path)}. Click send (✈️) to analyze.", gr.update(value="", interactive=True), gr.update(interactive=False)
+    return None, "File upload cancelled/cleared.", gr.update(value="", interactive=True), gr.update(interactive=False)
+
+def clear_staged_media() -> gr.update:
+    """Clears the staged media state after sending or canceling."""
+    return gr.update(value=None)
+
+def manual_fact_check(history: List[Dict[str, str]]) -> Tuple[List[Dict[str, str]], str, gr.update]:
+    """Triggers a manual fact check/web search, using the 'messages' format."""
+    if not history or not history[-1]['content']:
+        return history, "Error: No final response to check.", gr.update(visible=False)
+    
+    # Find the most recent user prompt that generated the last assistant response
+    last_user_prompt = ""
+    for item in reversed(history):
+        if item['role'] == 'user' and item['content']:
+            last_user_prompt = item['content'].split("**User Query:**")[-1].strip()
+            break
+            
+    if not last_user_prompt:
+        return history, "Error: Could not find the original user query.", gr.update(visible=False)
+
+    web_results = web_search_tool(last_user_prompt)
+    
+    new_history = list(history)
+    new_history[-1]['content'] += web_results
+    
+    return new_history, "✅ Double-checked with web facts.", gr.update(visible=False)
+
+# UPGRADE 3: Automatic Camera Capture Function (Simplified)
+def auto_capture_camera(user_message: str, chat_history: List[Dict[str, str]]) -> Tuple[str, List[Dict[str, str]], gr.update, gr.update, gr.update, gr.update, gr.update]:
+    """
+    Simulates the automatic capture action by updating the UI components 
+    to show the camera, and then immediately capturing (simulated).
+    """
+    # Use user_turn logic to setup the chat history correctly for the intent flow
+    _, chat_history = user_turn(user_message, chat_history)
+    
+    # Update the last assistant response placeholder with a status message
+    if chat_history and chat_history[-1]['role'] == 'assistant' and chat_history[-1]['content'] is None:
+        chat_history[-1]['content'] = "📸 Preparing camera capture..."
+    
+    # Update UI to show the webcam (start capture simulation)
+    return "", chat_history, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), gr.update(value="📸 Capturing in 3 seconds...", interactive=False), gr.update(value="➕")
+
+
+# --- GRADIO INTERFACE ---
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Luna Coding Partner") as demo:
+    
+    # --- State Components ---
+    stop_signal = gr.State(value=False)
+    is_voice_chat = gr.State(value=False) 
+    staged_image = gr.State(value=None) 
+    menu_visible_state = gr.State(value=False)
+    
+    gr.HTML("<h1 style='text-align: center; color: #4B0082;'>🌙 Luna Chat Space</h1>")
+
+    # Hint Box
+    hint_box = gr.Textbox(value="Ask anything", lines=1, show_label=False, interactive=False, placeholder="Luna's Action...", visible=True) 
+
+    # Download Box
+    file_download_output = gr.File(label="Generated File", visible=True)
+
+    # Fact Check button row 
+    with gr.Row(visible=False) as fact_check_btn_row:
+        gr.Column(min_width=1)
+        btn_fact_check = gr.Button("Fact Check 🔎")
+        gr.Column(min_width=1)
+        
+    # Chatbot Area
+    # --- FIX: Added type='messages' to comply with new Gradio standard ---
+    chatbot = gr.Chatbot(label="Luna", height=500, type='messages') 
+    
+    # Webcam Capture Area (Hidden)
+    with gr.Row(visible=False) as webcam_capture_row:
+        webcam_capture_component = gr.Image(sources=["webcam"], show_label=False)
+        close_webcam_btn = gr.Button("✅ Use this image")
+        
+    # Audio Recording Row (Hidden)
+    with gr.Row(visible=False) as audio_record_row:
+        audio_input = gr.Audio(sources=["microphone"], type="filepath", show_label=False)
+    
+    # Option Menu (Hidden)
+    with gr.Column(visible=False, elem_id="menu_options_row") as menu_options_row:
+        file_input = gr.File(type="filepath", label="File Uploader", interactive=False) 
+        btn_take_photo = gr.Button("📸 Google Lens (Take Photo)")
+        btn_add_files = gr.Button("📎 Upload File")
+
+    # Fixed Input Row (Footer)
+    with gr.Row(variant="panel") as input_row:
+        btn_menu = gr.Button("➕", interactive=True, size="sm")
+        txt = gr.Textbox(placeholder="Ask anything", show_label=False, lines=1, autofocus=True)
+        mic_btn = gr.Button("🎙️", interactive=True, size="sm")
+        combined_btn = gr.Button("✈️", variant="primary", size="sm")
+        
+    audio_output = gr.Audio(visible=False) 
+
+    # Group all output components for convenience
+    output_components = [chatbot, stop_signal, hint_box, txt, combined_btn, audio_output, is_voice_chat, fact_check_btn_row, staged_image, file_input, file_download_output]
+
+    # --- WIRE EVENTS ---
+
+    # 1. Menu Button
+    btn_menu.click(
+        fn=toggle_menu,
+        inputs=[menu_visible_state], 
+        outputs=[menu_visible_state, menu_options_row, fact_check_btn_row, btn_menu], 
+        queue=False
+    )
+    
+    # 2. File Upload
+    def prepare_file_upload():
+        return gr.update(visible=False), gr.update(value="➕"), gr.update(visible=False), gr.update(interactive=True), gr.update(value="")
+    
+    btn_add_files.click(fn=prepare_file_upload, inputs=[], outputs=[menu_options_row, btn_menu, fact_check_btn_row, file_input, txt], queue=False)
+    
+    file_input.change(
+        fn=stage_file_upload,
+        inputs=[file_input],
+        outputs=[staged_image, hint_box, txt, file_input],
+        queue=False
+    )
+
+    # 3. 'Take photo' (Webcam)
+    btn_take_photo.click(
+        fn=lambda: (gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), "📸 Camera Active. Capture an image.", gr.update(value="➕")),
+        inputs=[],
+        outputs=[menu_options_row, webcam_capture_row, input_row, hint_box, btn_menu],
+        queue=False
+    )
+    
+    # 4. Webcam Close
+    close_webcam_btn.click(
+        fn=lambda img: (gr.update(visible=True), gr.update(visible=False), img, f"📸 Photo staged: Click send (✈️) to process.", gr.update(value="")),
+        inputs=[webcam_capture_component],
+        outputs=[input_row, webcam_capture_row, staged_image, hint_box, txt],
+        queue=False
+    )
+    
+    # 5. Mic wiring (Fixed with simulate_recording_delay)
+    mic_btn.click(
+        fn=lambda: (gr.update(visible=False), gr.update(visible=True), "🎙️ Recording..."),
+        inputs=[],
+        outputs=[input_row, audio_record_row, hint_box], 
+        queue=False
+    ).then(
+        fn=simulate_recording_delay, # <<< NEW STEP FOR DELAY
+        inputs=[],
+        outputs=[], 
+        queue=False,
+    ).then(
+        fn=lambda: (gr.update(visible=True), gr.update(visible=False), "🎙️ Processing recording..."),
+        inputs=[],
+        outputs=[input_row, audio_record_row, hint_box], 
+        queue=False,
+    ).then(
+        fn=transcribe_audio,
+        inputs=audio_input,
+        outputs=[txt, hint_box, txt, combined_btn, is_voice_chat, fact_check_btn_row], 
+        queue=False
+    ).then(
+        fn=user_turn,
+        inputs=[txt, chatbot],
+        outputs=[txt, chatbot],
+        queue=False
+    ).then(
+        fn=chat_generator, 
+        inputs=[txt, staged_image, chatbot, stop_signal, is_voice_chat],
+        outputs=output_components,
+        queue=True,
+    ).then(
+        fn=clear_staged_media, inputs=[], outputs=[staged_image], queue=False
+    )
+
+    # 6. Main Submission Logic (Text submit and Send button)
+    generator_inputs = [txt, staged_image, chatbot, stop_signal, is_voice_chat]
+    
+    # Text submit (Enter key)
+    txt.submit(
+        fn=user_turn,
+        inputs=[txt, chatbot],
+        outputs=[txt, chatbot],
+        queue=False
+    ).then(
+        fn=chat_generator, 
+        inputs=generator_inputs, 
+        outputs=output_components, 
+        queue=True,
+    ).then(
+        fn=clear_staged_media, inputs=[], outputs=[staged_image], queue=False
+    )
+    
+    # Send button click
+    combined_btn.click(
+        fn=user_turn,
+        inputs=[txt, chatbot],
+        outputs=[txt, chatbot],
+        queue=False
+    ).then(
+        fn=chat_generator,
+        inputs=generator_inputs,
+        outputs=output_components,
+        queue=True
+    ).then(
+        fn=clear_staged_media, inputs=[], outputs=[staged_image], queue=False
+    )
+    
+    # 7. Fact Check Button
+    btn_fact_check.click(
+        fn=manual_fact_check,
+        inputs=[chatbot],
+        outputs=[chatbot, hint_box, fact_check_btn_row],
+        queue=True
+    )
+
+demo.queue(max_size=20).launch(server_name="0.0.0.0")