feat: Geräte-TTS, native Stimmen, Favicon, Auth-Gate, UI-Fixes

Web-UI / TTS:
- Geräte-TTS ("📱 Gerät"): Antwort wird on-device vorgelesen (Web Speech
  API), Server sendet nur Text (text_only) -> spart Bandbreite/Kosten.
  Mobil-Default, geräte-lokale Speicherung, iOS-Autoplay-Freischaltung.
- Vorlese-Symbol (🔊) je Bubble: Hybrid-Replay (Assistent-PCM gecacht,
  Eingabe via /api/speak); SVG-Icon mit kontrastreicher Farbe.
- Kombiniertes Sprachmenü (Flex + feste Sprachen) statt separatem Modus-Menü.
- "Neues Gespräch"-Button (frische Session gegen Sprach-Trägheit).
- Dark-Mode: lesbare <option>-Popups (Kontrast-Fix).
- Favicon (SVG + PNG-Fallbacks) aus mund.png.

TTS-Backend:
- Sprache wird an alle TTS-Provider durchgereicht; Piper-Stimme folgt der
  Sprache; Chatterbox mehrsprachig + cross-lingual.
- Native Referenz-Stimmen je Sprache (config/voices/<lang>.wav, FLEURS CC-BY),
  loudness-normalisiert.

LLM-Sprache:
- Antwort folgt zuverlässig der gewählten Sprache (verstärkte Anweisung +
  Erinnerung an der letzten Nutzer-Nachricht gegen History-Trägheit).

Admin / Auth:
- Wörterbuch: alle 8 Sprachen, Zeilen editierbar, alphabetische Sortierung.
- Web-UI hinter Auth-Gate (Redirect auf SSO_LOGIN_URL / 401); Favicons offen.
- Log-Tab: Hinweis, wenn der systemd-Dienst nicht aktiv ist.
- Einstellungen: Hinweis "pro Nutzer überschreibbar" bei Sprache/Modus/Qualität.

Doku (BEDIENUNGSANLEITUNG.md): Geräte-TTS §6.5.0, Fix/Flex §6.6, native
Stimmen §6.5.3, llama.cpp<->Ollama-Wechsel §4.7, Auth/SSO §7.4.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

app/providers/fallback.py

@@ -35,6 +35,19 @@ class FallbackSTTProvider(_Chain):
                 self._on_error(name)
         raise last_exc
 
+    async def transcribe_detect(self, audio_bytes, fmt, language=None) -> tuple[str, str | None]:
+        last_exc = None
+        for index, (name, provider) in enumerate(self.entries):
+            try:
+                result = await provider.transcribe_detect(audio_bytes, fmt, language=language)
+                if index > 0:
+                    self._on_fallback()
+                return result
+            except Exception as exc:  # noqa: BLE001
+                last_exc = exc
+                self._on_error(name)
+        raise last_exc
+
 
 class FallbackLLMProvider(_Chain):
     async def complete(self, text, history=None, session_id=None, language=None) -> str:
@@ -75,11 +88,13 @@ class FallbackLLMProvider(_Chain):
 
 
 class FallbackTTSProvider(_Chain):
-    async def synthesize(self, text, voice=None, audio_format="pcm") -> bytes:
+    async def synthesize(self, text, voice=None, audio_format="pcm", language=None) -> bytes:
         last_exc = None
         for index, (name, provider) in enumerate(self.entries):
             try:
-                result = await provider.synthesize(text, voice=voice, audio_format=audio_format)
+                result = await provider.synthesize(
+                    text, voice=voice, audio_format=audio_format, language=language
+                )
                 if index > 0:
                     self._on_fallback()
                 return result

app/providers/llm/base.py

@@ -16,11 +16,28 @@ _LANG_NAMES: dict[str, str] = {
 
 
 def lang_instruction(language: str | None) -> str | None:
-    """'Respond in X.' instruction for the given ISO language code, or None."""
+    """Sprach-Anweisung für den ISO-Code, oder None.
+
+    Bewusst nachdrücklich formuliert: Eine lange anderssprachige History (z. B. der
+    Nutzer hat zwischendurch englisch gesprochen) soll die gewünschte Sprache NICHT
+    überstimmen. Wird zusätzlich nah an die Generierung gesetzt (siehe with_lang_reminder).
+    """
     if not language:
         return None
     name = _LANG_NAMES.get(language, language)
-    return f"Respond in {name}."
+    return f"Respond ONLY in {name}, regardless of the language used earlier in this conversation."
+
+
+def with_lang_reminder(text: str, language: str | None) -> str:
+    """Hängt eine knappe Sprach-Erinnerung an die letzte Nutzer-Nachricht.
+
+    Direkt vor der Generierung platziert wirkt sie stärker als der (weit zurückliegende)
+    System-Prompt, wenn die bisherige Unterhaltung in einer anderen Sprache lief.
+    """
+    if not language:
+        return text
+    name = _LANG_NAMES.get(language, language)
+    return f"{text}\n\n[Bitte ausschließlich auf {name} antworten.]"
 
 
 def sse_delta(line: str) -> str | None:

app/providers/llm/local_openai_compatible.py

@@ -2,7 +2,12 @@ from collections.abc import AsyncIterator
 
 import httpx
 
-from app.providers.llm.base import LLMProvider, lang_instruction, sse_delta
+from app.providers.llm.base import (
+    LLMProvider,
+    lang_instruction,
+    with_lang_reminder,
+    sse_delta,
+)
 
 
 class LocalOpenAICompatibleLLM(LLMProvider):
@@ -50,7 +55,8 @@ class LocalOpenAICompatibleLLM(LLMProvider):
         if system_parts:
             messages.append({"role": "system", "content": "\n\n".join(system_parts)})
         messages.extend(rest)
-        messages.append({"role": "user", "content": text})
+        # Sprach-Erinnerung direkt an der letzten Nutzer-Nachricht (schlägt History-Trägheit).
+        messages.append({"role": "user", "content": with_lang_reminder(text, language)})
         return messages
 
     def _payload(

app/providers/llm/openrouter.py

@@ -2,7 +2,12 @@ from collections.abc import AsyncIterator
 
 import httpx
 
-from app.providers.llm.base import LLMProvider, lang_instruction, sse_delta
+from app.providers.llm.base import (
+    LLMProvider,
+    lang_instruction,
+    with_lang_reminder,
+    sse_delta,
+)
 
 
 SYSTEM_PROMPT = """
@@ -69,7 +74,8 @@ class OpenRouterLLMProvider(LLMProvider):
         messages = [{"role": "system", "content": system_content}]
         if history:
             messages.extend(history)
-        messages.append({"role": "user", "content": text.strip()})
+        # Sprach-Erinnerung direkt an der letzten Nutzer-Nachricht (schlägt History-Trägheit).
+        messages.append({"role": "user", "content": with_lang_reminder(text.strip(), language)})
         return messages
 
     async def complete(

app/providers/stt/base.py

@@ -1,5 +1,17 @@
 from abc import ABC, abstractmethod
 
+
 class STTProvider(ABC):
     @abstractmethod
     async def transcribe(self, audio_bytes: bytes, fmt: str, language: str | None = None) -> str: ...
+
+    async def transcribe_detect(
+        self, audio_bytes: bytes, fmt: str, language: str | None = None
+    ) -> tuple[str, str | None]:
+        """Transkribiert und liefert (text, detected_language).
+
+        Standardimplementierung delegiert an transcribe(); detected_language=None.
+        Provider mit Spracherkennung überschreiben diese Methode.
+        """
+        text = await self.transcribe(audio_bytes, fmt, language=language)
+        return text, None

app/providers/stt/faster_whisper.py

@@ -38,12 +38,24 @@ class FasterWhisperProvider(STTProvider):
         self.device = device or settings.faster_whisper_device
         self.compute_type = compute_type or settings.faster_whisper_compute_type
 
-    def _transcribe_sync(self, audio_bytes: bytes, language: str | None) -> str:
+    def _transcribe_sync(
+        self, audio_bytes: bytes, language: str | None
+    ) -> tuple[str, str | None]:
         model = _load_model(self.model_size, self.device, self.compute_type)
-        segments, _info = model.transcribe(io.BytesIO(audio_bytes), language=language)
-        return "".join(segment.text for segment in segments).strip()
+        segments, info = model.transcribe(io.BytesIO(audio_bytes), language=language)
+        text = "".join(segment.text for segment in segments).strip()
+        detected = getattr(info, "language", None)
+        return text, detected
 
     async def transcribe(self, audio_bytes: bytes, fmt: str, language: str | None = None) -> str:
+        if not audio_bytes:
+            raise ValueError("STT input audio is empty")
+        text, _ = await asyncio.to_thread(self._transcribe_sync, audio_bytes, language)
+        return text
+
+    async def transcribe_detect(
+        self, audio_bytes: bytes, fmt: str, language: str | None = None
+    ) -> tuple[str, str | None]:
         if not audio_bytes:
             raise ValueError("STT input audio is empty")
         return await asyncio.to_thread(self._transcribe_sync, audio_bytes, language)

app/providers/stt/openrouter.py

@@ -52,4 +52,48 @@ class OpenRouterSTTProvider(STTProvider):
             except httpx.HTTPError as exc:
                 raise RuntimeError(f"OpenRouter STT transport error: {exc}") from exc
 
-        return response.json().get("text", "")
+        data = response.json()
+        return data.get("text", "")
+
+    async def transcribe_detect(
+        self, audio_bytes: bytes, fmt: str, language: str | None = None
+    ) -> tuple[str, str | None]:
+        if not self.api_key:
+            raise ValueError("OPENROUTER_API_KEY is empty")
+        if not self.model:
+            raise ValueError("OPENROUTER_STT_MODEL is empty")
+        if not audio_bytes:
+            raise ValueError("STT input audio is empty")
+
+        payload = {
+            "model": self.model,
+            "input_audio": {
+                "data": base64.b64encode(audio_bytes).decode("utf-8"),
+                "format": fmt,
+            },
+        }
+        if language:
+            payload["language"] = language
+
+        timeout = httpx.Timeout(connect=10.0, read=120.0, write=30.0, pool=10.0)
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            try:
+                response = await client.post(
+                    "https://openrouter.ai/api/v1/audio/transcriptions",
+                    headers={
+                        "Authorization": f"Bearer {self.api_key}",
+                        "Content-Type": "application/json",
+                    },
+                    json=payload,
+                )
+                response.raise_for_status()
+            except httpx.HTTPStatusError as exc:
+                raise RuntimeError(
+                    f"OpenRouter STT error {exc.response.status_code}: {exc.response.text}"
+                ) from exc
+            except httpx.TimeoutException as exc:
+                raise RuntimeError("OpenRouter STT timeout") from exc
+            except httpx.HTTPError as exc:
+                raise RuntimeError(f"OpenRouter STT transport error: {exc}") from exc
+        data = response.json()
+        return data.get("text", ""), data.get("language")

app/providers/tts/base.py

@@ -2,4 +2,10 @@ from abc import ABC, abstractmethod
 
 class TTSProvider(ABC):
     @abstractmethod
-    async def synthesize(self, text: str, voice: str | None = None, audio_format: str = "pcm") -> bytes: ...
+    async def synthesize(
+        self,
+        text: str,
+        voice: str | None = None,
+        audio_format: str = "pcm",
+        language: str | None = None,
+    ) -> bytes: ...

app/providers/tts/chatterbox.py

@@ -15,6 +15,7 @@ import asyncio
 import io
 import time
 import wave
+from pathlib import Path
 
 import httpx
 
@@ -31,6 +32,7 @@ class ChatterboxTTSProvider(TTSProvider):
         speed: float = 1.0,
         target_rate: int = 24000,
         timeout: int = 180,
+        voices_dir: str = "",
     ):
         self.base_url = base_url.rstrip("/")
         self.voice = (voice or "").strip()  # Pfad zu Referenz-WAV (Voice-Cloning) oder leer
@@ -38,32 +40,51 @@ class ChatterboxTTSProvider(TTSProvider):
         self.speed = speed
         self.target_rate = int(target_rate)
         self.timeout = timeout
+        # Absolut auflösen: der Chatterbox-Dienst liest den Pfad mit eigenem CWD.
+        self.voices_dir = Path(voices_dir).expanduser().resolve() if voices_dir else None
 
-    def _ref_voice(self, voice: str | None) -> str | None:
-        # Eine angefragte Stimme gilt nur, wenn sie wie ein WAV-Pfad aussieht
-        # (Cloud-Stimmennamen wie "Zephyr"/"alloy" ignorieren -> Default nehmen).
+    def _lang_ref(self, lang: str) -> str | None:
+        """Native Referenz-WAV der Sprache (Konvention <voices_dir>/<lang>.wav), falls vorhanden."""
+        if not self.voices_dir:
+            return None
+        path = self.voices_dir / f"{lang}.wav"
+        return str(path) if path.exists() else None
+
+    def _ref_voice(self, voice: str | None, lang: str) -> str | None:
+        # 1. Explizit angefragte Stimme nur, wenn sie wie ein WAV-Pfad aussieht
+        #    (Cloud-Stimmennamen wie "Zephyr"/"alloy" ignorieren).
         cand = (voice or "").strip()
         if cand.endswith(".wav"):
             return cand
-        return self.voice or None
+        # 2. Native Stimme der jeweiligen Sprache, sonst die konfigurierte Default-Stimme.
+        return self._lang_ref(lang) or self.voice or None
+
+    # Chatterbox ist mehrsprachig und klont die Stimme cross-lingual: die Referenz-WAV
+    # liefert das Timbre, `lang` die Aussprache. So spricht die Klon-Stimme jede Sprache.
+    _LANG_ALIASES = {"cmn": "zh"}
 
     async def synthesize(
         self,
         text: str,
         voice: str | None = None,
         audio_format: str = "pcm",
+        language: str | None = None,
     ) -> bytes:
         if not text or not text.strip():
             raise ValueError("TTS input text is empty")
 
+        # Gesprächssprache bevorzugen; ohne Angabe der konfigurierte Default.
+        lang = (language or self.lang or "de").strip()
+        lang = self._LANG_ALIASES.get(lang, lang)
+
         payload = {
             "text": text.strip(),
-            "lang": self.lang,
+            "lang": lang,
             "speed": self.speed,
             "keep_audio": True,
             "no_playback": True,
         }
-        ref = self._ref_voice(voice)
+        ref = self._ref_voice(voice, lang)
         if ref:
             payload["voice"] = ref
 

app/providers/tts/openrouter.py

@@ -21,6 +21,7 @@ class OpenRouterTTSProvider(TTSProvider):
         text: str,
         voice: str | None = None,
         audio_format: str = "pcm",
+        language: str | None = None,  # Cloud-TTS steuert Sprache über Stimme/Modell
     ) -> bytes:
         if not self.api_key:
             raise ValueError("OPENROUTER_API_KEY is empty")

app/providers/tts/piper.py

@@ -109,6 +109,7 @@ class PiperTTSProvider(TTSProvider):
         text: str,
         voice: str | None = None,
         audio_format: str = "pcm",
+        language: str | None = None,  # ignoriert: die Piper-Stimme kodiert die Sprache
     ) -> bytes:
         if not text or not text.strip():
             raise ValueError("TTS input text is empty")