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>
This commit is contained in:
Dieter Schlüter
parent
dc8ac80505
commit
878bf785dd
51 changed files with 985 additions and 202 deletions
|
|
@ -16,7 +16,7 @@ router = APIRouter()
|
|||
|
||||
_CONFIG_DIR = Path(__file__).resolve().parents[2] / "config"
|
||||
_ALLOWED_SECTIONS = {"abbreviations", "units", "terms"}
|
||||
_ALLOWED_LANGS = {"de", "en"}
|
||||
_ALLOWED_LANGS = {"de", "en", "fr", "es", "it", "nl", "ru", "zh"}
|
||||
|
||||
|
||||
class PronunciationEntry(BaseModel):
|
||||
|
|
@ -231,6 +231,10 @@ async def add_pronunciation(lang: str, entry: PronunciationEntry):
|
|||
raise HTTPException(status_code=422, detail="key und value duerfen nicht leer sein.")
|
||||
data = _read_pronunciation(lang)
|
||||
data[entry.section][entry.key.strip()] = entry.value.strip()
|
||||
# Nach jedem Einfügen: Sektion alphabetisch aufsteigend nach Schlüssel sortieren.
|
||||
data[entry.section] = dict(
|
||||
sorted(data[entry.section].items(), key=lambda kv: kv[0].lower())
|
||||
)
|
||||
_write_pronunciation(lang, data)
|
||||
return {"section": entry.section, "key": entry.key.strip(), "value": entry.value.strip()}
|
||||
|
||||
|
|
@ -314,6 +318,26 @@ async def admin_log_ws(websocket: WebSocket, key: str | None = None):
|
|||
return
|
||||
|
||||
await websocket.accept()
|
||||
|
||||
# Hinweis, falls die laufende Instanz NICHT der systemd-Dienst ist (z. B. manueller
|
||||
# `uvicorn --reload`-Start). Dann hat das Journal dieser Unit keine aktuellen Zeilen,
|
||||
# und der Log-Tab bliebe sonst kommentarlos leer.
|
||||
try:
|
||||
check = await asyncio.create_subprocess_exec(
|
||||
"systemctl", "--user", "is-active", "voice-assistant.service",
|
||||
stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
|
||||
)
|
||||
out, _ = await check.communicate()
|
||||
if out.decode().strip() != "active":
|
||||
await websocket.send_text(
|
||||
"⚠ Der systemd-Dienst 'voice-assistant.service' ist nicht aktiv — "
|
||||
"die laufende Instanz wurde vermutlich manuell gestartet (uvicorn --reload). "
|
||||
"Live-Logs erscheinen hier nur, wenn das Gateway als Dienst läuft "
|
||||
"(systemctl --user start voice-assistant.service). Manuelle Starts loggen ins Terminal."
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
proc = await asyncio.create_subprocess_exec(
|
||||
"journalctl", "--user", "-f", "-u", "voice-assistant.service",
|
||||
"-n", "100", "--no-pager", "-o", "short",
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ from app.dependencies import (
|
|||
build_orchestrator,
|
||||
resolve_output_endpoint,
|
||||
get_store,
|
||||
piper_voice_for_language,
|
||||
)
|
||||
from app.core.memory_extractor import maybe_schedule_extraction
|
||||
from app.quota import enforce_quota, record_usage, QuotaExceededError
|
||||
|
|
@ -48,13 +49,11 @@ async def chat(
|
|||
"input_endpoint": payload.input_endpoint,
|
||||
"output_endpoint": payload.output_endpoint,
|
||||
"language": payload.language,
|
||||
"language_mode": payload.language_mode,
|
||||
"stt_provider": payload.stt_provider,
|
||||
"llm_provider": payload.llm_provider,
|
||||
"tts_provider": payload.tts_provider,
|
||||
}
|
||||
# None -> der gewaehlte TTS-Provider nimmt seinen eigenen Default.
|
||||
voice = payload.voice
|
||||
|
||||
store = get_store()
|
||||
|
||||
try:
|
||||
|
|
@ -96,6 +95,9 @@ async def chat(
|
|||
except QuotaExceededError as exc:
|
||||
raise HTTPException(status_code=429, detail=str(exc))
|
||||
|
||||
# Explizit angeforderte Stimme gewinnt; sonst folgt sie der Routensprache.
|
||||
voice = payload.voice or piper_voice_for_language(route.tts_provider, route.language)
|
||||
|
||||
try:
|
||||
trace, audio = await orchestrator.chat_text(
|
||||
payload.text,
|
||||
|
|
@ -103,6 +105,8 @@ async def chat(
|
|||
voice=voice,
|
||||
output=output,
|
||||
history=llm_context,
|
||||
language_mode=route.language_mode,
|
||||
text_only=bool(payload.text_only),
|
||||
)
|
||||
except Exception as exc:
|
||||
raise HTTPException(status_code=502, detail=str(exc))
|
||||
|
|
|
|||
|
|
@ -23,9 +23,10 @@ async def get_me(user: User = Depends(require_user)):
|
|||
|
||||
@router.put("/me/prefs")
|
||||
async def set_my_prefs(payload: UserPrefs, user: User = Depends(require_user)):
|
||||
"""Setzt die dauerhaften Routing-Praeferenzen des Nutzers (nur gesetzte Felder)."""
|
||||
prefs = {k: v for k, v in payload.model_dump().items() if v is not None}
|
||||
updated = get_store().set_user_prefs(user.id, prefs)
|
||||
"""Setzt dauerhafter Routing-Präferenzen des Nutzers. Merge mit bestehenden Prefs."""
|
||||
new = {k: v for k, v in payload.model_dump().items() if v is not None}
|
||||
merged = {**user.prefs, **new}
|
||||
updated = get_store().set_user_prefs(user.id, merged)
|
||||
return {"user_id": updated.id, "prefs": updated.prefs}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ from app.dependencies import (
|
|||
build_orchestrator,
|
||||
resolve_output_endpoint,
|
||||
get_store,
|
||||
piper_voice_for_language,
|
||||
)
|
||||
from app.quota import enforce_quota, record_usage, QuotaExceededError
|
||||
from app.schemas import SpeakRequest
|
||||
|
|
@ -32,11 +33,10 @@ async def speak(
|
|||
"language": payload.language,
|
||||
"tts_provider": payload.tts_provider,
|
||||
}
|
||||
# None -> der gewaehlte TTS-Provider nimmt seinen eigenen Default.
|
||||
voice = payload.voice
|
||||
|
||||
try:
|
||||
route = resolve_route(user, session_id, overrides)
|
||||
# Explizit angefragte Stimme gewinnt; sonst folgt sie der Sprache (Piper-Parität zu /chat).
|
||||
voice = payload.voice or piper_voice_for_language(route.tts_provider, route.language)
|
||||
orchestrator = build_orchestrator(route)
|
||||
output = await resolve_output_endpoint(route)
|
||||
except SessionOwnershipError as exc:
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ from app.dependencies import (
|
|||
resolve_route,
|
||||
build_orchestrator,
|
||||
resolve_output_endpoint,
|
||||
piper_voice_for_language,
|
||||
)
|
||||
from app.store import ANONYMOUS_USER_ID, SessionOwnershipError
|
||||
from app.audio.vad import EnergyVAD
|
||||
|
|
@ -40,6 +41,7 @@ _OVERRIDE_KEYS = (
|
|||
"input_endpoint",
|
||||
"output_endpoint",
|
||||
"language",
|
||||
"language_mode",
|
||||
"stt_provider",
|
||||
"llm_provider",
|
||||
"tts_provider",
|
||||
|
|
@ -62,7 +64,10 @@ async def _resolve(user, session_id, options):
|
|||
return route, orchestrator, output
|
||||
|
||||
|
||||
async def _run_turn(websocket, store, user, session_id, route, orchestrator, output, text, options):
|
||||
async def _run_turn(
|
||||
websocket, store, user, session_id, route, orchestrator, output, text, options,
|
||||
detected_language: str | None = None, effective_voice: str | None = None,
|
||||
):
|
||||
"""Faehrt einen Antwort-Turn und streamt die Events an den Client."""
|
||||
conversation = (
|
||||
store.get_recent_messages(session_id, settings.history_max_messages)
|
||||
|
|
@ -108,13 +113,24 @@ async def _run_turn(websocket, store, user, session_id, route, orchestrator, out
|
|||
|
||||
await websocket.send_json({"type": "ack", "route": route.as_dict()})
|
||||
|
||||
# Ohne explizite Stimme None lassen -> jeder TTS-Provider nimmt SEINEN Default
|
||||
# (OpenRouter: OPENROUTER_TTS_VOICE, piper: PIPER_VOICE).
|
||||
voice = options.get("voice")
|
||||
# Stimme: explizit angeforderte gewinnt, sonst die vom Caller (Sprach-Turn)
|
||||
# vorberechnete sprachpassende Stimme, sonst folgt sie der Routensprache
|
||||
# (greift v. a. beim Text-Chat ohne Spracherkennung).
|
||||
explicit_voice = options.get("voice")
|
||||
if explicit_voice:
|
||||
voice = explicit_voice
|
||||
elif effective_voice is not None:
|
||||
voice = effective_voice
|
||||
else:
|
||||
voice = piper_voice_for_language(route.tts_provider, route.language)
|
||||
stream = bool(options.get("stream"))
|
||||
# text_only: Geräte-TTS (Web Speech API) spricht selbst -> kein Server-Audio erzeugen/senden.
|
||||
text_only = bool(options.get("text_only"))
|
||||
# audio_stream: explizite Anfrage gewinnt, sonst der serverseitige Default (Admin).
|
||||
audio_stream = bool(options["audio_stream"]) if "audio_stream" in options \
|
||||
audio_stream = False if text_only else (
|
||||
bool(options["audio_stream"]) if "audio_stream" in options
|
||||
else settings.audio_stream_default
|
||||
)
|
||||
|
||||
on_token = None
|
||||
if stream:
|
||||
|
|
@ -141,6 +157,9 @@ async def _run_turn(websocket, store, user, session_id, route, orchestrator, out
|
|||
history=llm_context,
|
||||
on_token=on_token,
|
||||
on_audio=on_audio,
|
||||
language_mode=route.language_mode,
|
||||
detected_language=detected_language,
|
||||
text_only=text_only,
|
||||
)
|
||||
else:
|
||||
trace, audio = await orchestrator.chat_text(
|
||||
|
|
@ -149,6 +168,9 @@ async def _run_turn(websocket, store, user, session_id, route, orchestrator, out
|
|||
voice=voice,
|
||||
output=output,
|
||||
history=llm_context,
|
||||
language_mode=route.language_mode,
|
||||
detected_language=detected_language,
|
||||
text_only=text_only,
|
||||
)
|
||||
except Exception as exc:
|
||||
await websocket.send_json({"type": "error", "status": 502, "detail": str(exc)})
|
||||
|
|
@ -164,7 +186,8 @@ async def _run_turn(websocket, store, user, session_id, route, orchestrator, out
|
|||
await websocket.send_json(
|
||||
{"type": "semantic", "text": trace.semantic_response, "spoken": trace.spoken_response}
|
||||
)
|
||||
if not audio_stream:
|
||||
# Im text_only-Modus kommt kein Audio (Gerät spricht selbst).
|
||||
if not audio_stream and not text_only:
|
||||
await websocket.send_bytes(audio)
|
||||
await websocket.send_json({"type": "done", "audio_format": "pcm", "sample_rate": 24000})
|
||||
|
||||
|
|
@ -202,19 +225,42 @@ async def _voice_turn(websocket, store, user, session_id, audio, fmt, options):
|
|||
except RoutingError as exc:
|
||||
await websocket.send_json({"type": "error", "status": 422, "detail": str(exc)})
|
||||
return
|
||||
|
||||
try:
|
||||
transcript = await orchestrator.stt.transcribe(audio, fmt=fmt, language=route.language)
|
||||
if route.language_mode == "flex":
|
||||
# Flex: Sprache auto-erkennen, kein Übersetzen durch Whisper.
|
||||
transcript, detected_language = await orchestrator.stt.transcribe_detect(
|
||||
audio, fmt=fmt, language=None
|
||||
)
|
||||
# Stimme folgt der erkannten Sprache (Fallback: Routensprache).
|
||||
effective_voice = piper_voice_for_language(
|
||||
route.tts_provider, detected_language or route.language
|
||||
)
|
||||
else:
|
||||
# Fix: konfigurierte Sprache an Whisper → Whisper übersetzt automatisch.
|
||||
transcript = await orchestrator.stt.transcribe(audio, fmt=fmt, language=route.language)
|
||||
detected_language = None
|
||||
# Stimme folgt der konfigurierten Sprache.
|
||||
effective_voice = piper_voice_for_language(route.tts_provider, route.language)
|
||||
except Exception as exc:
|
||||
await websocket.send_json({"type": "error", "status": 502, "detail": str(exc)})
|
||||
return
|
||||
await websocket.send_json({"type": "transcript", "text": transcript})
|
||||
|
||||
await websocket.send_json({
|
||||
"type": "transcript",
|
||||
"text": transcript,
|
||||
"detected_language": detected_language,
|
||||
})
|
||||
if not transcript or not transcript.strip():
|
||||
await websocket.send_json({
|
||||
"type": "error",
|
||||
"detail": "Keine Sprache erkannt — bitte erneut sprechen.",
|
||||
})
|
||||
return
|
||||
await _run_turn(websocket, store, user, session_id, route, orchestrator, output, transcript, options)
|
||||
await _run_turn(
|
||||
websocket, store, user, session_id, route, orchestrator, output, transcript, options,
|
||||
detected_language=detected_language, effective_voice=effective_voice,
|
||||
)
|
||||
|
||||
|
||||
@router.websocket("/ws/chat")
|
||||
|
|
|
|||
|
|
@ -112,6 +112,7 @@ class Settings(BaseSettings):
|
|||
openrouter_tts_voice: str = "alloy"
|
||||
openrouter_llm_model: str = "openai/gpt-4.1-mini"
|
||||
default_language: str = "de"
|
||||
default_language_mode: str = "fix"
|
||||
default_input_endpoint: str = "local-default"
|
||||
default_output_endpoint: str = "local-default"
|
||||
default_stt_provider: str = "openrouter"
|
||||
|
|
@ -144,6 +145,9 @@ class Settings(BaseSettings):
|
|||
chatterbox_lang: str = "de"
|
||||
chatterbox_speed: float = 1.0
|
||||
chatterbox_timeout: int = 180
|
||||
# Verzeichnis mit nativen Referenz-WAVs je Sprache (Konvention <lang>.wav, z. B. fr.wav).
|
||||
# Greift cross-lingual: pro Sprache eine muttersprachliche Stimme. Leer -> nur chatterbox_voice.
|
||||
chatterbox_voices_dir: str = str(BASE_DIR / "config" / "voices")
|
||||
db_path: str = str(BASE_DIR / "data" / "voice-assistant.db")
|
||||
admin_api_key: str = ""
|
||||
auth_enabled: bool = True
|
||||
|
|
@ -161,6 +165,9 @@ class Settings(BaseSettings):
|
|||
trusted_proxy_ips: str = "" # kommasepariert; IP(s) des Reverse-Proxys
|
||||
admin_users: str = "" # kommaseparierte SSO-Usernamen mit Admin-Rechten
|
||||
sso_logout_url: str = "" # Logout-Link fuers Frontend (SSO-Portal)
|
||||
# Login-/Portal-URL: unauthentifizierte Seitenaufrufe werden hierhin umgeleitet
|
||||
# (Defense-in-Depth zusaetzlich zu SSOwat). Leer -> stattdessen HTTP 401.
|
||||
sso_login_url: str = ""
|
||||
history_max_messages: int = 10
|
||||
# Automatische Erinnerungs-Extraktion: das LLM destilliert dauerhafte Fakten
|
||||
# aus dem Gespraech und legt sie als Nutzer-Erinnerungen ab (best-effort,
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ class Orchestrator:
|
|||
spoken, language=language, level=self.normalize_level
|
||||
)
|
||||
with _stage("tts"):
|
||||
audio = await self.tts.synthesize(normalized, voice=voice)
|
||||
audio = await self.tts.synthesize(normalized, voice=voice, language=language)
|
||||
await self._emit_to_output(audio, output)
|
||||
return audio
|
||||
|
||||
|
|
@ -89,35 +89,48 @@ class Orchestrator:
|
|||
voice: str | None = None,
|
||||
output=None,
|
||||
history: list[dict] | None = None,
|
||||
language_mode: str = "fix",
|
||||
detected_language: str | None = None,
|
||||
text_only: bool = False,
|
||||
):
|
||||
trace = PipelineTrace()
|
||||
|
||||
trace.raw_transcript = text
|
||||
trace.cleaned_transcript = await self.input_cleaner.run(text or "")
|
||||
|
||||
# Flex: die erkannte Sprache bestimmt die Ausgabe. Gibt es keine (z. B. Text-Chat
|
||||
# ohne Audio), bleibt sie None -> das LLM antwortet von selbst in der Eingabesprache.
|
||||
# Fix: immer die konfigurierte Sprache (Whisper hat die Eingabe übersetzt).
|
||||
effective_language = detected_language if language_mode == "flex" else language
|
||||
|
||||
with _stage("llm"):
|
||||
trace.semantic_response = await self.llm.complete(
|
||||
trace.cleaned_transcript or "",
|
||||
history=history,
|
||||
language=language,
|
||||
language=effective_language,
|
||||
)
|
||||
if not trace.semantic_response:
|
||||
raise RuntimeError("LLM returned an empty response")
|
||||
|
||||
trace.spoken_response = await self.spoken_adapter.run(
|
||||
trace.semantic_response,
|
||||
language=language,
|
||||
language=effective_language,
|
||||
)
|
||||
trace.tts_ready_text = await self.tts_normalizer.run(
|
||||
trace.spoken_response,
|
||||
language=language,
|
||||
language=effective_language,
|
||||
level=self.normalize_level,
|
||||
)
|
||||
|
||||
# text_only: Geräte-TTS (Web Speech API) übernimmt das Sprechen -> kein Server-Audio.
|
||||
if text_only:
|
||||
return trace, b""
|
||||
|
||||
with _stage("tts"):
|
||||
audio = await self.tts.synthesize(
|
||||
trace.tts_ready_text,
|
||||
voice=voice,
|
||||
language=effective_language,
|
||||
)
|
||||
await self._emit_to_output(audio, output)
|
||||
return trace, audio
|
||||
|
|
@ -131,6 +144,9 @@ class Orchestrator:
|
|||
history: list[dict] | None = None,
|
||||
on_token=None,
|
||||
on_audio=None,
|
||||
language_mode: str = "fix",
|
||||
detected_language: str | None = None,
|
||||
text_only: bool = False,
|
||||
):
|
||||
"""Wie chat_text, aber gestreamt.
|
||||
|
||||
|
|
@ -142,24 +158,29 @@ class Orchestrator:
|
|||
trace.raw_transcript = text
|
||||
trace.cleaned_transcript = await self.input_cleaner.run(text or "")
|
||||
|
||||
chunker = SentenceChunker() if on_audio else None
|
||||
# Siehe chat_text: Flex folgt der erkannten Sprache (None -> LLM spiegelt Eingabe),
|
||||
# Fix nutzt die konfigurierte Sprache.
|
||||
effective_language = detected_language if language_mode == "flex" else language
|
||||
|
||||
# text_only: kein Server-Audio (Geräte-TTS spricht selbst) -> kein Chunked-TTS.
|
||||
chunker = SentenceChunker() if (on_audio and not text_only) else None
|
||||
audio_parts: list[bytes] = []
|
||||
|
||||
async def _emit_sentence(sentence: str) -> None:
|
||||
spoken = await self.spoken_adapter.run(sentence, language=language)
|
||||
spoken = await self.spoken_adapter.run(sentence, language=effective_language)
|
||||
ready = await self.tts_normalizer.run(
|
||||
spoken, language=language, level=self.normalize_level
|
||||
spoken, language=effective_language, level=self.normalize_level
|
||||
)
|
||||
if not ready.strip():
|
||||
return
|
||||
chunk = await self.tts.synthesize(ready, voice=voice)
|
||||
chunk = await self.tts.synthesize(ready, voice=voice, language=effective_language)
|
||||
audio_parts.append(chunk)
|
||||
await on_audio(chunk)
|
||||
|
||||
parts: list[str] = []
|
||||
stream_fn = getattr(self.llm, "stream", None)
|
||||
if stream_fn is not None:
|
||||
async for delta in stream_fn(trace.cleaned_transcript or "", history=history, language=language):
|
||||
async for delta in stream_fn(trace.cleaned_transcript or "", history=history, language=effective_language):
|
||||
parts.append(delta)
|
||||
if on_token:
|
||||
await on_token(delta)
|
||||
|
|
@ -167,8 +188,7 @@ class Orchestrator:
|
|||
for sentence in chunker.feed(delta):
|
||||
await _emit_sentence(sentence)
|
||||
else:
|
||||
# Provider ohne Streaming -> komplette Antwort als ein Token.
|
||||
result = await self.llm.complete(trace.cleaned_transcript or "", history=history, language=language)
|
||||
result = await self.llm.complete(trace.cleaned_transcript or "", history=history, language=effective_language)
|
||||
parts.append(result)
|
||||
if on_token:
|
||||
await on_token(result)
|
||||
|
|
@ -182,21 +202,26 @@ class Orchestrator:
|
|||
|
||||
trace.spoken_response = await self.spoken_adapter.run(
|
||||
trace.semantic_response,
|
||||
language=language,
|
||||
language=effective_language,
|
||||
)
|
||||
trace.tts_ready_text = await self.tts_normalizer.run(
|
||||
trace.spoken_response,
|
||||
language=language,
|
||||
language=effective_language,
|
||||
level=self.normalize_level,
|
||||
)
|
||||
|
||||
if text_only:
|
||||
return trace, b""
|
||||
|
||||
if chunker:
|
||||
tail = chunker.flush()
|
||||
if tail:
|
||||
await _emit_sentence(tail)
|
||||
audio = b"".join(audio_parts)
|
||||
else:
|
||||
audio = await self.tts.synthesize(trace.tts_ready_text, voice=voice)
|
||||
audio = await self.tts.synthesize(
|
||||
trace.tts_ready_text, voice=voice, language=effective_language
|
||||
)
|
||||
|
||||
await self._emit_to_output(audio, output)
|
||||
return trace, audio
|
||||
|
|
|
|||
|
|
@ -77,6 +77,7 @@ TTS_REGISTRY = {
|
|||
s.chatterbox_speed,
|
||||
s.tts_sample_rate,
|
||||
s.chatterbox_timeout,
|
||||
voices_dir=s.chatterbox_voices_dir,
|
||||
),
|
||||
"piper": lambda s: PiperTTSProvider(
|
||||
s.piper_bin, s.piper_voices_dir, s.piper_voice, s.tts_sample_rate
|
||||
|
|
@ -148,8 +149,35 @@ ROUTE_KEYS = (
|
|||
"llm_provider",
|
||||
"tts_provider",
|
||||
"language",
|
||||
"language_mode",
|
||||
)
|
||||
|
||||
# Stimm-Auswahl nach Sprache: (effektive) Sprache → beste Piper-Stimme.
|
||||
# Gilt in BEIDEN Modi — die gesprochene Stimme folgt immer der Antwortsprache.
|
||||
LANG_TO_PIPER_VOICE: dict[str, str] = {
|
||||
"de": "de_DE-thorsten-high",
|
||||
"en": "en_US-lessac-high",
|
||||
"fr": "fr_FR-siwis-medium",
|
||||
"es": "es_ES-sharvard-medium",
|
||||
"it": "it_IT-paola-medium",
|
||||
"nl": "nl_NL-mls-medium",
|
||||
"ru": "ru_RU-irina-medium",
|
||||
"zh": "zh_CN-huayan-medium",
|
||||
"cmn": "zh_CN-huayan-medium",
|
||||
}
|
||||
|
||||
|
||||
def piper_voice_for_language(tts_provider: str, language: str | None) -> str | None:
|
||||
"""Liefert die zur Sprache passende Piper-Stimme (sonst None → Provider-Default).
|
||||
|
||||
Nur für Piper sinnvoll: Cloud-TTS (OpenRouter) und Chatterbox haben eigene
|
||||
Stimmnamen (z. B. "Zephyr") und steuern die Sprache anders. Bei None nimmt der
|
||||
jeweilige Provider seine konfigurierte Default-Stimme.
|
||||
"""
|
||||
if tts_provider == "piper" and language:
|
||||
return LANG_TO_PIPER_VOICE.get(language)
|
||||
return None
|
||||
|
||||
|
||||
@dataclass
|
||||
class ResolvedRoute:
|
||||
|
|
@ -159,6 +187,7 @@ class ResolvedRoute:
|
|||
llm_provider: str
|
||||
tts_provider: str
|
||||
language: str
|
||||
language_mode: str = "fix"
|
||||
|
||||
def as_dict(self) -> dict:
|
||||
return {
|
||||
|
|
@ -168,6 +197,7 @@ class ResolvedRoute:
|
|||
"llm_provider": self.llm_provider,
|
||||
"tts_provider": self.tts_provider,
|
||||
"language": self.language,
|
||||
"language_mode": self.language_mode,
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -208,6 +238,7 @@ def resolve_route(
|
|||
"llm_provider": cfg.default_llm_provider,
|
||||
"tts_provider": cfg.default_tts_provider,
|
||||
"language": cfg.default_language,
|
||||
"language_mode": cfg.default_language_mode,
|
||||
}
|
||||
|
||||
user_prefs = user.prefs if user is not None else {}
|
||||
|
|
|
|||
29
app/main.py
29
app/main.py
|
|
@ -5,7 +5,10 @@ from pathlib import Path
|
|||
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.staticfiles import StaticFiles
|
||||
from starlette.responses import RedirectResponse, JSONResponse
|
||||
|
||||
from app.config import settings
|
||||
from app.auth import authenticate, _bearer_token
|
||||
from app.core.warmup import warmup_local_models
|
||||
from app.metrics import metrics
|
||||
from app.api.health import router as health_router
|
||||
|
|
@ -48,6 +51,32 @@ async def record_metrics(request: Request, call_next):
|
|||
return response
|
||||
|
||||
|
||||
# Pfade mit eigener Auth, Health-Checks und Favicons: nicht gaten.
|
||||
_PUBLIC_PREFIXES = ("/api", "/ws", "/health", "/favicon", "/apple-touch-icon")
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def gate_web_ui(request: Request, call_next):
|
||||
"""Schuetzt die statische Web-UI: unauthentifizierte Seitenaufrufe -> SSO-Login (sonst 401).
|
||||
|
||||
Defense-in-Depth zusaetzlich zu SSOwat: Selbst wenn der Reverse-Proxy einen
|
||||
unauthentifizierten Request durchliesse (oder jemand den Port direkt trifft),
|
||||
bekommt er die Seite nicht ausgeliefert. API/WS haben ihre eigene Auth (require_user
|
||||
-> 401/JSON), Health-Checks bleiben offen. Bei abgeschalteter Auth (LAN-Dev) liefert
|
||||
authenticate() einen anonymen Nutzer -> die Seite wird wie bisher ausgeliefert.
|
||||
"""
|
||||
path = request.url.path
|
||||
if not path.startswith(_PUBLIC_PREFIXES):
|
||||
client_host = request.client.host if request.client else ""
|
||||
token = _bearer_token(request.headers.get("authorization"))
|
||||
if authenticate(request.headers, client_host, token) is None:
|
||||
login = settings.sso_login_url.strip()
|
||||
if login:
|
||||
return RedirectResponse(login, status_code=302)
|
||||
return JSONResponse({"detail": "Authentication required"}, status_code=401)
|
||||
return await call_next(request)
|
||||
|
||||
|
||||
app.include_router(health_router)
|
||||
app.include_router(chat_router, prefix="/api")
|
||||
app.include_router(transcribe_router, prefix="/api")
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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: ...
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -18,8 +18,9 @@ from app.config import Settings, settings as _base
|
|||
RUNTIME_SETTABLE: dict[str, tuple[str, str, str]] = {
|
||||
"default_stt_provider": ("STT-Provider (Standard)", "str", "openrouter | faster-whisper"),
|
||||
"default_llm_provider": ("LLM-Provider (Standard)", "str", "openrouter | local-openai-compatible"),
|
||||
"default_tts_provider": ("TTS-Provider (Standard)", "str", "openrouter | piper | chatterbox"),
|
||||
"default_language": ("Sprache (Standard)", "str", "de | en | …"),
|
||||
"default_tts_provider": ("TTS-Provider (Standard)", "str", "openrouter | piper | chatterbox — Standard, pro Nutzer überschreibbar"),
|
||||
"default_language": ("Sprache (Standard)", "str", "de | en | … — Standard, pro Nutzer überschreibbar"),
|
||||
"default_language_mode": ("Sprachmodus (Standard)", "str", "fix | flex — Standard, pro Nutzer überschreibbar"),
|
||||
"openrouter_llm_model": ("LLM-Modell (OpenRouter)", "str", "z.B. google/gemini-3.1-flash-lite"),
|
||||
"openrouter_tts_model": ("TTS-Modell (OpenRouter)", "str", "z.B. google/gemini-3.1-flash-tts-preview"),
|
||||
"openrouter_tts_voice": ("TTS-Stimme (OpenRouter)", "str", "z.B. Zephyr, Puck, Kore"),
|
||||
|
|
|
|||
|
|
@ -46,10 +46,12 @@ class ChatRequest(BaseModel):
|
|||
input_endpoint: str | None = None
|
||||
output_endpoint: str | None = None
|
||||
language: str | None = None
|
||||
language_mode: Literal["fix", "flex"] | None = None
|
||||
voice: str | None = None
|
||||
stt_provider: str | None = None
|
||||
llm_provider: str | None = None
|
||||
tts_provider: str | None = None
|
||||
text_only: bool | None = None # True -> kein Server-Audio (Geräte-TTS spricht selbst)
|
||||
|
||||
|
||||
class SessionRouteRequest(BaseModel):
|
||||
|
|
@ -91,6 +93,7 @@ class UserPrefs(BaseModel):
|
|||
llm_provider: str | None = None
|
||||
tts_provider: str | None = None
|
||||
language: str | None = None
|
||||
language_mode: Literal["fix", "flex"] | None = None
|
||||
|
||||
|
||||
class MemoryCreate(BaseModel):
|
||||
|
|
|
|||
333
app/web/app.js
333
app/web/app.js
|
|
@ -8,11 +8,121 @@ const promptEl = $("#prompt");
|
|||
const formEl = $("#prompt-form");
|
||||
const micBtn = $("#mic");
|
||||
const ttsSel = $("#tts");
|
||||
const langSel = $("#lang-sel");
|
||||
|
||||
// Gewählter TTS-Provider (leer = Default/piper) als Request-Override.
|
||||
// "Flex" ist im Sprachmenü nur ein weiterer Wert: keine feste Sprache, sondern
|
||||
// automatische Erkennung. Eine konkrete Sprache = Fix-Modus (Eingabe wird übersetzt).
|
||||
// Beide internen Felder (language, language_mode) werden aus dieser einen Auswahl abgeleitet.
|
||||
function langOverrides() {
|
||||
const sel = langSel && langSel.value;
|
||||
if (!sel || sel === "flex") return { language_mode: "flex" };
|
||||
return { language: sel, language_mode: "fix" };
|
||||
}
|
||||
|
||||
// Nutzer-Präferenzen als Request-Overrides für jeden Turn.
|
||||
function overrides() {
|
||||
const t = ttsSel && ttsSel.value;
|
||||
return t ? { tts_provider: t } : {};
|
||||
const out = { ...langOverrides() };
|
||||
if (isDeviceMode()) {
|
||||
out.text_only = true; // kein Server-Audio -> Gerät spricht selbst
|
||||
} else if (ttsSel && ttsSel.value) {
|
||||
out.tts_provider = ttsSel.value;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
async function savePrefs(obj) {
|
||||
try {
|
||||
await fetch("/api/me/prefs", {
|
||||
method: "PUT",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify(obj),
|
||||
});
|
||||
} catch (e) { console.error("savePrefs", e); }
|
||||
}
|
||||
|
||||
// ---------- Geräte-TTS (Web Speech API) ----------
|
||||
// "Gerät" liest die Antwort lokal vor -> der Server schickt kein Audio (spart Bytes/Kosten).
|
||||
const TTS_SUPPORTED = typeof window !== "undefined" && "speechSynthesis" in window;
|
||||
const LANG_BCP47 = {
|
||||
de: "de-DE", en: "en-US", fr: "fr-FR", es: "es-ES",
|
||||
it: "it-IT", nl: "nl-NL", ru: "ru-RU", zh: "zh-CN",
|
||||
};
|
||||
|
||||
function isMobile() {
|
||||
const ua = navigator.userAgent || "";
|
||||
return /Android|iPhone|iPad|iPod/i.test(ua) ||
|
||||
(navigator.maxTouchPoints > 1 && /Macintosh/.test(ua)); // iPad ab iOS 13
|
||||
}
|
||||
|
||||
function isDeviceMode() { return !!ttsSel && ttsSel.value === "device"; }
|
||||
|
||||
let _voices = [];
|
||||
function loadVoices() { _voices = TTS_SUPPORTED ? speechSynthesis.getVoices() : []; }
|
||||
if (TTS_SUPPORTED) {
|
||||
loadVoices();
|
||||
speechSynthesis.addEventListener("voiceschanged", loadVoices);
|
||||
}
|
||||
|
||||
function pickVoice(bcp) {
|
||||
if (!_voices.length) loadVoices();
|
||||
const lc = bcp.toLowerCase();
|
||||
const two = lc.slice(0, 2);
|
||||
return _voices.find((v) => v.lang && v.lang.toLowerCase() === lc) ||
|
||||
_voices.find((v) => v.lang && v.lang.toLowerCase().startsWith(two)) || null;
|
||||
}
|
||||
|
||||
function _makeUtterance(text, lang) {
|
||||
const u = new SpeechSynthesisUtterance(text);
|
||||
u.lang = LANG_BCP47[lang] || lang || "de-DE";
|
||||
const v = pickVoice(u.lang);
|
||||
if (v) u.voice = v;
|
||||
return u;
|
||||
}
|
||||
|
||||
// Vorlesen ohne Button-Status (automatisches Vorlesen der Antwort).
|
||||
function deviceSpeak(text, lang) {
|
||||
if (!TTS_SUPPORTED || !text) return;
|
||||
speechSynthesis.cancel();
|
||||
speechSynthesis.speak(_makeUtterance(text, lang));
|
||||
}
|
||||
|
||||
// Vorlesen mit Button-Status (Replay): Icon -> ⏹ während des Sprechens, danach zurück.
|
||||
function deviceSpeakBtn(text, lang, btn) {
|
||||
if (!TTS_SUPPORTED || !text) { setReplayPlaying(btn, false); return; }
|
||||
speechSynthesis.cancel();
|
||||
const u = _makeUtterance(text, lang);
|
||||
u.onend = u.onerror = () => setReplayPlaying(btn, false);
|
||||
setReplayPlaying(btn, true);
|
||||
speechSynthesis.speak(u);
|
||||
}
|
||||
|
||||
// iOS: speechSynthesis darf nur nach einer Nutzergeste starten -> beim ersten Tap freischalten.
|
||||
let _ttsUnlocked = false;
|
||||
function unlockTTS() {
|
||||
if (_ttsUnlocked || !TTS_SUPPORTED) return;
|
||||
try { speechSynthesis.speak(new SpeechSynthesisUtterance("")); _ttsUnlocked = true; } catch (e) {}
|
||||
}
|
||||
|
||||
const PLAYBACK_KEY = "va-playback"; // geräte-lokal: "device" wenn Geräte-TTS gewählt
|
||||
|
||||
// Setzt das Qualität-Dropdown beim Laden. Vorrang:
|
||||
// 1. lokale Wahl (localStorage), 2. Server-Pref (tts_provider), 3. Mobil-Default = Gerät.
|
||||
function applyPlaybackChoice(serverProvider) {
|
||||
if (!ttsSel) return;
|
||||
// "Gerät"-Option ausblenden, wenn der Browser keine Web Speech API hat.
|
||||
if (!TTS_SUPPORTED) {
|
||||
const opt = ttsSel.querySelector('option[value="device"]');
|
||||
if (opt) opt.remove();
|
||||
}
|
||||
const local = localStorage.getItem(PLAYBACK_KEY);
|
||||
if (local === "device" && TTS_SUPPORTED) {
|
||||
ttsSel.value = "device";
|
||||
} else if (serverProvider) {
|
||||
ttsSel.value = serverProvider;
|
||||
} else if (TTS_SUPPORTED && isMobile() && local === null) {
|
||||
ttsSel.value = "device"; // Mobil-Default, solange nichts gewählt wurde
|
||||
localStorage.setItem(PLAYBACK_KEY, "device");
|
||||
}
|
||||
}
|
||||
|
||||
let busy = false;
|
||||
|
|
@ -23,6 +133,8 @@ let activeSources = []; // laufende AudioBufferSourceNodes (stoppbar per Barge-
|
|||
// /api/me abgeleitet; bis dahin null -> ensureSession() wartet auf loadMe().
|
||||
let sessionId = null;
|
||||
let mePromise = null;
|
||||
let currentUserId = null;
|
||||
const sessionKey = (uid) => "va-session-" + uid;
|
||||
|
||||
// ---------- Identitaet / Menue ----------
|
||||
function loadMe() {
|
||||
|
|
@ -34,7 +146,9 @@ function loadMe() {
|
|||
return null;
|
||||
}
|
||||
const me = await res.json();
|
||||
sessionId = "web-" + me.user_id;
|
||||
currentUserId = me.user_id;
|
||||
// Zuletzt aktive (ggf. frische) Session bevorzugen, sonst die Basis-Session.
|
||||
sessionId = localStorage.getItem(sessionKey(me.user_id)) || ("web-" + me.user_id);
|
||||
$("#identity").textContent = "Angemeldet als " + (me.display_name || me.external_id || "Gast");
|
||||
if (me.sso_logout_url) {
|
||||
const logout = $("#logout");
|
||||
|
|
@ -44,6 +158,15 @@ function loadMe() {
|
|||
if (me.is_admin) {
|
||||
$("#admin-toggle").classList.remove("hidden");
|
||||
}
|
||||
// Gespeicherte Nutzer-Präferenzen in die Dropdowns laden.
|
||||
const prefs = me.prefs || {};
|
||||
if (langSel) {
|
||||
// Flex-Modus -> "flex", sonst die feste Sprache (Fallback: Flex).
|
||||
langSel.value = prefs.language_mode === "flex"
|
||||
? "flex"
|
||||
: (prefs.language || "flex");
|
||||
}
|
||||
applyPlaybackChoice(prefs.tts_provider);
|
||||
return me;
|
||||
} catch (e) {
|
||||
$("#identity").textContent = "Verbindung fehlgeschlagen";
|
||||
|
|
@ -76,19 +199,98 @@ const BUBBLE = {
|
|||
emergency: "mx-auto max-w-[90%] rounded-lg bg-red-100 px-3 py-1.5 text-sm font-semibold text-red-800 dark:bg-red-900/40 dark:text-red-200",
|
||||
};
|
||||
|
||||
function addMessage(role, text) {
|
||||
// Lautsprecher-/Stop-Icons als SVG (currentColor → per CSS einfärbbar, anders als Emoji).
|
||||
const ICON_SPEAKER =
|
||||
'<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" ' +
|
||||
'class="w-4 h-4"><path stroke-linecap="round" stroke-linejoin="round" ' +
|
||||
'd="M19.114 5.636a9 9 0 0 1 0 12.728M16.463 8.288a5.25 5.25 0 0 1 0 7.424M6.75 8.25l4.72-4.72a.75.75 0 0 1 1.28.53v15.88a.75.75 0 0 1-1.28.53l-4.72-4.72H4.51c-.88 0-1.704-.507-1.938-1.354A9.009 9.009 0 0 1 2.25 12c0-.83.112-1.633.322-2.396C2.806 8.756 3.63 8.25 4.51 8.25H6.75Z" /></svg>';
|
||||
const ICON_STOP =
|
||||
'<svg viewBox="0 0 24 24" fill="currentColor" class="w-4 h-4">' +
|
||||
'<rect x="6" y="6" width="12" height="12" rx="2" /></svg>';
|
||||
|
||||
// meta.lang: Sprache, in der diese Bubble vorgelesen werden soll (für Replay).
|
||||
function addMessage(role, text, meta = {}) {
|
||||
const div = document.createElement("div");
|
||||
div.className = BUBBLE[role] || BUBBLE.assistant;
|
||||
div.textContent = text;
|
||||
const span = document.createElement("span");
|
||||
span.className = "bubble-text";
|
||||
span.textContent = text;
|
||||
div.appendChild(span);
|
||||
div._textEl = span;
|
||||
// Vorlese-Symbol nur an Nutzer-/Assistenten-Bubbles (nicht System/Notfall).
|
||||
if (role === "user" || role === "assistant") {
|
||||
div.classList.add("relative", "pr-7");
|
||||
div._replay = { lang: meta.lang || null, chunks: null }; // chunks: gecachtes PCM (Assistent)
|
||||
const btn = document.createElement("button");
|
||||
btn.type = "button";
|
||||
btn.innerHTML = ICON_SPEAKER;
|
||||
btn.title = "Vorlesen";
|
||||
btn.setAttribute("aria-label", "Vorlesen");
|
||||
// Kontrastreiche Farbe je Bubble: weiß auf Blau; im Dark-Mode hell auf Dunkelgrau.
|
||||
const replayColor = role === "user"
|
||||
? "text-white/80 hover:text-white"
|
||||
: "text-slate-500 hover:text-slate-700 dark:text-slate-300 dark:hover:text-white";
|
||||
btn.className = "replay-btn absolute top-1.5 right-1.5 transition-colors " + replayColor;
|
||||
btn.addEventListener("click", () => replayBubble(div));
|
||||
div._replayBtn = btn;
|
||||
div.appendChild(btn);
|
||||
}
|
||||
messagesEl.appendChild(div);
|
||||
scrollToBottom();
|
||||
return div;
|
||||
}
|
||||
|
||||
// ---------- Vorlesen / Replay ----------
|
||||
function setReplayPlaying(btn, on) {
|
||||
if (!btn) return;
|
||||
btn.innerHTML = on ? ICON_STOP : ICON_SPEAKER;
|
||||
btn.dataset.playing = on ? "1" : "";
|
||||
}
|
||||
|
||||
function startReplay(chunks, btn) {
|
||||
stopAudio(); // Barge-in: laufendes Audio (auch andere Replays) stoppen
|
||||
setReplayPlaying(btn, true);
|
||||
playPcm(chunks, 24000, () => setReplayPlaying(btn, false));
|
||||
}
|
||||
|
||||
async function speakBubble(text, lang, btn) {
|
||||
try {
|
||||
const body = { text };
|
||||
if (lang) body.language = lang;
|
||||
if (ttsSel && ttsSel.value) body.tts_provider = ttsSel.value;
|
||||
const r = await fetch("/api/speak", {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify(body),
|
||||
});
|
||||
if (!r.ok) throw new Error("HTTP " + r.status);
|
||||
startReplay([await r.arrayBuffer()], btn);
|
||||
} catch (e) {
|
||||
setReplayPlaying(btn, false);
|
||||
statusEl.textContent = "Vorlesen fehlgeschlagen";
|
||||
}
|
||||
}
|
||||
|
||||
function replayBubble(div) {
|
||||
const btn = div._replayBtn;
|
||||
if (btn && btn.dataset.playing) { stopAudio(); setReplayPlaying(btn, false); return; } // Toggle
|
||||
const info = div._replay || {};
|
||||
const text = (div._textEl && div._textEl.textContent) || "";
|
||||
if (info.chunks && info.chunks.length) {
|
||||
startReplay(info.chunks, btn); // Assistent: gecachtes PCM, sofort & gratis
|
||||
} else if (isDeviceMode()) {
|
||||
stopAudio();
|
||||
deviceSpeakBtn(text, info.lang, btn); // Geräte-TTS: lokal vorlesen, gratis
|
||||
} else {
|
||||
speakBubble(text, info.lang, btn); // Server-TTS via /api/speak
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- Barge-in-Hilfsfunktionen ----------
|
||||
function stopAudio() {
|
||||
activeSources.forEach((s) => { try { s.stop(); } catch (e) {} });
|
||||
activeSources = [];
|
||||
if (TTS_SUPPORTED) { try { speechSynthesis.cancel(); } catch (e) {} } // Geräte-TTS stoppen
|
||||
}
|
||||
|
||||
function setMicIdle() {
|
||||
|
|
@ -113,8 +315,8 @@ function setMicBusy() {
|
|||
|
||||
// ---------- Audio-Wiedergabe (PCM s16le) ----------
|
||||
let audioCtx = null;
|
||||
function playPcm(chunks, sampleRate) {
|
||||
if (!chunks.length) return;
|
||||
function playPcm(chunks, sampleRate, onended) {
|
||||
if (!chunks.length) { if (onended) onended(); return; }
|
||||
const total = chunks.reduce((n, c) => n + c.byteLength, 0);
|
||||
const merged = new Uint8Array(total);
|
||||
let off = 0;
|
||||
|
|
@ -122,6 +324,7 @@ function playPcm(chunks, sampleRate) {
|
|||
const view = new DataView(merged.buffer);
|
||||
const n = Math.floor(merged.byteLength / 2);
|
||||
audioCtx = audioCtx || new (window.AudioContext || window.webkitAudioContext)();
|
||||
if (audioCtx.state === "suspended") audioCtx.resume();
|
||||
const buf = audioCtx.createBuffer(1, n, sampleRate || 24000);
|
||||
const ch = buf.getChannelData(0);
|
||||
for (let i = 0; i < n; i++) ch[i] = view.getInt16(i * 2, true) / 32768;
|
||||
|
|
@ -129,7 +332,10 @@ function playPcm(chunks, sampleRate) {
|
|||
src.buffer = buf;
|
||||
src.connect(audioCtx.destination);
|
||||
activeSources.push(src);
|
||||
src.onended = () => { activeSources = activeSources.filter((s) => s !== src); };
|
||||
src.onended = () => {
|
||||
activeSources = activeSources.filter((s) => s !== src);
|
||||
if (onended) onended();
|
||||
};
|
||||
src.start();
|
||||
}
|
||||
|
||||
|
|
@ -148,6 +354,10 @@ function runTurn(path, onopen) {
|
|||
const pcm = [];
|
||||
let answerEl = null;
|
||||
let sampleRate = 24000;
|
||||
// Sprache dieses Turns (für den Replay je Bubble): Flex folgt erkannter Sprache.
|
||||
let routeLang = null, routeMode = null, detectedLang = null;
|
||||
const turnLang = () =>
|
||||
(routeMode === "flex" ? (detectedLang || routeLang) : routeLang) || null;
|
||||
|
||||
ws.onopen = () => onopen(ws);
|
||||
ws.onerror = () => { statusEl.textContent = "Verbindungsfehler"; resolve(); };
|
||||
|
|
@ -158,17 +368,25 @@ function runTurn(path, onopen) {
|
|||
let msg;
|
||||
try { msg = JSON.parse(event.data); } catch { return; }
|
||||
switch (msg.type) {
|
||||
case "ack":
|
||||
routeLang = (msg.route && msg.route.language) || null;
|
||||
routeMode = (msg.route && msg.route.language_mode) || null;
|
||||
break;
|
||||
case "transcript":
|
||||
if (msg.text) addMessage("user", msg.text);
|
||||
detectedLang = msg.detected_language || null;
|
||||
if (msg.text) addMessage("user", msg.text, { lang: turnLang() });
|
||||
break;
|
||||
case "token":
|
||||
if (!answerEl) answerEl = addMessage("assistant", "");
|
||||
answerEl.textContent += msg.text || "";
|
||||
if (!answerEl) answerEl = addMessage("assistant", "", { lang: turnLang() });
|
||||
answerEl._textEl.textContent += msg.text || "";
|
||||
scrollToBottom();
|
||||
break;
|
||||
case "semantic":
|
||||
if (!answerEl) answerEl = addMessage("assistant", "");
|
||||
if (msg.text) answerEl.textContent = msg.text;
|
||||
if (!answerEl) answerEl = addMessage("assistant", "", { lang: turnLang() });
|
||||
if (msg.text) answerEl._textEl.textContent = msg.text;
|
||||
// Sprache final festhalten (für Replay) und im Geräte-Modus lokal vorlesen.
|
||||
if (answerEl._replay) answerEl._replay.lang = turnLang();
|
||||
if (isDeviceMode() && msg.text) deviceSpeak(msg.text, turnLang());
|
||||
scrollToBottom();
|
||||
break;
|
||||
case "emergency":
|
||||
|
|
@ -176,7 +394,11 @@ function runTurn(path, onopen) {
|
|||
break;
|
||||
case "done":
|
||||
sampleRate = msg.sample_rate || 24000;
|
||||
playPcm(pcm, sampleRate);
|
||||
// Geräte-Modus: kein Server-Audio -> nichts abspielen/cachen (Gerät hat schon gesprochen).
|
||||
if (!isDeviceMode()) {
|
||||
if (answerEl && answerEl._replay) answerEl._replay.chunks = pcm.slice(); // Replay-Cache
|
||||
playPcm(pcm, sampleRate);
|
||||
}
|
||||
statusEl.textContent = "";
|
||||
scrollToBottom();
|
||||
ws.close();
|
||||
|
|
@ -200,10 +422,13 @@ async function sendText(text) {
|
|||
busy = true;
|
||||
setMicBusy();
|
||||
await ensureSession();
|
||||
addMessage("user", text);
|
||||
// Bei fester Sprache wird der eigene Text in dieser Sprache vorgelesen; bei Flex offen.
|
||||
const lo = langOverrides();
|
||||
addMessage("user", text, { lang: lo.language_mode === "fix" ? lo.language : null });
|
||||
statusEl.textContent = "denkt …";
|
||||
const audioStream = !isDeviceMode(); // Geräte-Modus: kein Server-Audio anfordern
|
||||
await runTurn("/ws/chat", (ws) => {
|
||||
ws.send(JSON.stringify({ text, stream: true, audio_stream: true, ...overrides() }));
|
||||
ws.send(JSON.stringify({ text, stream: true, audio_stream: audioStream, ...overrides() }));
|
||||
});
|
||||
busy = false;
|
||||
setMicIdle();
|
||||
|
|
@ -211,6 +436,7 @@ async function sendText(text) {
|
|||
|
||||
formEl.addEventListener("submit", (e) => {
|
||||
e.preventDefault();
|
||||
unlockTTS(); // iOS: Geräte-TTS bei der Nutzergeste freischalten
|
||||
const text = promptEl.value;
|
||||
promptEl.value = "";
|
||||
sendText(text);
|
||||
|
|
@ -272,8 +498,9 @@ async function sendVoice(bytes, fmt = "webm") {
|
|||
setMicBusy();
|
||||
await ensureSession();
|
||||
statusEl.textContent = "verarbeite Sprache …";
|
||||
const audioStream = !isDeviceMode(); // Geräte-Modus: kein Server-Audio anfordern
|
||||
await runTurn("/ws/voice", (ws) => {
|
||||
ws.send(JSON.stringify({ type: "start", format: fmt, stream: true, audio_stream: true, ...overrides() }));
|
||||
ws.send(JSON.stringify({ type: "start", format: fmt, stream: true, audio_stream: audioStream, ...overrides() }));
|
||||
ws.send(bytes);
|
||||
ws.send(JSON.stringify({ type: "end" }));
|
||||
});
|
||||
|
|
@ -282,6 +509,7 @@ async function sendVoice(bytes, fmt = "webm") {
|
|||
}
|
||||
|
||||
micBtn.addEventListener("click", () => {
|
||||
unlockTTS(); // iOS: Geräte-TTS bei der Nutzergeste freischalten
|
||||
if (busy) {
|
||||
// Barge-in: laufende KI-Antwort sofort unterbrechen
|
||||
if (activeWs) activeWs.send(JSON.stringify({ type: "interrupt" }));
|
||||
|
|
@ -297,6 +525,23 @@ micBtn.addEventListener("click", () => {
|
|||
|
||||
$("#admin-toggle").addEventListener("click", openAdminPanel);
|
||||
|
||||
// ---------- Neues Gespräch ----------
|
||||
// Startet eine frische Session (neuer session_id) -> der bisherige Verlauf wird nicht
|
||||
// mehr als LLM-Kontext genutzt. Behebt "Sprache springt nicht um", wenn die History
|
||||
// in einer anderen Sprache dominiert. Nicht-destruktiv: alte Session bleibt in der DB.
|
||||
function newConversation() {
|
||||
const base = currentUserId || "anon";
|
||||
sessionId = "web-" + base + "-" + Date.now();
|
||||
if (currentUserId) localStorage.setItem(sessionKey(currentUserId), sessionId);
|
||||
stopAudio();
|
||||
messagesEl.innerHTML = "";
|
||||
statusEl.textContent = "Neues Gespräch begonnen";
|
||||
setTimeout(() => {
|
||||
if (statusEl.textContent === "Neues Gespräch begonnen") statusEl.textContent = "";
|
||||
}, 2500);
|
||||
}
|
||||
$("#new-chat").addEventListener("click", newConversation);
|
||||
|
||||
// Tag/Nacht: Umschalter (manuell) + automatisch dem System folgen, solange nichts gewählt.
|
||||
const themeBtn = $("#theme-toggle");
|
||||
const setThemeIcon = () =>
|
||||
|
|
@ -321,6 +566,21 @@ if (window.visualViewport) {
|
|||
window.addEventListener("resize", scrollToBottom);
|
||||
promptEl.addEventListener("focus", () => setTimeout(scrollToBottom, 300));
|
||||
|
||||
// Dropdown-Änderungen dauerhaft als Nutzer-Präferenz speichern.
|
||||
if (langSel) langSel.addEventListener("change", () => savePrefs(langOverrides()));
|
||||
if (ttsSel) {
|
||||
ttsSel.addEventListener("change", () => {
|
||||
unlockTTS(); // Auswahl ist eine Nutzergeste -> Geräte-TTS gleich freischalten
|
||||
if (ttsSel.value === "device") {
|
||||
// Geräte-TTS ist geräte-lokal (nicht server-seitig) -> nur lokal merken.
|
||||
localStorage.setItem(PLAYBACK_KEY, "device");
|
||||
} else {
|
||||
localStorage.removeItem(PLAYBACK_KEY);
|
||||
savePrefs({ tts_provider: ttsSel.value || null }); // echter Provider -> Server-Pref
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
loadMe();
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
|
|
@ -854,13 +1114,14 @@ function buildWortSection(title, section, entries, lang) {
|
|||
wrap.className = "bg-white dark:bg-slate-800 rounded-xl border border-slate-200 dark:border-slate-700 p-4";
|
||||
|
||||
const rows = Object.entries(entries).map(([k, v]) => `
|
||||
<tr class="hover:bg-slate-50 dark:hover:bg-slate-700/40 transition-colors group">
|
||||
<tr class="row-edit cursor-pointer hover:bg-slate-50 dark:hover:bg-slate-700/40 transition-colors group"
|
||||
data-key="${escHtml(k)}" data-val="${escHtml(v)}" title="Zum Bearbeiten anklicken">
|
||||
<td class="px-3 py-2 text-xs font-mono text-slate-700 dark:text-slate-300">${escHtml(k)}</td>
|
||||
<td class="px-3 py-2 text-xs text-slate-400">→</td>
|
||||
<td class="px-3 py-2 text-xs text-slate-700 dark:text-slate-300 font-medium">${escHtml(v)}</td>
|
||||
<td class="px-3 py-2 text-right">
|
||||
<button class="del-btn text-slate-300 dark:text-slate-600 hover:text-red-500 dark:hover:text-red-400 transition-colors text-xs opacity-0 group-hover:opacity-100"
|
||||
data-key="${escHtml(k)}">✕</button>
|
||||
data-key="${escHtml(k)}" title="Löschen">✕</button>
|
||||
</td>
|
||||
</tr>`).join("");
|
||||
|
||||
|
|
@ -885,8 +1146,24 @@ function buildWortSection(title, section, entries, lang) {
|
|||
</form>
|
||||
`;
|
||||
|
||||
const form = wrap.querySelector(".add-form");
|
||||
const [keyInp, valInp] = form.querySelectorAll("input");
|
||||
const submitBtn = form.querySelector('button[type="submit"]');
|
||||
|
||||
// Zeile anklicken -> Begriffspaar in die Editier-Felder laden, Button wird zu „Speichern".
|
||||
wrap.querySelectorAll("tr.row-edit").forEach((tr) =>
|
||||
tr.addEventListener("click", () => {
|
||||
keyInp.value = tr.dataset.key;
|
||||
valInp.value = tr.dataset.val;
|
||||
form.dataset.editKey = tr.dataset.key; // Originalschlüssel merken (für Umbenennen)
|
||||
submitBtn.textContent = "Speichern";
|
||||
valInp.focus();
|
||||
})
|
||||
);
|
||||
|
||||
wrap.querySelectorAll(".del-btn").forEach((btn) =>
|
||||
btn.addEventListener("click", async () => {
|
||||
btn.addEventListener("click", async (e) => {
|
||||
e.stopPropagation(); // nicht zugleich die Zeile zum Bearbeiten laden
|
||||
const key = btn.dataset.key;
|
||||
if (!confirm(`Eintrag „${key}" löschen?`)) return;
|
||||
const res = await adminFetch(
|
||||
|
|
@ -896,14 +1173,22 @@ function buildWortSection(title, section, entries, lang) {
|
|||
})
|
||||
);
|
||||
|
||||
wrap.querySelector(".add-form").addEventListener("submit", async (e) => {
|
||||
form.addEventListener("submit", async (e) => {
|
||||
e.preventDefault();
|
||||
const [keyInp, valInp] = e.target.querySelectorAll("input");
|
||||
const key = keyInp.value.trim();
|
||||
const value = valInp.value.trim();
|
||||
if (!key || !value) return;
|
||||
const editKey = form.dataset.editKey || "";
|
||||
// Hinzufügen ODER Aktualisieren (gleicher Schlüssel wird überschrieben; Backend sortiert).
|
||||
const res = await adminFetch(`/api/admin/pronunciation/${lang}`, "POST", { section, key, value });
|
||||
if (res !== null) { keyInp.value = ""; valInp.value = ""; loadWoerterbuch(); }
|
||||
if (res === null) return;
|
||||
// Umbenannt -> alten Schlüssel entfernen (neuer wurde oben bereits angelegt).
|
||||
if (editKey && editKey !== key) {
|
||||
await adminFetch(
|
||||
`/api/admin/pronunciation/${lang}/${section}/${encodeURIComponent(editKey)}`, "DELETE"
|
||||
);
|
||||
}
|
||||
loadWoerterbuch(); // neu laden -> sortierte Liste, Formular zurück auf „+ Hinzufügen"
|
||||
});
|
||||
|
||||
return wrap;
|
||||
|
|
|
|||
BIN
app/web/apple-touch-icon.png
Normal file
BIN
app/web/apple-touch-icon.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 22 KiB |
BIN
app/web/favicon-32.png
Normal file
BIN
app/web/favicon-32.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 2.4 KiB |
3
app/web/favicon.svg
Normal file
3
app/web/favicon.svg
Normal file
File diff suppressed because one or more lines are too long
|
After Width: | Height: | Size: 44 KiB |
|
|
@ -4,8 +4,17 @@
|
|||
<meta charset="utf-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
|
||||
<title>Voice Assistant</title>
|
||||
<link rel="icon" type="image/svg+xml" href="/favicon.svg?v=1" />
|
||||
<link rel="icon" type="image/png" sizes="32x32" href="/favicon-32.png?v=1" />
|
||||
<link rel="apple-touch-icon" href="/apple-touch-icon.png?v=1" />
|
||||
<script src="https://cdn.tailwindcss.com"></script>
|
||||
<script>tailwind.config = { darkMode: "class" };</script>
|
||||
<style>
|
||||
/* Dropdown-Popup (<option>) hat sonst Browser-Default-Weiß -> im Dark-Mode
|
||||
helle Schrift auf hellem Grund = unlesbar. Farben explizit setzen. */
|
||||
select option { background-color: #ffffff; color: #1e293b; } /* slate-800 */
|
||||
.dark select option { background-color: #1e293b; color: #f1f5f9; } /* slate-100 */
|
||||
</style>
|
||||
<script>
|
||||
(function () {
|
||||
try {
|
||||
|
|
@ -137,6 +146,12 @@
|
|||
class="text-sm rounded-lg border border-slate-300 dark:border-slate-600 bg-transparent px-2 py-1.5">
|
||||
<option value="de">Deutsch (de)</option>
|
||||
<option value="en">Englisch (en)</option>
|
||||
<option value="fr">Französisch (fr)</option>
|
||||
<option value="es">Spanisch (es)</option>
|
||||
<option value="it">Italienisch (it)</option>
|
||||
<option value="nl">Niederländisch (nl)</option>
|
||||
<option value="ru">Russisch (ru)</option>
|
||||
<option value="zh">Chinesisch (zh)</option>
|
||||
</select>
|
||||
<button id="load-words"
|
||||
class="rounded-lg border border-slate-300 dark:border-slate-600 text-sm px-3 py-1.5 hover:bg-slate-100 dark:hover:bg-slate-700 transition-colors">Aktualisieren</button>
|
||||
|
|
@ -185,14 +200,31 @@
|
|||
|
||||
|
||||
<!-- ═══════════════════ CHAT INTERFACE ═══════════════════ -->
|
||||
<header class="shrink-0 h-14 flex items-center gap-3 px-4 border-b border-slate-200 dark:border-slate-700 bg-white/80 dark:bg-slate-800/80 backdrop-blur">
|
||||
<header class="shrink-0 h-14 flex items-center gap-2 px-3 border-b border-slate-200 dark:border-slate-700 bg-white/80 dark:bg-slate-800/80 backdrop-blur">
|
||||
<h1 class="flex-1 truncate font-semibold text-base">Voice Assistant</h1>
|
||||
<select id="tts" title="Stimme"
|
||||
<select id="lang-sel" title="Sprache — feste Sprache (Eingabe wird übersetzt) oder 🔄 Flex (folgt automatisch der gesprochenen Sprache)"
|
||||
class="text-sm rounded-lg border border-slate-300 dark:border-slate-600 bg-transparent px-2 py-1.5">
|
||||
<option value="">Schnell</option>
|
||||
<option value="chatterbox">Hohe Qualität</option>
|
||||
<option value="flex">🔄 Flex</option>
|
||||
<option value="de">🇩🇪 DE</option>
|
||||
<option value="en">🇬🇧 EN</option>
|
||||
<option value="fr">🇫🇷 FR</option>
|
||||
<option value="es">🇪🇸 ES</option>
|
||||
<option value="it">🇮🇹 IT</option>
|
||||
<option value="nl">🇳🇱 NL</option>
|
||||
<option value="ru">🇷🇺 RU</option>
|
||||
<option value="zh">🇨🇳 ZH</option>
|
||||
</select>
|
||||
<select id="tts" title="Sprachqualität"
|
||||
class="text-sm rounded-lg border border-slate-300 dark:border-slate-600 bg-transparent px-2 py-1.5">
|
||||
<option value="device">📱 Gerät</option>
|
||||
<option value="piper">Schnell</option>
|
||||
<option value="chatterbox">Hoch</option>
|
||||
<option value="openrouter">Cloud</option>
|
||||
</select>
|
||||
<button id="new-chat" title="Neues Gespräch (Verlauf zurücksetzen)"
|
||||
class="h-9 w-9 grid place-items-center rounded-lg border border-slate-300 dark:border-slate-600 hover:bg-slate-100 dark:hover:bg-slate-700 transition-colors">
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" class="w-5 h-5"><path stroke-linecap="round" stroke-linejoin="round" d="M16.862 4.487l1.687-1.688a1.875 1.875 0 1 1 2.652 2.652L10.582 16.07a4.5 4.5 0 0 1-1.897 1.13L6 18l.8-2.685a4.5 4.5 0 0 1 1.13-1.897l8.932-8.931Zm0 0L19.5 7.125M18 14v4.75A2.25 2.25 0 0 1 15.75 21H5.25A2.25 2.25 0 0 1 3 18.75V8.25A2.25 2.25 0 0 1 5.25 6H10"/></svg>
|
||||
</button>
|
||||
<button id="admin-toggle" title="Admin"
|
||||
class="hidden h-9 w-9 grid place-items-center rounded-lg border border-slate-300 dark:border-slate-600 hover:bg-slate-100 dark:hover:bg-slate-700 transition-colors">⚙️</button>
|
||||
<button id="theme-toggle" title="Tag/Nacht"
|
||||
|
|
@ -218,6 +250,6 @@
|
|||
<div id="status" class="w-full max-w-3xl mx-auto mt-1 min-h-[1rem] text-xs text-slate-500 dark:text-slate-400"></div>
|
||||
</footer>
|
||||
|
||||
<script src="/app.js?v=19"></script>
|
||||
<script src="/app.js?v=27"></script>
|
||||
</body>
|
||||
</html>
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue