fix: use correct Qwen3-TTS model methods

- Load both CustomVoice and Base models
- Use generate_custom_voice() for basic TTS with preset speakers
- Use generate_voice_clone() for voice cloning with ref_audio/ref_text
- Add /v1/speakers endpoint to list available preset speakers
- Add speaker parameter to /v1/audio/speech endpoint
- Fix audio loading to properly read sample rate from reference files

The Base model only supports generate_voice_clone(), not a generic
generate() method. For basic TTS, we need the CustomVoice model.

Author: willgriffin

server.py

@@ -8,7 +8,7 @@
 import io
 import os
 from abc import ABC, abstractmethod
-from typing import Optional, Tuple
+from typing import Optional, Tuple, List
 from contextlib import asynccontextmanager
 
 import torch
@@ -34,6 +34,7 @@ def synthesize(
         self,
         text: str,
         language: str = "English",
+        speaker: Optional[str] = None,
         ref_audio: Optional[Tuple[bytes, int]] = None,
         ref_text: Optional[str] = None,
         speed: float = 1.0,
@@ -44,6 +45,7 @@ def synthesize(
         Args:
             text: Text to synthesize
             language: Target language
+            speaker: Preset speaker name (for basic TTS)
             ref_audio: Optional (audio_bytes, sample_rate) for voice cloning
             ref_text: Optional transcript of reference audio for voice cloning
             speed: Speech speed multiplier
@@ -58,56 +60,79 @@ def get_info(self) -> dict:
         """Return model information."""
         pass
 
+    @abstractmethod
+    def get_speakers(self) -> List[str]:
+        """Return available preset speakers."""
+        pass
+
 
 class Qwen3TTSBackend(TTSBackend):
-    """Qwen3-TTS backend with voice cloning support."""
+    """
+    Qwen3-TTS backend with voice cloning support.
+
+    Uses CustomVoice model for basic TTS and Base model for voice cloning.
+    """
 
-    def __init__(self, model_name: str = "Qwen/Qwen3-TTS-12Hz-1.7B-Base"):
-        self.model_name = model_name
-        self.model = None
+    def __init__(
+        self,
+        custom_voice_model: str = "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice",
+        base_model: str = "Qwen/Qwen3-TTS-12Hz-1.7B-Base",
+    ):
+        self.custom_voice_model_name = custom_voice_model
+        self.base_model_name = base_model
+        self.custom_voice_model = None
+        self.base_model = None
+        self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        self.dtype = torch.bfloat16 if torch.cuda.is_available() else torch.float32
 
     def load(self) -> None:
         from qwen_tts import Qwen3TTSModel
 
-        print(f"Loading Qwen3-TTS model: {self.model_name}")
-        self.model = Qwen3TTSModel.from_pretrained(
-            self.model_name,
-            device_map="cuda:0" if torch.cuda.is_available() else "cpu",
-            dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+        # Load CustomVoice model for basic TTS with preset speakers
+        print(f"Loading CustomVoice model: {self.custom_voice_model_name}")
+        self.custom_voice_model = Qwen3TTSModel.from_pretrained(
+            self.custom_voice_model_name,
+            device_map=self.device,
+            dtype=self.dtype,
+        )
+        print("CustomVoice model loaded")
+
+        # Load Base model for voice cloning
+        print(f"Loading Base model: {self.base_model_name}")
+        self.base_model = Qwen3TTSModel.from_pretrained(
+            self.base_model_name,
+            device_map=self.device,
+            dtype=self.dtype,
         )
-        print("Qwen3-TTS model loaded successfully")
+        print("Base model loaded")
 
     def synthesize(
         self,
         text: str,
         language: str = "English",
+        speaker: Optional[str] = None,
         ref_audio: Optional[Tuple[bytes, int]] = None,
         ref_text: Optional[str] = None,
         speed: float = 1.0,
     ) -> Tuple[bytes, int]:
-        if self.model is None:
-            raise RuntimeError("Model not loaded")
+        if self.custom_voice_model is None or self.base_model is None:
+            raise RuntimeError("Models not loaded")
 
-        if ref_audio and ref_text:
-            # Voice cloning with reference audio and text
-            wavs, sr = self.model.generate_voice_clone(
+        if ref_audio:
+            # Voice cloning path - use Base model
+            wavs, sr = self.base_model.generate_voice_clone(
                 text=text,
                 language=language,
                 ref_audio=ref_audio,
                 ref_text=ref_text,
             )
-        elif ref_audio:
-            # Voice cloning with just reference audio (model will auto-transcribe)
-            wavs, sr = self.model.generate_voice_clone(
-                text=text,
-                language=language,
-                ref_audio=ref_audio,
-            )
         else:
-            # Basic TTS without voice cloning
-            wavs, sr = self.model.generate(
+            # Basic TTS path - use CustomVoice model with preset speaker
+            speaker = speaker or "Vivian"
+            wavs, sr = self.custom_voice_model.generate_custom_voice(
                 text=text,
                 language=language,
+                speaker=speaker,
             )
 
         # Convert to WAV bytes
@@ -120,12 +145,23 @@ def synthesize(
     def get_info(self) -> dict:
         return {
             "backend": "qwen3-tts",
-            "model": self.model_name,
+            "custom_voice_model": self.custom_voice_model_name,
+            "base_model": self.base_model_name,
             "supports_voice_cloning": True,
             "supports_ref_text": True,
             "device": "cuda" if torch.cuda.is_available() else "cpu",
         }
 
+    def get_speakers(self) -> List[str]:
+        """Return available preset speakers from CustomVoice model."""
+        if self.custom_voice_model is None:
+            return []
+        try:
+            return self.custom_voice_model.get_supported_speakers()
+        except Exception:
+            # Fallback to known speakers
+            return ["Vivian", "Ryan", "Sophia", "Isabella", "Evan", "Lily"]
+
 
 # =============================================================================
 # Backend Registry
@@ -155,12 +191,7 @@ async def lifespan(app: FastAPI):
     global backend
 
     backend_name = os.environ.get("TTS_BACKEND", "qwen3-tts")
-    model_name = os.environ.get("TTS_MODEL", None)
-
     backend = get_backend(backend_name)
-    if model_name and hasattr(backend, 'model_name'):
-        backend.model_name = model_name
-
     backend.load()
 
     yield
@@ -172,7 +203,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(
     title="TTS Server",
     description="Multi-model text-to-speech API with voice cloning support",
-    version="0.1.0",
+    version="0.2.0",
     lifespan=lifespan,
 )
 
@@ -194,20 +225,30 @@ async def list_models():
     }
 
 
+@app.get("/v1/speakers")
+async def list_speakers():
+    """List available preset speakers for basic TTS."""
+    if backend is None:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    return {"speakers": backend.get_speakers()}
+
+
 @app.post("/v1/audio/speech")
 async def synthesize_speech(
     text: str = Form(..., description="Text to synthesize"),
     language: str = Form("English", description="Target language"),
+    speaker: Optional[str] = Form(None, description="Preset speaker for basic TTS (e.g., Vivian, Ryan)"),
     ref_audio: Optional[UploadFile] = File(None, description="Reference audio for voice cloning"),
     ref_text: Optional[str] = Form(None, description="Transcript of reference audio"),
     speed: float = Form(1.0, description="Speech speed multiplier"),
 ):
     """
     Synthesize speech from text.
 
-    For voice cloning, provide both ref_audio and ref_text.
-    The ref_text should be the exact transcript of the reference audio
-    for best voice cloning quality.
+    **Basic TTS:** Just provide `text` and optionally `speaker`.
+
+    **Voice Cloning:** Provide `ref_audio` and `ref_text` for best quality.
+    The `ref_text` should be the exact transcript of the reference audio.
     """
     if backend is None:
         raise HTTPException(status_code=503, detail="Model not loaded")
@@ -217,13 +258,16 @@ async def synthesize_speech(
         ref_audio_data = None
         if ref_audio:
             audio_bytes = await ref_audio.read()
-            # Assume 16kHz sample rate for reference audio, model will resample if needed
-            ref_audio_data = (audio_bytes, 16000)
+            # Load audio to get actual sample rate
+            audio_buffer = io.BytesIO(audio_bytes)
+            audio_data, sample_rate = sf.read(audio_buffer)
+            ref_audio_data = (audio_data, sample_rate)
 
         # Synthesize
         wav_bytes, sample_rate = backend.synthesize(
             text=text,
             language=language,
+            speaker=speaker,
             ref_audio=ref_audio_data,
             ref_text=ref_text,
             speed=speed,
@@ -242,13 +286,6 @@ async def synthesize_speech(
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.get("/docs", include_in_schema=False)
-async def docs_redirect():
-    """Redirect to Swagger UI."""
-    from fastapi.responses import RedirectResponse
-    return RedirectResponse(url="/docs")
-
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)