feat: new prompt, richer feedback format, howto redesign, move legacy src

- Replace SYSTEM_PROMPT with improved roleplay + feedback prompt
- Add --- delimiter between spoken intro and written recap
- Rewrite parse_feedback.py: Citation/Correction/Pourquoi format +
Points forts, Vocabulaire dentaire utile, Priorité, Bilan scores
- Update core.py: new delimiter, expanded TERMINATE_RE, richer result dict
- Update server_app.py to pass 4 new feedback sections
- Redesign custom_index.html feedback panel: new table headers,
sections for Points forts/Vocabulaire/Priorité/Bilan with progress bars
- Redesign .howto section with Lovable-style numbered circles
- Update app.py Gradio app for new feedback format
- Move legacy React/Gemini code to legacy/ and gitignore it

.gitignore

@@ -10,3 +10,4 @@ __pycache__/
 *.pyc
 .gradio/
 test-qwen/
+legacy/

_modal_llamacpp_base.py

@@ -0,0 +1,326 @@
+# _modal_llamacpp_base.py
+# Shared infrastructure for all llama.cpp Modal endpoints.
+# Do not deploy this file directly — import from model-specific files.
+
+import subprocess
+import time
+from dataclasses import dataclass
+
+import modal
+
+# ─── CONSTANTS ───────────────────────────────────────────────────────────────
+HOST = "0.0.0.0"
+PORT = 8080
+SCALEDOWN_WINDOW = 300
+CONTAINER_TIMEOUT = 3600
+MODEL_DIR = "/cache"
+
+SECRETS = [
+    modal.Secret.from_name("api-key"),
+    modal.Secret.from_name("hf-token"),
+]
+
+
+@dataclass(frozen=True)
+class ModelConfig:
+    model_repo: str
+    model_quant: str
+    alias: str
+    gpu_type: str = "L4"
+    ctx_size: int = 65536
+    n_gpu_layers: int = 99
+    cache_type_k: str = "q8_0"
+    cache_type_v: str = "q8_0"
+    batch_size: int = 2048
+    ubatch_size: int = 512
+    threads: int = 4
+    threads_batch: int = 4
+    flash_attn: bool = True
+    speculative: bool = False
+    multimodal: bool = False
+    volume_name: str = ""
+    mtp_draft_n_max: int = 2
+    mtp_draft_p_min: float = 0.75
+
+    def __post_init__(self):
+        if not self.volume_name:
+            object.__setattr__(
+                self,
+                "volume_name",
+                f"llm-cache-{self.alias.replace('.', '').replace('/', '-')}",
+            )
+
+
+# ─── SHARED IMAGE ────────────────────────────────────────────────────────────
+
+llama_image = (
+    modal.Image.from_registry(
+        "nvidia/cuda:12.4.1-devel-ubuntu22.04", add_python="3.12"
+    )
+    .apt_install(
+        "build-essential",
+        "git",
+        "cmake",
+        "curl",
+        "libcurl4-openssl-dev",
+        "libssl-dev",
+        "pciutils",
+    )
+    .run_commands(
+        "git clone https://github.com/ggml-org/llama.cpp /llama.cpp",
+        "cmake /llama.cpp -B /llama.cpp/build "
+        "-DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON",
+        "cmake --build /llama.cpp/build --config Release -j "
+        "--target llama-server",
+    )
+    .pip_install("fastapi[standard]", "httpx")
+    .env({"LLAMA_CACHE": MODEL_DIR})
+    .add_local_python_source("_modal_llamacpp_base")
+)
+
+
+# ─── HELPERS ─────────────────────────────────────────────────────────────────
+
+def build_llama_cmd(cfg: ModelConfig) -> list[str]:
+    cmd = [
+        "/llama.cpp/build/bin/llama-server",
+        "-hf",
+        f"{cfg.model_repo}:{cfg.model_quant}",
+        "-ngl",
+        str(cfg.n_gpu_layers),
+        "-c",
+        str(cfg.ctx_size),
+        "-fa",
+        "on" if cfg.flash_attn else "off",
+        "-np",
+        "1",
+        "--cache-type-k",
+        cfg.cache_type_k,
+        "--cache-type-v",
+        cfg.cache_type_v,
+        "--host",
+        HOST,
+        "--port",
+        str(PORT),
+        "--threads",
+        str(cfg.threads),
+        "--threads-batch",
+        str(cfg.threads_batch),
+        "--batch-size",
+        str(cfg.batch_size),
+        "--ubatch-size",
+        str(cfg.ubatch_size),
+        "--alias",
+        cfg.alias,
+        "--jinja",
+    ]
+    if cfg.speculative:
+        cmd += [
+            "--spec-type",
+            "draft-mtp",
+            "--spec-draft-n-max",
+            str(cfg.mtp_draft_n_max),
+            "--spec-draft-p-min",
+            str(cfg.mtp_draft_p_min),
+        ]
+    return cmd
+
+
+def make_asgi_app(cfg: ModelConfig) -> modal.App:
+    """Return a standalone Modal ASGI app for one model."""
+    app = modal.App(f"{cfg.alias.replace('.', '')}-llamacpp")
+    vol = modal.Volume.from_name(cfg.volume_name, create_if_missing=True)
+
+    @app.function(
+        image=llama_image,
+        gpu=cfg.gpu_type,
+        volumes={MODEL_DIR: vol},
+        secrets=SECRETS,
+        timeout=CONTAINER_TIMEOUT,
+        scaledown_window=SCALEDOWN_WINDOW,
+        max_containers=1,
+        serialized=True,
+        name=f"{cfg.alias.replace('.', '')}-infer",
+        cpu=2,
+        memory=6144
+    )
+    @modal.asgi_app()
+    def infer():
+        import httpx
+        import os
+
+        from fastapi import Depends, FastAPI, HTTPException, Request, Response, Security
+        from fastapi.responses import StreamingResponse
+        from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+        fastapi_app = FastAPI()
+        security = HTTPBearer()
+        llama_url = f"http://localhost:{PORT}"
+
+        async def verify_api_key(
+            creds: HTTPAuthorizationCredentials = Security(security),
+        ):
+            expected = os.environ.get("API_KEY", "")
+            if not expected:
+                raise HTTPException(500, "API_KEY secret not configured")
+            if creds.credentials != expected:
+                raise HTTPException(401, "Invalid API key")
+
+        # ── Start llama-server ────────────────────────────────────────────
+        cmd = build_llama_cmd(cfg)
+        print(f"[{cfg.alias}] Starting llama-server: {' '.join(cmd)}")
+        stderr_log = open(f"/tmp/llama-server-{cfg.alias}.log", "w")
+        proc = subprocess.Popen(cmd, stderr=stderr_log)
+
+        print(f"[{cfg.alias}] Waiting for llama-server (download + load)...")
+        for i in range(600):
+            if proc.poll() is not None:
+                stderr_log.close()
+                with open(f"/tmp/llama-server-{cfg.alias}.log") as f:
+                    stderr = f.read()
+                raise RuntimeError(
+                    f"[{cfg.alias}] llama-server exited {proc.returncode}: {stderr}"
+                )
+            if i % 30 == 0 and i > 0:
+                print(f"[{cfg.alias}] ...still waiting ({i}s)")
+            try:
+                with httpx.Client(timeout=2) as client:
+                    r = client.get(f"{llama_url}/health")
+                    if r.status_code == 200:
+                        print(f"[{cfg.alias}] llama-server ready after {i + 1}s")
+                        break
+            except Exception:
+                pass
+            time.sleep(1)
+        else:
+            stderr_log.close()
+            proc.terminate()
+            with open(f"/tmp/llama-server-{cfg.alias}.log") as f:
+                stderr = f.read()
+            raise RuntimeError(
+                f"[{cfg.alias}] failed to start in 600s. Last logs:\n{stderr[-2000:]}"
+            )
+
+        # ── Endpoints ────────────────────────────────────────────────────
+
+        @fastapi_app.get("/health")
+        async def health(_: None = Depends(verify_api_key)):
+            async with httpx.AsyncClient(timeout=5) as client:
+                r = await client.get(f"{llama_url}/health")
+                status = "ok" if r.status_code == 200 else "starting"
+            return {"status": status}
+
+        @fastapi_app.post("/v1/chat/completions")
+        async def chat_completions(request: Request, _: None = Depends(verify_api_key)):
+            body = await request.json()
+            stream = body.get("stream", False)
+            if stream:
+                client = httpx.AsyncClient(timeout=300)
+                r = await client.send(
+                    client.build_request(
+                        "POST", f"{llama_url}/v1/chat/completions", json=body
+                    ),
+                    stream=True,
+                )
+
+                async def proxy_stream():
+                    try:
+                        async for chunk in r.aiter_bytes():
+                            yield chunk
+                    finally:
+                        await r.aclose()
+                        await client.aclose()
+
+                return StreamingResponse(
+                    proxy_stream(), media_type="text/event-stream"
+                )
+
+            async with httpx.AsyncClient(timeout=300) as client:
+                r = await client.post(
+                    f"{llama_url}/v1/chat/completions", json=body
+                )
+            return Response(
+                content=r.content,
+                status_code=r.status_code,
+                media_type="application/json",
+            )
+
+        @fastapi_app.post("/v1/completions")
+        async def completions(request: Request, _: None = Depends(verify_api_key)):
+            body = await request.json()
+            stream = body.get("stream", False)
+            if stream:
+                client = httpx.AsyncClient(timeout=300)
+                r = await client.send(
+                    client.build_request(
+                        "POST", f"{llama_url}/v1/completions", json=body
+                    ),
+                    stream=True,
+                )
+
+                async def proxy_stream():
+                    try:
+                        async for chunk in r.aiter_bytes():
+                            yield chunk
+                    finally:
+                        await r.aclose()
+                        await client.aclose()
+
+                return StreamingResponse(
+                    proxy_stream(), media_type="text/event-stream"
+                )
+
+            async with httpx.AsyncClient(timeout=300) as client:
+                r = await client.post(f"{llama_url}/v1/completions", json=body)
+            return Response(
+                content=r.content,
+                status_code=r.status_code,
+                media_type="application/json",
+            )
+
+        @fastapi_app.get("/v1/models")
+        async def models(_: None = Depends(verify_api_key)):
+            async with httpx.AsyncClient(timeout=10) as client:
+                r = await client.get(f"{llama_url}/v1/models")
+            return Response(
+                content=r.content,
+                status_code=r.status_code,
+                media_type="application/json",
+            )
+
+        @fastapi_app.get("/gpu")
+        async def gpu_stats(_: None = Depends(verify_api_key)):
+            import subprocess as _sp
+
+            smi = _sp.check_output(
+                [
+                    "nvidia-smi",
+                    "--query-gpu=name,memory.used,memory.total,memory.free,utilization.gpu",
+                    "--format=csv,noheader,nounits",
+                ],
+                text=True,
+            ).strip()
+            return {
+                "alias": cfg.alias,
+                "gpu": smi,
+                "config": {
+                    "ctx_size": cfg.ctx_size,
+                    "cache_type_k": cfg.cache_type_k,
+                    "cache_type_v": cfg.cache_type_v,
+                    "n_gpu_layers": cfg.n_gpu_layers,
+                    "batch_size": cfg.batch_size,
+                    "ubatch_size": cfg.ubatch_size,
+                    "flash_attn": cfg.flash_attn,
+                    "speculative": cfg.speculative,
+                    "multimodal": cfg.multimodal,
+                },
+            }
+
+        return fastapi_app
+
+    return app
+
+
+# ─── LOCAL TEST MODE ─────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    print("This is a shared library. Run one of the model files directly.")

app.py

@@ -8,7 +8,10 @@ from stt_engine import transcribe, warmup
 from llm_engine import chat as llm_chat
 from tts_engine import synthesize
 
-TERMINATE_RE = re.compile(r"(fin\s+de\s+(la\s+)?séance|session\s+terminée)", re.IGNORECASE)
+TERMINATE_RE = re.compile(
+    r"(fin\s+de\s+(la\s+)?séance|session\s+terminée|on\s+a\s+terminé|c'est\s+fini)",
+    re.IGNORECASE,
+)
 
 # ---- i18n ----
 i18n = gr.I18n(
@@ -67,12 +70,10 @@ i18n = gr.I18n(
 def _idle_feedback():
     return "", [], gr.update(open=False)
 
-def _show_feedback(state, clean):
-    entries = parse_feedback(clean)
-    table = render_feedback_table(entries) if entries else []
-    intro = clean
-    if "Disse:" in intro:
-        intro = intro.split("Disse:")[0].strip()
+def _show_feedback(clean):
+    fb = parse_feedback(clean)
+    table = render_feedback_table(fb["erreurs"]) if fb["erreurs"] else []
+    intro = fb.get("intro") or clean
     return intro, table, gr.update(open=True)
 
 def _chat_val(state):
@@ -132,10 +133,10 @@ def _end_session(state):
         return
 
     clean = strip_markdown(response)
-    state["messages"].append({"role": "assistant", "content": clean})
     state["phase"] = 2
 
-    intro, table, accordion = _show_feedback(state, clean)
+    intro, table, accordion = _show_feedback(clean)
+    state["messages"].append({"role": "assistant", "content": intro})
     audio_bytes = synthesize(intro)
 
     yield _chat_val(state), _make_audio(audio_bytes), state, intro, table, accordion, ""
@@ -219,7 +220,7 @@ with gr.Blocks() as demo:
         with feedback_panel:
             feedback_intro = gr.Markdown("")
             feedback_table = gr.Dataframe(
-                headers=["Disse", "Correction", "Explication"],
+                headers=["Citation", "Correction", "Pourquoi"],
                 datatype=["str", "str", "str"],
                 wrap=True,
                 interactive=False,

core.py

@@ -8,7 +8,10 @@ from stt_engine import transcribe, warmup
 from llm_engine import chat as llm_chat
 from tts_engine import synthesize
 
-TERMINATE_RE = re.compile(r"(fin\s+de\s+(la\s+)?séance|session\s+terminée)", re.IGNORECASE)
+TERMINATE_RE = re.compile(
+    r"(fin\s+de\s+(la\s+)?séance|session\s+terminée|on\s+a\s+terminé|c'est\s+fini)",
+    re.IGNORECASE,
+)
 
 
 def make_initial_state():
@@ -29,23 +32,32 @@ def _make_audio(audio_bytes):
     return os.path.basename(f.name)
 
 
+def _default_feedback():
+    """Return a blank feedback result block."""
+    return {
+        "feedback_intro": "",
+        "feedback_points_forts": [],
+        "feedback_table": [],
+        "feedback_vocabulaire": [],
+        "feedback_priorite": [],
+        "feedback_bilan": {},
+        "feedback_open": False,
+    }
+
+
 def process_turn(audio_path, state):
-    """Process one voice turn. Returns dict with all outputs."""
     state = dict(state)
     result = {
         "chat": _chat_val(state),
         "audio_file": None,
         "state": state,
-        "feedback_intro": "",
-        "feedback_table": [],
-        "feedback_open": False,
+        **_default_feedback(),
         "status": "",
     }
 
     if not audio_path:
         return result
 
-    # 1. STT
     result["status"] = "🎙 Transcription…"
     user_text = transcribe(audio_path)
     if not user_text or len(user_text.strip()) < 2:
@@ -57,7 +69,6 @@ def process_turn(audio_path, state):
     if TERMINATE_RE.search(user_text):
         return _end_session(state)
 
-    # 2. LLM
     result["status"] = "🧠 Réflexion…"
     response = llm_chat(state["messages"])
     if not response:
@@ -67,7 +78,6 @@ def process_turn(audio_path, state):
     clean = strip_markdown(response)
     state["messages"].append({"role": "assistant", "content": clean})
 
-    # 3. TTS
     result["status"] = "🔊 Synthèse vocale…"
     audio_bytes = synthesize(clean)
     result["audio_file"] = _make_audio(audio_bytes)
@@ -77,16 +87,13 @@ def process_turn(audio_path, state):
 
 
 def _end_session(state):
-    """End session and generate recap."""
     state["messages"].append({"role": "user", "content": PHASE_SWITCH_REMINDER})
 
     result = {
         "chat": _chat_val(state),
         "audio_file": None,
         "state": state,
-        "feedback_intro": "",
-        "feedback_table": [],
-        "feedback_open": False,
+        **_default_feedback(),
         "status": "📝 Génération du récapitulatif…",
     }
 
@@ -98,13 +105,10 @@ def _end_session(state):
     clean = strip_markdown(response)
     state["phase"] = 2
 
-    entries = parse_feedback(clean)
-    table = render_feedback_table(entries) if entries else []
-    intro = clean
-    if "Disse:" in intro:
-        intro = intro.split("Disse:")[0].strip()
+    fb = parse_feedback(clean)
+    table = render_feedback_table(fb["erreurs"]) if fb["erreurs"] else []
+    intro = fb.get("intro") or clean
 
-    # Only add spoken intro to chat, not raw Disse/Correction/Explication blocks
     state["messages"].append({"role": "assistant", "content": intro})
 
     audio_bytes = synthesize(intro)
@@ -112,18 +116,20 @@ def _end_session(state):
     result["chat"] = _chat_val(state)
     result["audio_file"] = _make_audio(audio_bytes)
     result["feedback_intro"] = intro
+    result["feedback_points_forts"] = fb["points_forts"]
     result["feedback_table"] = table
+    result["feedback_vocabulaire"] = fb["vocabulaire"]
+    result["feedback_priorite"] = fb["priorite"]
+    result["feedback_bilan"] = fb["bilan"]
     result["feedback_open"] = True
     result["status"] = ""
     return result
 
 
 def end_session_click(state):
-    """Public wrapper for end_session."""
     return _end_session(dict(state))
 
 
 def reset_session():
-    """Reset to initial state."""
     warmup()
     return make_initial_state()

custom_index.html

@@ -134,48 +134,45 @@ body {
 
 /* How-to */
 .howto {
-  padding: 20px 24px;
-  background: var(--glass);
-  border: 1px solid var(--glass-border);
-  border-radius: 14px;
+  padding: 24px;
+  background: rgba(255,255,255,0.03);
+  border: 1px solid rgba(255,255,255,0.08);
+  border-radius: 12px;
+  backdrop-filter: blur(10px);
 }
-.howto h3 {
-  font-size: 11px;
+.howto .howto-title {
+  font-size: 10px;
   text-transform: uppercase;
   letter-spacing: 0.15em;
   color: var(--accent);
-  margin-bottom: 14px;
-  font-weight: 600;
+  font-weight: 700;
 }
 .howto ol {
   list-style: none;
-  counter-reset: steps;
+  margin: 16px 0 0;
+  padding: 0;
   display: flex;
   flex-direction: column;
-  gap: 10px;
-  padding: 0;
+  gap: 12px;
 }
 .howto li {
-  counter-increment: steps;
   display: flex;
-  align-items: flex-start;
   gap: 12px;
   font-size: 13px;
   color: var(--text-dim);
-  line-height: 1.5;
+  line-height: 1.6;
 }
-.howto li::before {
-  content: counter(steps);
+.howto li .num {
   flex-shrink: 0;
-  width: 22px; height: 22px;
+  width: 20px; height: 20px;
   border-radius: 50%;
-  background: var(--accent-dim);
-  color: var(--accent);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  font-size: 11px;
+  display: grid;
+  place-items: center;
+  border: 1px solid rgba(255,255,255,0.15);
+  font-size: 10px;
   font-weight: 600;
+  color: var(--accent);
+  margin-top: 2px;
 }
 .howto li strong { color: var(--text); }
 
@@ -448,9 +445,71 @@ body {
 }
 .feedback-table td {
   padding: 8px 10px;
-  border-bottom: 1px solid rgba(255,255,255,0.04);
-  color: var(--text-dim);
+  border-bottom: 1px solid var(--glass-border);
+  color: var(--text);
   line-height: 1.5;
+  font-size: 12px;
+}
+
+/* Feedback sections */
+.feedback-section { margin-bottom: 14px; }
+.feedback-section-title {
+  font-family: var(--serif);
+  font-size: 14px;
+  font-weight: 600;
+  margin-bottom: 6px;
+  color: var(--accent);
+}
+.feedback-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+.feedback-list li {
+  font-size: 12px;
+  line-height: 1.6;
+  padding: 2px 0;
+  color: var(--text);
+}
+.feedback-list li::before {
+  content: "•";
+  color: var(--accent);
+  margin-right: 6px;
+}
+
+/* Progress bars for Bilan */
+.bilan-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 8px;
+}
+.bilan-label {
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-dim);
+  width: 140px;
+  flex-shrink: 0;
+}
+.bilan-bar {
+  flex: 1;
+  height: 8px;
+  background: rgba(255,255,255,0.08);
+  border-radius: 4px;
+  overflow: hidden;
+}
+.bilan-fill {
+  height: 100%;
+  background: var(--accent);
+  border-radius: 4px;
+  transition: width 0.5s ease;
+}
+.bilan-score {
+  font-size: 11px;
+  color: var(--text-dim);
+  width: 30px;
+  text-align: right;
 }
 
 /* Footer */
@@ -524,12 +583,12 @@ body {
 
       <!-- How to use -->
       <div class="howto">
-        <h3>Comment utiliser</h3>
+        <div class="howto-title">Comment utiliser</div>
         <ol>
-          <li>Appuyez sur le bouton micro pour commencer à enregistrer.</li>
-          <li>Parlez en français — saluez le patient, posez des questions, expliquez les soins.</li>
-          <li>Appuyez à nouveau pour arrêter — le patient vous répond à voix haute.</li>
-          <li>Dites <strong>« Fin de la séance »</strong> ou appuyez sur <strong>Terminer</strong> pour obtenir votre bilan.</li>
+          <li><span class="num">1</span><span>Appuyez sur le bouton micro pour commencer à enregistrer.</span></li>
+          <li><span class="num">2</span><span>Parlez en français — saluez le patient, posez des questions, expliquez les soins.</span></li>
+          <li><span class="num">3</span><span>Appuyez à nouveau pour arrêter — le patient vous répond à voix haute.</span></li>
+          <li><span class="num">4</span><span>Dites <strong>« Fin de la séance »</strong> ou appuyez sur <strong>Terminer</strong> pour obtenir votre bilan.</span></li>
         </ol>
       </div>
 
@@ -582,10 +641,31 @@ body {
         <div class="feedback-body">
           <div class="feedback-intro" id="feedback-intro"></div>
           <div class="feedback-empty" id="feedback-empty">Le bilan se construira au fil de la conversation.</div>
+
+          <div id="feedback-points-forts" class="feedback-section" style="display:none">
+            <div class="feedback-section-title">Points forts</div>
+            <ul class="feedback-list" id="feedback-points-list"></ul>
+          </div>
+
           <table class="feedback-table" id="feedback-table" style="display:none">
-            <thead><tr><th>Disse</th><th>Correction</th><th>Explication</th></tr></thead>
+            <thead><tr><th>Citation</th><th>Correction</th><th>Pourquoi</th></tr></thead>
             <tbody id="feedback-tbody"></tbody>
           </table>
+
+          <div id="feedback-vocab" class="feedback-section" style="display:none">
+            <div class="feedback-section-title">Vocabulaire dentaire utile</div>
+            <ul class="feedback-list" id="feedback-vocab-list"></ul>
+          </div>
+
+          <div id="feedback-priorite" class="feedback-section" style="display:none">
+            <div class="feedback-section-title">Priorité pour la prochaine séance</div>
+            <ul class="feedback-list" id="feedback-priorite-list"></ul>
+          </div>
+
+          <div id="feedback-bilan" class="feedback-section" style="display:none">
+            <div class="feedback-section-title">Bilan</div>
+            <div id="feedback-bilan-rows"></div>
+          </div>
         </div>
       </div>
     </div>
@@ -622,6 +702,14 @@ const feedbackTbody = document.getElementById("feedback-tbody");
 const feedbackTable = document.getElementById("feedback-table");
 const feedbackEmpty = document.getElementById("feedback-empty");
 const feedbackCount = document.getElementById("feedback-count");
+const feedbackPointsForts = document.getElementById("feedback-points-forts");
+const feedbackPointsList = document.getElementById("feedback-points-list");
+const feedbackVocab = document.getElementById("feedback-vocab");
+const feedbackVocabList = document.getElementById("feedback-vocab-list");
+const feedbackPriorite = document.getElementById("feedback-priorite");
+const feedbackPrioriteList = document.getElementById("feedback-priorite-list");
+const feedbackBilan = document.getElementById("feedback-bilan");
+const feedbackBilanRows = document.getElementById("feedback-bilan-rows");
 const audioPlayer = document.getElementById("audio-player");
 const btnEnd = document.getElementById("btn-end");
 const btnReset = document.getElementById("btn-reset");
@@ -715,7 +803,7 @@ async function processAudio(blob) {
 
     // Feedback
     if (d.feedback_open) {
-      showFeedback(d.feedback_intro, d.feedback_table);
+      showFeedback(d.feedback_intro, d.feedback_table, d.feedback_points_forts, d.feedback_vocabulaire, d.feedback_priorite, d.feedback_bilan);
     }
 
     setStatus(d.status || "");
@@ -748,7 +836,7 @@ async function endSession() {
       await playAudio(d.audio_url);
     }
     if (d.feedback_open) {
-      showFeedback(d.feedback_intro, d.feedback_table);
+      showFeedback(d.feedback_intro, d.feedback_table, d.feedback_points_forts, d.feedback_vocabulaire, d.feedback_priorite, d.feedback_bilan);
     }
     setStatus("");
   } catch (err) {
@@ -773,6 +861,14 @@ async function resetSession() {
     feedbackTbody.innerHTML = "";
     feedbackTable.style.display = "none";
     feedbackEmpty.style.display = "";
+    feedbackPointsForts.style.display = "none";
+    feedbackPointsList.innerHTML = "";
+    feedbackVocab.style.display = "none";
+    feedbackVocabList.innerHTML = "";
+    feedbackPriorite.style.display = "none";
+    feedbackPrioriteList.innerHTML = "";
+    feedbackBilan.style.display = "none";
+    feedbackBilanRows.innerHTML = "";
     feedbackCount.textContent = "0 notes";
     setStatus("");
     audioPlayer.pause();
@@ -797,16 +893,31 @@ function renderChat(messages) {
 }
 
 // Feedback
-function showFeedback(intro, table) {
+function showFeedback(intro, table, pointsForts, vocabulaire, priorite, bilan) {
   feedbackIntro.textContent = intro;
   feedbackTbody.innerHTML = "";
+
+  // Points forts
+  if (pointsForts && pointsForts.length) {
+    feedbackPointsForts.style.display = "";
+    feedbackPointsList.innerHTML = "";
+    for (const item of pointsForts) {
+      const li = document.createElement("li");
+      li.textContent = item;
+      feedbackPointsList.appendChild(li);
+    }
+  } else {
+    feedbackPointsForts.style.display = "none";
+  }
+
+  // Error table
   if (table && table.length) {
     feedbackTable.style.display = "";
     feedbackEmpty.style.display = "none";
     feedbackCount.textContent = table.length + (table.length > 1 ? " notes" : " note");
     for (const row of table) {
       const tr = document.createElement("tr");
-      const cells = Array.isArray(row) ? row : [row["Disse"], row["Correction"], row["Explication"]];
+      const cells = Array.isArray(row) ? row : [row["citation"], row["correction"], row["pourquoi"]];
       for (const cell of cells) {
         const td = document.createElement("td");
         td.textContent = cell || "";
@@ -814,7 +925,68 @@ function showFeedback(intro, table) {
       }
       feedbackTbody.appendChild(tr);
     }
+  } else {
+    feedbackTable.style.display = "none";
+  }
+
+  // Vocabulaire dentaire utile
+  if (vocabulaire && vocabulaire.length) {
+    feedbackVocab.style.display = "";
+    feedbackVocabList.innerHTML = "";
+    for (const item of vocabulaire) {
+      const li = document.createElement("li");
+      li.textContent = item;
+      feedbackVocabList.appendChild(li);
+    }
+  } else {
+    feedbackVocab.style.display = "none";
   }
+
+  // Priorité
+  if (priorite && priorite.length) {
+    feedbackPriorite.style.display = "";
+    feedbackPrioriteList.innerHTML = "";
+    for (const item of priorite) {
+      const li = document.createElement("li");
+      li.textContent = item;
+      feedbackPrioriteList.appendChild(li);
+    }
+  } else {
+    feedbackPriorite.style.display = "none";
+  }
+
+  // Bilan scores with progress bars
+  if (bilan && Object.keys(bilan).length) {
+    feedbackBilan.style.display = "";
+    feedbackBilanRows.innerHTML = "";
+    const labels = {
+      grammaire: "Grammaire",
+      fluidite: "Fluidité",
+      vocabulaire_dentaire: "Vocabulaire dentaire",
+      communication_clinique: "Communication clinique",
+    };
+    for (const [key, label] of Object.entries(labels)) {
+      const val = bilan[key];
+      if (val == null) continue;
+      const pct = Math.max(10, (val / 5) * 100);
+      const row = document.createElement("div");
+      row.className = "bilan-row";
+      row.innerHTML =
+        `<span class="bilan-label">${label}</span>` +
+        `<div class="bilan-bar"><div class="bilan-fill" style="width:${pct}%"></div></div>` +
+        `<span class="bilan-score">${val}/5</span>`;
+      feedbackBilanRows.appendChild(row);
+    }
+  } else {
+    feedbackBilan.style.display = "none";
+  }
+
+  // Show table count if any visible
+  if (!table || !table.length) {
+    feedbackEmpty.style.display = "none";
+    feedbackCount.textContent = "";
+  }
+
   feedbackEl.classList.add("open");
 }
 

get-modal-key.py

@@ -0,0 +1,10 @@
+import os
+
+import modal
+
+app = modal.App()
+
+
+@app.function(secrets=[modal.Secret.from_name("api-key")])
+def f():
+    print(os.environ["API_KEY"])

modal_gemma4_26b_llamacpp.py

@@ -0,0 +1,44 @@
+# modal_gemma4_26b_llamacpp.py
+# ─── Gemma 4 26B-A4B QAT on Modal (L4 GPU) ─────────────────────────────────
+#
+# Single-user OpenAI-compatible inference endpoint with multimodal (vision) support.
+# Uses llama.cpp built from source with CUDA. No speculative decoding.
+#
+# Deploy:
+#   modal deploy modal_gemma4_26b_llamacpp.py
+#
+# Set secrets (one-time):
+#   modal secret create api-key API_KEY=$(openssl rand -hex 32)
+#   modal secret create hf-token HF_TOKEN=hf_your_token_here
+#
+# Invoke (curl):
+#   curl -X POST <URL>/v1/chat/completions \
+#     -H "Authorization: Bearer $API_KEY" \
+#     -H "Content-Type: application/json" \
+#     -d '{"model":"gemma4-26b-a4b","messages":[{"role":"user","content":"Hello"}]}'
+#
+# Opencode / OpenAI base URL:
+#   https://<workspace>--gemma4-26b-a4b-llamacpp-gemma4-26b-a4b-infer.modal.run/v1
+#
+# Local test (outside Modal):
+#   python modal_gemma4_26b_llamacpp.py
+# ─────────────────────────────────────────────────────────────────────────────
+
+from _modal_llamacpp_base import ModelConfig, build_llama_cmd, make_asgi_app
+
+cfg = ModelConfig(
+    model_repo="unsloth/gemma-4-26B-A4B-it-qat-GGUF",
+    model_quant="UD-Q4_K_XL",
+    alias="gemma4-26b-a4b",
+    speculative=False,
+    multimodal=True,
+)
+
+app = make_asgi_app(cfg)
+
+if __name__ == "__main__":
+    cmd = " ".join(build_llama_cmd(cfg))
+    print("─── Local test mode ─────────────────────────────────")
+    print("Command that would run on Modal (L4 GPU):\n")
+    print(f"  {cmd}\n")
+    print("─── End ─────────────────────────────────────────────")

modal_gemma4_31b_llamacpp.py

@@ -0,0 +1,44 @@
+# modal_gemma4_31b_llamacpp.py
+# ─── Gemma 4 31B QAT on Modal (L4 GPU) ─────────────────────────────────────
+#
+# Single-user OpenAI-compatible inference endpoint with multimodal (vision) support.
+# Uses llama.cpp built from source with CUDA. No speculative decoding.
+#
+# Deploy:
+#   modal deploy modal_gemma4_31b_llamacpp.py
+#
+# Set secrets (one-time):
+#   modal secret create api-key API_KEY=$(openssl rand -hex 32)
+#   modal secret create hf-token HF_TOKEN=hf_your_token_here
+#
+# Invoke (curl):
+#   curl -X POST <URL>/v1/chat/completions \
+#     -H "Authorization: Bearer $API_KEY" \
+#     -H "Content-Type: application/json" \
+#     -d '{"model":"gemma4-31b","messages":[{"role":"user","content":"Hello"}]}'
+#
+# Opencode / OpenAI base URL:
+#   https://<workspace>--gemma4-31b-llamacpp-gemma4-31b-infer.modal.run/v1
+#
+# Local test (outside Modal):
+#   python modal_gemma4_31b_llamacpp.py
+# ─────────────────────────────────────────────────────────────────────────────
+
+from _modal_llamacpp_base import ModelConfig, build_llama_cmd, make_asgi_app
+
+cfg = ModelConfig(
+    model_repo="unsloth/gemma-4-31B-it-qat-GGUF",
+    model_quant="UD-Q4_K_XL",
+    alias="gemma4-31b",
+    speculative=False,
+    multimodal=True,
+)
+
+app = make_asgi_app(cfg)
+
+if __name__ == "__main__":
+    cmd = " ".join(build_llama_cmd(cfg))
+    print("─── Local test mode ─────────────────────────────────")
+    print("Command that would run on Modal (L4 GPU):\n")
+    print(f"  {cmd}\n")
+    print("─── End ─────────────────────────────────────────────")

modal_llamacpp_proxy.py

@@ -0,0 +1,233 @@
+# modal_llamacpp_proxy.py
+# ─── Single-URL Reverse Proxy for All llama.cpp Endpoints ────────────────────
+#
+# Lightweight CPU-only Modal ASGI app that routes requests to the correct
+# GPU backend based on the "model" field in the request body.
+#
+# Deploy:
+#   modal deploy modal_llamacpp_proxy.py
+#
+# Set secrets (one-time):
+#   modal secret create api-key API_KEY=$(openssl rand -hex 32)
+#
+# Models routed:
+#   qwen3.6-27b       → Qwen3.6-27B-MTP (MTP speculative decoding)
+#   gemma4-26b-a4b    → Gemma 4 26B-A4B QAT (multimodal)
+#   gemma4-31b        → Gemma 4 31B QAT (multimodal)
+#
+# Invoke (curl):
+#   curl -X POST <PROXY_URL>/v1/chat/completions \
+#     -H "Authorization: Bearer $API_KEY" \
+#     -H "Content-Type: application/json" \
+#     -d '{"model":"qwen3.6-27b","messages":[{"role":"user","content":"Hello"}]}'
+#
+# Custom domain (Cloudflare):
+#   1. Deploy this proxy
+#   2. Modal dashboard → app → web endpoint → Settings → Custom Domain
+#   3. Add CNAME in Cloudflare pointing to the Modal ingress target
+# ─────────────────────────────────────────────────────────────────────────────
+
+import modal
+
+# ─── ROUTING TABLE ───────────────────────────────────────────────────────────
+# Map model aliases to their backend Modal web endpoint URLs.
+# Update these URLs after deploying each backend.
+
+BACKENDS: dict[str, str] = {
+    "qwen3.6-27b": (
+        "https://carlosduplar--qwen36-27b-llamacpp-qwen36-27b-infer.modal.run"
+    ),
+    "gemma4-26b-a4b": (
+        "https://carlosduplar--gemma4-26b-a4b-llamacpp-gemma4-26b-a4b-infer.modal.run"
+    ),
+    "gemma4-31b": (
+        "https://carlosduplar--gemma4-31b-llamacpp-gemma4-31b-infer.modal.run"
+    ),
+}
+
+DEFAULT_MODEL = "qwen3.6-27b"
+
+# ─── APP ─────────────────────────────────────────────────────────────────────
+
+app = modal.App("llamacpp-proxy")
+
+proxy_image = modal.Image.debian_slim(python_version="3.12").pip_install(
+    "fastapi[standard]", "httpx"
+)
+
+
+@app.function(
+    image=proxy_image,
+    secrets=[modal.Secret.from_name("api-key")],
+    timeout=300,
+    scaledown_window=300,
+    max_containers=1,
+    cpu=0.25,
+    memory=512,
+)
+@modal.asgi_app()
+def infer():
+    import os
+
+    import httpx
+    from fastapi import HTTPException, Request, Response, Security
+    from fastapi.responses import StreamingResponse
+    from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+    from fastapi import FastAPI
+
+    fastapi_app = FastAPI(title="llamacpp-proxy")
+    security = HTTPBearer()
+
+    async def verify_api_key(
+        creds: HTTPAuthorizationCredentials = Security(security),
+    ):
+        expected = os.environ.get("API_KEY", "")
+        if not expected:
+            raise HTTPException(500, "API_KEY secret not configured")
+        if creds.credentials != expected:
+            raise HTTPException(401, "Invalid API key")
+
+    def _auth_headers(creds: HTTPAuthorizationCredentials) -> dict[str, str]:
+        return {"Authorization": f"Bearer {creds.credentials}"}
+
+    def _backend_for(model: str | None) -> tuple[str, str]:
+        """Return (alias, base_url) for the given model name."""
+        alias = model or DEFAULT_MODEL
+        base = BACKENDS.get(alias)
+        if not base:
+            raise HTTPException(
+                400,
+                f"Unknown model '{alias}'. Available: {', '.join(BACKENDS)}",
+            )
+        return alias, base
+
+    # ── Health: check all backends ────────────────────────────────────────
+
+    @fastapi_app.get("/health")
+    async def health(creds: HTTPAuthorizationCredentials = Security(security)):
+        results = {}
+        headers = _auth_headers(creds)
+        async with httpx.AsyncClient(timeout=5) as client:
+            for alias, base in BACKENDS.items():
+                try:
+                    r = await client.get(f"{base}/health", headers=headers)
+                    results[alias] = "ok" if r.status_code == 200 else "starting"
+                except Exception:
+                    results[alias] = "unreachable"
+        return {"status": results}
+
+    # ── Models: merge from all backends ───────────────────────────────────
+
+    @fastapi_app.get("/v1/models")
+    async def models(creds: HTTPAuthorizationCredentials = Security(security)):
+        all_models = []
+        headers = _auth_headers(creds)
+        async with httpx.AsyncClient(timeout=10) as client:
+            for base in BACKENDS.values():
+                try:
+                    r = await client.get(f"{base}/v1/models", headers=headers)
+                    if r.status_code == 200:
+                        data = r.json()
+                        all_models.extend(data.get("data", []))
+                except Exception:
+                    pass
+        return {"object": "list", "data": all_models}
+
+    # ── Chat completions ──────────────────────────────────────────────────
+
+    @fastapi_app.post("/v1/chat/completions")
+    async def chat_completions(
+        request: Request,
+        creds: HTTPAuthorizationCredentials = Security(security),
+    ):
+        body = await request.json()
+        alias, base = _backend_for(body.get("model"))
+        stream = body.get("stream", False)
+        headers = _auth_headers(creds)
+
+        if stream:
+            client = httpx.AsyncClient(timeout=300)
+            r = await client.send(
+                client.build_request(
+                    "POST", f"{base}/v1/chat/completions", json=body, headers=headers
+                ),
+                stream=True,
+            )
+
+            async def proxy_stream():
+                try:
+                    async for chunk in r.aiter_bytes():
+                        yield chunk
+                finally:
+                    await r.aclose()
+                    await client.aclose()
+
+            return StreamingResponse(proxy_stream(), media_type="text/event-stream")
+
+        async with httpx.AsyncClient(timeout=300) as client:
+            r = await client.post(f"{base}/v1/chat/completions", json=body, headers=headers)
+        return Response(
+            content=r.content,
+            status_code=r.status_code,
+            media_type="application/json",
+        )
+
+    # ── Completions ───────────────────────────────────────────────────────
+
+    @fastapi_app.post("/v1/completions")
+    async def completions(
+        request: Request,
+        creds: HTTPAuthorizationCredentials = Security(security),
+    ):
+        body = await request.json()
+        alias, base = _backend_for(body.get("model"))
+        stream = body.get("stream", False)
+        headers = _auth_headers(creds)
+
+        if stream:
+            client = httpx.AsyncClient(timeout=300)
+            r = await client.send(
+                client.build_request(
+                    "POST", f"{base}/v1/completions", json=body, headers=headers
+                ),
+                stream=True,
+            )
+
+            async def proxy_stream():
+                try:
+                    async for chunk in r.aiter_bytes():
+                        yield chunk
+                finally:
+                    await r.aclose()
+                    await client.aclose()
+
+            return StreamingResponse(proxy_stream(), media_type="text/event-stream")
+
+        async with httpx.AsyncClient(timeout=300) as client:
+            r = await client.post(f"{base}/v1/completions", json=body, headers=headers)
+        return Response(
+            content=r.content,
+            status_code=r.status_code,
+            media_type="application/json",
+        )
+
+    # ── GPU stats: all backends ───────────────────────────────────────────
+
+    @fastapi_app.get("/gpu")
+    async def gpu_stats(creds: HTTPAuthorizationCredentials = Security(security)):
+        results = {}
+        headers = _auth_headers(creds)
+        async with httpx.AsyncClient(timeout=10) as client:
+            for alias, base in BACKENDS.items():
+                try:
+                    r = await client.get(f"{base}/gpu", headers=headers)
+                    if r.status_code == 200:
+                        results[alias] = r.json()
+                    else:
+                        results[alias] = {"error": f"status {r.status_code}"}
+                except Exception as e:
+                    results[alias] = {"error": str(e)}
+        return {"backends": results}
+
+    return fastapi_app

modal_qwen36_llamacpp.py

@@ -0,0 +1,52 @@
+# modal_qwen36_llamacpp.py
+# ─── Qwen3.6-35B-A3B-MTP-GGUF on Modal (L4 GPU) ───────────────────────────
+#
+# Single-user OpenAI-compatible inference endpoint for coding agent workflows.
+# Uses llama.cpp built from source with CUDA, MTP speculative decoding enabled.
+#
+# Deploy:
+#   modal deploy modal_qwen36_llamacpp.py
+#
+# Set secrets (one-time):
+#   modal secret create api-key API_KEY=$(openssl rand -hex 32)
+#   modal secret create hf-token HF_TOKEN=hf_your_token_here
+#
+# Invoke (curl):
+#   curl -X POST <URL>/v1/chat/completions \
+#     -H "Authorization: Bearer $API_KEY" \
+#     -H "Content-Type: application/json" \
+#     -d '{"model":"qwen3.6-35b-a3b","messages":[{"role":"user","content":"Hello"}]}'
+#
+# Opencode / OpenAI base URL:
+#   https://<workspace>--qwen36-llamacpp-qwen36-infer.modal.run/v1
+#
+# Local test (outside Modal):
+#   python modal_qwen36_llamacpp.py
+# ─────────────────────────────────────────────────────────────────────────────
+
+from _modal_llamacpp_base import ModelConfig, build_llama_cmd, make_asgi_app
+
+cfg = ModelConfig(
+    model_repo="unsloth/Qwen3.6-35B-A3B-MTP-GGUF",
+    model_quant="UD-Q4_K_XL",
+    alias="qwen3.6-35b-a3b",
+    ctx_size=65536,
+    cache_type_k="q8_0",
+    cache_type_v="q4_0",
+    batch_size=1024,
+    ubatch_size=512,
+    threads=8,
+    threads_batch=8,
+    speculative=True,
+    mtp_draft_p_min=0.0,
+    multimodal=False,
+)
+
+app = make_asgi_app(cfg)
+
+if __name__ == "__main__":
+    cmd = " ".join(build_llama_cmd(cfg))
+    print("─── Local test mode ─────────────────────────────────")
+    print("Command that would run on Modal (L4 GPU):\n")
+    print(f"  {cmd}\n")
+    print("─── End ─────────────────────────────────────────────")

parse_feedback.py

@@ -1,23 +1,121 @@
 import re
 
-PATTERN = re.compile(
-    r"Disse:\s*(.+?)\s*Correction:\s*(.+?)\s*Explication:\s*(.+?)(?=\s*Disse:|\s*$)",
+SECTION_HEADERS = [
+    "Points forts",
+    "À corriger",
+    "Vocabulaire dentaire utile",
+    "Priorité pour la prochaine séance",
+    "Bilan",
+]
+
+NEXT_HEADER_PATTERN = re.compile(
+    rf"(?:^|\n)\s*(?:{'|'.join(re.escape(h) for h in SECTION_HEADERS)})\s*:\s*",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+CITATION_RE = re.compile(
+    r'Citation:\s*["\u00ab](.+?)["\u00bb]\s*Correction:\s*(.+?)\s*Pourquoi:\s*(.+?)(?=\s*(?:Citation:|[A-Z\u00c0-\u017f][^\n:]*:)|\s*$)',
     re.DOTALL | re.IGNORECASE,
 )
 
-def parse_feedback(text: str) -> list[dict]:
-    entries = []
-    for m in PATTERN.finditer(text):
-        entries.append({
-            "disse": m.group(1).strip(),
+
+def _extract_section(text: str, header: str) -> str:
+    """Return content between *header*: and the next section header or EOF."""
+    m = re.search(
+        rf"(?:^|\n)\s*{re.escape(header)}\s*:\s*",
+        text, re.IGNORECASE | re.MULTILINE,
+    )
+    if not m:
+        return ""
+    start = m.end()
+    # Find next section header
+    nm = NEXT_HEADER_PATTERN.search(text, start)
+    end = nm.start() if nm else len(text)
+    return text[start:end].strip()
+
+
+def _parse_bullets(text: str) -> list[str]:
+    """Extract lines prefixed with - or • from a section block."""
+    if not text:
+        return []
+    items = []
+    for line in text.split("\n"):
+        line = line.strip()
+        if re.match(r"^[-•]\s", line):
+            items.append(re.sub(r"^[-•]\s*", "", line).strip())
+    return items
+
+
+def _parse_bilan(text: str) -> dict:
+    """Extract Bilan scores as {key: int}."""
+    section = _extract_section(text, "Bilan")
+    if not section:
+        return {}
+    scores = {}
+    for line in section.split("\n"):
+        m = re.match(
+            r"[-•]?\s*(Grammaire|Fluidité|Vocabulaire dentaire|Communication clinique)\s*:\s*(\d+)\s*/\s*\d+",
+            line.strip(), re.IGNORECASE,
+        )
+        if m:
+            key = m.group(1).lower().replace(" ", "_")
+            scores[key] = int(m.group(2))
+    return scores
+
+
+def parse_feedback(text: str) -> dict:
+    """Parse full feedback into a structured dict.
+
+    Returns:
+        intro -- spoken part (before delimiter)
+        points_forts -- list[str]
+        erreurs -- list[dict] with keys: citation, correction, pourquoi
+        vocabulaire -- list[str]
+        priorite -- list[str]
+        bilan -- dict {grammaire: int, fluidite: int, ...}
+    """
+    result = {
+        "intro": "",
+        "points_forts": [],
+        "erreurs": [],
+        "vocabulaire": [],
+        "priorite": [],
+        "bilan": {},
+    }
+
+    # Split on delimiter
+    if "---" in text:
+        parts = text.split("---", 1)
+        result["intro"] = parts[0].strip()
+        rest = parts[1].strip()
+    elif "Points forts:" in text:
+        parts = text.split("Points forts:", 1)
+        result["intro"] = parts[0].strip()
+        rest = "Points forts: " + parts[1].strip()
+    else:
+        result["intro"] = text.strip()
+        return result
+
+    result["points_forts"] = _parse_bullets(_extract_section(rest, "Points forts"))
+
+    corriger = _extract_section(rest, "À corriger")
+    for m in CITATION_RE.finditer(corriger):
+        result["erreurs"].append({
+            "citation": m.group(1).strip(),
             "correction": m.group(2).strip(),
-            "explication": m.group(3).strip(),
+            "pourquoi": m.group(3).strip(),
         })
-    return entries
+
+    result["vocabulaire"] = _parse_bullets(_extract_section(rest, "Vocabulaire dentaire utile"))
+    result["priorite"] = _parse_bullets(_extract_section(rest, "Priorité pour la prochaine séance"))
+    result["bilan"] = _parse_bilan(rest)
+
+    return result
 
 
 def render_feedback_table(entries: list[dict]) -> list[list[str]]:
-    return [[e["disse"], e["correction"], e["explication"]] for e in entries]
+    """Convert error entries to table rows for the frontend."""
+    return [[e["citation"], e["correction"], e["pourquoi"]] for e in entries]
 
 
 def strip_markdown(text: str) -> str:
@@ -27,6 +125,6 @@ def strip_markdown(text: str) -> str:
     text = re.sub(r"#{1,6}\s*", "", text)
     text = re.sub(r"^[-*]\s", "", text, flags=re.MULTILINE)
     text = re.sub(r"!?\[.*?\]\(.*?\)", "", text)
-    text = text.replace("▌", "")
-    text = text.replace("🤖", "")
+    text = text.replace("\u258c", "")
+    text = text.replace("\U0001f916", "")
     return text.strip()

prompts.py

@@ -1,26 +1,81 @@
-SYSTEM_PROMPT = """You are a virtual dental patient. The user is your dental hygienist, currently training to improve their professional French.
-
-Phase 1: Voice Roleplay
-Act as a patient undergoing a 60-minute hygiene session. The flow is: Anamnesis -> Scaling (Détartrage) -> Polishing (Polissage) -> Fluoridation.
-Let the user lead the conversation. Do not anticipate their lines.
-Keep your answers highly concise (1-2 short sentences maximum).
-Speak entirely in French.
-Vary your language skills: use Swiss-French regionalisms (septante, huitante, lolette, chanterelle).
-Incorporate natural small talk at the beginning or during pauses (weather, public transport, holidays).
-Occasionally ask administrative questions about cost or insurance coverage.
-During the scaling phase, occasionally simulate sudden pain or sensitivity ("Aïe !", "C'est sensible ici") to test their clinical response.
-NEVER break character, offer advice, or correct their French during the roleplay.
-FORMATTING: Do not use emojis, asterisks, bolding, bullet points, or any markdown. Use only plain text and standard punctuation to ensure smooth text-to-speech playback.
-Continue the roleplay until the user explicitly says: "Fin de la séance" or "Session terminée".
-
-Phase 2: Feedback & Recap (Post-Roleplay)
-Trigger this phase ONLY when the user uses one of the termination phrases above.
-Drop the patient persona and act as an expert French language tutor.
-First, respond with exactly two spoken sentences in French: encourage them, then highlight one main area of improvement regarding medical vocabulary or grammar progression.
-Then IMMEDIATELY provide a structured text response with the detailed written breakdown of their mistakes. Do NOT wait for any further prompt. List the errors clearly in plain text (not a markdown table) using this format for each mistake:
-Disse: [What they said in FR]
-Correction: [Correction in FR]
-Explication: [Explanation in FR]
-"""
-
-PHASE_SWITCH_REMINDER = """Reminder: you are now an expert French language tutor providing feedback. Do NOT continue the patient roleplay. Respond with exactly two spoken sentences in French (encouragement + one area of improvement), then immediately provide the structured Disse/Correction/Explication breakdown. Use plain text only — no markdown, no emojis."""
+SYSTEM_PROMPT = """You are a virtual dental patient in a Swiss dental hygiene appointment. The user is the hygienist and is practicing professional French.
+
+ROLEPLAY
+Stay in character until the user ends the session.
+Speak only French.
+Use plain text only.
+Let the user lead. Do not anticipate their next line.
+Answer naturally and briefly:
+- anamnesis: 1 to 2 short sentences
+- treatment: very short replies or fragments
+
+PATIENT
+At the start of each session, create one hidden patient profile and keep it consistent:
+- age
+- reason for visit
+- relevant medical history
+- dental habits
+- one mild concern
+The patient should sound realistic, cooperative, and sometimes slightly vague.
+
+REALISM
+Use light Swiss Romand French naturally.
+Use septante and nonante when relevant.
+Do not force regional words.
+Allow brief small talk at the beginning or during pauses.
+Ask at most one natural question about cost or insurance during the whole session.
+During scaling, occasionally react to sensitivity briefly, for example:
+Aïe.
+C'est sensible ici.
+Un peu plus doucement, s'il vous plaît.
+
+DO NOT
+Do not explain, teach, translate, or correct during the roleplay.
+Do not use markdown, bullets, or emojis in your replies.
+Do not become overly talkative or clinically expert as a patient.
+
+END OF SESSION
+Only stop roleplay if the user says one of these or an obvious equivalent:
+- Fin de la séance
+- Session terminée
+- On a terminé
+- C'est fini
+
+FEEDBACK MODE
+After the session ends, stop being the patient and become a French coach.
+
+First output exactly 2 short sentences in French:
+1. one encouraging sentence
+2. one sentence with the main priority for improvement
+
+Then output --- on its own line.
+
+Then give a short written recap in plain text with exactly these sections:
+
+Points forts:
+- ...
+
+À corriger:
+Citation: "..."
+Correction: ...
+Pourquoi: ...
+
+Vocabulaire dentaire utile:
+- ...
+
+Priorité pour la prochaine séance:
+- ...
+
+Bilan:
+- Grammaire: x/5
+- Fluidité: x/5
+- Vocabulaire dentaire: x/5
+- Communication clinique: x/5
+
+Only correct genuine errors or awkward wording actually produced by the user.
+If a phrase is unclear because of speech recognition, say:
+Transcription incertaine.
+Do not invent mistakes.
+Prioritize important or repeated errors over minor ones."""
+
+PHASE_SWITCH_REMINDER = """Reminder: you are now a French coach. Do NOT continue the patient roleplay. Respond with exactly 2 spoken sentences in French (encouragement + priority), then output --- on its own line, then provide the written recap with Points forts, Citation/Correction/Pourquoi, Vocabulaire dentaire utile, Priorité, and Bilan scores. Use plain text only."""

server_app.py

@@ -29,7 +29,11 @@ def api_process_turn(audio: FileData, state: dict) -> dict:
             "audio_url": None,
             "state": state,
             "feedback_intro": "",
+            "feedback_points_forts": [],
             "feedback_table": [],
+            "feedback_vocabulaire": [],
+            "feedback_priorite": [],
+            "feedback_bilan": {},
             "feedback_open": False,
             "status": f"Erreur: {e}",
         }
@@ -43,7 +47,11 @@ def api_process_turn(audio: FileData, state: dict) -> dict:
         "audio_url": audio_url,
         "state": result["state"],
         "feedback_intro": result["feedback_intro"],
+        "feedback_points_forts": result["feedback_points_forts"],
         "feedback_table": result["feedback_table"],
+        "feedback_vocabulaire": result["feedback_vocabulaire"],
+        "feedback_priorite": result["feedback_priorite"],
+        "feedback_bilan": result["feedback_bilan"],
         "feedback_open": result["feedback_open"],
         "status": result["status"],
     }
@@ -63,7 +71,11 @@ def api_end_session(state: dict) -> dict:
         "audio_url": audio_url,
         "state": result["state"],
         "feedback_intro": result["feedback_intro"],
+        "feedback_points_forts": result["feedback_points_forts"],
         "feedback_table": result["feedback_table"],
+        "feedback_vocabulaire": result["feedback_vocabulaire"],
+        "feedback_priorite": result["feedback_priorite"],
+        "feedback_bilan": result["feedback_bilan"],
         "feedback_open": result["feedback_open"],
         "status": result["status"],
     }

src/App.tsx

@@ -1,258 +0,0 @@
-import { useState, useEffect, useRef, useCallback, ReactNode } from 'react';
-import { motion, AnimatePresence } from 'motion/react';
-import { Mic, MicOff, Stethoscope, Languages, ClipboardList, Info } from 'lucide-react';
-import { GeminiLiveService } from './services/geminiLiveService';
-import { LiveServerMessage } from '@google/genai';
-
-export default function App() {
-  const [isConnected, setIsConnected] = useState(false);
-  const [isRecording, setIsRecording] = useState(false);
-  const [isSpeaking, setIsSpeaking] = useState(false);
-  const [feedbackText, setFeedbackText] = useState<string | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  
-  const liveServiceRef = useRef<GeminiLiveService | null>(null);
-  const audioContextRef = useRef<AudioContext | null>(null);
-  const audioQueueRef = useRef<Int16Array[]>([]);
-  const isPlayingRef = useRef(false);
-
-  const playNextInQueue = useCallback(async () => {
-    if (isPlayingRef.current || audioQueueRef.current.length === 0 || !audioContextRef.current) return;
-
-    isPlayingRef.current = true;
-    setIsSpeaking(true);
-
-    const pcmData = audioQueueRef.current.shift()!;
-    const buffer = audioContextRef.current.createBuffer(1, pcmData.length, 24000);
-    const channelData = buffer.getChannelData(0);
-
-    for (let i = 0; i < pcmData.length; i++) {
-      channelData[i] = pcmData[i] / 0x7FFF;
-    }
-
-    const source = audioContextRef.current.createBufferSource();
-    source.buffer = buffer;
-    source.connect(audioContextRef.current.destination);
-    
-    source.onended = () => {
-      isPlayingRef.current = false;
-      if (audioQueueRef.current.length === 0) {
-        setIsSpeaking(false);
-      }
-      playNextInQueue();
-    };
-
-    source.start();
-  }, []);
-
-  const handleMessage = useCallback((message: LiveServerMessage) => {
-    // Handle audio output
-    const base64Audio = message.serverContent?.modelTurn?.parts?.[0]?.inlineData?.data;
-    if (base64Audio) {
-      const binaryString = atob(base64Audio);
-      const len = binaryString.length;
-      const bytes = new Uint8Array(len);
-      for (let i = 0; i < len; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      const pcmData = new Int16Array(bytes.buffer);
-      audioQueueRef.current.push(pcmData);
-      
-      if (!audioContextRef.current) {
-        audioContextRef.current = new AudioContext({ sampleRate: 24000 });
-      }
-      playNextInQueue();
-    }
-
-    // Handle text output (for "Gere a tabela")
-    const text = message.serverContent?.modelTurn?.parts?.[0]?.text;
-    if (text && (text.includes('Disse:') || text.includes('Correção:'))) {
-      setFeedbackText(text);
-    }
-
-    // Handle interruption
-    if (message.serverContent?.interrupted) {
-      audioQueueRef.current = [];
-      isPlayingRef.current = false;
-      setIsSpeaking(false);
-    }
-  }, [playNextInQueue]);
-
-  const toggleConnection = async () => {
-    if (isConnected) {
-      liveServiceRef.current?.disconnect();
-      setIsConnected(false);
-      setIsRecording(false);
-      setIsSpeaking(false);
-    } else {
-      try {
-        setError(null);
-        if (!liveServiceRef.current) {
-          liveServiceRef.current = new GeminiLiveService();
-        }
-        await liveServiceRef.current.connect({
-          onOpen: () => {
-            setIsConnected(true);
-            setIsRecording(true);
-          },
-          onClose: () => {
-            setIsConnected(false);
-            setIsRecording(false);
-          },
-          onMessage: handleMessage,
-          onError: (err) => {
-            setError("Connection error. Please check your API key.");
-            setIsConnected(false);
-          },
-          onInterrupted: () => {
-            // Handled in handleMessage
-          }
-        });
-      } catch (err) {
-        setError("Failed to connect to Gemini Live.");
-      }
-    }
-  };
-
-  useEffect(() => {
-    return () => {
-      liveServiceRef.current?.disconnect();
-      audioContextRef.current?.close();
-    };
-  }, []);
-
-  return (
-    <div className="min-h-screen flex flex-col items-center justify-center p-6 relative">
-      <div className="atmosphere" />
-      
-      <header className="absolute top-8 left-8 flex items-center gap-3">
-        <div className="w-10 h-10 rounded-full bg-orange-500 flex items-center justify-center shadow-lg">
-          <Stethoscope className="text-white w-6 h-6" />
-        </div>
-        <div>
-          <h1 className="text-xl font-serif font-light tracking-wide">Français en médecine dentaire</h1>
-          <p className="text-[10px] uppercase tracking-[0.2em] text-orange-400 font-medium">Bienne, Suisse</p>
-        </div>
-      </header>
-
-      <main className="w-full max-w-2xl flex flex-col items-center gap-12">
-        <AnimatePresence mode="wait">
-          {!isConnected ? (
-            <motion.div 
-              key="start"
-              initial={{ opacity: 0, y: 20 }}
-              animate={{ opacity: 1, y: 0 }}
-              exit={{ opacity: 0, scale: 0.9 }}
-              className="text-center space-y-8"
-            >
-              <div className="space-y-4">
-                <h2 className="text-5xl font-serif font-light leading-tight">
-                  Pratiquez votre <br />
-                  <span className="italic text-orange-500">Français Dentaire</span>
-                </h2>
-                <p className="text-zinc-400 max-w-md mx-auto text-sm leading-relaxed">
-                  Entraînez-vous avec un patient virtuel suisse. 
-                  Améliorez votre vocabulaire professionnel en temps réel.
-                </p>
-              </div>
-
-              <button 
-                onClick={toggleConnection}
-                className="group relative px-12 py-4 rounded-full bg-white text-black font-medium transition-all hover:scale-105 active:scale-95 overflow-hidden"
-              >
-                <div className="absolute inset-0 bg-orange-500 translate-y-full group-hover:translate-y-0 transition-transform duration-300" />
-                <span className="relative z-10 flex items-center gap-2 group-hover:text-white transition-colors">
-                  Commencer la séance
-                </span>
-              </button>
-              
-              {error && <p className="text-red-400 text-xs mt-4">{error}</p>}
-            </motion.div>
-          ) : (
-            <motion.div 
-              key="active"
-              initial={{ opacity: 0, scale: 0.9 }}
-              animate={{ opacity: 1, scale: 1 }}
-              className="w-full flex flex-col items-center gap-12"
-            >
-              <div className="relative">
-                <div className={`w-48 h-48 rounded-full flex items-center justify-center glass-card transition-all duration-500 ${isRecording ? 'recording-glow' : ''}`}>
-                  {isSpeaking ? (
-                    <div className="speaking-wave">
-                      {[1, 2, 3, 4, 5].map((i) => (
-                        <motion.div 
-                          key={i}
-                          className="wave-bar"
-                          animate={{ height: [10, 40, 10] }}
-                          transition={{ repeat: Infinity, duration: 0.8, delay: i * 0.1 }}
-                        />
-                      ))}
-                    </div>
-                  ) : (
-                    <Mic className={`w-12 h-12 ${isRecording ? 'text-orange-500' : 'text-zinc-500'}`} />
-                  )}
-                </div>
-                
-                <div className="absolute -bottom-4 left-1/2 -translate-x-1/2 px-4 py-1 rounded-full bg-black/50 backdrop-blur-md border border-white/10 text-[10px] uppercase tracking-widest">
-                  {isSpeaking ? 'Le patient parle...' : 'À vous de parler'}
-                </div>
-              </div>
-
-              <div className="grid grid-cols-3 gap-4 w-full">
-                <StatusCard icon={<Languages size={16} />} label="Langue" value="Français (CH)" />
-                <StatusCard icon={<ClipboardList size={16} />} label="Phase" value="Roleplay" />
-                <StatusCard icon={<Info size={16} />} label="Lieu" value="Bienne, BE" />
-              </div>
-
-              <button 
-                onClick={toggleConnection}
-                className="flex items-center gap-2 text-zinc-500 hover:text-red-400 transition-colors text-sm uppercase tracking-widest"
-              >
-                <MicOff size={16} />
-                Terminer la connexion
-              </button>
-            </motion.div>
-          )}
-        </AnimatePresence>
-
-        <AnimatePresence>
-          {feedbackText && (
-            <motion.div 
-              initial={{ opacity: 0, y: 40 }}
-              animate={{ opacity: 1, y: 0 }}
-              className="w-full glass-card rounded-3xl p-8 space-y-6 max-h-[400px] overflow-y-auto custom-scrollbar"
-            >
-              <div className="flex items-center justify-between border-b border-white/10 pb-4">
-                <h3 className="font-serif text-xl italic">Récapitulatif de la séance</h3>
-                <button 
-                  onClick={() => setFeedbackText(null)}
-                  className="text-zinc-500 hover:text-white"
-                >
-                  Fermer
-                </button>
-              </div>
-              <div className="whitespace-pre-wrap font-mono text-sm text-zinc-300 leading-relaxed">
-                {feedbackText}
-              </div>
-            </motion.div>
-          )}
-        </AnimatePresence>
-      </main>
-
-      <footer className="absolute bottom-8 text-[10px] text-zinc-600 uppercase tracking-[0.3em]">
-        Interactive Voice Training System &copy; 2026
-      </footer>
-    </div>
-  );
-}
-
-function StatusCard({ icon, label, value }: { icon: ReactNode, label: string, value: string }) {
-  return (
-    <div className="glass-card rounded-2xl p-4 flex flex-col gap-1 items-center text-center">
-      <div className="text-orange-500 mb-1">{icon}</div>
-      <span className="text-[9px] uppercase tracking-wider text-zinc-500">{label}</span>
-      <span className="text-xs font-medium">{value}</span>
-    </div>
-  );
-}
-

src/index.css

@@ -1,76 +0,0 @@
-@import "tailwindcss";
-
-@theme {
-  --font-sans: "Inter", ui-sans-serif, system-ui, sans-serif;
-  --font-serif: "Cormorant Garamond", serif;
-}
-
-:root {
-  --color-bg: #0a0502;
-  --color-accent: #ff4e00;
-  --glass-surface: rgba(255, 80, 20, 0.1);
-  --glass-border: rgba(255, 200, 150, 0.1);
-}
-
-body {
-  background-color: var(--color-bg);
-  color: #fff;
-  overflow: hidden;
-}
-
-.atmosphere {
-  position: fixed;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-  background: 
-    radial-gradient(circle at 50% 30%, #3a1510 0%, transparent 60%),
-    radial-gradient(circle at 10% 80%, var(--color-accent) 0%, transparent 50%);
-  filter: blur(80px);
-  opacity: 0.6;
-  z-index: -1;
-  animation: pulse 15s ease-in-out infinite alternate;
-}
-
-@keyframes pulse {
-  0% { opacity: 0.4; transform: scale(1); }
-  100% { opacity: 0.7; transform: scale(1.1); }
-}
-
-.glass-card {
-  background: var(--glass-surface);
-  backdrop-filter: blur(40px);
-  border: 1px solid var(--glass-border);
-  box-shadow: 0 20px 50px rgba(0, 0, 0, 0.3);
-}
-
-.recording-glow {
-  box-shadow: 0 0 20px rgba(255, 78, 0, 0.5);
-  animation: glow 1.5s ease-in-out infinite alternate;
-}
-
-@keyframes glow {
-  0% { box-shadow: 0 0 10px rgba(255, 78, 0, 0.3); }
-  100% { box-shadow: 0 0 30px rgba(255, 78, 0, 0.8); }
-}
-
-.speaking-wave {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-}
-
-.wave-bar {
-  width: 3px;
-  height: 10px;
-  background: var(--color-accent);
-  border-radius: 2px;
-  animation: wave 1s ease-in-out infinite;
-}
-
-@keyframes wave {
-  0%, 100% { height: 10px; }
-  50% { height: 30px; }
-}
-

src/main.tsx

@@ -1,10 +0,0 @@
-import {StrictMode} from 'react';
-import {createRoot} from 'react-dom/client';
-import App from './App.tsx';
-import './index.css';
-
-createRoot(document.getElementById('root')!).render(
-  <StrictMode>
-    <App />
-  </StrictMode>,
-);

src/services/geminiLiveService.ts

@@ -1,160 +0,0 @@
-import { GoogleGenAI, LiveServerMessage, Modality } from "@google/genai";
-
-export enum AppPhase {
-  ROLEPLAY = 'roleplay',
-  FEEDBACK = 'feedback'
-}
-
-export interface LiveSessionCallbacks {
-  onOpen?: () => void;
-  onClose?: () => void;
-  onMessage?: (message: LiveServerMessage) => void;
-  onError?: (error: any) => void;
-  onInterrupted?: () => void;
-}
-
-export class GeminiLiveService {
-  private ai: GoogleGenAI;
-  private session: any = null;
-  private audioContext: AudioContext | null = null;
-  private workletNode: AudioWorkletNode | null = null;
-  private stream: MediaStream | null = null;
-
-  constructor() {
-    this.ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
-  }
-
-  async connect(callbacks: LiveSessionCallbacks) {
-    const systemInstruction = `
-You are a virtual dental patient in a Swiss clinic (Bienne, Canton de Berne). The user is your dental hygienist, a native Brazilian Portuguese speaker currently at a B1 French level, training to improve her professional French.
-
-Your behavior is divided into two strict phases: Phase 1 (Roleplay) and Phase 2 (Feedback).
-
-Phase 1: Voice Roleplay
-Act as a patient undergoing a 60-minute hygiene session. The flow is: Anamnesis -> Scaling (Détartrage) -> Polishing (Polissage) -> Fluoridation.
-Let the user lead the conversation. Do not anticipate her lines.
-Keep your answers highly concise (1-2 short sentences maximum).
-Speak entirely in French.
-Vary your language skills: use Swiss-French regionalisms (e.g., septante, huitante, lolette, chanterelle). As Bienne is bilingual, occasionally drop in a basic Swiss-German greeting or loanword (e.g., "Grüessech", "Merci vielmal").
-Incorporate natural small talk at the beginning or during pauses (e.g., weather, CFF/SBB trains, holidays).
-Occasionally ask administrative questions, such as the estimated cost in CHF or if the treatment is covered by basic health insurance (assurance de base / LAMal).
-During the scaling phase, occasionally simulate sudden pain or sensitivity (e.g., "Aïe !", "C'est sensible ici") to test her clinical response.
-NEVER break character, offer advice, or correct her French during the roleplay.
-FORMATTING: Do not use emojis, asterisks, bolding, bullet points, or any markdown. Use only plain text and standard punctuation to ensure smooth text-to-speech playback.
-Continue the roleplay until the user explicitly says: "Fin de la séance", "Fim da consulta", "Fim da sessão" or "Session terminée".
-
-Phase 2: Feedback & Recap (Post-Roleplay)
-Trigger this phase ONLY when the user uses one of the termination phrases above.
-Drop the patient persona and act as an expert French language tutor.
-Respond with exactly two spoken sentences in Brazilian Portuguese: First, encourage her. Second, highlight one main area of improvement regarding her medical vocabulary or B1-to-B2 grammar progression.
-Conclude by asking her to say "Gere a tabela" if she wants to see a detailed written breakdown of her mistakes.
-
-If the user says "Gere a tabela", provide a structured text response. List the errors clearly in plain text (not a markdown table) using this format for each mistake:
-Disse: [What she said in FR]
-Correção: [Correction in FR]
-Explicação: [Explanation in PT-BR]
-    `.trim();
-
-    this.session = await this.ai.live.connect({
-      model: "gemini-2.5-flash-native-audio-preview-12-2025",
-      config: {
-        systemInstruction,
-        responseModalities: [Modality.AUDIO],
-        speechConfig: {
-          voiceConfig: { prebuiltVoiceConfig: { voiceName: "Zephyr" } },
-        },
-      },
-      callbacks: {
-        onopen: () => {
-          console.log("Live session opened");
-          callbacks.onOpen?.();
-          this.startAudioCapture();
-        },
-        onmessage: (message: LiveServerMessage) => {
-          if (message.serverContent?.interrupted) {
-            callbacks.onInterrupted?.();
-          }
-          callbacks.onMessage?.(message);
-        },
-        onclose: () => {
-          console.log("Live session closed");
-          callbacks.onClose?.();
-          this.stopAudioCapture();
-        },
-        onerror: (error) => {
-          console.error("Live session error:", error);
-          callbacks.onError?.(error);
-        },
-      },
-    });
-  }
-
-  private async startAudioCapture() {
-    try {
-      this.audioContext = new AudioContext({ sampleRate: 16000 });
-      this.stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-      const source = this.audioContext.createMediaStreamSource(this.stream);
-
-      // We need an AudioWorklet to handle raw PCM data
-      await this.audioContext.audioWorklet.addModule(this.getWorkletUrl());
-      this.workletNode = new AudioWorkletNode(this.audioContext, 'input-processor');
-
-      this.workletNode.port.onmessage = (event) => {
-        if (this.session && event.data) {
-          const base64Data = this.arrayBufferToBase64(event.data);
-          this.session.sendRealtimeInput({
-            audio: { data: base64Data, mimeType: 'audio/pcm;rate=16000' }
-          });
-        }
-      };
-
-      source.connect(this.workletNode);
-    } catch (err) {
-      console.error("Error starting audio capture:", err);
-    }
-  }
-
-  private stopAudioCapture() {
-    this.stream?.getTracks().forEach(track => track.stop());
-    this.workletNode?.disconnect();
-    this.audioContext?.close();
-  }
-
-  private arrayBufferToBase64(buffer: ArrayBuffer): string {
-    let binary = '';
-    const bytes = new Uint8Array(buffer);
-    const len = bytes.byteLength;
-    for (let i = 0; i < len; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-
-  private getWorkletUrl(): string {
-    const code = `
-      class InputProcessor extends AudioWorkletProcessor {
-        process(inputs, outputs, parameters) {
-          const input = inputs[0];
-          if (input.length > 0) {
-            const channelData = input[0];
-            // Convert Float32 to Int16
-            const pcmData = new Int16Array(channelData.length);
-            for (let i = 0; i < channelData.length; i++) {
-              pcmData[i] = Math.max(-1, Math.min(1, channelData[i])) * 0x7FFF;
-            }
-            this.port.postMessage(pcmData.buffer);
-          }
-          return true;
-        }
-      }
-      registerProcessor('input-processor', InputProcessor);
-    `;
-    const blob = new Blob([code], { type: 'application/javascript' });
-    return URL.createObjectURL(blob);
-  }
-
-  disconnect() {
-    this.session?.close();
-    this.stopAudioCapture();
-  }
-}