feat(dialog): /api/generate/dialog endpoint + per-turn dispatcher with seed reuse

server/dialog.py

@@ -38,3 +38,90 @@ def parse_dialog(text: str) -> list[DialogTurn]:
     if not turns:
         raise DialogParseError("No non-empty speaker turns found.")
     return turns
+
+
+import io as _io
+import tempfile as _tempfile
+from typing import Optional
+
+import numpy as _np
+import soundfile as _sf
+
+from server.audio import AudioValidationError, validate_reference_clip, write_wav_bytes
+from server.registry import Registry
+from server.seed import apply_seed
+
+
+SILENCE_GAP_MS = 250
+
+
+class DialogReferenceError(ValueError):
+    """Raised when a turn references a speaker without an uploaded clip."""
+
+
+def _decode_wav_to_mono_float(wav_bytes: bytes) -> tuple[_np.ndarray, int]:
+    arr, sr = _sf.read(_io.BytesIO(wav_bytes), dtype="float32", always_2d=False)
+    if arr.ndim == 2:
+        arr = arr.mean(axis=1)
+    return arr.astype(_np.float32), int(sr)
+
+
+def _save_temp_wav(data: bytes) -> str:
+    tmp = _tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+    tmp.write(data)
+    tmp.flush()
+    tmp.close()
+    return tmp.name
+
+
+async def generate_dialog(
+    *,
+    registry: Registry,
+    engine_id: str,
+    text: str,
+    language: Optional[str],
+    params: dict,
+    speaker_clips: dict[str, bytes],   # letter -> raw upload bytes (already validated)
+    silence_ms: int = SILENCE_GAP_MS,
+) -> tuple[bytes, int, int]:
+    turns = parse_dialog(text)
+
+    # Verify every referenced speaker has a clip.
+    referenced = {t.speaker for t in turns}
+    missing = referenced - set(speaker_clips.keys())
+    if missing:
+        raise DialogReferenceError(
+            f"missing reference for speaker {sorted(missing)[0]}"
+        )
+
+    # Persist each clip to a tempfile path once (the adapter expects a path).
+    paths: dict[str, str] = {
+        letter: _save_temp_wav(blob) for letter, blob in speaker_clips.items()
+    }
+
+    adapter = await registry.get_or_load(engine_id)
+
+    # Resolve and re-apply one seed for the whole dialog.
+    seed_used = apply_seed(params.get("seed"))
+    params_for_call = {**params, "seed": seed_used}
+
+    sr_out: int | None = None
+    adapter_seed_used: int = seed_used
+    chunks: list[_np.ndarray] = []
+    for turn in turns:
+        # Re-apply the same seed before each turn so the run is reproducible.
+        apply_seed(seed_used)
+        wav_bytes, sr, adapter_seed_used = adapter.generate(
+            turn.text, paths[turn.speaker], language, params_for_call,
+        )
+        arr, _ = _decode_wav_to_mono_float(wav_bytes)
+        chunks.append(arr)
+        if sr_out is None:
+            sr_out = sr
+        if silence_ms > 0:
+            chunks.append(_np.zeros(int(silence_ms * sr / 1000), dtype=_np.float32))
+
+    assert sr_out is not None
+    full = _np.concatenate(chunks) if chunks else _np.zeros(0, dtype=_np.float32)
+    out = write_wav_bytes(full, sr_out)
+    return out, sr_out, adapter_seed_used

server/main.py

@@ -16,6 +16,11 @@ from sse_starlette.sse import EventSourceResponse
 
 from server.audio import AudioValidationError, validate_reference_clip
 from server.device import select_device
+from server.dialog import (
+    DialogParseError,
+    DialogReferenceError,
+    generate_dialog,
+)
 from server.registry import Registry
 from server.zerogpu import decorate
 
@@ -165,6 +170,86 @@ def build_app() -> FastAPI:
             headers={"X-Seed-Used": str(seed_used), "Access-Control-Expose-Headers": "X-Seed-Used"},
         )
 
+    @app.post("/api/generate/dialog")
+    async def generate_dialog_route(
+        text: str = Form(...),
+        engine_id: str = Form(...),
+        params: str = Form("{}"),
+        language: str | None = Form(None),
+        reference_wav_a: UploadFile | None = File(None),
+        reference_wav_b: UploadFile | None = File(None),
+        reference_wav_c: UploadFile | None = File(None),
+        reference_wav_d: UploadFile | None = File(None),
+    ):
+        speaker_clips: dict[str, bytes] = {}
+        upload_map = {
+            "A": reference_wav_a,
+            "B": reference_wav_b,
+            "C": reference_wav_c,
+            "D": reference_wav_d,
+        }
+        for letter, upload in upload_map.items():
+            if upload is None:
+                continue
+            data = await upload.read()
+            try:
+                validate_reference_clip(data)
+            except AudioValidationError as exc:
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "error": {
+                            "code": "reference_invalid",
+                            "message": f"speaker {letter}: {exc}",
+                        }
+                    },
+                )
+            speaker_clips[letter] = data
+
+        try:
+            wav_bytes, _sr, seed_used = await generate_dialog(
+                registry=app.state.registry,
+                engine_id=engine_id,
+                text=text,
+                language=language,
+                params=json.loads(params or "{}"),
+                speaker_clips=speaker_clips,
+            )
+        except KeyError:
+            raise HTTPException(
+                status_code=404,
+                detail={"error": {"code": "model_not_found", "message": engine_id}},
+            )
+        except DialogParseError as exc:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "error": {"code": "dialog_format_invalid", "message": str(exc)}
+                },
+            )
+        except DialogReferenceError as exc:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "error": {"code": "dialog_missing_reference", "message": str(exc)}
+                },
+            )
+        except Exception as exc:
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "error": {"code": "generation_failed", "message": str(exc)}
+                },
+            )
+        return Response(
+            content=wav_bytes,
+            media_type="audio/wav",
+            headers={
+                "X-Seed-Used": str(seed_used),
+                "Access-Control-Expose-Headers": "X-Seed-Used",
+            },
+        )
+
     @app.exception_handler(HTTPException)
     async def _http_exc(request, exc: HTTPException):
         if isinstance(exc.detail, dict) and "error" in exc.detail:

tests/test_dialog_endpoint.py

@@ -0,0 +1,113 @@
+import io
+
+import httpx
+import numpy as np
+import pytest
+import soundfile as sf
+
+from server.main import build_app
+
+
+pytestmark = pytest.mark.asyncio
+
+
+def _silent_wav(seconds: float = 1.0, sr: int = 24000) -> bytes:
+    samples = np.zeros(int(seconds * sr), dtype=np.float32)
+    buf = io.BytesIO()
+    sf.write(buf, samples, sr, format="WAV", subtype="PCM_16")
+    return buf.getvalue()
+
+
+async def test_dialog_generates_concatenated_wav(monkeypatch, fake_classes):
+    monkeypatch.setattr("server.main._discover_adapter_classes", lambda: fake_classes)
+    monkeypatch.setattr("server.main.select_device", lambda: "cpu")
+    # Have FakeAdapter emit a real silent WAV so the dialog generator can decode it.
+    monkeypatch.setattr(
+        fake_classes["fake"],
+        "generate",
+        lambda self, text, ref, lang, p: (_silent_wav(0.2), 24000, 0),
+    )
+    app = build_app()
+    from tests.conftest import lifespan_ctx
+    transport = httpx.ASGITransport(app=app)
+    async with lifespan_ctx(app), httpx.AsyncClient(transport=transport, base_url="http://t") as c:
+        files = {
+            "reference_wav_a": ("a.wav", _silent_wav(1.0), "audio/wav"),
+            "reference_wav_b": ("b.wav", _silent_wav(1.0), "audio/wav"),
+        }
+        r = await c.post(
+            "/api/generate/dialog",
+            data={
+                "text": "SPEAKER A: hi\nSPEAKER B: hello",
+                "engine_id": "fake",
+                "params": "{}",
+            },
+            files=files,
+        )
+    assert r.status_code == 200
+    assert r.headers["content-type"].startswith("audio/wav")
+    assert r.content[:4] == b"RIFF"
+    assert r.headers["x-seed-used"] == "0"
+
+
+async def test_dialog_format_invalid(monkeypatch, fake_classes):
+    monkeypatch.setattr("server.main._discover_adapter_classes", lambda: fake_classes)
+    monkeypatch.setattr("server.main.select_device", lambda: "cpu")
+    app = build_app()
+    from tests.conftest import lifespan_ctx
+    transport = httpx.ASGITransport(app=app)
+    async with lifespan_ctx(app), httpx.AsyncClient(transport=transport, base_url="http://t") as c:
+        r = await c.post(
+            "/api/generate/dialog",
+            data={"text": "no speaker tags", "engine_id": "fake", "params": "{}"},
+            files={
+                "reference_wav_a": ("a.wav", _silent_wav(1.0), "audio/wav"),
+            },
+        )
+    assert r.status_code == 400
+    assert r.json()["error"]["code"] == "dialog_format_invalid"
+
+
+async def test_dialog_missing_reference(monkeypatch, fake_classes):
+    monkeypatch.setattr("server.main._discover_adapter_classes", lambda: fake_classes)
+    monkeypatch.setattr("server.main.select_device", lambda: "cpu")
+    monkeypatch.setattr(
+        fake_classes["fake"],
+        "generate",
+        lambda self, text, ref, lang, p: (_silent_wav(0.2), 24000, 0),
+    )
+    app = build_app()
+    from tests.conftest import lifespan_ctx
+    transport = httpx.ASGITransport(app=app)
+    async with lifespan_ctx(app), httpx.AsyncClient(transport=transport, base_url="http://t") as c:
+        r = await c.post(
+            "/api/generate/dialog",
+            data={
+                "text": "SPEAKER A: hi\nSPEAKER B: hello",
+                "engine_id": "fake",
+                "params": "{}",
+            },
+            files={"reference_wav_a": ("a.wav", _silent_wav(1.0), "audio/wav")},
+        )
+    assert r.status_code == 400
+    assert r.json()["error"]["code"] == "dialog_missing_reference"
+
+
+async def test_dialog_unknown_engine_404(monkeypatch, fake_classes):
+    monkeypatch.setattr("server.main._discover_adapter_classes", lambda: fake_classes)
+    monkeypatch.setattr("server.main.select_device", lambda: "cpu")
+    app = build_app()
+    from tests.conftest import lifespan_ctx
+    transport = httpx.ASGITransport(app=app)
+    async with lifespan_ctx(app), httpx.AsyncClient(transport=transport, base_url="http://t") as c:
+        r = await c.post(
+            "/api/generate/dialog",
+            data={
+                "text": "SPEAKER A: hi",
+                "engine_id": "nope",
+                "params": "{}",
+            },
+            files={"reference_wav_a": ("a.wav", _silent_wav(1.0), "audio/wav")},
+        )
+    assert r.status_code == 404
+    assert r.json()["error"]["code"] == "model_not_found"