379e002460
- LLMProvider.stream: Basis-Default (Fallback über complete) + SSE-Streaming
fuer OpenRouter und lokalen OpenAI-kompatiblen Provider; gemeinsamer Parser sse_delta
- Orchestrator.chat_stream: LLM-Token live via on_token-Callback, danach
Spoken-Adapter/Normalizer/TTS/Output; Fallback fuer Provider ohne stream
- WS /ws/chat: opt-in {"stream":true} -> ack -> token* -> semantic -> audio -> done
- Tests: 43 gruen (+5: SSE-Parsing, Default-Fallback, WS-Token-Flow)
- Doku aktualisiert; .gitignore: *.wav (generierte Audio-Ausgaben)
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
140 lines
4.8 KiB
Python
140 lines
4.8 KiB
Python
"""WebSocket-Streaming-Chat (Echtzeit-Transport, erster Increment).
|
|
|
|
Etabliert einen dauerhaften, bidirektionalen Kanal: der Client schickt pro Turn
|
|
eine JSON-Nachricht, der Server streamt strukturierte Events zurueck
|
|
(ack -> semantic -> audio (binaer) -> done). Auth, Session-Gedaechtnis und
|
|
Langzeit-Erinnerungen gelten wie bei POST /api/chat.
|
|
|
|
Bewusst spaeter (eigene Increments): Token-Level-LLM-Streaming, Audio-Eingang/
|
|
Streaming-STT, Barge-in/Interrupt und WebRTC.
|
|
"""
|
|
|
|
from fastapi import APIRouter, WebSocket, WebSocketDisconnect
|
|
|
|
from app.config import settings
|
|
from app.errors import RoutingError
|
|
from app.dependencies import (
|
|
get_store,
|
|
resolve_route,
|
|
build_orchestrator,
|
|
resolve_output_endpoint,
|
|
)
|
|
from app.store import SessionOwnershipError
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
def _authenticate(token: str | None):
|
|
store = get_store()
|
|
if not settings.auth_enabled:
|
|
return store.ensure_anonymous_user()
|
|
if not token:
|
|
return None
|
|
return store.get_user_by_token(token)
|
|
|
|
|
|
@router.websocket("/ws/chat")
|
|
async def ws_chat(
|
|
websocket: WebSocket,
|
|
session_id: str | None = None,
|
|
token: str | None = None,
|
|
):
|
|
user = _authenticate(token)
|
|
if user is None:
|
|
# Vor accept() schliessen -> Handshake wird mit 403 abgelehnt.
|
|
await websocket.close(code=1008)
|
|
return
|
|
|
|
await websocket.accept()
|
|
store = get_store()
|
|
|
|
try:
|
|
while True:
|
|
msg = await websocket.receive_json()
|
|
text = (msg.get("text") or "").strip()
|
|
if not text:
|
|
await websocket.send_json({"type": "error", "detail": "empty text"})
|
|
continue
|
|
|
|
overrides = {
|
|
key: msg.get(key)
|
|
for key in (
|
|
"input_endpoint",
|
|
"output_endpoint",
|
|
"language",
|
|
"stt_provider",
|
|
"llm_provider",
|
|
"tts_provider",
|
|
)
|
|
}
|
|
|
|
try:
|
|
route = resolve_route(user, session_id, overrides)
|
|
orchestrator = build_orchestrator(route)
|
|
output = await resolve_output_endpoint(route)
|
|
conversation = (
|
|
store.get_recent_messages(session_id, settings.history_max_messages)
|
|
if session_id
|
|
else []
|
|
)
|
|
memories = store.get_memories(user.id)
|
|
except SessionOwnershipError as exc:
|
|
await websocket.send_json({"type": "error", "status": 403, "detail": str(exc)})
|
|
continue
|
|
except RoutingError as exc:
|
|
await websocket.send_json({"type": "error", "status": 422, "detail": str(exc)})
|
|
continue
|
|
|
|
llm_context = list(conversation)
|
|
if memories:
|
|
memory_text = "Was du ueber den Nutzer weisst:\n" + "\n".join(
|
|
f"- {m.content}" for m in memories
|
|
)
|
|
llm_context = [{"role": "system", "content": memory_text}] + llm_context
|
|
|
|
await websocket.send_json({"type": "ack", "route": route.as_dict()})
|
|
|
|
voice = msg.get("voice") or settings.openrouter_tts_voice
|
|
stream = bool(msg.get("stream"))
|
|
try:
|
|
if stream:
|
|
async def on_token(delta):
|
|
await websocket.send_json({"type": "token", "text": delta})
|
|
|
|
trace, audio = await orchestrator.chat_stream(
|
|
text,
|
|
language=route.language,
|
|
voice=voice,
|
|
output=output,
|
|
history=llm_context,
|
|
on_token=on_token,
|
|
)
|
|
else:
|
|
trace, audio = await orchestrator.chat_text(
|
|
text,
|
|
language=route.language,
|
|
voice=voice,
|
|
output=output,
|
|
history=llm_context,
|
|
)
|
|
except Exception as exc:
|
|
await websocket.send_json({"type": "error", "status": 502, "detail": str(exc)})
|
|
continue
|
|
|
|
if session_id:
|
|
store.append_message(session_id, user.id, "user", text)
|
|
store.append_message(session_id, user.id, "assistant", trace.semantic_response)
|
|
|
|
await websocket.send_json(
|
|
{
|
|
"type": "semantic",
|
|
"text": trace.semantic_response,
|
|
"spoken": trace.spoken_response,
|
|
}
|
|
)
|
|
await websocket.send_bytes(audio)
|
|
await websocket.send_json(
|
|
{"type": "done", "audio_format": "pcm", "sample_rate": 24000}
|
|
)
|
|
except WebSocketDisconnect:
|
|
return
|