openvoiceui 1.0.0

package/tts_providers/qwen3_provider.py

@@ -0,0 +1,371 @@
+"""
+Qwen3-TTS Provider — fal.ai hosted Qwen3-TTS models.
+
+Supports:
+  - Named speaker TTS (0.6B and 1.7B)
+  - Voice cloning from audio samples via clone-voice endpoint
+  - Emotion/style control via prompt (1.7B)
+  - Cloned voice embeddings stored locally for reuse
+
+API key: FAL_KEY env var
+"""
+
+import json
+import os
+import time
+import logging
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from .base_provider import TTSProvider
+
+logger = logging.getLogger(__name__)
+
+# fal.ai endpoints
+FAL_TTS_1_7B = "https://fal.run/fal-ai/qwen-3-tts/text-to-speech/1.7b"
+FAL_TTS_0_6B = "https://fal.run/fal-ai/qwen-3-tts/text-to-speech/0.6b"
+FAL_CLONE_1_7B = "https://fal.run/fal-ai/qwen-3-tts/clone-voice/1.7b"
+FAL_CLONE_0_6B = "https://fal.run/fal-ai/qwen-3-tts/clone-voice/0.6b"
+
+BUILTIN_VOICES = [
+    "Vivian",    # Female, warm
+    "Serena",    # Female, clear
+    "Dylan",     # Male, casual
+    "Eric",      # Male, professional
+    "Ryan",      # Male, energetic
+    "Aiden",     # Male, deep
+    "Uncle_Fu",  # Male, character
+    "Ono_Anna",  # Female, Japanese accent
+    "Sohee",     # Female, Korean accent
+]
+
+
+def _get_clones_dir() -> Path:
+    """Resolve voice clones directory from paths module or fallback."""
+    try:
+        from services.paths import VOICE_CLONES_DIR
+        return VOICE_CLONES_DIR
+    except ImportError:
+        return Path(os.getenv("VOICE_CLONES_DIR", "./runtime/voice-clones"))
+
+
+def _fal_request(api_key: str, endpoint: str, payload: dict,
+                 timeout: float = 90.0) -> dict:
+    """Make a JSON request to fal.ai and return the parsed response."""
+    headers = {
+        'Authorization': f'Key {api_key}',
+        'Content-Type': 'application/json',
+    }
+    with httpx.Client(timeout=httpx.Timeout(timeout, connect=10.0)) as client:
+        resp = client.post(endpoint, json=payload, headers=headers)
+        resp.raise_for_status()
+        return resp.json()
+
+
+def _fal_download(url: str, timeout: float = 30.0) -> bytes:
+    """Download binary content from a fal.ai result URL."""
+    with httpx.Client(timeout=httpx.Timeout(timeout)) as client:
+        resp = client.get(url)
+        resp.raise_for_status()
+        return resp.content
+
+
+class Qwen3Provider(TTSProvider):
+    """
+    TTS Provider using Qwen3-TTS via fal.ai.
+
+    Built-in voices: Vivian, Serena, Dylan, Eric, Ryan, Aiden, Uncle_Fu, Ono_Anna, Sohee
+    Cloned voices: stored locally as .safetensors embeddings, referenced by voice_id
+    Output: MP3 audio bytes
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.api_key = os.getenv('FAL_KEY', '')
+        self._status = 'active' if self.api_key else 'error'
+        self._init_error = None if self.api_key else 'FAL_KEY not set in environment'
+
+    # ------------------------------------------------------------------
+    # Voice cloning
+    # ------------------------------------------------------------------
+
+    def clone_voice(self, audio_url: str, name: str,
+                    reference_text: Optional[str] = None) -> dict:
+        """
+        Clone a voice from a reference audio sample.
+
+        Args:
+            audio_url: Public URL to reference audio (WAV/MP3, 3+ seconds).
+            name: Human-readable name for this cloned voice.
+            reference_text: Optional transcript of what's said in the audio
+                            (improves quality).
+
+        Returns:
+            dict with: voice_id, name, embedding_url, created_at, metadata
+        """
+        if not self.api_key:
+            raise RuntimeError("FAL_KEY not set — cannot clone voice")
+
+        t = time.time()
+        logger.info(f"[Qwen3] Cloning voice '{name}' from {audio_url[:80]}")
+
+        payload = {"audio_url": audio_url}
+        if reference_text:
+            payload["reference_text"] = reference_text
+
+        try:
+            result = _fal_request(self.api_key, FAL_CLONE_1_7B, payload,
+                                  timeout=120.0)
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(
+                f"fal.ai clone error {e.response.status_code}: {e.response.text}"
+            )
+
+        # Extract embedding URL from response
+        embedding_url = result.get('speaker_embedding', {}).get('url')
+        if not embedding_url:
+            # Try alternate response shapes
+            embedding_url = result.get('audio', {}).get('url')
+        if not embedding_url:
+            raise RuntimeError(f"No embedding URL in fal.ai response: {result}")
+
+        elapsed_ms = int((time.time() - t) * 1000)
+
+        # Download and persist the embedding locally
+        embedding_bytes = _fal_download(embedding_url)
+
+        clones_dir = _get_clones_dir()
+        # voice_id = sanitized name
+        voice_id = "clone_" + "".join(
+            c for c in name.lower().replace(" ", "_")
+            if c.isalnum() or c == "_"
+        )[:40]
+        voice_dir = clones_dir / voice_id
+        voice_dir.mkdir(parents=True, exist_ok=True)
+
+        embedding_path = voice_dir / "embedding.safetensors"
+        with open(embedding_path, 'wb') as f:
+            f.write(embedding_bytes)
+
+        metadata = {
+            "voice_id": voice_id,
+            "name": name,
+            "embedding_url": embedding_url,
+            "embedding_size": len(embedding_bytes),
+            "reference_text": reference_text,
+            "source_audio_url": audio_url,
+            "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "clone_time_ms": elapsed_ms,
+            "provider": "qwen3",
+            "fal_response": result,
+        }
+        with open(voice_dir / "metadata.json", 'w') as f:
+            json.dump(metadata, f, indent=2)
+
+        logger.info(
+            f"[Qwen3] Voice cloned: {voice_id} ({len(embedding_bytes)} bytes) "
+            f"in {elapsed_ms}ms"
+        )
+        return metadata
+
+    def list_cloned_voices(self) -> list:
+        """List all locally stored cloned voice embeddings."""
+        clones_dir = _get_clones_dir()
+        voices = []
+        if not clones_dir.exists():
+            return voices
+        for voice_dir in sorted(clones_dir.iterdir()):
+            meta_path = voice_dir / "metadata.json"
+            if meta_path.exists():
+                try:
+                    with open(meta_path) as f:
+                        meta = json.load(f)
+                    meta["has_embedding"] = (voice_dir / "embedding.safetensors").exists()
+                    voices.append(meta)
+                except Exception as e:
+                    logger.warning(f"Bad voice metadata in {voice_dir}: {e}")
+        return voices
+
+    def get_clone_embedding_url(self, voice_id: str) -> Optional[str]:
+        """Get the fal.ai embedding URL for a cloned voice.
+
+        Returns the cached remote URL from metadata. The embedding is also
+        stored locally as a fallback, but fal.ai needs the URL for generation.
+        """
+        clones_dir = _get_clones_dir()
+        meta_path = clones_dir / voice_id / "metadata.json"
+        if not meta_path.exists():
+            return None
+        try:
+            with open(meta_path) as f:
+                meta = json.load(f)
+            return meta.get("embedding_url")
+        except Exception:
+            return None
+
+    # ------------------------------------------------------------------
+    # Speech generation
+    # ------------------------------------------------------------------
+
+    def generate_speech(self, text: str, voice: str = 'Vivian', **kwargs) -> bytes:
+        """
+        Generate speech via fal.ai Qwen3-TTS.
+
+        Args:
+            text: Text to synthesize.
+            voice: Built-in voice name OR cloned voice_id (clone_xxx).
+            **kwargs:
+                language: Language name (default 'English').
+                prompt: Style/emotion instruction for 1.7B model.
+                speaker_embedding_url: Direct embedding URL override.
+                reference_text: Reference text for cloned voice quality.
+                model: '0.6b' or '1.7b' (default '1.7b').
+
+        Returns:
+            MP3 audio bytes.
+        """
+        if not self.api_key:
+            raise RuntimeError("FAL_KEY not set — cannot call fal.ai API")
+
+        self.validate_text(text)
+
+        language = kwargs.get('language', 'English')
+        prompt = kwargs.get('prompt', '')
+        embedding_url = kwargs.get('speaker_embedding_url')
+        reference_text = kwargs.get('reference_text', '')
+        model = kwargs.get('model', '1.7b')
+
+        endpoint = FAL_TTS_1_7B if model == '1.7b' else FAL_TTS_0_6B
+
+        # Resolve cloned voice → embedding URL
+        is_cloned = voice.startswith("clone_") if voice else False
+        if is_cloned and not embedding_url:
+            embedding_url = self.get_clone_embedding_url(voice)
+            if not embedding_url:
+                raise RuntimeError(
+                    f"Cloned voice '{voice}' not found or missing embedding"
+                )
+            # Load reference_text from metadata if not provided
+            if not reference_text:
+                clones_dir = _get_clones_dir()
+                meta_path = clones_dir / voice / "metadata.json"
+                if meta_path.exists():
+                    try:
+                        with open(meta_path) as f:
+                            meta = json.load(f)
+                        reference_text = meta.get("reference_text", "")
+                    except Exception:
+                        pass
+
+        payload = {
+            "text": text,
+            "language": language,
+        }
+
+        if embedding_url:
+            # Cloned voice — use embedding, skip built-in voice
+            payload["speaker_voice_embedding_file_url"] = embedding_url
+            if reference_text:
+                payload["reference_text"] = reference_text
+            if prompt:
+                payload["prompt"] = prompt
+        else:
+            # Built-in voice
+            if voice not in BUILTIN_VOICES:
+                logger.warning(f"Unknown voice '{voice}', falling back to Vivian")
+                voice = 'Vivian'
+            payload["voice"] = voice
+            if prompt:
+                payload["prompt"] = prompt
+
+        t = time.time()
+        voice_label = voice if not is_cloned else f"{voice} (cloned)"
+        logger.info(f"[Qwen3] TTS: '{text[:60]}...' voice={voice_label}")
+
+        try:
+            result = _fal_request(self.api_key, endpoint, payload)
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(
+                f"fal.ai API error {e.response.status_code}: {e.response.text}"
+            )
+        except Exception as e:
+            raise RuntimeError(f"fal.ai request failed: {e}")
+
+        audio_url = result.get('audio', {}).get('url')
+        if not audio_url:
+            raise RuntimeError(f"No audio URL in fal.ai response: {result}")
+
+        audio_bytes = _fal_download(audio_url)
+
+        elapsed = int((time.time() - t) * 1000)
+        logger.info(f"[Qwen3] Generated {len(audio_bytes)} bytes in {elapsed}ms")
+        return audio_bytes
+
+    # ------------------------------------------------------------------
+    # Provider interface
+    # ------------------------------------------------------------------
+
+    def health_check(self) -> dict:
+        if not self.api_key:
+            return {"ok": False, "latency_ms": 0, "detail": "FAL_KEY not set"}
+        t = time.time()
+        try:
+            with httpx.Client(timeout=httpx.Timeout(8.0)) as client:
+                resp = client.get(
+                    "https://fal.run/",
+                    headers={"Authorization": f"Key {self.api_key}"},
+                )
+            latency_ms = int((time.time() - t) * 1000)
+            return {
+                "ok": True, "latency_ms": latency_ms,
+                "detail": "fal.ai reachable — Qwen3-TTS ready",
+            }
+        except Exception as e:
+            latency_ms = int((time.time() - t) * 1000)
+            return {"ok": False, "latency_ms": latency_ms, "detail": str(e)}
+
+    def list_voices(self) -> list:
+        voices = BUILTIN_VOICES.copy()
+        for clone in self.list_cloned_voices():
+            voices.append(clone["voice_id"])
+        return voices
+
+    def get_default_voice(self) -> str:
+        return 'Vivian'
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def get_info(self) -> dict:
+        cloned = self.list_cloned_voices()
+        return {
+            'name': 'Qwen3-TTS (fal.ai)',
+            'provider_id': 'qwen3',
+            'status': self._status,
+            'description': (
+                'Qwen3-TTS via fal.ai — expressive, multilingual, '
+                'voice cloning, emotion control'
+            ),
+            'quality': 'very-high',
+            'latency': 'fast',
+            'cost_per_minute': 0.003,
+            'voices': BUILTIN_VOICES.copy(),
+            'cloned_voices': [
+                {"voice_id": c["voice_id"], "name": c["name"]}
+                for c in cloned
+            ],
+            'features': [
+                'multilingual', 'expressive', 'voice-cloning',
+                'emotion-control', 'cloud', 'mp3-output',
+            ],
+            'requires_api_key': True,
+            'languages': ['en', 'zh', 'es', 'fr', 'de', 'it', 'ja', 'ko', 'pt', 'ru'],
+            'max_characters': 5000,
+            'notes': 'Qwen3-TTS 1.7B + 0.6B. Voice cloning via clone-voice endpoint. FAL_KEY required.',
+            'default_voice': 'Vivian',
+            'audio_format': 'mp3',
+            'sample_rate': 24000,
+            'error': self._init_error,
+        }

package/tts_providers/resemble_provider.py

@@ -0,0 +1,315 @@
+"""
+Resemble AI TTS Provider — Chatterbox models via Resemble API.
+
+Supports:
+  - HTTP streaming TTS (chunked WAV, progressive playback)
+  - Multiple models: chatterbox (original), chatterbox-turbo, chatterbox-multilingual
+  - Voice cloning via Resemble dashboard (voice_uuid per clone)
+  - SSML support (prosody, emphasis, breaks, prompts)
+  - Emotion/exaggeration control
+  - 90+ languages (multilingual model)
+  - 8-48kHz sample rate, PCM_16/24/32/MULAW
+
+API key: RESEMBLE_API_KEY env var
+Synthesis server: https://f.cluster.resemble.ai
+API server: https://app.resemble.ai/api/v2
+"""
+
+import os
+import io
+import time
+import logging
+import threading
+
+import httpx
+
+from .base_provider import TTSProvider
+
+logger = logging.getLogger(__name__)
+
+# Resemble API endpoints
+SYNTHESIS_URL = "https://f.cluster.resemble.ai/stream"
+API_BASE_URL = "https://app.resemble.ai/api/v2"
+
+# Models available via Resemble API
+MODELS = {
+    "chatterbox": "Default Chatterbox — emotion exaggeration + CFG control",
+    "chatterbox-turbo": "Chatterbox Turbo — lowest latency, paralinguistic tags",
+    "chatterbox-multilingual": "Chatterbox Multilingual — 23+ languages",
+}
+
+DEFAULT_MODEL = "chatterbox-turbo"
+
+# Timeouts
+STREAM_TIMEOUT = 30.0    # Max wait for full streaming response
+CONNECT_TIMEOUT = 10.0   # TCP connect timeout
+API_TIMEOUT = 15.0       # For voice listing / non-synthesis calls
+
+# Module-level voice cache — shared across all ResembleProvider instances.
+# list_providers() creates new instances each call, so instance-level cache
+# is lost. This persists across the process lifetime.
+_voices_cache_global = None
+_voices_cache_time_global = 0
+_voices_loading_global = False
+
+
+class ResembleProvider(TTSProvider):
+    """
+    TTS Provider using Resemble AI's Chatterbox API.
+
+    Uses HTTP streaming endpoint for progressive audio delivery.
+    Voices are managed via Resemble dashboard — each voice has a UUID.
+
+    Output: WAV audio bytes (PCM_16, configurable sample rate)
+    Latency: sub-200ms time-to-first-byte (streaming)
+    Cost: pay-as-you-go, character-based
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.api_key = os.getenv('RESEMBLE_API_KEY', '')
+        self._status = 'active' if self.api_key else 'error'
+        self._init_error = None if self.api_key else 'RESEMBLE_API_KEY not set'
+
+        # Warm the global voice cache in background on first instantiation
+        global _voices_loading_global
+        if self.api_key and not _voices_cache_global and not _voices_loading_global:
+            _voices_loading_global = True
+            t = threading.Thread(target=self._fetch_voices_from_api, daemon=True)
+            t.start()
+
+    def _auth_headers(self):
+        return {
+            'Authorization': f'Bearer {self.api_key}',
+            'Content-Type': 'application/json',
+        }
+
+    # ------------------------------------------------------------------
+    # Voice listing (cached from Resemble API)
+    # ------------------------------------------------------------------
+
+    def _fetch_voices_from_api(self) -> list:
+        """Fetch available voices from Resemble API. Cached globally for 5 minutes."""
+        global _voices_cache_global, _voices_cache_time_global, _voices_loading_global
+        now = time.time()
+        if _voices_cache_global and (now - _voices_cache_time_global) < 300:
+            return _voices_cache_global
+
+        try:
+            voices = []
+            page = 1
+            with httpx.Client(timeout=httpx.Timeout(API_TIMEOUT)) as client:
+                while True:
+                    resp = client.get(
+                        f"{API_BASE_URL}/voices",
+                        params={"page": page, "page_size": 50},
+                        headers=self._auth_headers(),
+                    )
+                    resp.raise_for_status()
+                    data = resp.json()
+
+                    for v in data.get('items', []):
+                        if v.get('voice_status') == 'Ready':
+                            voices.append({
+                                'id': v.get('uuid', ''),
+                                'name': v.get('name', 'Unknown'),
+                                'language': v.get('default_language', 'en'),
+                                'streaming': v.get('api_support', {}).get('streaming', False),
+                            })
+
+                    if page >= data.get('num_pages', 1):
+                        break
+                    page += 1
+
+            _voices_cache_global = voices
+            _voices_cache_time_global = now
+            _voices_loading_global = False
+            logger.info(f"[Resemble] Fetched {len(voices)} voices from API")
+            return voices
+
+        except Exception as e:
+            _voices_loading_global = False
+            logger.warning(f"[Resemble] Failed to fetch voices: {e}")
+            return _voices_cache_global or []
+
+    # ------------------------------------------------------------------
+    # Speech generation (HTTP streaming)
+    # ------------------------------------------------------------------
+
+    def generate_speech(self, text: str, voice: str = '', **kwargs) -> bytes:
+        """
+        Generate speech via Resemble streaming API.
+
+        Args:
+            text: Text or SSML to synthesize (max 2000 chars).
+            voice: Resemble voice UUID. If empty, uses RESEMBLE_VOICE_UUID env var.
+            **kwargs:
+                model: 'chatterbox', 'chatterbox-turbo', or 'chatterbox-multilingual'
+                sample_rate: 8000-48000 (default 24000)
+                precision: 'PCM_16', 'PCM_24', 'PCM_32', 'MULAW' (default PCM_16)
+                exaggeration: 0.0-1.0 emotion intensity (via SSML prompt attr)
+
+        Returns:
+            WAV audio bytes.
+        """
+        if not self.api_key:
+            raise RuntimeError("RESEMBLE_API_KEY not set")
+
+        self.validate_text(text)
+
+        # Resolve voice — accept UUID or display name
+        voice_uuid = voice or os.getenv('RESEMBLE_VOICE_UUID', '')
+        if not voice_uuid:
+            raise RuntimeError(
+                "No voice_uuid provided and RESEMBLE_VOICE_UUID not set. "
+                "Create a voice at app.resemble.ai and set the UUID."
+            )
+
+        # If the voice looks like a name (not a short hex UUID), resolve it
+        if not all(c in '0123456789abcdef' for c in voice_uuid):
+            cache = _voices_cache_global or self._fetch_voices_from_api()
+            for v in cache:
+                if v['name'] == voice_uuid:
+                    logger.info(f"[Resemble] Resolved voice name '{voice_uuid}' → {v['id']}")
+                    voice_uuid = v['id']
+                    break
+            else:
+                logger.warning(f"[Resemble] Voice name '{voice_uuid}' not found in {len(cache)} voices")
+
+        model = kwargs.get('model', '')
+        sample_rate = kwargs.get('sample_rate', 24000)
+        precision = kwargs.get('precision', 'PCM_16')
+        exaggeration = kwargs.get('exaggeration')
+
+        # Wrap in SSML if exaggeration is set
+        if exaggeration is not None and not text.strip().startswith('<speak'):
+            text = f'<speak exaggeration="{exaggeration}">{text}</speak>'
+
+        payload = {
+            'voice_uuid': voice_uuid,
+            'data': text[:2000],  # API limit
+            'precision': precision,
+            'sample_rate': sample_rate,
+        }
+
+        # Only include model if explicitly requested — API defaults to
+        # the correct model for each voice. Forcing chatterbox-turbo on
+        # voices that don't support it returns 500.
+        if model:
+            payload['model'] = model
+
+        t = time.time()
+        logger.info(
+            f"[Resemble] TTS: '{text[:60]}...' model={model} "
+            f"voice={voice_uuid[:12]}..."
+        )
+
+        try:
+            with httpx.Client(
+                timeout=httpx.Timeout(STREAM_TIMEOUT, connect=CONNECT_TIMEOUT)
+            ) as client:
+                resp = client.post(
+                    SYNTHESIS_URL,
+                    json=payload,
+                    headers=self._auth_headers(),
+                )
+                resp.raise_for_status()
+                audio_bytes = resp.content
+
+        except httpx.HTTPStatusError as e:
+            status = e.response.status_code
+            body = e.response.text[:200]
+            raise RuntimeError(f"Resemble API error {status}: {body}")
+        except httpx.TimeoutException:
+            raise RuntimeError(
+                f"Resemble API timeout after {STREAM_TIMEOUT}s"
+            )
+        except Exception as e:
+            raise RuntimeError(f"Resemble request failed: {e}")
+
+        elapsed = int((time.time() - t) * 1000)
+        logger.info(f"[Resemble] Generated {len(audio_bytes)} bytes in {elapsed}ms")
+
+        if len(audio_bytes) < 100:
+            raise RuntimeError(
+                f"Resemble returned suspiciously small response ({len(audio_bytes)} bytes)"
+            )
+
+        return audio_bytes
+
+    # ------------------------------------------------------------------
+    # Provider interface
+    # ------------------------------------------------------------------
+
+    def health_check(self) -> dict:
+        if not self.api_key:
+            return {"ok": False, "latency_ms": 0, "detail": "RESEMBLE_API_KEY not set"}
+        t = time.time()
+        try:
+            with httpx.Client(timeout=httpx.Timeout(API_TIMEOUT)) as client:
+                resp = client.get(
+                    f"{API_BASE_URL}/voices",
+                    params={"page": 1, "page_size": 1},
+                    headers=self._auth_headers(),
+                )
+                resp.raise_for_status()
+            latency_ms = int((time.time() - t) * 1000)
+            return {
+                "ok": True, "latency_ms": latency_ms,
+                "detail": "Resemble API reachable — Chatterbox ready",
+            }
+        except Exception as e:
+            latency_ms = int((time.time() - t) * 1000)
+            return {"ok": False, "latency_ms": latency_ms, "detail": str(e)}
+
+    def list_voices(self) -> list:
+        voices = _voices_cache_global or self._fetch_voices_from_api()
+        return [v['id'] for v in voices] if voices else []
+
+    def get_default_voice(self) -> str:
+        return os.getenv('RESEMBLE_VOICE_UUID', '')
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def get_info(self) -> dict:
+        # Use global cache — populated by background thread on first init.
+        # Never fetch synchronously here; that blocks the settings panel.
+        cached_names = [v['name'] for v in _voices_cache_global] if _voices_cache_global else []
+        return {
+            'name': 'Resemble AI (Chatterbox)',
+            'provider_id': 'resemble',
+            'status': self._status,
+            'description': (
+                'Resemble AI Chatterbox — streaming TTS, voice cloning, '
+                'emotion control, SSML, 90+ languages'
+            ),
+            'quality': 'very-high',
+            'latency': 'very-fast',
+            'cost_per_minute': 0.10,
+            'voices': cached_names,
+            'features': [
+                'streaming', 'voice-cloning', 'emotion-control',
+                'ssml', 'multilingual', 'cloud', 'wav-output',
+                'paralinguistic-tags',
+            ],
+            'requires_api_key': True,
+            'languages': [
+                'en', 'es', 'fr', 'de', 'it', 'pt', 'ja', 'ko', 'zh',
+                'ar', 'ru', 'hi', 'nl', 'pl', 'sv', 'da', 'fi', 'el',
+                'cs', 'hu', 'ro', 'tr', 'uk', 'vi', 'th', 'id',
+            ],
+            'max_characters': 2000,
+            'notes': (
+                'Streaming HTTP TTS via f.cluster.resemble.ai. '
+                'Models: chatterbox-turbo (fastest), chatterbox (emotion), '
+                'chatterbox-multilingual (23 langs). '
+                'Voice cloning via Resemble dashboard. '
+                'RESEMBLE_API_KEY + RESEMBLE_VOICE_UUID required.'
+            ),
+            'default_voice': os.getenv('RESEMBLE_VOICE_UUID', ''),
+            'audio_format': 'wav',
+            'sample_rate': 24000,
+            'models': list(MODELS.keys()),
+            'error': self._init_error,
+        }