Fixed UI

app.py

@@ -1,6 +1,5 @@
 import base64
 import html
-import io
 import json
 import math
 import os
@@ -35,11 +34,6 @@ try:
 except Exception:  # pragma: no cover
     pdfium = None  # type: ignore
 
-try:
-    import soundfile as sf  # type: ignore
-except Exception:  # pragma: no cover
-    sf = None  # type: ignore
-
 
 APP_DIR = Path(__file__).parent.resolve()
 TMP_DIR = APP_DIR / "tmp_outputs"
@@ -68,41 +62,11 @@ CHAT_MODEL_ID = os.getenv("QWEN_VL_MODEL_ID", "qwen-vl-max")
 TTS_MODEL_ID = os.getenv("QWEN_TTS_MODEL_ID", "qwen-tts")
 TTS_SPEAKER = os.getenv("QWEN_TTS_SPEAKER", "longxiaochun_v2")
 TTS_FORMAT = os.getenv("QWEN_TTS_FORMAT", "wav")
-TTS_BACKEND = (os.getenv("TTS_BACKEND") or "gpt_sovits_local").strip().lower()
 API_TIMEOUT_SEC = int(os.getenv("API_TIMEOUT_SEC", "180"))
 QWEN_VL_MAX_PAGES = int(os.getenv("QWEN_VL_MAX_PAGES", "4"))
 QWEN_VL_RENDER_SCALE = float(os.getenv("QWEN_VL_RENDER_SCALE", "1.5"))
 QWEN_VL_MAX_NEW_TOKENS = int(os.getenv("QWEN_VL_MAX_NEW_TOKENS", "800"))
 QWEN_VL_MCQ_MAX_NEW_TOKENS = int(os.getenv("QWEN_VL_MCQ_MAX_NEW_TOKENS", "1800"))
-GPT_SOVITS_BASE_URL = (os.getenv("GPT_SOVITS_BASE_URL") or "http://127.0.0.1:9880").rstrip("/")
-GPT_SOVITS_TTS_ENDPOINT = os.getenv("GPT_SOVITS_TTS_ENDPOINT", "/tts")
-GPT_SOVITS_SET_SOVITS_ENDPOINT = os.getenv("GPT_SOVITS_SET_SOVITS_ENDPOINT", "/set_sovits_weights")
-GPT_SOVITS_SET_GPT_ENDPOINT = os.getenv("GPT_SOVITS_SET_GPT_ENDPOINT", "/set_gpt_weights")
-GPT_SOVITS_DEFAULT_SOVITS_PATH = os.getenv(
-    "GPT_SOVITS_DEFAULT_SOVITS_PATH",
-    str((APP_DIR / "audio" / "s2Gv2ProPlus.pth").resolve()),
-)
-GPT_SOVITS_DEFAULT_GPT_PATH = os.getenv("GPT_SOVITS_DEFAULT_GPT_PATH", "")
-GPT_SOVITS_DEFAULT_REF_AUDIO_PATH = os.getenv("GPT_SOVITS_REF_AUDIO_PATH", "")
-GPT_SOVITS_DEFAULT_PROMPT_TEXT = os.getenv("GPT_SOVITS_PROMPT_TEXT", "")
-GPT_SOVITS_DEFAULT_PROMPT_LANG = os.getenv("GPT_SOVITS_PROMPT_LANG", "zh")
-GPT_SOVITS_DEFAULT_TEXT_LANG = os.getenv("GPT_SOVITS_TEXT_LANG", "zh")
-GPT_SOVITS_MEDIA_TYPE = os.getenv("GPT_SOVITS_MEDIA_TYPE", "wav")
-GPT_SOVITS_STREAMING_MODE = os.getenv("GPT_SOVITS_STREAMING_MODE", "0").strip() == "1"
-GPT_SOVITS_ROLE_MODEL_MAP_RAW = os.getenv("GPT_SOVITS_ROLE_MODEL_MAP", "")
-
-
-def _parse_json_dict_env(raw: str) -> Dict[str, Any]:
-    if not raw.strip():
-        return {}
-    try:
-        data = json.loads(raw)
-    except Exception:
-        return {}
-    return data if isinstance(data, dict) else {}
-
-
-GPT_SOVITS_ROLE_MODEL_MAP = _parse_json_dict_env(GPT_SOVITS_ROLE_MODEL_MAP_RAW)
 
 
 DEFAULT_LECTURE_PROMPT_TEMPLATE = """
@@ -221,14 +185,6 @@ def load_character_configs() -> Dict[str, Dict[str, Any]]:
                     d / str(meta.get("mcq_retry_prompt_file", "mcq_retry_prompt.txt")),
                     DEFAULT_MCQ_RETRY_PROMPT_TEMPLATE,
                 ),
-                # Optional local GPT-SoVITS overrides.
-                "voice_model": str(meta.get("voice_model", meta.get("display_name", cid))),
-                "gpt_sovits_sovits_path": str(meta.get("gpt_sovits_sovits_path", "")).strip(),
-                "gpt_sovits_gpt_path": str(meta.get("gpt_sovits_gpt_path", "")).strip(),
-                "gpt_sovits_ref_audio_path": str(meta.get("gpt_sovits_ref_audio_path", "")).strip(),
-                "gpt_sovits_prompt_text": str(meta.get("gpt_sovits_prompt_text", "")).strip(),
-                "gpt_sovits_prompt_lang": str(meta.get("gpt_sovits_prompt_lang", "")).strip(),
-                "gpt_sovits_text_lang": str(meta.get("gpt_sovits_text_lang", "")).strip(),
             }
             configs[cid] = config
 
@@ -245,13 +201,6 @@ def load_character_configs() -> Dict[str, Dict[str, Any]]:
             "lecture_prompt_template": DEFAULT_LECTURE_PROMPT_TEMPLATE,
             "mcq_prompt_template": DEFAULT_MCQ_PROMPT_TEMPLATE,
             "mcq_retry_prompt_template": DEFAULT_MCQ_RETRY_PROMPT_TEMPLATE,
-            "voice_model": "default",
-            "gpt_sovits_sovits_path": "",
-            "gpt_sovits_gpt_path": "",
-            "gpt_sovits_ref_audio_path": "",
-            "gpt_sovits_prompt_text": "",
-            "gpt_sovits_prompt_lang": "",
-            "gpt_sovits_text_lang": "",
         }
     return configs
 
@@ -266,45 +215,6 @@ def get_character_config(character_id: Optional[str]) -> Dict[str, Any]:
     return CHARACTER_CONFIGS[DEFAULT_CHARACTER_ID]
 
 
-def normalize_role_key(value: Optional[str]) -> str:
-    s = str(value or "").strip().lower()
-    return re.sub(r"[^a-z0-9]+", "", s)
-
-
-def build_role_aliases(character_id: Optional[str], character_cfg: Optional[Dict[str, Any]] = None) -> List[str]:
-    raws: List[str] = []
-    if character_id:
-        raws.append(character_id)
-    if character_cfg:
-        for k in ["id", "display_name", "chat_label", "voice_model"]:
-            v = character_cfg.get(k)
-            if isinstance(v, str) and v.strip():
-                raws.append(v.strip())
-    seen: set[str] = set()
-    out: List[str] = []
-    for raw in raws:
-        for candidate in [raw, normalize_role_key(raw)]:
-            if not candidate or candidate in seen:
-                continue
-            seen.add(candidate)
-            out.append(candidate)
-    return out
-
-
-def resolve_local_path_maybe(value: Optional[str]) -> str:
-    s = str(value or "").strip()
-    if not s:
-        return ""
-    p = Path(s).expanduser()
-    if not p.is_absolute():
-        p = (APP_DIR / p).resolve()
-    return str(p)
-
-
-def file_exists(path_str: Optional[str]) -> bool:
-    return bool(path_str) and Path(str(path_str)).expanduser().exists()
-
-
 @dataclass
 class MCQItem:
     question: str
@@ -551,12 +461,9 @@ class QwenPipelineEngine:
 
     def __init__(self) -> None:
         self.mock_mode = USE_MOCK_MODELS
-        self.tts_backend = TTS_BACKEND
         self.vl_loaded = False
         self.tts_loaded = False
         self._pdf_page_cache: Dict[str, List[str]] = {}
-        self._loaded_sovits_weights: Optional[str] = None
-        self._loaded_gpt_weights: Optional[str] = None
 
     def ensure_vl_loaded(self) -> None:
         if self.vl_loaded:
@@ -572,11 +479,6 @@ class QwenPipelineEngine:
     def ensure_tts_loaded(self) -> None:
         if self.tts_loaded:
             return
-        if self.tts_backend == "gpt_sovits_local":
-            if not GPT_SOVITS_BASE_URL:
-                raise RuntimeError("Missing GPT_SOVITS_BASE_URL for local GPT-SoVITS TTS.")
-            self.tts_loaded = True
-            return
         if self.mock_mode:
             self.tts_loaded = True
             return
@@ -585,196 +487,6 @@ class QwenPipelineEngine:
             raise RuntimeError("Missing API_KEY for TTS API calls.")
         self.tts_loaded = True
 
-    def _gptsovits_endpoint_url(self, endpoint: str) -> str:
-        endpoint = endpoint.strip()
-        if endpoint.startswith("http://") or endpoint.startswith("https://"):
-            return endpoint
-        if not endpoint.startswith("/"):
-            endpoint = "/" + endpoint
-        return f"{GPT_SOVITS_BASE_URL}{endpoint}"
-
-    def _find_gptsovits_role_entry(
-        self,
-        character_id: Optional[str],
-        character_cfg: Optional[Dict[str, Any]],
-    ) -> Dict[str, Any]:
-        aliases = build_role_aliases(character_id, character_cfg)
-
-        for key in aliases:
-            entry = GPT_SOVITS_ROLE_MODEL_MAP.get(key)
-            if entry is None:
-                continue
-            if isinstance(entry, str):
-                return {"sovits_path": entry}
-            if isinstance(entry, dict):
-                return dict(entry)
-
-        norm_map: Dict[str, Any] = {}
-        for k, v in GPT_SOVITS_ROLE_MODEL_MAP.items():
-            nk = normalize_role_key(k)
-            if nk and nk not in norm_map:
-                norm_map[nk] = v
-        for key in aliases:
-            entry = norm_map.get(normalize_role_key(key))
-            if entry is None:
-                continue
-            if isinstance(entry, str):
-                return {"sovits_path": entry}
-            if isinstance(entry, dict):
-                return dict(entry)
-
-        return {}
-
-    def _guess_sovits_path_from_audio_dir(self, aliases: List[str]) -> str:
-        audio_dir = APP_DIR / "audio"
-        if not audio_dir.exists():
-            return ""
-        pth_files = [p for p in audio_dir.iterdir() if p.is_file() and p.suffix.lower() == ".pth"]
-        if not pth_files:
-            return ""
-
-        alias_set = {normalize_role_key(a) for a in aliases if a}
-        for p in pth_files:
-            stem_norm = normalize_role_key(p.stem)
-            if stem_norm and stem_norm in alias_set:
-                return str(p.resolve())
-        for p in pth_files:
-            name_norm = normalize_role_key(p.name)
-            if name_norm and any(a and a in name_norm for a in alias_set):
-                return str(p.resolve())
-        return ""
-
-    def _guess_role_ref_audio_path(self, aliases: List[str]) -> str:
-        audio_dir = APP_DIR / "audio"
-        if not audio_dir.exists():
-            return ""
-        candidates = [p for p in audio_dir.iterdir() if p.is_file() and p.suffix.lower() in {".wav", ".mp3", ".flac", ".m4a"}]
-        alias_set = {normalize_role_key(a) for a in aliases if a}
-        for p in candidates:
-            stem_norm = normalize_role_key(p.stem)
-            if stem_norm and stem_norm in alias_set:
-                return str(p.resolve())
-        return ""
-
-    def _guess_role_prompt_text(self, aliases: List[str]) -> str:
-        audio_dir = APP_DIR / "audio"
-        if not audio_dir.exists():
-            return ""
-        alias_set = {normalize_role_key(a) for a in aliases if a}
-        for p in audio_dir.iterdir():
-            if not p.is_file() or p.suffix.lower() != ".txt":
-                continue
-            stem_norm = normalize_role_key(p.stem)
-            if stem_norm and stem_norm in alias_set:
-                try:
-                    return p.read_text(encoding="utf-8").strip()
-                except Exception:
-                    return ""
-        return ""
-
-    def _gptsovits_role_tts_config(
-        self,
-        character_id: Optional[str],
-        character_cfg: Optional[Dict[str, Any]],
-    ) -> Dict[str, str]:
-        aliases = build_role_aliases(character_id, character_cfg)
-        entry = self._find_gptsovits_role_entry(character_id, character_cfg)
-
-        cfg = character_cfg or {}
-        sovits_path = resolve_local_path_maybe(
-            str(entry.get("sovits_path") or entry.get("model_path") or cfg.get("gpt_sovits_sovits_path") or "")
-        )
-        if not file_exists(sovits_path):
-            guessed = self._guess_sovits_path_from_audio_dir(aliases)
-            if guessed:
-                sovits_path = guessed
-        if not file_exists(sovits_path):
-            sovits_path = resolve_local_path_maybe(GPT_SOVITS_DEFAULT_SOVITS_PATH)
-
-        gpt_path = resolve_local_path_maybe(
-            str(entry.get("gpt_path") or cfg.get("gpt_sovits_gpt_path") or GPT_SOVITS_DEFAULT_GPT_PATH or "")
-        )
-        if gpt_path and not file_exists(gpt_path):
-            gpt_path = ""
-
-        ref_audio_path = resolve_local_path_maybe(
-            str(entry.get("ref_audio_path") or cfg.get("gpt_sovits_ref_audio_path") or GPT_SOVITS_DEFAULT_REF_AUDIO_PATH or "")
-        )
-        if ref_audio_path and not file_exists(ref_audio_path):
-            ref_audio_path = ""
-        if not ref_audio_path:
-            guessed_ref = self._guess_role_ref_audio_path(aliases)
-            if guessed_ref:
-                ref_audio_path = guessed_ref
-
-        prompt_text = str(
-            entry.get("prompt_text") or cfg.get("gpt_sovits_prompt_text") or GPT_SOVITS_DEFAULT_PROMPT_TEXT or ""
-        ).strip()
-        if not prompt_text:
-            prompt_text = self._guess_role_prompt_text(aliases)
-        prompt_lang = str(
-            entry.get("prompt_lang") or cfg.get("gpt_sovits_prompt_lang") or GPT_SOVITS_DEFAULT_PROMPT_LANG or "zh"
-        ).strip() or "zh"
-        text_lang = str(
-            entry.get("text_lang") or cfg.get("gpt_sovits_text_lang") or GPT_SOVITS_DEFAULT_TEXT_LANG or "zh"
-        ).strip() or "zh"
-
-        return {
-            "sovits_path": sovits_path,
-            "gpt_path": gpt_path,
-            "ref_audio_path": ref_audio_path,
-            "prompt_text": prompt_text,
-            "prompt_lang": prompt_lang,
-            "text_lang": text_lang,
-        }
-
-    def _gptsovits_set_weights(self, endpoint: str, weights_path: str) -> None:
-        if not weights_path:
-            return
-        url = self._gptsovits_endpoint_url(endpoint)
-        attempts = [
-            ("POST", {"weights_path": weights_path}),
-            ("POST", {"path": weights_path}),
-            ("GET", {"weights_path": weights_path}),
-            ("GET", {"path": weights_path}),
-        ]
-        last_err = ""
-        for method, payload in attempts:
-            try:
-                if method == "POST":
-                    resp = requests.post(url, json=payload, timeout=API_TIMEOUT_SEC)
-                else:
-                    resp = requests.get(url, params=payload, timeout=API_TIMEOUT_SEC)
-                if resp.status_code < 400:
-                    return
-                last_err = f"{resp.status_code}: {resp.text[:400]}"
-            except requests.RequestException as exc:
-                last_err = f"{type(exc).__name__}: {exc}"
-        raise RuntimeError(f"Failed to load GPT-SoVITS weights via {url}. Last error: {last_err}")
-
-    def _gptsovits_ensure_role_model(
-        self,
-        character_id: Optional[str],
-        character_cfg: Optional[Dict[str, Any]],
-    ) -> Dict[str, str]:
-        cfg = self._gptsovits_role_tts_config(character_id, character_cfg)
-        sovits_path = cfg.get("sovits_path", "")
-        if not sovits_path:
-            raise RuntimeError(
-                "No SoVITS weight found. Put role-specific .pth in ./audio/ or set GPT_SOVITS_DEFAULT_SOVITS_PATH."
-            )
-        if not file_exists(sovits_path):
-            raise RuntimeError(f"SoVITS weight file not found: {sovits_path}")
-        if self._loaded_sovits_weights != sovits_path:
-            self._gptsovits_set_weights(GPT_SOVITS_SET_SOVITS_ENDPOINT, sovits_path)
-            self._loaded_sovits_weights = sovits_path
-
-        gpt_path = cfg.get("gpt_path", "")
-        if gpt_path and self._loaded_gpt_weights != gpt_path:
-            self._gptsovits_set_weights(GPT_SOVITS_SET_GPT_ENDPOINT, gpt_path)
-            self._loaded_gpt_weights = gpt_path
-        return cfg
-
     def _mock_generate_lecture(self, pdf_excerpt: str) -> str:
         excerpt = re.sub(r"\s+", " ", pdf_excerpt).strip()
         excerpt = excerpt[:1000]
@@ -958,132 +670,6 @@ class QwenPipelineEngine:
             chunk_paths.append(self._real_tts_single(chunk, chunk_path))
         return concat_wav_files(chunk_paths, out_path)
 
-    def _maybe_transcode_to_wav(self, audio_bytes: bytes, out_path: str) -> str:
-        if not audio_bytes:
-            raise RuntimeError("Empty audio payload from GPT-SoVITS.")
-        if audio_bytes[:4] == b"RIFF":
-            return _save_binary_audio(audio_bytes, out_path)
-        if sf is None:
-            return _save_binary_audio(audio_bytes, out_path)
-        try:
-            data, sr = sf.read(io.BytesIO(audio_bytes))
-            sf.write(out_path, data, sr, format="WAV")
-            return out_path
-        except Exception:
-            return _save_binary_audio(audio_bytes, out_path)
-
-    def _extract_audio_bytes_from_json(self, data: Dict[str, Any]) -> bytes:
-        candidates = [
-            data.get("audio"),
-            data.get("audio_base64"),
-            data.get("audioData"),
-            (data.get("data") or {}).get("audio") if isinstance(data.get("data"), dict) else None,
-            (data.get("output") or {}).get("audio") if isinstance(data.get("output"), dict) else None,
-        ]
-        for item in candidates:
-            if isinstance(item, str) and item.strip():
-                s = item.strip()
-                if s.startswith("data:"):
-                    _, _, s = s.partition(",")
-                try:
-                    return base64.b64decode(s)
-                except Exception:
-                    continue
-        url_candidates = [
-            data.get("audio_url"),
-            data.get("url"),
-            (data.get("output") or {}).get("audio_url") if isinstance(data.get("output"), dict) else None,
-        ]
-        for u in url_candidates:
-            if isinstance(u, str) and u.strip():
-                resp = requests.get(u.strip(), timeout=API_TIMEOUT_SEC)
-                if resp.status_code >= 400:
-                    raise RuntimeError(f"Failed downloading GPT-SoVITS audio URL {resp.status_code}: {resp.text[:300]}")
-                return resp.content
-        raise RuntimeError(f"GPT-SoVITS JSON response did not contain audio payload: {str(data)[:500]}")
-
-    def _gptsovits_tts_single(
-        self,
-        text: str,
-        out_path: str,
-        role_cfg: Dict[str, str],
-    ) -> str:
-        if not text.strip():
-            return write_tone_wav("empty", out_path)
-        payload: Dict[str, Any] = {
-            "text": text,
-            "text_lang": role_cfg.get("text_lang") or "zh",
-            "media_type": GPT_SOVITS_MEDIA_TYPE,
-            "streaming_mode": GPT_SOVITS_STREAMING_MODE,
-        }
-        ref_audio_path = role_cfg.get("ref_audio_path", "").strip()
-        prompt_text = role_cfg.get("prompt_text", "").strip()
-        prompt_lang = role_cfg.get("prompt_lang", "").strip() or "zh"
-        if ref_audio_path:
-            payload["ref_audio_path"] = ref_audio_path
-        if prompt_text:
-            payload["prompt_text"] = prompt_text
-            payload["prompt_lang"] = prompt_lang
-
-        url = self._gptsovits_endpoint_url(GPT_SOVITS_TTS_ENDPOINT)
-        last_err = ""
-        responses: List[requests.Response] = []
-        try:
-            responses.append(requests.post(url, json=payload, timeout=API_TIMEOUT_SEC))
-        except requests.RequestException as exc:
-            last_err = f"POST {type(exc).__name__}: {exc}"
-        if not responses or responses[-1].status_code in {404, 405, 422}:
-            try:
-                responses.append(requests.get(url, params=payload, timeout=API_TIMEOUT_SEC))
-            except requests.RequestException as exc:
-                last_err = f"{last_err}; GET {type(exc).__name__}: {exc}".strip("; ")
-
-        for resp in responses:
-            if resp.status_code >= 400:
-                last_err = f"{resp.status_code}: {resp.text[:500]}"
-                continue
-            content_type = (resp.headers.get("content-type") or "").lower()
-            if "application/json" in content_type:
-                data = resp.json()
-                audio_bytes = self._extract_audio_bytes_from_json(data)
-                return self._maybe_transcode_to_wav(audio_bytes, out_path)
-            return self._maybe_transcode_to_wav(resp.content, out_path)
-
-        missing_bits = []
-        if not ref_audio_path:
-            missing_bits.append("GPT_SOVITS_REF_AUDIO_PATH/ref_audio_path")
-        if not prompt_text:
-            missing_bits.append("GPT_SOVITS_PROMPT_TEXT/prompt_text")
-        hint = ""
-        if missing_bits:
-            hint = f" (check {', '.join(missing_bits)} for your GPT-SoVITS API setup)"
-        raise RuntimeError(f"GPT-SoVITS /tts request failed: {last_err}{hint}")
-
-    def _gptsovits_tts(
-        self,
-        text: str,
-        out_path: str,
-        *,
-        character_id: Optional[str] = None,
-        character_cfg: Optional[Dict[str, Any]] = None,
-    ) -> str:
-        role_cfg = self._gptsovits_ensure_role_model(character_id, character_cfg)
-        # For non-WAV outputs, avoid chunking because concatenation is WAV-only.
-        if GPT_SOVITS_MEDIA_TYPE.lower() != "wav":
-            return self._gptsovits_tts_single(text, out_path, role_cfg)
-
-        chunks = split_text_for_tts(text, max_len=220)
-        if not chunks:
-            return write_tone_wav("empty", out_path)
-        if len(chunks) == 1:
-            return self._gptsovits_tts_single(chunks[0], out_path, role_cfg)
-
-        chunk_paths: List[str] = []
-        for idx, chunk in enumerate(chunks, start=1):
-            chunk_out = str(TMP_DIR / f"gptsovits_chunk_{idx}_{uuid.uuid4().hex}.wav")
-            chunk_paths.append(self._gptsovits_tts_single(chunk, chunk_out, role_cfg))
-        return concat_wav_files(chunk_paths, out_path)
-
     @spaces.GPU
     def build_lesson_and_quiz(self, pdf_path: str, character_cfg: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         self.ensure_vl_loaded()
@@ -1198,18 +784,9 @@ class QwenPipelineEngine:
         return rebalance_mcq_answers([asdict(q) for q in mcqs])
 
     @spaces.GPU
-    def synthesize_tts(
-        self,
-        text: str,
-        name_prefix: str = "audio",
-        *,
-        character_id: Optional[str] = None,
-        character_cfg: Optional[Dict[str, Any]] = None,
-    ) -> str:
+    def synthesize_tts(self, text: str, name_prefix: str = "audio") -> str:
         self.ensure_tts_loaded()
         out_path = str(TMP_DIR / f"{name_prefix}_{uuid.uuid4().hex}.wav")
-        if self.tts_backend == "gpt_sovits_local":
-            return self._gptsovits_tts(text, out_path, character_id=character_id, character_cfg=character_cfg)
         if self.mock_mode:
             return write_tone_wav(text, out_path)
         return self._real_tts(text, out_path)
@@ -2000,15 +1577,8 @@ def play_lecture_audio(state: Dict[str, Any]):
         state["status"] = "No lecture text available."
         return state, state["status"], state.get("lecture_audio_path"), "Generate lecture first."
     try:
-        character_id = str(state.get("character_id") or DEFAULT_CHARACTER_ID)
-        character_cfg = get_character_config(character_id)
         state["status"] = "Generating lecture audio..."
-        state["lecture_audio_path"] = engine.synthesize_tts(
-            state["lecture_text"],
-            name_prefix="lecture",
-            character_id=character_id,
-            character_cfg=character_cfg,
-        )
+        state["lecture_audio_path"] = engine.synthesize_tts(state["lecture_text"], name_prefix="lecture")
         state["status"] = "Lecture audio ready."
         return state, state["status"], state["lecture_audio_path"], "Lecture audio generated."
     except Exception as exc:
@@ -2022,15 +1592,8 @@ def play_explanation_audio(state: Dict[str, Any]):
         state["status"] = "No explanation available for TTS."
         return state, state["status"], state.get("explanation_audio_path"), "Answer a question incorrectly first."
     try:
-        character_id = str(state.get("exam_character_id") or state.get("character_id") or DEFAULT_CHARACTER_ID)
-        character_cfg = get_character_config(character_id)
         state["status"] = "Generating explanation audio..."
-        state["explanation_audio_path"] = engine.synthesize_tts(
-            text,
-            name_prefix="explanation",
-            character_id=character_id,
-            character_cfg=character_cfg,
-        )
+        state["explanation_audio_path"] = engine.synthesize_tts(text, name_prefix="explanation")
         state["status"] = "Explanation audio ready."
         return state, state["status"], state["explanation_audio_path"], "Explanation audio generated."
     except Exception as exc:
@@ -2045,14 +1608,16 @@ def build_css() -> str:
 @import url('https://fonts.googleapis.com/css2?family=Instrument+Serif:ital@0;1&family=Inter:wght@400;500;600;700&display=swap');
 
 html, body {{
+  height: 100%;
   min-height: 100%;
-  height: auto;
 }}
 body {{
   background-color: #ffffff !important;
+  color: #0f172a !important;
   font-family: "Inter", sans-serif !important;
 }}
 .app, #root, .gradio-container, .gradio-container > .main {{
+  min-height: 100%;
   background: transparent !important;
 }}
 .gradio-container {{
@@ -2087,8 +1652,8 @@ body {{
   color: #eef1f6 !important;
 }}
 #page-shell {{
-  min-height: 100vh;
-  padding: 2rem 1.2rem 2rem 1.2rem;
+  min-height: 100%;
+  padding: 2rem 1.2rem 9rem 1.2rem;
   max-width: 980px;
   margin: 0 auto;
 }}
@@ -2354,8 +1919,12 @@ body {{
   margin-top: 0.25rem !important;
 }}
 #bottom-composer {{
-  width: min(860px, 100%);
-  margin: 0 auto 1rem auto;
+  position: fixed;
+  left: 50%;
+  transform: translateX(-50%);
+  bottom: 18px;
+  width: min(860px, calc(100vw - 28px));
+  z-index: 40;
   background: rgba(24, 26, 34, 0.88);
   border: 1px solid rgba(255,255,255,0.08);
   border-radius: 999px;
@@ -2474,79 +2043,7 @@ body {{
   border: 1px solid rgba(59, 130, 246, 0.28);
   color: rgba(255, 255, 255, 0.95);
 }}
-#exam-picker-overlay {{
-  position: fixed;
-  inset: 0;
-  z-index: 200;
-  display: none;
-  align-items: center;
-  justify-content: center;
-  background: rgba(2, 6, 23, 0.55);
-  backdrop-filter: blur(6px);
-  padding: 16px;
-}}
-#exam-picker-overlay:not(.hide) {{
-  display: flex;
-}}
-#exam-picker-overlay.hide {{
-  display: none !important;
-  pointer-events: none !important;
-}}
-#exam-picker-modal {{
-  width: min(720px, 94vw);
-  border-radius: 16px;
-  background: rgba(14, 16, 24, 0.96);
-  border: 1px solid rgba(255, 255, 255, 0.12);
-  box-shadow: 0 18px 50px rgba(0, 0, 0, 0.45);
-  padding: 16px;
-  height: auto !important;
-  max-height: 320px;
-  overflow: hidden;
-}}
-#exam-picker-modal .block,
-#exam-picker-modal .wrap,
-#exam-picker-modal .panel {{
-  background: transparent !important;
-  border: none !important;
-  box-shadow: none !important;
-}}
-#exam-picker-title {{
-  font-weight: 700;
-  color: #f4f6fb;
-  margin-bottom: 10px;
-}}
-.exam-picker-grid {{
-  display: flex !important;
-  flex-wrap: nowrap;
-  gap: 12px;
-}}
-.exam-picker-card {{
-  flex: 1 1 0;
-  min-width: 0 !important;
-  border-radius: 14px;
-  border: 1px solid rgba(255, 255, 255, 0.14);
-  background: rgba(255, 255, 255, 0.06);
-  padding: 12px;
-  overflow: hidden;
-  transition: transform 120ms ease, border-color 120ms ease, box-shadow 120ms ease;
-}}
-.exam-picker-card:hover {{
-  transform: translateY(-2px);
-  border-color: rgba(59, 130, 246, 0.42);
-  box-shadow: 0 10px 24px rgba(0, 0, 0, 0.35);
-}}
-.exam-picker-avatar {{
-  width: 56px;
-  height: 56px;
-  border-radius: 999px;
-  object-fit: cover;
-  display: block;
-  margin: 0 auto 10px auto;
-}}
-.exam-picker-card button {{
-  width: 100%;
-}}
-@media (prefers-color-scheme: light) and (prefers-color-scheme: dark) {{
+@media (prefers-color-scheme: light) {{
   body {{
     background: linear-gradient(180deg, #f5f7fb 0%, #eef2f8 100%) !important;
   }}
@@ -2935,18 +2432,6 @@ with gr.Blocks(css=CSS) as demo:
             container=False,
         )
 
-        with gr.Row(elem_id="bottom-composer"):
-            pdf_input = gr.File(
-                label="",
-                show_label=False,
-                file_types=[".pdf"],
-                type="filepath",
-                elem_id="pdf-uploader",
-                scale=7,
-                min_width=0,
-            )
-            run_btn = gr.Button("Generate", variant="primary", elem_id="generate-btn", scale=3, min_width=120)
-
         state = gr.State(new_session_state())
 
         loading_md = gr.HTML("", elem_id="gen-loading", visible=False)
@@ -3055,6 +2540,18 @@ with gr.Blocks(css=CSS) as demo:
                 score_box = gr.Textbox(label="Score", value="Score: 0 / 0", interactive=False, visible=False)
                 feedback_box = gr.Textbox(label="Feedback / Explanation", lines=8, interactive=False, visible=False)
 
+        with gr.Row(elem_id="bottom-composer"):
+            pdf_input = gr.File(
+                label="",
+                show_label=False,
+                file_types=[".pdf"],
+                type="filepath",
+                elem_id="pdf-uploader",
+                scale=7,
+                min_width=0,
+            )
+            run_btn = gr.Button("Generate", variant="primary", elem_id="generate-btn", scale=3, min_width=120)
+
     outputs = [
         state,
         character_header_html,
@@ -3102,4 +2599,9 @@ with gr.Blocks(css=CSS) as demo:
 demo.queue()
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        css=CSS,          
+        ssr_mode=False,
+    )