refactor: Modularize app structure (app_module.py + thin entry points)

app.py

@@ -1,554 +1,5 @@
-import os
-import torch
-import gradio as gr
-import time
-import re
-import codecs
-import uuid
-import json
-import logging
-import tempfile
-import numpy as np
-import scipy.io.wavfile as wavfile
-import asyncio
-import warnings
-from typing import List, Tuple, Generator, Dict
-from threading import Thread
-
-# ML / Transformers
-import transformers
-transformers.utils.logging.set_verbosity_error()
-warnings.filterwarnings("ignore", category=UserWarning, module="gradio.components.dropdown")
-from transformers import AutoProcessor, Gemma3ForConditionalGeneration, TextIteratorStreamer
-
-# --- Logging Setup ---
-# Set root logger to ERROR to suppress external library noise
-logging.basicConfig(level=logging.ERROR, format='%(name)s [%(levelname)s] %(message)s')
-
-# Specific library suppressions
-for lib in ["transformers", "accelerate", "httpx", "gradio", "langchain"]:
-    logging.getLogger(lib).setLevel(logging.ERROR)
-
-# Application-level logger
-logger = logging.getLogger("app")
-logger.setLevel(logging.DEBUG)
-logger.propagate = False  # DO NOT propagate to root to avoid double-logging or filtering
-ch = logging.StreamHandler()
-ch.setLevel(logging.DEBUG)
-ch.setFormatter(logging.Formatter('[app] [%(levelname)s] %(message)s'))
-logger.addHandler(ch)
-
-# --------------------------------------------------------------------
-# Konfiguration & Globale States
-# --------------------------------------------------------------------
-EMBED_MODEL_ID = "google/embeddinggemma-300m"
-LLM_MODEL_ID = "google/gemma-3-4b-it"
-
-EMBEDDING_FUNCTION = None
-LLM_MODEL = None
-LLM_PROCESSOR = None
-
-# --- UI Premium Aesthetics ---
-PREMIUM_CSS = """
-.glass-panel {
-    background: rgba(255, 255, 255, 0.05) !important;
-    backdrop-filter: blur(10px) !important;
-    border: 1px solid rgba(255, 255, 255, 0.1) !important;
-    border-radius: 15px !important;
-    box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37) !important;
-}
-.sidebar-panel {
-    border-right: 1px solid rgba(255, 255, 255, 0.1) !important;
-    height: 100vh;
-}
-    border-bottom: 2px solid #0f3460;
-}
-.desktop-only { display: block; }
-.mobile-only { display: none; }
-@media (max-width: 768px) {
-    .desktop-only { display: none !important; }
-    .mobile-only { display: block !important; }
-    .sidebar-panel { display: none !important; }
-}
-"""
-
-try:
-    from pypdf import PdfReader
-    from langchain_community.vectorstores import FAISS
-    from langchain_huggingface import HuggingFaceEmbeddings
-    from langchain_core.documents import Document
-    from langchain_text_splitters import RecursiveCharacterTextSplitter
-    from mongochain import MongoDBHandler
-except ImportError:
-    pass
-
-# Spiritual Integration
-try:
-    from spiritual_bridge import get_oracle_data
-except ImportError:
-    get_oracle_data = None
-
-# --- Model Loading ---
-def get_device() -> torch.device:
-    if torch.cuda.is_available(): return torch.device("cuda")
-    return torch.device("cpu")
-
-def get_embedding_function():
-    global EMBEDDING_FUNCTION
-    if EMBEDDING_FUNCTION is None:
-        device = get_device()
-        logger.debug(f"Initialisiere Embedding-Modell '{EMBED_MODEL_ID}' auf Device '{device}'.")
-        EMBEDDING_FUNCTION = HuggingFaceEmbeddings(
-            model_name=EMBED_MODEL_ID,
-            model_kwargs={'device': device}
-        )
-        logger.debug("Embedding-Modell erfolgreich initialisiert.")
-    return EMBEDDING_FUNCTION
-
-def get_llm():
-    global LLM_MODEL, LLM_PROCESSOR
-    if LLM_MODEL is None or LLM_PROCESSOR is None:
-        device = get_device()
-        logger.debug(f"Initialisiere LLM '{LLM_MODEL_ID}' auf Device '{device}'.")
-        dtype = torch.bfloat16 if "cuda" in device.type else torch.float32
-        LLM_MODEL = Gemma3ForConditionalGeneration.from_pretrained(
-            LLM_MODEL_ID,
-            dtype=dtype,
-            device_map="auto",
-        ).eval()
-        LLM_PROCESSOR = AutoProcessor.from_pretrained(LLM_MODEL_ID)
-        logger.debug("LLM und Prozessor erfolgreich initialisiert.")
-    return LLM_MODEL, LLM_PROCESSOR
-
-# --- Language Detection ---
-def detect_language(text: str) -> str:
-    if not text or len(text) < 3: return "English"
-    model, processor = get_llm()
-    prompt = f"Detect the language of the following text and return ONLY the language name (e.g., 'English', 'German', 'French'):\n\n\"{text}\""
-    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
-    inputs = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
-    with torch.no_grad():
-        outputs = model.generate(inputs, max_new_tokens=20, do_sample=False)
-    raw_output = processor.batch_decode(outputs[:, inputs.shape[1]:], skip_special_tokens=True)[0].strip()
-    logger.debug(f"DEBUG: Raw Language Detection Output: '{raw_output}'")
-    
-    keywords = ["English", "German", "French", "Spanish", "Italian", "Dutch", "Russian", "Chinese", "Japanese"]
-    for k in keywords:
-        if k.lower() in raw_output.lower():
-            logger.debug(f"DEBUG: Detected User Language (Normalized): '{k}'")
-            return k
-    return "English"
-
-# --- Document Handling ---
-def extract_text_from_file(path: str) -> str:
-    ext = os.path.splitext(path)[1].lower()
-    if ext in [".txt", ".md", ".markdown"]:
-        with open(path, "r", encoding="utf-8", errors="ignore") as f: return f.read()
-    if ext == ".pdf":
-        text_parts = []
-        try:
-            reader = PdfReader(path)
-            for page in reader.pages:
-                page_text = page.extract_text()
-                if page_text: text_parts.append(page_text)
-            return "\n\n".join(text_parts)
-        except Exception as e:
-            logger.error(f"Error reading PDF {path}: {e}"); return ""
-    try:
-        with open(path, "r", encoding="utf-8", errors="ignore") as f: return f.read()
-    except Exception: return ""
-
-def get_text_splitter() -> RecursiveCharacterTextSplitter:
-    return RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200, length_function=len)
-
-# --- RAG Core ---
-def index_files(file_paths, mongo_uri, db_name, coll_name, use_mongo, vs_state, mh_state, progress=gr.Progress(track_tqdm=True)):
-    if not file_paths: return "Keine Dateien zum Indexieren ausgewählt.", vs_state, mh_state
-    
-    logger.debug(f"Indexierung gestartet für {len(file_paths)} Datei(en).")
-    embed_fn = get_embedding_function()
-    splitter = get_text_splitter()
-    documents = []
-    
-    for path in progress.tqdm(file_paths, desc="1/2: Dateien verarbeiten"):
-        if path is None: continue
-        text = extract_text_from_file(path)
-        if not text.strip(): continue
-        chunks = splitter.split_text(text)
-        source_name = os.path.basename(path)
-        for c in chunks:
-            documents.append(Document(page_content=c, metadata={"source": source_name}))
-    
-    logger.debug(f"Total chunks created: {len(documents)}")
-    if not documents: return "Kein Text zum Indexieren gefunden.", vs_state, mh_state
-    
-    progress(0.7, desc="2/2: Indexing...")
-    new_vs = FAISS.from_documents(documents, embed_fn)
-    if vs_state: 
-        vs_state.merge_from(new_vs)
-    else: 
-        vs_state = new_vs
-        
-    mh_state = None
-    if use_mongo:
-        try:
-            mh_state = MongoDBHandler(uri=mongo_uri, db_name=db_name, collection_name=coll_name)
-            mh_state.connect()
-            logger.debug(f"Pushe {len(documents)} Chunks nach MongoDB...")
-            for doc in documents:
-                mh_state.insert_chunk(doc.page_content, doc.metadata)
-            logger.debug("MongoDB-Sync abgeschlossen.")
-        except Exception as e:
-            logger.error(f"Mongo Error: {e}")
-
-    logger.debug(f"Indexierung abgeschlossen. Gesamt: {vs_state.index.ntotal} Chunks.")
-    return f"Index aktualisiert: {vs_state.index.ntotal} Chunks insgesamt.", vs_state, mh_state
-
-def clear_index():
-    import gc; gc.collect()
-    logger.debug("Vektor-Index wurde geleert.")
-    return "Index geleert.", None, None
-
-def retrieve_relevant_chunks(query, vs_state, mh_state, top_k=3):
-    if not vs_state: return []
-    logger.debug(f"Suche in FAISS: '{query}'")
-    docs = vs_state.similarity_search(query, k=top_k)
-    return [{"content": d.page_content, "source": d.metadata.get("source", "Unknown")} for d in docs]
-
-def build_rag_prompt(user_question: str, retrieved_chunks: List[Dict]) -> str:
-    if not retrieved_chunks: context_str = "Kein relevanter Kontext gefunden."
-    else:
-        context_parts = [f"[{i}] (Quelle: {ch['source']}): \"{ch['content']}\"" for i, ch in enumerate(retrieved_chunks, 1)]
-        context_str = "\n\n".join(context_parts)
-    return (f"Beantworte die Benutzerfrage nur basierend auf dem Kontext.\n\n"
-            f"--- Kontext ---\n{context_str}\n\n"
-            f"--- Frage ---\n{user_question}\n\n"
-            f"--- Antwort ---")
-
-# --- Agent System ---
-def build_agent_prompt(query, context, history, language="English", short_answers=False):
-    context_str = "\n".join([f"- {c['content']} (Source: {c['source']})" for i, c in enumerate(context)])
-    
-    style_instruction = "Be concise." if short_answers else ""
-    
-    system = f"""You are Sage 6.5, a spiritual AI guide. 
-Respond in {language}. {style_instruction}
-If you need to use a tool, you MUST use the following JSON format inside <tool_call> tags:
-<tool_call>{{"name": "tool_name", "arguments": {{"arg1": "val1"}}}}</tool_call>
-
-Available Tools:
-1. oracle_consultation: Consult the archive for deep wisdom. Arguments: {{"topic": "str", "name": "str (Optional. Use ONLY if the user explicitly stated their name, otherwise omit)"}}
-"""
-    return system + f"\n\nContext:\n{context_str}\n\nUser Question: {query}"
-
-def chat_agent_stream(query, history, vs_state, mh_state, user_lang=None, short_answers=False):
-    model, processor = get_llm()
-    lang = user_lang if user_lang else detect_language(query)
-    context = retrieve_relevant_chunks(query, vs_state, mh_state)
-    prompt = build_agent_prompt(query, context, history, language=lang, short_answers=short_answers)
-    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
-    
-    logger.info(f"[AGENT] 🏁 Starting Agent Loop for Query: '{query}' (Lang: {lang})")
-    
-def chat_agent_stream(query, history, vs_state, mh_state, user_lang=None, short_answers=False):
-    model, processor = get_llm()
-    lang = user_lang if user_lang else detect_language(query)
-    context = retrieve_relevant_chunks(query, vs_state, mh_state)
-    prompt = build_agent_prompt(query, context, history, language=lang, short_answers=short_answers)
-    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
-    
-    logger.info(f"[AGENT] 🏁 Starting Agent Loop for Query: '{query}' (Lang: {lang})")
-    
-    max_turns = 3
-    for turn in range(max_turns):
-        logger.info(f"[AGENT] 🔄 Turn {turn+1}/{max_turns}")
-        
-        input_ids = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
-        streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)
-        
-        gen_kwargs = {"input_ids": input_ids, "streamer": streamer, "max_new_tokens": 512, "do_sample": False}
-        thread = Thread(target=model.generate, kwargs=gen_kwargs)
-        thread.start()
-        
-        current_turn_text = ""
-        # We yield a TUPLE: (accumulated_text_for_THIS_turn, is_final)
-        # But wait, the wrapper needs to handle new messages.
-        # Strategy: Yield just the text of THIS turn. Wrapper handles appending to a NEW history item each turn.
-        
-        logger.info("[AGENT] ⏳ Streaming response...")
-        for new_text in streamer:
-            current_turn_text += new_text
-            clean_chunk = re.sub(r"<tool_call>.*?</tool_call>", "", current_turn_text, flags=re.DOTALL)
-            yield clean_chunk.strip()
-            
-        logger.info(f"[AGENT] 🛑 Raw Model Output: {current_turn_text}")
-        
-        # Tool Detection
-        tool_match = re.search(r"<tool_call>(.*?)</tool_call>", current_turn_text, re.DOTALL)
-        if tool_match:
-            # If tool found, this turn is OVER regarding user output.
-            # We yield a special signal to indicate "End of Message, Start Next Logic"?
-            # actually, if we yield, the wrapper updates history[-1]. 
-            # If we want a NEW message, we need to tell wrapper to append.
-            # Simplified: Use a separator? No, wrapper loop is easier.
-            
-            # For now, let's keep the generator simple. 
-            # It yields text updates for the CURRENT turn.
-            # Once loop breaks (tool found), we start next turn.
-            # BUT: How to tell wrapper "This turn is done, start a new bubble"?
-            # Generator yields: {"text": "...", "new_bubble": True/False}
-            
-            try:
-                tool_data = json.loads(tool_match.group(1))
-                logger.info(f"[AGENT] 🛠️ Tool Call Detected: {tool_data}")
-                
-                tool_name = tool_data.get("name")
-                tool_args = tool_data.get("arguments", {})
-                
-                if tool_name == "oracle_consultation":
-                    topic = tool_args.get("topic", "")
-                    
-                    # Name Handling: Use provided name or default to 'Seeker'
-                    req_name = tool_args.get("name", "").strip()
-                    effective_name = req_name if req_name else "Seeker"
-                    
-                    logger.info(f"[AGENT] 🔮 Executing Oracle with topic: '{topic}' for '{effective_name}'")
-                    if get_oracle_data:
-                        try:
-                            # Call backend
-                            oracle_raw = get_oracle_data(name=effective_name, topic=topic, date_str="")
-                            
-                            # FILTERING LOGIC (User Request: Only 3 sources, no BOS API/ELS)
-                            # We construct a filtered dictionary
-                            filtered_result = {
-                                "wisdom_nodes": oracle_raw.get("wisdom_nodes", [])
-                            }
-                            # If wisdom_nodes is missing/empty, maybe keep raw but warn?
-                            # Use strict filtering as requested.
-                            
-                            tool_result = json.dumps(filtered_result, indent=2)
-                            logger.info(f"[AGENT] ✅ Oracle Result Obtained (Filtered Size: {len(tool_result)} bytes)")
-                        except Exception as e:
-                            logger.error(f"[AGENT] ❌ Oracle Backend Error: {e}")
-                            tool_result = f"Error executing oracle: {str(e)}"
-                    else:
-                        logger.warning("[AGENT] ⚠️ Oracle module not available")
-                        tool_result = "Oracle module not available."
-                else:
-                    logger.warning(f"[AGENT] ⚠️ Unknown tool requested: {tool_name}")
-                    tool_result = f"Unknown tool: {tool_name}"
-
-                messages.append({"role": "assistant", "content": [{"type": "text", "text": current_turn_text}]})
-                
-                tool_injection = f"""<tool_result>{tool_result}</tool_result>
-Now interpret this result soulfully and poetically for the user. Do not mention JSON.
-IMPORTANT: Connect this smoothly to your previous statement. Ensure a fluid, cohesive narrative without abrupt jumps."""
-                
-                logger.info("[AGENT] 💉 Injecting Tool Result into context for interpretation...")
-                messages.append({"role": "user", "content": [{"type": "text", "text": tool_injection}]})
-                
-                # Yield a special marker to say "Turn Finished"
-                yield "__TURN_END__" 
-                continue
-            except Exception as e:
-                logger.error(f"[AGENT] 💥 Tool parsing/logic crash: {e}")
-                break
-        else:
-            logger.info("[AGENT] ✨ No tool calls. Finalizing response.")
-            break
-
-# --- Voice Engine ---
-async def generate_speech(text: str, lang: str = "English"):
-    import edge_tts
-    VOICES = {"English": "en-US-GuyNeural", "German": "de-DE-ConradNeural", "French": "fr-FR-HenriNeural"}
-    voice = VOICES.get(lang, VOICES["English"])
-    logger.debug(f"TRACE: generate_speech() called. Text len: {len(text)}, Lang: {lang}")
-    temp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
-    communicate = edge_tts.Communicate(text, voice)
-    await communicate.save(temp_wav.name)
-    return temp_wav.name
-
-def transcribe_audio(path: str):
-    logger.debug(f"TRACE: transcribe_audio() called with path: {path}")
-    return "Transcribed text"
-
-# --- Gradio Wrappers ---
-def voice_chat_wrapper(audio_path, history, threads, tid, vs_state, mh_state, short_answers):
-    if audio_path is None: yield history, threads, gr.update(), gr.update(), None; return
-    text = transcribe_audio(audio_path)
-    detected_lang = detect_language(text)
-    final_history, final_threads, final_update = history, threads, gr.update()
-    if text:
-        gen = chat_wrapper(text, history, threads, tid, vs_state, mh_state, short_answers=short_answers, lang=detected_lang)
-        for h, t, tr1, tr2, _ in gen:
-            final_history, final_threads, final_update = h, t, tr1
-            yield h, t, tr1, tr2, None
-    import asyncio
-    last_msg = final_history[-1]["content"] if final_history else ""
-    if last_msg:
-        voice_path = asyncio.run(generate_speech(last_msg, lang=detected_lang))
-        yield final_history, final_threads, final_update, final_update, voice_path
-    else:
-        yield final_history, final_threads, final_update, final_update, None
-
-def chat_wrapper(message, history, threads, tid, vs_state, mh_state, short_answers=False, lang=None):
-    if not message.strip(): 
-        upd = gr.update(choices=[(v["title"], k) for k, v in threads.items()], value=tid)
-        yield history, threads, upd, upd, None
-        return
-    history.append({"role": "user", "content": message})
-    yield history, threads, gr.update(), gr.update(), None
-    
-    # Start first response bubble
-    history.append({"role": "assistant", "content": ""})
-    
-    for response_part in chat_agent_stream(message, history[:-2], vs_state, mh_state, user_lang=lang, short_answers=short_answers):
-        if response_part == "__TURN_END__":
-            # Start NEW bubble for next turn
-            history.append({"role": "assistant", "content": ""})
-            yield history, threads, gr.update(), gr.update(), None
-        else:
-            history[-1]["content"] = response_part
-            yield history, threads, gr.update(), gr.update(), None
-            
-    # Cleanup empty bubble if exists (rare edge case)
-    if not history[-1]["content"]: history.pop()
-    
-    if tid not in threads: threads[tid] = {"title": "Conversation", "history": []}
-    threads[tid]["history"] = history
-    if len(history) <= 2: 
-        threads[tid]["title"] = (message[:25] + "..") if message else "Conversation"
-    choices = [(v["title"], k) for k, v in threads.items()]
-    upd = gr.update(choices=choices, value=tid)
-    yield history, threads, upd, upd, None
-
-def stream_handler(stream, state):
-    if stream is None: return state, None
-    sr, y = stream
-    if y is None or len(y) == 0: return state, None
-    y = y.astype(np.float32)
-    y = y / np.max(np.abs(y)) if np.max(np.abs(y)) > 0 else y
-    rms = np.sqrt(np.mean(y**2))
-    SILENCE_THRESHOLD, SILENCE_CHUNKS = 0.01, 20
-    if state is None: state = {"buffer": [], "silence_counter": 0, "is_speaking": False}
-    state["buffer"].append((sr, stream[1]))
-    if rms > SILENCE_THRESHOLD:
-        state["is_speaking"], state["silence_counter"] = True, 0
-    elif state["is_speaking"]:
-        state["silence_counter"] += 1
-    if state["is_speaking"] and state["silence_counter"] > SILENCE_CHUNKS:
-        full_audio = np.concatenate([c[1] for c in state["buffer"]])
-        sr_final = state["buffer"][0][0]
-        temp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-        wavfile.write(temp_wav.name, sr_final, full_audio)
-        return {"buffer": [], "silence_counter": 0, "is_speaking": False}, temp_wav.name
-    return state, None
-
-# --- INTERNAL CALLBACKS ---
-def create_new_thread_callback(threads):
-    nid = str(uuid.uuid4())
-    threads[nid] = {"title": "New Conversation", "history": []}
-    choices = [(v["title"], k) for k, v in threads.items()]
-    return threads, nid, gr.update(choices=choices, value=nid), []
-
-def switch_thread(tid, t_state):
-    logger.debug(f"TRACE: switch_thread() called for tid: {tid}")
-    if isinstance(tid, list):
-        if not tid: return [], gr.update(), gr.update(), gr.update()
-        tid = tid[0]
-    tid = str(tid)
-    history = t_state.get(tid, {}).get("history", [])
-    choices = [(v["title"], k) for k, v in t_state.items()]
-    upd = gr.update(value=tid, choices=choices)
-    return history, tid, upd, upd
-
-def session_import_handler(file):
-    if not file: return [], {}, None, gr.update(), gr.update()
-    with open(file.name, "r") as f: data = json.load(f)
-    imported_threads = data.get("threads", {})
-    active_id = data.get("active_id", list(imported_threads.keys())[0] if imported_threads else None)
-    history = imported_threads.get(active_id, {}).get("history", []) if active_id else []
-    choices = [(v["title"], k) for k, v in imported_threads.items()]
-    upd = gr.update(choices=choices, value=active_id)
-    return history, imported_threads, active_id, upd, upd
-
-def session_export_handler(chatbot_val, threads, active_id):
-    export_data = {"threads": threads, "active_id": active_id}
-    path = "sage_session_export.json"
-    with open(path, "w") as f: json.dump(export_data, f, indent=2)
-    return path
-
-def build_demo() -> gr.Blocks:
-    initial_thread_id = str(uuid.uuid4())
-    with gr.Blocks(title="Gemma 3 Sage v6.5 SP1", theme="soft", css=PREMIUM_CSS) as demo:
-        threads_state = gr.State({initial_thread_id: {"title": "New Chat", "history": []}})
-        active_thread_id = gr.State(initial_thread_id)
-        vector_store_state = gr.State(None)
-        mongo_handler_state = gr.State(None)
-        
-        with gr.Row(elem_classes="header-tray"):
-            gr.Markdown("# 🌌 Gemma 3 Sage <small>v6.5 SP1</small>")
-
-        with gr.Row():
-            # Desktop Sidebar (Radio List)
-            with gr.Column(scale=1, variant="panel", elem_classes="sidebar-panel glass-panel desktop-only"):
-                gr.Markdown("### 🕒 Recent Chats")
-                # Using Radio as a list selector
-                thread_list = gr.Radio(choices=[(f"New Chat", initial_thread_id)], value=initial_thread_id, label=None, interactive=True, container=False)
-                new_thread_btn = gr.Button("➕ New Conversation", variant="secondary")
-                
-            with gr.Column(scale=4):
-                with gr.Tabs() as tabs:
-                    with gr.Tab("💬 Live Conversation", id=0, elem_classes="glass-panel"):
-                        
-                        # Mobile Menu (Accordion + Dropdown)
-                        with gr.Accordion("🕒 Conversations (Mobile)", open=False, visible=True, elem_classes="mobile-only") as mobile_sessions:
-                            m_thread_list = gr.Dropdown(choices=[("New Chat", initial_thread_id)], value=initial_thread_id, label="Select Session")
-                            m_new_btn = gr.Button("➕ New Conversation", variant="secondary")
-                        
-                        chatbot = gr.Chatbot(label="Sage", type="messages", height=600, show_label=False, autoscroll=False)
-                        with gr.Row():
-                            msg_textbox = gr.Textbox(placeholder="Whisper your heart or type...", label=None, scale=8, container=False)
-                            submit_btn = gr.Button("Send", variant="primary", scale=1)
-                        # Moved Short Answer checkbox here for visibility
-                        with gr.Row():
-                            short_ans_cb = gr.Checkbox(label="Short Answers", value=False)
-                        with gr.Row():
-                            stream_state = gr.State({"buffer": [], "silence_counter": 0, "is_speaking": False})
-                            audio_input = gr.Audio(label="Voice", sources="microphone", type="numpy", streaming=True)
-                            processed_audio, audio_output = gr.State(None), gr.Audio(label="Sage Voice", autoplay=True, visible=False)
-                        with gr.Row(elem_classes="glass-panel"):
-                            export_btn = gr.Button("📤 Export Session", variant="secondary", size="sm")
-                            import_file = gr.File(label="Import", file_count="single", height=60)
-                            export_file = gr.File(label="Download", interactive=False, visible=False)
-
-                    with gr.Tab("📚 Sacred Knowledge", id=1, elem_classes="glass-panel"):
-                        file_uploader = gr.File(label="Upload", file_count="multiple", type="filepath")
-                        index_button = gr.Button("🔄 Sync Index", variant="primary")
-                        index_status = gr.Markdown("Bereit.")
-                        with gr.Accordion("⚙️ MongoDB Settings", open=False):
-                            mongo_uri = gr.Textbox(label="URI", value="mongodb://localhost:27017/")
-                            mongo_db = gr.Textbox(label="DB", value="rag_db")
-                            mongo_coll = gr.Textbox(label="Coll", value="gemma_chunks")
-                            use_mongo_cb = gr.Checkbox(label="Sync to Mongo", value=True)
-                            clear_mongo_btn = gr.Button("🗑️ Clear Mongo")
-                        clear_idx_btn = gr.Button("🧹 Clear FAISS", variant="stop")
-                        
-                        clear_mongo_btn.click(lambda u, d, c: MongoDBHandler(u, d, c).connect() and MongoDBHandler(u, d, c).clear() or "Mongo geleert", [mongo_uri, mongo_db, mongo_coll], index_status)
-
-        audio_input.stream(stream_handler, [audio_input, stream_state], [stream_state, processed_audio])
-        processed_audio.change(voice_chat_wrapper, [processed_audio, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output])
-        msg_textbox.submit(chat_wrapper, [msg_textbox, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output]).then(lambda: "", None, msg_textbox)
-        submit_btn.click(chat_wrapper, [msg_textbox, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output]).then(lambda: "", None, msg_textbox)
-        new_thread_btn.click(create_new_thread_callback, [threads_state], [threads_state, active_thread_id, thread_list, chatbot])
-        m_new_btn.click(create_new_thread_callback, [threads_state], [threads_state, active_thread_id, m_thread_list, chatbot])
-        thread_list.change(switch_thread, [thread_list, threads_state], [chatbot, active_thread_id, thread_list, m_thread_list])
-        m_thread_list.change(switch_thread, [m_thread_list, threads_state], [chatbot, active_thread_id, thread_list, m_thread_list])
-        index_button.click(index_files, [file_uploader, mongo_uri, mongo_db, mongo_coll, use_mongo_cb, vector_store_state, mongo_handler_state], [index_status, vector_store_state, mongo_handler_state], show_progress="full")
-        clear_idx_btn.click(clear_index, outputs=[index_status, vector_store_state, mongo_handler_state], show_progress="full")
-        import_file.change(session_import_handler, import_file, [chatbot, threads_state, active_thread_id, thread_list, m_thread_list], show_progress="full")
-        export_btn.click(session_export_handler, [chatbot, threads_state, active_thread_id], export_file, show_progress="full").then(lambda: gr.update(visible=True), None, export_file)
-    return demo
+from app_module import get_llm, build_demo
 
 if __name__ == "__main__":
-    get_llm(); build_demo().launch(server_name="0.0.0.0")
+    get_llm()
+    build_demo().launch(server_name="0.0.0.0")

app_local.py

@@ -1,554 +1,11 @@
-import os
-import torch
-import gradio as gr
-import time
-import re
-import codecs
-import uuid
-import json
-import logging
-import tempfile
-import numpy as np
-import scipy.io.wavfile as wavfile
-import asyncio
-import warnings
-from typing import List, Tuple, Generator, Dict
-from threading import Thread
-
-# ML / Transformers
-import transformers
-transformers.utils.logging.set_verbosity_error()
-warnings.filterwarnings("ignore", category=UserWarning, module="gradio.components.dropdown")
-from transformers import AutoProcessor, Gemma3ForConditionalGeneration, TextIteratorStreamer
-
-# --- Logging Setup ---
-# Set root logger to ERROR to suppress external library noise
-logging.basicConfig(level=logging.ERROR, format='%(name)s [%(levelname)s] %(message)s')
-
-# Specific library suppressions
-for lib in ["transformers", "accelerate", "httpx", "gradio", "langchain"]:
-    logging.getLogger(lib).setLevel(logging.ERROR)
-
-# Application-level logger
-logger = logging.getLogger("app")
-logger.setLevel(logging.DEBUG)
-logger.propagate = False  # DO NOT propagate to root to avoid double-logging or filtering
-ch = logging.StreamHandler()
-ch.setLevel(logging.DEBUG)
-ch.setFormatter(logging.Formatter('[app] [%(levelname)s] %(message)s'))
-logger.addHandler(ch)
-
-# --------------------------------------------------------------------
-# Konfiguration & Globale States
-# --------------------------------------------------------------------
-EMBED_MODEL_ID = "google/embeddinggemma-300m"
-LLM_MODEL_ID = "google/gemma-3-4b-it"
-
-EMBEDDING_FUNCTION = None
-LLM_MODEL = None
-LLM_PROCESSOR = None
-
-# --- UI Premium Aesthetics ---
-PREMIUM_CSS = """
-.glass-panel {
-    background: rgba(255, 255, 255, 0.05) !important;
-    backdrop-filter: blur(10px) !important;
-    border: 1px solid rgba(255, 255, 255, 0.1) !important;
-    border-radius: 15px !important;
-    box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37) !important;
-}
-.sidebar-panel {
-    border-right: 1px solid rgba(255, 255, 255, 0.1) !important;
-    height: 100vh;
-}
-    border-bottom: 2px solid #0f3460;
-}
-.desktop-only { display: block; }
-.mobile-only { display: none; }
-@media (max-width: 768px) {
-    .desktop-only { display: none !important; }
-    .mobile-only { display: block !important; }
-    .sidebar-panel { display: none !important; }
-}
-"""
-
-try:
-    from pypdf import PdfReader
-    from langchain_community.vectorstores import FAISS
-    from langchain_huggingface import HuggingFaceEmbeddings
-    from langchain_core.documents import Document
-    from langchain_text_splitters import RecursiveCharacterTextSplitter
-    from mongochain import MongoDBHandler
-except ImportError:
-    pass
-
-# Spiritual Integration
-try:
-    from spiritual_bridge import get_oracle_data
-except ImportError:
-    get_oracle_data = None
-
-# --- Model Loading ---
-def get_device() -> torch.device:
-    if torch.cuda.is_available(): return torch.device("cuda")
-    return torch.device("cpu")
-
-def get_embedding_function():
-    global EMBEDDING_FUNCTION
-    if EMBEDDING_FUNCTION is None:
-        device = get_device()
-        logger.debug(f"Initialisiere Embedding-Modell '{EMBED_MODEL_ID}' auf Device '{device}'.")
-        EMBEDDING_FUNCTION = HuggingFaceEmbeddings(
-            model_name=EMBED_MODEL_ID,
-            model_kwargs={'device': device}
-        )
-        logger.debug("Embedding-Modell erfolgreich initialisiert.")
-    return EMBEDDING_FUNCTION
-
-def get_llm():
-    global LLM_MODEL, LLM_PROCESSOR
-    if LLM_MODEL is None or LLM_PROCESSOR is None:
-        device = get_device()
-        logger.debug(f"Initialisiere LLM '{LLM_MODEL_ID}' auf Device '{device}'.")
-        dtype = torch.bfloat16 if "cuda" in device.type else torch.float32
-        LLM_MODEL = Gemma3ForConditionalGeneration.from_pretrained(
-            LLM_MODEL_ID,
-            dtype=dtype,
-            device_map="auto",
-        ).eval()
-        LLM_PROCESSOR = AutoProcessor.from_pretrained(LLM_MODEL_ID)
-        logger.debug("LLM und Prozessor erfolgreich initialisiert.")
-    return LLM_MODEL, LLM_PROCESSOR
-
-# --- Language Detection ---
-def detect_language(text: str) -> str:
-    if not text or len(text) < 3: return "English"
-    model, processor = get_llm()
-    prompt = f"Detect the language of the following text and return ONLY the language name (e.g., 'English', 'German', 'French'):\n\n\"{text}\""
-    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
-    inputs = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
-    with torch.no_grad():
-        outputs = model.generate(inputs, max_new_tokens=20, do_sample=False)
-    raw_output = processor.batch_decode(outputs[:, inputs.shape[1]:], skip_special_tokens=True)[0].strip()
-    logger.debug(f"DEBUG: Raw Language Detection Output: '{raw_output}'")
-    
-    keywords = ["English", "German", "French", "Spanish", "Italian", "Dutch", "Russian", "Chinese", "Japanese"]
-    for k in keywords:
-        if k.lower() in raw_output.lower():
-            logger.debug(f"DEBUG: Detected User Language (Normalized): '{k}'")
-            return k
-    return "English"
-
-# --- Document Handling ---
-def extract_text_from_file(path: str) -> str:
-    ext = os.path.splitext(path)[1].lower()
-    if ext in [".txt", ".md", ".markdown"]:
-        with open(path, "r", encoding="utf-8", errors="ignore") as f: return f.read()
-    if ext == ".pdf":
-        text_parts = []
-        try:
-            reader = PdfReader(path)
-            for page in reader.pages:
-                page_text = page.extract_text()
-                if page_text: text_parts.append(page_text)
-            return "\n\n".join(text_parts)
-        except Exception as e:
-            logger.error(f"Error reading PDF {path}: {e}"); return ""
-    try:
-        with open(path, "r", encoding="utf-8", errors="ignore") as f: return f.read()
-    except Exception: return ""
-
-def get_text_splitter() -> RecursiveCharacterTextSplitter:
-    return RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200, length_function=len)
-
-# --- RAG Core ---
-def index_files(file_paths, mongo_uri, db_name, coll_name, use_mongo, vs_state, mh_state, progress=gr.Progress(track_tqdm=True)):
-    if not file_paths: return "Keine Dateien zum Indexieren ausgewählt.", vs_state, mh_state
-    
-    logger.debug(f"Indexierung gestartet für {len(file_paths)} Datei(en).")
-    embed_fn = get_embedding_function()
-    splitter = get_text_splitter()
-    documents = []
-    
-    for path in progress.tqdm(file_paths, desc="1/2: Dateien verarbeiten"):
-        if path is None: continue
-        text = extract_text_from_file(path)
-        if not text.strip(): continue
-        chunks = splitter.split_text(text)
-        source_name = os.path.basename(path)
-        for c in chunks:
-            documents.append(Document(page_content=c, metadata={"source": source_name}))
-    
-    logger.debug(f"Total chunks created: {len(documents)}")
-    if not documents: return "Kein Text zum Indexieren gefunden.", vs_state, mh_state
-    
-    progress(0.7, desc="2/2: Indexing...")
-    new_vs = FAISS.from_documents(documents, embed_fn)
-    if vs_state: 
-        vs_state.merge_from(new_vs)
-    else: 
-        vs_state = new_vs
-        
-    mh_state = None
-    if use_mongo:
-        try:
-            mh_state = MongoDBHandler(uri=mongo_uri, db_name=db_name, collection_name=coll_name)
-            mh_state.connect()
-            logger.debug(f"Pushe {len(documents)} Chunks nach MongoDB...")
-            for doc in documents:
-                mh_state.insert_chunk(doc.page_content, doc.metadata)
-            logger.debug("MongoDB-Sync abgeschlossen.")
-        except Exception as e:
-            logger.error(f"Mongo Error: {e}")
-
-    logger.debug(f"Indexierung abgeschlossen. Gesamt: {vs_state.index.ntotal} Chunks.")
-    return f"Index aktualisiert: {vs_state.index.ntotal} Chunks insgesamt.", vs_state, mh_state
-
-def clear_index():
-    import gc; gc.collect()
-    logger.debug("Vektor-Index wurde geleert.")
-    return "Index geleert.", None, None
-
-def retrieve_relevant_chunks(query, vs_state, mh_state, top_k=3):
-    if not vs_state: return []
-    logger.debug(f"Suche in FAISS: '{query}'")
-    docs = vs_state.similarity_search(query, k=top_k)
-    return [{"content": d.page_content, "source": d.metadata.get("source", "Unknown")} for d in docs]
-
-def build_rag_prompt(user_question: str, retrieved_chunks: List[Dict]) -> str:
-    if not retrieved_chunks: context_str = "Kein relevanter Kontext gefunden."
-    else:
-        context_parts = [f"[{i}] (Quelle: {ch['source']}): \"{ch['content']}\"" for i, ch in enumerate(retrieved_chunks, 1)]
-        context_str = "\n\n".join(context_parts)
-    return (f"Beantworte die Benutzerfrage nur basierend auf dem Kontext.\n\n"
-            f"--- Kontext ---\n{context_str}\n\n"
-            f"--- Frage ---\n{user_question}\n\n"
-            f"--- Antwort ---")
-
-# --- Agent System ---
-def build_agent_prompt(query, context, history, language="English", short_answers=False):
-    context_str = "\n".join([f"- {c['content']} (Source: {c['source']})" for i, c in enumerate(context)])
-    
-    style_instruction = "Be concise." if short_answers else ""
-    
-    system = f"""You are Sage 6.5, a spiritual AI guide. 
-Respond in {language}. {style_instruction}
-If you need to use a tool, you MUST use the following JSON format inside <tool_call> tags:
-<tool_call>{{"name": "tool_name", "arguments": {{"arg1": "val1"}}}}</tool_call>
-
-Available Tools:
-1. oracle_consultation: Consult the archive for deep wisdom. Arguments: {{"topic": "str", "name": "str (Optional. Use ONLY if the user explicitly stated their name, otherwise omit)"}}
-"""
-    return system + f"\n\nContext:\n{context_str}\n\nUser Question: {query}"
-
-def chat_agent_stream(query, history, vs_state, mh_state, user_lang=None, short_answers=False):
-    model, processor = get_llm()
-    lang = user_lang if user_lang else detect_language(query)
-    context = retrieve_relevant_chunks(query, vs_state, mh_state)
-    prompt = build_agent_prompt(query, context, history, language=lang, short_answers=short_answers)
-    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
-    
-    logger.info(f"[AGENT] 🏁 Starting Agent Loop for Query: '{query}' (Lang: {lang})")
-    
-def chat_agent_stream(query, history, vs_state, mh_state, user_lang=None, short_answers=False):
-    model, processor = get_llm()
-    lang = user_lang if user_lang else detect_language(query)
-    context = retrieve_relevant_chunks(query, vs_state, mh_state)
-    prompt = build_agent_prompt(query, context, history, language=lang, short_answers=short_answers)
-    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
-    
-    logger.info(f"[AGENT] 🏁 Starting Agent Loop for Query: '{query}' (Lang: {lang})")
-    
-    max_turns = 3
-    for turn in range(max_turns):
-        logger.info(f"[AGENT] 🔄 Turn {turn+1}/{max_turns}")
-        
-        input_ids = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
-        streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)
-        
-        gen_kwargs = {"input_ids": input_ids, "streamer": streamer, "max_new_tokens": 512, "do_sample": False}
-        thread = Thread(target=model.generate, kwargs=gen_kwargs)
-        thread.start()
-        
-        current_turn_text = ""
-        # We yield a TUPLE: (accumulated_text_for_THIS_turn, is_final)
-        # But wait, the wrapper needs to handle new messages.
-        # Strategy: Yield just the text of THIS turn. Wrapper handles appending to a NEW history item each turn.
-        
-        logger.info("[AGENT] ⏳ Streaming response...")
-        for new_text in streamer:
-            current_turn_text += new_text
-            clean_chunk = re.sub(r"<tool_call>.*?</tool_call>", "", current_turn_text, flags=re.DOTALL)
-            yield clean_chunk.strip()
-            
-        logger.info(f"[AGENT] 🛑 Raw Model Output: {current_turn_text}")
-        
-        # Tool Detection
-        tool_match = re.search(r"<tool_call>(.*?)</tool_call>", current_turn_text, re.DOTALL)
-        if tool_match:
-            # If tool found, this turn is OVER regarding user output.
-            # We yield a special signal to indicate "End of Message, Start Next Logic"?
-            # actually, if we yield, the wrapper updates history[-1]. 
-            # If we want a NEW message, we need to tell wrapper to append.
-            # Simplified: Use a separator? No, wrapper loop is easier.
-            
-            # For now, let's keep the generator simple. 
-            # It yields text updates for the CURRENT turn.
-            # Once loop breaks (tool found), we start next turn.
-            # BUT: How to tell wrapper "This turn is done, start a new bubble"?
-            # Generator yields: {"text": "...", "new_bubble": True/False}
-            
-            try:
-                tool_data = json.loads(tool_match.group(1))
-                logger.info(f"[AGENT] 🛠️ Tool Call Detected: {tool_data}")
-                
-                tool_name = tool_data.get("name")
-                tool_args = tool_data.get("arguments", {})
-                
-                if tool_name == "oracle_consultation":
-                    topic = tool_args.get("topic", "")
-                    
-                    # Name Handling: Use provided name or default to 'Seeker'
-                    req_name = tool_args.get("name", "").strip()
-                    effective_name = req_name if req_name else "Seeker"
-                    
-                    logger.info(f"[AGENT] 🔮 Executing Oracle with topic: '{topic}' for '{effective_name}'")
-                    if get_oracle_data:
-                        try:
-                            # Call backend
-                            oracle_raw = get_oracle_data(name=effective_name, topic=topic, date_str="")
-                            
-                            # FILTERING LOGIC (User Request: Only 3 sources, no BOS API/ELS)
-                            # We construct a filtered dictionary
-                            filtered_result = {
-                                "wisdom_nodes": oracle_raw.get("wisdom_nodes", [])
-                            }
-                            # If wisdom_nodes is missing/empty, maybe keep raw but warn?
-                            # Use strict filtering as requested.
-                            
-                            tool_result = json.dumps(filtered_result, indent=2)
-                            logger.info(f"[AGENT] ✅ Oracle Result Obtained (Filtered Size: {len(tool_result)} bytes)")
-                        except Exception as e:
-                            logger.error(f"[AGENT] ❌ Oracle Backend Error: {e}")
-                            tool_result = f"Error executing oracle: {str(e)}"
-                    else:
-                        logger.warning("[AGENT] ⚠️ Oracle module not available")
-                        tool_result = "Oracle module not available."
-                else:
-                    logger.warning(f"[AGENT] ⚠️ Unknown tool requested: {tool_name}")
-                    tool_result = f"Unknown tool: {tool_name}"
-
-                messages.append({"role": "assistant", "content": [{"type": "text", "text": current_turn_text}]})
-                
-                tool_injection = f"""<tool_result>{tool_result}</tool_result>
-Now interpret this result soulfully and poetically for the user. Do not mention JSON.
-IMPORTANT: Connect this smoothly to your previous statement. Ensure a fluid, cohesive narrative without abrupt jumps."""
-                
-                logger.info("[AGENT] 💉 Injecting Tool Result into context for interpretation...")
-                messages.append({"role": "user", "content": [{"type": "text", "text": tool_injection}]})
-                
-                # Yield a special marker to say "Turn Finished"
-                yield "__TURN_END__" 
-                continue
-            except Exception as e:
-                logger.error(f"[AGENT] 💥 Tool parsing/logic crash: {e}")
-                break
-        else:
-            logger.info("[AGENT] ✨ No tool calls. Finalizing response.")
-            break
-
-# --- Voice Engine ---
-async def generate_speech(text: str, lang: str = "English"):
-    import edge_tts
-    VOICES = {"English": "en-US-GuyNeural", "German": "de-DE-ConradNeural", "French": "fr-FR-HenriNeural"}
-    voice = VOICES.get(lang, VOICES["English"])
-    logger.debug(f"TRACE: generate_speech() called. Text len: {len(text)}, Lang: {lang}")
-    temp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
-    communicate = edge_tts.Communicate(text, voice)
-    await communicate.save(temp_wav.name)
-    return temp_wav.name
-
-def transcribe_audio(path: str):
-    logger.debug(f"TRACE: transcribe_audio() called with path: {path}")
-    return "Transcribed text"
-
-# --- Gradio Wrappers ---
-def voice_chat_wrapper(audio_path, history, threads, tid, vs_state, mh_state, short_answers):
-    if audio_path is None: yield history, threads, gr.update(), gr.update(), None; return
-    text = transcribe_audio(audio_path)
-    detected_lang = detect_language(text)
-    final_history, final_threads, final_update = history, threads, gr.update()
-    if text:
-        gen = chat_wrapper(text, history, threads, tid, vs_state, mh_state, short_answers=short_answers, lang=detected_lang)
-        for h, t, tr1, tr2, _ in gen:
-            final_history, final_threads, final_update = h, t, tr1
-            yield h, t, tr1, tr2, None
-    import asyncio
-    last_msg = final_history[-1]["content"] if final_history else ""
-    if last_msg:
-        voice_path = asyncio.run(generate_speech(last_msg, lang=detected_lang))
-        yield final_history, final_threads, final_update, final_update, voice_path
-    else:
-        yield final_history, final_threads, final_update, final_update, None
-
-def chat_wrapper(message, history, threads, tid, vs_state, mh_state, short_answers=False, lang=None):
-    if not message.strip(): 
-        upd = gr.update(choices=[(v["title"], k) for k, v in threads.items()], value=tid)
-        yield history, threads, upd, upd, None
-        return
-    history.append({"role": "user", "content": message})
-    yield history, threads, gr.update(), gr.update(), None
-    
-    # Start first response bubble
-    history.append({"role": "assistant", "content": ""})
-    
-    for response_part in chat_agent_stream(message, history[:-2], vs_state, mh_state, user_lang=lang, short_answers=short_answers):
-        if response_part == "__TURN_END__":
-            # Start NEW bubble for next turn
-            history.append({"role": "assistant", "content": ""})
-            yield history, threads, gr.update(), gr.update(), None
-        else:
-            history[-1]["content"] = response_part
-            yield history, threads, gr.update(), gr.update(), None
-            
-    # Cleanup empty bubble if exists (rare edge case)
-    if not history[-1]["content"]: history.pop()
-    
-    if tid not in threads: threads[tid] = {"title": "Conversation", "history": []}
-    threads[tid]["history"] = history
-    if len(history) <= 2: 
-        threads[tid]["title"] = (message[:25] + "..") if message else "Conversation"
-    choices = [(v["title"], k) for k, v in threads.items()]
-    upd = gr.update(choices=choices, value=tid)
-    yield history, threads, upd, upd, None
-
-def stream_handler(stream, state):
-    if stream is None: return state, None
-    sr, y = stream
-    if y is None or len(y) == 0: return state, None
-    y = y.astype(np.float32)
-    y = y / np.max(np.abs(y)) if np.max(np.abs(y)) > 0 else y
-    rms = np.sqrt(np.mean(y**2))
-    SILENCE_THRESHOLD, SILENCE_CHUNKS = 0.01, 20
-    if state is None: state = {"buffer": [], "silence_counter": 0, "is_speaking": False}
-    state["buffer"].append((sr, stream[1]))
-    if rms > SILENCE_THRESHOLD:
-        state["is_speaking"], state["silence_counter"] = True, 0
-    elif state["is_speaking"]:
-        state["silence_counter"] += 1
-    if state["is_speaking"] and state["silence_counter"] > SILENCE_CHUNKS:
-        full_audio = np.concatenate([c[1] for c in state["buffer"]])
-        sr_final = state["buffer"][0][0]
-        temp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-        wavfile.write(temp_wav.name, sr_final, full_audio)
-        return {"buffer": [], "silence_counter": 0, "is_speaking": False}, temp_wav.name
-    return state, None
-
-# --- INTERNAL CALLBACKS ---
-def create_new_thread_callback(threads):
-    nid = str(uuid.uuid4())
-    threads[nid] = {"title": "New Conversation", "history": []}
-    choices = [(v["title"], k) for k, v in threads.items()]
-    return threads, nid, gr.update(choices=choices, value=nid), []
-
-def switch_thread(tid, t_state):
-    logger.debug(f"TRACE: switch_thread() called for tid: {tid}")
-    if isinstance(tid, list):
-        if not tid: return [], gr.update(), gr.update(), gr.update()
-        tid = tid[0]
-    tid = str(tid)
-    history = t_state.get(tid, {}).get("history", [])
-    choices = [(v["title"], k) for k, v in t_state.items()]
-    upd = gr.update(value=tid, choices=choices)
-    return history, tid, upd, upd
-
-def session_import_handler(file):
-    if not file: return [], {}, None, gr.update(), gr.update()
-    with open(file.name, "r") as f: data = json.load(f)
-    imported_threads = data.get("threads", {})
-    active_id = data.get("active_id", list(imported_threads.keys())[0] if imported_threads else None)
-    history = imported_threads.get(active_id, {}).get("history", []) if active_id else []
-    choices = [(v["title"], k) for k, v in imported_threads.items()]
-    upd = gr.update(choices=choices, value=active_id)
-    return history, imported_threads, active_id, upd, upd
-
-def session_export_handler(chatbot_val, threads, active_id):
-    export_data = {"threads": threads, "active_id": active_id}
-    path = "sage_session_export.json"
-    with open(path, "w") as f: json.dump(export_data, f, indent=2)
-    return path
-
-def build_demo() -> gr.Blocks:
-    initial_thread_id = str(uuid.uuid4())
-    with gr.Blocks(title="Gemma 3 Sage v6.5 SP1", theme="soft", css=PREMIUM_CSS) as demo:
-        threads_state = gr.State({initial_thread_id: {"title": "New Chat", "history": []}})
-        active_thread_id = gr.State(initial_thread_id)
-        vector_store_state = gr.State(None)
-        mongo_handler_state = gr.State(None)
-        
-        with gr.Row(elem_classes="header-tray"):
-            gr.Markdown("# 🌌 Gemma 3 Sage <small>v6.5 SP1</small>")
-
-        with gr.Row():
-            # Desktop Sidebar (Radio List)
-            with gr.Column(scale=1, variant="panel", elem_classes="sidebar-panel glass-panel desktop-only"):
-                gr.Markdown("### 🕒 Recent Chats")
-                # Using Radio as a list selector
-                thread_list = gr.Radio(choices=[(f"New Chat", initial_thread_id)], value=initial_thread_id, label=None, interactive=True, container=False)
-                new_thread_btn = gr.Button("➕ New Conversation", variant="secondary")
-                
-            with gr.Column(scale=4):
-                with gr.Tabs() as tabs:
-                    with gr.Tab("💬 Live Conversation", id=0, elem_classes="glass-panel"):
-                        
-                        # Mobile Menu (Accordion + Dropdown)
-                        with gr.Accordion("🕒 Conversations (Mobile)", open=False, visible=True, elem_classes="mobile-only") as mobile_sessions:
-                            m_thread_list = gr.Dropdown(choices=[("New Chat", initial_thread_id)], value=initial_thread_id, label="Select Session")
-                            m_new_btn = gr.Button("➕ New Conversation", variant="secondary")
-                        
-                        chatbot = gr.Chatbot(label="Sage", type="messages", height=600, show_label=False, autoscroll=False)
-                        with gr.Row():
-                            msg_textbox = gr.Textbox(placeholder="Whisper your heart or type...", label=None, scale=8, container=False)
-                            submit_btn = gr.Button("Send", variant="primary", scale=1)
-                        # Moved Short Answer checkbox here for visibility
-                        with gr.Row():
-                            short_ans_cb = gr.Checkbox(label="Short Answers", value=False)
-                        with gr.Row():
-                            stream_state = gr.State({"buffer": [], "silence_counter": 0, "is_speaking": False})
-                            audio_input = gr.Audio(label="Voice", sources="microphone", type="numpy", streaming=True)
-                            processed_audio, audio_output = gr.State(None), gr.Audio(label="Sage Voice", autoplay=True, visible=False)
-                        with gr.Row(elem_classes="glass-panel"):
-                            export_btn = gr.Button("📤 Export Session", variant="secondary", size="sm")
-                            import_file = gr.File(label="Import", file_count="single", height=60)
-                            export_file = gr.File(label="Download", interactive=False, visible=False)
-
-                    with gr.Tab("📚 Sacred Knowledge", id=1, elem_classes="glass-panel"):
-                        file_uploader = gr.File(label="Upload", file_count="multiple", type="filepath")
-                        index_button = gr.Button("🔄 Sync Index", variant="primary")
-                        index_status = gr.Markdown("Bereit.")
-                        with gr.Accordion("⚙️ MongoDB Settings", open=False):
-                            mongo_uri = gr.Textbox(label="URI", value="mongodb://localhost:27017/")
-                            mongo_db = gr.Textbox(label="DB", value="rag_db")
-                            mongo_coll = gr.Textbox(label="Coll", value="gemma_chunks")
-                            use_mongo_cb = gr.Checkbox(label="Sync to Mongo", value=True)
-                            clear_mongo_btn = gr.Button("🗑️ Clear Mongo")
-                        clear_idx_btn = gr.Button("🧹 Clear FAISS", variant="stop")
-                        
-                        clear_mongo_btn.click(lambda u, d, c: MongoDBHandler(u, d, c).connect() and MongoDBHandler(u, d, c).clear() or "Mongo geleert", [mongo_uri, mongo_db, mongo_coll], index_status)
-
-        audio_input.stream(stream_handler, [audio_input, stream_state], [stream_state, processed_audio])
-        processed_audio.change(voice_chat_wrapper, [processed_audio, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output])
-        msg_textbox.submit(chat_wrapper, [msg_textbox, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output]).then(lambda: "", None, msg_textbox)
-        submit_btn.click(chat_wrapper, [msg_textbox, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output]).then(lambda: "", None, msg_textbox)
-        new_thread_btn.click(create_new_thread_callback, [threads_state], [threads_state, active_thread_id, thread_list, chatbot])
-        m_new_btn.click(create_new_thread_callback, [threads_state], [threads_state, active_thread_id, m_thread_list, chatbot])
-        thread_list.change(switch_thread, [thread_list, threads_state], [chatbot, active_thread_id, thread_list, m_thread_list])
-        m_thread_list.change(switch_thread, [m_thread_list, threads_state], [chatbot, active_thread_id, thread_list, m_thread_list])
-        index_button.click(index_files, [file_uploader, mongo_uri, mongo_db, mongo_coll, use_mongo_cb, vector_store_state, mongo_handler_state], [index_status, vector_store_state, mongo_handler_state], show_progress="full")
-        clear_idx_btn.click(clear_index, outputs=[index_status, vector_store_state, mongo_handler_state], show_progress="full")
-        import_file.change(session_import_handler, import_file, [chatbot, threads_state, active_thread_id, thread_list, m_thread_list], show_progress="full")
-        export_btn.click(session_export_handler, [chatbot, threads_state, active_thread_id], export_file, show_progress="full").then(lambda: gr.update(visible=True), None, export_file)
-    return demo
+from app_module import get_llm, build_demo
 
 if __name__ == "__main__":
-    get_llm(); build_demo().launch(share=True, server_name="0.0.0.0", ssl_certfile="cert.pem", ssl_keyfile="key.pem", ssl_verify=False)
+    get_llm()
+    build_demo().launch(
+        share=True, 
+        server_name="0.0.0.0", 
+        ssl_certfile="cert.pem", 
+        ssl_keyfile="key.pem", 
+        ssl_verify=False
+    )

app_module.py

@@ -0,0 +1,553 @@
+import os
+import torch
+import gradio as gr
+import time
+import re
+import codecs
+import uuid
+import json
+import logging
+import tempfile
+import numpy as np
+import scipy.io.wavfile as wavfile
+import asyncio
+import warnings
+from typing import List, Tuple, Generator, Dict
+from threading import Thread
+
+# ML / Transformers
+import transformers
+transformers.utils.logging.set_verbosity_error()
+warnings.filterwarnings("ignore", category=UserWarning, module="gradio.components.dropdown")
+from transformers import AutoProcessor, Gemma3ForConditionalGeneration, TextIteratorStreamer
+
+# --- Logging Setup ---
+# Set root logger to ERROR to suppress external library noise
+logging.basicConfig(level=logging.ERROR, format='%(name)s [%(levelname)s] %(message)s')
+
+# Specific library suppressions
+for lib in ["transformers", "accelerate", "httpx", "gradio", "langchain"]:
+    logging.getLogger(lib).setLevel(logging.ERROR)
+
+# Application-level logger
+logger = logging.getLogger("app")
+logger.setLevel(logging.DEBUG)
+logger.propagate = False  # DO NOT propagate to root to avoid double-logging or filtering
+ch = logging.StreamHandler()
+ch.setLevel(logging.DEBUG)
+ch.setFormatter(logging.Formatter('[app] [%(levelname)s] %(message)s'))
+logger.addHandler(ch)
+
+# --------------------------------------------------------------------
+# Konfiguration & Globale States
+# --------------------------------------------------------------------
+EMBED_MODEL_ID = "google/embeddinggemma-300m"
+LLM_MODEL_ID = "google/gemma-3-4b-it"
+
+EMBEDDING_FUNCTION = None
+LLM_MODEL = None
+LLM_PROCESSOR = None
+
+# --- UI Premium Aesthetics ---
+PREMIUM_CSS = """
+.glass-panel {
+    background: rgba(255, 255, 255, 0.05) !important;
+    backdrop-filter: blur(10px) !important;
+    border: 1px solid rgba(255, 255, 255, 0.1) !important;
+    border-radius: 15px !important;
+    box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37) !important;
+}
+.sidebar-panel {
+    border-right: 1px solid rgba(255, 255, 255, 0.1) !important;
+    height: 100vh;
+}
+    border-bottom: 2px solid #0f3460;
+}
+.desktop-only { display: block; }
+.mobile-only { display: none; }
+@media (max-width: 768px) {
+    .desktop-only { display: none !important; }
+    .mobile-only { display: block !important; }
+    .sidebar-panel { display: none !important; }
+}
+"""
+
+try:
+    from pypdf import PdfReader
+    from langchain_community.vectorstores import FAISS
+    from langchain_huggingface import HuggingFaceEmbeddings
+    from langchain_core.documents import Document
+    from langchain_text_splitters import RecursiveCharacterTextSplitter
+    from mongochain import MongoDBHandler
+except ImportError:
+    pass
+
+# Spiritual Integration
+try:
+    from spiritual_bridge import get_oracle_data
+except ImportError:
+    get_oracle_data = None
+
+# --- Model Loading ---
+def get_device() -> torch.device:
+    if torch.cuda.is_available(): return torch.device("cuda")
+    return torch.device("cpu")
+
+def get_embedding_function():
+    global EMBEDDING_FUNCTION
+    if EMBEDDING_FUNCTION is None:
+        device = get_device()
+        logger.debug(f"Initialisiere Embedding-Modell '{EMBED_MODEL_ID}' auf Device '{device}'.")
+        EMBEDDING_FUNCTION = HuggingFaceEmbeddings(
+            model_name=EMBED_MODEL_ID,
+            model_kwargs={'device': device}
+        )
+        logger.debug("Embedding-Modell erfolgreich initialisiert.")
+    return EMBEDDING_FUNCTION
+
+def get_llm():
+    global LLM_MODEL, LLM_PROCESSOR
+    if LLM_MODEL is None or LLM_PROCESSOR is None:
+        device = get_device()
+        logger.debug(f"Initialisiere LLM '{LLM_MODEL_ID}' auf Device '{device}'.")
+        dtype = torch.bfloat16 if "cuda" in device.type else torch.float32
+        LLM_MODEL = Gemma3ForConditionalGeneration.from_pretrained(
+            LLM_MODEL_ID,
+            dtype=dtype,
+            device_map="auto",
+        ).eval()
+        LLM_PROCESSOR = AutoProcessor.from_pretrained(LLM_MODEL_ID)
+        logger.debug("LLM und Prozessor erfolgreich initialisiert.")
+    return LLM_MODEL, LLM_PROCESSOR
+
+# --- Language Detection ---
+def detect_language(text: str) -> str:
+    if not text or len(text) < 3: return "English"
+    model, processor = get_llm()
+    prompt = f"Detect the language of the following text and return ONLY the language name (e.g., 'English', 'German', 'French'):\n\n\"{text}\""
+    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
+    inputs = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
+    with torch.no_grad():
+        outputs = model.generate(inputs, max_new_tokens=20, do_sample=False)
+    raw_output = processor.batch_decode(outputs[:, inputs.shape[1]:], skip_special_tokens=True)[0].strip()
+    logger.debug(f"DEBUG: Raw Language Detection Output: '{raw_output}'")
+    
+    keywords = ["English", "German", "French", "Spanish", "Italian", "Dutch", "Russian", "Chinese", "Japanese"]
+    for k in keywords:
+        if k.lower() in raw_output.lower():
+            logger.debug(f"DEBUG: Detected User Language (Normalized): '{k}'")
+            return k
+    return "English"
+
+# --- Document Handling ---
+def extract_text_from_file(path: str) -> str:
+    ext = os.path.splitext(path)[1].lower()
+    if ext in [".txt", ".md", ".markdown"]:
+        with open(path, "r", encoding="utf-8", errors="ignore") as f: return f.read()
+    if ext == ".pdf":
+        text_parts = []
+        try:
+            reader = PdfReader(path)
+            for page in reader.pages:
+                page_text = page.extract_text()
+                if page_text: text_parts.append(page_text)
+            return "\n\n".join(text_parts)
+        except Exception as e:
+            logger.error(f"Error reading PDF {path}: {e}"); return ""
+    try:
+        with open(path, "r", encoding="utf-8", errors="ignore") as f: return f.read()
+    except Exception: return ""
+
+def get_text_splitter() -> RecursiveCharacterTextSplitter:
+    return RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200, length_function=len)
+
+# --- RAG Core ---
+def index_files(file_paths, mongo_uri, db_name, coll_name, use_mongo, vs_state, mh_state, progress=gr.Progress(track_tqdm=True)):
+    if not file_paths: return "Keine Dateien zum Indexieren ausgewählt.", vs_state, mh_state
+    
+    logger.debug(f"Indexierung gestartet für {len(file_paths)} Datei(en).")
+    embed_fn = get_embedding_function()
+    splitter = get_text_splitter()
+    documents = []
+    
+    for path in progress.tqdm(file_paths, desc="1/2: Dateien verarbeiten"):
+        if path is None: continue
+        text = extract_text_from_file(path)
+        if not text.strip(): continue
+        chunks = splitter.split_text(text)
+        source_name = os.path.basename(path)
+        for c in chunks:
+            documents.append(Document(page_content=c, metadata={"source": source_name}))
+    
+    logger.debug(f"Total chunks created: {len(documents)}")
+    if not documents: return "Kein Text zum Indexieren gefunden.", vs_state, mh_state
+    
+    progress(0.7, desc="2/2: Indexing...")
+    new_vs = FAISS.from_documents(documents, embed_fn)
+    if vs_state: 
+        vs_state.merge_from(new_vs)
+    else: 
+        vs_state = new_vs
+        
+    mh_state = None
+    if use_mongo:
+        try:
+            mh_state = MongoDBHandler(uri=mongo_uri, db_name=db_name, collection_name=coll_name)
+            mh_state.connect()
+            logger.debug(f"Pushe {len(documents)} Chunks nach MongoDB...")
+            for doc in documents:
+                mh_state.insert_chunk(doc.page_content, doc.metadata)
+            logger.debug("MongoDB-Sync abgeschlossen.")
+        except Exception as e:
+            logger.error(f"Mongo Error: {e}")
+
+    logger.debug(f"Indexierung abgeschlossen. Gesamt: {vs_state.index.ntotal} Chunks.")
+    return f"Index aktualisiert: {vs_state.index.ntotal} Chunks insgesamt.", vs_state, mh_state
+
+def clear_index():
+    import gc; gc.collect()
+    logger.debug("Vektor-Index wurde geleert.")
+    return "Index geleert.", None, None
+
+def retrieve_relevant_chunks(query, vs_state, mh_state, top_k=3):
+    if not vs_state: return []
+    logger.debug(f"Suche in FAISS: '{query}'")
+    docs = vs_state.similarity_search(query, k=top_k)
+    return [{"content": d.page_content, "source": d.metadata.get("source", "Unknown")} for d in docs]
+
+def build_rag_prompt(user_question: str, retrieved_chunks: List[Dict]) -> str:
+    if not retrieved_chunks: context_str = "Kein relevanter Kontext gefunden."
+    else:
+        context_parts = [f"[{i}] (Quelle: {ch['source']}): \"{ch['content']}\"" for i, ch in enumerate(retrieved_chunks, 1)]
+        context_str = "\n\n".join(context_parts)
+    return (f"Beantworte die Benutzerfrage nur basierend auf dem Kontext.\n\n"
+            f"--- Kontext ---\n{context_str}\n\n"
+            f"--- Frage ---\n{user_question}\n\n"
+            f"--- Antwort ---")
+
+# --- Agent System ---
+def build_agent_prompt(query, context, history, language="English", short_answers=False):
+    context_str = "\n".join([f"- {c['content']} (Source: {c['source']})" for i, c in enumerate(context)])
+    
+    style_instruction = "Be concise." if short_answers else ""
+    
+    system = f"""You are Sage 6.5, a spiritual AI guide. 
+Respond in {language}. {style_instruction}
+If you need to use a tool, you MUST use the following JSON format inside <tool_call> tags:
+<tool_call>{{"name": "tool_name", "arguments": {{"arg1": "val1"}}}}</tool_call>
+
+Available Tools:
+1. oracle_consultation: Consult the archive for deep wisdom. Arguments: {{"topic": "str", "name": "str (Optional. Use ONLY if the user explicitly stated their name, otherwise omit)"}}
+"""
+    return system + f"\n\nContext:\n{context_str}\n\nUser Question: {query}"
+
+def chat_agent_stream(query, history, vs_state, mh_state, user_lang=None, short_answers=False):
+    model, processor = get_llm()
+    lang = user_lang if user_lang else detect_language(query)
+    context = retrieve_relevant_chunks(query, vs_state, mh_state)
+    prompt = build_agent_prompt(query, context, history, language=lang, short_answers=short_answers)
+    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
+    
+    logger.info(f"[AGENT] 🏁 Starting Agent Loop for Query: '{query}' (Lang: {lang})")
+    
+def chat_agent_stream(query, history, vs_state, mh_state, user_lang=None, short_answers=False):
+    model, processor = get_llm()
+    lang = user_lang if user_lang else detect_language(query)
+    context = retrieve_relevant_chunks(query, vs_state, mh_state)
+    prompt = build_agent_prompt(query, context, history, language=lang, short_answers=short_answers)
+    messages = [{"role": "user", "content": [{"type": "text", "text": prompt}]}]
+    
+    logger.info(f"[AGENT] 🏁 Starting Agent Loop for Query: '{query}' (Lang: {lang})")
+    
+    max_turns = 3
+    for turn in range(max_turns):
+        logger.info(f"[AGENT] 🔄 Turn {turn+1}/{max_turns}")
+        
+        input_ids = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt").to(model.device)
+        streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=True)
+        
+        gen_kwargs = {"input_ids": input_ids, "streamer": streamer, "max_new_tokens": 512, "do_sample": False}
+        thread = Thread(target=model.generate, kwargs=gen_kwargs)
+        thread.start()
+        
+        current_turn_text = ""
+        # We yield a TUPLE: (accumulated_text_for_THIS_turn, is_final)
+        # But wait, the wrapper needs to handle new messages.
+        # Strategy: Yield just the text of THIS turn. Wrapper handles appending to a NEW history item each turn.
+        
+        logger.info("[AGENT] ⏳ Streaming response...")
+        for new_text in streamer:
+            current_turn_text += new_text
+            clean_chunk = re.sub(r"<tool_call>.*?</tool_call>", "", current_turn_text, flags=re.DOTALL)
+            yield clean_chunk.strip()
+            
+        logger.info(f"[AGENT] 🛑 Raw Model Output: {current_turn_text}")
+        
+        # Tool Detection
+        tool_match = re.search(r"<tool_call>(.*?)</tool_call>", current_turn_text, re.DOTALL)
+        if tool_match:
+            # If tool found, this turn is OVER regarding user output.
+            # We yield a special signal to indicate "End of Message, Start Next Logic"?
+            # actually, if we yield, the wrapper updates history[-1]. 
+            # If we want a NEW message, we need to tell wrapper to append.
+            # Simplified: Use a separator? No, wrapper loop is easier.
+            
+            # For now, let's keep the generator simple. 
+            # It yields text updates for the CURRENT turn.
+            # Once loop breaks (tool found), we start next turn.
+            # BUT: How to tell wrapper "This turn is done, start a new bubble"?
+            # Generator yields: {"text": "...", "new_bubble": True/False}
+            
+            try:
+                tool_data = json.loads(tool_match.group(1))
+                logger.info(f"[AGENT] 🛠️ Tool Call Detected: {tool_data}")
+                
+                tool_name = tool_data.get("name")
+                tool_args = tool_data.get("arguments", {})
+                
+                if tool_name == "oracle_consultation":
+                    topic = tool_args.get("topic", "")
+                    
+                    # Name Handling: Use provided name or default to 'Seeker'
+                    req_name = tool_args.get("name", "").strip()
+                    effective_name = req_name if req_name else "Seeker"
+                    
+                    logger.info(f"[AGENT] 🔮 Executing Oracle with topic: '{topic}' for '{effective_name}'")
+                    if get_oracle_data:
+                        try:
+                            # Call backend
+                            oracle_raw = get_oracle_data(name=effective_name, topic=topic, date_str="")
+                            
+                            # FILTERING LOGIC (User Request: Only 3 sources, no BOS API/ELS)
+                            # We construct a filtered dictionary
+                            filtered_result = {
+                                "wisdom_nodes": oracle_raw.get("wisdom_nodes", [])
+                            }
+                            # If wisdom_nodes is missing/empty, maybe keep raw but warn?
+                            # Use strict filtering as requested.
+                            
+                            tool_result = json.dumps(filtered_result, indent=2)
+                            logger.info(f"[AGENT] ✅ Oracle Result Obtained (Filtered Size: {len(tool_result)} bytes)")
+                        except Exception as e:
+                            logger.error(f"[AGENT] ❌ Oracle Backend Error: {e}")
+                            tool_result = f"Error executing oracle: {str(e)}"
+                    else:
+                        logger.warning("[AGENT] ⚠️ Oracle module not available")
+                        tool_result = "Oracle module not available."
+                else:
+                    logger.warning(f"[AGENT] ⚠️ Unknown tool requested: {tool_name}")
+                    tool_result = f"Unknown tool: {tool_name}"
+
+                messages.append({"role": "assistant", "content": [{"type": "text", "text": current_turn_text}]})
+                
+                tool_injection = f"""<tool_result>{tool_result}</tool_result>
+Now interpret this result soulfully and poetically for the user. Do not mention JSON.
+IMPORTANT: Connect this smoothly to your previous statement. Ensure a fluid, cohesive narrative without abrupt jumps."""
+                
+                logger.info("[AGENT] 💉 Injecting Tool Result into context for interpretation...")
+                messages.append({"role": "user", "content": [{"type": "text", "text": tool_injection}]})
+                
+                # Yield a special marker to say "Turn Finished"
+                yield "__TURN_END__" 
+                continue
+            except Exception as e:
+                logger.error(f"[AGENT] 💥 Tool parsing/logic crash: {e}")
+                break
+        else:
+            logger.info("[AGENT] ✨ No tool calls. Finalizing response.")
+            break
+
+# --- Voice Engine ---
+async def generate_speech(text: str, lang: str = "English"):
+    import edge_tts
+    VOICES = {"English": "en-US-GuyNeural", "German": "de-DE-ConradNeural", "French": "fr-FR-HenriNeural"}
+    voice = VOICES.get(lang, VOICES["English"])
+    logger.debug(f"TRACE: generate_speech() called. Text len: {len(text)}, Lang: {lang}")
+    temp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(temp_wav.name)
+    return temp_wav.name
+
+def transcribe_audio(path: str):
+    logger.debug(f"TRACE: transcribe_audio() called with path: {path}")
+    return "Transcribed text"
+
+# --- Gradio Wrappers ---
+def voice_chat_wrapper(audio_path, history, threads, tid, vs_state, mh_state, short_answers):
+    if audio_path is None: yield history, threads, gr.update(), gr.update(), None; return
+    text = transcribe_audio(audio_path)
+    detected_lang = detect_language(text)
+    final_history, final_threads, final_update = history, threads, gr.update()
+    if text:
+        gen = chat_wrapper(text, history, threads, tid, vs_state, mh_state, short_answers=short_answers, lang=detected_lang)
+        for h, t, tr1, tr2, _ in gen:
+            final_history, final_threads, final_update = h, t, tr1
+            yield h, t, tr1, tr2, None
+    import asyncio
+    last_msg = final_history[-1]["content"] if final_history else ""
+    if last_msg:
+        voice_path = asyncio.run(generate_speech(last_msg, lang=detected_lang))
+        yield final_history, final_threads, final_update, final_update, voice_path
+    else:
+        yield final_history, final_threads, final_update, final_update, None
+
+def chat_wrapper(message, history, threads, tid, vs_state, mh_state, short_answers=False, lang=None):
+    if not message.strip(): 
+        upd = gr.update(choices=[(v["title"], k) for k, v in threads.items()], value=tid)
+        yield history, threads, upd, upd, None
+        return
+    history.append({"role": "user", "content": message})
+    yield history, threads, gr.update(), gr.update(), None
+    
+    # Start first response bubble
+    history.append({"role": "assistant", "content": ""})
+    
+    for response_part in chat_agent_stream(message, history[:-2], vs_state, mh_state, user_lang=lang, short_answers=short_answers):
+        if response_part == "__TURN_END__":
+            # Start NEW bubble for next turn
+            history.append({"role": "assistant", "content": ""})
+            yield history, threads, gr.update(), gr.update(), None
+        else:
+            history[-1]["content"] = response_part
+            yield history, threads, gr.update(), gr.update(), None
+            
+    # Cleanup empty bubble if exists (rare edge case)
+    if not history[-1]["content"]: history.pop()
+    
+    if tid not in threads: threads[tid] = {"title": "Conversation", "history": []}
+    threads[tid]["history"] = history
+    if len(history) <= 2: 
+        threads[tid]["title"] = (message[:25] + "..") if message else "Conversation"
+    choices = [(v["title"], k) for k, v in threads.items()]
+    upd = gr.update(choices=choices, value=tid)
+    yield history, threads, upd, upd, None
+
+def stream_handler(stream, state):
+    if stream is None: return state, None
+    sr, y = stream
+    if y is None or len(y) == 0: return state, None
+    y = y.astype(np.float32)
+    y = y / np.max(np.abs(y)) if np.max(np.abs(y)) > 0 else y
+    rms = np.sqrt(np.mean(y**2))
+    SILENCE_THRESHOLD, SILENCE_CHUNKS = 0.01, 20
+    if state is None: state = {"buffer": [], "silence_counter": 0, "is_speaking": False}
+    state["buffer"].append((sr, stream[1]))
+    if rms > SILENCE_THRESHOLD:
+        state["is_speaking"], state["silence_counter"] = True, 0
+    elif state["is_speaking"]:
+        state["silence_counter"] += 1
+    if state["is_speaking"] and state["silence_counter"] > SILENCE_CHUNKS:
+        full_audio = np.concatenate([c[1] for c in state["buffer"]])
+        sr_final = state["buffer"][0][0]
+        temp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+        wavfile.write(temp_wav.name, sr_final, full_audio)
+        return {"buffer": [], "silence_counter": 0, "is_speaking": False}, temp_wav.name
+    return state, None
+
+# --- INTERNAL CALLBACKS ---
+def create_new_thread_callback(threads):
+    nid = str(uuid.uuid4())
+    threads[nid] = {"title": "New Conversation", "history": []}
+    choices = [(v["title"], k) for k, v in threads.items()]
+    return threads, nid, gr.update(choices=choices, value=nid), []
+
+def switch_thread(tid, t_state):
+    logger.debug(f"TRACE: switch_thread() called for tid: {tid}")
+    if isinstance(tid, list):
+        if not tid: return [], gr.update(), gr.update(), gr.update()
+        tid = tid[0]
+    tid = str(tid)
+    history = t_state.get(tid, {}).get("history", [])
+    choices = [(v["title"], k) for k, v in t_state.items()]
+    upd = gr.update(value=tid, choices=choices)
+    return history, tid, upd, upd
+
+def session_import_handler(file):
+    if not file: return [], {}, None, gr.update(), gr.update()
+    with open(file.name, "r") as f: data = json.load(f)
+    imported_threads = data.get("threads", {})
+    active_id = data.get("active_id", list(imported_threads.keys())[0] if imported_threads else None)
+    history = imported_threads.get(active_id, {}).get("history", []) if active_id else []
+    choices = [(v["title"], k) for k, v in imported_threads.items()]
+    upd = gr.update(choices=choices, value=active_id)
+    return history, imported_threads, active_id, upd, upd
+
+def session_export_handler(chatbot_val, threads, active_id):
+    export_data = {"threads": threads, "active_id": active_id}
+    path = "sage_session_export.json"
+    with open(path, "w") as f: json.dump(export_data, f, indent=2)
+    return path
+
+def build_demo() -> gr.Blocks:
+    initial_thread_id = str(uuid.uuid4())
+    with gr.Blocks(title="Gemma 3 Sage v6.5 SP1", theme="soft", css=PREMIUM_CSS) as demo:
+        threads_state = gr.State({initial_thread_id: {"title": "New Chat", "history": []}})
+        active_thread_id = gr.State(initial_thread_id)
+        vector_store_state = gr.State(None)
+        mongo_handler_state = gr.State(None)
+        
+        with gr.Row(elem_classes="header-tray"):
+            gr.Markdown("# 🌌 Gemma 3 Sage <small>v6.5 SP1</small>")
+
+        with gr.Row():
+            # Desktop Sidebar (Radio List)
+            with gr.Column(scale=1, variant="panel", elem_classes="sidebar-panel glass-panel desktop-only"):
+                gr.Markdown("### 🕒 Recent Chats")
+                # Using Radio as a list selector
+                thread_list = gr.Radio(choices=[(f"New Chat", initial_thread_id)], value=initial_thread_id, label=None, interactive=True, container=False)
+                new_thread_btn = gr.Button("➕ New Conversation", variant="secondary")
+                
+            with gr.Column(scale=4):
+                with gr.Tabs() as tabs:
+                    with gr.Tab("💬 Live Conversation", id=0, elem_classes="glass-panel"):
+                        
+                        # Mobile Menu (Accordion + Dropdown)
+                        with gr.Accordion("🕒 Conversations (Mobile)", open=False, visible=True, elem_classes="mobile-only") as mobile_sessions:
+                            m_thread_list = gr.Dropdown(choices=[("New Chat", initial_thread_id)], value=initial_thread_id, label="Select Session")
+                            m_new_btn = gr.Button("➕ New Conversation", variant="secondary")
+                        
+                        chatbot = gr.Chatbot(label="Sage", type="messages", height=600, show_label=False, autoscroll=False)
+                        with gr.Row():
+                            msg_textbox = gr.Textbox(placeholder="Whisper your heart or type...", label=None, scale=8, container=False)
+                            submit_btn = gr.Button("Send", variant="primary", scale=1)
+                        # Moved Short Answer checkbox here for visibility
+                        with gr.Row():
+                            short_ans_cb = gr.Checkbox(label="Short Answers", value=False)
+                        with gr.Row():
+                            stream_state = gr.State({"buffer": [], "silence_counter": 0, "is_speaking": False})
+                            audio_input = gr.Audio(label="Voice", sources="microphone", type="numpy", streaming=True)
+                            processed_audio, audio_output = gr.State(None), gr.Audio(label="Sage Voice", autoplay=True, visible=False)
+                        with gr.Row(elem_classes="glass-panel"):
+                            export_btn = gr.Button("📤 Export Session", variant="secondary", size="sm")
+                            import_file = gr.File(label="Import", file_count="single", height=60)
+                            export_file = gr.File(label="Download", interactive=False, visible=False)
+
+                    with gr.Tab("📚 Sacred Knowledge", id=1, elem_classes="glass-panel"):
+                        file_uploader = gr.File(label="Upload", file_count="multiple", type="filepath")
+                        index_button = gr.Button("🔄 Sync Index", variant="primary")
+                        index_status = gr.Markdown("Bereit.")
+                        with gr.Accordion("⚙️ MongoDB Settings", open=False):
+                            mongo_uri = gr.Textbox(label="URI", value="mongodb://localhost:27017/")
+                            mongo_db = gr.Textbox(label="DB", value="rag_db")
+                            mongo_coll = gr.Textbox(label="Coll", value="gemma_chunks")
+                            use_mongo_cb = gr.Checkbox(label="Sync to Mongo", value=True)
+                            clear_mongo_btn = gr.Button("🗑️ Clear Mongo")
+                        clear_idx_btn = gr.Button("🧹 Clear FAISS", variant="stop")
+                        
+                        clear_mongo_btn.click(lambda u, d, c: MongoDBHandler(u, d, c).connect() and MongoDBHandler(u, d, c).clear() or "Mongo geleert", [mongo_uri, mongo_db, mongo_coll], index_status)
+
+        audio_input.stream(stream_handler, [audio_input, stream_state], [stream_state, processed_audio])
+        processed_audio.change(voice_chat_wrapper, [processed_audio, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output])
+        msg_textbox.submit(chat_wrapper, [msg_textbox, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output]).then(lambda: "", None, msg_textbox)
+        submit_btn.click(chat_wrapper, [msg_textbox, chatbot, threads_state, active_thread_id, vector_store_state, mongo_handler_state, short_ans_cb], [chatbot, threads_state, thread_list, m_thread_list, audio_output]).then(lambda: "", None, msg_textbox)
+        new_thread_btn.click(create_new_thread_callback, [threads_state], [threads_state, active_thread_id, thread_list, chatbot])
+        m_new_btn.click(create_new_thread_callback, [threads_state], [threads_state, active_thread_id, m_thread_list, chatbot])
+        thread_list.change(switch_thread, [thread_list, threads_state], [chatbot, active_thread_id, thread_list, m_thread_list])
+        m_thread_list.change(switch_thread, [m_thread_list, threads_state], [chatbot, active_thread_id, thread_list, m_thread_list])
+        index_button.click(index_files, [file_uploader, mongo_uri, mongo_db, mongo_coll, use_mongo_cb, vector_store_state, mongo_handler_state], [index_status, vector_store_state, mongo_handler_state], show_progress="full")
+        clear_idx_btn.click(clear_index, outputs=[index_status, vector_store_state, mongo_handler_state], show_progress="full")
+        import_file.change(session_import_handler, import_file, [chatbot, threads_state, active_thread_id, thread_list, m_thread_list], show_progress="full")
+        export_btn.click(session_export_handler, [chatbot, threads_state, active_thread_id], export_file, show_progress="full").then(lambda: gr.update(visible=True), None, export_file)
+    return demo
+
+

tests/rag_reproduce_test.py

@@ -7,7 +7,7 @@ import time
 project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 sys.path.append(project_root)
 
-from app import (
+from app_module import (
     index_files, 
     answer_with_rag, 
     get_embedding_function, 

tests/suite_test.py

@@ -7,7 +7,7 @@ project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 sys.path.append(project_root)
 
 # Import components to test
-from app import extract_text_from_file, get_text_splitter, Document
+from app_module import extract_text_from_file, get_text_splitter, Document
 from mongochain import MongoDBHandler
 
 class TestRAGFunctions(unittest.TestCase):

tests/test_accumulation_bug.py

@@ -1,15 +1,15 @@
 import unittest
 from unittest.mock import MagicMock, patch
-from app import chat_agent_stream
+from app_module import chat_agent_stream
 import re
 import json
 
 class TestAccumulationBug(unittest.TestCase):
     
-    @patch('app.get_llm')
-    @patch('app.TextIteratorStreamer')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
+    @patch('app_module.get_llm')
+    @patch('app_module.TextIteratorStreamer')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
     def test_multi_turn_accumulation(self, mock_detect, mock_rag, mock_streamer, mock_llm):
         """
         Simulates:

tests/test_agent.py

@@ -6,7 +6,7 @@ from unittest.mock import MagicMock, patch
 # Ensure project root is in path
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
-from app import build_agent_prompt, detect_language
+from app_module import build_agent_prompt, detect_language
 
 def test_build_agent_prompt_structure():
     """Verifies that the agent prompt contains the Proactivity Patch rules."""

tests/test_agent_tools.py

@@ -2,7 +2,7 @@ import unittest
 import json
 import re
 from unittest.mock import MagicMock, patch
-from app import build_agent_prompt, chat_agent_stream
+from app_module import build_agent_prompt, chat_agent_stream
 
 # Import backend tool function to verify it exists
 try:
@@ -30,7 +30,7 @@ class TestAgentTools(unittest.TestCase):
         self.assertEqual(data["name"], "oracle_consultation")
         self.assertEqual(data["arguments"]["topic"], "life")
 
-    @patch('app.get_oracle_data')
+    @patch('app_module.get_oracle_data')
     def test_oracle_dispatch_mock(self, mock_oracle):
         """Verify valid tool calls trigger the backend function."""
         mock_oracle.return_value = {"mock": "result"}

tests/test_final_suite.py

@@ -1,14 +1,14 @@
 import unittest
 from unittest.mock import MagicMock, patch
-from app import chat_wrapper, chat_agent_stream, get_oracle_data
+from app_module import chat_wrapper, chat_agent_stream, get_oracle_data
 import json
 
 class TestFinalSuite(unittest.TestCase):
 
-    @patch('app.get_llm')
-    @patch('app.TextIteratorStreamer')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
+    @patch('app_module.get_llm')
+    @patch('app_module.TextIteratorStreamer')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
     def test_multi_message_bubbles(self, mock_detect, mock_rag, mock_streamer, mock_llm):
         """
         Verify that multi-turn agent responses result in multiple distinct message bubbles in history.
@@ -51,11 +51,11 @@ class TestFinalSuite(unittest.TestCase):
             self.assertEqual(final_history[2]["content"], "Final Answer")
             
     
-    @patch('app.get_llm')
-    @patch('app.TextIteratorStreamer')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
-    @patch('app.get_oracle_data')
+    @patch('app_module.get_llm')
+    @patch('app_module.TextIteratorStreamer')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
+    @patch('app_module.get_oracle_data')
     def test_oracle_filtering(self, mock_oracle, mock_detect, mock_rag, mock_streamer, mock_llm):
         """
         Verify that ONLY wisdom_nodes are passed to the tool result string, masking 'els_revelation' etc.
@@ -120,10 +120,10 @@ class TestFinalSuite(unittest.TestCase):
         
         self.assertTrue(found_filtered, "Tool Result did not contain filtered data (or contained forbidden keys).")
 
-    @patch('app.get_llm')
-    @patch('app.TextIteratorStreamer')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
+    @patch('app_module.get_llm')
+    @patch('app_module.TextIteratorStreamer')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
     def test_prompt_fluidity_instruction(self, mock_detect, mock_rag, mock_streamer, mock_llm):
         """
         Verify that the injected prompt contains the 'connect smoothly' instruction.

tests/test_full_coverage.py

@@ -17,7 +17,7 @@ with patch('transformers.AutoProcessor.from_pretrained'), \
      patch('langchain_huggingface.HuggingFaceEmbeddings'), \
      patch('langchain_community.vectorstores.FAISS'):
     import app
-    from app import (
+    from app_module import (
         detect_language, build_agent_prompt, get_device, get_embedding_function, get_llm,
         extract_text_from_file, get_text_splitter, index_files, clear_index,
         retrieve_relevant_chunks, build_rag_prompt, chat_agent_stream,
@@ -29,7 +29,7 @@ class TestSageFullCoverage(unittest.TestCase):
 
     # --- Group 1: Utils & ML Logic ---
 
-    @patch('app.get_llm')
+    @patch('app_module.get_llm')
     def test_detect_language(self, mock_get_llm):
         mock_model = MagicMock()
         mock_processor = MagicMock()
@@ -55,7 +55,7 @@ class TestSageFullCoverage(unittest.TestCase):
         device = get_device()
         self.assertIsInstance(device, torch.device)
 
-    @patch('app.HuggingFaceEmbeddings')
+    @patch('app_module.HuggingFaceEmbeddings')
     def test_get_embedding_function(self, mock_emb):
         # Reset global
         app.EMBEDDING_FUNCTION = None
@@ -63,8 +63,8 @@ class TestSageFullCoverage(unittest.TestCase):
         self.assertIsNotNone(func)
         mock_emb.assert_called_once()
 
-    @patch('app.AutoProcessor.from_pretrained')
-    @patch('app.Gemma3ForConditionalGeneration.from_pretrained')
+    @patch('app_module.AutoProcessor.from_pretrained')
+    @patch('app_module.Gemma3ForConditionalGeneration.from_pretrained')
     def test_get_llm(self, mock_model, mock_proc):
         app.LLM_MODEL = None
         app.LLM_PROCESSOR = None
@@ -72,7 +72,7 @@ class TestSageFullCoverage(unittest.TestCase):
         self.assertIsNotNone(m)
         self.assertIsNotNone(p)
 
-    @patch('app.PdfReader')
+    @patch('app_module.PdfReader')
     def test_extract_text_from_file_pdf(self, mock_pdf):
         mock_reader = mock_pdf.return_value
         mock_reader.pages = [MagicMock(extract_text=lambda: "Page 1 content")]
@@ -90,10 +90,10 @@ class TestSageFullCoverage(unittest.TestCase):
 
     # --- Group 2: RAG & Indexing ---
 
-    @patch('app.extract_text_from_file')
-    @patch('app.get_text_splitter')
-    @patch('app.FAISS')
-    @patch('app.MongoDBHandler')
+    @patch('app_module.extract_text_from_file')
+    @patch('app_module.get_text_splitter')
+    @patch('app_module.FAISS')
+    @patch('app_module.MongoDBHandler')
     def test_index_files(self, mock_mongo, mock_faiss, mock_splitter, mock_extract):
         mock_extract.return_value = "Long text content"
         mock_splitter.return_value.split_text.return_value = ["chunk1", "chunk2"]
@@ -136,7 +136,7 @@ class TestSageFullCoverage(unittest.TestCase):
         self.assertIsNotNone(w)
         mock_load.assert_called_once()
 
-    @patch('app.get_whisper')
+    @patch('app_module.get_whisper')
     def test_transcribe_audio(self, mock_get_w):
         mock_w = mock_get_w.return_value
         mock_w.transcribe.return_value = {"text": "Transcribed text"}
@@ -166,9 +166,9 @@ class TestSageFullCoverage(unittest.TestCase):
 
     # --- Group 4: Actions & Orchestration ---
 
-    @patch('app.get_llm')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
+    @patch('app_module.get_llm')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
     def test_chat_agent_stream(self, mock_detect, mock_rag, mock_get_llm):
         mock_model = MagicMock()
         mock_processor = MagicMock()
@@ -180,10 +180,10 @@ class TestSageFullCoverage(unittest.TestCase):
         gen = chat_agent_stream("msg", [], None, None)
         self.assertTrue(hasattr(gen, '__next__'))
 
-    @patch('app.get_llm')
-    @patch('app.TextIteratorStreamer')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
+    @patch('app_module.get_llm')
+    @patch('app_module.TextIteratorStreamer')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
     def test_purification(self, mock_detect, mock_rag, mock_streamer, mock_get_llm):
         mock_model = MagicMock()
         mock_processor = MagicMock()
@@ -203,10 +203,10 @@ class TestSageFullCoverage(unittest.TestCase):
         self.assertIn("Hello", responses[-1])
         self.assertIn("World", responses[-1])
 
-    @patch('app.chat_wrapper')
-    @patch('app.transcribe_audio')
-    @patch('app.generate_speech')
-    @patch('app.detect_language')
+    @patch('app_module.chat_wrapper')
+    @patch('app_module.transcribe_audio')
+    @patch('app_module.generate_speech')
+    @patch('app_module.detect_language')
     def test_voice_chat_wrapper(self, mock_detect, mock_tts, mock_stt, mock_chat):
         mock_detect.return_value = "English"
         mock_stt.return_value = "Hello"
@@ -227,7 +227,7 @@ class TestSageFullCoverage(unittest.TestCase):
              res = r
         self.assertEqual(res[4], "out.mp3")
 
-    @patch('app.chat_agent_stream')
+    @patch('app_module.chat_agent_stream')
     def test_chat_wrapper(self, mock_agent):
         mock_agent.return_value = iter(["Part 1", "Part 2"])
         history = []

tests/test_name_extraction.py

@@ -18,7 +18,7 @@ sys.modules["accelerate"] = MagicMock()
 # Add parent directory to path to import app
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from app import build_agent_prompt, chat_agent_stream
+from app_module import build_agent_prompt, chat_agent_stream
 
 class TestNameExtraction(unittest.TestCase):
     def setUp(self):
@@ -34,11 +34,11 @@ class TestNameExtraction(unittest.TestCase):
         expected_part = '"name": "str (Optional. Use ONLY if the user explicitly stated their name, otherwise omit)"'
         self.assertIn(expected_part, prompt)
 
-    @patch('app.get_llm')
-    @patch('app.TextIteratorStreamer')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
-    @patch('app.get_oracle_data')
+    @patch('app_module.get_llm')
+    @patch('app_module.TextIteratorStreamer')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
+    @patch('app_module.get_oracle_data')
     def test_oracle_call_with_name(self, mock_get_oracle_data, mock_detect, mock_retrieve, mock_streamer_cls, mock_get_llm):
         """Test that the agent calls get_oracle_data with the extracted name."""
         
@@ -80,11 +80,11 @@ class TestNameExtraction(unittest.TestCase):
         self.assertEqual(call_args.kwargs.get('name'), "Julian")
         self.assertEqual(call_args.kwargs.get('topic'), "Future")
 
-    @patch('app.get_llm')
-    @patch('app.TextIteratorStreamer')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
-    @patch('app.get_oracle_data')
+    @patch('app_module.get_llm')
+    @patch('app_module.TextIteratorStreamer')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
+    @patch('app_module.get_oracle_data')
     def test_oracle_call_without_name_defaults_to_seeker(self, mock_get_oracle_data, mock_detect, mock_retrieve, mock_streamer_cls, mock_get_llm):
         """Test that the agent defaults to 'Seeker' if no name is provided."""
         

tests/test_regression_v6_5.py

@@ -1,7 +1,7 @@
 import unittest
 from unittest.mock import MagicMock, patch
 import gradio as gr
-from app import chat_wrapper, chat_agent_stream, switch_thread
+from app_module import chat_wrapper, chat_agent_stream, switch_thread
 
 class TestSageRegressionV6_5(unittest.TestCase):
     
@@ -22,8 +22,8 @@ class TestSageRegressionV6_5(unittest.TestCase):
         h, tid, ud, um = switch_thread([], t_state)
         self.assertEqual(h, [])
 
-    @patch('app.detect_language')
-    @patch('app.get_oracle_data')
+    @patch('app_module.detect_language')
+    @patch('app_module.get_oracle_data')
     def test_agent_role_alternation(self, mock_oracle, mock_detect):
         """Verifies Assistant -> Tool -> Execution -> Assistant sequence."""
         mock_detect.return_value = "English"
@@ -56,7 +56,7 @@ class TestSageRegressionV6_5(unittest.TestCase):
             # Verify final response
             self.assertIn("Peace", responses[-1])
 
-    @patch('app.detect_language')
+    @patch('app_module.detect_language')
     def test_chat_purification_logic(self, mock_detect):
         """Verifies that <tool_call> tags are stripped from streaming output."""
         mock_detect.return_value = "English"

tests/test_ui_logic.py

@@ -1,7 +1,7 @@
 import unittest
 from unittest.mock import MagicMock, patch
 import gradio as gr
-from app import switch_thread, create_new_thread_callback, build_agent_prompt, chat_agent_stream
+from app_module import switch_thread, create_new_thread_callback, build_agent_prompt, chat_agent_stream
 
 class TestUILogic(unittest.TestCase):
 
@@ -44,10 +44,10 @@ class TestUILogic(unittest.TestCase):
         prompt_short = build_agent_prompt("Hi", [], [], short_answers=True)
         self.assertIn("Be concise", prompt_short)
 
-    @patch('app.get_llm')
-    @patch('app.TextIteratorStreamer')
-    @patch('app.retrieve_relevant_chunks')
-    @patch('app.detect_language')
+    @patch('app_module.get_llm')
+    @patch('app_module.TextIteratorStreamer')
+    @patch('app_module.retrieve_relevant_chunks')
+    @patch('app_module.detect_language')
     def test_accumulative_chat_streaming(self, mock_detect, mock_rag, mock_streamer, mock_llm):
         """Verify that streaming yields growing strings (Accumulation) instead of chunks."""
         mock_detect.return_value = "English"