Update app.py

app.py

@@ -1,5 +1,6 @@
 """
 Avatar Chatbot - HuggingFace Spaces Edition
+Avatar profile system: each avatar has ref.png, persona.txt, idlevideos/
 Chunked pipeline: LLM (once) → split sentences → TTS+FLOAT per chunk → stream to frontend
 """
 from fastapi import FastAPI, HTTPException, Request
@@ -18,33 +19,136 @@ logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
-VIDEOS_DIR = Path("/app/p2")
+# ---- Avatar system ----
+AVATARS_DIR = Path("/app/avatars")
+_current_avatar = None  # name of active avatar folder
+
 TTS_DIR = Path("/tmp/tts_output")
 LIPSYNC_DIR = Path("/tmp/lipsync_output")
 REPO_ID = os.environ.get("SPACE_ID", "ffbeqwbe/AvatarChatbot")
 FLOAT_ENABLED = os.environ.get("FLOAT_ENABLED", "true").lower() == "true"
 
-for d in [VIDEOS_DIR, TTS_DIR, LIPSYNC_DIR]:
+for d in [TTS_DIR, LIPSYNC_DIR]:
     d.mkdir(parents=True, exist_ok=True)
 
 
 def _ts():
-    """Wall-clock timestamp for logs."""
     return _time.strftime("%H:%M:%S", _time.gmtime()) + f".{int(_time.time()*1000)%1000:03d}"
 
+
+def _get_avatar_dir(name=None):
+    """Get path to an avatar's directory."""
+    if name is None:
+        name = _current_avatar
+    if name:
+        return AVATARS_DIR / name
+    return None
+
+
+def _get_idle_videos_dir():
+    """Get the current avatar's idle videos directory."""
+    d = _get_avatar_dir()
+    if d:
+        return d / "idlevideos"
+    return Path("/tmp/videos")
+
+
+def _list_idle_videos():
+    """List idle video files for the current avatar."""
+    d = _get_idle_videos_dir()
+    if not d.exists():
+        return []
+    return [
+        {"name": f.stem, "filename": f.name}
+        for f in sorted(d.iterdir())
+        if f.suffix.lower() in (".mp4", ".webm", ".mkv", ".mov") and f.stat().st_size > 1024
+    ]
+
+
 import threading
 _gpu_lock = threading.Lock()
 
-# In-memory store for chunked generation results
 _sessions = {}
-
-# Pre-generated greeting (warmup)
 GREETING_DATA = None
 
 
+def _discover_avatars():
+    """Find all avatar profiles in the avatars directory."""
+    if not AVATARS_DIR.exists():
+        logger.warning(f"[AVATARS] Directory not found: {AVATARS_DIR}")
+        return []
+    avatars = []
+    for d in sorted(AVATARS_DIR.iterdir()):
+        if d.is_dir():
+            has_ref = (d / "ref.png").exists() or (d / "ref.jpg").exists()
+            has_persona = (d / "persona.txt").exists()
+            has_videos = (d / "idlevideos").exists()
+            avatars.append({
+                "name": d.name,
+                "has_ref": has_ref,
+                "has_persona": has_persona,
+                "has_videos": has_videos,
+            })
+    return avatars
+
+
+def _switch_avatar(avatar_name: str):
+    """Switch to a different avatar profile."""
+    global _current_avatar
+    avatar_dir = AVATARS_DIR / avatar_name
+    if not avatar_dir.exists():
+        logger.error(f"[AVATARS] Avatar not found: {avatar_name}")
+        return False
+
+    _current_avatar = avatar_name
+    logger.info(f"[AVATARS] Switching to avatar: {avatar_name}")
+
+    # 1. Load persona into LLM
+    persona_path = avatar_dir / "persona.txt"
+    from llm import load_persona_from_file
+    persona_text = load_persona_from_file(str(persona_path))
+    logger.info(f"[AVATARS] Persona loaded: {persona_text[:80]}..." if persona_text else "[AVATARS] No persona.txt found")
+
+    # 2. Update FLOAT reference image
+    if FLOAT_ENABLED:
+        try:
+            from float_lipsync import get_lipsync
+            lipsync = get_lipsync()
+            if lipsync.ready:
+                ref_path = avatar_dir / "ref.png"
+                if not ref_path.exists():
+                    ref_path = avatar_dir / "ref.jpg"
+                if ref_path.exists():
+                    lipsync.update_reference_image(str(ref_path))
+                    logger.info(f"[AVATARS] Reference image updated: {ref_path}")
+                else:
+                    logger.warning(f"[AVATARS] No ref image in {avatar_dir}")
+        except Exception as e:
+            logger.error(f"[AVATARS] Failed to update ref image: {e}")
+
+    # 3. Idle videos — no action needed, _get_idle_videos_dir() uses _current_avatar dynamically
+
+    logger.info(f"[AVATARS] ✓ Switched to {avatar_name}")
+    return True
+
+
 @app.on_event("startup")
 async def startup():
-    await download_videos()
+    # Discover avatars and set default
+    avatars = _discover_avatars()
+    logger.info(f"[STARTUP] Found {len(avatars)} avatars: {[a['name'] for a in avatars]}")
+
+    if avatars:
+        # Use first avatar as default
+        default = avatars[0]["name"]
+        # Load persona for default avatar (before FLOAT init so ref image is set)
+        global _current_avatar
+        _current_avatar = default
+        persona_path = AVATARS_DIR / default / "persona.txt"
+        from llm import load_persona_from_file
+        load_persona_from_file(str(persona_path))
+        logger.info(f"[STARTUP] Default avatar: {default}")
+
     await init_tts()
     if FLOAT_ENABLED:
         await init_float()
@@ -52,12 +156,10 @@ async def startup():
 
 
 async def init_tts():
-    """Initialize local Orpheus TTS model."""
     logger.info(f"[{_ts()}] [STARTUP] Initializing TTS...")
     t0 = _time.time()
     try:
-        import groq_tts as tts_module  
-        logger.info(f"[{_ts()}] [STARTUP] TTS module imported OK")
+        import groq_tts as tts_module
         tts_module.initialize()
         logger.info(f"[{_ts()}] [STARTUP] ✓ TTS ready in {_time.time()-t0:.2f}s")
     except Exception as e:
@@ -65,31 +167,23 @@ async def init_tts():
 
 
 async def generate_greeting():
-    """Generate TTS + lipsync for a greeting to warm up FLOAT on first load."""
     global GREETING_DATA
-
-    greeting_text = "Good day! I am Charles Darwin, recreated in this curious digital form. Do feel free to ask me anything about the natural world."
-
+    greeting_text = "Hello! Feel free to ask me anything."
     logger.info(f"[{_ts()}] [GREETING] Generating warmup greeting...")
     t0 = _time.time()
 
     try:
         from groq_tts import generate_audio
-        t_tts = _time.time()
         audio_path = generate_audio(greeting_text)
-        t_tts_done = _time.time()
-        logger.info(f"[{_ts()}] [GREETING] TTS: {t_tts_done-t_tts:.2f}s")
         audio_url = None
         audio_duration = 0
 
         if audio_path and os.path.exists(audio_path):
             audio_url = f"/api/audio/{os.path.basename(audio_path)}"
-            logger.info(f"[{_ts()}] [GREETING] Audio: {os.path.getsize(audio_path)/1024:.0f}KB")
             try:
                 r = subprocess.run(["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
                                     "-of", "csv=p=0", audio_path], capture_output=True, text=True, check=True)
                 audio_duration = float(r.stdout.strip())
-                logger.info(f"[{_ts()}] [GREETING] Audio duration: {audio_duration:.1f}s")
             except Exception:
                 audio_duration = 5.0
 
@@ -98,16 +192,12 @@ async def generate_greeting():
             try:
                 from float_lipsync import get_lipsync
                 lipsync = get_lipsync()
-                if lipsync.ready:
-                    t_float = _time.time()
+                if lipsync.ready and audio_path:
                     lp = lipsync.generate(audio_path)
-                    t_float_done = _time.time()
-                    logger.info(f"[{_ts()}] [GREETING] FLOAT: {t_float_done-t_float:.2f}s")
                     if lp and os.path.exists(lp):
                         lipsync_video_url = f"/api/stream/{os.path.basename(lp)}"
-                        logger.info(f"[{_ts()}] [GREETING] Video: {os.path.getsize(lp)/1024:.0f}KB")
             except Exception as e:
-                logger.warning(f"[GREETING] FLOAT failed, greeting will be text-only: {e}")
+                logger.warning(f"[GREETING] FLOAT failed: {e}")
 
         GREETING_DATA = {
             "text": greeting_text,
@@ -126,8 +216,7 @@ async def init_float():
     import torch
     logger.info(f"[STARTUP] CUDA available: {torch.cuda.is_available()}")
     if not torch.cuda.is_available():
-        logger.warning("[STARTUP] No GPU - FLOAT disabled")
-        return
+        logger.warning("[STARTUP] No GPU - FLOAT disabled"); return
     try:
         from float_lipsync import get_lipsync
         from huggingface_hub import hf_hub_download, snapshot_download
@@ -154,25 +243,38 @@ async def init_float():
             shutil.copy2(dl, fp)
             logger.info(f"[STARTUP] float.pth: {fp.stat().st_size/1e6:.1f} MB")
 
-        assets = Path("/app/assets")
-        assets.mkdir(parents=True, exist_ok=True)
-        ref = assets / "ref.png"
-        if not ref.exists() or ref.stat().st_size < 1024:
-            for name in ["ref.png", "ref.jpg", "main2.png"]:
-                try:
-                    dl = hf_hub_download(repo_id=REPO_ID, repo_type="space",
-                                         filename=f"app/assets/{name}", local_dir="/tmp/hf_download")
-                    shutil.copy2(dl, assets / name)
-                    ref = assets / name
+        # Use current avatar's ref.png for initial FLOAT setup
+        ref_path = None
+        avatar_dir = _get_avatar_dir()
+        if avatar_dir:
+            for name in ["ref.png", "ref.jpg"]:
+                p = avatar_dir / name
+                if p.exists():
+                    ref_path = str(p)
                     break
-                except Exception:
-                    continue
-            else:
-                logger.warning("[STARTUP] No ref image found"); return
+
+        # Fallback to legacy location
+        if not ref_path:
+            assets = Path("/app/assets")
+            assets.mkdir(parents=True, exist_ok=True)
+            ref = assets / "ref.png"
+            if not ref.exists() or ref.stat().st_size < 1024:
+                for name in ["ref.png", "ref.jpg", "main2.png"]:
+                    try:
+                        dl = hf_hub_download(repo_id=REPO_ID, repo_type="space",
+                                             filename=f"app/assets/{name}", local_dir="/tmp/hf_download")
+                        shutil.copy2(dl, assets / name)
+                        ref = assets / name
+                        break
+                    except Exception:
+                        continue
+                else:
+                    logger.warning("[STARTUP] No ref image found"); return
+            ref_path = str(ref)
 
         lipsync = get_lipsync()
         lipsync.initialize({
-            "ref_path": str(ref), "ckpt_path": str(fp),
+            "ref_path": ref_path, "ckpt_path": str(fp),
             "wav2vec_model_path": str(w2v), "audio2emotion_path": str(emo),
         })
         logger.info("[STARTUP] ✓ FLOAT ready!")
@@ -180,33 +282,57 @@ async def init_float():
         logger.error(f"[STARTUP] FLOAT init failed: {e}", exc_info=True)
 
 
-async def download_videos():
-    """Idle videos are COPY'd into /app/p2 at build time — no download needed."""
-    logger.info(f"[STARTUP] Using pre-built idle videos from {VIDEOS_DIR}")
-    if VIDEOS_DIR.exists():
-        vids = [f for f in VIDEOS_DIR.iterdir() if f.suffix.lower() in (".mp4",".webm",".mkv",".mov")]
-        logger.info(f"[STARTUP] Found {len(vids)} idle video files")
-    else:
-        logger.warning(f"[STARTUP] Videos directory not found: {VIDEOS_DIR}")
+# ---- Avatar API endpoints ----
+
+@app.get("/api/avatars")
+async def list_avatars():
+    """List all available avatar profiles."""
+    avatars = _discover_avatars()
+    return JSONResponse({
+        "avatars": avatars,
+        "current": _current_avatar,
+    })
+
+
+@app.post("/api/switch-avatar")
+async def switch_avatar(request: Request):
+    """Switch to a different avatar. Resets chat history."""
+    body = await request.json()
+    avatar_name = body.get("avatar", "").strip()
+    if not avatar_name:
+        raise HTTPException(400, "No avatar specified")
+
+    success = _switch_avatar(avatar_name)
+    if not success:
+        raise HTTPException(404, f"Avatar not found: {avatar_name}")
+
+    return JSONResponse({
+        "status": "ok",
+        "avatar": avatar_name,
+        "videos": _list_idle_videos(),
+    })
 
 
 @app.get("/api/videos")
 async def list_videos():
-    if not VIDEOS_DIR.exists(): return JSONResponse({"videos": []})
-    return JSONResponse({"videos": [
-        {"name": f.stem, "filename": f.name}
-        for f in sorted(VIDEOS_DIR.iterdir())
-        if f.suffix.lower() in (".mp4",".webm",".mkv",".mov") and f.stat().st_size > 1024
-    ]})
+    vids = _list_idle_videos()
+    return JSONResponse({"videos": vids})
 
 
 @app.get("/api/stream/{filename}")
 async def stream_video(filename: str):
     path = None
-    for d in [VIDEOS_DIR, LIPSYNC_DIR, TTS_DIR]:
+    # Search in current avatar's idle videos, lipsync output, and TTS output
+    search_dirs = [_get_idle_videos_dir(), LIPSYNC_DIR, TTS_DIR]
+    for d in search_dirs:
+        if d is None:
+            continue
         c = d / filename
-        if c.exists() and c.is_file(): path = c; break
-    if not path: raise HTTPException(404, "Not found")
+        if c.exists() and c.is_file():
+            path = c
+            break
+    if not path:
+        raise HTTPException(404, "Not found")
     mime = mimetypes.guess_type(filename)[0] or "video/mp4"
     def gen():
         with open(path, "rb") as f:
@@ -228,13 +354,8 @@ async def stream_audio(filename: str):
 
 
 def split_sentences(text):
-    """Split text into chunks, merging short sentences for better voice cloning quality.
-    Each chunk should be at least ~8 words so the model has enough text context."""
     parts = re.split(r'(?<=[.!?])\s+', text)
     parts = [s.strip() for s in parts if s.strip()]
-
-    # Merge sentences into longer chunks (minimum ~25 words per chunk)
-    # Voice cloning works much better with longer text context
     MIN_WORDS = 25
     merged = []
     buffer = ""
@@ -243,28 +364,19 @@ def split_sentences(text):
             buffer += " " + p
         else:
             buffer = p
-        # Flush if buffer is long enough
         if len(buffer.split()) >= MIN_WORDS:
             merged.append(buffer)
             buffer = ""
-    # Don't leave a tiny orphan — merge it with last chunk
     if buffer:
         if merged:
             merged[-1] += " " + buffer
         else:
             merged.append(buffer)
-
     return merged if merged else [text]
 
 
 @app.post("/api/chat")
 async def chat(request: Request):
-    """
-    Step 1: LLM generates full response (fast).
-    Step 2: Split into sentences.
-    Step 3: Return text + session_id immediately.
-    Step 4: Frontend polls /api/chat/next to get chunks as they're generated.
-    """
     t0 = _time.time()
     body = await request.json()
     user_text = body.get("text", "").strip()
@@ -272,22 +384,19 @@ async def chat(request: Request):
 
     logger.info(f"[{_ts()}] [CHAT] User: {user_text}")
 
-    # 1. LLM (single call)
     t1 = _time.time()
-    from llm import generate_darwin_response
-    llm_result = generate_darwin_response(user_text)
+    from llm import generate_response
+    llm_result = generate_response(user_text)
     reply_text = llm_result['text']
     t2 = _time.time()
-    logger.info(f"[{_ts()}] [CHAT] Darwin: {reply_text}")
+    logger.info(f"[{_ts()}] [CHAT] Reply: {reply_text}")
     logger.info(f"[{_ts()}] [TIMING] LLM: {t2-t1:.2f}s")
 
-    # 2. Split into sentences
     sentences = split_sentences(reply_text)
     if not sentences:
         sentences = [reply_text]
     logger.info(f"[{_ts()}] [CHAT] Split into {len(sentences)} chunks")
 
-    # 3. Create session
     session_id = str(uuid.uuid4())[:8]
     _sessions[session_id] = {
         "sentences": sentences,
@@ -297,8 +406,6 @@ async def chat(request: Request):
         "created": _time.time(),
     }
 
-    logger.info(f"[{_ts()}] [TIMING] Chat response ready: {_time.time()-t0:.2f}s")
-
     return JSONResponse({
         "text": reply_text,
         "emotion": llm_result.get('emotion', 'neutral'),
@@ -309,17 +416,11 @@ async def chat(request: Request):
 
 @app.post("/api/chat/next")
 async def chat_next(request: Request):
-    """
-    Generate TTS + lipsync for the next sentence in the session.
-    Heavy work runs in a thread so the server stays responsive for prefetch requests.
-    """
     t_req = _time.time()
     body = await request.json()
     session_id = body.get("session_id", "")
     session = _sessions.get(session_id)
-
-    if not session:
-        raise HTTPException(404, "Session not found")
+    if not session: raise HTTPException(404, "Session not found")
 
     idx = session["next_index"]
     if idx >= session["total"]:
@@ -333,7 +434,6 @@ async def chat_next(request: Request):
 
     logger.info(f"[{_ts()}] [REQ] /api/chat/next chunk {idx+1}/{total} received")
 
-    # Run the heavy TTS + FLOAT work in a thread
     import asyncio
     result = await asyncio.to_thread(_generate_chunk, sentence, idx, total)
 
@@ -360,31 +460,25 @@ async def chat_next(request: Request):
 
 
 def _generate_chunk(sentence, idx, total):
-    """Synchronous TTS + FLOAT generation (runs in thread pool)."""
     logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] START | \"{sentence[:80]}\"")
     t0 = _time.time()
-    
     import torch
 
-    # Both TTS (Orpheus) and FLOAT use GPU — serialize with lock
     with _gpu_lock:
-        # 1. TTS (local Orpheus - GPU)
         from groq_tts import generate_audio
         t_tts_start = _time.time()
         audio_path = generate_audio(sentence)
         t_tts_end = _time.time()
-        
-        # FIX: Clear VRAM after massive LLM generation
+
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
-    
+
         audio_url = None
         audio_duration = 0
         audio_size = 0
         if audio_path and os.path.exists(audio_path):
             audio_size = os.path.getsize(audio_path)
             audio_url = f"/api/audio/{os.path.basename(audio_path)}"
-            t_probe_start = _time.time()
             try:
                 r = subprocess.run(["ffprobe","-v","quiet","-show_entries","format=duration",
                                     "-of","csv=p=0", audio_path], capture_output=True, text=True, check=True)
@@ -393,11 +487,10 @@ def _generate_chunk(sentence, idx, total):
                 audio_duration = 3.0
             t_probe_end = _time.time()
         else:
-            t_probe_start = t_probe_end = _time.time()
+            t_probe_end = _time.time()
 
-        logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] TTS: {t_tts_end-t_tts_start:.2f}s | audio: {audio_duration:.1f}s, {audio_size/1024:.0f}KB | ffprobe: {t_probe_end-t_probe_start:.3f}s")
+        logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] TTS: {t_tts_end-t_tts_start:.2f}s | audio: {audio_duration:.1f}s, {audio_size/1024:.0f}KB")
 
-        # 2. Lipsync (FLOAT - GPU)
         lipsync_video_url = None
         if FLOAT_ENABLED and audio_path and os.path.exists(audio_path):
             try:
@@ -407,21 +500,18 @@ def _generate_chunk(sentence, idx, total):
                     t_float_start = _time.time()
                     lp = lipsync.generate(audio_path)
                     t_float_done = _time.time()
-                    float_time = t_float_done - t_float_start
-                    logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] FLOAT: {float_time:.2f}s")
+                    logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] FLOAT: {t_float_done-t_float_start:.2f}s")
                     if lp and os.path.exists(lp):
-                        lp_size = os.path.getsize(lp)
                         lipsync_video_url = f"/api/stream/{os.path.basename(lp)}"
-                        logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] VIDEO: {lp_size/1024:.0f}KB")
+                        logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] VIDEO: {os.path.getsize(lp)/1024:.0f}KB")
             except Exception as e:
                 logger.error(f"[{_ts()}] [CHUNK {idx+1}/{total}] LIPSYNC FAILED: {e}", exc_info=True)
-                
-        # FIX: Clear VRAM after FLOAT visual generation
+
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
 
     total_time = _time.time() - t0
-    logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] DONE | total: {total_time:.2f}s | tts: {t_tts_end-t_tts_start:.2f}s + float: {total_time-(t_tts_end-t_tts_start):.2f}s")
+    logger.info(f"[{_ts()}] [CHUNK {idx+1}/{total}] DONE | total: {total_time:.2f}s")
 
     return {
         "audio_url": audio_url,
@@ -429,6 +519,7 @@ def _generate_chunk(sentence, idx, total):
         "lipsync_video_url": lipsync_video_url,
     }
 
+
 @app.post("/api/reset")
 async def reset_chat():
     from llm import reset_conversation
@@ -438,7 +529,6 @@ async def reset_chat():
 
 @app.get("/api/greeting")
 async def get_greeting():
-    """Return the pre-generated greeting (audio + lipsync video)."""
     if GREETING_DATA:
         return JSONResponse(GREETING_DATA)
     return JSONResponse({"text": None})
@@ -455,11 +545,15 @@ HTML_PAGE = """\
 <head>
 <meta charset="UTF-8"/>
 <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-<title>Darwin Avatar Chatbot</title>
+<title>Avatar Chatbot</title>
 <style>
 *{margin:0;padding:0;box-sizing:border-box}
 body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;background:#0a0f1c;color:#e2e8f0;height:100vh;display:flex;flex-direction:column;overflow:hidden}
 .app-container{display:flex;flex-direction:column;height:100vh;max-width:900px;margin:0 auto;width:100%;padding:1rem;gap:.75rem}
+.top-bar{display:flex;align-items:center;gap:.75rem;flex-shrink:0}
+.top-bar label{font-size:.85rem;color:#94a3b8}
+.top-bar select{background:#1e293b;color:#e2e8f0;border:1px solid rgba(59,130,246,.3);border-radius:6px;padding:6px 10px;font-size:.85rem;outline:none;cursor:pointer}
+.top-bar select:focus{border-color:#3b82f6}
 .video-section{position:relative;width:100%;min-height:300px;max-height:45vh;background:#000;border-radius:12px;overflow:hidden;flex-shrink:0;display:flex;align-items:center;justify-content:center}
 .video-container{position:relative;width:100%;height:100%}
 .video-container video{width:100%;height:100%;object-fit:contain;display:block}
@@ -491,6 +585,10 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;backgrou
 </head>
 <body>
 <div class="app-container">
+  <div class="top-bar">
+    <label for="avatarSelect">Avatar:</label>
+    <select id="avatarSelect"></select>
+  </div>
   <div class="video-section">
     <div class="video-container">
       <video id="videoA" muted autoplay playsinline></video>
@@ -501,25 +599,20 @@ body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;backgrou
   <div class="chat-section">
     <div class="chat-log" id="chatLog"></div>
     <div class="input-bar">
-      <input type="text" id="chatInput" placeholder="Ask Darwin something..." autocomplete="off"/>
+      <input type="text" id="chatInput" placeholder="Say something..." autocomplete="off"/>
       <button class="btn-send" id="btnSend">Send</button>
       <button class="btn-reset" id="btnReset" title="Reset conversation">&#8635;</button>
     </div>
   </div>
 </div>
 <script>
-// ======================================================================
-// STATE
-// ======================================================================
 let videos=[], currentVideo='A', isTransitioning=false, isProcessing=false, lastPlayed=null, msgCounter=0;
+let currentAvatarName='Avatar';
 const videoA=document.getElementById('videoA'), videoB=document.getElementById('videoB');
 const videoStatus=document.getElementById('videoStatus'), chatLog=document.getElementById('chatLog');
 const chatInput=document.getElementById('chatInput'), btnSend=document.getElementById('btnSend');
-const btnReset=document.getElementById('btnReset');
+const btnReset=document.getElementById('btnReset'), avatarSelect=document.getElementById('avatarSelect');
 
-// ======================================================================
-// VIDEO: Crossfade
-// ======================================================================
 function getActiveVideo(){return currentVideo==='A'?videoA:videoB}
 function getInactiveVideo(){return currentVideo==='A'?videoB:videoA}
 
@@ -529,48 +622,28 @@ function crossfadeTo(url, muted){
         isTransitioning=true;
         const prev=getActiveVideo(), next=getInactiveVideo();
         next.muted=(muted!==false);
-
-        // Prepare new video behind current, fully opaque (no flash)
-        next.style.opacity='1';
-        next.style.zIndex='0';
-        prev.style.zIndex='1';
-        next.src=url;
-        next.load();
-
+        next.style.opacity='1'; next.style.zIndex='0'; prev.style.zIndex='1';
+        next.src=url; next.load();
         next.onloadeddata=function(){
             next.play().then(()=>{
-                // New video is playing behind. Now bring it on top.
-                next.style.zIndex='2';
-                // Fade out the old video to reveal new one smoothly
-                prev.style.opacity='0';
-
+                next.style.zIndex='2'; prev.style.opacity='0';
                 setTimeout(()=>{
-                    // Cleanup after fade completes
-                    prev.pause();
-                    prev.removeAttribute('src');
-                    prev.load();
-                    prev.style.zIndex='0';
-                    prev.style.opacity='1'; // reset for next use
+                    prev.pause(); prev.removeAttribute('src'); prev.load();
+                    prev.style.zIndex='0'; prev.style.opacity='1';
                     next.style.zIndex='1';
                     currentVideo=currentVideo==='A'?'B':'A';
-                    isTransitioning=false;
-                    resolve();
-                }, 180); // slightly longer than CSS transition
+                    isTransitioning=false; resolve();
+                }, 180);
             }).catch(()=>{
                 next.muted=true;
                 next.play().then(()=>{
-                    next.style.zIndex='2';
-                    prev.style.opacity='0';
+                    next.style.zIndex='2'; prev.style.opacity='0';
                     setTimeout(()=>{
-                        prev.pause();
-                        prev.removeAttribute('src');
-                        prev.load();
-                        prev.style.zIndex='0';
-                        prev.style.opacity='1';
+                        prev.pause(); prev.removeAttribute('src'); prev.load();
+                        prev.style.zIndex='0'; prev.style.opacity='1';
                         next.style.zIndex='1';
                         currentVideo=currentVideo==='A'?'B':'A';
-                        isTransitioning=false;
-                        resolve();
+                        isTransitioning=false; resolve();
                     }, 180);
                 }).catch(()=>{ isTransitioning=false; resolve(); });
             });
@@ -593,35 +666,24 @@ function playNextIdle(){
     crossfadeTo('/api/stream/'+encodeURIComponent(c.filename), true);
 }
 
-// isSpeaking: true when lipsync chunks are actively playing
-// idle loop continues when isProcessing but NOT isSpeaking
 let isSpeaking=false;
-
 videoA.addEventListener('ended',()=>{ if(currentVideo==='A'&&!isSpeaking) playNextIdle(); });
 videoB.addEventListener('ended',()=>{ if(currentVideo==='B'&&!isSpeaking) playNextIdle(); });
 
-// ======================================================================
-// VIDEO: Wait for current video to end
-// ======================================================================
 function waitForVideoEnd(){
     return new Promise((resolve)=>{
         const active=getActiveVideo();
-        if(active.ended || active.paused || !active.src){
-            resolve(); return;
-        }
+        if(active.ended || active.paused || !active.src){ resolve(); return; }
         const onEnd=()=>{ active.removeEventListener('ended',onEnd); resolve(); };
         active.addEventListener('ended', onEnd);
     });
 }
 
-// ======================================================================
-// CHAT: Messages
-// ======================================================================
 function addMessage(role, text, extra){
     const id='msg_'+(msgCounter++);
     const w=document.createElement('div'); w.className='msg '+role;
     const b=document.createElement('div'); b.className='bubble '+role+(extra?' '+extra:''); b.id=id;
-    const l=document.createElement('div'); l.className='label'; l.textContent=role==='user'?'You':'Darwin';
+    const l=document.createElement('div'); l.className='label'; l.textContent=role==='user'?'You':currentAvatarName;
     const c=document.createElement('div'); c.className='content'; c.textContent=text;
     b.appendChild(l); b.appendChild(c); w.appendChild(b);
     chatLog.appendChild(w); chatLog.scrollTop=chatLog.scrollHeight;
@@ -634,9 +696,32 @@ function addTypingIndicator(){
     return r;
 }
 
-// ======================================================================
-// CHAT: Send message with chunked playback
-// ======================================================================
+// ---- Avatar switching ----
+avatarSelect.addEventListener('change', async ()=>{
+    const name=avatarSelect.value;
+    if(!name || isProcessing) return;
+    videoStatus.textContent='Switching avatar...';
+    btnSend.disabled=true;
+    try{
+        const res=await fetch('/api/switch-avatar',{
+            method:'POST', headers:{'Content-Type':'application/json'},
+            body:JSON.stringify({avatar:name})
+        });
+        const data=await res.json();
+        if(data.videos){
+            videos=data.videos;
+        }
+        currentAvatarName=name;
+        chatLog.innerHTML='';
+        addMessage('bot','Hi, I\\'m '+name+'. How can I help you?');
+        playNextIdle();
+    }catch(e){
+        videoStatus.textContent='Switch failed: '+e.message;
+    }
+    btnSend.disabled=false;
+});
+
+// ---- Chat ----
 async function sendMessage(){
     const text=chatInput.value.trim();
     if(!text||isProcessing) return;
@@ -645,8 +730,6 @@ async function sendMessage(){
     const typing=addTypingIndicator();
 
     try{
-        // Step 1: Get LLM response + session (fast, ~0.5s)
-        // Idle videos keep playing during this
         const res=await fetch('/api/chat',{
             method:'POST', headers:{'Content-Type':'application/json'},
             body:JSON.stringify({text:text})
@@ -654,7 +737,6 @@ async function sendMessage(){
         if(!res.ok) throw new Error('HTTP '+res.status);
         const data=await res.json();
 
-        // Replace typing indicator with empty bot bubble, ready for streaming
         typing.bubbleEl.classList.remove('typing');
         typing.contentEl.classList.remove('typing-dots');
         typing.contentEl.textContent='';
@@ -665,20 +747,14 @@ async function sendMessage(){
         const fullText=data.text;
         let displayedText='';
 
-        // Text streaming: reveal words of a specific sentence over the given duration
         function streamChunkText(sentence, durationSec){
-            const chunkWords=sentence.split(/\s+/).filter(w=>w.length>0);
+            const chunkWords=sentence.split(/\\s+/).filter(w=>w.length>0);
             if(chunkWords.length===0) return Promise.resolve();
             const interval=Math.max(50, (durationSec*1000)/chunkWords.length);
             return new Promise((resolve)=>{
                 let i=0;
                 const timer=setInterval(()=>{
-                    if(i>=chunkWords.length){
-                        clearInterval(timer);
-                        resolve();
-                        return;
-                    }
-                    // Add space between previous text and new word
+                    if(i>=chunkWords.length){ clearInterval(timer); resolve(); return; }
                     if(displayedText.length>0) displayedText+=' ';
                     displayedText+=chunkWords[i];
                     typing.contentEl.textContent=displayedText;
@@ -688,16 +764,12 @@ async function sendMessage(){
             });
         }
 
-        // Show all remaining text instantly (cleanup)
         function showAllText(){
             typing.contentEl.textContent=fullText;
             typing.contentEl.classList.remove('streaming-cursor');
             chatLog.scrollTop=chatLog.scrollHeight;
         }
 
-        videoStatus.textContent='generating 1/'+totalChunks+'...';
-
-        // Helper to fetch a chunk from the server
         async function fetchChunk(sid){
             const r=await fetch('/api/chat/next',{
                 method:'POST', headers:{'Content-Type':'application/json'},
@@ -707,69 +779,47 @@ async function sendMessage(){
             return await r.json();
         }
 
-        // Step 2: Prefetch first chunk (idle keeps playing while we wait)
         let nextChunkPromise=fetchChunk(sessionId);
 
         for(let i=0; i<totalChunks; i++){
             videoStatus.textContent='generating '+(i+1)+'/'+totalChunks+'...';
-
-            // Wait for the chunk to be ready
             const chunk=await nextChunkPromise;
             if(!chunk || chunk.done) break;
+            if(i+1 < totalChunks) nextChunkPromise=fetchChunk(sessionId);
 
-            // Immediately start prefetching the NEXT chunk
-            if(i+1 < totalChunks){
-                nextChunkPromise=fetchChunk(sessionId);
-            }
-
-            // Now we have a chunk ready — stop idle loop and wait for current idle to finish
             isSpeaking=true;
-            videoStatus.textContent='waiting for idle to finish...';
             await waitForVideoEnd();
-
             videoStatus.textContent='speaking '+(i+1)+'/'+totalChunks;
 
-            // Play audio
             let audioPromise=null;
             if(chunk.audio_url){
                 const audio=new Audio(chunk.audio_url);
                 audioPromise=new Promise((resolve)=>{
-                    audio.onended=resolve;
-                    audio.onerror=resolve;
+                    audio.onended=resolve; audio.onerror=resolve;
                     audio.play().catch(()=>resolve());
                 });
             }
 
-            // Stream text for this chunk's sentence over its audio duration
             const chunkDuration=chunk.audio_duration||3.0;
             const textStreamPromise=streamChunkText(chunk.sentence, chunkDuration);
 
-            // Play lipsync video
             if(chunk.lipsync_video_url){
                 await crossfadeTo(chunk.lipsync_video_url, true);
-                // Wait for lipsync video to finish before next chunk
                 await waitForVideoEnd();
             } else if(audioPromise){
-                // No lipsync, just wait for audio to finish
                 await audioPromise;
             }
-
-            // Ensure text streaming for this chunk is done
             await textStreamPromise;
         }
 
-        // Ensure all text is shown
         showAllText();
-
-        // All chunks done, return to idle
         isSpeaking=false;
         playNextIdle();
 
     }catch(err){
         typing.bubbleEl.classList.remove('typing');
         typing.bubbleEl.classList.add('error');
-        typing.contentEl.classList.remove('typing-dots');
-        typing.contentEl.classList.remove('streaming-cursor');
+        typing.contentEl.classList.remove('typing-dots','streaming-cursor');
         typing.contentEl.textContent='Error: '+err.message;
     }
     isSpeaking=false; isProcessing=false; btnSend.disabled=false; chatInput.focus();
@@ -780,40 +830,46 @@ chatInput.addEventListener('keydown', e=>{ if(e.key==='Enter'&&!e.shiftKey){ e.p
 btnReset.addEventListener('click', async()=>{
     await fetch('/api/reset',{method:'POST'});
     chatLog.innerHTML='';
-    addMessage('bot','Ah, a fresh start! How may I assist you, my good fellow?');
+    addMessage('bot','Conversation reset. How can I help you?');
 });
 
-// ======================================================================
-// INIT
-// ======================================================================
+// ---- Init ----
 async function init(){
     try{
+        // Load avatars into dropdown
+        const avatarRes=await fetch('/api/avatars');
+        const avatarData=await avatarRes.json();
+        avatarSelect.innerHTML='';
+        for(const a of avatarData.avatars){
+            const opt=document.createElement('option');
+            opt.value=a.name; opt.textContent=a.name;
+            if(a.name===avatarData.current) opt.selected=true;
+            avatarSelect.appendChild(opt);
+        }
+        if(avatarData.current) currentAvatarName=avatarData.current;
+
+        // Load idle videos
         const res=await fetch('/api/videos');
         const data=await res.json();
-        if(!data.videos.length){ videoStatus.textContent='Downloading...'; setTimeout(init,3000); return; }
-        videos=data.videos;
-        videoStatus.textContent=videos.length+' idle clips loaded';
+        if(!data.videos.length){ videoStatus.textContent='No idle videos...'; }
+        else{ videos=data.videos; videoStatus.textContent=videos.length+' idle clips loaded'; }
 
-        // Check for pre-generated greeting
+        // Check greeting
         const greetRes=await fetch('/api/greeting');
         const greeting=await greetRes.json();
 
         if(greeting.lipsync_video_url){
-            // Play greeting lipsync video first
             videoStatus.textContent='greeting...';
             addMessage('bot', greeting.text);
-
             if(greeting.audio_url){
                 const audio=new Audio(greeting.audio_url);
                 audio.play().catch(e=>console.warn('[AUDIO]',e));
             }
-
             await crossfadeTo(greeting.lipsync_video_url, true);
             await waitForVideoEnd();
             playNextIdle();
         } else {
-            // No lipsync available, show text and start idle
-            addMessage('bot', greeting.text || 'Good day! I am Charles Darwin, recreated in this curious digital form. Do feel free to ask me anything about the natural world.');
+            addMessage('bot', greeting.text || 'Hello! Feel free to ask me anything.');
             playNextIdle();
         }
     }catch(e){ videoStatus.textContent='Error: '+e.message; }